Kas ir JPA?

Spring Boot JPA ir Java specifikācija pārvaldībai relāciju datus Java lietojumprogrammās. Tas ļauj mums piekļūt un saglabāt datus starp Java objektu/klasi un relāciju datu bāzi. JPA seko Objektu attiecību kartēšana (ORM). Tas ir saskarņu kopums. Tas nodrošina arī izpildlaiku EntityManager API vaicājumu un transakciju apstrādei objektos pret datu bāzi. Tā izmanto no platformas neatkarīgu objektorientētu vaicājumu valodu JPQL (Java Persistent Query Language).

Noturības kontekstā tas aptver trīs jomas:

• Java Persistence API
Objekts-relācijametadati
• Pati API, kas definēta neatlaidība iepakojums

APA nav ietvars. Tas definē koncepciju, ko var īstenot ar jebkuru sistēmu.

Kāpēc mums vajadzētu izmantot JPA?

JPA ir vienkāršāka, tīrāka un mazāk darbietilpīga nekā JDBC, SQL un ar roku rakstīta kartēšana. JPA ir piemērots sarežģītiem lietojumiem, kas nav vērsti uz veiktspēju. Galvenā JPA priekšrocība salīdzinājumā ar JDBC ir tā, ka JPA datus attēlo objekti un klases, savukārt JDBC datus attēlo tabulas un ieraksti. Tas izmanto POJO, lai attēlotu pastāvīgus datus, kas vienkāršo datu bāzes programmēšanu. Ir arī dažas citas JPA priekšrocības:

• JPA izvairās rakstīt DDL datubāzei raksturīgā SQL dialektā. Tā vietā tas ļauj kartēt XML vai izmantot Java anotācijas.
• JPA ļauj mums izvairīties no DML rakstīšanas datubāzei raksturīgajā SQL dialektā.
• JPA ļauj mums saglabāt un ielādēt Java objektus un grafikus bez DML valodas.
• Ja mums ir jāveic vaicājumi JPQL, tas ļauj mums izteikt vaicājumus Java entītiju izteiksmē, nevis (vietējās) SQL tabulas un kolonnu izteiksmē.

JPA funkcijas

Ir šādas JPA funkcijas:

• Tā ir spēcīga krātuve un pielāgota objektu kartēšanas abstrakcija.
• Tas atbalsta par starpveikalu noturība . Tas nozīmē, ka entītiju var daļēji saglabāt MySQL un Neo4j (Graph Database Management System).
• Tas dinamiski ģenerē vaicājumus no vaicājumu metodes nosaukuma.
• Domēna bāzes klases nodrošina pamata īpašības.
• Tā atbalsta pārredzamu auditu.
• Iespēja integrēt pielāgotu repozitorija kodu.
• To ir viegli integrēt ar Spring Framework, izmantojot pielāgoto nosaukumvietu.

JPA arhitektūra

JPA ir avots, lai saglabātu biznesa vienības kā relāciju vienības. Tas parāda, kā definēt POJO kā entītiju un kā pārvaldīt entītijas ar relāciju.

Nākamajā attēlā ir aprakstīta JPA klases līmeņa arhitektūra, kas apraksta JPA galvenās klases un saskarnes, kas definētas javax noturība iepakojums. JPA arhitektūra satur šādas vienības:

Noturība:Tā ir klase, kas satur statiskas metodes EntityManagerFactory instances iegūšanai.EntityManagerFactory:Tā ir EntityManager rūpnīcas klase. Tas izveido un pārvalda vairākus EntityManager gadījumus.EntityManager:Tā ir saskarne. Tas kontrolē noturības darbības objektos. Tas darbojas vaicājuma instancē.Vienība:Entītijas ir noturības objekti, kas tiek saglabāti kā ieraksts datu bāzē.Noturības vienība:Tas definē visu entītiju klašu kopu. Lietojumprogrammā EntityManager gadījumi to pārvalda. Entītiju klašu kopa attēlo datus, kas atrodas vienā datu krātuvē.EntityTransaction:Tam ir a viens pret vienu attiecības ar EntityManager klasi. Katrai EntityManager operācijas uztur EntityTransaction klase.Vaicājums:Tā ir saskarne, ko ievieš katrs JPA piegādātājs, lai iegūtu kritērijiem atbilstošus relāciju objektus.

JPA klases attiecības

Klases un saskarnes, par kurām mēs runājām iepriekš, uztur attiecības. Nākamajā attēlā parādītas attiecības starp klasēm un saskarnēm.

• Attiecības starp EntityManager un EntiyTransaction ir viens pret vienu . Katrai EntityManager darbībai ir EntityTransaction instance.
• Attiecības starp EntityManageFactory un EntiyManager ir viens pret daudziem . Tā ir EntityManager instances rūpnīcas klase.
• Attiecības starp EntityManager un Query ir viens pret daudziem . Mēs varam izpildīt neierobežotu skaitu vaicājumu, izmantojot EntityManager klases gadījumu.
• Attiecības starp EntityManager un Entity ir viens pret daudziem . EntityManager instance var pārvaldīt vairākas entītijas.

APA īstenošana

JPA ir atvērtā koda API. Ir dažādi uzņēmumu pārdevēji, piemēram, Eclipse, RedHat, Oracle uc, kas nodrošina jaunus produktus, pievienojot tiem JPA. Ir dažas populāras JPA ieviešanas sistēmas, piemēram Hibernate, EclipseLink, DataNucleus, utt. To sauc arī par Objektu attiecību kartēšana (ORM) rīks.

Objektu attiecību kartēšana (ORM)

ORM tiek izsaukta Java objektu kartēšana datu bāzes tabulām un otrādi Objektu relāciju kartēšana. ORM kartēšana darbojas kā tilts starp a relāciju datu bāze (tabulas un ieraksti) un Java lietojumprogramma (klases un objekti).

Nākamajā attēlā ORM slānis ir adaptera slānis. Tā pielāgo objektu grafiku valodu SQL un relāciju tabulu valodai.

ORM slānis pastāv starp lietojumprogrammu un datu bāzi. Tas pārveido Java klases un objektus, lai tos varētu uzglabāt un pārvaldīt relāciju datu bāzē. Pēc noklusējuma nosaukums, kas saglabājas, kļūst par tabulas nosaukumu, un lauki kļūst par kolonnām. Kad lietojumprogramma ir iestatīta, katra tabulas rinda atbilst objektam.

JPA versijas

Iepriekšējās EJB versijas definē noturības slāni apvienojumā ar biznesa loģikas slāni, izmantojot javax.ejb.EntityBean Interfeiss. EJB specifikācijā ir iekļauta JPA definīcija.

Ieviešot EJB 3.0, noturības slānis tika atdalīts un norādīts kā JPA 1.0 (Java Persistence API). Šīs API specifikācijas tika izlaistas kopā ar JAVA EE5 specifikācijām 2006. gada 11. maijā, izmantojot JSR 220.

2019. gadā JPA tika pārdēvēta par Džakartas neatlaidība . Jaunākā JPA versija ir 2.2 . Tā atbalsta šādas funkcijas:

• Java 8, datu un laika API
• CDI injekcija pakalpojumā AttributeConvertes
• Tas padara anotācijas @Repeatable

Atšķirība starp JPA un Hibernate

JPA: JPA ir Java specifikācija, ko izmanto, lai piekļūtu datiem, pārvaldītu un saglabātu tos starp Java objektu un relāciju datu bāzi. Tā ir standarta pieeja ORM.

Hibernēt: Tas ir viegls, atvērtā koda ORM rīks, ko izmanto Java objektu glabāšanai relāciju datu bāzes sistēmā. Tas ir JPA nodrošinātājs. Tas atbilst kopējai APA nodrošinātajai pieejai.

Šajā tabulā ir aprakstītas atšķirības starp JPA un Hibernate.

Spring Boot Starter Data JPA

Spring Boot nodrošina startera atkarību spring-boot-starter-data-jpa lai efektīvi savienotu Spring Boot lietojumprogrammu ar relāciju datu bāzi. Spring-boot-starter-data-jpa iekšēji izmanto atkarību spring-boot-jpa.

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

Spring Boot JPA piemērs

Izveidosim Spring Boot lietojumprogrammu, kas izmanto JPA, lai izveidotu savienojumu ar datu bāzi. Nākamajā piemērā mēs esam izmantojuši atmiņā esošo datu bāzi Apache Derbijs.

Apache Derby: Tas ir an atvērtā koda, iegultā relāciju datu bāze, kas pilnībā ieviesta Java. Tas ir pieejams saskaņā ar Apache licenci 2.0. Apache Derby ir šādas priekšrocības:

• To ir viegli uzstādīt, izvietot un lietot.
• Tas ir balstīts uz Java, JDBC un SQL standartiem.
• Tas nodrošina iegultu JDBC draiveri, kas ļauj mums iegult Derby jebkurā uz Java balstītā risinājumā.
• Tā atbalsta arī klienta/servera režīmu ar Derby Network Client JDBC draiveri un Derby Network Server.

Spring Boot var automātiski konfigurēt iegulto datu bāzi, piemēram, H2, HSQL, un Derbiju datu bāzes . Mums nav jānorāda nekādi savienojuma URL. Mums ir jāiekļauj tikai izveides atkarība no iegultās datu bāzes, kuru vēlamies izmantot.

Programmā Spring Boot mēs varam viegli integrēt Apache Derby datu bāzi, vienkārši pievienojot Derbijs atkarība pom.xml failā.

 org.apache.derby derby runtime 

1. darbība: Atveriet pavasara inicializāciju https://start.spring.io/ .

2. darbība: Atlasiet jaunāko Spring Boot versiju 2.3.0 (momentuzņēmums)

3. darbība: Nodrošiniet Grupa nosaukums. Mēs esam nodrošinājuši com.javatpoint.

4. darbība: Nodrošiniet Artefakts Id. Mēs esam nodrošinājuši apache-derby-example .

5. darbība: Pievienojiet atkarības: Spring Web, Spring Data JPA, un Apache Derby datu bāze .

6. darbība: Noklikšķiniet uz Ģenerēt pogu. Kad mēs noklikšķinām uz pogas Ģenerēt, tas iesaiņo projektu Jar failā un lejupielādē to vietējā sistēmā.

7. darbība: ekstrakts Jar failu un ielīmējiet to STS darbvietā.

8. darbība: importēšana projekta mapi STS.

Fails -> Importēt -> Esošie Maven projekti -> Pārlūkot -> Atlasiet mapi apache-derby-example -> Pabeigt

Importēšanai nepieciešams zināms laiks.

9. darbība: Izveidojiet paketi ar nosaukumu com.javatpoint.model mapē src/main/java.

10. darbība: Izveidojiet klasi ar nosaukumu UserRecord iepakojumā com.javatpoint.model un rīkojieties šādi:

• Definējiet trīs mainīgos id, vārds, un e-pasts .
• Ģenerējiet Getterus un Seterus.
  Ar peles labo pogu noklikšķiniet uz faila -> Avots -> Ģenerēt ieguvējus un iestatītājus
• Definējiet noklusējuma konstruktoru.
• Atzīmēt klasi kā an Vienība izmantojot anotāciju @Entity.
• Atzīmēt Id kā primāro atslēgu, izmantojot anotāciju @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; } } 

11. darbība: Izveidojiet paketi ar nosaukumu com.javatpoint.controller mapē src/main/java.

12. darbība: Izveidojiet kontroliera klasi ar nosaukumu UserController iepakojumā com.javatpoint.controller un rīkojieties šādi:

• Atzīmējiet klasi kā kontrolieri, izmantojot anotāciju @RestController.
• Automātiski pieslēdza klasi UserService izmantojot anotāciju @Autowired .
• Mēs esam definējuši divus kartējumus, vienu priekš iegūt visus lietotājus un otrs par pievienot lietotāju.

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

13. darbība: Izveidojiet paketi ar nosaukumu com.javatpoint.service mapē src/main/java.

14. darbība: Izveidojiet pakalpojumu klasi ar nosaukumu UserService iepakojumā com.javatpoint.service un rīkojieties šādi:

karte java

• Atzīmējiet klasi kā pakalpojumu, izmantojot anotāciju @Apkalpošana.
• Automātiski pieslēgts UserRepository
• Definējiet metodi getAllUsers() kas atgriež sarakstu ar
• Definējiet citu metodes nosaukumu addUser() kas saglabā lietotāja ierakstu.

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

15. darbība: Izveidojiet paketi ar nosaukumu com.javatpoint.repository mapē src/main/java.

16. darbība: Izveidojiet repozitorija saskarni ar nosaukumu UserRepository iepakojumā com.javatpoint.repository un pagarina CrudRepository .

UserRepository.java

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

17. darbība: Tagad atveriet ApacheDerbyExampleApplication.java failu. Tas tika izveidots pēc noklusējuma, kad mēs iestatām lietojumprogrammu.

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

Tagad mēs esam izveidojuši visas nepieciešamās klases un paketes atbilstoši prasībām. Ņemiet vērā, ka mēs to neesam nodrošinājuši savienojuma URL datu bāzei. Pēc visu iepriekš minēto darbību veikšanas projekta direktorijs izskatās šādi:

Palaidīsim lietojumprogrammu.

18. darbība: Atveriet ApacheDerbyExampleApplication.java failu un palaidiet to kā Java lietojumprogrammu.

19. darbība: Atveriet pārlūkprogrammu un izsauciet URL http://localhost:8080/. Tas atgriež tukšu sarakstu, jo mēs sarakstā neesam pievienojuši nevienu lietotāju.

Lai datubāzei pievienotu lietotāju, mēs nosūtīsim a POSTĪT pieprasīt, izmantojot Pastnieks .

20. darbība: Atveriet Pastnieks un rīkojieties šādi:

• Izvēlieties POSTĪT
• Izsauciet URL http://localhost:8080/add-user.
• Noklikšķiniet uz Ķermenis
• Atlasiet Satura veids kā JSON (lietojumprogramma/json).
• Ievietojiet datubāzē datus, kurus vēlaties ievietot. Mēs esam ievietojuši šādus datus:

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

• Noklikšķiniet uz Sūtīt pogu.

Kad mēs noklikšķinām uz pogas Sūtīt, tas tiek parādīts Statuss: 200 OK . Tas nozīmē, ka pieprasījums ir veiksmīgi izpildīts.

21. darbība: Atveriet pārlūkprogrammu un izsauciet URL http://localhost:8080. Tas atgriež lietotāju, kuru esam ievietojuši datu bāzē.