JPA di Spring Boot

Cos'è JPA?

JPA di Spring Boot è una specifica Java utilizzata per la gestione delle applicazioni Javarelazionaledati. Ci permette di accedere e persistere dati tra oggetti/cls Java e database relazionali. JPA seguemappatura oggetto-relazionale(ORM). È un insieme di interfacce. Fornisce anche EntityManager API per gestire query e transazioni su oggetti di database. Usa un linguaggio di query orientato agli oggetti e indipendente dalla piattaforma, JPQL (Java Persistence Query Language).

Nel campo della persistenza, copre tre aree:

Java Persistence API Object-Relationalmetadatinel persistenza L'API definita nel pacchetto

JPA non è un framework. Definisce concetti che possono essere implementati in qualsiasi framework.

Perché dovremmo usare JPA?

Confrontato con JDBC, JPA è più semplice, più pulito e meno laborioso, evitando SQL e mappature manuali. È adatto per applicazioni complesse non orientate alla performance. Uno dei principali vantaggi 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. Usa POJO per rappresentare i dati persistenti, semplificando la programmazione del database. JPA ha anche altri vantaggi:

JPA evita l'uso di dialetti SQL specifici per il database per scrivere DDL. Invece, permette di mappare utilizzando XML o annotazioni Java. JPA ci permette di evitare di scrivere DML utilizzando dialetti di database specifici per il SQL. JPA ci permette di salvare e caricare oggetti Java e grafici senza utilizzare alcun linguaggio DML.Quando dobbiamo eseguire una query JPQL, ci permette di esprimere la query utilizzando le entità Java invece di tabelle e colonne (nativi) SQL.

Funzionalità JPA

JPA ha le seguenti funzionalità:

Questo è un repository potente e personalizzatol'astrazione di mappatura degli oggetti. SupportaPersistenza transazionale. Questo significa che un ente può essere memorizzato parzialmente in MySQL e Neo4j (sistema di gestione del database a grafo).Genera dinamicamente le query a partire dal nome del metodo di query.Le classi basate sul dominio forniscono attributi di base.Supporta la revisione trasparente.Possibilità di integrare codice di repository personalizzato.È facile integrarsi con il Spring Framework tramite namespace personalizzati.

Architettura JPA

JPA è la fonte che memorizza gli enti aziendali come enti relazionali. Mostra come definire un POJO come entità e come gestire gli enti attraverso la gestione relazionale.

La seguente figura descrive l'architettura di livello classe di JPA, che descrive le classi e gli interface fondamentali di JPA. javax persistenzaPacchetto. L'architettura JPA contiene le seguenti unità:

Persistenza: Questa è una classe che contiene metodi statici per ottenere l'istanza di EntityManagerFactory. EntityManagerFactory: È la classe factory di EntityManager. Crea e gestisce più istanze di EntityManager. EntityManager: . È un'interfaccia. Controlla le operazioni di persistenza sugli oggetti. È applicabile all'istanza Query. Entity: Gli enti sono oggetti persistenti memorizzati come record nel database. È un'interfaccia. Controlla le operazioni di persistenza sugli oggetti. È applicabile all'istanza Query. Unità di persistenza: Definisce un insieme di classi di entità. Nell'applicazione, l'istanza EntityManager le gestisce. Un insieme di classi di entità rappresenta i dati contenuti in un singolo archivio di dati. EntityTransaction: Ha una relazione con la classe EntityManagerUno a unoLa relazione. Per ogni EntityManager, le operazioni sono mantenute dalla classe EntityTransaction. Query: Questa interfaccia è implementata da ogni fornitore JPA per ottenere oggetti di relazione conformi ai requisiti.

Relazione di classe JPA

Le classi e gli interface discussi in precedenza mantengono una relazione. La seguente figura mostra la relazione tra le classi e gli interface.

Il rapporto tra EntityManager e EntiyTransaction èUno a unoOgni operazione EntityManager ha un'istanza di EntityTransaction. La relazione tra EntityManageFactory e EntityManager èUno a molti. Questa è la classe factory dell'istanza EntityManager. La relazione tra EntityManager e Query èUno a molti. Possiamo eseguire una qualsiasi quantità di query utilizzando l'istanza della classe EntityManager. La relazione tra EntityManager e Entity èUno a molti. L'istanza di EntityManager può gestire più entità.

implementazione JPA

JPA è un'API open source. Ci sono vari fornitori aziendali, come Eclipse, RedHat, Oracle, che offrono nuovi prodotti aggiungendo JPA. Ci sono diversi framework di implementazione popolari di JPA, come Hibernate, EclipseLink, DataNucleus ecc. È anche chiamatomappatura oggetto-relazionale(ORM) strumenti.

mappatura oggetto-relazionale (ORM)

Nell'ORM, la mappatura degli oggetti Java ai database tabellari (e viceversa) è chiamatamappatura oggetto-relazionale (ORM) La mappatura ORM agisce comee database relazionalie (tabelle e record) Applicazione JavaPonte tra (classi e oggetti)

Nella figura sottostante, il livello ORM è uno strato di adattamento. Esso adatta il linguaggio del diagramma degli oggetti al linguaggio SQL e delle tabelle relazionali.

Il livello ORM esiste tra l'applicazione e il database. Esso trasforma le classi Java e gli oggetti in modo che possano essere memorizzati e gestiti nei database relazionali. Di default, il nome della persistenza diventerà il nome della tabella, mentre i campi diventeranno le colonne. Una volta che l'applicazione è stata configurata, ogni riga della tabella corrisponde a un oggetto.

versione JPA

Le prime versioni di EJB hanno definito il livello di persistenza combinato con la logica di business. Utilizzando javax.ejb.EntityBean Interfaccia. La specifica EJB include la definizione di JPA.

Quando è stato introdotto EJB 3.0, il livello di persistenza è stato separato e designato come JPA 1.0 (Java Persistence API). La specifica dell'API è stata pubblicata insieme alla specifica JAVA EE5 del 11 maggio 2006 utilizzando JSR 220.

Nel 2019, JPA è stato rinominato Jakarta Persistence . La versione più recente di JPA è 2.2 Sostiene le seguenti funzionalità:

API di dati e tempo Java 8 Iniezione CDI in AttributeConvertesEsso rende annotazione @Repeatable

La differenza tra JPA e Hibernate

JPA: JPA è una specifica Java utilizzata per accedere, gestire e persistere oggetti Java e database relazionali. È il metodo standard dell'ORM.

Hibernate: È uno strumento ORM open source leggero utilizzato per memorizzare oggetti Java nei sistemi di database relazionali. È un provider JPA. Segue un metodo comune fornito dal provider JPA.

La tabella seguente descrive le differenze tra JPA e Hibernate.

Spring Boot starter data JPA

Spring Boot fornisce dipendenze di avvio spring-boot-starter-data-jpa Per connettere efficacemente Spring Boot all'uso di database relazionali. spring-boot-starter-data-jpa utilizza internamente la dipendenza spring-boot-jpa.

<dependency>　　
<groupId>org.springframework.boot</groupId>　　
<artifactId>spring-boot-starter-data-jpa</artifactId>　　
<version>2.2.2.RELEASE</version>　　
</dependency>

Esempio Spring Boot JPA

Creiamo un'applicazione Spring Boot che utilizza JPA per connettersi al database. Nei seguenti esempi, abbiamo utilizzato un database in memoria Apache Derby.

Apache Derby : Questo è un embeddedSoftware open sourceIl database relazionale è completamente implementato in Java. È disponibile sotto la licenza Apache License 2.0. Apache Derby ha i seguenti vantaggi:

Facile da installare, distribuire e utilizzare.È basato su Java, JDBC e standard SQL.Fornisce un driver JDBC integrato che ci permette di integrare Derby in qualsiasi soluzione basata su Java.它还通过 Derby Network Client JDBC 驱动程序和 Derby Network Server 支持客户端/服务器模式。

Spring Boot 可以自动配置嵌入式数据库，例如 H2，HSQL，和 Derby databases 。我们不需要提供任何连接 URL。我们只需要包含要使用的嵌入式数据库的构建依赖项即可。

在 Spring Boot 中，只需在 pom 中添加 Derby 依赖项即可轻松集成 Apache Derby 数据库。 xml 文件。

<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
<scope>runtime</scope>
</dependency>

步骤1: 打开 Spring Initializr https://start.spring.io/。

步骤2: 选择最新版本的 Spring Boot 2.3.0(SNAPSHOT)

步骤3: 提供Group名称。我们已经提供了 com.w3codebox。

步骤4: 提供Artifact ID。我们提供了 apache-derby-example .

步骤5: 添加依赖项: Spring Web，Spring Data JPA和 Apache Derby 数据库.

步骤6: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它会将项目包装到一个 Jar 文件中，并将其下载到本地系统。

步骤7: 提取 Jar 文件并将其粘贴到 STS 工作区中。

步骤8: 导入

文件->导入->现有 Maven 项目->浏览->选择文件夹 apache-derby-example->完成

导入需要一些时间。

步骤9: Nella cartella src/main/javaNella creazione del nome com.w3codebox.model del pacchetto.

步骤10: Nel pacchetto com.w3codebox.model Nella creazione del nome UserRecord 的类，然后执行以下:

定义三个变量 id, name, and email.生成 Getter 和 Setter。
右键单击文件->源->生成 Getter 和 Setter 定义默认的构造函数。utilizzando l'annotazione @Entity将类标记为Entity. utilizzando l'annotazione @Id将 Id 标记为主键。

UserRecord.java

package com.w3codebox.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity　　
public class UserRecord　
{　
@Id　　
private int id;　　
private String name;　　
private String email;
//costruttore predefinito　　
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;　　
}　　
}

passo 11: nel crea una cartella chiamata com.w3codebox.controller del pacchetto.

passo 12: Nel pacchetto com.w3codebox.controller Nella creazione del nome UserController classe Controller di User, e eseguire le seguenti operazioni:

utilizzando l'annotazione @RestController marcare la classe come controller.utilizzando l'annotazione @Autowired classe di connessione automatica UserService .abbiamo definito due mappaggi, uno dei quali viene utilizzato perottenere tutti gli utentiun altro mappaggio viene utilizzato peraggiungi utente.

UserController.java

package com.w3codebox.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.w3codebox.model.UserRecord;
import com.w3codebox.service.UserService;
import java.util.List;　　
@RestController　　
public class UserController　
{　　
@Autowired　　
private UserService userService;　　　
@RequestMapping("/")　　
public List<UserRecord> getAllUser
{　　
return userService.getAllUsers();　　
}　　　　　
@RequestMapping(value="/add-user", method=RequestMethod.POST)　　
public void addUser(@RequestBody UserRecord userRecord)
{　　
userService.addUser(userRecord);　　
}　　　　　
}

步骤13: Nella cartella src/main/java中创建一个名称为 com.w3codebox.service del pacchetto.

步骤14: Nel pacchetto com.w3codebox.service Nella creazione del nome UserController 的Service类，并执行以下操作:

通过使用注解 @Service将该类标记为服务。 自动连接 UserRepository 定义方法 getAllUsers()，该方法返回以下列表: 定义另一个方法名称 addUser()，以保存用户记录。

UserService.java

package com.w3codebox.service;　　
import java.util.List;　　
import java.util.ArrayList;　　
import org.springframework.beans.factory.annotation.Autowired;　　
import org.springframework.stereotype.Service;
import com.w3codebox.model.UserRecord;
import com.w3codebox.repository.UserRepository;　　
@Service　　
public class UserService　
{　　
@Autowired　　
private UserRepository userRepository;　　
public List<UserRecord> getAllUsers()
{　　
List<UserRecord>userRecords = new ArrayList<>();　　
userRepository.findAll().forEach(userRecords::add);　　
return userRecords;　　
}　　
public void addUser(UserRecord userRecord)
{　　
userRepository.save(userRecord);　　
}　　
}

Passaggio 15: Nella cartella src/main/javaNella creazione del nome com.w3codebox.repository del pacchetto.

Passaggio 16: Nel pacchetto com.w3codebox.repository Nella creazione del nome UserRepository l'interfaccia di archiviazione e estende CrudRepository .

UserRepository.java

package com.w3codebox.repository;　　
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.UserRecord;　　
public interface UserRepository extends CrudRepository<UserRecord, String>　
{　　
}

Passaggio 17: Ora, apri ApacheDerbyExampleApplication.java Il file. È stato creato di default quando abbiamo configurato l'applicazione.

ApacheDerbyExampleApplication.java

package com.w3codebox;
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 configurato tutti i classi e i pacchetti necessari secondo le richieste. Si prega di notare che non abbiamo fornito alcunaIndirizzo di connessione URL Dopo aver completato tutti i passaggi sopra elencati, la directory del progetto è come segue:

Facciamo girare l'applicazione.

Passaggio 18: Apri ApacheDerbyExampleApplication.java file e eseguilo come applicazione Java.

Passaggio 19: Apri il browser e chiama l'URL http://localhost:8080/. Poiché non è stato aggiunto alcun utente alla lista, viene restituita una lista vuota.

Per aggiungere un utente al database, useremoInvia POST Richiesta Postman.

Passaggio 20: ApriPostmane esegui le seguenti operazioni:

Scegli POST Chiama l'URL http://localhost:8080/add-user.CliccaCorpo Scegli "Content-Type" comeJSON (application/json).Inserisci i dati che verranno inseriti nel database. Abbiamo inserito i seguenti dati:

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

CliccaInviapulsante.

Quando facciamo clic sul pulsante "Invia", viene visualizzatoStato: 200 OK . Questo significa che la richiesta è stata eseguita con successo.

Passaggio 21: Apri il browser e chiama l'URL http://localhost:8080. Ritornerà gli utenti inseriti nel database.