Tutorial de Hibernate 4 con Netbeans 7.2

En esta nueva serie vamos a conocer un componente importante en el desarrollo de sistemas de información empresariales con Java.  El Hibernate 4 ORM.

Introducción

Hibernate 4, es una librería para el Mapeo objeto-relacional (ORM) que facilita el mapeo de atributos entre una base de datos relacional y el modelo de objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones en los clases de las entidades que permiten establecer estas relaciones.  Por lo tanto Hibernate vincula la aplicación con la base de datos.

Contenido

  1. Creando una base de datos MySQL
  2. Crear un proyecto en Netbeans IDE 7.2
  3. Descargar e instalar Hibernate 4 ORM
  4. Crear una clase Entidad
  5. Ejecutar tareas de persistencia

1. Creando una base de datos MySQL

Asumiendo que el motor MySQL está instalada procedemos a la creación de una base de datos “heyma” con: create database heyma;

Confirmando la operación deberíamos ver la base de datos ejecutando: show databases;

2. Crear un proyecto en Netbeans IDE 7.2

En el tutorial de Netbeans vimos como crear un proyecto de Aplicación Java.  Por lo tanto vamos a crear y tener listo un proyecto con el nombre: jcode-hibernate”

3. Descargar e instalar Hibernate 4 ORM

El sitio oficial de Hibernate es: http://www.hibernate.org.  Donde encontraremos un enlace al sitio de descargas.

Una vez allí ingresamos al enlace de: release bundles.

Esto nos llevará al sitio de Source Forge donde obtendremos gratis, una copia de Hibernate 4 ORM.

Seleccionamos el paquete: hibernate-release-4.1.7.Final.zip, (48.7 MB ) y descomprimimos el mismo en una ubicación adecuada para nuestras librerías.

Luego como vimos en el tutorial de Netbeans de cómo crear y agregar librerías creamos una librería llamada: Hibernate 4.1.7, con todos los jars del directorio: lib/required de Hibernate 4 ORM.

Con esto está instalado hibernate 4 en nuestro proyecto y listo para ser usado.

4. Crear una clase Entidad

Primero vamos a crear un paquete: model y luego una clase de entidad: Employee.

La clase: Employee.java.

package jcode.hibernate.model;

import java.sql.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 *
 * @author John
 */
@Entity
@Table(name = "EMPLOYEE")
public class Employee {

    @Id
    @GeneratedValue
    private Long id;
    @Column(name = "firstname")
    private String firstname;
    @Column(name = "lastname")
    private String lastname;
    @Column(name = "birth_date")
    private Date birthDate;
    @Column(name = "cell_phone")
    private String cellphone;

    public Employee() {
    }

    public Employee(String firstname, String lastname, Date birthdate, String phone) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.birthDate = birthdate;
        this.cellphone = phone;

    }

    public Long getId() {
        return id;
    }

    public String getFirstname() {
        return firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public String getCellphone() {
        return cellphone;
    }

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

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    public void setCellphone(String cellphone) {
        this.cellphone = cellphone;
    }
}

Luego Netbeans nos ayudará a crear un archivo de configuración para Hibernate.  Esta opción ejecutaremos sobre el paquete: jcode.hibernate.  Luiego:  New > Other…

Luego seleccionamos: (Categories) Hibernate > (File Types) Hibernate Configuration Wizard.

Luego de darle en: Next >.  Establecemos el nombre y el directorio de ubicación.

Luego en el siguiente paso debemos establecer una conexión a la base de datos.

Seguidamente presionamos: Next >.

Luego de finalizar el archivo xml debe quedar como sigue.  Sera necesario aumentar unas líneas extra.

El archivo: hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/heyma</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123</property>

        <property name="show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <mapping class="jcode.hibernate.model.Employee"/>
    </session-factory>
</hibernate-configuration>

5. Ejecutar tareas de persistencia

Ahora tan solo queda probar.  Para ello utilizaremos la clase: JcodeHibernate.java, que tiene un metodo main().

La clase:  JcodeHibernate.java

package jcode.hibernate;

import jcode.hibernate.model.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

/**
 *
 * @author John
 */
public class JcodeHibernate {

    private static SessionFactory sessionFactory = null;

    public static void main(String[] args) {
        Session session = null;
        try {
            try {
                sessionFactory = PersonFactory.getSessionFactory();
                session = sessionFactory.openSession();

                System.out.println("Insertando registro");
                Transaction tx = session.beginTransaction();
                //Creando un Objeto
                Employee employe = new Employee();
                employe.setFirstname("John");
                employe.setLastname("Castillo");
                //Guardando
                session.save(employe);
                tx.commit();
                System.out.println("Finalizado...");
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        } finally {
            session.close();
        }
    }
}

Luego de ejecutar la aplicación la consola (Output) debe mostrar lo siguiente:

Verificando la base de datos.

Con esto finalizamos el tutorial de Hibernate 4 ORM.  Un componente importante en la construcción de aplicaciones o sistemas de información con Java.

La clase: PersonFactory.java

package jcode.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

/**
 *
 * @author John
 */
public class PersonFactory {

    private static ServiceRegistry serviceRegistry;
    private static final SessionFactory sessionFactory;

    static {
        try {
            Configuration configuration = new Configuration();
            configuration.configure("jcode/hibernate/hibernate.cfg.xml");
            serviceRegistry = new ServiceRegistryBuilder().applySettings(
                    configuration.getProperties()).buildServiceRegistry();
            sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        } catch (Throwable ex) {
            System.err.println("Failed to create sessionFactory object." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Capítulo 3 – Configurando la Aplicación Spring Parte 2

En este capítulo vamos a integrar a nuestro proyecto una conexión de base de datos PostgreSQL 9.

Para ello vamos a configurar una conexión JDBC con Hibernate 4, y configurar Spring para que administre las transacciones con AspectJ una alternativa a AOPAlliance, gracias al soporte que tiene Spring para AOP (Programación Orientada a Aspectos).

Requerimientos

  1. Contar Con lo avanzado hasta el capitulo anterior de este tutorial
  2. Crear una base de datos “heyma” en PostgreSQL 9
  3. Descargar Hibernate ORM 4, hibernate-release-4.1.7.Final.zip
  4. Descargar AspectJ, aspectj-1.7.0.jar
  5. Descargar PostgreSQL JDBC 4, postgresql-9.1-902.jdbc4.jar

NOTA: En este capítulo se va a suponer que la Base de Datos PostgreSQL 9 ya está instalada y configurada correctamente.

Agregando Hibernate 4 al Proyecto “heyma”

En el Tutorial de Netbeans 7.2 hay un capítulo de cómo crear librerias en Netbeans IDE 7.2 para usar en nuestros proyectos.

El paquete descargado de Hibernate 4 (.zip) contiene las librerías que debemos agregar al proyecto, las 8 jars del directorio lib/required.

Para ello seleccionamos en: Libraries > Properties.

De la ventana de Propiedades seleccionamos en: Add JAR/Folder.

Seleccionamos todas las jars del directorio lib/required de Hibernate 4.

Con esto está listo la integración de Hibernate  en el proyecto “heyma“.

Instalación de AspectJ

El paquete de AspectJ aspectj-1.7.0.jar en realidad es un archivo ejecutable, un asistente (wizard) que instala las librerías en C:\aspectj1.7.

Con el mismo Procedimiento de integrar Hibernate al Proyecto vamos a agregar todas las jars del directorio donde se instalo AspectJ  C:\aspectj1.7\lib.

Instalacion del Driver JDBC de PostgreSQL

El archivo descargado postgresql-9.1-902.jdbc4.jar es una librería que únicamente debe agregarse al Proyecto igual que los procedimientos anteriores.

Luego de la Instalación o integración de librerías al Proyecto “heyma”, la ventata de propiedades de librerías debe estar como muestra la siguiente imagen.

Configurando e implementando una Prueba

Ahora el archivo applicationContext.xml debe quedar de la siguiente manera.

<?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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
          p:location="/WEB-INF/jdbc.properties" />

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

    <!-- ADD PERSISTENCE SUPPORT HERE (jpa, hibernate, etc) -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="org.heyma.webapp.model" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <bean class="org.springframework.transaction.aspectj.AnnotationTransactionAspect" factory-method="aspectOf">
        <property name="transactionManager" ref="transactionManager" />
    </bean>

    <context:annotation-config />
    <context:load-time-weaver />
    <context:spring-configured />
    <context:component-scan base-package="org.heyma.webapp" />
    <mvc:annotation-driven />

</beans>

Vamos a agregar un archivo de propiedades jdbc.properties al Proyecto con el siguiente código.

jdbc.driverClassName=org.postgresql.Driver
jdbc.dialect=org.hibernate.dialect.PostgreSQLDialect
jdbc.url=jdbc:postgresql://localhost:5432/heyma
jdbc.username=root
jdbc.password=123

Para agregar un archivo de Propiedades hacemos sobre WEB-INF > New.. > Properties file.  Si no aparece en el menú lo podremos localizar en la categoría Other, así de esta manera la vista del proyecto se vera como en la siguiente imagen.

Debemos tener la seguridad de que los parametros de conexión a la Base de Datos son las Correctas.

Con esto finalizamos la configuración del Proyecto para la conexión con una Base de Datos PostgreSQL 9, ahora tan solo queda agregar elementos o implementar alguna necesidad o requerimiento específico del Sistema. Para probar esta configuración vamos a implementar un Registro de Personas con algunos datos Básicos.

Estructura de paquetes y Componentes del Sistema (Entidades y Servicios)

Creamos la siguiente estructura de paquetes en el Proyecto

Según nuestro requerimiento de Registro de Personas se nota claramente que debemos crear la Entidad Persona, esta será una Clase Java en el paquete org.heyma.webapp.model con las @Anotaciones necesarias para ser una Entidad.

La Clase Persona.java

package org.heyma.webapp.model;

import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;

/**
 *
 * @author John
 */
@Entity
public class Persona {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int persona_id;
    private String nombres;
    private String apellidoPaterno;
    private String apellidoMaterno;
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date fechaDeNacimiento;

    public int getPersona_id() {
        return persona_id;
    }

    public void setPersona_id(int persona_id) {
        this.persona_id = persona_id;
    }

    public String getNombres() {
        return nombres;
    }

    public void setNombres(String nombres) {
        this.nombres = nombres;
    }

    public String getApellidoPaterno() {
        return apellidoPaterno;
    }

    public void setApellidoPaterno(String apellidoPaterno) {
        this.apellidoPaterno = apellidoPaterno;
    }

    public String getApellidoMaterno() {
        return apellidoMaterno;
    }

    public void setApellidoMaterno(String apellidoMaterno) {
        this.apellidoMaterno = apellidoMaterno;
    }

    public Date getFechaDeNacimiento() {
        return fechaDeNacimiento;
    }

    public void setFechaDeNacimiento(Date fechaDeNacimiento) {
        this.fechaDeNacimiento = fechaDeNacimiento;
    }
}

La Interfaz Dao.java

package org.heyma.webapp.dao;

/**
 *
 * @author John
 */
public interface Dao {

    void save(Object obj);
}

La Clase DaoImpl.java (Implementación de Dao.java)

package org.heyma.webapp.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

/**
 *
 * @author John
 */
@Repository
public class DaoImpl implements Dao {

    @Autowired
    private SessionFactory sessionFactory;

    private Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }

    @Override
    public void save(Object obj) {
        getCurrentSession().save(obj);
    }
}

La Interfaz IPersonaSrv.java

package org.heyma.webapp.srv;

import org.heyma.webapp.model.Persona;

/**
 *
 * @author John
 */
public interface IPersonaSrv {

    public void guardarPersona(Persona persona);
}

La Clase PersonaImpl.java (Implementación de IPersonaSrv)

package org.heyma.webapp.srv;

import org.heyma.webapp.dao.Dao;
import org.heyma.webapp.model.Persona;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 *
 * @author John
 */
@Service
public class PersonaImpl implements IPersonaSrv {

    @Autowired
    Dao dao;

    @Override
    @Transactional
    public void guardarPersona(Persona persona) {
        dao.save(persona);
    }
}

Finalmente agregaremos dos metodos a MainController.java

    @RequestMapping("/registerpage.htm")
    public String registerPage() {
        return "registerPage"; //hace referencia a WEB-INF/jsp/registerPage.jsp
    }

    @RequestMapping(value = "/guardarpersona.htm", method = RequestMethod.POST)
    public String guardarPersona(Persona persona) {
        service.guardarPersona(persona);
        return "successPage"; //hace referencia a WEB-INF/jsp/successPage.jsp
    }

La Clase Maincontroller.java (Completo)

package org.heyma.webapp;

import org.heyma.webapp.model.Persona;
import org.heyma.webapp.srv.IPersonaSrv;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 *
 * @author John
 */
@Controller
public class MainController {

    @Autowired
    private IPersonaSrv service;

    @RequestMapping("/saludo.htm")
    public @ResponseBody
    String saludo() {
        return "Hola mundo";
    }

    @RequestMapping("/registerpage.htm")
    public String registerPage() {
        return "registerPage"; //hace referencia a WEB-INF/jsp/registerPage.jsp
    }

    @RequestMapping(value = "/guardarpersona.htm", method = RequestMethod.POST)
    public String guardarPersona(Persona persona) {
        service.guardarPersona(persona);
        return "successPage"; //hace referencia a WEB-INF/jsp/successPage.jsp
    }
}

Ambos métodos hacen referencia a dos páginas que deben crearse.  Estas Páginas son archivos JSP que deben crearse en WEB-INF/jsp del Proyecto.

La Página registerPage.jsp

<%--
    Document   : registerPage
    Created on : 27-08-2012, 03:02:55 PM
    Author     : John
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Página de Registro</title>
    </head>
    <body>
        <h1>Registro de Persona</h1>
        <form action="guardarpersona.htm" method="POST">
            <table>
                <tr>
                    <td>Nombres:</td>
                    <td><input type="text" name="nombres"></td>
                </tr>
                <tr>
                    <td>Apellido paterno:</td>
                    <td><input type="text" name="apellidoPaterno"></td>
                </tr>
                <tr>
                    <td>Apellido materno:</td>
                    <td><input type="text" name="apellidoMaterno"></td>
                </tr>
                <tr>
                    <td>Fecha de nacimeinto:</td>
                    <td><input type="text" name="fechaDeNacimeinto"></td>
                </tr>
                <tr>
                    <td></td>
                    <td><input type="submit" value="Guardar"></td>
                </tr>
            </table>
        </form>
    </body>
</html>

La Página successPage.jsp

<%--
    Document   : successPage
    Created on : 27-08-2012, 03:46:48 PM
    Author     : John
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Success</title>
    </head>
    <body>
        <h1>Success!</h1>
    </body>
</html>

Finalmente la estructura del Proyecto será.

Prueba Final

Ahora llego el momento de la prueba final, Desplegar la Aplicación en el servidor (Deploy) e ingresar un registro.

Luego de ejecutar Run o Deploy abrimos la Página de Registro en heyma/registerpage.htm

Si todo salio correctamente deberiamos ver la siguiente Página.

Para confirmar bastaría con ver en la Base de Datos “heyma” una tabla persona, creada automáticamente con el registro anterior.

Con esto hemos finalizado con el tema Configurando la Aplicación Spring Parte 2. En los siguientes capítulos vamos a implementar un requerimiento más avanzado y además vamos a integrar a nuestra Aplicación el Framework ExtJS 4 para la Interfaz de usuario.