DAO con Spring Framework

En tutoriales anteriores hemos visto cómo implementar la arquitectura DAO ya sea con la API JDBC directamente o mediante el ORM Hibernate utilizando la especificación JPA 2.1, en este punto podemos avanzar al siguiente nivel, integrar un framework para simplificar aún más nuestro proyecto, utilizaremos Spring Framework 4.x y aprovecharemos sus capacidades de Inversión de Control (IoC).

Como siempre creamos el proyecto Maven y editamos el archivo pom.xml, en el añadimos las librerías requeridas por el proyecto que estemos desarrollando, spring-context, spring-orm, hibernate-entitymanager, hsqldb.

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.11.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hsqldb</groupId>
            <artifactId>hsqldb</artifactId>
            <version>2.3.3</version>
        </dependency>
</dependencies>

Lo siguiente que debemos hacer es configurar Spring ORM, creamos una clase llamada DaoConfiguration, le aplicamos las anotaciones: @Configuration (le indica a spring que esta es una clase de configuración), @EnableTransactionManagement (habilita las transacciones automáticas manejadas por spring), @ComponentScan("com.carmelo.dao") (le indica a spring donde encontrar los repositorios de datos).

@Configuration
@EnableTransactionManagement
@ComponentScan("com.carmelo.dao")
public class DaoConfiguration {

    @Bean
    public DataSource dataSource() {
        SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
        dataSource.setDriverClass(org.hsqldb.jdbcDriver.class);
        dataSource.setUrl("jdbc:hsqldb:hsql://localhost");
        dataSource.setUsername("sa");
        dataSource.setPassword("");
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
        jpaVendorAdapter.setShowSql(true);
        jpaVendorAdapter.setGenerateDdl(false);
        jpaVendorAdapter.setDatabase(Database.HSQL);

        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setPersistenceUnitName("punit");
        emf.setPackagesToScan("com.carmelo.model");
        emf.setDataSource(dataSource());
        emf.setJpaVendorAdapter(jpaVendorAdapter);
        return emf;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new JpaTransactionManager(entityManagerFactory().getObject());
    }
}

DataSource: este bean configura el acceso a la fuente de datos, debemos establecer url de conexión, nombre de usuario, contraseña y nombre de la clase Driver JDBC.

LocalContainerEntityManagerFactoryBean: configura y crea la unidad de persistencia, no requerimos el archivo persistence.xml, podemos establecer el nombre a través de PersistenceUnitName, setPackagesToScan("com.carmelo.model") indica el paquete donde se encuentran las entidades, DataSource establece la fuente de datos y JpaVendorAdapter establece el proveedor JPA a utilizar, en nuestro caso Hibernate.

PlatformTransactionManager: es el bean encargado de administrar las transacciones.

Para implementar la interfaz ProductDao creamos y marcamos la clase ProductDaoImpl con la anotación @Repository la misma le indica a spring que este es un componente, cada método de esta clase estará marcado con @Transactional, spring administrará la transacción por nosotros, para obtener el EntityManager usamos @PersistenceContext, spring inyectará el bean correspondiente, del mismo modo podemos obtener el EntityManagerFactory con @PersistenceUnit.

@Repository
public class ProductDaoImpl implements ProductDao {

    @PersistenceContext
    private EntityManager em;

    @Override
    @Transactional
    public void insert(Product product) {
        em.persist(product);
    }

    @Override
    @Transactional
    public void update(Product product) {
        em.merge(product);
    }

    @Override
    @Transactional
    public void delete(Integer id) {
        Product product = em.find(Product.class, id);
        if (product != null) {
            em.remove(product);
        }
    }

    @Override
    @Transactional(readOnly = true)
    public Product read(Integer id) {
        return em.find(Product.class, id);
    }

}

La clase principal ProductManger es la encargada de iniciar spring, obtener el bean ProductDao y ejecutar las acciones correspondientes de actualización, creación, borrado y lectura de datos.

Como siempre para probar la aplicación debemos iniciar el servidor HSQLDB con los datos de prueba, para más detalles puedes ver el tutorial DAO con JDBC.

GitHub: Dao con Spring Hibernate JPA