spring-boot
Federstiefel + Spring Data JPA

Einführung

Bemerkungen

Beispiel für die Integration von Spring Boot und Spring Data JPA

Wir werden eine Anwendung erstellen, die POJOs in einer Datenbank speichert. Die Anwendung verwendet Spring Data JPA zum Speichern und Abrufen von Daten in einer relationalen Datenbank. Die überzeugendste Funktion ist die Möglichkeit, Repository-Implementierungen automatisch zur Laufzeit über eine Repository-Schnittstelle zu erstellen.

Hauptklasse

package org.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

Die main() -Methode verwendet die SpringApplication.run() -Methode von Spring Boot, um eine Anwendung zu starten. Bitte beachten Sie, dass es keine einzige XML-Zeile gibt. Auch keine web.xml-Datei. Diese Webanwendung besteht zu 100% aus reinem Java und Sie müssen sich nicht mit der Konfiguration von Rohrleitungen oder Infrastrukturen beschäftigen.

Entity-Klasse

package org.springboot.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;

    public Greeting() {
        super();
    }

    public Greeting(String text) {
        super();
        this.text = text;
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

Hier haben Sie eine Greeting mit zwei Attributen, der id und dem text . Sie haben auch zwei Konstruktoren. Der Standardkonstruktor existiert nur aus Gründen der JPA. Sie werden es nicht direkt verwenden, daher kann es als protected . Der andere Konstruktor ist derjenige, mit dem Sie Greeting erstellen, die in der Datenbank gespeichert werden.

Die Greeting Klasse wird mit @Entity annotiert, um @Entity , dass es sich um eine JPA-Entität handelt. @Table keine @Table Annotation vorhanden ist, wird davon ausgegangen, dass diese Entität einer Tabelle mit dem Namen 'Greeting' zugeordnet wird.

Die id @Id Begrüßung wird mit @Id kommentiert, sodass JPA sie als ID des Objekts erkennt. Die id @GeneratedValue wird auch mit @GeneratedValue kommentiert, um @GeneratedValue , dass die ID automatisch generiert werden soll.

Die andere Eigenschaft, text wird nicht kommentiert. Es wird davon ausgegangen, dass es einer Spalte zugeordnet wird, die denselben Namen wie die Eigenschaft selbst hat.

Transiente Eigenschaften

In einer Entitätsklasse, die der obigen ähnelt, können wir Eigenschaften haben, die wir nicht in der Datenbank persistieren oder als Spalten in unserer Datenbank erstellen möchten, vielleicht weil wir sie nur zur Laufzeit setzen und in unserer Anwendung verwenden möchten. Daher können wir diese Eigenschaft mit der Annotation @Transient versehen.

package org.springboot.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Transient;

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;
    @Transient
    private String textInSomeLanguage;
    
    public Greeting() {
        super();
    }
 
    public Greeting(String text) {
        super();
        this.text = text;
        this.textInSomeLanguage = getTextTranslationInSpecifiedLanguage(text);
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

Hier haben Sie die gleiche Greeting-Klasse, die jetzt eine vorübergehende Eigenschaft textInSomeLanguage , die zur Laufzeit initialisiert und verwendet werden kann und nicht in der Datenbank gespeichert bleibt.

DAO-Klasse

package org.springboot.repository;

import org.springboot.model.Greeting;
import org.springframework.data.repository.CrudRepository;

public interface GreetingRepository extends CrudRepository<Greeting, Long> {

    List<Greeting> findByText(String text);
}

GreetingRepository erweitert die CrudRepository Schnittstelle. Die Art der Entität und die ID, mit der sie arbeitet, Greeting und Long , werden in den allgemeinen Parametern in CrudRepository . Durch die Erweiterung von CrudRepository erbt GreetingRepository verschiedene Methoden für die Arbeit mit der Beständigkeit der Greeting , einschließlich Methoden zum Speichern, Löschen und Suchen von Greeting .
Sehen Sie sich diese Diskussion zum Vergleich von CrudRepository , PagingAndSortingRepository und JpaRepository .

Mit Spring Data JPA können Sie auch andere Abfragemethoden definieren, indem Sie deren Methodensignatur einfach deklarieren. Im Fall von GreetingRepository wird dies mit einer findByText() -Methode findByText() .

In einer typischen Java-Anwendung würden Sie erwarten, eine Klasse zu schreiben, die GreetingRepository implementiert. Aber genau das macht Spring Data JPA so leistungsfähig: Sie müssen keine Implementierung der Repository-Schnittstelle schreiben. Spring Data JPA erstellt eine Implementierung, wenn Sie die Anwendung ausführen.

Serviceklasse

package org.springboot.service;

import java.util.Collection
import org.springboot.model.Greeting;

public interface GreetingService {

    Collection<Greeting> findAll();
    Greeting findOne(Long id);
    Greeting create(Greeting greeting);
    Greeting update(Greeting greeting);
    void delete(Long id);

}

Service Bean

package org.springboot.service;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.repository.GreetingRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class GreetingServiceBean implements GreetingService {

    @Autowired
    private GreetingRepository greetingRepository;

    @Override
    public Collection<Greeting> findAll() {
        Collection<Greeting> greetings = greetingRepository.findAll();
        return greetings;
    }

    @Override
    public Greeting findOne(Long id) {
        Greeting greeting = greetingRepository.findOne(id);
        return greeting;
    }

    @Override
    public Greeting create(Greeting greeting) {
        if (greeting.getId() != null) {
            //cannot create Greeting with specified Id value
            return null;
        }
        Greeting savedGreeting = greetingRepository.save(greeting);
        return savedGreeting;
    }

    @Override
    public Greeting update(Greeting greeting) {
        Greeting greetingPersisted = findOne(greeting.getId());
        if (greetingPersisted == null) {
            //cannot find Greeting with specified Id value
            return null;
        }
        Greeting updatedGreeting = greetingRepository.save(greeting);
        return updatedGreeting;
    }

    @Override
    public void delete(Long id) {
         greetingRepository.delete(id);
    }

}

Controller-Klasse

package org.springboot.web.api;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/api")
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    // GET [method = RequestMethod.GET] is a default method for any request. 
    // So we do not need to mention explicitly

    @RequestMapping(value = "/greetings", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Collection<Greeting>> getGreetings() {
        Collection<Greeting> greetings = greetingService.findAll();        
        return new ResponseEntity<Collection<Greeting>>(greetings, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> getGreeting(@PathVariable("id") Long id) {
        Greeting greeting = greetingService.findOne(id);
        if(greeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Greeting>(greeting, HttpStatus.OK);
    }
    
    @RequestMapping(value = "/greetings", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> createGreeting(@RequestBody Greeting greeting) {
        Greeting savedGreeting = greetingService.create(greeting);
        return new ResponseEntity<Greeting>(savedGreeting, HttpStatus.CREATED);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> updateGreeting(@PathVariable("id") Long id, @RequestBody Greeting greeting) {
        Greeting updatedGreeting = null;
        if (greeting != null && id == greeting.getId()) {
            updatedGreeting = greetingService.update(greeting); 
        }
        if(updatedGreeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity<Greeting>(updatedGreeting, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<Greeting> deleteGreeting(@PathVariable("id") Long id) {
        greetingService.delete(id);
        return new ResponseEntity<Greeting>(HttpStatus.NO_CONTENT);
    }

}

Anwendungseigenschaftendatei für MySQL-Datenbank

#mysql config
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=Welcome@123
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto = update

spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.DefaultNamingStrategy

#initialization
spring.datasource.schema=classpath:/data/schema.sql

SQL-Datei

drop table if exists greeting;
create table greeting (
    id bigint not null auto_increment, 
    text varchar(100) not null, 
    primary key(id)
);

pom.xml-Datei

<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>org</groupId>
<artifactId>springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.1.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Erstellen eines ausführbaren JAR

Sie können die Anwendung über die Befehlszeile mit Maven ausführen. Sie können auch eine einzelne ausführbare JAR-Datei erstellen, die alle erforderlichen Abhängigkeiten, Klassen und Ressourcen enthält, und diese ausführen. Dies macht es einfach, den Service als Anwendung während des gesamten Entwicklungszyklus, in verschiedenen Umgebungen usw. zu liefern, zu implementieren und bereitzustellen.

Führen Sie die Anwendung mit ./mvnw spring-boot:run . Oder Sie können die JAR-Datei mit ./mvnw clean package . Dann können Sie die JAR-Datei ausführen:

java -jar target/springboot-0.0.1-SNAPSHOT.jar