JPA en Spring Boot

¿Qué es JPA?

JPA en Spring Boot es una especificación Java utilizada para gestionar aplicaciones Javarelacioneslos datos. Nos permite acceder y persistir objetos Java/los datos entre las clases y las bases de datos relacionales. JPA siguemapeo de objeto-relacional(ORM)。Es un conjunto de interfaces. También proporciona información en tiempo de ejecución EntityManager API para manejar consultas y transacciones contra objetos de base de datos. Utiliza un lenguaje de consulta orientado a objetos sin plataforma JPQL (Java Persistence Query Language).

En términos de persistencia, abarca tres áreas:

Java Persistence API Objeto-RelacionalMetadatosen persistence La API definida en el paquete

JPA no es un framework. Define conceptos que se pueden implementar en cualquier framework.

¿Por qué deberíamos usar JPA?

En comparación con JDBC, JPA es más sencilla, más limpia y menos laboriosa, sin SQL y sin mapeo handwritten. JPA es adecuado para aplicaciones complejas no orientadas al rendimiento. En comparación con JDBC, la principal ventaja de JPA radica en que, en JPA, los datos se representan por objetos y clases, mientras que en JDBC, los datos se representan por tablas y registros. Utiliza POJO para representar datos persistentes, lo que simplifica la programación de bases de datos. JPA también tiene otras ventajas:

JPA evita escribir DDL específico de base de datos SQL. En su lugar, permite mapear con XML o mediante anotaciones Java. JPA nos permite evitar escribir DML utilizando dialectos específicos de base de datos SQL. JPA nos permite guardar y cargar objetos Java y gráficos sin usar ningún lenguaje DML.Cuando necesitamos ejecutar consultas JPQL, nos permite expresar la consulta utilizando entidades Java en lugar de tablas y columnas (nativas) SQL.

Características de JPA

JPA tiene las siguientes características:

Esta es una biblioteca de almacenamiento potente y personalizadaAbstracción de mapeo de objetos. SoportaPersistencia transaccionalEsto significa que una entidad puede almacenarse en parte en MySQL y Neo4en la base de datos de gestión de图形 (j).Genera dinámicamente consultas a partir del nombre del método de consulta.Las clases base de dominio proporcionan propiedades básicas.Soporta auditoría transparente.Posibilidad de integrar código de repositorio personalizado.Es fácil integrarse con el Framework de Spring a través de nombres de espacio personalizados.

Arquitectura de JPA

JPA es la fuente que almacena entidades de negocio como entidades relacionales. Muestra cómo definir POJO como entidad y cómo gestionar entidades a través de relaciones.

La siguiente imagen describe la arquitectura de nivel de clase de JPA, que describe las clases y interfaces nucleares de JPA. javax persistenciaPaquete. La arquitectura de JPA contiene las siguientes unidades:

Persistence: Esta es una clase que contiene métodos estáticos para obtener instancias de EntityManagerFactory. EntityManagerFactory: Es la clase fábrica de EntityManager. Crea y gestiona múltiples instancias de EntityManager. EntityManager: Es una interfaz. Controla las operaciones de persistencia de objetos. Es aplicable a instancias de Query. @Entity marca la clase como: La entidad es un objeto persistente almacenado como registro en la base de datos. Unidad de persistencia: Define un conjunto de todas las clases de entidad. En la aplicación, la instancia de EntityManager las gestiona. Un conjunto de clases de entidad representa los datos que se contienen en un solo almacenamiento de datos. EntityTransaction: Tiene una relación con la clase EntityManageruno a unorelación. Para cada EntityManager, las operaciones son mantenidas por la clase EntityTransaction. Consulta: Esta interfaz es implementada por cada proveedor de JPA para obtener objetos de relación que cumplan con los requisitos.

relaciones de clase de JPA

Las clases y interfaces que discutimos anteriormente mantienen una relación. La siguiente figura muestra la relación entre las clases y las interfaces.

La relación entre EntityManager y EntityTransaction esuno a unoCada operación de EntityManager tiene una instancia de EntityTransaction. La relación entre EntityManageFactory y EntityManager esuno a muchosEsta es la clase fábrica de instancias de EntityManager. La relación entre EntityManager y Query esuno a muchosPodemos ejecutar cualquier cantidad de consultas utilizando la instancia de la clase EntityManager. La relación entre EntityManager y Entity esuno a muchosLa instancia de EntityManager puede administrar múltiples entidades.

implementación de JPA

JPA es una API de código abierto. Hay varios proveedores empresariales, como Eclipse, RedHat, Oracle, etc., que proporcionan nuevos productos al agregar JPA. Algunos marcos de implementación populares de JPA son Hibernate, EclipseLink, DataNucleus etc. También se conoce comomapeo de objeto-relacional(Herramientas ORM).

mapeo de objeto-relacional (ORM)

En ORM, el mapeo de objetos Java a tablas de bases de datos (y viceversa) se llamamapeo de objeto-relacional. La mapeo ORM actúa comobase de datos relacionaly (tablas y registros) y aplicación Javapuente entre (clases y objetos).

Como se muestra a continuación en la figura, la capa ORM es una capa de adaptador. Adaptará el lenguaje del grafo de objetos al lenguaje de SQL y de tablas relacionales.

La capa ORM existe entre la aplicación y la base de datos. Transforma las clases y objetos Java para que puedan almacenarse y administrarse en una base de datos relacional. Por defecto, el nombre de la persistencia se convertirá en el nombre de la tabla, y los campos en columnas. Una vez que la aplicación se establece, cada fila de tabla se corresponde con un objeto.

versión de JPA

Las versiones tempranas de EJB definieron una capa persistente que se combina con la lógica de negocio. Se utiliza javax.ejb.EntityBean 接口。 EJB规范包括JPA的定义。

在引入EJB 3.0时，持久层被分离并指定为JPA 1.0(Java Persistence API)。该API的规范已与2006年5月11日使用JSR 220的JAVA EE5规范一起发布。

2019年，JPA重命名为 Jakarta Persistence 。 JPA的最新版本是 2.2 。它支持以下功能:

Java 8，数据和时间API AttributeConvertes中的CDI注入它使注解@Repeatable

JPA和Hibernate之间的区别

JPA: JPA是一种Java规范，用于访问，管理和持久化之间的数据Java对象和关系数据库。这是ORM的标准方法。

Hibernate: 这是一种轻量级的开源ORM工具，用于在关系数据库系统中存储Java对象。它是JPA的提供者。它遵循JPA提供的一种通用方法。

下表描述了JPA和Hibernate之间的区别。

Spring Boot启动程序数据JPA

Spring Boot提供了启动程序依赖项 spring-boot-starter-data-jpa 以连接Spring Boot应用程序高效地使用关系数据库。 spring-boot-starter-data-jpa在内部使用spring-boot-jpa依赖项。

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

Ejemplo Spring Boot JPA

Creamos una aplicación Spring Boot que se conecta a la base de datos utilizando JPA. En el siguiente ejemplo, usamos una base de datos en memoria Apache Derby。

Apache Derby : Esto es una base de datos integradaSoftware de código abiertoBase de datos relacional implementada completamente en Java. Está bajo la Licencia Apache 2Disponible bajo la versión .0. Apache Derby tiene los siguientes beneficios:

Fácil de instalar, desplegar y usar.Basado en Java, JDBC y estándares SQL.Proporciona un controlador JDBC嵌入式 que nos permite integrar Derby en cualquier solución basada en Java.También ofrece soporte para clientes a través del controlador JDBC de Cliente de Red Derby y Servidor de Red Derby./modo servidor.

Spring Boot puede configurar automáticamente la base de datos嵌入式, por ejemplo H2，HSQL，y Bases de datos Derby . No necesitamos proporcionar ninguna URL de conexión. Solo necesitamos incluir la dependencia de construcción de la base de datos嵌入式 que se utilizará.

En Spring Boot, simplemente añada en el pom Derby Añadir la dependencia para integrar fácilmente la base de datos Apache Derby. archivo xml.

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

Pasos1: Abrir Spring Initializr https://start.spring.io/.

Pasos2: Elegir la última versión de Spring Boot 2.3.0(SNAPSHOT)

Pasos3: proporcionarGrupoNombre. Hemos proporcionado com.w3codebox.

Pasos4: proporcionarArtificio ID. Hemos proporcionado apache-derby-ejemplo .

Pasos5: Añadir dependencias: Spring Web, Spring Data JPAy Base de datos Apache Derby.

Pasos6: Hacer clic Generar (Generar) botón. Al hacer clic en el botón "Generar", se empaquetará el proyecto en un archivo Jar y se descargará en el sistema local.

Pasos7: Extraer un archivo Jar y pégalo en el área de trabajo de STS.

Pasos8: Importar

Archivo->Importar->Proyecto Maven existente->Navegar->Elegir carpeta apache-derby-ejemplo-完成

La importación lleva un tiempo.

Pasos9: en la carpeta src/main/javaen la creación de un nombre com.w3codebox.model paquete.

Pasos10: en el paquete com.w3codebox.model en la creación de un nombre codebox.model UserRecord

de la clase, luego ejecutar lo siguiente: definir tres variables.id, nombre y correo electrónico
generar Getter y Setter.-> Botón derecho del ratón en el archivo-> Fuente > Generar Getter y Setterusando la anotación definir el constructor por defecto.@Entity marca la clase como. usando la anotación @Id marca Id marcar como clave primaria.

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;
//constructor por defecto　　
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;　　
}　　
}

Pasos11: en src/main/Crear un archivo con el nombre en el directorio com.w3codebox.controller paquete.

Pasos12: en el paquete com.w3codebox.controller en la creación de un nombre UserController clase Controller, y realizar las siguientes operaciones:

usando la anotación @RestController marcar la clase como controlador.usando la anotación @Autowired clase de conexión automática UserService .definimos dos mapeos, uno se utiliza paraobtener todos los usuariosotro mapeo se utiliza paraAgregar usuario.

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

Pasos13: en la carpeta src/main/crear un nombre en java com.w3codebox.service paquete.

Pasos14: en el paquete com.w3codebox.service en la creación de un nombre UserController de la clase Service y realizar las siguientes operaciones:

usando la anotación @Servicemarcar esta clase como servicio. conexión automática UserRepository definir el método getAllUsers()el método devuelve la siguiente lista: definir otro nombre para el método addUser()para guardar el registro del usuario.

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

Pasos15: en la carpeta src/main/javaen la creación de un nombre com.w3codebox.repository paquete.

Pasos16: en el paquete com.w3codebox.repository en la creación de un nombre UserRepository la interfaz de almacenamiento, y extiende 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>　
{　　
}

Pasos17: Ahora, abra ApacheDerbyExampleApplication.java El archivo. Se crea por defecto cuando configuramos la aplicación.

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

Ahora, hemos configurado todos los clases y paquetes necesarios según el requisito. Tenga en cuenta que no hemos proporcionado nada para la base de datos.URL de conexión . Después de completar todos los pasos anteriores, la estructura del directorio del proyecto es la siguiente:

Vamos a ejecutar la aplicación.

Pasos18: Abrir ApacheDerbyExampleApplication.java Ejecutar el archivo como aplicación Java.

El19Paso: Abra el navegador y llame a la URL http://localhost:8080/. Dado que no se ha agregado ningún usuario a la lista, se devuelve una lista vacía.

Para agregar usuarios a la base de datos, utilizaremosEnviar POST Solicitud de Postman.

Pasos20: AbrirPostman， luego ejecutar las siguientes operaciones:

Elegir POST Llamar a la URL http://localhost:8080/add-user。Hacer clicBody Elegir Content-Type comoJSON (application/json).Inserta los datos que se van a insertar en la base de datos. Hemos insertado los siguientes datos:

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

Hacer clicEnviarbotón.

Cuando hacemos clic en el botón "Enviar", se muestraEstado: 200 OK . Esto indica que la solicitud se ha ejecutado con éxito.

Pasos21: Abra el navegador y llame a la URL http: //localhost: 8080. Devuelve los usuarios que hemos insertado en la base de datos.