Usando Hibernate

Hasta ahora hemos visto cómo configurar hibernate usando los ficheros XML de configuración o usando notaciones pero no hemos visto nada de código Java para usarlo realmente. En esta lección veremos finalmente cómo usar Java para persistir una clase.

La clase que más usaremos en Hibernate es org.hibernate.Session. Esta clase contiene métodos para leer, guardar o borrar entidades sobre la base de datos. Pero antes de poder usarla hace falta crear el objeto SessionFactory que mediante el método SessionFactory.openSession() nos dará acceso a Session.

Session session = sessionFactory.openSession();

Veamos ahora cómo crear el objeto SessionFactory.

SesionFactory

La forma de crear el objeto SessionFactory es mediante un objeto org.hibernate.cfg.Configuration que leerá el fichero de configuración de hibernate hibernate.cfg.xml que se encuentra en el directorio raíz de las clases Java.

 1: import org.hibernate.SessionFactory;
 2: import org.hibernate.cfg.Configuration;
 3: import org.hibernate.service.ServiceRegistry;
 4: import org.hibernate.service.ServiceRegistryBuilder;
 5:
 6: SessionFactory sessionFactory;
 7:
 8: Configuration configuration = new Configuration();
 9: configuration.configure();
10: ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
11: sessionFactory = configuration.buildSessionFactory(serviceRegistry);

Listado 1.Creación del objeto SessionFactory

  • En la línea 8 vemos cómo se crea el objeto Configuration
  • En la línea 9 mediante el método configure() se va a leer el fichero de configuración hibernate.cfg.xml.
  • La línea 10 es nueva en hibernate 4 y contiene la lista de los distintos servicios que usará 1) hibernate.Para ello se crea un objeto de la clase org.hibernate.service.ServiceRegistry.
  • La línea 11 es la que finalmente creará el objeto SessionFactory en función de la configuración y de los servicios.

Todo el código anterior deberá realizarse una única vez en la aplicación y deberemos guardar la referencia a SessionFactory para su posterior uso durante toda la vida de la aplicación.

Si vemos la documentación de hibernate 4.1 se indica que la forma de crear el objeto SessionFactory es la siguiente:

1: Configuration configuration = new Configuration();
2: configuration.configure();
3: sessionFactory = configuration.buildSessionFactory();

Forma antigua de crear el objeto SessionFactory

Sin embargo al usar este código se puede observar que el método buildSessionFactory() está depreciado.En la documentación del propio método se indica que ahora se use buildSessionFactory(ServiceRegistry serviceRegistry) es decir que la documentación contiene un error y debemos usar el código del Listado 1.

Una discusión sobre el error en la documentación de Hibernate 4 la podéis encontrar en:Is buildSessionFactory() deprecated in hibernate 4?

Al finalizar la aplicación deberemos llamar al método close():

sessionFactory.close();

Session

Ahora que ya tenemos el objeto SessionFactory podemos obtener la Session para trabajar con Hibernate. Como ya hemos visto crear la Session es tan sencillo como llamar al método openSession():

Session session = sessionFactory.openSession();

Una vez obtenida la sesión trabajaremos con Hibernate persistiendo las clases y una vez finalizado se deberá cerrar la sesión con el método close():

session.close(); 

Transacciones

Para trabajar con una base de datos usamos las transacciones. En hibernate es tan sencillo como:

session.beginTransaction();


  • Hacer un commit de la transacción actual llamando al método commit() de la transacción actual de la sesión:
session.getTransaction().commit();


  • Hacer un rollback de la transacción actual llamando al método rollback() de la transacción actual de la sesión:
session.getTransaction().rollback();

CRUD

Ya hemos llegado al punto en que tenemos todo preparado para poder trabajar con Hibernate en las operaciones fundamentales de una base de datos, las operaciones CRUD.

  • Create: Guardar un nuevo objeto en la base de datos.
  • Read:Leer los datos de un objeto de la base de datos.
  • Update:Actualizar los datos de un objeto de la base de datos.
  • Delete:Borrar los datos de un objeto de la base de datos.

Estas 4 operaciones será tan sencillas de usar desde hibernate como llamar a un único método para cada uno de ellos.

Guardar

Usaremos el método save(Object object) de la sesión pasándole como argumento el objeto a guardar.

Profesor profesor=new Profesor(101, "Juan", "Perez", "García");  //Creamos el objeto
 
Session session = sessionFactory.openSession();
session.beginTransaction();
 
session.save(profesor); //<|--- Aqui guardamos el objeto en la base de datos.
 
session.getTransaction().commit();
session.close();

Como vemos , guardar una clase Java en la base de datos solo implica usar una única línea.

Leer

El método que debemos usar es get(Class,Serializable), al que le deberemos pasar la clase que queremos leer y su clave primaria.

Profesor profesor=(Profesor)session.get(profesor.class,101);

El método get(Class,Serializable) permite leer un único objeto de la base de datos a partir de su clave primaria.

El uso de este método tiene 2 peculiaridades:

  • Uso del cast:Es necesario hacer un cast añadiendo (Message) en el retorno de la función. Ésto es así ya que el método get() se usa para cualquier tipo de entidad así que Java desconoce que tipo de datos va a retornar , por lo que debemos decírselo nosotros mediante el cast para “asegurarle” el tipo que retorna.
  • El uso de la propiedad .class:Ésta es la forma que se ha definido en en lenguaje Java para pasar un objeto de la clase java.lang.Class. Véase Class Literals.

Actualizar

El método a usar es update(Object object), al que le deberemos pasar el objeto a actualizar en la base de datos

session.beginTransaction();
 
session.update(profesor);
 
session.getTransaction().commit();

El método update(Object object) simplemente actualiza el objeto de la base de datos.

Borrar

Ahora pasemos a borrar un objeto desde la base de datos.El método que debemos usar es delete(Object object), al que le deberemos pasar el objeto a borrar de la base de datos

session.beginTransaction();
 
session.delete(profesor);
 
session.getTransaction().commit();

El método delete(Object object) simplemente borra el objeto de la base de datos.

Guardar y actualizar

Muchas veces resulta cómodo al programar no tener que estar pendiente de si un objeto va a insertarse o actualizarse. Para ello Hibernate dispone del método saveOrUpdate(Object object) que inserta o actualiza en la base de datos en función de si ya existe o no dicha fila.

1: Profesor profesor=new Profesor(101, "Juan", "Perez", "García");
2:
3: session.beginTransaction();
4:
5: session.saveOrUpdate(profesor);
6:
7: session.getTransaction().commit();

En este caso dependiendo de si existe o no la fila en la base de datos con Id=101 se realizará un UPDATE o un INSERT contra la base de datos.

Referencias

1) Tiene registrados
unidades/02_hibernate/04_usando_hibernate.txt · Última modificación: 2016/07/03 20:35 (editor externo)
Ir hasta arriba
CC Attribution-Noncommercial-Share Alike 3.0 Unported
chimeric.de = chi`s home Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0