9.5.

JPA
http://www.oracle.com/technetwork/articles/javaee/jpa-137156.html

JPA o Java Persistence API es un framework de Java EE que permite gestionar la información almacenada en
sistemas gestores de bases de datos relacionales desde Java, de una forma sencilla. Para ello, posee tres
elementos de programación:

 El conjunto de clases de acceso a los datos (API), sustituyendo a JDBC.

 JPQL (Java Persistence Query Language): un lenguaje propio de creación de consultas muy similar a SQL.
Se crean las consultas preparadas (similar a las Prepared Statement) asociadas a cada entidad mediante
anotaciones del tipo
 La transición transparente para el programador del modelo relacional al modelo orientado a objetos.

@NamedQueries({
@NamedQuery(name = "Producto.findById", query = "SELECT p FROM Producto p
WHERE p.id = :id")
})

Código 40. Ejemplo de consulta JPQL mediante JPA.

Entre las implementaciones más conocidas de la especificación de JPA (JSR-317) están: TopLink, EclipseLink,
OpenJPA, DataNucleus e Hibernate.

A continuación se muestra un resultado de rendimiento publicado por JPA Performance Benchmarking

(http://www.jpab.org) y elaborado por ObjectDB. Se puede observar el resultado similar obtenido entre todos
los proveedores de soluciones relacionales-objeto. Mejor, cuanto más alto.

Figura 36. Comparativa de rendimiento entre proveedores JPA. Fuente: http://www.jpab.org

Profundizando en los resultados de Hibernate con EclipseLink , se obtienen los siguientes resultados (mejor,
cuanto más alto):

Figura 37. Comparativa de rendimiento entre JPA e Hibernate con MySQL. Fuente: http://www.jpab.org

A continuación se detallarán las acciones para incorporar JPA mediante EclipseLink a nuestro proyecto Java.

1. Creación de la base de datos. Este paso es muy importante, ya que las tablas definidas representarán la
estructura de nuestros futuros objetos Java.

Figura 38. Estructura de la tabla Producto en la base de datos MySQL.

2. Creación de las entidades. Las entidades son Java Beans asociados a una tabla que representarán
nuestra lógica de objetos. Mediante la opción de menú New file… se creará una entidad (Entity Class)
desde la base de datos. De esta forma, la nueva entidad tendrá la misma estructura que la declaración
de la tabla. La base de datos de la cual se desean obtener las entidades puede estar vinculada
previamente con Netbeans (ver Figura 40) o crear la conexión en esta misma pantalla.
 Figura 39. Creación de la entidad desde la base de datos. Paso 1 de 4.

Figura 40. Creación de una conexión con Netbeans.

El resto de pasos para la creación de las entidades es trivial, dejando habilitadas las opciones por defecto.

Figura 41. Resto de pasos de creación de las entidades.

En las clases generadas de forma automática se puede observar cómo mediante las anotaciones se definen las
consultas JPQL y se establecen los vínculos entre el diseño relacional y el orientado a objetos.
 Figura 42. Entidad generada automáticamente para la tabla Producto

3. Creación de una Unidad de Persistencia. La información de conexión con la base de datos se almacena
en un fichero denominado persistence.xml. Éste es creado automáticamente y no requiere ser
modificado para su correcto funcionamiento inicial.

Figura 43. Asistente de creación de Unidad de Persistencia.

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
<persistence-unit name="CarritoCompraDWRJPAPU" transaction-type="RESOURCE_LOCAL">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<class>dominio.Producto</class>
<exclude-unlisted-classes>false</exclude-unlisted-classes>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/java"/>
<property name="javax.persistence.jdbc.password" value="root"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="javax.persistence.jdbc.user" value="root"/>
</properties>
</persistence-unit>

Código 41. Fichero persistence.xml definiendo la Unidad de Persistencia “CarritoCompraDWRJPAPU”.

Al finalizar el proceso de creación de las Entidades y la Unidad de Persistencia, se puede observar cómo
automáticamente se han incorporado las librerías del framework.

Figura 44. Librerías JPA incoporporadas al proyecto.

4. Creación del objeto de acceso a datos. Creación del objeto EntityManager para la manipulación de la
base de datos. En el siguiente código de ejemplo se puede observar como a diferencia del código JDBC,
se prescinde la de la utilización de SQL (se invoca las sentencias JPQL declaradas en cada entidad). Como
elementos personalizables a destacar, están:
a. La especificación de la Unidad de Persistencia para la creación del objeto EntityManager:
CarritoCompraDWRJPAPU
b. La especificación de la consulta deseada, declarada en la entidad: Producto.findById,
Producto.findAll, etc. mediante la utilizació de un objeto Query.
c. Creación de transacciones: EntityTransaction.
d. Inserción de objetos mediante el método persist(Object).
package dao;

import dominio.Producto;

import java.util.Collection;
import java.util.Iterator;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class DAOPersona

{
private EntityManager em;

public DAOPersona ()
{
EntityManagerFactory emf =
Persistence.createEntityManagerFactory("CarritoCompraDWRJPAPU");
em = emf.createEntityManager();
}

public Producto getProductos(int id)

{
Query qry = em.createNamedQuery("Producto.findById");
Collection lista = qry.setParameter("id", id).getResultList();
Producto p = null;
if(lista.size()>0)
{
Iterator it = lista.iterator();
p = (Producto) it.next();
}
return p;
}

public Collection<Producto> getProductos()

{
Query qry = em.createNamedQuery("Producto.findAll");
Collection lista = qry.getResultList();
return lista;
}

public boolean createProducto(Producto p)

{
EntityTransaction transaccion = em.getTransaction();
transaccion.begin();
em.persist(p);
transaccion.commit();
return true;
}
}

Código 42. Definición de la clase que manipulará el EntityManager de la unidad de persitencia.