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;
    }
}