Simplificar DAO con Hibernate JPA

En el tutorial anterior DAO con JDBC vimos cómo implementar la arquitectura DAO con la API JDBC, en el mismo podemos notar la gran cantidad de código que requerimos para el manejo de excepciones que además repetimos varias veces, también observamos que siempre necesitamos mapear los objetos java hacia la base de datos o al contrario de la base de datos a objetos java, existen herramientas llamadas Object Relational Mapping (ORM), que realizan estas tareas por nosotros, por lo que este tutorial veremos cómo simplificar nuestro código mediante el uso del ORM Hibernate 4.x.

Hibernate es una herramienta de mapeo objeto/relacional para entornos Java. El término de mapeo objeto/relacional (ORM) se refiere a la técnica de mapear una representación de datos desde un modelo de objeto a un modelo de datos relacionales con un esquema basado en SQL.

Hibernate no sólamente se ocupa del mapeo desde las clases Java a las tablas de las bases de datos (y desde los tipos de datos de Java a los tipos de datos de SQL), sino que también facilita la consulta y recuperación de datos. Esto puede reducir de manera importante el tiempo de desarrollo que se tomaría con el manejo de datos de forma manual en SQL y JDBC.

Crear proyecto DAO Hibernate JPA

Primero creamos el proyecto maven, editamos el archivo pom.xml para agregar hibernate-entitymanger, requerido para acceder a JPA mediante Hibernate y hsqldb que nuestro servidor de datos de pruebas, iniciamos el servidor con los datos de pruebas como lo hicimos en el tutorial DAO con JDBC.

<dependencies>
        <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 la unidad de persistencia, para ello agregamos el archivo persintence.xml en la siguiente ubicación “scr/main/resources/META-INF/persistence.xml”, este archivo contiene la información para la conexión a la base de datos y las propiedades de configuración de Hibernate.

<persistence-unit name="punit" transaction-type="RESOURCE_LOCAL">
    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
    <class>com.carmelo.model.Product</class>
    <properties>
      <property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcDriver"/>
      <property name="javax.persistence.jdbc.user" value="sa"/>
      <property name="javax.persistence.jdbc.password" value=""/>
      <property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:hsql://localhost"/>
      
      <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>
      <property name="hibernate.show_sql" value="true"/>
    </properties>
</persistence-unit>

La unidad de persistencia se llamará “punit” definido por <persistence-unit />, <provider /> indica el proveedor a utilizar, <class /> indica las clases a mapear por ahora la clase Product.

La anotación @Entity aplicada a la clase indica que la misma es una entidad, @Table específica a que tabla representa la clase, las siguientes anotaciones serán aplicadas a campos: @Column para mapear al campo correspondiente a un columna de la base de datos, @Id indica la clave primaria de la tabla.

@Entity
@Table(name = "PRODUCT")
public class Product implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @Basic(optional = false)
    @Column(name = "ID")
    private Integer id;

    @Column(name = "NAME")
    private String name;

    @Column(name = "PRICE")
    private BigDecimal price;

    public Product() {
    }

   //... omitidos: getter, setter, hashcode, equals, toString ...//
}

Ahora podemos implementar la interfaz ProductDao con Hibernate JPA, antes de iniciar debemos obtener un EntityManger, este el encargado a manejar las entidades, debemos abrir la conexión e iniciar la transacción, ejecutamos las acciones deseadas (crear, borrar, actualizar, leer), al terminar cerramos la transacción y el EntityManager, Hibernate se encargara del mapeo de los datos, crear las correspondientes consultas y administrar la conexión con la base de datos.

public class ProductDaoImpl implements ProductDao {

    @Override
    public void insert(Product product) {
        EntityManager em = DaoHibernate.getEntityManager();
        em.getTransaction().begin();
        try {
            em.persist(product);
            em.getTransaction().commit();
        } catch (Exception e) {
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }

    @Override
    public void update(Product product) { ... }

    @Override
    public void delete(Integer id) { ... }

    @Override
    public Product read(Integer id) {
        EntityManager em = DaoHibernate.getEntityManager();
        try {
            return em.find(Product.class, id);
        } finally {
            em.close();
        }
    }

}

Si comparamos la versión anterior de este proyecto donde la implementación se realizó con JDBC veremos el ahorro de código que hemos logrado, esto se traduce en mayor productividad, además al dejar que Hibernate controle los detalles de acceso a la base de datos reducimos la posibilidad de errores.

GitHub: DAO Hibernate JPA