Para empezar debemos realizar un pequeño repaso a lo que nos referimos con persistencia, más allá de la mera definición de la RAE este termino surge como la manera de almacenar nuestros objetos en un soporte relacional; es decir como guardar nuestros objetos a base de datos directamente.
El problema es que es como mezclar aceite y agua, aquello no se mezcla ni une, ya que las bases de datos suelen estar orientadas en un modelo relacional y el software orientado en un modelo objetual. Esto hace optemos con frecuencia por soluciones de unir ambos modelos con unas clases dao que muchas veces son meros parseadores de las respuestas a nuestras consultas SQL.
Aquí es donde aparece Hibernate para aportarnos todo eso de una manera más o menos transparente.
Ejemplo para insertar un registro en una tabla habitualmente se utiliza una estructura de este tipo.
[code lang=»java»]
Class.forName(“org.oracle.jdbcDriver”);
String url = “jdbc:oracle:@database”;
Connection connection = DriverManager.getConnection(url, “usuario”, “password”);
String ins = “INSERT INTO COCHES VALUES(1, ‘Audi’)”;
Statement stmt = null;
stmt = connection.createStatement();
stmt.executeUpdate(ins);
[/code]
Con Hibernate, escribiríamos algo similar a esto:
[code lang=»java»]
Configuration conf = new Configuration();
conf.addClass(Coches.class);
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
Coche coche = new Coche();
coche.setModelo(“Audi”);
session.save(coche);
session.flush();
session.close();
[/code]
Y si nos interesase añadir otro modelo:
[code lang=»java»]
session = sessionFactory.openSession();
coche = new Coche();
coche.setModelo(“Ford”);
session.save(coche);
session.flush();
session.close();
[/code]
Vemos que hay una gran diferencia entre ambos métodos, ya que en el segundo caso pasamos del SQL a simplemente decir que queremos “salvar” un coche.
A la hora de buscar también sabemos cual puede ser el lío con la técnica habitual mientras que con Hibernate se reduce a:
[code lang=»java»]
session = sessionFactory.openSession();
String qry = “FROM beans.Coche AS P
WHERE P.Modelo = ‘Audi’
ORDER BY P.Modelo”;
List coches = session.find(qry);
session.close();
for (int i = 0; i < coches.size(); i++) {
Coche c = (Coche)coches.get(i);
…….
}
[/code]
¿Ya está así de sencillo?
No todo iba a ser así de fácil, para que Hibernate consiga realizar esto debemos realizar un mínimo de configuración:
1. Hibernate.properties: En el que se especifica contra que base de datos y que lenguaje conectaremos y cómo lo haremos.
2. NombreDeClasse.hbm.xml: En el que se describe cómo se relacionan nuestras clases con las tablas.
Hibernate.properties
En este archivo, se pueden especificar muchísimas cosas. Nos limitaremos, por ahora, a proporcionar los datos necesarios para que Hibernate se pueda conectar a nuestra base de datos HSQLDB. Este sería, pues, el mínimo necesario para funcionar:
[code]
## HypersonicSQL
hibernate.dialect net.sf.hibernate.dialect.HSQLDialect
hibernate.connection.driver_class org.hsqldb.jdbcDriver
hibernate.connection.username usuario
hibernate.connection.password pasword
hibernate.connection.url jdbc:hsqldb:hsql://localhost
[/code]
Solo hay que configurar pocos datos. Además dentro de la propia distribución de Hibernate en el fichero vienen ejemplos para todas las bases de datos que soporta Hibernate solo tenemos que descomentar nuestro tipo de bbdd y comenzar.
NombreDeClase.hbm.xml
Este es el archivo que vincula nuestra clase (bean) con la bbdd. Este ejemplo es el que se corresponde con la clase Coche (Coche.hbm.xml).
[code lang=»xml»]
[/code]
Para nuestro bean Coche:
[code lang=»java»]
Package beans;
public class Coche {
/** Identificador único */
int id;
String modelo;
public String getModelo() {
return modelo;
}
public int getId() {
return id;
}
public void setModelo(String nuevoModelo) {
modelo = nuevoModelo;
}
public void setId(int nuevoId) {
id = nuevoId;
}
public String toString() {
return getId() + » » + getModelo();
}
}
[/code]
Y con esto si que estaría todo, solo faltaría ubicar correctamente nuestros ficheros de configuración, el Coche.hbm.xml en el mismo directorio de la clase, y el fichero
Hibernate.properties en la raíz de nuestro árbol de paquetes.
Ahora os voy a presentar un pequeño ejemplo de funcionalidad de Hibernate:
[code lang=»java»]
public void anadir(String modelo) {
Coche categoria = new Coche();
coche.setModelo(modelo);
//Obtenemos la configuración
Configuration conf = new Configuration();
//Buscamos el mapeo de nuestra clase
conf.addClass(Coche.class);
//Construimos la sesion
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
//iniciamos la transaccion
Transaction tx = session.beginTransaction();
// Guardamos la nueva Categoria en la base de datos
session.save(coche);
// Confirmamos la transacción
tx.commit();
// Cerramos la sesión
session.close();
}
Configuration conf = new Configuration();
conf.addClass(Categoria.class);
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
Categoria categ = new Categoria();
categ.setCategoria(“Profesor”);
session.save(categ);
session.flush();
session.close();
Otro ejemplo:
public void borrar(int id) {
[…]
Coche coche = new Coche();
coche.setId(id);
Transaction tx = session.beginTransaction();
session.delete(coche);
tx.commit();
[…]
}
[/code]
Por supuesto todo esto solo es la punta de Hibernate, os recomiendo que paséis por la página y deis un vistazo, sobre todo a que actualmente soporta mas de 20 diferentes tipos de bases de datos.
Hemos visto que la presencia de los archivos de configuración y demás hace que nuestra aplicación se vuelve un poco compleja, en próximos post analizaremos las anotaciones en java y su aplicación con Hibernate.
Enlace: Hibernate
Comentarios recientes