logo

TechCodeview

Avviamento primaverile dell'APP

Cos'è l'APP?

Avviamento primaverile dell'APP è una specifica Java per la gestione relazionale dati nelle applicazioni Java. Ci consente di accedere e rendere persistenti i dati tra oggetto/classe Java e database relazionale. Segue l'APP Mappatura delle relazioni tra oggetti (ORM). È un insieme di interfacce. Fornisce anche un runtime Gestore entità API per l'elaborazione di query e transazioni sugli oggetti rispetto al database. Utilizza un linguaggio di query orientato agli oggetti indipendente dalla piattaforma JPQL (Java Persistent Query Language).

Nel contesto della persistenza, copre tre aree:

  • L'API di persistenza Java
    • Relazionale agli oggettimetadati
  • L'API stessa, definita nel file persistenza pacchetto

L'APP non è un quadro. Definisce un concetto che può essere implementato da qualsiasi framework.

array.da Java

Perché dovremmo utilizzare l'APP?

JPA è più semplice, più pulito e richiede meno manodopera rispetto a JDBC, SQL e alla mappatura scritta a mano. JPA è adatto per applicazioni complesse non orientate alle prestazioni. Il vantaggio principale di JPA rispetto a JDBC è che, in JPA, i dati sono rappresentati da oggetti e classi mentre in JDBC i dati sono rappresentati da tabelle e record. Utilizza POJO per rappresentare dati persistenti che semplificano la programmazione del database. Ci sono alcuni altri vantaggi dell'APP:

  • JPA evita di scrivere DDL in un dialetto SQL specifico del database. Invece di ciò, consente la mappatura in XML o l'utilizzo di annotazioni Java.
  • JPA ci consente di evitare di scrivere DML nel dialetto SQL specifico del database.
  • JPA ci consente di salvare e caricare oggetti e grafici Java senza alcun linguaggio DML.
  • Quando dobbiamo eseguire query JPQL, ci consente di esprimere le query in termini di entità Java anziché di tabelle e colonne SQL (native).

Caratteristiche dell'APP

Ci sono le seguenti funzionalità di JPA:

  • È un repository potente e personalizzato astrazione della mappatura degli oggetti.
  • Supporta per persistenza tra più negozi . Significa che un'entità può essere parzialmente archiviata in MySQL e Neo4j (Graph Database Management System).
  • Genera dinamicamente query dal nome del metodo di query.
  • Le classi base del dominio forniscono proprietà di base.
  • Supporta un controllo trasparente.
  • Possibilità di integrare codice repository personalizzato.
  • È facile da integrare con Spring Framework con lo spazio dei nomi personalizzato.

Architettura dell'APP

JPA è una fonte per archiviare entità aziendali come entità relazionali. Mostra come definire un POJO come entità e come gestire le entità con relazione.

La figura seguente descrive l'architettura a livello di classe di JPA che descrive le classi principali e le interfacce di JPA definite nel file persistenza Javax pacchetto. L'architettura JPA contiene le seguenti unità:

    Persistenza:È una classe che contiene metodi statici per ottenere un'istanza EntityManagerFactory.EntityManagerFactory:È una classe factory di EntityManager. Crea e gestisce più istanze di EntityManager.Gestore entità:È un'interfaccia. Controlla le operazioni di persistenza sugli oggetti. Funziona per l'istanza Query.Entità:Le entità sono gli oggetti di persistenza archiviati come record nel database.Unità di persistenza:Definisce un insieme di tutte le classi di entità. In un'applicazione, le istanze EntityManager la gestiscono. L'insieme di classi di entità rappresenta i dati contenuti in un singolo archivio dati.Transazione entità:Ha un uno a uno relazione con la classe EntityManager. Per ogni EntityManager, le operazioni vengono gestite dalla classe EntityTransaction.Domanda:Si tratta di un'interfaccia implementata da ciascun fornitore JPA per ottenere oggetti di relazione che soddisfano i criteri.
Spring Boot jpa

Relazioni di classe JPA

Le classi e le interfacce di cui abbiamo discusso sopra mantengono una relazione. La figura seguente mostra la relazione tra classi e interfacce.

Spring Boot jpa
  • La relazione tra EntityManager ed EntiyTransaction è uno a uno . Esiste un'istanza di EntityTransaction per ogni operazione EntityManager.
  • La relazione tra EntityManageFactory ed EntiyManager è uno a molti . È una classe factory per l'istanza di EntityManager.
  • La relazione tra EntityManager e Query è uno a molti . Possiamo eseguire qualsiasi numero di query utilizzando un'istanza della classe EntityManager.
  • La relazione tra EntityManager ed Entity è uno a molti . Un'istanza di EntityManager può gestire più entità.

Implementazioni dell'APP

JPA è un'API open source. Esistono vari fornitori di aziende come Eclipse, RedHat, Oracle, ecc. Che forniscono nuovi prodotti aggiungendovi JPA. Esistono alcuni framework di implementazione JPA popolari come Ibernazione, EclipseLink, DataNucleus, ecc. È anche noto come Mappatura delle relazioni tra oggetti (ORM).

Mappatura delle relazioni tra oggetti (ORM)

In ORM viene chiamata la mappatura degli oggetti Java sulle tabelle del database e viceversa Mappatura relazionale degli oggetti. La mappatura ORM funziona come un ponte tra a banca dati relazionale (tabelle e record) e Applicazione Java (classi e oggetti).

Nella figura seguente, il livello ORM è un livello adattatore. Adatta il linguaggio degli oggetti grafici al linguaggio SQL e alle tabelle relazionali.

Spring Boot jpa

Il livello ORM esiste tra l'applicazione e il database. Converte le classi e gli oggetti Java in modo che possano essere archiviati e gestiti in un database relazionale. Per impostazione predefinita, il nome che persiste diventa il nome della tabella e i campi diventano colonne. Una volta configurata un'applicazione, ogni riga della tabella corrisponde a un oggetto.

Versioni dell'APP

Le versioni precedenti di EJB definiscono il livello di persistenza combinato con il livello di logica aziendale utilizzando javax.ejb.EntityBean Interfaccia. Le specifiche EJB includono la definizione di JPA.

Durante l'introduzione di EJB 3.0, il livello di persistenza è stato separato e specificato come JPA 1.0 (Java Persistence API). Le specifiche di questa API sono state rilasciate insieme alle specifiche di JAVA EE5 l'11 maggio 2006, utilizzando JSR 220.

Nel 2019, l'APP è stata rinominata Persistenza di Giakarta . L'ultima versione di JPA è 2.2 . Supporta le seguenti funzionalità:

  • Java 8, API dati e ora
  • Iniezione CDI in AttributeConvertes
  • Crea annotazioni @Repeatable

Differenza tra JPA e Ibernazione

APP: JPA è una specifica Java utilizzata per accedere, gestire e rendere persistenti i dati tra l'oggetto Java e il database relazionale. È un approccio standard per ORM.

Ibernazione: È uno strumento ORM leggero e open source utilizzato per archiviare oggetti Java nel sistema di database relazionale. È un fornitore di JPA. Segue un approccio comune fornito dall'APP.

La tabella seguente descrive le differenze tra JPA e Hibernate.

APP Ibernazione
L'APP è un specifica Java per la mappatura dei dati di relazione nell'applicazione Java. L'ibernazione è un quadro ORM che si occupa della persistenza dei dati.
JPA non fornisce alcuna classe di implementazione. Fornisce classi di implementazione.
Utilizza un linguaggio di query indipendente dalla piattaforma chiamato JPQL (Java Persistence Query Language). Utilizza il proprio linguaggio di query chiamato HQL (Linguaggio di query di ibernazione).
È definito in javax.persistenza pacchetto. È definito in org.hibernate pacchetto.
È implementato in vari strumenti ORM come Ibernazione, EclipseLink, eccetera. L'ibernazione è il fornitore del PSD.
L'APP utilizza Gestore entità per gestire la persistenza dei dati. Negli usi di ibernazione Sessione per gestire la persistenza dei dati.

Dati di avvio Spring Boot JPA

Spring Boot fornisce la dipendenza di Starter spring-boot-starter-data-jpa per connettere in modo efficiente l'applicazione Spring Boot con il database relazionale. Spring-boot-starter-data-jpa utilizza internamente la dipendenza spring-boot-jpa.

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

Esempio JPA Spring Boot

Creiamo un'applicazione Spring Boot che utilizza JPA per connettersi al database. Nell'esempio seguente, abbiamo utilizzato il database in memoria Derby dell'Apache.

Derby dell'Apache: È un open source, incorporato database relazionale implementato interamente in Java. È disponibile con la licenza Apache 2.0. I vantaggi di Apache Derby sono i seguenti:

matrice Java
  • È facile da installare, distribuire e utilizzare.
  • Si basa sugli standard Java, JDBC e SQL.
  • Fornisce un driver JDBC incorporato che ci consente di incorporare Derby in qualsiasi soluzione basata su Java.
  • Supporta inoltre la modalità client/server con il driver JDBC Derby Network Client e Derby Network Server.

Spring Boot può configurare automaticamente un database incorporato come H2, HSQL, E Database Derby . Non è necessario fornire alcun URL di connessione. Dobbiamo solo includere una dipendenza di compilazione dal database incorporato che vogliamo utilizzare.

In Spring Boot, possiamo integrare facilmente il database Apache Derby semplicemente aggiungendo Derby dipendenza nel file pom.xml.

 org.apache.derby derby runtime

Passo 1: Inizializzazione primavera aperta https://start.spring.io/ .

Passo 2: Seleziona l'ultima versione di Spring Boot 2.3.0(ISTANTANEA)

Passaggio 3: Fornire il Gruppo nome. Abbiamo fornito com.javatpoint.

Passaggio 4: Fornire il Artefatto Id. Abbiamo fornito apache-derby-esempio .

Passaggio 5: Aggiungi le dipendenze: Spring Web, Spring Data JPA, E Database Apache Derby .

Passaggio 6: Clicca sul creare pulsante. Quando facciamo clic sul pulsante Genera, avvolge il progetto in un file Jar e lo scarica sul sistema locale.

Spring Boot jpa

Passaggio 7: estrazione il file Jar e incollarlo nell'area di lavoro STS.

Passaggio 8: importa la cartella del progetto in STS.

File -> Importa -> Progetti Maven esistenti -> Sfoglia -> Seleziona la cartella apache-derby-example -> Fine

L'importazione richiede del tempo.

Passaggio 9: Crea un pacchetto con il nome com.javatpoint.model nella cartella src/principale/java.

Passaggio 10: Crea una classe con il nome Record utente nel pacchetto com.javatpoint.model e fai quanto segue:

  • Definire tre variabili ID, nome, E e-mail .
  • Genera getter e setter.
    Fare clic con il tasto destro sul file -> Sorgente -> Genera getter e setter
  • Definire un costruttore predefinito.
  • Contrassegna la classe come Entità utilizzando l'annotazione @Entità.
  • Segno Id come chiave primaria utilizzando l'annotazione @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; } }

Passaggio 11: Crea un pacchetto con il nome com.javatpoint.controller nella cartella src/principale/java.

Passaggio 12: Crea una classe Controller con il nome UserController nel pacchetto com.javatpoint.controller e fai quanto segue:

  • Contrassegna la classe come controller utilizzando l'annotazione @RestController.
  • Autowired la classe UserService utilizzando l'annotazione @Autowired .
  • Abbiamo definito due mappature, una per ottenere tutti gli utenti e l'altro per Aggiungi utente.

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

Passaggio 13: Crea un pacchetto con il nome com.javatpoint.service nella cartella src/principale/java.

Passaggio 14: Crea una classe di servizio con il nome UserService nel pacchetto com.javatpoint.service e fai quanto segue:

  • Contrassegna la classe come servizio utilizzando l'annotazione @Servizio.
  • Cablato automaticamente il Repository utente
  • Definire un metodo getAllUsers() che restituisce un elenco di
  • Definire un altro nome di metodo Aggiungi utente() che salva il record dell'utente.

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

Passaggio 15: Crea un pacchetto con il nome com.javatpoint.repository nella cartella src/principale/java.

Passaggio 16: Crea un'interfaccia del repository con il nome Repository utente nel pacchetto com.javatpoint.repository e si estende CrudRepository .

elenco di array in Java

UserRepository.java 

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

Passaggio 17: Ora apri il file ApacheDerbyExampleApplication.java file. Viene creato per impostazione predefinita quando configuriamo un'applicazione.

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

Ora abbiamo impostato tutte le classi e i pacchetti necessari in base ai requisiti. Tieni presente che non ne abbiamo fornito nessuno URL di connessione per la banca dati. Dopo aver completato tutti i passaggi precedenti, la directory del progetto è simile alla seguente:

Spring Boot jpa

Eseguiamo l'applicazione.

Passaggio 18: Apri il ApacheDerbyExampleApplication.java file ed eseguirlo come applicazione Java.

Passaggio 19: Aprire il browser e richiamare l'URL http://localhost:8080/. Restituisce un elenco vuoto perché non abbiamo aggiunto alcun utente nell'elenco.

Per aggiungere un utente al database, invieremo un file INVIARE richiesta utilizzando il Postino .

Passaggio 20: Apri il Postino e fai quanto segue:

  • Seleziona il INVIARE
  • Richiamare l'URL http://localhost:8080/add-user.
  • Clicca sul Corpo
  • Seleziona Tipo di contenuto come JSON (applicazione/json).
  • Inserire i dati che si vogliono inserire nel database. Abbiamo inserito i seguenti dati:
 { 'id': '001', 'name': 'Tom', 'email': '[email protected]' }
  • Clicca sul Inviare pulsante.
Spring Boot jpa

Quando facciamo clic sul pulsante Invia, viene visualizzato Stato:200 OK . Significa che la richiesta è stata eseguita con successo.

Passaggio 21: Aprire il browser e richiamare l'URL http://localhost:8080. Restituisce l'utente che abbiamo inserito nel database.

Spring Boot jpa
Scarica il progetto di esempio Apache Derby