Ce este JPA?

Spring Boot JPA este o specificație Java pentru administrare relaționale date în aplicațiile Java. Ne permite să accesăm și să păstrăm date între obiectul/clasa Java și baza de date relațională. Urmează JPA Maparea relației obiect (ORM). Este un set de interfețe. De asemenea, oferă un timp de rulare EntityManager API pentru procesarea interogărilor și tranzacțiilor asupra obiectelor în baza de date. Utilizează un limbaj de interogare orientat pe obiecte independent de platformă JPQL (Java Persistent Query Language).

În contextul persistenței, acesta acoperă trei domenii:

• API-ul Java Persistence
Obiect-relaționalmetadate
• API-ul în sine, definit în persistenţă pachet

JPA nu este un cadru. Acesta definește un concept care poate fi implementat de orice cadru.

De ce ar trebui să folosim JPA?

JPA este mai simplu, mai curat și mai puțin laborios decât JDBC, SQL și maparea scrisă de mână. JPA este potrivit pentru aplicații complexe orientate spre non-performanță. Principalul avantaj al JPA față de JDBC este că, în JPA, datele sunt reprezentate de obiecte și clase, în timp ce în JDBC datele sunt reprezentate de tabele și înregistrări. Utilizează POJO pentru a reprezenta date persistente care simplifică programarea bazei de date. Există și alte avantaje ale JPA:

• JPA evită scrierea DDL într-un dialect SQL specific bazei de date. În loc de aceasta, permite maparea în XML sau utilizarea adnotărilor Java.
• JPA ne permite să evităm să scriem DML în dialectul SQL specific bazei de date.
• JPA ne permite să salvăm și să încărcăm obiecte și grafice Java fără nici un limbaj DML.
• Când trebuie să facem interogări JPQL, ne permite să exprimăm interogările în termeni de entități Java, mai degrabă decât tabelul și coloanele SQL (native).

Caracteristici JPA

Există următoarele caracteristici ale JPA:

• Este un depozit puternic și personalizat abstractizarea cartografierii obiectelor.
• Susține pt persistența între depozite . Înseamnă că o entitate poate fi stocată parțial în MySQL și Neo4j (Graph Database Management System).
• Acesta generează dinamic interogări din numele metodelor de interogare.
• Clasele de bază ale domeniului oferă proprietăți de bază.
• Susține auditarea transparentă.
• Posibilitatea de a integra cod de depozit personalizat.
• Este ușor de integrat cu Spring Framework cu spațiul de nume personalizat.

Arhitectura JPA

JPA este o sursă de stocare a entităților de afaceri ca entități relaționale. Acesta arată cum să definiți un POJO ca entitate și cum să gestionați entitățile cu relație.

Următoarea figură descrie arhitectura la nivel de clasă a JPA care descrie clasele și interfețele de bază ale JPA care sunt definite în persistența javax pachet. Arhitectura JPA conține următoarele unități:

Persistenţă:Este o clasă care conține metode statice pentru a obține o instanță EntityManagerFactory.EntityManagerFactory:Este o clasă din fabrică a EntityManager. Acesta creează și gestionează mai multe instanțe ale EntityManager.EntityManager:Este o interfață. Controlează operațiunile de persistență asupra obiectelor. Funcționează pentru instanța de interogare.Entitate:Entitățile sunt obiectele de persistență stocate ca înregistrare în baza de date.Unitate de persistență:Acesta definește un set de toate clasele de entități. Într-o aplicație, instanțele EntityManager o gestionează. Setul de clase de entități reprezintă datele conținute într-un singur depozit de date.EntityTransaction:Are o unu la unu relația cu clasa EntityManager. Pentru fiecare EntityManager, operațiunile sunt menținute de clasa EntityTransaction.Interogare:Este o interfață care este implementată de fiecare furnizor JPA pentru a obține obiecte de relație care îndeplinesc criteriile.

Relații de clasă JPA

Clasele și interfețele despre care am discutat mai sus mențin o relație. Figura următoare arată relația dintre clase și interfețe.

• Relația dintre EntityManager și EntiyTransaction este unu la unu . Există o instanță EntityTransaction pentru fiecare operație EntityManager.
• Relația dintre EntityManageFactory și EntiyManager este unu-la-multi . Este o clasă din fabrică pentru instanța EntityManager.
• Relația dintre EntityManager și Query este unu-la-multi . Putem executa orice număr de interogări folosind o instanță a clasei EntityManager.
• Relația dintre EntityManager și Entity este unu-la-multi . O instanță EntityManager poate gestiona mai multe entități.

Implementări JPA

JPA este un API open-source. Există diverși furnizori de întreprinderi, cum ar fi Eclipse, RedHat, Oracle etc., care oferă produse noi prin adăugarea JPA în ele. Există câteva cadre populare de implementare JPA, cum ar fi Hibernare, EclipseLink, DataNucleus, etc Este cunoscut și ca Maparea relației obiect instrument (ORM).

Maparea relației obiect (ORM)

În ORM, se apelează maparea obiectelor Java la tabelele bazei de date și viceversa Maparea obiect-relațională. Maparea ORM funcționează ca o punte între a baza de date relationala (tabele și înregistrări) și aplicație Java (clase și obiecte).

În figura următoare, stratul ORM este un strat adaptor. Acesta adaptează limbajul graficelor obiect la limbajul SQL și a tabelelor de relații.

Stratul ORM există între aplicație și baza de date. Acesta convertește clasele și obiectele Java, astfel încât acestea să poată fi stocate și gestionate într-o bază de date relațională. În mod implicit, numele care persistă devine numele tabelului, iar câmpurile devin coloane. Odată ce o aplicație este configurată, fiecare rând de tabel corespunde unui obiect.

Versiuni JPA

Versiunile anterioare ale EJB definesc stratul de persistență combinat cu stratul logic de afaceri folosind javax.ejb.EntityBean Interfață. Specificația EJB include definiția JPA.

În timpul introducerii EJB 3.0, stratul de persistență a fost separat și specificat ca JPA 1.0 (Java Persistence API). Specificațiile acestui API au fost lansate împreună cu specificațiile JAVA EE5 pe 11 mai 2006, folosind JSR 220.

În 2019, JPA a redenumit în Jakarta Persistență . Cea mai recentă versiune a JPA este 2.2 . Acesta acceptă următoarele caracteristici:

• Java 8, API de date și timp
• Injecție CDI în AttributeConvertes
• Face adnotări @Repeatable

Diferența dintre JPA și Hibernate

JPA: JPA este o specificație Java care este utilizată pentru a accesa, gestiona și persiste date între obiectul Java și baza de date relațională. Este o abordare standard pentru ORM.

Hibernare: Este un instrument ORM ușor, open-source, care este utilizat pentru a stoca obiecte Java în sistemul de baze de date relaționale. Este un furnizor de JPA. Urmează o abordare comună oferită de JPA.

Următorul tabel descrie diferențele dintre JPA și Hibernate.

Spring Boot Starter Data JPA

Spring Boot oferă dependență de pornire Spring-boot-starter-data-jpa pentru a conecta eficient aplicația Spring Boot cu baza de date relațională. Spring-boot-starter-data-jpa utilizează intern dependența spring-boot-jpa.

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

Exemplu JPA Spring Boot

Să creăm o aplicație Spring Boot care folosește JPA pentru a se conecta la baza de date. În exemplul următor, am folosit baza de date în memorie Apache Derby.

șir în numere întregi

Apache Derby: Este un open-source, încorporat bază de date relațională implementată în întregime în Java. Este disponibil sub licența Apache 2.0. Există următoarele avantaje ale Apache Derby:

• Este ușor de instalat, implementat și utilizat.
• Se bazează pe standardele Java, JDBC și SQL.
• Oferă un driver JDBC încorporat care ne permite să încorporam Derby în orice soluție bazată pe Java.
• De asemenea, acceptă modul client/server cu driverul JDBC Derby Network Client și Derby Network Server.

Spring Boot poate configura automat o bază de date încorporată, cum ar fi H2, HSQL, și Baze de date Derby . Nu este necesar să furnizăm niciun URL de conexiune. Trebuie doar să includem o dependență de construcție pe baza de date încorporată pe care dorim să o folosim.

În Spring Boot, putem integra cu ușurință baza de date Apache Derby doar adăugând Derby dependență în fișierul pom.xml.

 org.apache.derby derby runtime 

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

Pasul 2: Selectați cea mai recentă versiune de Spring Boot 2.3.0 (INSTANTANĂ)

Pasul 3: Furnizați grup Nume. Noi am asigurat com.javatpoint.

Pasul 4: Furnizați Artefact Id. Noi am asigurat apache-derby-exemplu .

Pasul 5: Adăugați dependențele: Spring Web, Spring Data JPA, și Baza de date Apache Derby .

Pasul 6: Faceți clic pe Genera buton. Când facem clic pe butonul Generare, acesta înfășoară proiectul într-un fișier Jar și îl descarcă în sistemul local.

matrice java

Pasul 7: Extrageți fișierul Jar și inserați-l în spațiul de lucru STS.

Pasul 8: Import folderul de proiect în STS.

Fișier -> Import -> Proiecte Maven existente -> Răsfoiți -> Selectați folderul apache-derby-example -> Terminați

Este nevoie de ceva timp pentru a importa.

Pasul 9: Creați un pachet cu numele com.javatpoint.model în dosar src/main/java.

Pasul 10: Creați o clasă cu numele Înregistrare utilizator in pachet com.javatpoint.model și faceți următoarele:

• Definiți trei variabile id, nume, și e-mail .
• Generați Getters și Setter.
  Faceți clic dreapta pe fișier -> Source -> Generate Getters and Setters
• Definiți un constructor implicit.
• Marcați clasa ca un Entitate prin utilizarea adnotării @Entitate.
• marcă Id ca cheie primară folosind adnotarea @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; } } 

Pasul 11: Creați un pachet cu numele com.javatpoint.controller în dosar src/main/java.

Pasul 12: Creați o clasă Controller cu numele UserController in pachet com.javatpoint.controller și faceți următoarele:

• Marcați clasa ca controler folosind adnotarea @RestController.
• A conectat automat clasa Serviciu utilizator prin utilizarea adnotării @Cablat automat .
• Am definit două mapări, una pentru obținerea tuturor utilizatorilor iar celălalt pentru Adăugați utilizator.

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

Pasul 13: Creați un pachet cu numele com.javatpoint.service în dosar src/main/java.

Pasul 14: Creați o clasă de servicii cu numele Serviciu utilizator in pachet com.javatpoint.service și faceți următoarele:

• Marcați clasa ca serviciu utilizând adnotarea @Serviciu.
• Cablat automat UserRepository
• Definiți o metodă getAllUsers() care returnează o listă de
• Definiți un alt nume de metodă Adăugați utilizator() care salvează înregistrarea utilizatorului.

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

Pasul 15: Creați un pachet cu numele com.javatpoint.repository în dosar src/main/java.

Pasul 16: Creați o interfață de depozit cu numele UserRepository in pachet com.javatpoint.repository și se extinde CrudRepository .

UserRepository.java

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

Pasul 17: Acum, deschideți ApacheDerbyExampleApplication.java fişier. Este creat în mod implicit atunci când setăm o aplicație.

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

Acum, am configurat toate clasele și pachetele necesare conform cerințelor. Observați că nu am furnizat niciunul URL de conexiune pentru baza de date. După parcurgerea tuturor pașilor de mai sus, directorul proiectului arată astfel:

Să rulăm aplicația.

Pasul 18: Deschide ApacheDerbyExampleApplication.java fișier și rulați-l ca aplicație Java.

Pasul 19: Deschideți browserul și invocați adresa URL http://localhost:8080/. Returnează o listă goală deoarece nu am adăugat niciun utilizator în listă.

Pentru a adăuga un utilizator la baza de date, vom trimite un POST cerere prin utilizarea Poştaş .

Pasul 20: Deschide Poştaş și faceți următoarele:

• Selectează POST
• Invocați adresa URL http://localhost:8080/add-user.
• Faceți clic pe Corp
• Selectați Content-Type ca JSON (aplicație/json).
• Introduceți datele pe care doriți să le inserați în baza de date. Am introdus următoarele date:

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

• Faceți clic pe Trimite buton.

Când facem clic pe butonul Trimite, se afișează Stare: 200 OK . Înseamnă că cererea a fost executată cu succes.

Pasul 21: Deschideți browserul și invocați adresa URL http://localhost:8080. Returnează utilizatorul pe care l-am inserat în baza de date.