Programación IV. Guía No.

6 1

Facultad: Informática y Ciencias Aplicadas

Escuela: Informática
Asignatura: Programación IV

Tema: “Java Persistence API (JPA)”.

Objetivos

Comprender el funcionamiento de la API Java para persistencia de datos JPA.

Identificar las características de JPA.
Comprender el ciclo de vida de las entidades en JPA.
Manejar transacciones utilizando EJB y JPA.
Crear aplicaciones Java Web utilizando JPA.

Introducción Teórica

¿Qué es Java Persistence API - JPA?

Java Persistence API, mejor conocido como JPA, es el estándar de persistencia de datos de Java. JPA
implementa conceptos de frameworks ORM. Cuenta con varias implementaciones, tales como Hibernate,
EclipseLink, OpenJPA, entre algunas más. Así que si ya conoces Hibernate, o algún framework de
persistencia Java, te será muy familiar muchos de los conceptos que estudiaremos en esta lección.

Como podemos observar en la figura, un framework ORM nos permite "mapear" una clase Java con una tabla
de base de datos. Por ejemplo, la clase Persona, al crear un objeto en memoria, podemos almacenarlo
directamente en la tabla Persona, simplemente ejecutando una línea de código: em.persist (persona).
Esto ha simplificado enormemente la cantidad de código a escribir en la capa de datos de una aplicación
empresarial.

Arquitectura empresarial con JPA.

 2 Programación IV. Guía No. 6

En la figura anterior podemos observar el rol de JPA en una arquitectura Java Empresarial. Esta tecnología
aplica directamente en la capa de datos, la cual se encarga de tareas tales como:
▪ Recuperación de información a través de consultas (select).
▪ Manejo de información de objetos Java en las tablas de base de datos respectivas (insert, update, delete).
▪ Manejo de una unidad de persistencia (Persistence Unit) para la creación y destrucción de conexiones
a la base de datos.
▪ Manejo de transacciones, respetando el esquema de propagación definido en la capa de negocio en los
EJB de Sesión.
▪ Portabilidad hacia otras bases de datos con un impacto menor, así como bajo acoplamiento con las otras
capas empresariales.

Además, para realizar las tareas de persistencia, podemos utilizar patrones de diseño tales como:
DAO (Data Access Object): Este patrón de diseño suele definir una interfaz y una implementación de
dicha interfaz, para realizar las operaciones más comunes con la entidad respectiva. Por ejemplo, para
la entidad Persona, generaremos la interfaz DaoPersona, y agregaremos los métodos agregarPersona,
modificarPersona, eliminarPersona, buscarPersonas, etc.

DTO (Data Transfer Object): Este patrón de diseño permite definir una clase, que en ocasiones es muy
similar a la clase de entidad, ya que contiene los mismos atributos, pero con el objetivo de transmitirla
a las siguientes capas, incluso, hasta la capa Web. Por ello se les conoce como objetos de valor o de
transferencia.

En la actualidad, y con la simplificación de las capas de una arquitectura empresarial, es opcional utilizar estos
y otros patrones de diseño empresariales, sin embargo, muchas aplicaciones Java han sido construidas con
estos patrones, así que vale la pena entender para qué se utilizan y cómo aplicarlos.

Ciclo de vida en JPA.

El API de JPA simplifica en gran medida la forma en que interactuamos con una base de datos. JPA agrega un
ciclo de vida para la administración de los objetos de entidad. A continuación describimos los estados del ciclo
de vida:
 Programación IV. Guía No. 6 3

➢ Estado Transitivo (Transient):

o Los objetos de entidad nuevos NO son guardados directamente en la Base de Datos (BD).
o No están asociados con un registro de BD.
o Se consideran NO transaccionales.

➢ Estado Persistente (Managed):

o Un objeto persistente tiene asociado un registro en la BD.
o Los objetos persistentes siempre están asociados con una transacción. Su estado se sincroniza con
la BD al terminar la transacción.

➢ Estado Separado (Detached):

o Estos objetos tienen asociado un registro de BD, pero su estado no está sincronizado con la BD
o Todos los objetos recuperados en una transacción se convierten en detached una vez que termina
la misma

➢ Estado Eliminado (Removed):

o Estos objetos ya no tiene una representación con la BD y al terminar la transacción, el registro
asociado es eliminado.

Procedimiento

Crear una carpeta con el nombre Practica 6 para guardar los ejemplos y ejercicios, en el escritorio de su
computadora.

Guía 6 Ejemplo 1. Creación de base de datos en MySql.

Para la implementación del uso de JPA utilizaremos el SGBD MySql y Workbench.

Abrimos MySql Workbench y nos conectamos a la instancia local.

 4 Programación IV. Guía No. 6

Creamos un nuevo Schema y le colocamos el nombre “sistema”:

Creamos una tabla de nombre “persona” con la siguiente estructura:

El query a utilizar es el siguiente:

CREATE TABLE `sistema`.`persona` (
`id_persona` INT NOT NULL AUTO_INCREMENT,
`nombres` VARCHAR(45) NOT NULL,
`apellidos` VARCHAR(45) NOT NULL,
`email` VARCHAR(45) NOT NULL,
`telefono` VARCHAR(45) NOT NULL,
PRIMARY KEY (`id_persona`),
UNIQUE INDEX `email_UNIQUE` (`email` ASC) VISIBLE);

Agreguemos un par de registros a nuestra tabla.

Para esta guía continuaremos utilizando el proyecto creado en la guía práctica No. 5, por lo que debemos abrir
en este momento nuestro proyecto de nombre “SistemaWebJee”.
Básicamente lo que hemos hecho si vamos a la clase Persona, es crear una tabla de base de datos con los
atributos definidos; así que esta clase la vamos a convertir a una clase de Entidad utilizando JPA para que
podamos interactuar con la base de datos.

Si usted desea, puede crear una copia del proyecto realizado en la guía anterior, para tener un proyecto nuevo
para esta guía, le colocaremos el nombre “SistemaWebJeeJpa”.

Guía 6 Ejemplo 2. Creación del pool de conexiones y la unidad de persistencia.

 Programación IV. Guía No. 6 5
Debido a que esta es una aplicación empresarial y la vamos a desplegar sobre un servidor GlassFish,
necesitamos crear un pool de conexiones y posteriormente definir la unidad de persistencia que utilizará nuestro
proyecto, es decir, la definición del archivo persistence.xml.
Primero crearemos el pool de conexiones en GlassFish.
Iniciamos el servidor GlassFish.
Una vez que se ha iniciado damos clic derecho y seleccionamos la opción “View Domain Admin Console”:

Cuando carga la ventana de la consola vamos a dar clic en “Resources” y luego damos clic en “JDBC”:

Luego damos clic en la opción “JDBC Connections Pools” y damos clic en el botón “New”:
 6 Programación IV. Guía No. 6

En la ventana que aparece le colocamos como nombre “PersonaPool” y configuramos los datos indicados y
damos clic en el botón “Next”:

En la ventana que se muestra debemos proporcionar el dato “DataSource Classname” y digitamos

“com mysql.cj.jdbc.MysqlDataSource”, ya que en la versión 8 este es el valor correcto, no el que nos
proporciona automáticamente, así:

También debemos agregar las siguientes propiedades y damos clic en el botón “Finish”:

En esta nueva ventana, damos clic en el nombre del pool de conexiones que hemos creado, para probarlo:
 Programación IV. Guía No. 6 7
Ahora damos clic en el botón “Ping”, y debe aparecernos un mensaje indicándonos que se ha realizado la
conexión:

Con esto ya tenemos el pool de conexiones.

Ahora vamos de nuevo a la opción “JDBC” y damos clic en la opción “JDBC Resources” y damos clic en el
botón “New”:

Debemos proporcionar el nombre del JNDI que vamos a utilizar para nuestra aplicación, le colocaremos el
nombre “jdbc/PersonaDb”, seleccionamos el pool que acabamos de crear “personaPool” y damos clic en el
botón “Ok”:

Y con eso ya debe de estar listo la conexión JDBC desde GlassFish hacia MySQL y con esto ya tenemos
configurado la conexión que utilizará nuestra aplicación:
 8 Programación IV. Guía No. 6

El siguiente paso a realizar es crear la unidad de persistencia en nuestro proyecto.

Para ello, damos clic derecho en el nombre del proyecto, seleccionamos la opción New, luego buscamos en la
categoría “Persistence” y seleccionamos el tipo de archivo “Persistence Unit” y damos clic en el botón
“Siguiente”:

En la ventana que aparece le colocamos el nombre deseado, en este caso lo llamaremos “SistemaPU” y como
fuente de datos seleccionamos el pool de conexiones que configuramos anteriormente, es decir “personaPool”
y damos clic en el botón “Terminar”.
NOTA: Si no permitiera seleccionar el pool de conexiones, haremos los siguientes pasos.

En la ventana que aparece le colocamos el nombre deseado, en este caso lo llamaremos “SistemaPU” y como
fuente de datos seleccionamos la opción “New Database Connection”:

En la ventana que aparece en la opción Driver seleccionamos “MySQL (Connector/Jdriver)”, luego damos
clic en el botón “Add” y buscamos donde tenemos el driver de MySQL (ruta en la PC) y luego damos clic en
el botón “Next”:
 Programación IV. Guía No. 6 9

En la siguiente ventana, debemos proporcionar el nombre de nuestra BD, usuario y contraseña y modificamos
la propiedad JDBC URL, agregando los siguientes parámetros
“jdbc:mysql://localhost:3306/sistema?serverTimezone=UTC&useSSL=false&useTimezone=true”, luego
podemos probar la conexión dando clic en el botón “Test Connection”; si se realiza la conexión damos clic
en el botón “Next”:

En la siguiente ventana, damos clic en el botón “Next” y finalmente damos clic en el botón “Finish”:

De esta manera, nos aparecerá de nuevo el wizard de creación de unidad de persistencia, con la opción
Database Connection que acabamos de crear. En esta ventana damos clic en el botón “Finish”:
 10 Programación IV. Guía No. 6

De esta manera, hemos agregado la unidad de persistencia a nuestro proyecto y nos agrega el archivo
persistence.xml en la carpeta “Configuration Files”:

En este archivo, realizaremos las modificaciones necesarias para que reconozca el pool de conexiones; el
archivo persistence.xml debe quedar de la siguiente forma:
 Programación IV. Guía No. 6 11

Este archivo persistence.xml se utiliza para configurar la persistencia de nuestro proyecto. Para que este
archivo funcione correctamente, debemos agregar a nuestra instalación de GlassFish el driver para la gestión
de bases de datos de MySQL.
Procedemos a descargar el driver del sitio oficial de MySQL: https://dev.mysql.com/downloads/connector/j/
Una vez descargado el archivo, lo descomprimimos y copiamos el archivo “jar” en la ruta donde tengamos
nuestro servidor, específicamente en la carpeta “lib”.

Guía 6 Ejemplo 3. Creación de proyecto para interactuar con JPA.

Para este ejemplo, debemos empezar a convertir nuestro proyecto para que cumpla con la siguiente estructura:

Hasta el momento lo que hemos creado es la capa de servicio, la cual utiliza una interfaz local PersonaService
y tenemos la implementación del EJB llamado PersonaServiceImpl, el cual es un EJB de tipo Stateless.
Lo que vamos a hacer a continuación para comunicarnos con la base de datos es crear una capa de datos en
nuestra aplicación empresarial.
Así que vamos a crear una interfaz “PersonaDao”, la cual se va a inyectar al EJB PersonaService y por medio
de esta interfaz es que se va a comunicar con una implementación llamada “PersonaDaoImpl”, también vamos
a convertir nuestra clase Persona en una clase de entidad. Esta clase de entidad va a utilizar el concepto de
JPA para que se pueda comunicar hacia la base de datos.
 12 Programación IV. Guía No. 6

Esta implementación de PersonaDaoImpl también es un EJB y también va a utilizar el Persistence Unit de

JPA para interactuar con la base de datos, así que esta será la nueva arquitectura que vamos a desarrollar en
nuestra aplicación.

Entonces, vamos a convertir la clase Persona en una clase Entidad, es decir, realizar el mapeo para que pueda
interactuar con la base de datos utilizando JPA.
Abrimos la clase Persona y realizaremos los siguientes cambios:

Al realizar estos cambios, nos marca error la clase PersonaServiceImpl, ya que esta implementación ya no la
vamos a tener, sino que ahora lo vamos a obtener de la base de datos, así que vamos a realizar los siguientes
cambios:

Ahora, vamos a aplicar el patrón de diseño DAO (Data Access Object) y nos va a permitir poner una capa
lógica para acceder hacia la base de datos y así la capa lógica que hemos definido en la capa de servicio, va a
utilizar la capa de datos que vamos a definir a continuación.
Vamos a agregar la interfaz de nombre “PersonaDao” en un package que llamaremos “datos” y agregamos el
siguiente código:
 Programación IV. Guía No. 6 13

Esta interfaz es la que va a utilizar el EJB de servicio y con esto se va a comunicar hacia la base de datos; pero
para ello necesitamos agregar una implementación y la implementación es una clase (EJB) que tendrá el
nombre “PersonaDaoImpl”, que vamos a crear también en el package datos, y digitamos el código siguiente:
 14 Programación IV. Guía No. 6

A continuación, vamos a modificar la clase de entidad Persona. Vamos a definir un query (NamedQueries)
para recuperar todos los objetos de tipo Persona, de la siguiente manera:

De esta manera, ya tenemos completa nuestra capa lógica de datos y ya podemos interactuar completamente
con nuestra tabla personas en la base de datos.
Por último, vamos a modificar nuestra clase PersonaServiceImpl, debemos inyectar la capa de datos
(recordemos que no va a acceder directamente a la implementación, sino que vamos a utilizar la interfaz
PersonaDao). Agregamos el siguiente código:
 Programación IV. Guía No. 6 15

Podemos observar que la implementación fue muy simple debido a que ya tenemos toda la configuración en la
capa de datos y realmente es la capa de datos la que se va a encargar de interactuar con la base de datos. Pero
como estamos utilizando JPA, la interacción con la base de datos es muy simple.
De esta manera ya tenemos toda la configuración de nuestra aplicación y también toda la configuración en
GlassFish.
Así que vamos a ejecutar nuestra aplicación.

De esta forma, hemos creado nuestra primera aplicación Java web con JSF, EJB y JPA.

En esta guía, además de configurar nuestra conexión a base de datos utilizando JPA el cual nos permite delegar
los datos de conexión a GlassFish y así evitar configurar la conexión a la base de datos desde nuestra
aplicación, posteriormente realizamos la integración de la capa de datos con la capa de servicio utilizando la
notación @Inject.
Ya no tuvimos necesidad de hacer ningún cambio en la capa web, ya que la interfaz de la capa de servicio no
cambió, sólo la implementación de la misma. Esta es una de las ventajas de utilizar interfaces, ya que la
implementación de la capa de servicio pasó de contener datos en código duro a información real de una base
de datos y fue totalmente transparente para la capa web y para el cliente final.
Así que además de tecnologías como EJB y JPA, también estamos aplicando las mejores prácticas y varios
patrones de diseño que nos permiten crear aplicaciones web y empresariales robustas, escalables y más
sencillas de mantener entre varias características.

Ejercicios de práctica
 16 Programación IV. Guía No. 6

Incrementar la funcionalidad de la aplicación Web desarrollada en esta guía, de tal manera que permita realizar
todo el CRUD de la tabla persona.
Deben utilizarse mecanismos de validación para asegurar que los datos introducidos de las personas son los
esperados.
Debe validarse toda la información solicitada. En caso de inconsistencia, deben mostrarse mensajes de error
de acuerdo con los datos erróneos introducidos.