Mi az a JPA?

Spring Boot JPA egy Java specifikáció kezelésére relációs adatokat a Java alkalmazásokban. Lehetővé teszi számunkra a Java objektumok/osztályok és a relációs adatbázisok közötti adatok elérését és megőrzését. A JPA következik Objektum-reláció leképezés (ORM). Ez interfészek halmaza. Futási időt is biztosít EntityManager API lekérdezések és tranzakciók feldolgozásához az objektumokon az adatbázisban. Platformfüggetlen objektum-orientált lekérdezési nyelvet használ, a JPQL-t (Java Persistent Query Language).

A kitartással összefüggésben három területet fed le:

• A Java Persistence API
Objektum-relációsmetaadatokat
• Maga az API, amelyet a kitartás csomag

A JPA nem keretrendszer. Olyan koncepciót határoz meg, amely bármilyen keretrendszerrel megvalósítható.

Miért használjuk a JPA-t?

A JPA egyszerűbb, tisztább és kevésbé munkaigényes, mint a JDBC, SQL és kézzel írott leképezés. A JPA alkalmas nem teljesítményorientált összetett alkalmazásokhoz. A JPA fő előnye a JDBC-vel szemben, hogy a JPA-ban az adatokat objektumok és osztályok, míg a JDBC-ben táblák és rekordok képviselik. A POJO-t használja az állandó adatok megjelenítésére, ami leegyszerűsíti az adatbázis-programozást. Van még néhány előnye a JPA-nak:

• A JPA kerüli a DDL-t az SQL adatbázis-specifikus dialektusában. Ehelyett lehetővé teszi a leképezést XML-ben vagy Java megjegyzések használatát.
• A JPA lehetővé teszi, hogy elkerüljük a DML-t az SQL adatbázis-specifikus dialektusában.
• A JPA lehetővé teszi Java objektumok és grafikonok mentését és betöltését DML nyelv nélkül.
• Amikor JPQL lekérdezéseket kell végrehajtanunk, lehetővé teszi számunkra, hogy a lekérdezéseket Java entitásokkal fejezzük ki a (natív) SQL tábla és oszlopok helyett.

JPA jellemzői

A JPA következő jellemzői vannak:

• Ez egy erős adattár és szokás objektum-leképezés absztrakció.
• Támogatja a boltokon átívelő kitartás . Ez azt jelenti, hogy egy entitás részben MySQL-ben és Neo4j-ben (Graph Database Management System) tárolható.
• Dinamikusan generál lekérdezéseket a lekérdezési metódusok neve alapján.
• A tartomány alaposztályai alapvető tulajdonságokat biztosítanak.
• Támogatja az átlátható auditálást.
• Lehetőség egyéni tárkód integrálására.
• Könnyen integrálható a Spring Framework-be az egyéni névtérrel.

JPA építészet

A JPA egy forrás az üzleti entitások relációs entitásként való tárolására. Megmutatja, hogyan lehet egy POJO-t entitásként meghatározni, és hogyan kezelheti az entitásokat relációval.

öröklődés java-ban

A következő ábra a JPA osztályszintű architektúráját írja le, amely leírja a JPA alapvető osztályait és interfészeit, amelyeket a javax kitartás csomag. A JPA architektúrája a következő egységeket tartalmazza:

Kitartás:Ez egy olyan osztály, amely statikus metódusokat tartalmaz egy EntityManagerFactory példány beszerzéséhez.EntityManagerFactory:Ez az EntityManager gyári osztálya. Az EntityManager több példányát hozza létre és kezeli.EntityManager:Ez egy interfész. Ez vezérli az objektumok perzisztencia műveleteit. A Query példányhoz működik.Entitás:Az entitások a perzisztencia objektumok, amelyeket rekordként tárolnak az adatbázisban.Perzisztencia mértékegysége:Meghatározza az összes entitásosztály halmazát. Egy alkalmazásban az EntityManager példányok kezelik. Az entitásosztályok halmaza az egyetlen adattáron belüli adatokat reprezentálja.EntityTransaction:Van egy 1-1 kapcsolat az EntityManager osztállyal. Minden EntityManager esetében a műveleteket az EntityTransaction osztály tartja karban.Lekérdezés:Ez egy olyan interfész, amelyet minden JPA szállító implementál a feltételeknek megfelelő relációs objektumok beszerzésére.

JPA osztálykapcsolatok

A fentebb tárgyalt osztályok és interfészek kapcsolatot tartanak fenn. A következő ábra az osztályok és az interfészek közötti kapcsolatot mutatja be.

• Az EntityManager és az EntiyTransaction közötti kapcsolat a következő 1-1 . Minden EntityManager művelethez tartozik egy EntityTransaction példány.
• Az EntityManageFactory és az EntiyManager közötti kapcsolat a következő egy a sokhoz . Ez egy gyári osztály az EntityManager példányhoz.
• Az EntityManager és a Query közötti kapcsolat az egy a sokhoz . Az EntityManager osztály egy példányának használatával tetszőleges számú lekérdezést végrehajthatunk.
• Az EntityManager és az Entity közötti kapcsolat az egy a sokhoz . Egy EntityManager példány több entitást is kezelhet.

A JPA végrehajtásai

A JPA egy nyílt forráskódú API. Különféle vállalatok szállítói vannak, mint például az Eclipse, a RedHat, az Oracle stb., amelyek új termékeket kínálnak a JPA hozzáadásával. Van néhány népszerű JPA implementációs keretrendszer, mint pl Hibernate, EclipseLink, DataNucleus, stb. Más néven Objektum-reláció leképezés (ORM) eszköz.

Objektum-relációs leképezés (ORM)

Az ORM-ben a Java objektumok adatbázistáblákhoz való leképezését és fordítva hívják Objektum-relációs leképezés. Az ORM leképezés hídként működik a relációs adatbázis (táblázatok és rekordok) és Java alkalmazás (osztályok és objektumok).

A következő ábrán az ORM réteg egy adapterréteg. Az objektumgráfok nyelvét az SQL és a relációs táblák nyelvéhez igazítja.

Az ORM réteg az alkalmazás és az adatbázis között található. Átalakítja a Java osztályokat és objektumokat, hogy azok egy relációs adatbázisban tárolhatók és kezelhetők legyenek. Alapértelmezés szerint a megmaradt név lesz a tábla neve, a mezők pedig oszlopokká. Az alkalmazás beállítása után minden táblázatsor egy objektumnak felel meg.

JPA verziók

Az EJB korábbi verziói a perzisztencia réteget az üzleti logikai réteggel kombinálva határozzák meg javax.ejb.EntityBean Felület. Az EJB specifikáció tartalmazza a JPA meghatározását.

Az EJB 3.0 bevezetésekor a perzisztencia réteget elkülönítették, és JPA 1.0-ként (Java Persistence API) határozták meg. Ennek az API-nak a specifikációit a JAVA EE5 specifikációival együtt adták ki 2006. május 11-én, a JSR 220 használatával.

2019-ben a Közös Közgyűlés átnevezte a következőre Jakarta kitartás . A JPA legújabb verziója az 2.2 . A következő funkciókat támogatja:

• Java 8, adat és idő API
• CDI befecskendezés az AttributeConvertesben
• A megjegyzéseket @ismételhetővé teszi

A JPA és a Hibernate közötti különbség

JPA: A JPA egy Java specifikáció, amely a Java objektum és a relációs adatbázis közötti adatok elérésére, kezelésére és megőrzésére szolgál. Ez egy szabványos megközelítés az ORM számára.

Hibernálás: Ez egy könnyű, nyílt forráskódú ORM-eszköz, amely Java objektumok tárolására szolgál a relációs adatbázisrendszerben. Ez a JPA szolgáltatója. A KPK által biztosított közös megközelítést követi.

Az alábbi táblázat a JPA és a hibernált állapot közötti különbségeket írja le.

Spring Boot Starter Data JPA

A Spring Boot indítófüggőséget biztosít spring-boot-starter-data-jpa a Spring Boot alkalmazás és a relációs adatbázis hatékony összekapcsolása. A spring-boot-starter-data-jpa belsőleg a spring-boot-jpa függőséget használja.

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

Spring Boot JPA példa

Hozzunk létre egy Spring Boot alkalmazást, amely JPA segítségével csatlakozik az adatbázishoz. A következő példában a memórián belüli adatbázist használtuk Apache Derby.

Apache Derby: Ez egy nyílt forráskódú, beágyazott relációs adatbázis teljes egészében Java nyelven implementálva. Az Apache License 2.0 alatt érhető el. Az Apache Derbynek a következő előnyei vannak:

• Könnyen telepíthető, üzembe helyezhető és használható.
• Java, JDBC és SQL szabványokon alapul.
• Beágyazott JDBC illesztőprogramot biztosít, amely lehetővé teszi, hogy a Derbyt bármilyen Java-alapú megoldásba beágyazzuk.
• Támogatja a kliens/szerver módot is a Derby Network Client JDBC illesztőprogramjával és a Derby Network Serverrel.

A Spring Boot képes automatikusan konfigurálni egy beágyazott adatbázist, mint pl H2, HSQL, és Derby-adatbázisok . Nem kell megadnunk semmilyen kapcsolati URL-t. Csak egy felépítési függőséget kell megadnunk a használni kívánt beágyazott adatbázistól.

A Spring Bootban egyszerűen integrálhatjuk az Apache Derby adatbázist, csupán hozzáadva Derby függőség a pom.xml fájlban.

 org.apache.derby derby runtime 

1. lépés: Nyissa meg a tavaszi inicializálást https://start.spring.io/ .

2. lépés: Válassza ki a Spring Boot legújabb verzióját 2.3.0 (PILLANATFELVÉTEL)

123 film

3. lépés: Adja meg a Csoport név. biztosítottuk com.javatpoint.

4. lépés: Adja meg a Műalkotás Id. biztosítottuk apache-derby-example .

5. lépés: Adja hozzá a függőségeket: Spring Web, Spring Data JPA, és Apache Derby adatbázis .

java térképek

6. lépés: Kattintson a generál gomb. Amikor a Generate gombra kattintunk, a projektet egy Jar fájlba csomagolja, és letölti a helyi rendszerre.

7. lépés: Kivonat a Jar fájlt, és illessze be az STS munkaterületre.

8. lépés: Importálás a projekt mappát az STS-be.

Fájl -> Import -> Meglévő Maven Projektek -> Tallózás -> Válassza ki a mappát apache-derby-example -> Befejezés

Az importálás némi időt vesz igénybe.

9. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.model a mappában src/main/java.

10. lépés: Hozzon létre egy osztályt a névvel UserRecord a csomagban com.javatpoint.model és tegye a következőket:

• Határozzon meg három változót azonosító, név, és email .
• Getterek és szetterek létrehozása.
  Kattintson a jobb gombbal a fájlra -> Forrás -> Getterek és beállítók generálása
• Határozzon meg egy alapértelmezett konstruktort.
• Az osztály megjelölése an Entitás az annotáció használatával @Entity.
• Mark Id elsődleges kulcsként a megjegyzés használatával @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. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.controller a mappában src/main/java.

12. lépés: Hozzon létre egy Controller osztályt a névvel UserController a csomagban com.javatpoint.controller és tegye a következőket:

• Jelölje meg az osztályt vezérlőként a megjegyzés használatával @RestController.
• Automatikusan bekötötte az osztályt UserService az annotáció használatával @Autowired .
• Két leképezést határoztunk meg, az egyiket minden felhasználó elérése a másik pedig azért felhasználó hozzáadása.

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. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.service a mappában src/main/java.

14. lépés: Hozzon létre egy szolgáltatásosztályt a névvel UserService a csomagban com.javatpoint.service és tegye a következőket:

• Jelölje meg az osztályt szolgáltatásként a megjegyzés használatával @Szolgáltatás.
• Automatikusan behuzalozva a UserRepository
• Határozzon meg egy módszert getAllUsers() amely egy listát ad vissza
• Adjon meg egy másik metódusnevet felhasználó hozzáadása() amely elmenti a felhasználói rekordot.

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. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.repository a mappában src/main/java.

16. lépés: Hozzon létre egy adattár felületet a névvel UserRepository a csomagban com.javatpoint.repository és kiterjeszti CrudRepository .

UserRepository.java

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

17. lépés: Most nyissa meg a ApacheDerbyExampleApplication.java fájlt. Alapértelmezés szerint létrejön, amikor egy alkalmazást beállítunk.

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

Most minden szükséges osztályt és csomagot felállítottunk a követelményeknek megfelelően. Figyeljük meg, hogy nem adtunk meg semmit kapcsolat URL-je az adatbázishoz. A fenti lépések végrehajtása után a projektkönyvtár a következőképpen néz ki:

Futtassuk az alkalmazást.

18. lépés: Nyissa meg a ApacheDerbyExampleApplication.java fájlt, és futtassa Java alkalmazásként.

knn algoritmus

19. lépés: Nyissa meg a böngészőt, és hívja meg a http://localhost:8080/ URL-t. Üres listát ad vissza, mert nem adtunk hozzá felhasználót a listához.

Felhasználó hozzáadásához az adatbázishoz elküldjük a POST segítségével kérhet Postás .

20. lépés: Nyissa meg a Postás és tegye a következőket:

• Válaszd ki a POST
• Hívja meg a http://localhost:8080/add-user URL-t.
• Kattintson a Test
• Válassza ki a Tartalom típusa mint JSON (alkalmazás/json).
• Illessze be a beszúrni kívánt adatokat az adatbázisba. A következő adatokat illesztettük be:

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

• Kattintson a Küld gomb.

Amikor a Küldés gombra kattintunk, megjelenik Állapot: 200 OK . Ez azt jelenti, hogy a kérést sikeresen végrehajtották.

21. lépés: Nyissa meg a böngészőt, és hívja meg a http://localhost:8080 URL-t. Visszaadja azt a felhasználót, akit beszúrtunk az adatbázisba.