CAFEBABE

Primera parte

Una vez tenemos creado el proyecto y las dependencias vamos a empezar a añadir código.

Lo primero es añadir las clases que nos permitan acceder a la base de datos. Para ello basaremos el proyecto en un diseño basado en un solo DAO. Desde este centralizaremos todo el acceso a la base de datos para los casos más comunes (insertar, borrar, buscar…). Si en algún momento necesitamos algo más complejo podemos crear una clase que extienda de nuestro DAO. Otra cosa que vamos a crear es una clase sobre la cual extiendan todas las entidades que vayamos creando. Esta clase tan sólo tendrá algo común a todas las entidades: una variable version para el optimist lock y una variable id para la clave primaria.

Vamos a crear las clases según el diseño de proyecto de la imagen de la izquierda. Como soy un fanático del TDD no puedo evitar diseñar el proyecto de manera algo extraña para los no iniciados (¿dónde está el main?)

Vamos por el DAO. En la carpeta src/java/main creamos el paquete cafebabe.test.jpa y en su interior la clase sobre la que heredarán todas nuestras entidades:

package cafebabe.test.jpa;

import java.io.Serializable;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.Version;

@MappedSuperclass
public abstract class AbstractEntity implements Serializable{

	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue
	private long id;

	@Version
	private long version;

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public long getVersion() {
		return version;
	}

	public void setVersion(long version) {
		this.version = version;
	}
}

A continuación, en el mismo paquete, creamos nuestra clase de acceso a la base de datos, GenericDao, con el siguiente código:

package cafebabe.test.jpa;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaQuery;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

@Repository
public class GenericDao {

	private static final Logger log = LoggerFactory.getLogger(GenericDao.class);

	@PersistenceContext(unitName = "cafebabePersistenceUnit")
	private EntityManager em;

	public <T extends AbstractEntity> void delete(T entity) {
		log.debug("Eliminando la entidad::Clase={}::Id={}", entity
				.getClass().getCanonicalName(), entity.getId());
		em.remove(entity);
	}

	public <T extends AbstractEntity> void insert(T entity) {
		log.debug("Insertando una nueva entidad::Clase={}", entity
				.getClass().getCanonicalName());
		em.persist(entity);
		log.debug("Se le ha asignado la Id={}", entity.getId());
	}

	public <T extends AbstractEntity> T getByPrimaryKey(Class<T> entityClass, Object id) {
		log.debug("Buscando por clave primaria::Clase={}::Id={}", entityClass, id);
		return em.find(entityClass, id);
	}

	public <T extends AbstractEntity> List<T> getAll(Class<T> entityClass) {
		log.debug("Buscando todos los registros de la clase::Clase={}", entityClass);
		CriteriaQuery<T> cq =  em.getCriteriaBuilder().createQuery(entityClass);
		cq.from(entityClass);
		return em.createQuery(cq).getResultList();
	}
}

Y ya está, no tenemos que hacer nada más. La pregunta, claro, es ¿pero esto funciona? Evidentemente no, aquí no hay nada que ejecute código así que vamos a crear un test que haga funcionar nuestro DAO.

Vamos a pensar un ejemplo simple que luego podemos ir complicando. Tenemos una tabla Persona donde se guardan datos de usuarios o clientes ( nombre, edad… ) y una tabla Direccion donde se guardan direcciones (calle, código postal). Una persona puede tener muchas direcciones (relación 1 a n) ya que tenemos a algún cliente ricachón con una casa en la playa y otra en la montaña para las vacaciones. En base a este modelo vamos a construir las entidades.

Vamos al directorio /src/test/java, creamos el paquete cafebabe.test.jpa y la persona:

package cafebabe.test.jpa;

import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.OneToMany;

import cafebabe.test.jpa.AbstractEntity;

@Entity
public class Persona extends AbstractEntity {

	private static final long serialVersionUID = 1L;

	@OneToMany(mappedBy = "id")
	private Set<Direccion> direcciones;

	private int edad;

	@Column(nullable = false)
	private String nombre;

	public Set<Direccion> getDirecciones() {
		return direcciones;
	}

	public int getEdad() {
		return edad;
	}

	public String getNombre() {
		return nombre;
	}

	public void setDirecciones(Set<Direccion> direcciones) {
		this.direcciones = direcciones;
	}

	public void setEdad(int edad) {
		this.edad = edad;
	}

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

y ahora la dirección:

package cafebabe.test.jpa;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.ManyToOne;

import cafebabe.test.jpa.AbstractEntity;

@Entity
public class Direccion extends AbstractEntity {

	private static final long serialVersionUID = 1L;

	@Column(nullable = false)
	private String calle;

	@Column(length = 5, nullable = false)
	private String codigoPostal;

	@ManyToOne
	private Persona persona;

	public String getCalle() {
		return calle;
	}

	public String getCodigoPostal() {
		return codigoPostal;
	}

	public Persona getPersona() {
		return persona;
	}

	public void setCalle(String calle) {
		this.calle = calle;
	}

	public void setCodigoPostal(String codigoPostal) {
		this.codigoPostal = codigoPostal;
	}

	public void setPersona(Persona persona) {
		this.persona = persona;
	}
}

Y ahora, al fin, vamos a crear un pequeño test que utilice todo esto. En el mismo paquete que la clase Persona y Direccion creamos la clase GenericDaoTest que no es más que una prueba unitaria que valida que estemos insertando una persona en la base de datos:

package cafebabe.test.jpa;

import java.util.List;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import cafebabe.test.jpa.GenericDao;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class GenericDaoTest {

	private static final Logger log = LoggerFactory.getLogger(GenericDaoTest.class);

	@Autowired
	private GenericDao genericDao;

	@Test
	@Transactional
	public void insertTest() {
		log.info("Inicio del test de inserción");

		List resultados = genericDao.getAll(Persona.class);

		Assert.assertEquals(0, resultados.size());

		Persona p = new Persona();
		p.setNombre("Test");
		p.setEdad(33);

		Assert.assertEquals(0, p.getId());

		genericDao.insert(p);
		resultados = genericDao.getAll(Persona.class);

		Assert.assertEquals(1, resultados.size());
		log.info("Fin del test de inserción");
	}
}

Esto es todo el código que necesitamos. Ahora sólo hemos de añadir los ficheros de configuración. Empezamos con la configuración de Spring:

<?xml version="1.0" encoding="UTF-8">
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd" >

	<context:component-scan base-package="cafebabe.test" >
	<context:annotation-config >
	<context:property-placeholder
		location="classpath:/cafebabe/test/jpa/properties/jdbc.properties" >

	<tx:annotation-driven >

	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource"
		p:driverClassName="${jdbc.test.driverClassName}" p:url="${jdbc.test.url}"
		p:username="${jdbc.test.user}"; p:password="{jdbc.test.password}" >

	<bean id="jpaAdapter"
		class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
		p:database="${jpa.test.database}" p:showSql="${jpa.test.showSql}"
		p:generateDdl="${jpa.test.generatDdl}" >

	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
		p:dataSource-ref="dataSource" p:jpaVendorAdapter-ref="jpaAdapter"
		p:persistenceUnitName="cafebabePersistenceUnit" >

	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
		p:entityManagerFactory-ref="entityManagerFactory" >

</beans>

Como podemos ver he externalizado las propiedades de acceso a la base de datos para que se pueda modificar sin necesidad de modificar los xml, así que también hemos de poner el susodicho fichero de propiedades. Lo añado con dos configuraciones, una con HSQLDB que ya funciona sin tener que instalar ninguna base de datos y otra, comentada, para MySQL en caso de que queráis entrar más a trapo e ir viendo lo que se va creando en una base de datos física.

#jdbc.test.driverClassName=com.mysql.jdbc.Driver
#jdbc.test.url=jdbc:mysql://localhost:3306/test
#jdbc.test.user=root
#jdbc.test.password=admin
#jpa.test.database=MYSQL
#jpa.test.showSql=true
#jpa.test.generateDdl=true

## HSQLDB
jdbc.test.driverClassName=org.hsqldb.jdbcDriver
jdbc.test.url=jdbc:hsqldb:mem:mypersistence
jdbc.test.user=sa
jdbc.test.password=
jpa.test.database=HSQL
jpa.test.showSql=false
jpa.test.generateDdl=true

Seguimos con la configuración de JPA:

<?xml version="1.0" encoding="UTF-8">
<persistence 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"
	version="2.0">

	<persistence-unit name="cafebabePersistenceUnit"
		transaction-type="RESOURCE_LOCAL">
	</persistence-unit>

</persistence>

Y terminamos con la configuración del log:

<?xml version="1.0" encoding="UTF-8">

<configuration>
	<appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
			<pattern>%d{yyyy-MM-dd HH:mm:ss} - %c{1} [%p] %m%n</pattern>
		</encoder>
	</appender>

	<logger name="cafebabe.test" level="DEBUG" >
	<root level="WARN">
		<appender-ref ref="Console" />
	</root>
</configuration>

Y ahora sí que esto ya está. Para ejecutarlo podemos ir a la clase GenericDaoTest, apretar el botón derecho y seleccionar Run As -> JUnit Test. Al ejecutarse HSQLDB creará una base de datos en memoria (por lo que no hace falta una física tipo Oracle o MySql) y se crearán las tablas Persona y Dirección. Si lo deseáis, podéis ver las trazas de todo esto cambiando el nivel de log de WARN a DEBUG.

Una vez lo tenemos funcionando, vamos a analizarlo con detalle.

Detalle para los puristas: Lo que he hecho no es un test unitario sino un test de integración. Lo sé.

Tercera parte