Spring Data JPA-Tutorial mit Spring Boot

Dieses Tutorial führt Sie durch die Erstellung einfacher REST-APIs mit Spring Data JPA und Spring Boot. Am Ende dieses Tutorials sind Sie in der Lage, die Anwendungen mit Spring Data JPA und Spring Boot zu schreiben.

In unseren früheren Tutorials haben wir uns mit Spring Data JPA und JPA-Frameworks befasst. Dieses Tutorial verwendet jedoch Spring Boot zum Erstellen und Ausführen der Anwendung. Außerdem habe ich in diesem Tutorial Kernkonzepte des Spring Data Common-Projekts geschrieben.

Inhaltsverzeichnis

Hier ist die Liste der Abschnitte, die in diesem Tutorial behandelt werden.

  • Was sind Frühlingsdaten?
  • Spring Boot und Spring Data JPA
  • Spring-Datenrepositorys
  • CrudRepository
  • Repository
  • PagingAndSortingRepository
  • JpaRepository vs. CrudRepository
  • Abfragemethoden
  • Domänenklasse
  • REST-API
  • Serviceschicht
  • Spring Boot-Anwendung
  • Laden Sie den Quellcode herunter
  • Abschluss
  • Was sind Frühlingsdaten?

    Spring Data ist ein von der Spring-Community entwickeltes High-Level-Projekt mit dem Ziel, die Datenzugriffsvorgänge für die Anwendungen zu vereinfachen. Für die einzelnen Filialen werden mehrere Unterprojekte gepflegt, um über eine eigene Implementierung von Repositories zu verfügen.

    Wenn Sie verwenden Frühlingsdaten In Ihrem Projekt werden Sie die meisten Datenzugriffsvorgänge auf niedriger Ebene wie das Schreiben von SQL-Abfragen, DAO-Klassen usw. nicht schreiben. Spring Data generiert alles dynamisch zur Laufzeit, indem es die Proxy-Instanzen Ihrer abstrakten Repositorys erstellt und ausführt die erforderlichen Operationen. Was Sie schreiben, sind die abstrakten Schnittstellen, die die erforderlichen Operationen definieren.

    In diesen Tutorials verwenden wir eines der Unterprojekte Spring Data JPA. Ansonsten hat Spring Data die folgenden Unterprojekte:

    • Spring Data Commons
    • Spring Data MongoDB
    • Spring Data Redis
    • Spring Data Solr
    • Spring Data Gemfire
    • Spring Data REST
    • Frühlingsdaten Neo4j

    Release-Zug

    Das Spring Data-Projekt umfasst mehrere geschäftsspezifische Projekte, wie oben erwähnt. Selbstverständlich verfügt jedes der oben genannten Module über einen eigenen Veröffentlichungszyklus und ein eigenes Team, das an den Verbesserungen arbeitet. Wenn Sie die Abhängigkeiten für Ihre Anwendung herunterladen, sollten alle oben genannten Module miteinander kompatibel sein.

    Um das Kompatibilitätsproblem zu lösen, wird eine Stückliste (Bill of Materials) mit einem kuratierten Satz von Abhängigkeiten für das einzelne Projekt veröffentlicht. Die Release-Züge haben Namen, keine Versionen, um Verwechslungen mit den Unterprojekten zu vermeiden.

    Die neueste Version mit dem Namen Gosling-RELEASE und Sie müssen die folgenden Einträge in Ihrem hinzufügen pom.xml Datei.

    <dependencyManagement>
    <dependencies>
    <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-releasetrain</artifactId>
    <version>Gosling-RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
    </dependency>
    </dependencies>
    </dependencyManagement>
    

    Spring Data JPA

    Spring Data JPA ist Teil der Spring Data-Familie und zielt darauf ab, JPA-basierte Repositorys bereitzustellen, die die Implementierung der Datenzugriffsschicht mithilfe von JPA vereinfachen sollen.

    Frühlingsdaten JPA

    Spring Boot und Spring Data JPA

    Ich werde einfache REST-APIs für die Verwaltung einer Buchladenanwendung schreiben und die Details in der H2-Datenbank speichern, einer In-Memory-Datenbank, die am häufigsten für Entwicklungszwecke verwendet wird. Meine endgültige pom.xml-Datei würde so aussehen:

    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.5.RELEASE</version>
    </parent>
    <dependencies>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    </dependency>
    </dependencies>
    

    Wenn Sie sich die obigen Konfigurationen ansehen,

    • spring-boot-starter-parent Lädt alle Standardkonfigurationen, die für die grundlegenden Spring-Boot-Anwendungen erforderlich sind.
    • spring-boot-starter-data-jpa Die Abhängigkeit lädt die für Spring Data JPA erforderlichen Dateien herunter.
    • spring-boot-starter-webist erforderlich, da es sich um eine webbasierte Anwendung zur Bereitstellung der REST-Endpunkte handelt.

    Die oben genannten Konfigurationen reichen aus, um mit der Entwicklung unserer einfachen REST-API-Anwendung mithilfe von Spring Data JPA zu beginnen.

    In den kommenden Abschnitten werde ich einige der Schnittstellen in Spring Data und deren Zweck erläutern.

    Spring-Datenrepositorys

    Wenn Sie mit Spring-Data-Technologien arbeiten, ist es wichtig, das Repository-Konzept zu verstehen. Spring-Daten stellen die abstrakten Repositorys bereit, die zur Laufzeit vom Spring-Container implementiert werden und die CRUD-Operationen ausführen. Als Entwickler müssen wir lediglich die abstrakten Methoden in der Schnittstelle bereitstellen. Dadurch wird die Menge an Boilerplate-Code reduziert, die zum Schreiben von Datenzugriffsebenen erforderlich ist.

    Im Folgenden sind die drei Basisschnittstellen aufgeführt, die im definiert sind Spring Data Commons Projekt.

    Repository

    Es ist die zentrale Schnittstelle in der Abstraktion des Spring Data Repository. Dies ist eine Marker-Schnittstelle. Wenn Sie diese Schnittstelle erweitern, müssen Sie Ihre eigenen Methoden deklarieren und die Implementierungen werden von der Spring-Laufzeit bereitgestellt. Auch für diese Schnittstelle müssen wir zwei Parameter übergeben: Typ der Entität und Typ des ID-Felds der Entität. Dies ist die Superschnittstelle für CrudRepository.

    CrudRepository

    CrudRepository stellt Methoden für die CRUD-Operationen bereit. Diese Schnittstelle erweitert die Repository-Schnittstelle. Wenn Sie CrudRepository definieren, müssen Sie die beiden Parameter übergeben: Typ der Entität und Typ des ID-Felds der Entität. Diese Schnittstelle verfügt über die folgenden Methoden:

    • S speichern (S-Entität)
    • T findOne(ID PrimaryKey)
    • Iterierbares findAll()
    • Lange Zählung()
    • void delete(T-Entität)
    • boolescher Wert existiert (ID PrimaryKey)

    Wenn Sie die erweitern CrudRepositoryEs ist nicht erforderlich, eigene Methoden zu implementieren. Erweitern Sie einfach diese Schnittstelle und lassen Sie sie leer. Erforderliche Implementierungen werden zur Laufzeit bereitgestellt.

    Schauen Sie sich unser Beispiel an:

    public interface BookRepository extends JpaRepository<Book,Long> {
    }
    

    Wir haben benutzt JpaRepository, die spezielle Version speziell für die JPA-Technologie. Sofern Sie keine der JPA-spezifischen Dinge in Ihren Anwendungen verwenden, wird dringend empfohlen, die zu verwenden CrudRepositoryda Ihre Anwendung dadurch nicht an bestimmte Store-Implementierungen gebunden wird.

    Der obige Code reicht aus, um die grundlegenden Vorgänge wie Suchen, Speichern und Löschen auszuführen.

    PagingAndSortingRepository

    Dies ist eine Erweiterung von CrudRepository. Es handelt sich um eine spezielle Version für Paging-Vorgänge. Die Implementierung dieser Klasse sieht folgendermaßen aus:

    public interface PagingAndSortingRepository<T, ID extends Serializable>
    extends CrudRepository<T, ID> {
    Iterable<T> findAll(Sort sort);
    Page<T> findAll(Pageable pageable);
    }
    

    JpaRepository vs. CrudRepository

    Sowohl JpaRepository als auch CrudRepository sind Basisschnittstellen in Spring Data. Der Anwendungsentwickler muss eine der Basisschnittstellen für sein eigenes Repository auswählen. Es hat zwei Zwecke:

    • Eine besteht darin, Spring Data zu erlauben, eine Proxy-Instanz für Ihre Repository-Schnittstelle zu erstellen.
    • Die zweite Möglichkeit besteht darin, die maximale Standardfunktionalität von den Basisschnittstellen zu erben, ohne eigene Methoden zu deklarieren.

    Wenn wir uns beide Schnittstellen ansehen, sind die deutlichen Unterschiede:

    • CrudRepository ist Teil von Spring Data Commons Projekt und unter dem Paket deklariert org.springframework.data.repository. Wobei JpaRepository Teil der speicherspezifischen Implementierung ist und unter dem Paket deklariert wird org.springframework.data.jpa.repository.
    • CrudeRepository erweitert die Repository-Schnittstelle. Wobei sich JpaRepository vom PagingAndSortingRepository erstreckt, welches Inturen vom CrudeRepository erweitert.
    • JpaRepository kehrt zurück List Art der Entitäten und CrudRepository-Rückgaben Iterable Art der Entitäten.
    • Es wird allgemein empfohlen, die geschäftsspezifischen Basisschnittstellen nicht zu verwenden, da sie die zugrunde liegende Persistenztechnologie offenlegen und die Kopplung zwischen ihnen und dem Repository verstärken. Es ist immer eine gute Idee, eine der generischen Basisschnittstellen wie CrudRepository oder PagingAndSortungRepository zu wählen.

    Das folgende Diagramm zeigt die Struktur des Repository-Moduls.

    Zeichnung1

    Abfragemethoden

    • Abfragemethoden werden zum Suchen von Informationen aus der Datenbank verwendet und sind in der Repository-Schnittstelle deklariert.
    • Abfragemethoden können ein oder mehrere Ergebnisse zurückgeben.
    • Dies unterstützt auch die Übergabe von Parametern an Datenbankabfragen durch Senden über Parameterbindung oder benannte Parameter.
    • Wenn Sie Abfragemethoden implementieren möchten, implementieren Sie die Repository-Schnittstelle und schreiben Sie Ihre eigenen Methoden.

    Hier ist ein einfaches Beispiel für das Schreiben Abfragemethoden:

    public interface BookOwnRepository extends Repository<Book,Long>{
    List<Book> findByName(String name);
    List<Book> findByPrice(long price);
    List<Book> findByNameAndAuthor(String name, String author);
    }
    
    • Die Verwendung von Abfragemethoden ist die bequemste Möglichkeit, eigene Abfragen zu schreiben, um Daten aus der Datenbank abzurufen. Spring Data JPA ermöglicht eine leistungsfähigere Abfrageerstellung mithilfe der Methodennamen und Parameter.
    • In der obigen Beispielklasse haben wir nur wenige Namenskonventionen verwendet, die die Abfrage bilden.
      • findBy… – das ist das Präfix. Alles, was auf dieses Präfix folgt, wird zum Einrahmen der Abfrage verwendet
      • findByName – Bei dieser Methode werden nur die übereinstimmenden Namen zurückgegeben. Hier geben wir nur einen Parameternamen ein.
      • findByNameAndAuthor – Bei dieser Methode verwenden wir das „Und“, um der Abfrage weitere Informationen hinzuzufügen, indem wir entweder nach Name oder Autor suchen. Auf ähnliche Weise können Sie das Trennzeichen „Oder“ verwenden.

    Domänenklasse

    Hier ist das einfache Domänenklassenbuch, das für dieses Tutorial verwendet wird.

    Book.java

    @Entity
    public class Book implements Serializable{
    private static final long serialVersionUID = 1L;
    @Id
    long id;
    @Column(name="name")
    String name;
    @Column(name="author")
    String author;
    @Column(name="price")
    long price;
    //Getters and Setters Here
    }
    
    • @Entity Wird verwendet, um zu kennzeichnen, dass dieses POJO als Entität in der Datenbank verwendet wird.

    REST-API

    Ich habe eine einfache REST-API geschrieben, indem ich @RestController mit Annotationen versehen habe (diese Annotation wurde ab Spring 4.0 eingeführt). Diese Klasse dient als Schnittstelle zwischen der Clientanwendung und der Datenbankschicht. Es stellt die API zum Hinzufügen, Suchen, Auflisten und Löschen von Büchern zur Datenbank bereit.

    Schauen Sie sich den Beispielcode an:

    @RestController
    @RequestMapping(value = "/books")
    public class BooksController {
    @Autowired
    private BookService bookService;
    @RequestMapping(value = "/add/{id}/{name}/{author}/{price}")
    public Book addBook(@PathVariable int id, @PathVariable String name, @PathVariable String author,
    @PathVariable long price) {
    Book book = new Book();
    book.setId(id);
    book.setName(name);
    book.setAuthor(author);
    book.setPrice(price);
    bookService.saveBook(book);
    return book;
    }
    @RequestMapping(value = "/delete/{id}")
    public void deleteBook(@PathVariable int id) {
    Book book = new Book();
    book.setId(id);
    bookService.delete(id);
    }
    @RequestMapping(value = "/")
    public List<Book> getBooks() {
    return bookService.findAll();
    }
    
    @RequestMapping(value = "/{id}")
    public Book getBook(@PathVariable int id) {
    Book book = bookService.findOne(id);
    return book;
    }
    @RequestMapping(value = "/search/name/{name}")
    public List<Book> getBookByName(@PathVariable String name) {
    List<Book> books = bookService.findByName(name);
    return books;
    }
    @RequestMapping(value = "/search/price/{price}")
    public List<Book> getBookByPrice(@PathVariable int price) {
    List<Book> books = bookService.findByPrice(price);
    return books;
    }
    @RequestMapping(value = "/search/{name}/{author}")
    public List<Book> getBookByNameAndAuthor(@PathVariable String name, @PathVariable String author) {
    List<Book> books = bookService.findByNameAndAuthor(name, author);
    return books;
    }
    }
    

    Für diese Klasse ist keine Erklärung erforderlich, da wir bereits ausführlich über die RestControllers und Spring Rest Services berichtet haben.

    • Lesen Sie auch: Integrationstests der REST-API mit Spring Boot

    Serviceschicht

    Ich habe eine Serviceschicht geschrieben, die zwischen der REST-API und den Spring Data-Repositorys liegt. Das direkte Aufrufen der Datenzugriffs-APIs aus unserem REST ist keine gute Vorgehensweise, daher habe ich zu diesem Zweck eine Serviceschicht geschrieben.

    BookService.java

    public interface BookService {
    public List<Book> findAll();
    public void saveBook(Book book);
    public Book findOne(long id);
    public void delete(long id);
    public List<Book> findByName(String name);
    public List<Book> findByNameAndAuthor(String name, String author);
    public List<Book> findByPrice(long price);
    }
    

    BookServiceImpl.java

    @Service
    @Transactional
    public class BookServiceImpl implements BookService{
    @Autowired
    private BookRepository bookRepository;
    @Autowired
    private BookOwnRepository bookOwnRepository;
    
    public List<Book> findAll(){
    return bookRepository.findAll();
    }
    public List<Book> findByName(String name){
    return bookOwnRepository.findByName(name);
    }
    public List<Book> findByPrice(long price){
    return bookOwnRepository.findByPrice(price);
    }
    public List<Book> findByNameAndAuthor(String name, String author){
    return bookOwnRepository.findByNameAndAuthor(name,author);
    }
    public void saveBook(Book book){
    bookRepository.save(book);
    }
    public Book findOne(long id){
    return bookRepository.findOne(id);
    }
    public void delete(long id){
    bookRepository.delete(id);
    }
    }
    
    • Wir würden verlangen @Transaction Anmerkung zur Durchführung der Datenbanktransaktionen.
    • @Service Anmerkung, um anzugeben, dass es sich um eine Serviceklasse handelt
    • @Autowired wird zum Einfügen der Repository-Abhängigkeit in die Serviceschicht verwendet.
    • Beachten Sie Folgendes: Ich habe beide Repositorys in die Serviceschicht eingefügt. Ich habe beide nur zu Beispielzwecken verwendet. In Ihrer Anwendung wählen Sie besser einen beliebigen Repository-Typ und schreiben alles in das einzelne Repository.
    • Diese Serviceklasse ist lediglich ein Delegationsmodus zum Aufrufen der Repositorys.

    Spring Boot-Anwendung

    Notiz : Diese Beispielanwendung für Spring Data JPA mit Spring Boot wird am selben Ort kontinuierlich verbessert und aktualisiert. Daher kann es zu Abweichungen in diesem Tutorial und dem, was Sie tatsächlich im Quellcode sehen, kommen. Aber alles funktioniert gut :).

    Hier ist der letzte Code, um diese Anwendung mit Spring Boot zu booten. Stellen Sie sicher, dass diese Klasse auf derselben oder einer höheren Paketebene geschrieben ist. Wenn Sie die Spring-Boot-Anwendung ausführen, betrachtet sie das Paket, in dem sich die Hauptklasse befindet, als Basispaket und startet @ComponentScan von diesem Paket aus.

    Hier ist die Paketstruktur der Anwendung:

    Spring Data JPA-Projektstruktur

    @SpringBootApplication
    public class Application {
    public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
    }
    }
    
    • Sie können diese Anwendung über die Befehlszeile mit dem Befehl spring-boot:run ausführen

    Wenn Sie Probleme beim Ausführen dieser Anwendung haben, kontaktieren Sie mich bitte.

    • Lesen Sie auch: Vollständiger Leitfaden für Spring Boot Actuator (Produktionslesefunktionen für Spring Boot-Anwendungen sind sofort einsatzbereit)

    Laden Sie den Quellcode herunter

    Symbol

    Spring Data JPA mit Spring Boot-Beispielanwendung

    1 Datei(en) 12,43 KB Download: Spring Data JPA mit Spring Boot

    Abschluss

    In diesem Tutorial habe ich erklärt, wie man REST-APIs mit Spring Data JPA und Spring Boot-Frameworks schreibt. ich hoffe dies Lernprogramm wird eine sehr nützliche und vollständige Anleitung zum Lernen sein Spring Data JPA. Wenn Sie Schwierigkeiten haben, eines der Konzepte zu verstehen, kontaktieren Sie mich bitte über den Kommentarbereich. Genießen Sie die Arbeit mit Federdaten und der Kraft der Einfachheit.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen