Wat is JPA?

Lentelaars JPA is een Java-specificatie voor beheer relationeel gegevens in Java-applicaties. Het stelt ons in staat om toegang te krijgen tot gegevens tussen Java-objecten/-klassen en relationele databases en deze te bewaren. PPV volgt Object-relatie mapping (ORM). Het is een reeks interfaces. Het biedt ook een looptijd Entiteitsmanager API voor het verwerken van zoekopdrachten en transacties op de objecten in de database. Het maakt gebruik van een platformonafhankelijke objectgeoriënteerde querytaal JPQL (Java Persistent Query Language).

In de context van volharding bestrijkt het drie gebieden:

• De Java Persistence-API
Object-relationeelmetagegevens
• De API zelf, gedefinieerd in de vasthoudendheid pakket

De PPV is geen raamwerk. Het definieert een concept dat door elk raamwerk kan worden geïmplementeerd.

Waarom zouden we PPV gebruiken?

JPA is eenvoudiger, schoner en minder arbeidsintensief dan JDBC, SQL en handgeschreven mapping. JPA is geschikt voor niet-prestatiegerichte complexe toepassingen. Het belangrijkste voordeel van JPA ten opzichte van JDBC is dat gegevens in JPA worden weergegeven door objecten en klassen, terwijl gegevens in JDBC worden weergegeven door tabellen en records. Het gebruikt POJO om persistente gegevens weer te geven die het programmeren van databases vereenvoudigen. Er zijn nog enkele andere voordelen van JPA:

selenium tutorial

• JPA vermijdt het schrijven van DDL in een databasespecifiek SQL-dialect. In plaats daarvan zijn mapping in XML of het gebruik van Java-annotaties mogelijk.
• Met JPA kunnen we voorkomen dat DML in het databasespecifieke dialect van SQL wordt geschreven.
• Met JPA kunnen we Java-objecten en grafieken opslaan en laden zonder enige DML-taal.
• Wanneer we JPQL-query's moeten uitvoeren, kunnen we de query's uitdrukken in termen van Java-entiteiten in plaats van in de (native) SQL-tabel en -kolommen.

JPA-functies

Er zijn de volgende kenmerken van JPA:

• Het is een krachtige opslagplaats en maatwerk object-mapping abstractie.
• Het ondersteunt voor persistentie tussen winkels . Het betekent dat een entiteit gedeeltelijk kan worden opgeslagen in MySQL en Neo4j (Graph Database Management System).
• Het genereert dynamisch query's op basis van de naam van de querymethode.
• De domeinbasisklassen bieden basiseigenschappen.
• Het ondersteunt transparante auditing.
• Mogelijkheid om aangepaste repositorycode te integreren.
• Het is eenvoudig te integreren met Spring Framework met de aangepaste naamruimte.

JPA-architectuur

JPA is een bron om bedrijfsentiteiten op te slaan als relationele entiteiten. Het laat zien hoe u een POJO als entiteit kunt definiëren en hoe u entiteiten met relaties kunt beheren.

De volgende afbeelding beschrijft de architectuur op klasseniveau van JPA die de kernklassen en interfaces van JPA beschrijft die zijn gedefinieerd in de Javax-persistentie pakket. De JPA-architectuur bevat de volgende eenheden:

Vasthoudendheid:Het is een klasse die statische methoden bevat om een ​​EntityManagerFactory-instantie te verkrijgen.EntityManagerFactory:Het is een fabrieksklasse van EntityManager. Het creëert en beheert meerdere exemplaren van EntityManager.Entiteitsmanager:Het is een interface. Het bestuurt de persistentiebewerkingen op objecten. Het werkt voor de Query-instantie.Entiteit:De entiteiten zijn de persistentieobjecten die als record in de database zijn opgeslagen.Persistentie-eenheid:Het definieert een set van alle entiteitsklassen. In een applicatie beheren EntityManager-instanties deze. De set entiteitsklassen vertegenwoordigt de gegevens die zich in één enkele gegevensopslag bevinden.EntiteitTransactie:Het heeft een een op een relatie met de klasse EntityManager. Voor elke EntityManager worden bewerkingen onderhouden door de EntityTransaction-klasse.Vraag:Het is een interface die door elke JPA-leverancier wordt geïmplementeerd om relatieobjecten te verkrijgen die aan de criteria voldoen.

JPA-klasserelaties

De klassen en interfaces die we hierboven hebben besproken, onderhouden een relatie. De volgende afbeelding toont de relatie tussen klassen en interfaces.

• De relatie tussen EntityManager en EntiyTransaction is een op een . Er is een EntityTransaction-instantie voor elke EntityManager-bewerking.
• De relatie tussen EntityManageFactory en EntiyManager is een te veel . Het is een fabrieksklasse voor de EntityManager-instantie.
• De relatie tussen EntityManager en Query is een te veel . We kunnen een willekeurig aantal query's uitvoeren met behulp van een exemplaar van de EntityManager-klasse.
• De relatie tussen EntityManager en Entity is een te veel . Een EntityManager-instantie kan meerdere entiteiten beheren.

PPA-implementaties

JPA is een opensource-API. Er zijn verschillende zakelijke leveranciers zoals Eclipse, RedHat, Oracle, enz. die nieuwe producten leveren door de JPA eraan toe te voegen. Er zijn enkele populaire JPA-implementatieframeworks zoals Slaapstand, EclipseLink, DataNucleus, enz. Het is ook bekend als Object-relatie mapping (ORM)-tool.

Object-relatie mapping (ORM)

In ORM wordt de toewijzing van Java-objecten aan databasetabellen en omgekeerd aangeroepen Object-relationele mapping. De ORM-mapping werkt als een brug tussen a relationele database (tabellen en records) en Java-applicatie (klassen en objecten).

In de volgende afbeelding is de ORM-laag een adapterlaag. Het past de taal van objectgrafieken aan de taal van SQL en relatietabellen aan.

De ORM-laag bestaat tussen de applicatie en de database. Het converteert de Java-klassen en objecten zodat ze kunnen worden opgeslagen en beheerd in een relationele database. Standaard wordt de naam die blijft bestaan ​​de naam van de tabel en worden velden kolommen. Zodra een applicatie is ingesteld, komt elke tabelrij overeen met een object.

JPA-versies

Eerdere versies van EJB definieerden de persistentielaag in combinatie met de bedrijfslogicalaag met behulp van javax.ejb.EntityBean Koppel. De EJB-specificatie omvat de definitie van JPA.

Bij de introductie van EJB 3.0 werd de persistentielaag gescheiden en gespecificeerd als JPA 1.0 (Java Persistence API). De specificaties van deze API zijn op 11 mei 2006 samen met de specificaties van JAVA EE5 vrijgegeven, met behulp van JSR 220.

In 2019 werd de PPV omgedoopt tot Jakarta volharding . De nieuwste versie van JPA is 2.2 . Het ondersteunt de volgende functies:

• Java 8, data- en tijd-API
• CDI-injectie in AttributeConvertes
• Het maakt annotaties @Repeatable

Verschil tussen JPA en Hibernate

PPV: JPA is een Java-specificatie die wordt gebruikt voor het openen, beheren en bewaren van gegevens tussen het Java-object en de relationele database. Het is een standaardaanpak voor ORM.

Slaapstand: Het is een lichtgewicht, open-source ORM-tool die wordt gebruikt om Java-objecten op te slaan in het relationele databasesysteem. Het is een aanbieder van JPA. Het volgt een gemeenschappelijke aanpak van de PPV.

De volgende tabel beschrijft de verschillen tussen JPA en Hibernate.

Spring Boot Startergegevens JPA

Spring Boot biedt starterafhankelijkheid spring-boot-starter-data-jpa om de Spring Boot-applicatie efficiënt te verbinden met een relationele database. De spring-boot-starter-data-jpa maakt intern gebruik van de spring-boot-jpa-afhankelijkheid.

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

Spring Boot JPA-voorbeeld

Laten we een Spring Boot-applicatie maken die JPA gebruikt om verbinding te maken met de database. In het volgende voorbeeld hebben we een in-memory database gebruikt Apache-derby.

arraylist java sorteren

Apache-derby: Het is een open source, ingebed relationele database volledig geïmplementeerd in Java. Het is beschikbaar onder de Apache-licentie 2.0. Er zijn de volgende voordelen van Apache Derby:

• Het is eenvoudig te installeren, implementeren en gebruiken.
• Het is gebaseerd op Java-, JDBC- en SQL-standaarden.
• Het biedt een ingebouwde JDBC-driver waarmee we Derby in elke Java-gebaseerde oplossing kunnen insluiten.
• Het ondersteunt ook de client/server-modus met het Derby Network Client JDBC-stuurprogramma en Derby Network Server.

Spring Boot kan een ingebedde database zoals H2, HSQL, En Derbydatabases . We hoeven geen verbindings-URL's op te geven. We hoeven alleen een build-afhankelijkheid op te nemen van de ingebedde database die we willen gebruiken.

In Spring Boot kunnen we de Apache Derby-database eenvoudig integreren door simpelweg toe te voegen Derby afhankelijkheid in pom.xml-bestand.

 org.apache.derby derby runtime 

Stap 1: Open Spring Initializr https://start.spring.io/ .

Stap 2: Selecteer de nieuwste versie van Spring Boot 2.3.0(MOMENTOPNAME)

Stap 3: Lever de Groep naam. Wij hebben voorzien com.javatpoint.

Stap 4: Lever de Artefact ID kaart. Wij hebben voorzien apache-derby-voorbeeld .

Stap 5: Voeg de afhankelijkheden toe: Spring Web, Spring Data PPV, En Apache Derby-database .

doe terwijl java

Stap 6: Klik op de Genereer knop. Wanneer we op de knop Genereren klikken, wordt het project in een Jar-bestand verpakt en naar het lokale systeem gedownload.

Stap 7: Uitpakken het Jar-bestand en plak het in de STS-werkruimte.

Stap 8: Importeren de projectmap in STS.

Bestand -> Importeren -> Bestaande Maven-projecten -> Bladeren -> Selecteer de map apache-derby-example -> Voltooien

Het importeren duurt enige tijd.

Stap 9: Maak een pakket met de naam com.javatpoint.model in de map src/main/java.

Stap 10: Maak een klasse met de naam Gebruikersrecord in het pakket com.javatpoint.model en doe het volgende:

• Definieer drie variabelen identiteitsbewijs, naam, En e-mail .
• Genereer Getters en Setter.
  Klik met de rechtermuisknop op het bestand -> Bron -> Getters en Setters genereren
• Definieer een standaardconstructor.
• Markeer de klasse als een Entiteit door gebruik te maken van de annotatie @Entiteit.
• Markering ID kaart als de primaire sleutel met behulp van de annotatie @ID kaart.

Gebruikersrecord.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; } } 

Stap 11: Maak een pakket met de naam com.javatpoint.controller in de map src/main/java.

Stap 12: Maak een Controller-klasse met de naam GebruikerController in het pakket com.javatpoint.controller en doe het volgende:

• Markeer de klasse als controller met behulp van de annotatie @RestController.
• De klas automatisch bedraad GebruikersService door gebruik te maken van de annotatie @Autobedraad .
• We hebben twee toewijzingen gedefinieerd, één voor alle gebruikers krijgen en de andere voor Voeg gebruiker toe.

UserController.java

panda smelt

 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); } } 

Stap 13: Maak een pakket met de naam com.javatpoint.service in de map src/main/java.

Stap 14: Maak een Serviceklasse met de naam GebruikersService in het pakket com.javatpoint.service en doe het volgende:

• Markeer de klasse als service met behulp van de annotatie @Dienst.
• Autowired de GebruikersRepository
• Definieer een methode getAllUsers() dat een Lijst van retourneert
• Definieer een andere methodenaam Voeg gebruiker toe() waarmee het gebruikersrecord wordt opgeslagen.

GebruikersService.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); } } 

Stap 15: Maak een pakket met de naam com.javatpoint.repository in de map src/main/java.

Stap 16: Maak een repositoryinterface met de naam GebruikersRepository in het pakket com.javatpoint.repository en verlengt CrudRepository .

GebruikersRepository.java

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

Stap 17: Open nu de ApacheDerbyExampleApplication.java bestand. Het wordt standaard aangemaakt wanneer we een applicatie opzetten.

ApacheDerbyExampleApplication.java

javascript if-instructie

 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); } } 

Nu hebben we alle benodigde lessen en pakketten samengesteld volgens de vereisten. Merk op dat we er geen hebben verstrekt verbindings-URL voor de databank. Nadat alle bovenstaande stappen zijn voltooid, ziet de projectmap er als volgt uit:

Laten we de applicatie uitvoeren.

Stap 18: Open de ApacheDerbyExampleApplication.java bestand en voer het uit als Java-toepassing.

Stap 19: Open de browser en roep de URL http://localhost:8080/ op. Het retourneert een lege lijst omdat we geen enkele gebruiker aan de lijst hebben toegevoegd.

Om een ​​gebruiker aan de database toe te voegen, sturen wij een NA aanvragen via de Postbode .

Stap 20: Open de Postbode en doe het volgende:

• Selecteer de NA
• Roep de URL http://localhost:8080/add-user aan.
• Klik op de Lichaam
• Selecteer Inhoudstype als JSON (applicatie/json).
• Voer de gegevens in die u in de database wilt invoegen. Wij hebben de volgende gegevens ingevoerd:

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

• Klik op de Versturen knop.

Wanneer we op de knop Verzenden klikken, wordt deze weergegeven Status: 200 OK . Het betekent dat het verzoek met succes is uitgevoerd.

Stap 21: Open de browser en roep de URL http://localhost:8080 op. Het retourneert de gebruiker die we in de database hebben ingevoegd.