Hvad er JPA?

Spring Boot JPA er en Java-specifikation til administration relationelle data i Java-applikationer. Det giver os mulighed for at få adgang til og bevare data mellem Java-objekt/-klasse og relationsdatabase. JPA følger Objekt-relations kortlægning (ORM). Det er et sæt grænseflader. Det giver også en runtime EntityManager API til behandling af forespørgsler og transaktioner på objekterne mod databasen. Det bruger et platform-uafhængigt objektorienteret forespørgselssprog JPQL (Java Persistent Query Language).

I forbindelse med persistens dækker det tre områder:

• Java Persistence API
Objekt-relationelmetadata
• Selve API'en, defineret i udholdenhed pakke

Den Blandede Parlamentariske Forsamling er ikke en ramme. Det definerer et koncept, der kan implementeres af enhver ramme.

Hvorfor skal vi bruge JPA?

JPA er enklere, renere og mindre arbejdskrævende end JDBC, SQL og håndskrevet kortlægning. JPA er velegnet til ikke-ydelsesorienterede komplekse applikationer. Den største fordel ved JPA frem for JDBC er, at i JPA er data repræsenteret af objekter og klasser, mens data i JDBC er repræsenteret af tabeller og poster. Den bruger POJO til at repræsentere vedvarende data, der forenkler databaseprogrammering. Der er nogle andre fordele ved JPA:

• JPA undgår at skrive DDL på en databasespecifik dialekt af SQL. I stedet for dette tillader det kortlægning i XML eller brug af Java-annoteringer.
• JPA giver os mulighed for at undgå at skrive DML på den databasespecifikke dialekt af SQL.
• JPA giver os mulighed for at gemme og indlæse Java-objekter og -grafer uden noget DML-sprog overhovedet.
• Når vi skal udføre forespørgsler JPQL, giver det os mulighed for at udtrykke forespørgslerne i form af Java-enheder snarere end den (native) SQL-tabel og -kolonner.

JPA funktioner

Der er følgende funktioner i JPA:

• Det er et kraftfuldt lager og brugerdefineret objekt-mapping abstraktion.
• Det understøtter for vedholdenhed på tværs af butikker . Det betyder, at en enhed delvist kan lagres i MySQL og Neo4j (Graph Database Management System).
• Det genererer dynamisk forespørgsler fra forespørgselsmetodenavn.
• Domænebaseklasserne giver grundlæggende egenskaber.
• Det understøtter gennemsigtig revision.
• Mulighed for at integrere tilpasset depotkode.
• Det er nemt at integrere med Spring Framework med det tilpassede navneområde.

JPA arkitektur

JPA er en kilde til at opbevare forretningsenheder som relationelle enheder. Det viser, hvordan man definerer en POJO som en enhed, og hvordan man administrerer enheder med relation.

Følgende figur beskriver JPA's klasseniveauarkitektur, der beskriver JPA's kerneklasser og grænseflader, som er defineret i javax vedholdenhed pakke. JPA-arkitekturen indeholder følgende enheder:

mamta kulkarni skuespiller

Udholdenhed:Det er en klasse, der indeholder statiske metoder til at opnå en EntityManagerFactory-instans.EntityManagerFactory:Det er en fabriksklasse af EntityManager. Det opretter og administrerer flere forekomster af EntityManager.Entity Manager:Det er en grænseflade. Det styrer persistensoperationerne på objekter. Det virker for Query-forekomsten.Enhed:Entiteterne er de persistensobjekter, der lagrer som en post i databasen.Persistensenhed:Den definerer et sæt af alle enhedsklasser. I en applikation administrerer EntityManager-instanser den. Sættet af enhedsklasser repræsenterer de data, der er indeholdt i et enkelt datalager.Enhedstransaktion:Den har en en til en forhold til EntityManager-klassen. For hver EntityManager vedligeholdes operationer af EntityTransaction-klassen.Forespørgsel:Det er en grænseflade, der implementeres af hver JPA-leverandør for at opnå relationsobjekter, der opfylder kriterierne.

JPA klasseforhold

De klasser og grænseflader, som vi har diskuteret ovenfor, opretholder et forhold. Følgende figur viser forholdet mellem klasser og grænseflader.

• Forholdet mellem EntityManager og EntiyTransaction er en til en . Der er en EntityTransaction-instans for hver EntityManager-handling.
• Forholdet mellem EntityManageFactory og EntiyManager er en-til-mange . Det er en fabriksklasse til EntityManager-instansen.
• Forholdet mellem EntityManager og Query er en-til-mange . Vi kan udføre et hvilket som helst antal forespørgsler ved at bruge en forekomst af EntityManager-klassen.
• Forholdet mellem EntityManager og Entity er en-til-mange . En EntityManager-instans kan administrere flere entiteter.

JPA-implementeringer

JPA er en open source API. Der er forskellige virksomhedsleverandører såsom Eclipse, RedHat, Oracle osv., der leverer nye produkter ved at tilføje JPA i dem. Der er nogle populære JPA-implementeringsrammer som f.eks Hibernate, EclipseLink, DataNucleus, osv. Det er også kendt som Objekt-relations kortlægning (ORM) værktøj.

Object-Relation Mapping (ORM)

I ORM kaldes kortlægningen af ​​Java-objekter til databasetabeller og omvendt Objekt-relationel kortlægning. ORM-kortlægningen fungerer som en bro mellem en relationel database (tabeller og optegnelser) og Java-applikation (klasser og objekter).

I den følgende figur er ORM-laget et adapterlag. Det tilpasser sproget for objektgrafer til sproget i SQL og relationstabeller.

ORM-laget eksisterer mellem applikationen og databasen. Det konverterer Java-klasserne og -objekterne, så de kan gemmes og administreres i en relationsdatabase. Som standard bliver det navn, der eksisterer, navnet på tabellen, og felter bliver til kolonner. Når en applikation er konfigureret, svarer hver tabelrække til et objekt.

JPA versioner

Tidligere versioner af EJB definerer persistenslaget kombineret med forretningslogiklaget ved hjælp af javax.ejb.EntityBean Interface. EJB-specifikationen omfatter definitionen af ​​JPA.

Mens EJB 3.0 blev introduceret, blev persistenslaget adskilt og specificeret som JPA 1.0 (Java Persistence API). Specifikationerne for denne API blev frigivet sammen med specifikationerne for JAVA EE5 den 11. maj 2006 ved brug af JSR 220.

I 2019 omdøbte JPA til Jakarta vedholdenhed . Den seneste version af JPA er 2.2 . Det understøtter følgende funktioner:

• Java 8, data og tid API
• CDI-injektion i AttributeConvertes
• Det laver annoteringer @Repeatable

Forskellen mellem JPA og Hibernate

JPA: JPA er en Java-specifikation, der bruges til at få adgang til, administrere og bevare data mellem Java-objekt og relationsdatabase. Det er en standardtilgang for ORM.

Dvale: Det er et let, open source ORM-værktøj, der bruges til at gemme Java-objekter i relationsdatabasesystemet. Det er en udbyder af JPA. Den følger en fælles tilgang fra Den Blandede Parlamentariske Forsamling.

Følgende tabel beskriver forskellene mellem JPA og Hibernate.

Spring Boot Starter Data JPA

Spring Boot giver starter afhængighed spring-boot-starter-data-jpa at forbinde Spring Boot-applikationen med relationel database effektivt. Spring-boot-starter-data-jpa bruger internt spring-boot-jpa-afhængigheden.

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

Spring Boot JPA Eksempel

Lad os oprette et Spring Boot-program, der bruger JPA til at oprette forbindelse til databasen. I det følgende eksempel har vi brugt en in-memory database Apache Derby.

Apache Derby: Det er en open source, indlejret relationel database implementeret udelukkende i Java. Den er tilgængelig under Apache-licensen 2.0. Der er følgende fordele ved Apache Derby:

• Det er nemt at installere, implementere og bruge.
• Det er baseret på Java-, JDBC- og SQL-standarder.
• Det giver en indlejret JDBC-driver, der giver os mulighed for at integrere Derby i enhver Java-baseret løsning.
• Den understøtter også klient/server-tilstand med Derby Network Client JDBC-driveren og Derby Network Server.

Spring Boot kan automatisk konfigurere en indlejret database som f.eks H2, HSQL, og Derbydatabaser . Vi behøver ikke at angive nogen forbindelses-URL'er. Vi behøver kun at inkludere en build-afhængighed af den indlejrede database, som vi ønsker at bruge.

I Spring Boot kan vi nemt integrere Apache Derby-databasen blot ved at tilføje Derby afhængighed i filen pom.xml.

 org.apache.derby derby runtime 

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

Trin 2: Vælg den seneste version af Spring Boot 2.3.0 (SNAPSHOT)

azurblå abonnement

Trin 3: Giv den Gruppe navn. Vi har ydet com.javatpoint.

Trin 4: Giv den Artefakt Id. Vi har ydet apache-derby-eksempel .

Trin 5: Tilføj afhængighederne: Spring Web, Spring Data JPA, og Apache Derby Database .

Trin 6: Klik på Frembringe knap. Når vi klikker på knappen Generer, pakker det projektet ind i en Jar-fil og downloader det til det lokale system.

Trin 7: Udtræk Jar-filen og indsæt den i STS-arbejdsområdet.

Trin 8: Importer projektmappen til STS.

Fil -> Importer -> Eksisterende Maven-projekter -> Gennemse -> Vælg mappen apache-derby-eksempel -> Afslut

Det tager lidt tid at importere.

Trin 9: Opret en pakke med navnet com.javatpoint.model i mappen src/main/java.

Trin 10: Opret en klasse med navnet Brugerrekord i pakken com.javatpoint.model og gør følgende:

• Definer tre variable id, navn, og e-mail .
• Generer Getters og Setter.
  Højreklik på filen -> Kilde -> Generer Getters and Setters
• Definer en standardkonstruktør.
• Marker klassen som en Enhed ved at bruge anmærkningen @Enhed.
• Mærke Id som den primære nøgle ved at bruge annoteringen @Id.

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

Trin 11: Opret en pakke med navnet com.javatpoint.controller i mappen src/main/java.

Trin 12: Opret en Controller-klasse med navnet UserController i pakken com.javatpoint.controller og gør følgende:

• Marker klassen som en controller ved hjælp af annoteringen @RestController.
• Autowired klassen Brugerservice ved at bruge anmærkningen @Autowired .
• Vi har defineret to kortlægninger, en til få alle brugere og den anden for tilføjelsesbruger.

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

Trin 13: Opret en pakke med navnet com.javatpoint.service i mappen src/main/java.

Trin 14: Opret en Service-klasse med navnet Brugerservice i pakken com.javatpoint.service og gør følgende:

• Marker klassen som tjeneste ved hjælp af annoteringen @Service.
• Autowired til UserRepository
• Definer en metode getAllUsers() der returnerer en liste over
• Definer et andet metodenavn addUser() der gemmer brugerregistreringen.

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

Trin 15: Opret en pakke med navnet com.javatpoint.repository i mappen src/main/java.

Trin 16: Opret en lagergrænseflade med navnet UserRepository i pakken com.javatpoint.repository og strækker sig CrudRepository .

gør mens java

UserRepository.java

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

Trin 17: Åbn nu ApacheDerbyExampleApplication.java fil. Det oprettes som standard, når vi konfigurerer en applikation.

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

Nu har vi sat alle de nødvendige klasser og pakker op i henhold til kravene. Bemærk, at vi ikke har givet nogen forbindelses-URL for databasen. Efter at have gennemført alle ovenstående trin, ser projektmappen sådan ud:

Lad os køre programmet.

Trin 18: Åbn ApacheDerbyExampleApplication.java fil og kør den som Java-applikation.

Trin 19: Åbn browseren og kald URL'en http://localhost:8080/. Det returnerer en tom liste, fordi vi ikke har tilføjet nogen bruger på listen.

For at tilføje en bruger til databasen sender vi en STOLPE anmodning ved at bruge Postbud .

Trin 20: Åbn Postbud og gør følgende:

• Vælg STOLPE
• Kald URL'en http://localhost:8080/add-user.
• Klik på Legeme
• Vælg Indholdstype som JSON (applikation/json).
• Indsæt de data, der skal indsættes i databasen. Vi har indsat følgende data:

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

• Klik på Sende knap.

Når vi klikker på Send-knappen, vises det Status: 200 OK . Det betyder, at anmodningen er blevet udført.

Trin 21: Åbn browseren og kald URL'en http://localhost:8080. Det returnerer den bruger, som vi har indsat i databasen.