Manual Hibernate

Introduccrin a Hibernate
23/12/2004 00:00 Francesc Ros
INTRODUCCIN A HIBERNATE1
Francesc Ross Albiol
Septiembre 2003
Traduccin: Abril 2004
Revisin Octubre-Diciembre 2004
Hibernate es un entorno de trabajo que tiene como objetivo facilitar la persistencia de objetos Java
en bases de datos relacionales y al mismo tiempo la consulta de estas bases de datos para obtener
objetos.
El objetivo de este artculo es familiarizar al lector con la filosofa utilizada en Hibernate y
conseguir que sea capaz de utilizar Hibernate para desarrollar alguna aplicacin. Hay, pues, un
doble objetivo: Filosfico (obsrvese las comillas) y prctico, Ambos objetivos van unidos. No
pretendo entrar en la arquitectura de detalle usada por Hibernate ni en una discusin terica.
Partir de mi experiencia prctica como desarrollador para ilustrar (y justificar, en parte) la
filosofa de Hibernate.
Y si parto de la experiencia como desarrollador, he de proporcionar los medios para que un
desarrollador que lea este artculo pueda, despus de hacerlo, usar Hibernate. Es, pues, un objetivo
de este artculo, conseguir que el lector sea capaz de escribir pequeas aplicaciones de ABM
(Altas, Bajas y Modificaciones) usando Hibernate.
Las posibilidades que ofrece Hibernate exceden con mucho las pretensiones de este artculo, as
que me centrar slo en las que cubren la casustica ms habitual.
HIBERNATE: UN CASAMENTERO
Cualquier persona que se dedique al desarrollo objetual se encontrar con la problemtica de implementar
una persistencia de objetos en un soporte relacional.
El problema es que hay un divorcio total entre la estructura relacional y la objetual. Esto hace que el
desarrollador opte con frecuencia por soluciones de compromiso que le hacen perder de vista el mundo
objetual y la aplicacin acaba siendo un batiburrillo infumable con una pseudoarquitectura objetual que hace
dao a la vista.
Pongamos un ejemplo. Intentemos disear una base de datos para una escuela. Por una parte, tendramos la
lista de personas que pertenecen a la escuela. Cada persona tiene una sola categora: profesor, alumno,
personal de administracin, etc. En la escuela, hay niveles: primero de EGB, segundo de EGB, etc. Adems,
hay clases. Cada clase pertenece a un nivel y tiene un nombre. As, es posible que haya tres clases de
primero de EGB: A, B y C. Pero una clase no es una clase sin alumnos y profesores. As que tendremos que
asignar personas a una clase. No entraremos aqu en un diseo minucioso ni nos preocupar si una persona
est en una o ms clases.
As, podramos pensar en una definicin de tablas similar a esta:
CREATE TABLE CATEGORIAS
(
ID INTEGER IDENTITY,
CATEGORIA VARCHAR(50) NOT NULL
);
CREATE TABLE PERSONAS
(
NOMBRE VARCHAR(30) NOT NULL,
APELLIDOS VARCHAR(100) NOT NULL,
ID_CATEGORIA INTEGER NOT NULL
);
ALTER TABLE PERSONAS ADD CONSTRAINT FK_P2C
FOREIGN KEY ( ID_CATEGORIA )
REFERENCES CATEGORIAS ( ID );
CREATE TABLE NIVELES
(
NIVEL VARCHAR(30) NOT NULL
);
CREATE TABLE CLASE
(
NOMBRE VARCHAR(20) NOT NULL,
ID_NIVEL INTEGER NOT NULL
);
ALTER TABLE CLASE ADD CONSTRAINT FK_CLASE_NIVEL
FOREIGN KEY ( ID_NIVEL )
REFERENCES NIVELES ( ID );
CREATE TABLE CLASSE_PERSONAS
(
ID_CLASE INTEGER NOT NULL,
ID_PERSONA INTEGER NOT NULL,
PRIMARY KEY (ID_CLASE,ID_PERSONA)
);
ALTER TABLE CLASE_PERSONAS ADD CONSTRAINT FK_CP_C
FOREIGN KEY ( ID_CLASSE )
REFERENCES CLASE ( ID );
ALTER TABLE CLASE_PERSONAS ADD CONSTRAINT FK_CP_P
FOREIGN KEY ( ID_PERSONA )
REFERENCES PERSONAS ( ID );
El siguiente grfico muestra las relaciones entre tablas:
Figura 1: Modelo Relacional
Pero el diseo objetual con el que nos gustara trabajar no es un calco del diseo relacional. La siguiente
figura ilustra nuestro diseo objetual con un diagrama de clases UML.
Figura 2: Modelo Objetual
Observemos algunos cambios en nuestro diagrama de clases:

1. Los nombres de los objetos estn en singular, mientras que los de las tablas estn en plural. As,
entendemos que una instancia de un objeto se corresponde con un registro de una tabla. Una tabla es
un conjunto de Personas. La clase Persona representa una sola persona.
2. La clase Persona no tiene un entero que apunte a la tabla Categorias. Tiene un objeto de tipo
Categoria. As, vemos que los tipos de las propiedades de un objeto no siempre se corresponden
con los tipos de las columnas de las tablas. Un caso similar, lo encontraramos en el objeto Clase.
La propiedad correspondiente a la columna ID_NIVEL INTEGER es del tipo Nivel, no int.
3. En nuestro diseo del modelo relacional, tenemos la tabla CLASE_PERSONAS que es la encargada
de almacenar las personas asociadas a cada clase. Desde el punto de vista objetual, el planteamiento
es distinto. Cada clase tiene un conjunto, Set, de personas. No necesitamos crear un objeto puente
que relacione clases y personas.
Conclusin: el modelo relacional y el objectual no acaban de casar.
Ahora bien, est claro que tendremos que hacer casar los dos modelos si queremos trabajar con comodidad;
y este es el papel de Hibernate: hacer de casamentero. Hibernate se encarga de casar los dos modelos de
manera que nosotros trabajemos desde Java como corresponde. Usando el modelo objetual.
Sin Hibernate, para aadir un registro a la tabla Categorias tendramos que escribir algo similar a esto:2
[...]
Class.forName(org.hsqldb.jdbcDriver);
String url = jdbc:hsqldb:./Databases/ESCUELA;
Connection connection = DriverManager.getConnection(url, sa, );
String ins = INSERT INTO CATEGORIAS VALUES(NULL, 'Profesor');
Statement stmt = null;
stmt = connection.createStatement();
stmt.executeUpdate(ins);
[...]
Con Hibernate, escribiramos algo similar a esto:

[...]
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();
[...]
Y si nos interesase aadir otra:

[...]
session = sessionFactory.openSession();
categ = new Categoria();
categ.setCategoria(Alumno);
session.save(categ);
session.flush();
session.close();
Cul es la gran diferencia entre el cdigo tradicional JDBC y el cdigo que escribimos con Hibernate? Ha
desparecido el SQL. Lo nico que digo es que quiero guardar (save) un objeto.
Si lo que queremos es ejecutar una consulta a la base de datos, tendremos que utilizar un lenguaje de
interrogacin que case con el mundo objetual. Pedir una lista ordenada de profesores nos costara tan poco
como esto:
[...]
session = sessionFactory.openSession();
String qry = FROM escuela.beans.Persona AS P
WHERE P.categoria.categoria = 'Profesor'
ORDER BY P.apellidos, P.nombre;
List profes = session.find(qry);
session.close();
for (int i = 0; i < profes.size(); i++) {
Persona p = (Persona)profes.get(i);
System.out.println(p.getNombre() + + p.getApellidos() +
p.getCategoria().getCategoria());
}
Observamos aqu que la consulta se formula en base a objetos y que, una vez ms, ha desaparecido el
SQL. Del SQL, se ocupa Hibernate. l casa nuestro mundo objectual con el relacional. Pedimos objetos y
expresamos las condiciones de la consulta objetualmente. Hibernate se encarga de transformar nuestra
consulta al dialecto SQL que toque.
Hibernate soporta, actualmente, los siguientes dialectos:3
RDBMS
Clase del dialecto
DB2
net.sf.hibernate.dialect.DB2Dialect
DB2 AS/400
DB2 OS390
PostgreSQL
net.sf.hibernate.dialect.PostgreSQLDialect
MySQL
net.sf.hibernate.dialect.MySQLDialect
Oracle (cualquier versin)
net.sf.hibernate.dialect.OracleDialect
RDBMS
Clase del dialecto
Oracle 9/10g
net.sf.hibernate.dialect.Oracle9Dialect
Sybase
net.sf.hibernate.dialect.SybaseDialect
Sybase Anywhere
net.sf.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server
net.sf.hibernate.dialect.SQLServerDialect
SAP DB
net.sf.hibernate.dialect.SAPDBDialect
Informix
net.sf.hibernate.dialect.InformixDialect
HypersonicSQL (HSQLDB)
net.sf.hibernate.dialect.HSQLDialect
Ingres
net.sf.hibernate.dialect.IngresDialect
Progress
net.sf.hibernate.dialect.ProgressDialect
Mckoi SQL
net.sf.hibernate.dialect.MckoiDialect
Interbase
net.sf.hibernate.dialect.InterbaseDialect
Pointbase
net.sf.hibernate.dialect.PointbaseDialect
FrontBase
net.sf.hibernate.dialect.FrontbaseDialect
Firebird
net.sf.hibernate.dialect.FirebirdDialect
Tabla 1: Dialectos SQL soportados
Aadir, nicamente, que uno puede crearse sus propios dialectos, extendiendo uno ya existente o,
directamente, extendiendo la clase abstracta net.sf.hibernate.dialect.Dialect.
QU HAY QUE PRESENTAR PARA

CASARSE?
Como hemos visto, Hibernate casa el mundo objetual con el relacional. Ahora bien, para casarse hay que
presentar una serie de documentacin que es la que posibilita la boda.
Qu ha de saber Hibernate para casar los dos modelos?

1. Quin est detrs del modelo relacional:
1. Qu gestor de bases de datos est detrs
2. A qu base de datos me conecto
3. Cmo me conecto
4. Etc.
2. Cmo se emparejan propiedades y campos de tablas:
1. Clave primaria:
1. Cul es la propiedad que se corresponde con la clave primaria de la tabla
correspondiente?
2. Qu mtodo deber utilizar para generar un nuevo valor de la clave primaria?
3. Etc.
2. Otras propiedades:
1. Cmo empareja una propiedad con un campo de una tabla de la base de datos
1. Cmo se llama la columna correspondiente?
2. Qu tipo tiene?
3. Es obligatoria?
4. Etc.
3. Cmo gestiona las relaciones entre tablas
1. Es una relacin uno-a-uno,
2. uno-a-muchos,
3. muchos-a-muchos?, etc.
Para responder a las dos grandes preguntas, se utilizan dos archivos distintos:
1. El archivo de propiedades de Hibernate (Hibernate.properties) es el encargado de
determinar los aspectos relacionados con el gestor de bases de datos y las conexiones con l.
2. Los archivos que que definen el emparejamiento (mapping) de propiedades con tablas y
columnas (*.hbm.xml)
Una boda sencilla

Para no complicar las cosas de entrada, vamos a plantear un archivo de propiedades de Hibernate sencillo
que nos permita interactuar con HSQLDB y un archivo de emparejamiento simple entre la clase
Categoria y la tabla Categorias.
Para que tenga lugar la boda, hay que presentar dos documentos:
Hibernate.properties: En el que se dice qu gestor de bases de datos usaremos y a qu base

de datos nos conectaremos y cmo lo haremos.
NombreDeClasse.hbm.xml: En el que se describe cmo se relacionan clases y tablas y
propiedades y columnas.
A continuacin, los describiremos con ms detalle.
El archivo de propiedades de Hibernate: Hibernate.properties

En este archivo, se pueden especificar muchsimas cosas. Nos limitaremos, por ahora, a proporcionar los
datos necesarios para que Hibernate se pueda conectar a nuestra base de datos HSQLDB. Este sera, pues, el
mnimo necesario para funcionar:
## HypersonicSQL
hibernate.dialect net.sf.hibernate.dialect.HSQLDialect
hibernate.connection.driver_class org.hsqldb.jdbcDriver
hibernate.connection.username sa
hibernate.connection.password
hibernate.connection.url jdbc:hsqldb:hsql://localhost
La configuracin es sencilla. Especificamos el dialecto SQL y los datos necesarios para poder establecer una
conexin con la base de datos va JDBC (Driver, URL, usuario y contrasea).
El archivo de emparejamiento (mapping): Categoria.hbm.xml

Este es el archivo que casa los mundos relacional y objetual. El ejemplo, sencillsimo, que presentamos aqu
es el que se corresponde con la clase Categoria.
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="escuela.beans.Categoria" table="categorias">
<id name="id" type="integer" column="ID" unsaved-value="-1">
<generator class="identity"/>
</id>
<property name="categoria" column="CATEGORIA"

type="string"
unique=true
not-null="true"/>
</class>
</hibernate-mapping>
Como vemos, para definir los emparejamientos se usa un documento XML.
Cabecera XML
ste tiene una cabecera fija, tpica de todos los documentos XML, que no describiremos.
El elemento <hibernate-mapping>
Despus de la cabecera, entramos en la parte de descripcin de los emparejamientos, delimitada por el
elemento <hibernate-mapping>. Este elemento permite especificar, mediante atributos, diversas
caractersticas como el esquema de la base de datos. No nos entretendremos en describirlo.
El elemento <class>
Como estamos emparejando una clase con una tabla, hemos de especificar cules son. Lo hacemos usando
el elemento <class>:
<class name="escuela.beans.Categoria" table="categorias">
Indicamos el nombre de la clase (name=escuela.beans.Categoria) y el nombre de la tabla con la

que se empareja (table=categorias).
El elemento <id>
Una vez emparejados objeto y tabla, hay que emparejar las propiedades del objeto con las columnas de la
tabla. En nuestro ejemplo, observamos que para describir este emparejamiento se utilizan dos elementos
XML distintos: <id> y <property>.
El primero, <id>, empareja una de las propiedades con la clave primaria de la tabla:
<id name="id" type="integer" column="ID" unsaved-value="-1">
Identificamos la propiedad que se empareja con la clave primaria mediante el atributo XML name. En
nuestro caso, la propiedad a relacionar con la clave primaria es id.
Esta propiedad se empareja con la columna ID de la tabla: column=ID. Como el nombre de la
propiedad y el de la columna coinciden, en este caso, nos podramos ahorrar el atributo column.
Tambin, y opcionalmente, especificamos el tipo de datos con el que estamos trabajando. En este caso, con
enteros. Como es un tipo bsico, no necesitaramos usar el atributo type. Hibernate sabe deducir el tipo de
datos que estamos utilizando a partir de la introspeccin. Hibernate analiza en tiempo de ejecucin las clases
Java y obtiene la informacin que necesita. Aqu, a guisa de ejemplo, especificamos el tipo de datos
Hibernate: type=integer.4
En nuestro ejemplo, hemos vuelto a utilizar un atributo opcional: unsaved-value. Este atributo permite
especificar qu valor tiene el campo clave cuando an no ha sido guardado en la base de datos. En nuestro
caso, -1. As, de entrada, parece un atributo poco til, pero no es as. La clase Session de Hibernate
dispone de un mtodo muy prctico: saveOrUpdate(Object). Este mtodo distingue si un objeto debe
ser guardado por primera vez en la base de datos o bien modificado porque ya est en ella, en funcin de lo
que especifiquemos en el atributo unsaved value. En nuestro caso, la propiedad id de una
Categoria que an no haya sido guardada en la base de datos tendr un valor -1. Esto indicar a
Hibernate que hay que guardarla; y al hacerlo, la propiedad id de esta Categoria pasar a tener un valor
diferente de -1, por ejemplo, 25. Si recuperamos de la base de datos esta categora, tendremos un objeto
Categoria con un id igual a 25. Si modificamos la propiedad categoria y despus utilizamos el
mtodo saveOrUpdate(), Hibernate comprobar que la propiedad id no vale -1 y deducir que en vez
de guardar, ha de modificar.
El atributo unsaved-value puede tener los siguientes valores predefinidos: any, none y null. Por
defecto, null.
El subelemento <generator>
Este elemento nos permite definir cmo se generan los valores de las claves primarias. Hibernate nos ofrece
diversos mtodos de generacin de valores para las claves primarias.
El mtodo se especifica mediante el atributo class. En nuestro ejemplo, usamos el mtodo identity, ya
que HSQLDB soporta claves primarias de tipo IDENTITY.5
Hay ms muchos mtodos predefinidos y, si fuera necesario, los podramos definir nosotros. Algunos, como
identity, generan claves directamente y otros necesitan la ayuda de tablas auxiliares para generarlas.
Sera demasiado largo comentarlos todos, as que nos centraremos en un tres de ellos.6
El mtodo native es bastante interesante. Deja que Hibernate escoja entre los mtodos identity,
sequence o hilo,7 en funcin de las caractersticas del gestor de bases de datos con el que trabajemos.
El mtodo assigned deja que sea nuestra aplicacin la que asigne un identificador al objeto antes de
guardarlo en la base de datos.
El mtodo increment genera identificadores de tipo long, short o int que son nicos slo cuando no
hay otro proceso que est insertando datos en la misma tabla. Por lo tanto, no es recomendable usarlo, por
ejemplo, en un cluster.
El elemento <property>
Sirve para emparejar aquellas propiedades que no forman parte de la clave primaria con las
correspondientes columnas de una (o ms) tablas.
Aqu tenemos el emparejamiento propuesto para la propiedad categoria de nuestro ejemplo.

<property name="categoria" column="CATEGORIA"
type="string"
unique=true
not-null="true"/>
Como en el caso del elemento id, el atributo name indica el nombre de la propiedad, el atributo column,
el nombre de la columna de la tabla categorias y el atributo type nos indica el tipo de Hibernate.
El atributo unique, opcional, nos permite especificar si se admiten valores duplicados o no. En nuestro
caso, no.
El atributo opcional not-null, nos permite especificar la obligacin de que la propiedad tenga un valor
no nulo.
VIDA MATRIMONIAL
Bien, una vez casados, veamos qu hay que hacer...
Clases persistentes Java Beans

Para que una clase pueda beneficiarse de las ventajas de Hibernate, es necesario que cumpla con una nica
condicin de los Java Beans: Las propiedades objeto de persistencia deben ser accesibles mediante mtodos
get y set. Sencillsimo.
As, la clase Categoria quedara ms o menos como sigue:
/*
* Creada el 24/09/2003
* (c) Francesc Ross
*/
package escuela.beans;
/**
* Categora de personal.
* @author Francesc Ross
*/
public class Categoria {
/**
Identificador nico */
int
id;
/**
Devuelve el contenido de la propiedad <code>categoria</code>.
* @return Categoria
*/
public
String getCategoria() {
return
categoria;
/**
* Devuelve el contenido de la propiedad <code>id</code>.
* @return Id
*/
public
int getId() {
return
id;
/**
* Asigna un nuevo valor a la propiedad <code>categoria</code>.
* @param nuevaCategoria
*/
public
void setCategoria(String nuevaCategoria) {
categoria
= nuevaCategoria;
/**
* Asigna un nuevo valor a la propiedad <code>id</code>.
* @param nuevoId
*/
public void setId(int nuevoId) {
id = nuevoId;
}
/**
* Devuelve una tira que representa el objeto. En este caso,
* concatena las propiedades <code>id</code> y
* <code>categoria</code>.
* @return Una representacin textual del objeto.
*/
public String toString() {
return getId() + " " + getCategoria();
}
}
Altas, bajas, modificaciones (ABM) y consultas

En cualquier aplicacin que use Hibernate aparecen cuatro objetos bsicos:
1. Configuration: es el objeto que contiene la informacin necesaria para conectarse a la base de
datos. Es el encargado de leerse el archivo Hibernate.properties.
Tambin es el encargado de procesar la informacin correspondiente a los aparejamientos. Es el
encargado de leerse y verificar los archivos de emparejamiento nombreDeClasse.hbm.xml.
Configuration conf = new Configuration();
conf.addClass(escuela.beans.Categoria.class);
2. SessionFactory: es una fbrica de Sessions. Un objeto Configuration es capaz de

crear una SessionFactory ya que tiene toda la informacin necesaria.
Normalmente, una aplicacin slo tiene una SessionFactory.
SessionFactory sessionFactory = conf.buildSessionFactory();
3. Session: La principal interficie entre la aplicacin Java e Hibernate. Es la que mantiene las
conversaciones entre la aplicacin y la base de datos. Permite aadir, modificar y borrar objetos en la
base de datos.
Session session = sessionFactory.openSession();
4. Transaction: Como su nombre indica, se encarga de la transaccionalidad. Permite definir

unidades de trabajo.
Transaction tx = session.beginTransaction();
[...]session.save(unaCategoria);
tx.commit();
[...]
tx.rollback();
Un posible patrn de aplicacin

A continuacin, expondr un esquema (discutible, sin duda) que es el que acostumbro a usar en las
aplicaciones Hibernate.
Primero, defino las 3 propiedades bsicas y las asigno a null:
Configuration configuration = null;
SessionFactory sessionFactory = null;
Session session = null;
Despus, defino los mtodos de acceso a estas propiedades siguiendo siempre el mismo patrn: si la
propiedad es nula, la creo y la devuelvo. Si no es nula, simplemente la devuelvo:
/**
* [1] Construye y/o devuelve una Configuration.
*/
public Configuration getConfiguration() {
if (configuration == null) {
// [1.1] Aqu lee el archivo de propiedades de Hibernate
configuration = new Configuration();
// [1.2] Aqu lee el archivo de emparejamientos Categoria.hbm.xml

try {
configuration.addClass(escuela.beans.Categoria.class);
} catch (MappingException e) {
// Actuamos en consecuencia
}
}
return configuration;
}
/**
* [2] Construye y/o devuelve una SessionFactory.
*/
public SessionFactory getSessionFactory() {
if (sessionFactory == null) {
try {
sessionFactory = getConfiguration().buildSessionFactory();
} catch (HibernateException e) {
}
}
return sessionFactory;
/**
* [3] Construye y/o devuelve una Session.
*/
public Session getSession() {
// [3.1] La crea si es nula o est cerrada
if (session == null || !session.isOpen()) {
try {
session = getSessionFactory().openSession();
}
}
return session;
}
[1] Lo primero que hacemos es crear una instancia de Configuration. Esta clase, como hemos visto,
es la encargada de procesar el archivo de propiedades, hibernate.properties y el de
emparejamiento, nombreDeClasse.hbm.xml.
[1.1] En el momento de crearla, Hibernate va a buscar el archivo Hibernate.properties al
directorio padre del package en el que se encuentra nuestra clase. As, si nuestra clase se encuentra en el
package escuela.abm, y la estructura de directorios es:
C:\INTRODUCCION_HIBERNATE\EJEMPLO\escuela\abm\CategoriaABM.java
El archivo hibernate.properties tiene que estar en

C:\INTRODUCCION_HIBERNATE\EJEMPLO
[1.2] Una vez creada la instancia de Configuration, le pasamos la informacin sobre el

emparejamiento:
configuration.addClass(escuela.beans.Categoria.class);
Esto hace que Hibernate vaya a buscar el archivo de emparejamiento en el mismo directorio en el que se
encuentra la clase:
C:\INTRODUCCION_HIBERNATE\EJEMPLO\escuela\beans\Categoria.hbm.xml
[2] En estos momentos, Hibernate ya sabe cmo conectarse a la base de datos que nos interesa y cmo se
emparejan propiedades y columnas. Pero, como hemos visto ms arriba, para comunicarnos con Hibernate
desde nuestra aplicacin, necesitamos una Session, y para crearla, necesitamos una fbrica de
Sessions. Una SessionFactory:
sessionFactory = getConfiguration().buildSessionFactory();
[3] Una vez tenemos la fbrica, ya podemos crear Sessions:

session = getSessionFactory().openSession();
Altas
Aadir una nueva Categoria a la base de datos es sencillo:
public void anadir(String categ) {
// [1] Construimos una nueva Categoria
Categoria categoria = new Categoria();
categoria.setCategoria(categ);
// [2] Creamos una Session

Session session = getSession();
if (session == null) {
System.out.println(Error abriendo sesin.);
return;
}
Transaction tx = null;
try {
// [3] Iniciamos una unidad de trabajo
tx = session.beginTransaction();
// [4] Guardamos la nueva Categoria en la base de datos
session.save(categoria);
// [5] Confirmamos la transaccin
tx.commit();
if (tx != null) {
try {
[6] Tiramos para atrs la transaccin
tx.rollback();
}
}
}
finally {
try {
[7] Cerramos la sesin
session.close();
}
}
} // anadir()
[1] Para aadir una nueva Categoria, primero hay que crearla. En nuestro ejemplo, la creamos a partir
del parmetro categ del mtodo.
[2] Hemos visto que la Session es el puente entre nuestra aplicacin e Hibernate. Usamos el mtodo
getSession(), descrito ms arriba, para obtener una Session.
[3] Iniciamos una unidad de trabajo antes de aadir la Categoria:8
Transaction tx = getSession().beginTransaction();
[4] Guardamos categoria en la base de datos.

Observamos que no hay ninguna instruccin SQL. Simplemente, estamos persistiendo un objeto.
[5] Si no ha habido ningn problema, confirma la transaccin a la base de datos, haciendo un commit()
y cierra la unidad de trabajo. En definitiva, hace un SQL COMMIT pero adems, sincroniza la sesin con la
base de datos ejecutando implcitamente el mtodo flush() de la clase Session.
[6] Si ha habido algn problema, tira para atrs la transaccin y cierra la unidad de trabajo. En definitiva,
hace un ROLLBACK.
[7] Para acabar, pase lo que pase, cerramos la sesin.
Bajas
El esquema general para dar de baja una categora es bsicamente el mismo que el de darla de alta. Me
centrar, pues, en la parte especfica de darla de baja:
public void borrar(int idCategoria) {
[...]
Categoria unaCategoria = new Categoria();
unaCategoria.setId(idCategoria);
session.delete(unaCategoria);
tx.commit();
[...]
}
En el ejemplo anterior, creamos una Categoria y le asignamos el identificador que se nos pasa como
parmetro, Este identificador es el que usar Hibernate para eliminar la Categoria de la base de datos.
Hay tres estrategias para borrar registros. Por ejemplo, podemos usar una consulta basndonos en el
identificador de clave primaria:
public void borrar(int idCategoria) {
[...]
session.beginTransaction();
Categoria unaCategoria = (Categoria)session.load(Categoria.class,
new Integer(id));
session.delete(unaCategoria);
tx.commit();
[...]
}
Fijmonos en el mtodo load() de Session. Este mtodo nos devuelve un objeto a partir de un
identificador de clave primaria, Como es lgico, le hemos de pasar la clase (Categoria.class) para
que sepa en qu tabla ha de buscar. Recordemos que en el archivo de emparejamiento
(Categoria.hbm.xml) hemos emparejado la clase Categoria con la tabla CATEGORIAS. Con esta
informacin, Hibernate genera una instruccin SQL similar a esta:
SELECT * FROM CATEGORIAS WHERE ID = miID
Hibernate nos proporciona un lenguaje de consulta orientado a objetos bastante avanzado. Se llama HQL y
hablaremos de l con ms detalle, ms adelante.
El mtodo delete() admite una consulta en HQL como parmetro. En este caso, eliminara todos los
objetos devueltos por la consulta:
[...]
String sel = FROM Categoria AS C WHERE C.id = + idCategoria;
session.delete(sel);
[...]
En este caso, slo borrara un registro. Si, por ejemplo, nos interesase borrar todos los registros que tuvieran
r en el campo CATEGORIA, slo tendramos que cambiar la consulta:
[...]
String sel = FROM Categoria AS C WHERE C.categoria LIKE %r%;

session.delete(sel);
[...]
Fijmonos un poco en la sintaxis de la consulta. Se parece bastante a la sintaxis SQL habitual, pero est
adaptada al mundo de los objetos:
o
o
No hay SELECT ya que no devuelve valores de columnas, sino objetos.

No especificamos ninguna tabla en el FROM. Especificamos una clase. Es a partir de esta
clase y de las definiciones que hemos hecho en el archivo de emparejamientos que Hibernate
deducir qu tablas estn implicadas.
No usamos nombres de columnas en el WHERE. Usamos propiedades de objetos.
Modificaciones
La estrategia va a ser la misma que para las bajas:
public void cambiar(int idCategoria) {
[...]
Categoria unaCategoria = (Categoria)session.load(Categoria.class,
new Integer(id));
// Cambiamos una propiedad del objeto
unaCategoria.setCategoria(Una nueva categora);
// Lo modificamos en la base de datos

session.update(unaCategoria);
tx.commit();
[...]
}
Aadir o modificar?
Ms arriba, hemos visto que el elemento <id> del archivo de emparejamientos (Categoria.hbm.xml)
tiene un atributo que permite que Hibernate pueda decidir si hay que guardar un objeto o modificarlo:
unsaved-value.
En nuestro ejemplo, hemos especificado que si la propiedad id de Categoria vale -1, hay que aadir el
objeto y si no, hay que modificarlo en la base de datos.
public void anadirOCambiar(Categoria unaCategoria) {
[...]
// Lo modificamos o lo aadimos a la base de datos dependiendo del

// valor de la propiedad id
session.saveOrUpdate(unaCategoria);
tx.commit();
[...]
}
UNA BODA MS COMPLICADA

El ejemplo anterior era bastante sencillo. Es el caso tpico del mantenimiento de tablas auxiliares del tipo
codigo y descripcion. En nuestro modelo de datos, hay un caso prcticamente idntico: el de la tabla
NIVELES.
Pero las cosas no son siempre tan sencillas. En nuestro modelo, encontramos un caso igualmente tpico,
pero un poco ms complicado: el de la tabla PERSONAS. En esta tabla encontramos una referencia a la tabla
CATEGORIAS. Toda persona tiene una categora, y en el modelo relacional, lo sealamos con un
identificador de categora: la columna ID_CATEGORIA.
La representacin objetual, sin embargo, no cuadra con la relacional. Las propiedades de la clase Persona
seran:
public class Persona {
/**
Identificador de persona */
int
id;
/**
Nombre de la persona */
String
/**
Apellidos de la persona */
String
/**
nombre;
apellidos;
Categora laboral de la persona */
Categoria categoria;
[...]
}
Aqu, la categora no es un entero que apunta a la tabla de categoras, sino un objeto de tipo Categoria.
Para emparejar el objeto Persona con las tablas del mundo relacional, tenemos que describir esta relacin
en el archivo Persona.hbm.xml. Reproduzco a continuacin un fragmento de dicho archivo:
<hibernate-mapping>
<class name="escuela.beans.Persona" table="personas">

<id name="id" unsaved-value="-1">
</id>
<property name="nombre"/>
<property name="apellidos"/>
<many-to-one name="categoria" column="CATEGORIA_ID"/>
</class>
</hibernate-mapping>
Observamos que, excepto el emparejamiento de la propiedad categoria, todo es igual que en el ejemplo
anterior.
Para expresar la relacin de propiedad categoria, usamos el elemento <many-to-one>. Es decir,
estamos describiendo una relacin muchos-a-uno.
Para hacerlo, decimos que la propiedad de Persona que participa en la relacin many-to-one se llama
categoria (name=categoria). Con esto, Hibernate ya sabe que es de la clase Categoria, y que
esta clase est ligada a la tabla CATEGORIAS. Lo que no sabe es qu campo de la tabla PERSONAS est
emparejado con la clave primaria de la tabla CATEGORIAS. Por eso le decimos que la columna relacionada
es CATEGORIA_ID (column=CATEGORIA_ID).
Ahora, Hibernate ya dispone de todos los elementos para gestionar la persistencia de objetos de tipo
Persona.9
Todo lo que hemos explicado ms arriba sobre altas, bajas y modificaciones para objetos de tipo
Categoria es aplicable a objetos de tipo Persona. Por ejemplo, para aadir una persona a a base de
datos:
// [1] Obtenemos una categora de la base de datos
Categoria categ = null;
categ = (Categoria)unaSesion.load(Categoria.class, new Integer(3));
// [2] Creamos una Persona

Persona p = new Persona();
p.setNombre(Un nombre);
p.setApellidos(Los dos apellidos);
p.setCategoria(categ);
// [3] Iniciamos una unidad de trabajo

Transaction tk = null;
tk = unaSesion.beginTransaction();
// [4] Guardamos el objeto Persona en la base de datos

unaSesion.save(p);
// [5] Cerramos la unidad de trabajo

tk.commit();
Ms preguntas
Avancemos alguna cosa ms del lenguaje de interrogacin HQL, ahora que tenemos una relacin muchos a
uno. Una de las consultas tpicas a la tabla PERSONAS puede ser Quiero obtener todas las personas que
sean profesores.
Si utilizramos SQL y la categora de profesor tuviera un ID = 3, tendramos:.
SELECT NOMBRE, APELLIDOS FROM PERSONAS WHERE CATEGORIA_ID = 3
O tambin:
SELECT NOMBRE, APELLIDOS FROM PERSONAS P, CATEGORIAS C
WHERE P.ID_CATEGORIA = C.ID AND C.CATEGORIA = 'Profesor'
En HQL, la cosa tendra esta pinta:

FROM Persona P WHERE P.categoria.id = 3
o bien:
FROM Persona P WHERE P.categoria.categoria = 'Profesor'
Fijmonos en la lectura puramente objetual. El primer ejemplo se podra leer as: Dame todas la
Personas de las cuales su propiedad categoria tenga una propiedad id con valor 3. Y el segundo:
Dame todas las Personas de las cuales su propiedad categoria tenga una propiedad categoria con
valor 'Profesor'.
El primer caso es sencillo. Hibernate puede obtener respuestas de la misma tabla PERSONAS buscando
aquellos registros con un valor 3 en la columna ID_CATEGORIA. Se correspondera con el primer ejemplo
de consulta SQL:
SELECT NOMBRE, APELLIDOS FROM PERSONAS WHERE CATEGORIA_ID = 3
El segundo es ms complicado ya que el valor Profesor no est en la tabla PERSONAS, sino en la tabla
CATEGORIAS. Hibernate tendr que utilizar la informacin que tiene sobre las relaciones entre ambas
tablas para obtener la informacin que le pedimos. Sin embargo, la formulacin de la consulta en HQL es
sencilla y clara- Esta consulta se correspondera con el segundo ejemplo de consulta SQL:
SELECT NOMBRE, APELLIDOS FROM PERSONAS P, CATEGORIAS C
Como podis ver, la formulacin de la misma consulta en SQL es bastante ms compleja.
UNA BODA AN MS COMPLICADA

Hasta ahora, hemos visto cmo casbamos un objeto con una tabla (el caso de
Categoria/CATEGORIAS) y un objeto con dos tablas (Persona/PERSONAS/CATEGORIAS). Son
casos tpicos de cualquier aplicacin y relativamente sencillos.
Pero muestro maridaje no acaba aqu. Hemos de casar el objeto Clase con el modelo relacional. Si
observamos nuestro modelo relacional, veremos que la tabla CLASE est relacionada con la tabla
NIVELES. Es una relacin idntica a la descrita para Persona/CATEGORIAS. Toda persona tiene una
categora laboral y toda clase tiene un nivel (Primero de EGB, Segundo de EGB, etc.). Hasta aqu, nada
nuevo, pero en nuestro modelo relacional aparece la tabla CLASE_PERSONAS que nos permite asociar
personas a una clase.
Figura 3: Relaciones de Clase_Personas
La siguiente figura ilustra las relaciones entre la tabla CLASE_PERSONAS y las tablas PERSONAS y
CLASE.
Observamos que la tabla CLASE_PERSONAS no aparece en nuestro modelo objetual. El objeto Clase
tiene las siguientes propiedades:
public class Clase {
/**
Identificador nico de la clase */
int
id;
/**
Nombre de la clase. Por ejemplo, "C" */

nombre;
String
/**
Nivel de la clase. Por ejemplo, "Octavo de EGB" */
Nivel
/**
nivel;
Conjunto de personas asociadas a la clase */
Set personas = new HashSet();
La relacin entre el objeto Clase y la tabla NIVELES se establece mediante la propiedad nivel. Y el
archivo de emparejamiento Clase.hbm.xml la describe as:
<class name="escuela.beans.Clase" table="clase">
[...]
<many-to-one name="nivel" column="ID_NIVEL"/>
Donde se indica que la propiedad nivel (que Hibernate sabe que es del tipo Nivel) se obtiene a partir del
identificador ID_NIVEL de la tabla CLASES.
La relacin entre Clase y CLASE_PERSONAS se establece mediante la propiedad personas, un
java.util.Set. El archivo de emparejamiento Clase.hbm.xml la describe as:
[...]
<set name="personas" table="CLASE_PERSONAS">
<key column="ID_CLASE"/>
<many-to-many class="escuela.beans.Persona" column="ID_PERSONA"/>
</set>
Donde se indica que:

o
Estamos describiendo la relacin entre la clase escuela.beans.Clase y la tabla CLASE:

La propiedad personas se relaciona con la tabla CLASE_PERSONAS:

La columna clave de la tabla CLASE_PERSONAS que se relaciona con la clave primaria del
objeto Clase es ID_CLASSE:
<key column="ID_CLASSE"/>
La propiedad personas tiene una relacin muchos-a-muchos con la columna

ID_PERSONA de la tabla CLASE_PERSONAS:
<many-to-many class="escuela.beans.Persona" column="ID_PERSONA"/>
La propiedad personas contiene objetos de tipo escuela.beans.Persona, con lo

cual, Hibernate tiene elementos suficientes para saber que ha de relacionar Persona.id
con la columna ID_PERSONA de la tabla CLASE_PERSONAS.
El siguiente fragmento de cdigo indica cmo se guardara un objeto de tipo Clase en la base de datos:
// [1] Obtenemos un Nivel de la base de datos (p.e. EGB1)
Nivel nivel = null;

nivel = (Nivel)unaSesion.load(Nivel.class, new Integer(1));
// [2] Obtenemos unas cuantas personas de la base de datos

Persona p1 = (Persona)unaSesion.load(Persona.class, new Integer(1));
// [3] Creamos una instancia de Clase

Clase clase = new Clase();
// [4] Le asignamos un nombre

clase.setNombre(A);
// [5] Le asignamos el nivel

clase.setNivel(nivel);
// [6] Le aadimos las personas

clase.getPersonas().add(p1);
// [7] Guardamos el objeto clase en la base de datos

Transaction tk = unaSesion.beginTransaction();
unaSesion.save(clase);
tk.commit();
unaSesion.close();
Los puntos del [1] al [5], son evidentes y han sido comentados ms arriba para otras clases.
El punto [6] muestra cmo se aade un objeto al Set que contiene la lista de personas asociadas a una
clase.
El punto [7] muestra cmo se realiza la persistencia de un objeto en la base de datos. Observamos que el
cdigo es el mismo para cualquier objeto. No hay diferencia con el que usbamos con la clase Categoria:
Ahora bien, Hibernate, en este caso, y basndose en el archivo de emparejamientos Clase.hbm.xml,

hace muchas ms cosas que en el caso de Categoria:
1. Inserta un nuevo registro en la tabla CLASE usando las propiedades id, nombre y
nivel.id del objeto Clase.
2. Inserta tres (3) nuevos registros en la tabla CLASE_PERSONAS asignando a todos ellos el
valor de la propiedad id del objeto clase para la columna ID_CLASE y a cada registro el
valor de la propiedad id de cada uno de los objetos de tipo Persona que contiene la
propiedad Personas del objeto clase.
El resultado es que la tabla CLASE tendra los siguientes registros:
ID = 0
NOMBRE = 'A'
ID_NIVEL = 1
y la tabla CLASE_PERSONAS tendra los siguientes tres nuevos registros:

ID_CLASE = 0
ID_PERSONA = 1
ID_CLASE = 0
ID_PERSONA = 2
ID_CLASE = 0
ID_PERSONA = 3
Y todo esto, con una sola operacin:

Hagmoslo ms prctico: el atributo cascade

En el ejemplo anterior de insercin de clases a la base de datos, observamos que en el punto [2] obtenemos
de la base de datos los objetos Persona que formarn parte de la Clase. As, estas personas existen
previamente en la base de datos.
Pero qu pasara si estas personas todava no estuvieran entradas en la base de datos? La respuesta ms
obvia es que no funcionara. Para que funcionara tendramos que:
1. Aadir cada una de las nuevas personas a la base de datos.
2. Aadir estas personas a nuestra instancia de Clase..
3. Guardar nuestra Clase en la base de datos.
Este mtodo es correcto, pero un poco pesado.
Hay una manera ms prctica que delega el trabajo a Hibernate. En el elemento
podemos aadir el atributo cascade para indicar que haga las operaciones en cascada. Este atributo puede
tener los siguientes valores:
o
o
o
o
save-update: para aplicarlo a las operaciones de insercin o de modificacin

delete: para aplicarlo a las operaciones de borrado
all: para aplicarlo a cualquier operacin
none: para que no se realice nunca ninguna operacin en cascada
En nuestro ejemplo, aplicaramos la opcin save-update:

<set name="personas" table="CLASE_PERSONAS" cascade="save-update">
As, nuestra operacin del punto [2] podra quedar as:

// [2] Creamos tres nuevas personas
Persona p1 = new Persona();
p1.setId(-1);
p1.setNombre(Nombre1);
p1.setApellidos(Apellidos1);
p2.setId(-1);
p3.setId(-1);
// [6] Aadamos las personas a la clase

// [7] Guardamos el objeto clase en la base de datos

Transaction tk = unaSesion.beginTransaction();
tk.commit();
unaSesion.close();
Al guardar la clase en la base de datos, Hibernate

1. Crea un registro para cada una de las tres nuevas personas en la tabla PERSONAS.
2. Aade un nuevo registro en la tabla CLASES.
3. Aade tres nuevos registros en la tabla CLASE_PERSONAS.
Fijmonos que hemos asignado un valor -1 a la propiedad id de cada una de las nuevas personas. ste es
el valor que hemos definido para el atributo unsaved value en el archivo de emparejamientos de la
clase Persona. Esto hace que Hibernate sepa que se trata de personas que an no estn en la base de datos
y, por consiguiente, las aade.
Lo mismo podramos hacer con la propiedad nivel del objeto Clase:
<many-to-one name="nivel" column="ID_NIVEL" cascade="save-update"/>
En este caso, si Hibernate encuentra un nivel con un id = -1, decide que primero lo tiene que aadir a la
tabla NIVELES y despus aadir la clase.
EL LENGUAJE DE INTERROGACIN DEL

MUNDO OBJETUAL: EL HQL
Esparcidos por los ejemplos, hemos visto casos de uso del lenguaje HQL. Estos casos de uso nos dan, a mi
entender, una idea de por dnde va el HQL, pero no son suficientes para entrever todas sus posibilidades.
En este captulo tratar de justificar la necesidad del HQL, de sistematizar un poco lo que hemos ido viendo
en captulos anteriores y mostrar algunos aspectos tiles de HQL que an no hemos visto.
Hay que decir, sin embargo, que este artculo slo es introductorio y que no pretende cubrir todas las
posibilidades del HQL. stas son tantas, que sera necesario otro artculo para describirlas.
Qu es el HQL y qu sentido tiene?

El HQL (Hibernate Query Language) es un lenguaje de interrogacin. En el mundo relacional disponemos
del SQL (Structured Query Language) que nos permite obtener informacin haciendo preguntas basadas en
las tablas y sus columnas. El equivalente en el mundo objetual es el HQL, que nos permite hacer preguntas
basadas en los objetos y sus propiedades.
Una vez ms, Hibernate se encarga de casar los dos mundos. Traduce las consultas que hacemos desde el
mundo objetual en HQL al lenguaje de interrogacin del mundo relacional, el SQL, y transforma los
resultados obtenidos en el mundo relacional (filas y columnas) en aquello que tiene sentido en el mundo
objetual: objetos.
El concepto de traduccin es importante para entender qu hace Hibernate y uno de los sentidos de HQL.
Hemos visto ms arriba la equivalencia entre una consulta SQL y una en HQL. As, la consulta
se podra traducir a
SELECT ID, NOMBRE, APELLIDOS FROM PERSONAS WHERE CATEGORIA_ID = 3
y la consulta
FROM Persona P WHERE P.categoria.categoria = 'Profesor'
se podra traducir a
SELECT ID, NOMBRE, APELLIDOS FROM PERSONAS P, CATEGORIAS C
Los ejemplos que acabamos de ver son sencillos y la traduccin tambin lo es. Fijmonos que se usa una
sintaxis SQL estndar. Pero si hemos tenido que trabajar con diversos gestores de bases de datos, habremos
observado que hay tantas sintaxis SQL como gestores. Es decir, cada gestor tiene su dialecto SQL propio.
En una aplicacin JDBC tradicional, si cambiamos el gestor de bases de datos y no hemos ido con cuidado
con las instrucciones SQL, nos podemos ver obligados a tener que adaptar las instrucciones SQL a las
peculiaridades del dialecto del nuevo gestor.
En una aplicacin con Hibernate, el problema desaparece. Slo hay que cambiar el dialecto el el archivo
hibernate.properties e Hibernate se encarga de traducir el HQL al dialecto SQL que toque.
Tenemos, pues, una relacin uno a muchos: lo escribimos una vez en HQL y lo podemos aplicar a muchos
gestores/dialectos distintos.
Intentemos (especulemos) describir los pasos que hace Hibernate para resolver una consulta sencilla como
esta:
1. Determina el dialecto SQL que estamos utilizando (en nuestro caso, HSQLDB) a partir de la
informacin contenida en el archivo hibernate.properties:
hibernate.dialect net.sf.hibernate.dialect.HSQLDialect
2. Traduce nuestra consulta al dialecto SQL que toque:

SELECT ID, NOMBRE, APELLIDOS FROM PERSONAS WHERE CATEGORIA_ID = 3
3. Ejecuta la consulta va JDBC y obtiene un ResultSet:

3, 'Jaume', 'Figueres Audal'
4. Construye un objeto de tipo Persona a partir de los elementos del ResultSet:

Persona persona = new Persona();
persona.setId(3);
persona.setNombre(Jaume);
persona.setApellidos(Figueres Audal);
5. Devuelve el objeto Persona creado a partir del ResultSet.
Un intento de sistematizacin del HQL

Esto suena a una descripcin minuciosa y exhaustiva de la sintaxis HQL utilizando la ltima, definitiva e
incomprensible notacin formal. Pues no. Slo quiero sistematizar un poco una parte de la casustica.
Basmosnos en dos situaciones tpicas de interrogacin:
1. Conocemos el ID
2. No conocemos el ID (o queremos hacer preguntas complejas)
Para cada una de las situaciones, Hibernate proporciona mtodos o objetos y mtodos distintos. La siguiente
tabla los resume y, a continuacin, los comentamos:
Situacin
Conocemos el ID
Solucin Hibernate
Session.load()
Situacin
No conocemos el
ID
Solucin Hibernate
Session.find(), Session.iterate(), Query
Conocemos el ID: Session.load()

A lo largo del artculo, hemos visto diversos ejemplos de utilizacin de load(). En todos los ejemplos,
hemos usado la misma sintaxis de load():
Session.load(Classe.class, id)
Por ejemplo:
Categoria unaCategoria = (Categoria)sesion.load(Categoria.class,
new Integer(3));
Pero el mtodo load() tiene ms posibilidades que nos pueden resultar cmodas. Por ejemplo,
Session.load(unObjeto, id);
En este caso, el objeto con el id indicado se cargar en unObjeto:

Categoria unaCategoria = new Categoria();
sesion.load(unaCategoria, new Integer(3));
No conocemos el ID: preguntas complejas

Si bien es cierto que la carga de un objeto a partir de su identificador nico es una operacin bastante
frecuente en cualquier aplicacin, no deja de ser un caso simple.
Si disponemos de un potente lenguaje de interrogacin es para poder hacer preguntas complejas. El lenguaje
SQL nos permite hacer preguntas muy, muy complejas, y su equivalente en el mundo objetual, el HQL,
tambin.
No quiero describir aqu detalladamente la sintaxis HQL. Intentar ejemplificar un abanico razonable de la
casustica e invito al lector a que consulte el excelente manual de referencia de Hibernate.
Es necesario separar desde un principio lo que es el lenguaje de interrogacin (HQL) de los mtodos que
Hibernate nos proporciona para ejecutar la pregunta expresada en este lenguaje.
As, la consulta
String consulta = FROM Categorias C WHERE C.categoria LIKE 'A%';
se puede ejecutar de diversas maneras:

/* 1 */ List categorias = sesion.find(consulta);
/* 2 */ Iterator iterador = sesion.iterate(consulta);
/* 3 */ Query q = sesion.createQuery(consulta);
List categs = q.list();
Fijmonos que en los tres casos estamos ejecutando la misma consulta.
En primer lugar, nos centraremos en el lenguaje de interrogacin HQL y despus hablaremos de los diversos
mtodos que Hibernate nos ofrece para ejecutar las consultas.
A lo largo del artculo, hemos visto diversos ejemplos de HQL. Normalmente, han sido consultas simples
que no ilustran todas las posibilidades del lenguaje de interrogacin. Vamos a plantear algunas que muestren
algunas posibilidades ms del HQL.
Funciones escalares
HQL nos permite usar funciones escalares en nuestras consultas. As, por ejemplo, podemos contar el
nmero de personas de la escuela:
SELECT COUNT(*) FROM Persona
En nuestro ejemplo, no tenemos ms nmeros que los id de las clases, as que no puedo poner ejemplos
demasiado interesantes ni prcticos de las funciones escalares, pero a guisa de ejemplo, podemos obtener la
media de los id de Persona:
SELECT AVG(P.id) FROM Persona P
Tambin los podemos sumar:

SELECT SUM(P.id) FROM Persona P
O obtener los valores mximo y mnimo:

SELECT MAX(P.id), MIN(P.id) FROM Persona P
Listado de colecciones
Listar los niveles de las diferentes Clases es sencillo:
SELECT C.nivel FROM Clase C
Si Nivel dispone de un mtodo toString(), podemos obtener un resultado similar a ste, haciendo un
System.out.println() de los objetos Nivel retornados por la consulta:
0 EGB1
Tambin es fcil obtener la lista de clases:

FROM Clase
En este caso, y suponiendo tambin que Clase y Persona disponen de los toString() pertinentes,
obtendramos un resultado similar a ste:
1 0 EGB1 B
34 Prez Abril, Vernica 10 Alumno(-a)
38 Rosales Ribas, Nria 10 Alumno(-a)
9 Deulofeu Gai, Rosana 9 Profesor(-a)
13 Rosales Ribas, Francesc 9 Profesor(-a)
Ahora bien, nos puede interesar listar todas las personas de una clase. Es decir, la coleccin de personas que
pertenecen a una clase. Fijmonos que Clase tiene una propiedad personas que es un Set. Para obtener
la lista de personas, tendremos que utilizar la funcin elements().
SELECT elements(C.personas) FROM Clase C
Esto nos listara todas las personas de las clases:

34 Prez Abril, Vernica 10 Alumno(-a)
38 Rosales Ribas, Nria 10 Alumno(-a)
9 Deulofeu Gai, Rosana 9 Profesor(-a)
13 Rosales Ribas, Francesc 9 Profesor(-a)
Contar Colecciones: size

Imaginmonos que nos interesa saber qu clases tienen ms de 20 personas relacionadas. Hibernate nos
ofrece la posibilidad de contar colecciones mediante una propiedad especial, size, o una funcin especial,
size(). As, podremos formular nuestra pregunta de dos maneras distintas:
FROM Clase C WHERE C.personas.size > 20
o bien
FROM Clase C WHERE size(C.personas) > 20
La clusula Group By
Esta clusula tiene el mismo sentido que en SQL, as que no nos entretendremos demasiado. Un ejemplo
sencillo que nos cuente el nmero de personas por clase nos puede servir:
SELECT C.nivel, C.nombre, count(elements(C.personas))
FROM Clase C
GROUP BY C
Ejecucin de consultas
Existen diversos mtodos para ejecutar consultas. Hasta ahora, todas las que hemos visto en los ejemplos
utilizaban el mtodo Session.load(), si la bsqueda se haca a partir del id, o Session.find(), si
ejecutbamos una consulta compleja expresada en HQL. Hay, sin embargo, ms maneras de ejecutar una
consulta.
En este captulo, veremos algunos de estos mtodos y cmo se pueden pasar parmetros a una consulta.
El mtodo Session.find()
Este mtodo, lo hemos visto ya en la mayor parte de los ejemplos. Nos devuelve el resultado de la consulta
en una java.util.List. Es bastante prctico si se devuelven pocos resultados, ya que los tiene que
mantener en memoria:
List personas = sesion.find(FROM Persona P WHERE P.nombre = 'Berta');
Ciertamente, Berta no es un nombre demasiado comn y nos devolver pocos resultados.
El mtodo Session.iterate()
Este mtodo nos devuelve un java.util.Iterator y es prctico si la consulta nos proporciona un
gran nmero de resultados.
El iterador se encarga de cargar los objetos resultantes de la consulta uno a uno, a media que los vamos
pidiendo:
Iterator iterador = sesion.iterate(FROM Personas AS P
ORDER BY P.apellidos, P.nombre);
while (iterador.hasNext()) {
// Obtiene el objeto
Persona unaPersona = (Persona)iterador.next();
// Alguna cosa no expresable en la consulta

if (algoritmoComplicado(unaPersona)) {
// Borramos la instancia actual
iterador.remove();
// No hace falta que sigamos
break;
}
}
La interficie Query
La interficie Session, como hemos visto, dispone de tres mtodos de ejecucin de consulta: load(),
find() e iterate().
La interficie Query tambin nos permite ejecutar consultas pero aporta algunas ventajas:
1. Podemos especificar el nmero mximo de registros que queremos que se nos devuelvan
2. Podemos especificar el primer registro que queremos obtener
3. Permite el uso de parmetros con nombre
Aqu tenemos un ejemplo:
Query q = sesion.createQuery(FROM Persona AS P);
q.setFirstResult(5);
q.setMaxResults(20);
List personas = q.list();
Parmetros posicionales
Todas las consultas que hemos visto hasta ahora eran fijas; es decir, sabamos todo lo que necesitbamos
para hacer la consulta. Por ejemplo:
List personas = sesion.find(FROM Persona P WHERE P.nombre = 'Jaume');
Buscamos aquellas personas que se llaman 'Jaume'.
Pero, a veces, nos puede interesar pasar el nombre como un parmetro. Por ejemplo, si tenemos la consulta
ya definida y la ejecutamos diversas veces variando el nombre que buscamos.
El mtodo Session.find() nos permite especificar parmetros:
String consulta = FROM Persona P WHERE P.nombre = ?;
List personas = sesion.find(consulta, unNombre, Hibernate.STRING);
[...]
List personas = sesion.find(consulta, otroNombre, Hibernate.STRING);
Fijmonos que en las dos ejecuciones de find() usamos el mismo enunciado de la consulta, pero en el
primer caso preguntamos por unNombre y en el segundo por otroNombre.
En el enunciado de la consulta, usamos un parmetro por posicin, igual que lo haramos en JDBC, usando
un signo de interrogacin.
El ejemplo que hemos puesto es sencillo porque slo tiene un parmetro. El mtodo find() nos permite
especificar el valor de este parmetro (unNombre, otroNombre) y nos obliga a especificar el tipo
Hibernate del parmetro (Hibernate.STRING). La clase Hibernate define constantes estticas que
nos permiten acceder a instancias de net.sf.hibernate.type.Type, lo cual nos facilita la vida.
Si la consulta tuviera ms de un parmetro, tendramos que especificar los valores y los tipos mediante
matrices de valores y de tipos:
String cons = FROM Persona P WHERE P.nombre = ? AND P.apellidos LIKE ?
List personas = Sesion.list(cons,
new Object[] {Jaume, R%},
new Type[] {Hibernate.STRING,
Hibernate.STRING});
Parmetros con nombre

Todos los que hemos trabajado con JDBC sabemos qu quiere decir tener que contar interrogantes en una
consulta con 25 parmetros: acertar a la quinta.
La interficie Query nos permite especificar parmetros con nombre, adems de los posicionales. Esto tiene
varias ventajas:
o
o
o
o
El orden en que aparezcan dentro de la tira de la consulta es indiferente

Un mismo parmetro puede aparecer diversas veces en la misma consulta
Si el gestor de bases de datos soporta Scrollable Result Sets, nos permite movernos arriba y
abajo por los resultados de la consulta
Son autoexplicativos
Para especificar un parmetro con nombre, slo hay que poner dos puntos (:) seguidos del nombre del
parmetro:
// Parmetro con nombre (preferido)
Query q = sesion.createQuery(FROM CATEGORIAS C +
WHERE C.categoria = :nombreCategoria;
q.setString(nombreCategoria, Profesor);
Iterator categorias = q.find();
// Parmetro posicional
WHERE C.categoria = ?;
q.setString(0, Profesor);
Iterator categorias = q.find();
Tambin podemos pasar una lista de parmetros con nombre:

List nombresCateg = new ArrayList();
nombresCateg.add(Profesor);
nombresCateg.add(Alumno);

WHERE C.categoria IN (:listaNombresCateg);
q.setParameterList(listaNombresCateg, nombresCateg);
En este caso, estamos buscando todas las categoras cuyos nombres (C.categoria) estn en la lista de
nombres nombresCateg.
Iterar arriba y abajo

Si el driver JDBC de nuestro gestor de bases de datos soporta Scrollable ResultSets, podemos usar la
interficie Query para obtener una instancia de ScrollableResults que nos permitir disfrutar de las
ventajas de los Scrollable ResultSets.
El siguiente ejemplo muestra cmo obtener una lista de las personas de la escuela ordenada por apellidos y
nombre y ver cules son las que apareceran primero en cada una de las pginas del listado.
// Nmero de personas que caben en una pgina de listado
int PERSONAS_POR_PAGINA = 20;
String sel = SELECT P.nombre, P.apellidos, P +
FROM Persona P +
ORDER BY P.apellidos, P.nombre;
Query q = sesion.createQuery(sel);
ScrollableResults personas = q.scroll();
if (personas.first()) {
// Encontramos el primer nombre que aparece en cada una de las
// pginas del listado de personas
Vector primerosNombresDePagina = new Vector();
do {
String nombre = personas.getString(0);
String apellidos = personas.getString(1);
primerosNombresDePagina.addElement(apellidos + , + nombre);
} while (personas.scroll(PERSONAS_POR_PAGINA));
// Ahora obtenemos la primera pgina del listado de personas
Vector paginaPersonas = new Vector();
personas.beforeFirst();
int i = 0;
while ((PERSONAS_POR_PAGINA > i++ ) && personas.next()) {
paginaPersonas.addElement(personas.get(2));
}
}
El comportamiento del mtodo scroll() es similar al del mtodo iterate() que hemos visto mas
arriba excepto por el hecho que los objetos se pueden inicializar selectivamente con get(int) en vez de
inicializar un registro entero cada vez como hace iterate().
Lectura de resultados
Hemos visto ya cmo escribir consultas en HQL y cmo ejecutarlas, pero an no hemos visto cmo leer los
resultados de la ejecucin de la consulta. Vemoslo.
En algunos de los ejemplos que hemos visto, ya leamos resultados. Es el caso de aqullos que utilizan el
mtodo load(), ya que este mtodo siempre devuelve un solo objeto:
Persona p = sesion.load(Persona.class, new Integer(1));
Tambin hemos visto aquellos casos de find() que nos devuelven una java.util.List con la lista de
objetos resultante, todos del mismo tipo:
List personas = sesion.find(FROM Persona P WHERE p.nombre LIKE 'A%');
Los objetos resultantes estn el la List personas. Slo hay que recorrer la lista para acceder a ellos.
A veces, sin embargo, la consulta nos devuelve diversos objetos de diversos tipos. Por ejemplo, la consulta
SELECT C.nivel , C.nombre, count(elements(C.personas))
FROM Clase C
GROUP BY C
nos devolvera un objeto de tipo Nivel, otro de tipo String y un Integer. Podramos leer los
resultados de la consulta usando el mtodo iterate():
String consulta = SELECT C.nivel , C.nombre, +
count(elements(C.personas)) +
FROM Clase C +
GROUP BY C;
Iterator i = sesion.iterate(consulta);
while (i.hasNext()) {
Object[] registro = (Object[])i.next();
Nivell nivel = (Nivell)registro[0];
String nombre = (String)registro[1];
Integer personas = (Integer)registro[2];
}
Como podemos ver, el iterador nos devuelve un registro por iteracin y este registro es una matriz de
objetos: uno por cada una de las columnas de la tabla de resultados. Slo tenemos que hacer la conversin al
tipo esperado (Nivel, String e Integer en nuestro ejemplo) y ya tendramos los resultados.
QU UTILIZO?
En este artculo, he utilizado la versin 2.1.6 de Hibernate10 (la ltima estable a fecha de hoy11) y como
gestor de bases de datos, HSQLDB versin 1.7.212; un magnfico y completo gestor de bases de datos
escrito en Java. Hay que remarcar que tanto Hibernate como HSQLDB son productos de cdigo abierto.
He utilizado como entorno de desarrollo Java Eclipse versin 3.0.1. Este entorno de desarrollo es
completamente gratuito y, como Hibernate y HSQLDB, de cdigo abierto. A mi entender, por el momento,
es el mejor entorno de desarrollo para Java. Y, por supuesto, el que tiene mejor relacin calidad-precio.
Para los diagramas UML, he utilizado un plugin de Eclipse llamado Eclipse UML plugin, de OMONDO.
Una buena herramienta de modelado con dos versiones: una de pago y otra gratuita. Yo, obviamente, uso la
gratuita.
Para los diagramas de relaciones, he usado la versin 1.05, gratuita, del magnfico plugin de Eclipse Clay
Database Modelling (http://www.azzurri.jp/en/software/clay/index.jsp), de Azzurri Ltd. Un plugin de
Eclipse, para m, imprescindible que combina una herramienta grfica de diseo de modelos de bases de
datos con la posibilidad de crear modelos de bases de datos ya existentes mediante ingeniera inversa.
Dispone de una versin gratuita, que slo trabaja con gestores de bases de datos de cdigo abierto
(HSQLDB, MySQL, PostgreSQL, Firebird, SAP DB, McKoi y ANSI SQL-92) y otra de pago con ms
funcionalidades que ha dejado de estar disponible fuera de Japn.
Para generar los archivos bsicos de emparejamientos, he usado el plugin de Eclipse Hibernator. versin
0.9.6. Es interesante, pero le faltan algunas cosas. Entre otras, documentacin.13
Para probar las consultas, he usado Hibern8IDE (http://www.xam.dk/hibern8ide).Una interficie grfica que
nos ayuda a hacer prototipos de las consultas. Tambin Hibernator proporciona una interficie para probar
consultas pero me parece menos potente, Hibern8IDE e Hibernator comparten una carencia: la
documentacin. Una vez bien configurado, Hibern8IDE es una herramienta auxiliar excelente.
QU HAY QUE LEER?

Esta introduccin a Hibernate no habra sido posible sin la excelente documentacin oficial de Hibernate14
ni sin los artculos que terceras personas han escrito sobre el tema. El propio equipo de Hibernate
proporciona una lista15 muy interesante.
Mi consejo es que se empiece por los artculos introductorios antes que adentrarse en la documentacin
oficial de referencia.16
QU NO HE EXPLICADO?
No he explicado un montn de cosas interesantes que se pueden hacer con Hibernate. No he hablado de la
posibilidad de utilizar XDoclet con Hibernate, ni de cmo podemos especificar consultas con nombre en los
archivos de emparejamiento, ni de las herramientas de generacin de cdigo como Middlegen
(http://boss.bekk.no/boss/middlegen/index.html) o las que vienen con Hibernate. Tampoco he profundizado
en el HQL ni en los detalles de los archivos de configuracin y de emparejamiento.
Me he limitado a los casos ms sencillos y habituales y no he hablado nada de colecciones ni de filtros. He
obviado claramente los temas relacionados con el rendimiento y las capacidades de optimizacin de
Hibernate.
En fin, la sensacin que tengo es que he explicado un montn de cosas pero que hay muchas ms que se han
quedado en el tintero.
Me dara por satisfecho si este artculo motivara al lector a introducirse en el mundo de la persistencia
objetual y en el entorno de Hibernate.
APNDICE A: APLICACIN DE EJEMPLO

Para ilustrar los contenidos de este artculo, he desarrollado una pequea aplicacin de ejemplo
implementando la versin 1.7.2 de HSQLDB.17
La aplicacin de ejemplo ha sido desarrollada con Eclipse 3.0.1, que se puede descargar desde
http://www.eclipse.org/downloads/index.php, aunque no es obligatorio descargarlo.
Para la creacin de la base de datos, me remito al manual de HSQLDB. El archivo de configuracin de
Hibernate del ejemplo supone que el gestor de bases de datos est arrancado en modo servidor. Para acceder
a la base de datos en otra modalidad, de deber modificar la URL especificada en el archivo
hibernate.properties.
Tambin se deber modificar hibernate.properties si el lector opta por utilizar MySQL18.
APNDICE B: INSTALACIN
He decidido empaquetar este artculo y el cdigo fuente de ejemplo en un archivo ZIP
(HIBERNATE_INTRODUCCION.ZIP) para facilitar su instalacin.
Al descomprimir el archivo ZIP se crear un direcorio raz, INTRODUCCION_HIBERNATE y una serie de
subdirectorios que contienen este artculo, instrucciones para la ejecucin de la aplicacin de ejemplo
(archivo LEEME.txt), los archivos de configuracin y de emparejamiento y el cdigo fuente de la
aplicacin de ejemplo.
Si se desea usar MySQL en vez de HSQLDB, se deber crear una nueva base de datos en MySQL y ejecutar
el archivo de DDL ESCUELA_MYSQL.sql que se encuentra en el subdirectorio Databases. Tambin se
deber modificar el archivo de parmetros de Hibernate, hibernate.properties, y el archivo
RUNAPP.BAT.
1El presente artculo es una traduccin del original en cataln escrito durante el mes de septiembre de
2003.
2Para simplificar, obvio el control de excepciones.
3Los interesados en el nuevo gestor Apache Derby, pueden encontrar la implementacin de su dialecto,
basada en IBM DB2, en Hibernate JIRA: http://opensource.atlassian.com/projects/hibernate/browse/HB1224. Obsrvese que no es una implementacin definitiva, pero a m me funciona.
4Hibernate utiliza los siguientes tipos:
integer, long, short, float, double, character, byte
boolean, yes_no, true_false: alternativas para boolean o java.lang.Boolean.
string: empareja java.lang.String y VARCHAR.
date, time, timestamp: empareja java.util.Date y sus subclases con los tipos SQL
DATE, TIME y TIMESTAMP (o equivalente).
calendar, calendar_date: emparejan java.util.Calendar con SQL TIMESTAMP y DATE.
big_decimal: empareja java.math.BigDecimal con NUMERIC (o NUMBER de Oracle).
locale, timezone, currency: empareja java.util.Locale, java.util.TimeZone y

java.util.Currency con VARCHAR (o VARCHAR2 de Oracle)
class: empareja java.lang.Class con VARCHAR (o VARCHAR2 de Oracle)
binary: empareja matrices (arrays) de bytes con un tipo SQL binario adecuado
serializable: empareja tipos Java serializables con un tipo SQL binario adecuado
clob, blob: emparejamientos para las clases JDBC java.sql.Clob y java.sql.Blob
5Tambin las soportan los siguientes gestores: DB2, MySQL, MS SQL Server y Sybase.
6La documentacin de Hibernate comenta extensamente cada uno de los mtodos de generacin de valores
para claves primarias.
7El mtodo sequence usa una sequence en DB2, PostgreSQL, Oracle, SAP DB, McKoi o Interbase. El
mtodo hilo necesita una tabla auxiliar para generar las claves.
8Podramos no usar unidades de trabajo, pero creo que siempre es interesante su uso. Si no nos interesase
usarlas, el cdigo sera parecido a ste:
session.flush();
session.close();
9En nuestro modelo relacional de ejemplo, la tabla CLASES tambin presenta una relacin del tipo muchos
a uno para el campo ID_NIVEL, que apunta al campo ID de la tabla NIVELES.
10http://www.hibernate.org
113 de noviembre de 2004.
12http://hsqldb.sourceforge.net/
13En el momento de cerrar esta revisin del artculo, yo reemplazara Hibernator por el magnfico plugin de
Eclipse Hibernate Synchronizer (http://www.binamics.com/hibernatesync/) de Joe Hudson. El tutorial de
James Elliot Working with Hibernate in Eclipse
(http://www.onjava.com/pub/a/onjava/2004/06/23/hibernate.html) es una buena ayuda para empezar a
utilizar este plugin.
14http://www.hibernate.org/5.html
15http://www.hibernate.org/78.html
16Despus de escribir este artculo, apareci en el mercado el excelente libro Hibernate in Action de
Christian Bauer y Gavin King. A mi entender, lo mejor que se ha escrito sobre Hibernate. Es un libro claro,
completo y til de lectura casi obligatorioria para cualquiera que se quiera adentrar en los entresijos de
Hibernate.
17La versin 1.7.2 de HSQLDB se puede descargar de http://sourceforge.net/projects/hsqldb/.
18Visitar http://www.mysql.com.

Manual Hibernate

Cargado por

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Manual Hibernate

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual Hibernate

Cargado por

Copyright:

Formatos disponibles

Introduccrin a Hibernate

23/12/2004 00:00 Francesc Ros

El siguiente grfico muestra las relaciones entre tablas:

Figura 1: Modelo Relacional

Figura 2: Modelo Objetual

Observemos algunos cambios en nuestro diagrama de clases:

Con Hibernate, escribiramos algo similar a esto:

Y si nos interesase aadir otra:

Clase del dialecto

Oracle (cualquier versin)

Clase del dialecto

Microsoft SQL Server

Tabla 1: Dialectos SQL soportados

QU HAY QUE PRESENTAR PARA

Qu ha de saber Hibernate para casar los dos modelos?

Una boda sencilla

Hibernate.properties: En el que se dice qu gestor de bases de datos usaremos y a qu base

A continuacin, los describiremos con ms detalle.

El archivo de propiedades de Hibernate: Hibernate.properties

El archivo de emparejamiento (mapping): Categoria.hbm.xml

<property name="categoria" column="CATEGORIA"

Como vemos, para definir los emparejamientos se usa un documento XML.

Indicamos el nombre de la clase (name=escuela.beans.Categoria) y el nombre de la tabla con la

Aqu tenemos el emparejamiento propuesto para la propiedad categoria de nuestro ejemplo.

Clases persistentes Java Beans

Devuelve el contenido de la propiedad <code>categoria</code>.

void setCategoria(String nuevaCategoria) {

Altas, bajas, modificaciones (ABM) y consultas

2. SessionFactory: es una fbrica de Sessions. Un objeto Configuration es capaz de

4. Transaction: Como su nombre indica, se encarga de la transaccionalidad. Permite definir

Un posible patrn de aplicacin

// [1.2] Aqu lee el archivo de emparejamientos Categoria.hbm.xml

El archivo hibernate.properties tiene que estar en

[1.2] Una vez creada la instancia de Configuration, le pasamos la informacin sobre el

[3] Una vez tenemos la fbrica, ya podemos crear Sessions:

// [2] Creamos una Session

[4] Guardamos categoria en la base de datos.

String sel = FROM Categoria AS C WHERE C.categoria LIKE %r%;

No hay SELECT ya que no devuelve valores de columnas, sino objetos.

// Lo modificamos en la base de datos

// Lo modificamos o lo aadimos a la base de datos dependiendo del

UNA BODA MS COMPLICADA

Categora laboral de la persona */

<class name="escuela.beans.Persona" table="personas">

// [2] Creamos una Persona

// [3] Iniciamos una unidad de trabajo

// [4] Guardamos el objeto Persona en la base de datos

// [5] Cerramos la unidad de trabajo

En HQL, la cosa tendra esta pinta:

Como podis ver, la formulacin de la misma consulta en SQL es bastante ms compleja.

UNA BODA AN MS COMPLICADA

Figura 3: Relaciones de Clase_Personas

Identificador nico de la clase */

Nombre de la clase. Por ejemplo, "C" */

Nivel de la clase. Por ejemplo, "Octavo de EGB" */

Conjunto de personas asociadas a la clase */

Set personas = new HashSet();

Donde se indica que: