logo

TechCodeview

Bota de primavera JPA

¿Qué es la APP?

Bota de primavera JPA es una especificación de Java para gestionar relacional datos en aplicaciones Java. Nos permite acceder y conservar datos entre objetos/clases Java y bases de datos relacionales. APP sigue Mapeo de relación de objetos (ORM). Es un conjunto de interfaces. También proporciona un tiempo de ejecución. Administrador de entidades API para procesar consultas y transacciones sobre los objetos en la base de datos. Utiliza un lenguaje de consulta orientado a objetos independiente de la plataforma, JPQL (Java Persistent Query Language).

En el contexto de la persistencia, cubre tres áreas:

  • La API de persistencia de Java
    • Objeto-relacionalmetadatos
  • La API en sí, definida en el persistencia paquete

JPA no es un marco. Define un concepto que puede ser implementado por cualquier marco.

¿Por qué deberíamos utilizar JPA?

JPA es más simple, más limpio y menos laborioso que JDBC, SQL y el mapeo escrito a mano. JPA es adecuado para aplicaciones complejas no orientadas al rendimiento. La principal ventaja de JPA sobre JDBC es que, en JPA, los datos están representados por objetos y clases, mientras que en JDBC los datos están representados por tablas y registros. Utiliza POJO para representar datos persistentes que simplifica la programación de la base de datos. Hay algunas otras ventajas de JPA:

  • JPA evita escribir DDL en un dialecto SQL específico de la base de datos. En lugar de esto, permite mapear en XML o usar anotaciones Java.
  • JPA nos permite evitar escribir DML en el dialecto SQL específico de la base de datos.
  • JPA nos permite guardar y cargar objetos y gráficos Java sin ningún lenguaje DML.
  • Cuando necesitamos realizar consultas JPQL, nos permite expresar las consultas en términos de entidades Java en lugar de la tabla y columnas SQL (nativas).

Características de la APP

Existen las siguientes características de JPA:

  • Es un repositorio potente y personalizado. abstracción de mapeo de objetos.
  • Es compatible con persistencia entre tiendas . Significa que una entidad se puede almacenar parcialmente en MySQL y Neo4j (Sistema de gestión de bases de datos de gráficos).
  • Genera consultas dinámicamente a partir del nombre de los métodos de consulta.
  • Las clases base de dominio proporcionan propiedades básicas.
  • Apoya la auditoría transparente.
  • Posibilidad de integrar código de repositorio personalizado.
  • Es fácil de integrar con Spring Framework con el espacio de nombres personalizado.

Arquitectura APP

JPA es una fuente para almacenar entidades comerciales como entidades relacionales. Muestra cómo definir un POJO como una entidad y cómo gestionar entidades con relación.

La siguiente figura describe la arquitectura de nivel de clase de JPA que describe las clases e interfaces principales de JPA que se definen en el persistencia javax paquete. La arquitectura JPA contiene las siguientes unidades:

    Persistencia:Es una clase que contiene métodos estáticos para obtener una instancia de EntityManagerFactory.EntityManagerFábrica:Es una clase de fábrica de EntityManager. Crea y gestiona múltiples instancias de EntityManager.Administrador de entidades:Es una interfaz. Controla las operaciones de persistencia sobre objetos. Funciona para la instancia de Query.Entidad:Las entidades son los objetos de persistencia almacenados como un registro en la base de datos.Unidad de Persistencia:Define un conjunto de todas las clases de entidades. En una aplicación, las instancias de EntityManager la administran. El conjunto de clases de entidad representa los datos contenidos en un único almacén de datos.Transacción de entidad:Tiene un cara a cara relación con la clase EntityManager. Para cada EntityManager, las operaciones las mantiene la clase EntityTransaction.Consulta:Es una interfaz implementada por cada proveedor de JPA para obtener objetos de relación que cumplan con los criterios.
Bota de primavera jpa

Relaciones de clase JPA

Las clases e interfaces que hemos comentado anteriormente mantienen una relación. La siguiente figura muestra la relación entre clases e interfaces.

Bota de primavera jpa
  • La relación entre EntityManager y EntiyTransaction es cara a cara . Hay una instancia de EntityTransaction para cada operación de EntityManager.
  • La relación entre EntityManageFactory y EntiyManager es uno a muchos . Es una clase de fábrica para la instancia de EntityManager.
  • La relación entre EntityManager y Query es uno a muchos . Podemos ejecutar cualquier número de consultas utilizando una instancia de la clase EntityManager.
  • La relación entre EntityManager y Entity es uno a muchos . Una instancia de EntityManager puede gestionar múltiples entidades.

Implementaciones APP

JPA es una API de código abierto. Hay varios proveedores empresariales, como Eclipse, RedHat, Oracle, etc., que ofrecen nuevos productos agregando JPA en ellos. Existen algunos marcos de implementación JPA populares, como Hibernar, EclipseLink, DataNucleus, etc. También se le conoce como Mapeo de relación de objetos (ORM) herramienta.

Mapeo de relación de objetos (ORM)

En ORM, el mapeo de objetos Java a tablas de bases de datos y viceversa se llama Mapeo relacional de objetos. El mapeo ORM funciona como un puente entre un base de datos relacional (tablas y registros) y aplicación java (clases y objetos).

En la siguiente figura, la capa ORM es una capa adaptadora. Adapta el lenguaje de gráficos de objetos al lenguaje de SQL y tablas de relaciones.

Bota de primavera jpa

La capa ORM existe entre la aplicación y la base de datos. Convierte las clases y objetos de Java para que puedan almacenarse y administrarse en una base de datos relacional. De forma predeterminada, el nombre que persiste se convierte en el nombre de la tabla y los campos se convierten en columnas. Una vez que se configura una aplicación, cada fila de la tabla corresponde a un objeto.

Versiones JPA

Las versiones anteriores de EJB definen la capa de persistencia combinada con la capa de lógica de negocios usando javax.ejb.EntityBean Interfaz. La especificación EJB incluye la definición de JPA.

Al introducir EJB 3.0, la capa de persistencia se separó y se especificó como JPA 1.0 (Java Persistence API). Las especificaciones de esta API se publicaron junto con las especificaciones de JAVA EE5 el 11 de mayo de 2006, utilizando JSR 220.

En 2019, JPA pasó a llamarse Persistencia de Yakarta . La última versión de JPA es 2.2 . Admite las siguientes características:

  • Java 8, API de datos y tiempo
  • Inyección CDI en AttributeConvertes
  • Hace anotaciones @Repeatable

Diferencia entre JPA e Hibernación

APP: JPA es una especificación de Java que se utiliza para acceder, administrar y conservar datos entre objetos Java y bases de datos relacionales. Es un enfoque estándar para ORM.

Hibernar: Es una herramienta ORM liviana y de código abierto que se utiliza para almacenar objetos Java en el sistema de base de datos relacional. Es un proveedor de JPA. Sigue un enfoque común proporcionado por JPA.

La siguiente tabla describe las diferencias entre JPA e Hibernate.

APP Hibernar
APP es un especificación de Java para mapear datos de relaciones en una aplicación Java. Hibernar es un marco ORM que se ocupa de la persistencia de datos.
JPA no proporciona ninguna clase de implementación. Proporciona clases de implementación.
Utiliza un lenguaje de consulta independiente de la plataforma llamado JPQL (Lenguaje de consulta de persistencia de Java). Utiliza su propio lenguaje de consulta llamado HQL (Hibernar lenguaje de consulta).
Se define en javax.persistencia paquete. Se define en org.hibernar paquete.
Se implementa en varias herramientas ORM como Hibernar, EclipseLink, etc. Hibernar es el proveedor del PSD.
Usos de la APP Administrador de entidades para manejar la persistencia de datos. En usos de hibernación Sesión para manejar la persistencia de datos.

Datos de inicio de Spring Boot JPA

Spring Boot proporciona dependencia inicial datos-de-arranque-de-arranque-de-primavera-jpa para conectar la aplicación Spring Boot con la base de datos relacional de manera eficiente. Spring-boot-starter-data-jpa utiliza internamente la dependencia spring-boot-jpa.

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

Ejemplo de JPA de arranque de primavera

Creemos una aplicación Spring Boot que use JPA para conectarse a la base de datos. En el siguiente ejemplo, hemos utilizado una base de datos en memoria. Derbi apache.

Derbi apache: Es un de código abierto, integrado Base de datos relacional implementada íntegramente en Java. Está disponible bajo la licencia Apache 2.0. Existen las siguientes ventajas de Apache Derby:

  • Es fácil de instalar, implementar y usar.
  • Está basado en los estándares Java, JDBC y SQL.
  • Proporciona un controlador JDBC integrado que nos permite integrar Derby en cualquier solución basada en Java.
  • También admite el modo cliente/servidor con el controlador JDBC de Derby Network Client y Derby Network Server.

Spring Boot puede configurar automáticamente una base de datos integrada como H2, HSQL, y bases de datos derby . No necesitamos proporcionar ninguna URL de conexión. Solo necesitamos incluir una dependencia de compilación en la base de datos integrada que queremos usar.

En Spring Boot, podemos integrar fácilmente la base de datos Apache Derby simplemente agregando derby dependencia en el archivo pom.xml.

 org.apache.derby derby runtime

Paso 1: Abrir inicializador de primavera https://start.spring.io/ .

Paso 2: Seleccione la última versión de Spring Boot 2.3.0 (INSTANTÁNEA)

Paso 3: Proporcionar la Grupo nombre. Hemos proporcionado com.javatpoint.

si por rudyard kipling resumen

Etapa 4: Proporcionar la Artefacto Identificación. Hemos proporcionado ejemplo-apache-derby .

Paso 5: Agregue las dependencias: Spring Web, datos de primavera JPA, y Base de datos Apache Derby .

Paso 6: Clickea en el Generar botón. Cuando hacemos clic en el botón Generar, envuelve el proyecto en un archivo Jar y lo descarga al sistema local.

Bota de primavera jpa

Paso 7: extraer el archivo Jar y péguelo en el espacio de trabajo STS.

Paso 8: Importar la carpeta del proyecto en STS.

Archivo -> Importar -> Proyectos Maven existentes -> Examinar -> Seleccione la carpeta apache-derby-example -> Finalizar

La importación lleva algún tiempo.

Paso 9: Crea un paquete con el nombre com.javatpoint.model en la carpeta src/principal/java.

Paso 10: Crea una clase con el nombre. Registro de usuario en el paquete com.javatpoint.model y haz lo siguiente:

  • Definir tres variables identificación, nombre, y correo electrónico .
  • Generar captadores y definidores.
    Haga clic derecho en el archivo -> Fuente -> Generar captadores y definidores
  • Defina un constructor predeterminado.
  • Marcar la clase como Entidad usando la anotación @Entidad.
  • Marca Identificación como clave principal mediante el uso de la anotación @Identificación.

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

Paso 11: Crea un paquete con el nombre com.javatpoint.controller en la carpeta src/principal/java.

Paso 12: Crea una clase de controlador con el nombre Controlador de usuario en el paquete com.javatpoint.controller y haz lo siguiente:

  • Marcar la clase como controlador usando la anotación @RestController.
  • Autocableado la clase Servicio de usuario usando la anotación @autocableado .
  • Hemos definido dos mapeos, uno para obteniendo todos los usuarios y el otro para agregar usuario.

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

Paso 13: Crea un paquete con el nombre com.javatpoint.servicio en la carpeta src/principal/java.

Paso 14: Crea una clase de servicio con el nombre Servicio de usuario en el paquete com.javatpoint.servicio y haz lo siguiente:

  • Marcar la clase como servicio usando la anotación. @Servicio.
  • Autocableado el Repositorio de usuarios
  • Definir un método obtener todos los usuarios() que devuelve una lista de
  • Definir otro nombre de método agregar usuario() que guarda el registro del usuario.

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

Paso 15: Crea un paquete con el nombre com.javatpoint.repositorio en la carpeta src/principal/java.

Paso 16: Cree una interfaz de repositorio con el nombre Repositorio de usuarios en el paquete com.javatpoint.repositorio y se extiende Repositorio Crud .

UserRepository.java 

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

Paso 17: Ahora, abre el ApacheDerbyExampleApplication.java archivo. Se crea de forma predeterminada cuando configuramos una aplicación.

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

Ahora hemos configurado todas las clases y paquetes necesarios de acuerdo con los requisitos. Tenga en cuenta que no hemos proporcionado ningún URL de conexión para la base de datos. Después de completar todos los pasos anteriores, el directorio del proyecto tiene el siguiente aspecto:

Bota de primavera jpa

Ejecutemos la aplicación.

Paso 18: Abre el ApacheDerbyExampleApplication.java archivo y ejecútelo como aplicación Java.

Paso 19: Abra el navegador e invoque la URL http://localhost:8080/. Devuelve una lista vacía porque no hemos agregado ningún usuario a la Lista.

Para agregar un usuario a la base de datos, le enviaremos un CORREO solicitar utilizando el Cartero .

Paso 20: Abre el Cartero y haz lo siguiente:

  • Selecciona el CORREO
  • Invoque la URL http://localhost:8080/add-user.
  • Clickea en el Cuerpo
  • Seleccione tipo de contenido como JSON (aplicación/json).
  • Inserte los datos que desea insertar en la base de datos. Hemos insertado los siguientes datos:
 { 'id': '001', 'name': 'Tom', 'email': '[email protected]' }
  • Clickea en el Enviar botón.
Bota de primavera jpa

Cuando hacemos clic en el botón Enviar, se muestra Estado: 200 OK . Significa que la solicitud se ha ejecutado con éxito.

Paso 21: Abra el navegador e invoque la URL http://localhost:8080. Devuelve el usuario que hemos insertado en la base de datos.

Bota de primavera jpa
Descargar proyecto de ejemplo de Apache Derby