TechCodeview

Was ist JPA?

Spring Boot JPA ist eine Java-Spezifikation zur Verwaltung relational Daten in Java-Anwendungen. Es ermöglicht uns den Zugriff auf und die Speicherung von Daten zwischen Java-Objekten/-Klassen und relationalen Datenbanken. JPA folgt Objektbeziehungszuordnung (ORM). Es handelt sich um eine Reihe von Schnittstellen. Es bietet auch eine Laufzeit EntityManager API zur Verarbeitung von Abfragen und Transaktionen der Objekte gegenüber der Datenbank. Es verwendet eine plattformunabhängige objektorientierte Abfragesprache JPQL (Java Persistent Query Language).

Im Kontext der Persistenz werden drei Bereiche abgedeckt:

• Die Java Persistence API
ObjektrelationalMetadaten
• Die API selbst, definiert in der Beharrlichkeit Paket

JPA ist kein Framework. Es definiert ein Konzept, das von jedem Framework implementiert werden kann.

Warum sollten wir JPA verwenden?

JPA ist einfacher, sauberer und weniger arbeitsintensiv als JDBC, SQL und handgeschriebenes Mapping. JPA eignet sich für nicht leistungsorientierte komplexe Anwendungen. Der Hauptvorteil von JPA gegenüber JDBC besteht darin, dass Daten in JPA durch Objekte und Klassen dargestellt werden, während Daten in JDBC durch Tabellen und Datensätze dargestellt werden. Es verwendet POJO zur Darstellung persistenter Daten, was die Datenbankprogrammierung vereinfacht. Es gibt noch einige weitere Vorteile von JPA:

• JPA vermeidet das Schreiben von DDL in einem datenbankspezifischen SQL-Dialekt. Stattdessen ermöglicht es die Zuordnung in XML oder die Verwendung von Java-Annotationen.
• JPA ermöglicht es uns, das Schreiben von DML im datenbankspezifischen Dialekt von SQL zu vermeiden.
• JPA ermöglicht uns das Speichern und Laden von Java-Objekten und -Grafiken ohne jegliche DML-Sprache.
• Wenn wir JPQL-Abfragen durchführen müssen, können wir die Abfragen in Form von Java-Entitäten und nicht in (nativen) SQL-Tabellen und -Spalten ausdrücken.

JPA-Funktionen

Es gibt folgende Funktionen von JPA:

• Es ist ein leistungsstarkes und benutzerdefiniertes Repository Abstraktion der Objektzuordnung.
• Es unterstützt für Cross-Store-Persistenz . Dies bedeutet, dass eine Entität teilweise in MySQL und Neo4j (Graph Database Management System) gespeichert werden kann.
• Es generiert dynamisch Abfragen aus dem Namen der Abfragemethode.
• Die Domänenbasisklassen stellen grundlegende Eigenschaften bereit.
• Es unterstützt eine transparente Prüfung.
• Möglichkeit zur Integration von benutzerdefiniertem Repository-Code.
• Mit dem benutzerdefinierten Namespace ist die Integration in Spring Framework einfach.

JPA-Architektur

JPA ist eine Quelle zum Speichern von Geschäftseinheiten als relationale Einheiten. Es zeigt, wie man ein POJO als Entität definiert und wie man Entitäten mit Beziehungen verwaltet.

Die folgende Abbildung beschreibt die Architektur von JPA auf Klassenebene, die die Kernklassen und Schnittstellen von JPA beschreibt, die in definiert sind Javax-Persistenz Paket. Die JPA-Architektur enthält die folgenden Einheiten:

Beharrlichkeit:Es handelt sich um eine Klasse, die statische Methoden zum Abrufen einer EntityManagerFactory-Instanz enthält.EntityManagerFactory:Es ist eine Factory-Klasse von EntityManager. Es erstellt und verwaltet mehrere Instanzen von EntityManager.EntityManager:Es ist eine Schnittstelle. Es steuert die Persistenzoperationen für Objekte. Es funktioniert für die Query-Instanz.Juristische Person:Die Entitäten sind die Persistenzobjekte, die als Datensatz in der Datenbank gespeichert werden.Persistenzeinheit:Es definiert eine Menge aller Entitätsklassen. In einer Anwendung wird diese von EntityManager-Instanzen verwaltet. Der Satz von Entitätsklassen repräsentiert die in einem einzelnen Datenspeicher enthaltenen Daten.EntityTransaction:Es hat ein eins zu eins Beziehung zur EntityManager-Klasse. Für jeden EntityManager werden Vorgänge von der EntityTransaction-Klasse verwaltet.Abfrage:Es handelt sich um eine Schnittstelle, die von jedem JPA-Anbieter implementiert wird, um Beziehungsobjekte zu erhalten, die die Kriterien erfüllen.

JPA-Klassenbeziehungen

Die oben besprochenen Klassen und Schnittstellen pflegen eine Beziehung. Die folgende Abbildung zeigt die Beziehung zwischen Klassen und Schnittstellen.

MySQL zeigt alle Benutzer an

• Die Beziehung zwischen EntityManager und EntiyTransaction ist eins zu eins . Für jede EntityManager-Operation gibt es eine EntityTransaction-Instanz.
• Die Beziehung zwischen EntityManageFactory und EntiyManager ist eins-zu-viele . Es handelt sich um eine Factory-Klasse für die EntityManager-Instanz.
• Die Beziehung zwischen EntityManager und Query ist eins-zu-viele . Wir können eine beliebige Anzahl von Abfragen ausführen, indem wir eine Instanz der EntityManager-Klasse verwenden.
• Die Beziehung zwischen EntityManager und Entity ist eins-zu-viele . Eine EntityManager-Instanz kann mehrere Entitäten verwalten.

JPA-Implementierungen

JPA ist eine Open-Source-API. Es gibt verschiedene Unternehmensanbieter wie Eclipse, RedHat, Oracle usw., die neue Produkte durch die Integration von JPA bereitstellen. Es gibt einige beliebte JPA-Implementierungs-Frameworks, wie z Ruhezustand, EclipseLink, DataNucleus, usw. Es ist auch bekannt als Objektbeziehungszuordnung (ORM)-Tool.

Objektbeziehungszuordnung (ORM)

In ORM wird die Abbildung von Java-Objekten auf Datenbanktabellen und umgekehrt bezeichnet Objektrelationale Zuordnung. Das ORM-Mapping fungiert als Brücke zwischen a relationale Datenbank (Tabellen und Aufzeichnungen) und Java-Anwendung (Klassen und Objekte).

In der folgenden Abbildung ist die ORM-Schicht eine Adapterschicht. Es passt die Sprache von Objektgraphen an die Sprache von SQL und Beziehungstabellen an.

Die ORM-Schicht befindet sich zwischen der Anwendung und der Datenbank. Es konvertiert die Java-Klassen und -Objekte, sodass sie in einer relationalen Datenbank gespeichert und verwaltet werden können. Standardmäßig wird der verbleibende Name zum Namen der Tabelle und Felder werden zu Spalten. Sobald eine Anwendung eingerichtet ist, entspricht jede Tabellenzeile einem Objekt.

JPA-Versionen

Frühere Versionen von EJB definieren die Persistenzschicht in Kombination mit der Geschäftslogikschicht javax.ejb.EntityBean Schnittstelle. Die EJB-Spezifikation umfasst die Definition von JPA.

Bei der Einführung von EJB 3.0 wurde die Persistenzschicht getrennt und als JPA 1.0 (Java Persistence API) spezifiziert. Die Spezifikationen dieser API wurden zusammen mit den Spezifikationen von JAVA EE5 am 11. Mai 2006 unter Verwendung von JSR 220 veröffentlicht.

Java-Hauptmethode

Im Jahr 2019 wurde JPA umbenannt in Jakarta-Beharrlichkeit . Die neueste Version von JPA ist 2.2 . Es unterstützt die folgenden Funktionen:

• Java 8, Daten- und Zeit-API
• CDI-Injektion in AttributeConvertes
• Es macht Anmerkungen @Repeatable

Unterschied zwischen JPA und Hibernate

JPA: JPA ist eine Java-Spezifikation, die für den Zugriff auf, die Verwaltung und die Beibehaltung von Daten zwischen Java-Objekten und relationalen Datenbanken verwendet wird. Es handelt sich um einen Standardansatz für ORM.

Überwintern: Es handelt sich um ein leichtes Open-Source-ORM-Tool, das zum Speichern von Java-Objekten im relationalen Datenbanksystem verwendet wird. Es ist ein Anbieter von JPA. Es folgt einem gemeinsamen Ansatz der JPA.

In der folgenden Tabelle werden die Unterschiede zwischen JPA und Hibernate beschrieben.

Spring Boot Starter-Daten JPA

Spring Boot bietet Starter-Abhängigkeit spring-boot-starter-data-jpa um die Spring Boot-Anwendung effizient mit der relationalen Datenbank zu verbinden. Das spring-boot-starter-data-jpa verwendet intern die spring-boot-jpa-Abhängigkeit.

 org.springframework.boot spring-boot-starter-data-jpa 2.2.2.RELEASE 

Beispiel für Spring Boot JPA

Erstellen wir eine Spring Boot-Anwendung, die JPA verwendet, um eine Verbindung zur Datenbank herzustellen. Im folgenden Beispiel haben wir eine In-Memory-Datenbank verwendet Apache Derby.

Apache Derby: Es ist ein Open-Source, eingebettet relationale Datenbank, die vollständig in Java implementiert ist. Es ist unter der Apache-Lizenz 2.0 verfügbar. Es gibt folgende Vorteile von Apache Derby:

• Es ist einfach zu installieren, bereitzustellen und zu verwenden.
• Es basiert auf Java-, JDBC- und SQL-Standards.
• Es bietet einen eingebetteten JDBC-Treiber, der es uns ermöglicht, Derby in jede Java-basierte Lösung einzubetten.
• Es unterstützt auch den Client/Server-Modus mit dem Derby Network Client JDBC-Treiber und Derby Network Server.

Spring Boot kann eine eingebettete Datenbank automatisch konfigurieren, z H2, HSQL, Und Derbydatenbanken . Wir müssen keine Verbindungs-URLs angeben. Wir müssen lediglich eine Build-Abhängigkeit von der eingebetteten Datenbank einfügen, die wir verwenden möchten.

In Spring Boot können wir die Apache Derby-Datenbank einfach durch Hinzufügen integrieren Derby Abhängigkeit in der Datei pom.xml.

 org.apache.derby derby runtime 

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

Schritt 2: Wählen Sie die neueste Version von Spring Boot aus 2.3.0 (SCHNAPPSCHUSS)

Schritt 3: Das ____ bereitstellen Gruppe Name. Wir haben zur Verfügung gestellt com.javatpoint.

Schritt 4: Das ____ bereitstellen Artefakt Ausweis. Wir haben zur Verfügung gestellt Apache-Derby-Beispiel .

Schritt 5: Fügen Sie die Abhängigkeiten hinzu: Spring Web, Spring Data JPA, Und Apache Derby-Datenbank .

Java-Karten

Schritt 6: Klick auf das Generieren Taste. Wenn wir auf die Schaltfläche „Generieren“ klicken, wird das Projekt in eine Jar-Datei verpackt und auf das lokale System heruntergeladen.

Schritt 7: Extrahieren Öffnen Sie die Jar-Datei und fügen Sie sie in den STS-Arbeitsbereich ein.

Schritt 8: Importieren den Projektordner in STS.

Datei -> Importieren -> Vorhandene Maven-Projekte -> Durchsuchen -> Wählen Sie den Ordner apache-derby-example -> Fertig stellen

Der Import dauert einige Zeit.

Schritt 9: Erstellen Sie ein Paket mit dem Namen com.javatpoint.model im Ordner src/main/java.

Schritt 10: Erstellen Sie eine Klasse mit dem Namen Benutzerdatensatz im Paket com.javatpoint.model und machen Sie Folgendes:

• Definieren Sie drei Variablen ID, Name, Und Email .
• Generieren Sie Getter und Setter.
  Klicken Sie mit der rechten Maustaste auf die Datei -> Quelle -> Getter und Setter generieren
• Definieren Sie einen Standardkonstruktor.
• Markieren Sie die Klasse als Juristische Person durch Verwendung der Anmerkung @Juristische Person.
• Markieren Ausweis als Primärschlüssel mithilfe der Annotation @Ausweis.

UserRecord.java

 package com.javatpoint.model; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class UserRecord { @Id private int id; private String name; private String email; //default conatructor 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; } } 

Schritt 11: Erstellen Sie ein Paket mit dem Namen com.javatpoint.controller im Ordner src/main/java.

Schritt 12: Erstellen Sie eine Controller-Klasse mit dem Namen BenutzerController im Paket com.javatpoint.controller und machen Sie Folgendes:

• Markieren Sie die Klasse mithilfe der Annotation als Controller @RestController.
• Die Klasse automatisch verkabelt Benutzerservice durch Verwendung der Anmerkung @Autowired .
• Wir haben zwei Zuordnungen definiert, eine für alle Benutzer abrufen und das andere für Benutzer hinzufügen.

UserController.java

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

Schritt 13: Erstellen Sie ein Paket mit dem Namen com.javatpoint.service im Ordner src/main/java.

Schritt 14: Erstellen Sie eine Serviceklasse mit dem Namen Benutzerservice im Paket com.javatpoint.service und machen Sie Folgendes:

• Markieren Sie die Klasse mithilfe der Annotation als Dienst @Service.
• Automatisch verdrahtet UserRepository
• Definieren Sie eine Methode getAllUsers() das gibt eine Liste von zurück
• Definieren Sie einen anderen Methodennamen Benutzer hinzufügen() Dadurch wird der Benutzerdatensatz gespeichert.

UserService.java

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

Schritt 15: Erstellen Sie ein Paket mit dem Namen com.javatpoint.repository im Ordner src/main/java.

Schritt 16: Erstellen Sie eine Repository-Schnittstelle mit dem Namen UserRepository im Paket com.javatpoint.repository und erstreckt sich CrudRepository .

UserRepository.java

 package com.javatpoint.repository; import org.springframework.data.repository.CrudRepository; import com.javatpoint.model.UserRecord; public interface UserRepository extends CrudRepository { } 

Schritt 17: Öffnen Sie nun die ApacheDerbyExampleApplication.java Datei. Es wird standardmäßig erstellt, wenn wir eine Anwendung einrichten.

ApacheDerbyExampleApplication.java

 package com.javatpoint; 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); } } 

Jetzt haben wir alle notwendigen Klassen und Pakete entsprechend den Anforderungen eingerichtet. Beachten Sie, dass wir keine bereitgestellt haben Verbindungs-URL für die Datenbank. Nach Abschluss aller oben genannten Schritte sieht das Projektverzeichnis wie folgt aus:

Lassen Sie uns die Anwendung ausführen.

Schritt 18: Öffne das ApacheDerbyExampleApplication.java Datei und führen Sie sie als Java-Anwendung aus.

Schritt 19: Öffnen Sie den Browser und rufen Sie die URL http://localhost:8080/ auf. Es wird eine leere Liste zurückgegeben, da wir der Liste keinen Benutzer hinzugefügt haben.

Um einen Benutzer zur Datenbank hinzuzufügen, senden wir eine POST Anfrage über die Briefträger .

execvp

Schritt 20: Öffne das Briefträger und machen Sie Folgendes:

• Wähle aus POST
• Rufen Sie die URL http://localhost:8080/add-user auf.
• Klick auf das Körper
• Wählen Sie Inhaltstyp als aus JSON (Anwendung/json).
• Geben Sie die Daten ein, die Sie in die Datenbank einfügen möchten. Wir haben folgende Daten eingefügt:

 { 'id': '001', 'name': 'Tom', 'email': '[email protected]' } 

• Klick auf das Schicken Taste.

Wenn wir auf die Schaltfläche „Senden“ klicken, wird es angezeigt Status: 200 OK . Dies bedeutet, dass die Anfrage erfolgreich ausgeführt wurde.

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