Persistencia con JPA y Apache Tapestry

En Java disponemos de varias opciones para persistir la información a una base de datos relacional, algunas de ellas son:

JDBC: es la API que viene integrada en la propia plataforma Java sin necesidad de ninguna librería adicional exceptuando el driver JDBC para acceder a la base de datos. Mediante esta opción se tiene total flexibilidad y evita la abstracción y sobrecarga de los sistemas como Hibernate y JPA. Se trabaja con el lenguaje SQL de forma directa y este lenguaje puede varia en algunos aspectos de una base de datos a otra con lo que para migrar a otra base de datos puede implicar reescribir las SQL de la aplicación. Su utilización de forma directa no es tan habitual aunque en casos que se necesite acceder de forma masiva a los datos puede se útil para evitar la sobrecarga o complejidad que añaden sistemas como Hibernate o JPA.
Hibernate: el modelo relacional de las bases de datos es distinto del modelo de objetos del los lenguajes orientados a objetos. Los sistemas ORM como Hibernate tratan de hacer converger el sistema relacional hacia un modelo más similar al modelo de objetos de lenguajes como Java, de forma que trabajar con ellos sea como trabajar con objetos. En ORM como Hibernate normalmente no se trabaja a nivel de SQL como con JDBC sino que se trabaja con objetos (POJO), las consultas devuelven objetos, las relaciones se acceden a través de propiedades y los borrados, actualizaciones y inserciones se realizan usando objetos y métodos. Los objetos POJO incluyen anotaciones que le indican a Hibernate cual es la información a persistir y las relaciones con otros POJO. Como hibernate dispone de esta información en base a ella puede recrear o actualizar las tablas y los campos necesarios según la definición de esas anotaciones. El ORM es encarga de traducir las acciones a las SQL entendidas por el sistema relacional, esto proporciona la ventaja adicional de que el ORM puede generar las sentencias SQL adaptadas a la base de datos utilizada. De esta forma se podría cambiar de una base de datos a otra sin realizar ningún cambio en la aplicación o con pocos cambios comparado con los necesarios usando JDBC. Con Hibernate se puede emplear un lenguaje de consulta similar a SQL pero adaptado al modelo orientado a objetos, el lenguaje es HQL.
JPA: es una especificación de Java que define una API común para los sistemas ORM. Con JPA podríamos cambiar de proveedor ORM sin realizar ningún cambio en la aplicación. JPA se ha basado en gran parte en Hibernate y su forma de trabajar es similar, el lenguaje HQL también es similar pero denominado JPQL.

A continuación explicaré como acceder a una base de datos relacional a través de JPA en una aplicación web usando el framework Apache Tapestry. Lo primero que deberemos hacer es crear el archivo persistence.xml donde indicaremos el driver JDBC según la base de datos que utilicemos y la URL de conexión a la base de datos entre otras opciones como el usuario y password de conexión. En el ejemplo he usado H2 como base de datos ya que puede embeberse en una aplicación sin necesidad de tener un sistema externo como ocurren en el caso de MySQL y PostgreSQL. De esta forma este ejemplo puede probarse sin necesidad de instalar previamente ninguna base de datos relacional.

	<?xml version="1.0" encoding="UTF-8"?>
	<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
	<persistence-unit name="h2">
	<provider>org.hibernate.ejb.HibernatePersistence</provider>
	<properties>
	<property name="hibernate.connection.driver_class" value="org.h2.Driver"/>
	<property name="hibernate.connection.url" value="jdbc:h2:mem:test"/>
	<property name="hibernate.connection.username" value="sa"/>
	<property name="hibernate.connection.password" value="sa"/>
	<property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
	<property name="hibernate.hbm2ddl.auto" value="update"/>
	<!-- Hibernate Search -->
	<property name="hibernate.search.default.directory_provider" value="filesystem"/>
	<property name="hibernate.search.default.indexBase" value="indexes"/>
	</properties>
	</persistence-unit>
	</persistence>

view raw persistence.xml hosted with ❤ by GitHub

En la aplicación es necesario incluir unas pocas dependencias para acceder a la API JPA.

	dependencies {
	compile 'org.apache.tapestry:tapestry5-annotations:5.3.7'
	compile 'org.apache.tapestry:tapestry-core:5.3.7'
	compile 'org.apache.tapestry:tapestry-beanvalidator:5.3.7'
	compile 'org.apache.tapestry:tapestry-jpa:5.3.7'

	compile 'org.hibernate:hibernate-core:4.2.1.Final'
	compile 'org.hibernate:hibernate-validator:5.0.1.Final'
	compile 'org.hibernate:hibernate-entitymanager:4.2.1.Final'

	compile 'com.h2database:h2:1.3.171'

	providedCompile 'javax.servlet:servlet-api:2.5'
	}

view raw build.gradle hosted with ❤ by GitHub

Una vez incluidas las dependencias debemos configurar Tapestry para que nos proporcione el soporte de acceso a una base de datos empleando JPA, definimos en el módulo de la aplicación y contenedor de dependencias, el servicio DAO y al mismo tiempo configuraremos la transaccionalidad mediante anotaciones para el DAO.

	public static void bind(ServiceBinder binder) {
	binder.bind(ValidationDecoratorFactory.class, AppValidationDecoratorFactory.class).withId("AppValidationDecoratorFactory");

	binder.bind(ProductoDAO.class, ProductoDAOImpl.class);
	}

	public static void contributeBeanValidatorSource(OrderedConfiguration<BeanValidatorConfigurer> configuration) {
	configuration.add("AppConfigurer", new BeanValidatorConfigurer() {
	public void configure(javax.validation.Configuration<?> configuration) {
	configuration.ignoreXmlConfiguration();
	}
	});
	}

	/**
	* Los servicios con una interfaz *DAO (es necesario que sea una interfaz)
	* soportan las anotaciones de transaccionalidad.
	*/
	@Match("*DAO")
	public static void adviseTransactionally(JpaTransactionAdvisor advisor, MethodAdviceReceiver receiver) {
	advisor.addTransactionCommitAdvice(receiver);
	}

view raw AppModule.java hosted with ❤ by GitHub

Las clases con capacidad de persistencia han de ubicarse en un subpaquete del paquete de Tapestry. El paquete de Tapestry es aquel que está indicado en el parámetro de contexto tapestry.app-package en el archivo web.xml de la aplicación web. Si tapestry.app-package fuese es.com.blogspot.elblogdepicodev.tapestry.jpa el paquete de las entidades debería ser es.com.blogspot.elblogdepicodev.tapestry.jpa.entities. Esta es la convención y la forma preferida de hacerlo, si se quiere cambiar es posible hacerlo mediante configuración. La entidad de persistencia que usaré para el ejemplo es la siguiente, en la que se incluyen las anotaciones de JPA:

	package es.com.blogspot.elblogdepicodev.tapestry.jpa.entities;

	import java.io.Serializable;
	import java.util.Date;

	import javax.persistence.Column;
	import javax.persistence.Entity;
	import javax.persistence.GeneratedValue;
	import javax.persistence.Id;
	import javax.validation.constraints.Max;
	import javax.validation.constraints.Min;
	import javax.validation.constraints.NotNull;

	import org.hibernate.validator.constraints.Length;

	@Entity
	public class Producto implements Serializable {

	private static final long serialVersionUID = 4301591927955774037L;

	@Id
	@GeneratedValue
	private Long id;
	@NotNull
	@Length(min = 3, max = 100)
	@Column(name = "nombre", length = 100)
	private String nombre;
	@NotNull
	@Length(min = 0, max = 5000)
	@Column(name = "descripcion", length = 5000)
	private String descripcion;
	@NotNull
	@Min(value = 0) @Max(value = 1000)
	@Column(name = "cantidad")
	private Long cantidad;
	@NotNull
	@Column(name = "fecha")
	private Date fecha;

	public Producto() {
	}

	public Producto(String nombre, String descripcion, Long cantidad, Date fecha) {
	this.nombre = nombre;
	this.descripcion = descripcion;
	this.cantidad = cantidad;
	this.fecha = fecha;
	}

	public Long getId() {
	return id;
	}

	public String getNombre() {
	return nombre;
	}

	public void setNombre(String nombre) {
	this.nombre = nombre;
	}

	public String getDescripcion() {
	return descripcion;
	}

	public void setDescripcion(String descripcion) {
	this.descripcion = descripcion;
	}

	public Long getCantidad() {
	return cantidad;
	}

	public void setCantidad(Long cantidad) {
	this.cantidad = cantidad;
	}

	public Date getFecha() {
	return fecha;
	}

	public void setFecha(Date fecha) {
	this.fecha = fecha;
	}
	}

view raw Producto.java hosted with ❤ by GitHub

El código de acceso a base de datos suele ponerse en una clase denominada servicio y DAO (Data Access Object) que contiene todo ese código. Ya que las operaciones de acceso a base de datos son candidatas a ser reutilizadas desde varias páginas o componentes es recomendable hacerlo así, además de hacer que las páginas de Tapestry sean más pequeñas (ya tienen suficiente responsabilidad con hacer de controlador en el modelo MVC) permite que si un día cambiásemos de framework web solo tendríamos que modificar la capa de presentación. Todo el código de los servicios nos serviría perfectamente sin hacer ninguna modificación.

El contenedor de dependencias se encargará en el momento que necesite construir una instancia del servicio DAO inyectarle en el constructor los parámetros necesarios. En este caso una de las clases principales de la API JPA que es EntityManager. Una vez con la referencia a entityManager trabajaríamos usando sus métodos para realizar las consultas y operaciones que necesite proporcionar el DAO.

	package es.com.blogspot.elblogdepicodev.tapestry.jpa.dao;

	import java.util.List;

	import javax.persistence.EntityManager;
	import javax.persistence.Query;
	import javax.persistence.criteria.CriteriaBuilder;
	import javax.persistence.criteria.CriteriaQuery;
	import javax.persistence.criteria.Root;

	import es.com.blogspot.elblogdepicodev.tapestry.jpa.entities.Producto;
	import es.com.blogspot.elblogdepicodev.tapestry.jpa.misc.Pagination;

	public class ProductoDAOImpl implements ProductoDAO {

	private EntityManager entityManager;

	public ProductoDAOImpl(EntityManager entityManager) {
	this.entityManager = entityManager;
	}

	@Override
	public Producto findById(Long id) {
	return entityManager.find(Producto.class, id);
	}

	@Override
	public List<Producto> findAll(Pagination paginacion) {
	CriteriaBuilder cb = entityManager.getCriteriaBuilder();
	CriteriaQuery<Producto> cq = cb.createQuery(Producto.class);
	Root<Producto> root = cq.from(Producto.class);

	cq.select(root);
	if (paginacion != null) {
	cq.orderBy(paginacion.getOrders(root, cb));
	}

	Query q = entityManager.createQuery(cq);
	if (paginacion != null) {
	q.setFirstResult(paginacion.getStart());
	q.setMaxResults(paginacion.getEnd() - paginacion.getStart() + 1);
	}

	return q.getResultList();
	}

	@Override
	public void persist(Producto producto) {
	entityManager.persist(producto);
	}

	@Override
	public void remove(Producto producto) {
	entityManager.remove(producto);
	}

	@Override
	public void removeAll() {
	Query query = entityManager.createQuery("delete from Producto");
	query.executeUpdate();
	}
	}

view raw ProductoDAOImpl.java hosted with ❤ by GitHub

Hay métodos del DAO que finalmente lanzan sentencias de inserción, modificación y borrado, este DAO es muy sencillo pero si realizase varias operaciones contra la base de datos estas deberían cumplir las reglas ACID. Para cumplir las reglas ACID hay que utilizar transacciones, se puede conseguir de forma declarativa utilizando la anotación @CommitAfter. Esta anotación inicia una transacción al iniciarse el método y lanza un commit al finalizar el método. En caso de que se produzca una excepción se seguirá haciendo commit para las excepciones checked (de obligado tratamiento o lanzado) y únicamente un rollback para las excepciones unckecked (que extienden de RuntimeException y no es necesario capturarlas o lanzarlas).

Si quisiésemos hacer rollback en una excepción checked deberíamos hacerlo manualmente capturando la excepción y lanzando una unchecked aunque si es la opción que queremos por defecto podríamos implementar una anotación para tratar la transaccionalidad de esta manera y de forma declarativa en todos los casos.

Una vez que tenemos el servicio DAO basta con inyectarlo en la clase de una página o componente y hacer uso de él. En la siguiente página se muestra un listado de productos donde con un botón se pueden eliminar y con otro se pueden crear nuevos. En la clase de la página se hace uso del DAO para buscar las entidades, crear una nueva con un nombre y descripción aleatoria y eliminar un producto.

	package es.com.blogspot.elblogdepicodev.tapestry.jpa.pages.admin;

	import java.util.Date;
	import java.util.List;
	import java.util.UUID;

	import org.apache.tapestry5.ComponentResources;
	import org.apache.tapestry5.SymbolConstants;
	import org.apache.tapestry5.annotations.Cached;
	import org.apache.tapestry5.annotations.Property;
	import org.apache.tapestry5.beaneditor.BeanModel;
	import org.apache.tapestry5.ioc.annotations.Inject;
	import org.apache.tapestry5.ioc.annotations.Symbol;
	import org.apache.tapestry5.services.BeanModelSource;

	import es.com.blogspot.elblogdepicodev.tapestry.jpa.dao.ProductoDAO;
	import es.com.blogspot.elblogdepicodev.tapestry.jpa.entities.Producto;

	public class EjemploJPA {

	@Inject
	@Symbol(SymbolConstants.TAPESTRY_VERSION)
	@Property
	private String tapestryVersion;

	@Inject
	private ProductoDAO dao;

	@Inject
	private BeanModelSource beanModelSource;

	@Inject
	private ComponentResources resources;

	@Property
	private Producto producto;

	public BeanModel<Producto> getModel() {
	BeanModel<Producto> model = beanModelSource.createDisplayModel(Producto.class, resources.getMessages());
	// Columnas sin ordenación
	for (String name :model.getPropertyNames()) {
	model.get(name).sortable(false);
	}
	// Ocultar columna id
	model.exclude("id");
	// Añadir columna de acción
	model.add("action", null).label("").sortable(false);
	return model;
	}

	void onNuevo() {
	Producto producto = new Producto(UUID.randomUUID().toString(), UUID.randomUUID().toString(), 1l, new Date());
	dao.persist(producto);
	}

	void onEliminar(Long id) {
	Producto producto = dao.findById(id);
	dao.remove(producto);
	}

	@Cached
	public List<Producto> getProductos() {
	return dao.findAll(null);
	}
	}

view raw EjemploJPA.java hosted with ❤ by GitHub

	<!DOCTYPE html>
	<html t:type="layout"
	xmlns:t="http://tapestry.apache.org/schema/tapestry_5_3.xsd"
	xmlns:p="tapestry:parameter">

	Versión: <b>${tapestryVersion}</b><br/>
	<t:holaMundo/><br/>

	<h1>Lista de productos</h1>
	<t:grid source="productos" row="producto" model="model" lean="true" inPlace="true" class="table table-bordered table-condensed">
	<p:nombreCell>
	${producto.nombre}
	</p:nombreCell>
	<p:actionCell>
	<t:eventlink event="eliminar" context="producto.id" class="btn btn-danger">Eliminar</t:eventlink>
	</p:actionCell>
	<p:empty>
	<p>No hay productos.</p>
	</p:empty>
	</t:grid>
	<t:eventlink event="nuevo" class="btn btn-primary">Nuevo producto</t:eventlink>

	</html>

view raw EjemploJPA.tml hosted with ❤ by GitHub

Esta es una captura de pantalla del ejemplo en ejecución:

Para casos más complejos de transacciones como transacciones anidadas, requeridas, soportables, ninguna u obligatoria podemos basarnos en lo comentado en esta entrada donde queda perfectamente explicado.

Como en el resto de entradas el código fuente completo lo puedes encontrar en mi repositorio de GitHub. Si quieres probarlo en tu equipo lo puedes hacer de forma muy sencilla con los siguientes comandos y sin instalar nada previamente (salvo java y git). Si no dispones de git para clonar mi repositorio de GitHub puedes obtener el código fuente del repositorio en un archivo zip con el anterior enlace.

	$ git clone git://github.com/picodotdev/elblogdepicodev.git
	$ cd elblogdepicodev/TapestryJPA
	$ ./gradlew tomcatRun
	# Abrir en el navegador http://localhost:8080/TapestrySecurity/ejemplojpa