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

  1. Sumamente interesante la entrada, hacía tiempo buscaba algo similar, al menos en español, pero nada. Solo me queda una duda debido a ello es que no me funciona el ejemplo: qué es el PersonFactory del cual obtienes la Factory de la Session? Que debo hacer para incluirlo en el proyecto puesto que me dice que no encuentra esa variable. Muchas gracias de antemano.
    Saludos

    • Tienes razón es una clase que falta en el ejemplo, es una clase con un metodo estático que construye el Objeto SessionFactory de Hibernate basado en la configuración de la conexión.a la base de datos.
      Para resolver este problema he adjundato la clase Person Factory con codigo propio de Hibernate al final de la entrada :) Gracias.

  2. Hola! está muy bueno el tutorial pero tengo un pequeño problema:
    En la clase PersonFactory no puedo importar org.hibernate.service.. hay alguna librería que me falta u otra cosa??
    Saludos

    • Ya encontré el problema, por alguna razón me faltaba la libreria hibernate-core.. se supone que debería haber estado incluída junto a las otras pero no estaba.. problema solucionado. Saludos!

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s