Un Agente CRUD para el uso de Hibernate

Buenas de nuevo. Después de tanto tiempo vuelvo a incluir una nueva entrada. Perdón a los que habéis estado esperando tanto tiempo (según mis cuentas solo mi amigo y compañero Longinos), pero ya tengo preparadas una serie de entradas nuevas con las que ir entreteniéndoos. Adelanto que alguna de ellas no será de informática, para los que esperan ansiosos (todavía solo mi novia, jejeje) que les hable de otros temas.

La presente entrada trata sobre Hibernate. Para los que no conozcan lo que es Hibernate, comentar brevemente que es una tecnología de mapeo objeto-relacional implementada para Java. También existe una versión para .NET llamada NHibernate.

En resumidas cuentas, Hibernate es una herramienta que nos permite abstraer la capa de Persistencia de nuestros programas y aplicaciones, de manera que por ejemplo, para guardar la información de un determinado objeto en base de datos no tenemos primero que serializar el objeto en una consulta SQL y después ejecutarla, si no que directamente "guardas el objeto en la base de datos".


Esto se realiza a groso modo relacionando las tablas de la base de datos con las clases persistentes del programa mediante ficheros XML.

Hibernate es muchísimo más complejo de lo que he explicado de manera somera en los anteriores párrafos. Hay por la Web muchos tutoriales sobre esta tecnología que os pueden dar más información teórica. Yo como chico práctico que soy, voy a ir a eso, a enseñaros cosas prácticas que podáis utilizar directamente en vuestros programas.

Por lo tanto, lo primero sobre Hibernate que voy a añadir va a ser un Agente CRUD (Create, Read, Update, Delete), con el cual vais a poder abstraer en una sola clase el acceso a una base de datos utilizando Hibernate.

Este agente está hecho a partir de la clase HibernateUtil, que se crea automáticamente en muchos entornos de desarrollo, y el objetivo es crear las cuatros funciones  básicas de acceso a una base de datos, como son Insertar, Leer, Actualizar y Borrar.

Los que leísteis mi entrada anterior (y los más avanzados en conocimientos de Ingeniería del Software), comprobareis que esta clase implementa el patrón Singleton, lógico, ya que no vamos a querer por seguridad que dos instancias accedan a la vez a la base de datos.

Aquí os muestro el código.

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.hibernate.collection.PersistentSet;



/**
 * Clase Agente que permite el acceso a una base de datos relacional utilizando Hibernate.
 * Incluye las  cuatro funciones básicas de acceso a una base de datos como son Insertar,
 * Consultar, Editar y Borrar.
 * Implementa el patrón Singletón de manera que solo haya una instancia, y no haya conflictos
 * en el acceso a la BBDD.
 * @author Franjo
 *
 */
public class Agente {
 private SessionFactory sessionFactory;
 protected static Agente instancia;
 
 public static Agente getAgente() {
  if (instancia==null) 
   instancia=new Agente();
  
  return instancia;
 }
 
 /**
  * Constructor que configura hibernate para que la comunicación sea correcta
  */
    protected Agente(){
        try {
            sessionFactory = new Configuration().configure().buildSessionFactory();            
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }
    
    
    /**
     * El método insertar, añade el objeto que tiene por parámetros mediante el método
     * save de hibernate
     * @param obj, el objeto que se desea insertar
     */
    public void insertar(Object obj) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            session.save(obj);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    
    /**
     * El método select, realiza la consulta que hay por parámetros como String mediante
     * el método find de hibernate 
     * @param sql, es la sentencia SQL que debe ejecutar el agente
     * @return Lista de objetos que da como resultado la consulta
     */
    public List select(String sql) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            List result = session.find(sql);
            tx.commit();
            session.close();
            return result;
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    /**
     * El método editar, modifica el objeto que tiene por parámetros mediante el método
     * update de hibernate
     * @param obj, el objeto que se desea editar
     */
    public void editar(Object obj) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            session.update(obj);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    
    
    /**
     * El método borrar, elimina el objeto que tiene por parámetros mediante el método
     * delete de hibernate
     * @param obj, el objeto que se desea eliminar
     */
    public void borrar(Object obj) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            session.delete(obj);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }

}
  

Espero que os sirva esta clase para vuestras prácticas (pensando en los pobres estudiantes de Ingeniería Informática, como yo era antes de acabar la carrera). Si os sirve para sacar buena nota gracias al código que  os pongo lo único que espero es que insertéis un comentario en el blog para que os pueda felicitar, jejeje.

En futuras entradas tengo previsto seguir hablando sobre Hibernate. Para la próxima entrada sobre Hibernate estoy preparando una mini-aplicación sobre el uso de Hibernate con bases de datos SQLite. 

Así que un saludo, y hasta la próxima entrada que será bastante pronto. Ciaoooooo!!!!!!!!