Dao Generico + Spring + JPA 2

Aquí vamos,  a montar un dao genérico, que contenga las siguientes operaciones básicas:

• ObtenerId: Nos obtiene la entidad asociada a un id.
• Eliminar: Se encarga de eliminar la entidad que le pasamos.
• Actualizar: Se encarga de actualizar la entidad que le pasamos.
• Crear: Se encarga de crear un entidad.
• Obtener todos:  Nos devuelve todos los registros del sistema.

La idea de un dao generico, es que estas operaciones las hereden todos los dao de nuestro proyecto, sin necesidad de tener que picarlas.
El dao genérico, se compone de una interfaz y una clase que implementa las operaciones.

En el siguiente proyecto podéis encontrar https://github.com/blancoparis-tfc/SpringCrud

Interfaz

Lo primer que tenemos que hacer es definir las operaciones, en una interfaz, en la cual además de las operaciones, vamos a definir en la cabecera de la interfaz, dos tipos genéricos, que van a representar a la entidad con la que vamos a trabajar y el id de la entidad.

Gracias a estos dos genéricos, es lo que va hacer la magia que nos va a permitir que estas operaciones valgan para cualquier de nuestras entidades del proyecto.

package org.dbp.core.dao;

import java.io.Serializable;
import java.util.List;

public interface GenericDao {

 public E obtenerId(ID id);

 public void eliminar(E entidad);
 
 public void crear(E entidad);
 
 public E actualizar(E entidad);
 
 public List obtenerTodos();
 
}

Clase

Ahora vamos a implementar las operaciones que hemos puesto en el interfaz, en la siguiente clase.

package org.dbp.core.dao.impl;

import java.io.Serializable;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.dbp.core.dao.GenericDao;
import org.springframework.transaction.annotation.Transactional;

@Transactional(rollbackFor=Exception.class)
public class GenericDaoImpl  implements GenericDao{

 @PersistenceContext private EntityManager em;
 
 private Class clazzE;

 public GenericDaoImpl(Class clazzE) {
  super();
  this.clazzE = clazzE;
 }

 public E obtenerId(ID id){
  return em.find(clazzE, id);
 }

 public void eliminar(E entidad){
  em.remove(entidad);
 }
 
 public void crear(E entidad){
  em.persist(entidad);
 }
 
 public E actualizar(E actualizar){
  return em.merge(actualizar);
 }
 
 public List obtenerTodos(){
  CriteriaBuilder cb=em.getCriteriaBuilder();
  CriteriaQuery criteria=cb.createQuery(clazzE);
  Root from=criteria.from(clazzE);
  TypedQuery query=em.createQuery(criteria.select(from));
  return query.getResultList();
 }

}

Ejemplo

Una vez definido el dao genérico, para ver todo su potencial es ver el uso y poder apreciar el ahorro de código por un lado, y por otro lado y mas importante que ahora estas operaciones las tenemos centralizadas y si el día de mañana queremos cambiarlas o añadir alguna a todas las entidades lo podemos hacer o cambiar la versión del ORM o lo que sea, nos facilitara la vida.

package org.dbp.dao.impl;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.dbp.bom.Usuario;
import org.dbp.core.dao.impl.GenericDaoImpl;
import org.dbp.dao.UsuarioDao;
import org.springframework.stereotype.Repository;

@Repository
public class UsuarioDaoImpl  
 extends GenericDaoImpl 
 implements UsuarioDao{

 @PersistenceContext private EntityManager em;
 
 public UsuarioDaoImpl() {
  super(Usuario.class);
 }
 
 @Override
 public Usuario obtenerLogin(String login){
  return em.createQuery("from Usuario u where u.login = :login",Usuario.class)
  .setParameter("login", login)
  .getSingleResult();
 }
 
}

Test

Para ver el funcionamiento he creado el siguiente test:

package org.dbp.dao;

import static org.junit.Assert.*;

import java.util.List;

import org.dbp.bom.Usuario;
import org.dbp.core.config.TestConfiguracion;
import org.junit.Test;
import org.junit.runner.RunWith;
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;

@RunWith(SpringJUnit4ClassRunner.class)
@Transactional
@ContextConfiguration(classes = TestConfiguracion.class)
public class UsuarioDaoTest {

 @Autowired private UsuarioDao usuarioDao;
 
 @Test
 public void testRecuperarTodos(){
  List usuarios=usuarioDao.obtenerTodos();
  assertEquals("Miramos el número de elementos",1,usuarios.size());
 }
 @Test
 public void testObtenerPorId(){
  Usuario usuario=usuarioDao.obtenerId(1L);
  assertEquals("Validamos el ID:",new Long(1L),usuario.getId());
  assertEquals("Validamos el loging","dblanco",usuario.getLogin());
 }

 @Test
 public void testObtenerLogin(){
  Usuario usuario=usuarioDao.obtenerLogin("dblanco");
  assertEquals("Validamos el ID:",new Long(1L),usuario.getId());
  assertEquals("Validamos el loging","dblanco",usuario.getLogin());
 }
}

Conclusión

Yo solo os puedo decir, que en todos los proyectos que hago monto este patrón junto con un servicio desde el año 2007, que lo vi por primera vez.

Como configurar un Map en JPA

Vamos a ver como configurar un mapa en JPA. Yo lo he necesitado por que tengo un enumerado asociado a un campo String (Que tiene un valor), en vez de crear un campo por cada valor, creo un map al que le paso el tipo y me devuelve el valor.  Y si mañana necesito otro campo con la misma lógica, solo tengo que registrarlo en el enumerado y la B.D no se toca.

Ejemplo practico: Tengo 3 dimensiones para la visibilidad o entidades del sistema a las que le asocio una opción en el enumerado, a las cuales le aplico un comodín para saber a que usuarios aplico la seguridad. Por lo cual la lógica en el código es común y nos interesa,  que el modelo de datos lo tengo en un mapa, para que sea escalable. Tocando solo el tipo enumerado.

Nota: Yo estas cosas las hago cuando ya hay 2 o mas casos, o este muy claro que va a crecer en los requisitos, es mas una excepción que otra cosa.

Como configurar el mapeo:

En este caso vamos a crear un mapeo de un tipo enumerado a un campo:

public enum TipoDimensiones{

Dim1,Dim2,Dim3

}

Añadimos el mapeo a la entidad en cuestión

@Entity
public class Entity(){

@id
private Long id;

@ElementCollection
@MapKeyColumn(name = "tipoDimension")
@JoinTable(name="Entity_visivilidad", joinColumns=@JoinColumn(name="id"))
@Column(name="valor")
private Map<Tipodimensiones,String> visivilidad;

Ahora voy a explicar cada una de las anotaciones. para que entendamos que estamos haciendo y no copiemos como loros :P.

• ElementCollection: Indica que vamos a rellenar el collection a partir de una tabla.


• MapKeyColumn: Indica la clave del mapa, usaremos MapKeyColumn cuando sea un tipo básico, en caso de ser una entidad usaremos MapKey (Ojo con esto). 


• JoinTable: Indicamos la tabla donde se va a persistir el mapa (atributo name) y como que campo de la entidad tenemos que relacionarlo (joinColumn) en nuestro caso es la clave primaria.


• Column: Le indicamos cual sera la columna que alimentara el valor.

Otra forma de configurar el mapeo

Esto hace lo mismo que lo anterior, pero si nos fijamos en la configuración anterior es un poco redundante el indicarle el id, cuando hibernate tiene la capacidad de saber cual es su id.

Por defecto hibernate utiliza el número de orden para saber cual es el enumerado ( Que corresponde por la posición en el enum que tenemos, si queremos por claridad o otras historias indicarle que el tipo enumerado de la clave guarde el string usaremos la anotación MapKeyEnumerated.

@ElementCollection
@CollectionTable(name="Entity_visivilidad")
@MapKeyEnumerated(EnumType.STRING)
@MapKeyColumn( name = "tipoDimension" )
@Column(name="valor")
private Map<Tipodimensiones,String> visivilidad;

Spring 4.2 + Jpa 2.1 + Hibernate 4.3

Ahora vamos a montar un proyecto de spring, configurando Jpa 2.1 implementado por hibernate 4.3.
Como B.D vamos a usar una embebida (HSQLBD), para que el proyecto sea totalmente autónomo.
Para lo cual vamos a seguir los siguientes pasos:

• Establecer las dependencias necesarias para un proyecto Spring.
• Montar la configuración de spring.
• Montar la configuración de spring JPA.
• Crear el entorno de test.
• Montar un test, para que podamos probar nuestra configuración.

El ejemplo de este articulo lo podéis descargar del siguiente enlace https://github.com/blancoparis-tfc/SpringHibernate

Dependencias:

Primero vamos a ver que librerías que vamos a necesitar:

Spring

Las dependencias relacionadas con la versión de spring, en nuestro ejemplo vamos a utilizar la versión 4.2.0.RELEASE.

• Spring-context: Es la parte de spring encargada de levantar un contenedor de beans.
• Spring-orm: Es el modulo de spring que utilizaremos para trabajar con los orm, que en nuestro caso sera hibernate como implementación de JPA 2.1.

  compile 'org.springframework:spring-context:4.2.0.RELEASE'
  compile 'org.springframework:spring-orm:4.2.0.RELEASE'

JPA2.1 + Hibernate 4.3

Las dependencias, relacionada con jpa2.1 + hibernate 4.3.10.FINAL.

• Hibernate-core: Es la implementación de hibernate normal.
• Hibernate-entitymanager: Es la integración de hibernate con JPA.

    compile 'org.hibernate:hibernate-core:4.3.10.Final'
    compile 'org.hibernate:hibernate-entitymanager:4.3.10.Final'

B.D

Las dependencias, relacionadas como la B.D, que en nuestro caso sera la libreria de HSQLBD mas una implementación de el datasource.

• Hsqlbd: Es la bd embebida que vamos a utilizar.
• commons-dbcp: Es una implementación para el datasource, en un proyecto de producición podemos utilizar mejor este c3p0.

    compile 'commons-dbcp:commons-dbcp:1.4'
    compile 'org.hsqldb:hsqldb:2.3.3'

Entorno de test:

La librería que vamos a utilizar, para realizar los test, que en nuestro caso será junit + la librería de test de spring.

• Junit: Es la librería que vamos a utilizar para realizar los test unitarios.
• Spring-test: Es la librería para poder lanzar spring, desde los entornos de test.

    testCompile group: 'junit', name: 'junit', version: '4.+'
    testCompile 'org.springframework:spring-test:4.2.0.RELEASE'

Crear el proyecto

Ahora que ya sabemos cuales son las dependencias que necesitamos, vamos a crear el fichero de gradle para poder montar nuestro proyecto.

• Le tenemos que indicar, que es un proyecto de java y se va integrar con eclipse, para lo cual usaremos los pluging de (java,eclipse)
• La indicamos con que maquina de java, vamos a trabajar utilizando la variable sourceCompatibility
• Le indicamos que vamos a usar los repositorios de maven:
• Ponemos las dependencias que necesitemos.

apply plugin: 'java'
apply plugin: 'eclipse'

sourceCompatibility = 1.8
version = '1.0'

repositories {
    mavenCentral()
}

dependencies {
  compile 'org.springframework:spring-context:4.2.0.RELEASE'
  compile 'org.springframework:spring-orm:4.2.0.RELEASE'
    compile 'commons-dbcp:commons-dbcp:1.4'
    compile 'org.hsqldb:hsqldb:2.3.3'
    compile 'org.hibernate:hibernate-core:4.3.10.Final'
    compile 'org.hibernate:hibernate-entitymanager:4.3.10.Final'
    
    testCompile group: 'junit', name: 'junit', version: '4.+'
    testCompile 'org.springframework:spring-test:4.2.0.RELEASE'
    
}

Configuración de Spring:

Aquí vamos a ver las configuraciones necesarias para spring, en mi caso las colocaremos en el paquete org.dbp.core.config.

Configuración básica de spring

Vamos a ver que necesitamos para poder configurar Spring, mínimo. En este caso la verdad, lo único que le tenemos que indicar a spring en que paquete van a estar los beans con los que vamos a trabajar en nuestro caso sera (org.dbp.service).

• @Configuration: Le indicamos a spring, que es una clase para configurar spring.
• @ComponentScan: Le indicamos los paquetes donde se encontraran los beans del contexto, que en nuestro caso “org.dbp.service”

package org.dbp.core.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan(basePackages = "org.dbp.service")
public class TestConfiguracion {

}

Configuración de JPA + Hibernate:

Para la configuración de la JPA, vamos a crear otra clase independiente donde estableceremos toda la configuración necesaria para la persistencia y que inyectaremos en la configuración general.

Para la persistencia tendremos que configurar los siguientes aspectos:

• Habilitar las transaciones: @EnableTransactionManagement
• El datasource: Configuraremos el datasource, que realizara la conexión con la B.D, con la que vamos a trabajar. (Si el día de mañana quisiéramos poner un pool de conexión aquí es donde se establecerá).
• El entityManagerFactory: Configuramos la factoria de los entityManager de JPA, que es donde pondremos la configuración de JPA necesarias.
• Las transaciones: Aquí configuramos las transacciones de jpa, con spring (Tengamos en cuenta que estas transacciones serán por orientación aspectos).

package org.dbp.core.config;

import java.util.Properties;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
public class TestJpaConfiguration {

 @Bean
 public DataSource getDataSource() {
     BasicDataSource dataSource = new BasicDataSource();
  dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
  dataSource.setUrl("jdbc:hsqldb:mem:pruebas");
  dataSource.setUsername("sa");
  dataSource.setPassword("");
     return dataSource;
 }
 
 /**
  * Configuramos el entity manager en JPA. - Le indicamos el data source con
  * el que va a trabajar. - Le indicamos el paquete donde se encuentran las
  * clases. - Le pasamos el adaptador de JPA que en nuestro caso sera
  * hibernate. - Por otro lado le pasamos las propiedades.
  * 
  * @return
  */
 @Bean
 public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
  LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
  em.setDataSource(getDataSource());
  em.setPackagesToScan(new String[] { "org.dbp.bom" });
  JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
  em.setJpaVendorAdapter(vendorAdapter);
  em.setJpaProperties(propiedadesAdicionalesJpa());
  return em;
 }
 
 /**
  * Le indicamos el tipo de configuraci�n que nos interesa para hibernate -
  * Le indicmaos que cada vez que entremos borre y cree las B.D. - Le
  * indicamos que utilice el dialecto con HSQL.
  * 
  * Nota: este m�todo no es parte de la configuraci�n de spring.
  * 
  * @return
  */
 private Properties propiedadesAdicionalesJpa() {
  return new Properties() {
   {
    setProperty("hibernate.hbm2ddl.auto", "create");
    setProperty("hibernate.jdbc.batch_size", "20");
    setProperty("hibernate.show_sql", "true");
    setProperty("hibernate.dialect","org.hibernate.dialect.HSQLDialect");
    setProperty("hibernate.hbm2ddl.import_files","/META-INF/inicializar.sql");
   }
  };
 }

 /**
  * Configura las transaciones en JPA.
  * 
  * @return
  */
 @Bean
 public PlatformTransactionManager transactionManager(EntityManagerFactory emf){ 
  JpaTransactionManager transactionManager = new JpaTransactionManager();
  transactionManager.setEntityManagerFactory(emf);
  return transactionManager;
 }
 
}

Ahora simplemente tenemos que indicarle en la configuración general que importe esta configuración con @Import({TestJpaConfiguration.class})

Creamos una entidad.

Para poder probar la configuración, vamos a crear una entidad, en nuestro caso sera el típico ejemplo de usuario con los campos (id,login y descripción).

package org.dbp.bom;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Usuario implements Serializable{

 @Id
 private Long id;
 
 private String login;
  
 private String nombre;

 public String getLogin() {
  return login;
 }

 public void setLogin(String login) {
  this.login = login;
 }

 public String getNombre() {
  return nombre;
 }

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

 public Long getId() {
  return id;
 }

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

}

Test, para probar la configuración

Para poder probar esta configuración básica, la vamos a poner en el entorno de test,  y llamando a un test, consultamos un registro y insertamos otro y así podemos ver que funciona correctamente.

package org.dbp.core.config;

import static org.junit.Assert.*;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.dbp.bom.Usuario;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
 * Test para validar la configuración del JPA.
 * @author david
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@Transactional
@ContextConfiguration(classes = TestConfiguracion.class)
public class ConfigurationJpaTest {

 @PersistenceContext EntityManager em;
 
 @Test
 public void testRecuperarUnUsuario(){
  Usuario usuario=em.find(Usuario.class, 1L);
  assertEquals("El id del usuario 1",new Long(1L),usuario.getId());
  assertEquals("El login del usaurio","dblanco",usuario.getLogin());
  assertEquals("El nombre","david blanco paris",usuario.getNombre());
 }
 
 @Test
 public void testInsertarUsuario(){
  Usuario usuario=new Usuario();
  usuario.setId(2L);
  usuario.setLogin("perico");
  usuario.setNombre("Perico el de los palotes");
  em.persist(usuario);
 }
 
}

Conclusión

En este articulo hemos visto como configurar, un proyecto de spring + jpa. Para no complicar en exceso la configuración lo he montado en un entorno de test, pero ese mismo fichero se lleva a una configuración de spring y nos vale igual.