Spring Boot JPA

Was ist JPA?

Spring Boot JPA Ist eine Java-Spezifikation zur Verwaltung von Java-AnwendungenVerhältnisseDaten. Es ermöglicht uns, Java-Objekte zu accessen und zu persistieren/Daten zwischen Klassen und relationellen Datenbanken. JPA folgtObjektbeziehungsmapping(ORM)。Es ist eine Reihe von Schnittstellen. Es bietet auch Runtime- EntityManager API, um Abfragen und Transaktionen für Datenbankobjekte zu verarbeiten. Es verwendet eine plattformunabhängige objektorientierte Abfragesprache JPQL (Java Persistence Query Language).

In Bezug auf die Persistenz umfasst es drei Bereiche:

Java Persistence API Object-RelationalMetadatenin persistence Die API selbst definiert im Paket

JPA ist kein Framework. Es definiert Konzepte, die in jedem Framework implementiert werden können.

Warum sollten wir JPA verwenden?

Im Vergleich zu JDBC ist JPA einfacher, sauberer und weniger arbeitsintensiv, SQL und handschriftliche Mapping. JPA ist für komplexe Anwendungen ohne Performance-orientierung geeignet. Der Hauptvorteil von JPA im Vergleich zu JDBC liegt darin, dass Daten in JPA durch Objekte und Klassen dargestellt werden, während sie in JDBC durch Tabellen und Aufzeichnungen dargestellt werden. Es verwendet POJOs, um persistente Daten zu repräsentieren, was die Datenbankprogrammierung vereinfacht. JPA hat auch andere Vorteile:

JPA vermeidet die Verwendung von SQL-Spezialdialekten der Datenbank für DDL. Stattdessen ermöglicht es es, mit XML oder durch Java-Annotationen zu mappen. JPA ermöglicht es uns, DML zu vermeiden, indem man SQL-Spezialdialekte der Datenbank schreibt. JPA ermöglicht es uns, Java-Objekte und Graphen ohne jegliche DML-Sprache zu speichern und zu laden.Wenn wir JPQL-Abfragen ausführen müssen, ermöglicht es uns, Abfragen mit Java-Entitäten auszudrücken, anstatt (nativen) SQL-Tabellen und Spalten.

JPA-Funktionen

JPA hat folgende Funktionen:

Dies ist eine leistungsstarke Bibliothek und benutzerdefinierteObjektzuordnung Abstraktion. Es unterstütztCross-Store Persistence. Dies bedeutet, dass eine Entität teilweise in MySQL und Neo gespeichert werden kann4in der Datenbankverwaltung.Es generiert Queries dynamisch aus den Namen der AbfrageMethoden.Domenkbasierte Klassen bieten grundlegende Attribute.Es unterstützt transparente Überprüfung.Möglichkeit der Integration von benutzerdefiniertem Speichercode.Es ist einfach, mit dem Spring Framework zu integrieren, indem man benutzerdefinierte Namespaces verwendet.

JPA-Architektur

JPA ist die Quelle, um Geschäftsobjekte als relationale Objekte zu speichern. Es zeigt, wie man POJOs als Entitäten definiert und wie man Entitäten durch relationale Verwaltung verwaltet.

Das folgende Diagramm beschreibt die Klassenarchitektur von JPA, die die Kernklasse und -schnittstellen von JPA beschreibt. javax PersistencePaket. Die JPA-Architektur enthält die folgenden Einheiten:

Persistence: Dies ist eine Klasse, die statische Methoden enthält, um Instanzen von EntityManagerFactory zu erhalten. EntityManagerFactory: ist die Fabrikklasse für EntityManager. Sie erstellt und verwaltet mehrere Instanzen von EntityManager. EntityManager: Es ist eine Oberfläche. Es kontrolliert die persistente Operationen an Objekten. Es ist für Query-Instanzen geeignet. @Entity markiert die Klasse als: Entitäten sind als Aufzeichnungen in der Datenbank gespeichert und sind persistente Objekte.} Persistence Unit: Es definiert eine Gruppe von allen Entity-Klassen. In der Anwendung wird die EntityManager-Instanz verwaltet. Eine Gruppe von Entity-Klassen stellt Daten dar, die in einem einzigen Datenlager enthalten sind. EntityTransaction: . Es hat eineeins-zu-mehrVerhältnis. Für jede EntityManager werden die Operationen von der EntityTransaction-Klasse verwaltet. Abfrage: Diese Schnittstelle wird von jedem JPA-Anbieter implementiert, um berechtigte Beziehungsobjekte zu erhalten.

JPA-Klassenbeziehung

. Die oben diskutierten Klassen und Schnittstellen haben eine Beziehung. Das Diagramm unten zeigt die Beziehung zwischen Klassen und Schnittstellen.

Das Verhältnis zwischen EntityManager und EntityTransaction isteins-zu-mehr. Jede EntityManager-Operation hat eine EntityTransaction-Instanz. Das Verhältnis zwischen EntityManageFactory und EntityManager isteins-zu-eins. Dies ist die Fabrikklasse der EntityManager-Instanz. Das Verhältnis zwischen EntityManager und Query isteins-zu-eins. Wir können mit Instanzen der EntityManager-Klasse eine beliebige Anzahl von Abfragen ausführen. Das Verhältnis zwischen EntityManager und Entity isteins-zu-eins. Eine EntityManager-Instanz kann mehrere Entitäten verwalten.

JPA-Implementierung

JPA ist eine Open-Source-API. Es gibt verschiedene Unternehmensanbieter, wie z.B. Eclipse, RedHat, Oracle, die neue Produkte durch die Hinzufügung von JPA anbieten. Es gibt einige beliebte JPA-Implementierungsframeworks, wie z.B. Hibernate, EclipseLink, DataNucleus usw. Es wird auchObjektbeziehungsmappingwerkzeuge. (ORM)

Objektbeziehungsmapping (ORM)

In ORM wird die Abbildung von Java-Objekten zu Datenbanktabellen (und umgekehrt) alsObjektbeziehungsmapping. (ORM) ORM-Mapping spieltrelationale Datenbankenund (Tabellen und Aufzeichnungen) und Java-AnwendungBrücke zwischen (Klassen und Objekten).

Wie in der Abbildung unten gezeigt, ist die ORM-Schicht eine Adapter-Schicht. Sie passt die Sprache der Objektg graphen an die Sprache von SQL und den Sprache der relationellen Tabellen an.

Die ORM-Schicht existiert zwischen Anwendung und Datenbank. Sie konvertiert Java-Klassen und Objekte, um sie in relationellen Datenbanken speichern und verwalten zu können. Standardmäßig wird der Name der Persistenz zum Namen der Tabelle und die Felder zu den Spalten. Sobald die Anwendung eingerichtet ist, entspricht jede Tabellenzeile einem Objekt.

JPA-Version

Die frühen Versionen von EJB definierten eine Persistenzschicht, die mit der Geschäftslogik verknüpft ist. Verwendet javax.ejb.EntityBean 接口。 EJB规范包括JPA的定义。

在引入EJB 3im Rahmen der EJB-Spezifikation enthalten. 1.0 getrennt und als JPA spezifiziert, als die Persistenzschicht in die EJB eingeführt wurde.2.0 (Java Persistence API). Die Spezifikation der API wurde mit6005Jahr11Monat 22Tag wurde JSR50 der JAVA EE

2019Spezifikation umbenannt und gemeinsam veröffentlicht. Jahr, JPA wurde in den Jakarta Persistence 2.2 . Die neueste Version von JPA ist

. Es unterstützt folgende Funktionen: 8Java und Daten- und Zeit-APIEs ermöglicht die CDI-Injektion in AttributConverters mit der Annotation @Repeatable

Unterschiede zwischen JPA und Hibernate

JPA: JPA ist eine Java-Spezifikation zur Zugriff, Verwaltung und Persistenz von Daten zwischen Java-Objekten und relationalen Datenbanken. Dies ist der Standardansatz für ORM.

Hibernate: Dies ist ein leichtes Open-Source-ORM-Tool zur Speicherung von Java-Objekten in relationalen Datenbanken. Es ist ein Anbieter für JPA und folgt einem allgemeinen Ansatz der JPA.

Der folgende Tisch beschreibt die Unterschiede zwischen JPA und Hibernate.

Spring Boot Startprogramm Daten JPA

Spring Boot bietet Startprogramm-Abhängigkeiten spring-boot-starter-data-jpa um relationale Datenbanken effizient in Spring Boot-Anwendungen zu verbinden. spring-boot-starter-data-JPA verwendet intern Spring-boot-JPA-Abhängigkeiten.

<dependency>　　
<groupId>org.springframework.boot</groupId>　　
<artifactId>spring-boot-starter-data-jpa</artifactId>　　
<version>2.2.2.RELEASE</version>　　
</dependency>

Spring Boot JPA-Beispiel

Wir erstellen eine Spring Boot-Anwendung, die eine Verbindung zur Datenbank über JPA herstellt. Im folgenden Beispiel verwenden wir eine in-Memory-Datenbank Apache Derby.

Apache Derby : Dies ist eine eingebetteteOpen Source SoftwareRelationale Datenbank vollständig in Java implementiert. Es ist unter der Apache License 2.0 verfügbar. Apache Derby hat die folgenden Vorteile:

Einfach zu installieren, zu konfigurieren und zu verwenden.Es basiert auf Java, JDBC und SQL-Standard.Es bietet einen eingebetteten JDBC-Treiber, der es uns ermöglicht, Derby in jede auf Java basierende Lösung einzubetten.Es unterstützt auch Kunden durch den Derby Network Client JDBC-Treiber und den Derby Network Server./Server-Modus.

Spring Boot kann eingebettete Datenbanken automatisch konfigurieren, z.B. H2und HSQL,und Derbydatabases hinzufügen. Wir müssen keine Verbindung URL bereitstellen. Wir müssen nur die Bauabhängigkeiten der eingebetteten Datenbank enthalten.

In Spring Boot müssen Sie nur Derby Abhängigkeiten hinzufügen, um Apache Derby Datenbank problemlos zu integrieren. xml-Datei.

<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
<scope>runtime</scope>
</dependency>

Schritte1: Öffnen Sie Spring Initializr https://start.spring.io/.

Schritte2: Wählen Sie die neueste Version von Spring Boot 2.3.0(SNAPSHOT)

Schritte3: zur Verfügung gestelltGroupName. Wir haben com.w3codebox.

Schritte4: zur Verfügung gestelltArtifact ID. Wir haben apache-derby-example .

Schritte5: Hinzufügen von Abhängigkeiten: Spring Web, Spring Data JPAund Apache Derby Datenbank.

Schritte6: Klicken Generate (Erstellen) Schaltfläche. Wenn wir auf die Schaltfläche "Erstellen" klicken, packt sie das Projekt in eine Jar-Datei und lädt sie auf das lokale System herunter.

Schritte7: Extrahieren Jar-Datei und fügen Sie sie in den STS- Arbeitsbereich ein.

Schritte8: Importieren

Datei-> Importieren-> Bestehendes Maven-Projekt-> Durchsuchen-> Wählen Sie den Ordner apache-derby-example-> Fertig

Es dauert einige Zeit, um zu importieren.

Schritte9: im Verzeichnis src/main/javaErstellen Sie im Paket com.w3codebox.model Paket.

Schritte10: im Paket com.w3codebox.model Erstellen Sie im Paket codebox.model UserRecord

der Klasse und führen Sie dann folgende Aktionen aus: Definieren Sie drei Variablen.id, name und email
Erstellen Sie Getter und Setter.-> Klicken Sie mit der rechten Maustaste auf die Datei-> Quelle > Generieren Sie Getter und SetterVerwenden Sie die Annotation Definieren Sie den Standardkonstruktor.@Entity markiert die Klasse als. Verwenden Sie die Annotation @Id markiert Id als Primärschlüssel markieren.

UserRecord.java

package com.w3codebox.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity　　
public class UserRecord　
{　
@Id　　
private int id;　　
private String name;　　
private String email;
//Standardkonstruktor　　
public UserRecord()
{
}　　
public int getId()　
{　　
return id;　　
}　　
public void setId(int id)　
{　　
this.id = id;　　
}　　
public String getName()　
{　　
return name;　　
}　　
public void setName(String name)　
{　　
this.name = name;　　
}　　
public String getEmail()　
{　　
return email;　　
}　　
public void setEmail(String email)　
{
this.email = email;　　
}　　
}

Schritte11: in src/main/In einem Ordner namens com.w3codebox.controller Paket.

Schritte12: im Paket com.w3codebox.controller Erstellen Sie im Paket UserController Controller-Klasse von codebox.controller, und führen Sie folgende Aktionen aus:

Verwenden Sie die Annotation @RestController Die Klasse als Controller markieren.Verwenden Sie die Annotation @Autowired Automatische Verbindungsklasse UserService .Wir haben zwei Mapping definiert, eines davon wird verwendet, umalle Benutzer abrufen，另一个映射用于Benutzer hinzufügen.

UserController.java

package com.w3codebox.controller;　　
import org.springframework.beans.factory.annotation.Autowired;　　
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;
import com.w3codebox.model.UserRecord;
import com.w3codebox.service.UserService;
import java.util.List;　　
@RestController　　
public class UserController　
{　　
@Autowired　　
private UserService userService;　　　
@RequestMapping("/")　　
public List<UserRecord> getAllUser()
{　　
return userService.getAllUsers();　　
}　　　　　
@RequestMapping(value="/add-user", method=RequestMethod.POST)　　
public void addUser(@RequestBody UserRecord userRecord)
{　　
userService.addUser(userRecord);　　
}　　　　　
}

Schritte13: im Verzeichnis src/main/in Java eine Klasse mit dem Namen com.w3codebox.service Paket.

Schritte14: im Paket com.w3codebox.service im Namen UserController der Service-Klasse und führe folgende Aktionen aus:

durch die Verwendung von Annotationen @Servicemarkiere diese Klasse als Service. automatische Verbindung UserRepository definiere eine Methode getAllUsers()dieser Methode wird die folgende Liste zurückgeben: definiere einen weiteren Methodennamen addUser()um Benutzerdaten zu speichern.

UserService.java

package com.w3codebox.service;　　
import java.util.List;　　
import java.util.ArrayList;　　
import org.springframework.beans.factory.annotation.Autowired;　　
import org.springframework.stereotype.Service;
import com.w3codebox.model.UserRecord;
import com.w3codebox.repository.UserRepository;　　
@Service　　
public class UserService　
{　　
@Autowired　　
private UserRepository userRepository;　　
public List<UserRecord> getAllUsers()}
{　　
List<UserRecord>userRecords = new ArrayList<>();　　
userRepository.findAll().forEach(userRecords::add);　　
return userRecords;　　
}　　
public void addUser(UserRecord userRecord)
{　　
userRepository.save(userRecord);　　
}　　
}

Schritte15: im Verzeichnis src/main/javaErstellen Sie im Paket com.w3codebox.repository Paket.

Schritte16: im Paket com.w3codebox.repository im Namen UserRepository eines Speicherinterface, das erweitert CrudRepository .

UserRepository.java

package com.w3codebox.repository;　　
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.UserRecord;　　
public interface UserRepository extends CrudRepository<UserRecord, String>　
{　　
}

Schritte17: Öffnen Sie nun ApacheDerbyExampleApplication.java Datei. Sie wurde standardmäßig erstellt, als wir die Anwendung eingerichtet haben.

ApacheDerbyExampleApplication.java

package com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ApacheDerbyExampleApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(ApacheDerbyExampleApplication.class, args);
}
}

Nun haben wir alle erforderlichen Klassen und Pakete gemäß den Anforderungen eingerichtet. Bitte beachten Sie, dass wir der Datenbank keineVerbindungs-URL . Nach Abschluss aller oben genannten Schritte, sieht der Projektordner wie folgt aus:

Lassen Sie uns die Anwendung ausführen.

Schritte18: Öffnen Sie ApacheDerbyExampleApplication.java Datei und führen Sie sie als Java-Anwendung aus.

Der19Schritt: Öffnen Sie den Browser und rufen Sie die URL http: auf//localhost:8080/. Da keine Benutzer in die Liste aufgenommen wurden, wird eine leere Liste zurückgegeben.

Um den Benutzer in die Datenbank hinzuzufügen, verwenden wirSenden POST Postman-Anfrage.

Schritte20: Öffnen SiePostmanund führen Sie die folgenden Schritte aus:

Wählen Sie POST Rufen Sie die URL http: auf//localhost:8080/add-user.KlickenBody Wählen Sie Content-Typ alsJSON (application/json).Fügen Sie die zu insertierenden Daten in die Datenbank ein. Wir haben folgende Daten eingefügt:

{
"id": "00"1",
"name": "Tom",
"email": "[email protected]"
}

KlickenSendenSchaltfläche.

Wenn wir auf die Schaltfläche "Senden" klicken, wird angezeigtStatus: 200 OK . Dies bedeutet, dass die Anfrage erfolgreich ausgeführt wurde.

Schritte21: Öffnen Sie den Browser und rufen Sie die URL http: auf //localhost: 8080. Es gibt uns die Benutzer zurück, die wir in die Datenbank eingefügt haben.