Hable sobre cómo usar Spring Data JPA para conservar datos

1 JPA

JPA se llama API de persistencia de Java (API de persistencia de Java), es la especificación de persistencia de Java propuesta en jdk 5. Proporciona a los desarrolladores una herramienta de mapeo de objetos / asociaciones para administrar datos relacionales en aplicaciones, lo que simplifica la persistencia de los objetos Java. Muchos marcos de ORM implementan especificaciones JPA, como Hibernate, EclipseLink, etc.

1.1 Marco de persistencia de Java

Hay dos formas de que Java Persistence Framework acceda a la base de datos. Una especie de operación JDBC que toma SQL como núcleo y encapsula en cierto grado, como por ejemplo: MyBatis framework. El otro se basa en clases de entidad Java para establecer la relación de mapeo entre clases de entidad y tablas de base de datos, es decir, marcos ORM, como Hibernate, Spring Data JPA.

1.2 especificación JPA

Metadatos de mapeo ORM: JPA admite dos formatos de metadatos: XML y anotaciones. Los metadatos se utilizan para describir la relación de mapeo entre objetos y tablas, y el marco conservará los objetos de entidad en las tablas de la base de datos en consecuencia.
API JPA: se utiliza para manipular objetos de entidad y realizar operaciones CRUD. Para operaciones CRUD simples, los desarrolladores no necesitan escribir código.
Lenguaje de consulta JPQL: consulta datos de forma orientada a objetos.

1.3 Hibernar

El marco de Hibernate puede mapear objetos de modelos de datos en aplicaciones a tablas de bases de datos relacionales.

JPA es una especificación e Hibernate es un marco de implementación de JPA.

2 Spring Data JPA

Spring Data JPA es un conjunto de marco de aplicación JPA encapsulado sobre la base de la implementación de la especificación JPA. Use Spring Data JPA para cambiar fácilmente entre diferentes marcos ORM sin cambiar el código. El objetivo de Spring Data JPA es unificar la operación de la capa de persistencia de acceso del marco ORM para mejorar la eficiencia del desarrollo.

Spring Data JPA es solo una capa de abstracción, que se utiliza principalmente para reducir la cantidad de código repetitivo necesario para implementar la capa de acceso a datos para el almacenamiento de varias capas de persistencia. Su capa de implementación JPA se implementa utilizando el marco de Hibernate.

2.1 Introducción de paquetes de dependencia

En las aplicaciones Spring Boot, solo necesita abrir pom.xml y agregar una dependencia Spring Data JPA. Esta dependencia no solo presentará Spring Data JPA, sino que también presentará de manera transitiva a Hibernate como una implementación de JPA.

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

2.2 Anotación de clase de entidad

（1） @Entidad

La anotación de clase, que se utiliza para identificar esta clase de entidad, es una entidad JPA.

(2) @Table (name = "nombre de tabla personalizado")

Anotación de clase, utilizada para personalizar el nombre de la tabla correspondiente a la clase de entidad en la base de datos, el valor predeterminado es el nombre de la clase de entidad. Especialmente aquellos nombres de clase de entidad que se utilizan como palabras clave de la base de datos, esta anotación se utilizará para especificar el nombre de la tabla.

（3） @Id

Anotación de variable de clase, utilizada para especificar la clave principal.

（4） @GeneratedValue

Las anotaciones de variables de clase se utilizan para especificar la estrategia de generación de la clave principal.

Contiene el atributo de estrategia, que se describe a continuación:

estrategia	Descripción
AUTO	Controlado por el programa, opción predeterminada
IDENTIDAD	Generado por el modelo de crecimiento propio de la base de datos, adecuado para MySQL
SECUENCIA	Generado por secuencia de base de datos, adecuado para Oracle
Mesa	Generado a partir de la tabla especificada

（5） @ Básico

Especifique la relación de mapeo entre el método de lectura de la variable de clase y el campo de la tabla de la base de datos. Para los métodos getXxxx () sin anotaciones especiales, la anotación @Basic se adjunta de forma predeterminada. En otras palabras, a menos que existan circunstancias especiales, todas las variables de clase se anotan con @Basic y estas variables se asignan a los campos de tabla especificados.

La anotación @Basic tiene un atributo de recuperación para indicar la estrategia de lectura. Hay dos estrategias, EAGER y LAZY, que se expresan respectivamente como lectura activa y carga diferida. El valor predeterminado es EAGER.

（6） @Columna

Indica la descripción de la columna, si el nombre del campo es el mismo que el de la columna, se puede omitir.

La anotación @Column tiene los siguientes atributos:

Atributos	Descripción
nombre	El nombre del campo correspondiente en la tabla de la base de datos.
longitud	La longitud del campo. Es válido cuando el tipo de campo es varchar; el valor predeterminado es 255 caracteres.
anulable	Si puede ser un valor nulo, el valor predeterminado es verdadero.
precisión y escala	Representa precisión. Cuando el tipo de campo es doble, la precisión representa la longitud total del valor y la escala representa el número de dígitos ocupados por el punto decimal.

（7） @Transitorio

La anotación de la variable de clase indica que la variable no es una asignación de campo a una tabla de base de datos. Debido a que la anotación predeterminada de las variables de clase es @Basic, esta anotación se utilizará para las variables de clase no persistentes en algunos escenarios.

（8） @Temporal

Anotación de variable de clase (también disponible en el método getXxx), que indica el formato de hora. Las instrucciones específicas son las siguientes:

gramática	Descripción
@Temporal (TemporalType.DATE)	Fecha, como 2020-10-10
@Temporal (TemporalType.TIME)	Tiempo, como 10:10:10
@Temporal (TemporalType.TIMESTAMP)	Valor predeterminado; fecha + hora, como 2020-10-10 10:10:10

Craig Walls dio un ejemplo de código de entidad:

@Data
@RequiredArgsConstructor
@NoArgsConstructor(access = AccessLevel.PRIVATE, force = true)
@Entity
public class Ingredient {
    @Id
    private final String id;
    private final String name;
    private final Type type;

    public static enum Type {
        WRAP, PROTEIN, VEGGIES, CHEESE, SAUCE
    }
}

Además de aplicar las anotaciones @Entity y @Id en el ejemplo, las anotaciones @NoArgsConstructor también se agregan a nivel de clase. Debido a que JPA requiere que las clases de entidad proporcionen un constructor sin argumentos, usamos la anotación @NoArgsConstructor de Lombok para generar este constructor.

La anotación @NoArgsConstructor también puede privatizar este constructor sin argumentos (access = AccessLevel.PRIVATE) para que no se pueda llamar directamente desde fuera.

Debido a que las variables id, nombre y tipo de esta clase no se han inicializado, también necesitamos establecer force en verdadero e inicializarlo en nulo.

Aunque la anotación @Data agregará un constructor parametrizado para nosotros, debido a que la anotación @NoArgsConstructor se agregó antes, el constructor parametrizado se ha ido. Por lo tanto, debe agregar otra anotación @RequiredArgsConstructor para forzar la generación de un constructor parametrizado.

2.3 Anotación de relación de clase de entidad

Spring Data JPA tiene cuatro tipos de anotaciones de relaciones, son @OneToOne, @OneToMany, @ManyToOne y @ManyToMany.

Estas cuatro anotaciones de relación tienen dos atributos, recuperación y cascada.

El atributo de recuperación se utiliza para especificar la estrategia de carga de retraso de datos:

Estrategia	Descripción
FetchType.LAZY	Valor predeterminado; carga diferida
FetchType.EAGER	Cargar ahora

El atributo de cascada se utiliza para especificar la estrategia de cascada:

Estrategia	Descripción
CascadeType.PERSIST	Persistencia en cascada; cuando se guarda la entidad principal, la entidad secundaria también se guarda al mismo tiempo.
CascadeType.MERGE	Unión de niveles; si se modifica la entidad secundaria, la entidad secundaria (de uso común) también se guardará cuando se guarde la entidad principal.
CascadeType.REMOVE	Eliminación en cascada; al eliminar la entidad principal, las entidades secundarias asociadas se eliminarán en cascada.
CascadeType.REFRESH	Actualización en cascada; la obtención de la entidad principal también volverá a obtener la última entidad secundaria.
CascadeType.ALL	Las cuatro estrategias anteriores
No	Defaults

Debido a que estas cuatro anotaciones solo pueden expresar una relación de unos pocos a varios entre entidades, para especificar el campo de columna en la tabla de la base de datos asociada con la entidad en la que se está operando, debe usar la anotación @JoinColumn.

Suponga que existe tal conjunto de relaciones entre entidades. Un usuario tiene una contraseña; un usuario pertenece a un departamento y un departamento tiene múltiples usuarios; un usuario puede tener múltiples roles y un rol también puede contener múltiples usuarios.

（1） @OneToOne

@OneToOne se utiliza para representar una relación uno a uno y se coloca en la clase dominante. Por ejemplo, la clase de usuario tiene una clave primaria pwd_id que especifica la tabla de contraseñas. Poner @OneToOne en el campo pwd de la clase de usuario puede indicar que la clase de usuario y la clase de contraseña tienen una relación de uno a uno, y la clase dominante es la clase de usuario.

@OneToOne
@JoinColumn(name = "pwd_id")
private Password pwd;

Tampoco puede usar @JoinColumn, Hibernate generará automáticamente campos relacionados en la tabla de usuario. La regla de nomenclatura predeterminada para los campos es "nombre de clase subordinada_clave principal subordinada", como contraseña_id.

A veces verá la anotación @PrimaryKeyJoinColumn (nombre = "..."), de hecho, es esencialmente una combinación de @Id y @JoinColumn (nombre = "...").

（2） @OneToMany

Al analizar la relación entre usuarios y departamentos, se encuentra que un usuario solo puede pertenecer a un departamento y un departamento puede contener múltiples usuarios. Entonces, si lo miras desde la perspectiva del departamento

Al analizar la relación entre usuarios y departamentos, un empleado solo puede pertenecer a un departamento, pero un departamento puede contener varios empleados. Si lo miramos desde la perspectiva del departamento, existe una relación de uno a muchos entre departamentos y empleados. , Agregue la siguiente anotación en la clase de entidad Departamento Departamento:

1.	@OneToMany
2.	@JoinColumn(name = "department_id")
3.	private List<User> user;

Si no especifica la anotación @JoinColumn, Hibernate generará automáticamente una tabla intermedia para vincular usuarios y departamentos.La regla de nomenclatura predeterminada para esta tabla intermedia es: nombre de la tabla de clase de entidad nombre de atributo especificado en la clase de entidad. Por ejemplo, si la tabla de departamentos se denomina t_department y el atributo de colección de usuarios asociado en la clase de entidad de departamento se denomina user, la tabla intermedia predeterminada generada se denomina t_department_user.
En la práctica, recomendamos usar la anotación @JoinTable para especificar directamente la tabla intermedia:

@OneToMany
@JoinTable(name = " t_department_user ", joinColumns = {
@JoinColumn(name = "department_id") }, inverseJoinColumns = { @JoinColumn(name = "user_id") })
private List<User> users;

El atributo de nombre en @JoinColumn se usa para especificar el ID de asociación de la tabla correspondiente a la clase de entidad actual (departamento); el atributo inverseJoinColumns se usa para especificar el ID de asociación de la tabla de clase de entidad asociada (empleado), y la anotación @JoinColumn está incrustada.

(3) @ManyToOne (muchos a uno)

Si miramos la relación entre usuarios y departamentos desde la perspectiva de los usuarios, se convierten en una relación de varios a uno (varios usuarios pertenecen a un departamento). Agregue la siguiente anotación a la clase de entidad de usuario Usuario:

@ManyToOne
@JoinColumn(name = "department_id")
private Department department;

(4) @ManyToMany (muchos a muchos)

Existe una relación de muchos a muchos entre usuarios y roles, porque un usuario puede tener múltiples roles y un rol también puede pertenecer a varios empleados. Las relaciones de varios a varios se asocian generalmente mediante la creación de una tabla intermedia, y en este momento se usa la anotación @JoinTable.

Agregue las siguientes anotaciones a la clase de entidad de usuario:

@ManyToMany
@JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "user_id") }, inverseJoinColumns = {
@JoinColumn(name = "role_id") })
private List<Role> roles;

Agregue las siguientes anotaciones a la clase de entidad de rol:

@ManyToMany
@JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "role_id") }, inverseJoinColumns = {
@JoinColumn(name = "user_id") })
private List<User> users;