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

Comentarios

Entradas populares de este blog

Conectar SQL Server con Java

Entrenar OpenCV en Detección de Objetos

Procesamiento de imágenes en OpenCV

Conociendo la clase cv::Mat de OpenCV

Acceso a la webcam con OpenCV