logo

TechCodeview

Spring Boot JPA

Què és JPA?

Spring Boot JPA és una especificació de Java per gestionar relacional dades en aplicacions Java. Ens permet accedir i conservar dades entre l'objecte/classe Java i la base de dades relacional. El JPA segueix Mapeig objecte-relació (ORM). És un conjunt d'interfícies. També proporciona un temps d'execució EntityManager API per processar consultes i transaccions sobre els objectes contra la base de dades. Utilitza un llenguatge de consulta orientat a objectes independent de la plataforma JPQL (Java Persistent Query Language).

En el context de la persistència, abasta tres àrees:

  • L'API Java Persistence
    • Objecte-Relacionalmetadades
  • La pròpia API, definida a l' persistència paquet

JPA no és un marc. Defineix un concepte que pot ser implementat per qualsevol marc.

Per què hem d'utilitzar JPA?

JPA és més senzill, més net i requereix menys mà d'obra que JDBC, SQL i els mapes escrits a mà. JPA és adequat per a aplicacions complexes no orientades al rendiment. El principal avantatge de JPA sobre JDBC és que, a JPA, les dades es representen per objectes i classes, mentre que a JDBC les dades es representen per taules i registres. Utilitza POJO per representar dades persistents que simplifica la programació de bases de dades. Hi ha alguns altres avantatges de JPA:

  • JPA evita escriure DDL en un dialecte SQL específic de la base de dades. En lloc d'això, permet mapejar en XML o utilitzar anotacions Java.
  • JPA ens permet evitar escriure DML en el dialecte SQL específic de la base de dades.
  • JPA ens permet desar i carregar objectes i gràfics Java sense cap llenguatge DML.
  • Quan necessitem realitzar consultes JPQL, ens permet expressar les consultes en termes d'entitats Java en lloc de la taula i columnes SQL (natives).

Característiques JPA

Hi ha les següents característiques de JPA:

  • És un repositori potent i personalitzat abstracció de mapes d'objectes.
  • Dóna suport a persistència entre magatzems . Significa que una entitat es pot emmagatzemar parcialment a MySQL i Neo4j (Graph Database Management System).
  • Genera dinàmicament consultes a partir del nom dels mètodes de consultes.
  • Les classes base del domini proporcionen propietats bàsiques.
  • Admet auditories transparents.
  • Possibilitat d'integrar codi de repositori personalitzat.
  • És fàcil d'integrar amb Spring Framework amb l'espai de noms personalitzat.

Arquitectura JPA

JPA és una font per emmagatzemar entitats empresarials com a entitats relacionals. Mostra com definir un POJO com a entitat i com gestionar entitats amb relació.

La figura següent descriu l'arquitectura a nivell de classe de JPA que descriu les classes bàsiques i les interfícies de JPA que es defineixen a la persistència javax paquet. L'arquitectura JPA conté les unitats següents:

    Persistència:És una classe que conté mètodes estàtics per obtenir una instància d'EntityManagerFactory.EntityManagerFactory:És una classe de fàbrica d'EntityManager. Crea i gestiona múltiples instàncies d'EntityManager.EntityManager:És una interfície. Controla les operacions de persistència en objectes. Funciona per a la instància Query.Entitat:Les entitats són els objectes de persistència emmagatzemats com a registre a la base de dades.Unitat de persistència:Defineix un conjunt de totes les classes d'entitats. En una aplicació, les instàncies d'EntityManager la gestionen. El conjunt de classes d'entitats representa les dades contingudes en un únic magatzem de dades.EntityTransaction:Té un un a un relació amb la classe EntityManager. Per a cada EntityManager, les operacions es mantenen per classe EntityTransaction.Consulta:És una interfície que implementa cada proveïdor de JPA per obtenir objectes de relació que compleixin els criteris.
Spring Boot jpa

Relacions de classe JPA

Les classes i interfícies que hem comentat anteriorment mantenen una relació. La figura següent mostra la relació entre classes i interfícies.

Spring Boot jpa
  • La relació entre EntityManager i EntiyTransaction és un a un . Hi ha una instància d'EntityTransaction per a cada operació d'EntityManager.
  • La relació entre EntityManageFactory i EntiyManager és un a molts . És una classe de fàbrica per a la instància d'EntityManager.
  • La relació entre EntityManager i Query és un a molts . Podem executar qualsevol nombre de consultes utilitzant una instància de la classe EntityManager.
  • La relació entre EntityManager i Entity és un a molts . Una instància d'EntityManager pot gestionar diverses entitats.

Implementacions JPA

JPA és una API de codi obert. Hi ha diversos proveïdors d'empreses com Eclipse, RedHat, Oracle, etc. que ofereixen nous productes afegint-hi JPA. Hi ha alguns marcs d'implementació JPA populars com ara Hibernate, EclipseLink, DataNucleus, etc. També es coneix com Mapeig objecte-relació eina (ORM).

Mapeig de relació d'objectes (ORM)

A l'ORM, s'anomena l'assignació d'objectes Java a taules de bases de dades i viceversa Mapatge objecte-relacional. El mapeig ORM funciona com a pont entre a base de dades relacional (taules i registres) i Aplicació Java (classes i objectes).

A la figura següent, la capa ORM és una capa adaptadora. Adapta el llenguatge dels gràfics d'objectes al llenguatge SQL i les taules de relacions.

Spring Boot jpa

La capa ORM existeix entre l'aplicació i la base de dades. Converteix les classes i objectes Java perquè es puguin emmagatzemar i gestionar en una base de dades relacional. Per defecte, el nom que persisteix es converteix en el nom de la taula i els camps es converteixen en columnes. Un cop configurada una aplicació, cada fila de la taula correspon a un objecte.

Versions JPA

Les versions anteriors d'EJB defineixen la capa de persistència combinada amb la capa de lògica empresarial javax.ejb.EntityBean Interfície. L'especificació EJB inclou la definició de JPA.

Mentre es va introduir EJB 3.0, la capa de persistència es va separar i es va especificar com a JPA 1.0 (API de persistència de Java). Les especificacions d'aquesta API es van publicar juntament amb les especificacions de JAVA EE5 l'11 de maig de 2006, utilitzant JSR 220.

El 2019, JPA va canviar el nom a Jakarta persistència . L'última versió de JPA és 2.2 . Admet les funcions següents:

  • Java 8, API de dades i temps
  • Injecció CDI a AttributeConvertes
  • Fa anotacions @Repeatable

Diferència entre JPA i Hibernate

JPA: JPA és una especificació de Java que s'utilitza per accedir, gestionar i conservar dades entre l'objecte Java i la base de dades relacional. És un enfocament estàndard per a ORM.

Hibernar: És una eina ORM lleugera i de codi obert que s'utilitza per emmagatzemar objectes Java al sistema de bases de dades relacionals. És un proveïdor de JPA. Segueix un enfocament comú proporcionat per JPA.

La taula següent descriu les diferències entre JPA i Hibernate.

JPA Hibernar
JPA és a Especificació de Java per mapejar dades de relació a l'aplicació Java. Hibernar és un marc ORM que s'ocupa de la persistència de les dades.
JPA no proporciona cap classe d'implementació. Ofereix classes d'implementació.
Utilitza un llenguatge de consulta independent de la plataforma anomenat JPQL (Java Persistence Query Language). Utilitza el seu propi llenguatge de consulta anomenat HQL (Llenguatge de consulta Hibernate).
Es defineix a javax.persistència paquet. Es defineix a org.hibernar paquet.
S'implementa en diverses eines ORM com Hibernar, EclipseLink, etc. Hibernar és el proveïdor del PSD.
Usa JPA EntityManager per gestionar la persistència de les dades. En hibernació utilitza Sessió per gestionar la persistència de les dades.

Spring Boot Starter Data JPA

Spring Boot proporciona dependència de l'iniciador spring-boot-starter-data-jpa per connectar l'aplicació Spring Boot amb la base de dades relacional de manera eficient. El spring-boot-starter-data-jpa utilitza internament la dependència spring-boot-jpa.

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

Exemple de Spring Boot JPA

Creem una aplicació Spring Boot que utilitzi JPA per connectar-se a la base de dades. En l'exemple següent, hem utilitzat una base de dades en memòria Apache Derby.

Apache Derby: És un codi obert, incrustat base de dades relacional implementada completament en Java. Està disponible sota la llicència Apache 2.0. Hi ha els següents avantatges d'Apache Derby:

  • És fàcil d'instal·lar, desplegar i utilitzar.
  • Es basa en estàndards Java, JDBC i SQL.
  • Proporciona un controlador JDBC incrustat que ens permet incrustar Derby en qualsevol solució basada en Java.
  • També admet el mode client/servidor amb el controlador JDBC Derby Network Client i el Derby Network Server.

Spring Boot pot configurar automàticament una base de dades incrustada, com ara H2, HSQL, i Bases de dades Derby . No cal que proporcionem cap URL de connexió. Només hem d'incloure una dependència de compilació de la base de dades incrustada que volem utilitzar.

A Spring Boot, podem integrar fàcilment la base de dades Apache Derby només afegint-hi Derbi dependència al fitxer pom.xml.

 org.apache.derby derby runtime

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

Pas 2: Seleccioneu la darrera versió de Spring Boot 2.3.0 (INSTANTANÀRIA)

Pas 3: Proporcioneu el Grup nom. Hem proporcionat com.javatpoint.

Pas 4: Proporcioneu el Artefacte Id. Hem proporcionat apache-derby-exemple .

Pas 5: Afegeix les dependències: Spring Web, Spring Data JPA, i Base de dades Apache Derby .

Pas 6: Feu clic a Generar botó. Quan fem clic al botó Genera, embolica el projecte en un fitxer Jar i el baixa al sistema local.

Spring Boot jpa

Pas 7: Extracció el fitxer Jar i enganxeu-lo a l'espai de treball STS.

Pas 8: importar la carpeta del projecte a STS.

Fitxer -> Importa -> Projectes Maven existents -> Navega -> Seleccioneu la carpeta apache-derby-example -> Finalitza

Es necessita un temps per importar.

Pas 9: Creeu un paquet amb el nom com.javatpoint.model a la carpeta src/main/java.

Pas 10: Crea una classe amb el nom Registre d'usuari al paquet com.javatpoint.model i fes el següent:

  • Definiu tres variables id, nom, i correu electrònic .
  • Genera Getters i Setter.
    Feu clic amb el botó dret al fitxer -> Font -> Genera Getters i Setters
  • Definiu un constructor per defecte.
  • Marca la classe com a Entitat utilitzant l'anotació @Entitat.
  • senyal Id com a clau primària utilitzant l'anotació @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; } }

Pas 11: Creeu un paquet amb el nom com.javatpoint.controller a la carpeta src/main/java.

Pas 12: Creeu una classe de controlador amb el nom UserController al paquet com.javatpoint.controller i fes el següent:

  • Marqueu la classe com a controlador utilitzant l'anotació @RestController.
  • S'ha connectat automàticament la classe Servei d'usuari utilitzant l'anotació @Cablejat automàtic .
  • Hem definit dos mapes, un per aconseguir tots els usuaris i l'altre per usuari agregat.

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

Pas 13: Creeu un paquet amb el nom com.javatpoint.service a la carpeta src/main/java.

Pas 14: Creeu una classe de servei amb el nom Servei d'usuari al paquet com.javatpoint.service i fes el següent:

  • Marqueu la classe com a servei mitjançant l'anotació @Servei.
  • Connectat automàticament el Repositori d'usuaris
  • Definir un mètode getAllUsers() que retorna una llista de
  • Definiu un altre nom de mètode addUser() que guarda el registre de l'usuari.

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

Pas 15: Creeu un paquet amb el nom com.javatpoint.repository a la carpeta src/main/java.

Pas 16: Creeu una interfície de repositori amb el nom Repositori d'usuaris al paquet com.javatpoint.repository i s'estén CrudRepository .

UserRepository.java 

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

Pas 17: Ara, obriu el ApacheDerbyExampleApplication.java dossier. Es crea per defecte quan configurem una aplicació.

matemàtiques java.atzar

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

Ara, hem configurat totes les classes i paquets necessaris segons els requisits. Tingueu en compte que no n'hem proporcionat cap URL de connexió per a la base de dades. Després de completar tots els passos anteriors, el directori del projecte té l'aspecte següent:

Spring Boot jpa

Executem l'aplicació.

Pas 18: Obriu el ApacheDerbyExampleApplication.java fitxer i executeu-lo com a aplicació Java.

Pas 19: Obriu el navegador i invoqueu l'URL http://localhost:8080/. Retorna una llista buida perquè no hem afegit cap usuari a la llista.

Per afegir un usuari a la base de dades, enviarem un PUBLICACIÓ sol·licitud utilitzant el Carter .

Pas 20: Obriu el Carter i fes el següent:

  • Seleccioneu el PUBLICACIÓ
  • Invoqueu l'URL http://localhost:8080/add-user.
  • Feu clic a Cos
  • Seleccioneu Tipus de contingut com a JSON (aplicació/json).
  • Inseriu les dades que voleu inserir a la base de dades. Hem inserit les dades següents:
 { 'id': '001', 'name': 'Tom', 'email': '[email protected]' }
  • Feu clic a Enviar botó.
Spring Boot jpa

Quan fem clic al botó Envia, es mostra Estat: 200 OK . Significa que la sol·licitud s'ha executat correctament.

Pas 21: Obriu el navegador i invoqueu l'URL http://localhost:8080. Retorna l'usuari que hem inserit a la base de dades.

Spring Boot jpa
Baixeu el projecte d'exemple Apache derby