-
7/16/2019 Hibernate
1/90
HIBERNATE
-
7/16/2019 Hibernate
2/90
[2]
HIBERNATE
NDICE
1 INTRODUCCIN .................................................................................................................... 31.1 Object-Relational Mapping.......................................................................................... 3
1.2 Hibernate y MVC en entornos web ............................................................................. 5
2 MI PRIMERA APLICACIN CON HIBERNATE ......................................................................... 7
2.1 Pasos para crear una aplicacin Hibernate ................................................................. 7
2.2 Desarrollo paso a paso................................................................................................. 8
3 FRAMEWORK HIBERNATE .................................................................................................. 38
3.1 Introduccin............................................................................................................... 38
3.2 Instalacin..................................................................................................................39
3.3 Configuracin.............................................................................................................39
3.4 El interfaz Session ...................................................................................................... 58
4 ASOCIACIONES.................................................................................................................... 62
4.1 Relaciones en Bases de datos .................................................................................... 63
4.2 Many-to-one..............................................................................................................65
4.3 Many-to-many ...........................................................................................................67
4.4 One-to-one................................................................................................................. 69
5 RECUPERACIN DE DATOS ................................................................................................. 71
5.1 HQL ............................................................................................................................73
5.2 Criteria .......................................................................................................................83
5.3 SQL .............................................................................................................................89
-
7/16/2019 Hibernate
3/90
[3]
HIBERNATE
1. INTRODUCCIN
1.1.OBJECT-RELATIONAL MAPPING
Hibernate es una implementacin de mapeo Objeto-Relacional (ORM Object-Relational
Mapping). El objetivo de un ORM es hacer corresponder el modelo de datos de la aplicacin
con el modelo de clases de la misma, los cuales no son tan distintos como se pueda pensar.
Para ello, Hibernate realiza el mapeo de elementos (tablas, columnas) entre una Base de datos
relacional y objetos de la aplicacin en cuestin:
Base de Datos Relacional
Juan
Ana
Francisco
Beln
Lpez
Hurtado
Soria
Jimnez
666111122
959121212
889121212
789456123
Nombre Apellido Telfono
TABLA Persona
Persona
-String nombre-String apellido
-String telfono
Modelo de Objetos
instance: Persona
nombre = Juan
apellido = Lpez
telfono = 666111122
-
7/16/2019 Hibernate
4/90
[4]
HIBERNATE
Este tipo de sistema facilita todas las operaciones de persistencia y acceso a los datos desde la
aplicacin al presentar las siguientes caractersticas principales:
Independiente de SQL: Hibernate incorpora funcionalidades para las operacionessimples de recuperacin y actualizacin de datos para las cuales no ser necesario
utilizar las sentencias SELECT, INSERT, UPDATE o DELETE habituales, siendo sustituidas
por llamadas a mtodos (list, save, update, delete, ). Hibernate se encarga de
generar la sentencia SQL que se encargar de realizar tales operaciones. De cualquier
modo, se pueden especificar consultas SQL en caso necesario o incluso consultas en el
dialecto de Hibernate, el HQL, con sintaxis similar a SQL pero que establece una serie
de elementos propios del sistema ORM que gestiona.
Independiente del SGBD: al aislar las funciones de manipulacin de datos del lenguajeSQL, se consigue que la aplicacin pueda comunicarse con cualquier SGBD ya que no
existirn dependencias o particularidades en las sentencias de consulta o actualizacin
de datos que haran a la aplicacin dependiente de un SGBD en cuestin. El encargado
de realizar la traduccin final entre las operaciones Objeto-relacionales y las
sentencias SQL es Hibernate, con lo cual el problema de la compatibilidad queda
solventado. Incorpora soporte para la mayora de los sistemas de bases de datos
existentes.
Independiente de JDBC: Hibernate contiene una API completa que asla a la aplicacin,no solamente de las operaciones con lenguaje SQL, sino tambin la utilizacin de
objetos propios de la gestin de Bases de datos JDBC (Statement, ResultSet, ). Este
tipo de objetos habituales en la programacin Java de acceso a Bases de datos, se
sustituye por el uso de objetos mucho ms sencillos como colecciones de clases tipo
JavaBeans que contendrn los datos de los almacenes de datos.
-
7/16/2019 Hibernate
5/90
[5]
HIBERNATE
1.2.HIBERNATE Y MVC EN ENTORNOS WEB
En una arquitectura MVC genrica como la siguiente, Hibernate juega un papel primordial
como capa de persistencia de la aplicacin. Como aparece en el esquema, los JavaBeans
encargados de ejecutar la lgica de la aplicacin interacturn con datos habitualmente
almacenados en una Base de datos. Hibernate se introduce en este contexto para dar soporte
de acceso y gestin de los datos a la capa de Modelo.
El patrn MVC se utiliza de forma amplia en el desarrollo de aplicaciones web.
Fuente: http://java.sun.com/blueprints/patterns/MVC-detailed.html
-
7/16/2019 Hibernate
6/90
[6]
HIBERNATE
Controller (Controlador):
Servlet central que recibe las peticiones, procesa la URL recibida y delega elprocesamiento a los JavaBeans.
Servlet que almacena el resultado del procesamiento realizado por los JavaBeans en elcontexto de la peticin, la sesin o la aplicacin.
Servlet que transfiere el control a un JSP que lleva a cabo la presentacin deresultados.
Model (Modelo):
JavaBeans (o EJBs para aplicaciones ms escalables) que desempean el rol de modelo: Algunos beans ejecutan lgica. Otros guardan datos.
Normalmente: El Servlet Controller invoca un mtodo en un bean de lgica y ste devuelve un
bean de datos.
El programador del JSP tiene acceso a beans de datos.
View (Vista):
Rol ejecutado por JSPs. El Servlet Controller transfiere el control al JSP despus de guardar en un contexto el
resultado en forma de un bean de datos.
JSP usajsp:useBean yjsp:getProperty para recuperar datos y formatear respuesta enHTML o XML.
En resumen:
Los JavaBeans o EJBs ejecutan la lgica de negocio y guardan los resultados. Los JSPs proporcionan la informacin formateada. Los servlets coordinan/controlan la ejecucin de los beans y los JSPs.
-
7/16/2019 Hibernate
7/90
[7]
HIBERNATE
2. MI PRIMERA APLICACIN CON HIBERNATE
Esta parte del manual es una gua paso a paso para realizar una aplicacin sencilla, es tal vez la
mejor manera de introducirse con Hibernate y es recomendable realizarla antes de leer el
resto del manual ya que mejorar la comprensin de ste.
Esta aplicacin ser desarrollada haciendo uso del IDE Netbeans 6.7. Se puede descargar de
http://netbeans.org/.
2.2.PASOS PARA CREAR UNA APLICACIN HIBERNATE
Estos son los pasos mnimos que se debern seguir para desarrollar la aplicacin
satisfactoriamente.
1. Determinar el modelo de datos de la aplicacin.2. Aadir las libreras Java de Hibernate.3. Definir las clases de persistencia.4. Crear los ficheros de mapeo.5. Configurar Hibernate.6. Crear clases de ayuda.7. Cargar y guardar objetos.8. Ejecutar la primera versin.9. Asociar clases.10.Ejecutar la aplicacin.
-
7/16/2019 Hibernate
8/90
[8]
HIBERNATE
2.3.DESARROLLO PASO A PASO
1. Determinar el modelo de datos de la aplicacin.Este ejemplo se trata de una sencilla introduccin donde nicamente se dispone de
dos clases Event y Person tanto en la base de datos del sistema como en el modelo de
objetos de la aplicacin. Tambin se usarn clases auxiliares para la gestin del acceso
y operaciones con los datos.
En primer lugar, es necesario crear la Base de datos en MySQL. Su nombre ser
FirstApp pero no se van a crear tablas en la misma ya que se configurar una opcin en
el fichero de configuracin de Hibernate (hibernate.cfg.xml) para que genere el
esquema de la Base de datos al desplegar la aplicacin.
Como se ha comentado, la aplicacin se crear a travs de Netbeans. Este entorno de
desarrollo dispone de herramientas para la configuracin del acceso a la Base de
datos.
En primer lugar es posible que sea necesario configurar el driver de la base de datos
que se va a utilizar en la aplicacin, en este caso MySQL. Para ello es necesario
seleccionar la opcin New Connection del men del botn derecho del ratn sobre la
opcin Drivers.
A continuacin se selecciona el fichero .jar que contiene el driver de MySQL y se dejanel resto de campos con los valores que aparecen al seleccionarlo. Todo lo relacionado
-
7/16/2019 Hibernate
9/90
[9]
HIBERNATE
con la gestin de Drivers NO es propio de Hibernate, se est configurando el entorno
de Netbeans para la utilizacin de los Asistentes existentes.
Ahora hay que crear la conexin desde la pestaa Services seleccionando la opcin
New Connection del men del botn derecho del ratn sobre la opcin Databases.
-
7/16/2019 Hibernate
10/90
[10]
HIBERNATE
Los datos que se completan son los correspondientes a la conexin con la base de
datos que se encuentra en el servidor MySQL.
2. Aadir las libreras Java de Hibernate.Netbeans dispone de un asistente para la creacin de aplicaciones Web donde se
puede indicar que la aplicacin emplear Hibernate. De esta forma, Netbeans realiza
una serie de acciones de forma automtica que ayudarn al desarrollo mediante este
Framework.
Se deber crear un nuevo proyecto web con Netbeans, para ello dirigirse al men: File New Project Web Web Application. No se debe olvidar aadir el Framework,
como muestran las imgenes siguientes.
-
7/16/2019 Hibernate
11/90
[11]
HIBERNATE
Al crear el proyecto, Netbeans crea un fichero hibernate.cfg con los valores para conectar
con la Base de datos que se ha establecido al crear el proyecto. Dicho archivo se encuentraen la carpeta Source Packages\default package de la aplicacin.
-
7/16/2019 Hibernate
12/90
[12]
HIBERNATE
3. Definir las clases de persistencia.El paso siguiente es aadir clases para representar a los elementos de la Base de datos.
La clase Event (paquete events) es una clase tipo JavaBean sencilla, cuyas propiedades
coinciden con los campos de la tabla Events que existir en la Base de datos.
package events;
import java.util.Date;
public class Event {private Long id;private String title;private Date date;
public Event() {}
public Long getId() {return id;
}
private void setId(Long id) {this.id = id;
}
public Date getDate() {return date;
}
public void setDate(Date date) {this.date = date;
}
public String getTitle() {return title;
}
public void setTitle(String title) {this.title = title;
}}
La propiedad id representa el identificador nico para un evento. Todas las clases de
persistencia deben tener un identificador si se quiere utilizar el conjunto completo de
-
7/16/2019 Hibernate
13/90
[13]
HIBERNATE
funcionalidades de Hibernate. El constructor sin argumentos tambin es un requisito
para todas las clases persistentes.
Se recomienda en la mayora de las ocasiones utilizar clases para representar los tipos
de los atributos en lugar de utilizar tipos bsicos, debido a que para aquellos campos
que se permitan valores nulos en la Base de datos, la representacin del valor del
campo ser natural en la representacin Java (null), mientras que con tipos bsicos
podra resultar en un error.
En el paquete events tambin se introducir la clase Person, la cual se representar de
forma similar por el momento:
package events;
public class Person {private Long id;private int age;private String firstname;private String lastname;
public Person() {}
// getters y setters para todas las propiedades}
4. Crear los ficheros de mapeo.Para cada una de las clases de persistencia tiene que existir un fichero de mapeo que se
encarga de definir la relacin entre las tablas y columnas de stas en la Base de datos, y las
clases y sus propiedades en el modelo de objetos.
En Netbeans existe una utilidad para mapear las clases con las tablas de la Base de datos
de forma automtica. Para ello, seleccionar la opcin New Other Hibernate
Hibernate Mapping File
-
7/16/2019 Hibernate
14/90
[14]
HIBERNATE
El nombre del fichero (Event.hbm.xml) coincidir con el nombre de la clase que mapea
y se guardar habitualmente en el mismo paquete donde se encuentra dicha clase.
-
7/16/2019 Hibernate
15/90
[15]
HIBERNATE
Solamente queda seleccionar la clase y la tabla a mapear. En este caso no se puede
especificar ninguna tabla ya que la Base de datos se encuentra vaca.
Al pulsar Finish se genera un archivo de mapeo, al cual es necesario aadir el nombre
de la tabla que est mapeando, y completar con los datos del mapeo de las columnas.
-
7/16/2019 Hibernate
16/90
[16]
HIBERNATE
Algunos detalles sobre este archivo:
Aunque inicialmente el archive se crea con una serie de propiedades para el
mapeo (dynamic-insert="false" dynamic-update="false" ) se han eliminado
para simplificar el ejemplo. Realmente las nicas propiedades imprescindibles
son name (nombre de la clase) y table (nombre de la tabla).
En primer lugar se declara el identificador. Esta definicin se destaca porque se
identifica con la etiqueta id. La propiedad name representa el nombre delatributo en la clase, y la propiedad column el nombre del campo en la tabla.
Dentro del identificador se declara cmo se gestiona la asignacin de sta. En
este caso se ha elegido el valor native, que delega la gestin de la clave en el
SGBD utilizado, es decir, que no es necesario preocuparse de la
gestin/asignacin de claves de forma manual. Existen otras posibilidades de
generadores de clave que se estudiarn ms adelante en este documento.
-
7/16/2019 Hibernate
17/90
[17]
HIBERNATE
La siguiente propiedad en declararse es date. En este caso tambin name
representa el nombre del atributo en la clase, y column el nombre del campo
en la tabla. La propiedad type representa el tipo de datos que se va a utilizar,
ya que aunque Hibernate es capaz de detectar que este campo se refiere a un
valor de tipo Date, es necesario especificar si esa fecha se gestionar como
time, date o timestamp. Esta propiedad type sirve para realizar conversiones
de tipos si es necesario en la aplicacin, de forma que un campo que en la base
de datos es numrico se trate como String, o Boolean,
Por ltimo se declara el campo title. En este caso solamente se especifica el
nombre del atributo de la clase porque el nombre coincide con el nombre de la
columna de la tabla de Base de datos, si no sera necesario especificar el
nombre de dicha columna.
El fichero de mapeo para la clase Person quedar de la siguiente forma:
-
7/16/2019 Hibernate
18/90
[18]
HIBERNATE
5. Configurar Hibernate.Hasta el momento se han creado las clases para representar los objetos de la Base de
datos y los ficheros de mapeo para las mismas. Para que la aplicacin funcione de
forma correcta, es necesario configurar Hibernate a travs de su fichero de
configuracin hibernate.cfg.xml.
En este fichero se establecer al menos la conexin con la base de datos, y se
especificarn cules son los ficheros de mapeo que se estn empleando en la
aplicacin, es decir, que si un fichero de mapeo no aparece en hibernate.cfg el mapeo
no funcionar.
El fichero hibernate.cfg se encuentra en el paquete por defecto de la aplicacin. Si seabre este fichero con Netbeans, en primer lugar aparece la vista Diseo. Al seleccionar
la vista XML (esquina superior izquierda de la ventana) aparecer el cdigo que
Netbeans introdujo por defecto al crear la aplicacin y especificar la conexin a la Base
de datos que se iba a emplear en la misma:
org.hibernate.dialect.MySQLDialect
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/firstapp
root
root
-
7/16/2019 Hibernate
19/90
[19]
HIBERNATE
Indica el session factory utilizado en la aplicacin. Si la aplicacin accede a ms de una
Base de datos es necesario declarar ms de un session-factory, cada uno de ellos
identificado por un nombre distinto.
La propiedad dialect indica la variante de SQL que Hibernate genera a la hora de
acceder a la Base de datos.
Adems de los datos de la conexin a la Base de datos y los ficheros de mapeo de la
aplicacin (que Netbeans ha introducido de forma automtica al crear los propios ficheros
hbm), en hibernate.cfg deben aparecer propiedades importantes que definen los
siguientes aspectos:
current_session_context_class: Hibernate funciona con sesiones para acceder a losdatos. Es necesario definir una clase de gestin de sesiones para poder realizar
operaciones con la Base de datos.
cache.provider_class: especifica el comportamiento de la Cach de 2 nivel. show_sql: mostrar en los logs las sentencias SQL que Hibernate lanza cada vez que
realiza una operacin con la Base de datos.
hbm2ddl.auto: crear el esquema de la Base de datos de forma automtica al desplegarla aplicacin.
Los valores a aadir a hibernate.cfg para el ejemplo son los siguientes:
thread
org.hibernate.cache.NoCacheProvider
true
create
-
7/16/2019 Hibernate
20/90
[20]
HIBERNATE
6. Crear clases de ayuda.Una vez que se ha configurado Hibernate, ya se puede escribir el cdigo Java para el
acceso a los datos.
Como se ha comentado anteriormente, Hibernate utiliza el concepto de sesin para
acceder a los datos, de forma que cualquier operacin de consulta o manipulacin de
los datos debe estar enmarcada en una sesin.
Para que la gestin de sesiones quede aislada del resto de operaciones de acceso a
datos, y para evitar la duplicidad de cdigo, es habitual generar una clase de ayuda que
se encarga de la inicializacin de sesiones.
Netbeans permite la generacin de esta clase a travs del men New Other
Hibernate HibernateUtil. En este caso la clase HibernateUtil se incorporar al
paquete util.
-
7/16/2019 Hibernate
21/90
[21]
HIBERNATE
package util;
import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory from hibernate.cfg.xml
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {// Log the exception.
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
-
7/16/2019 Hibernate
22/90
[22]
HIBERNATE
Cuando una clase de la aplicacin quiera acceder a la sesin actual, simplemente
invocar al mtodo esttico getSessionFactory() (HibernateUtil.getSessionFactory()).
7. Cargar y guardar objetos.Para manipular los datos de la Base de datos se va a crear una clase EventManager en
el paquete event para el almacenamiento y recuperacin de eventos:
public class EventManager {
public void createAndStoreEvent(String title, Date theDate) {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Crear el evento
Event theEvent = new Event();
theEvent.setTitle(title);
theEvent.setDate(theDate);
//Almacenarlo
session.save(theEvent);
//Confirmar transaccin
session.getTransaction().commit();
}
public List listEvents() {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Obtener la lista de eventos
List result = session.createQuery("from Event").list();
//Confirmar transaccin
session.getTransaction().commit();
return result;
}
}
-
7/16/2019 Hibernate
23/90
[23]
HIBERNATE
Los mtodos que se han definido son los siguientes, los cuales se describen para
comprobar la sencillez de las acciones que realizan:
createAndStoreEvent: crea y almacena un evento realizando los siguientes pasos:1. Acceder a la sesin actual: a travs del mtodo esttico getSessionFactory() de la
clase HibernateUtil creada anteriormente en el proyecto.
2. Abrir una transaccin: utilizando la sesin actual.3. Crear el objeto: de la forma habitual en Java.4. Almacenar el objeto: simplemente invocando al mtodo save del interfaz Session
(sesin actual).
5. Confirmar la transaccin: utilizando tambin la sesin actual.En la siguiente imagen se muestra un esquema del funcionamiento de Hibernate
basado en sesiones:
listEvents: obtiene una lista de todos los eventos de la Base de datos realizando lossiguientes pasos:
1. Acceder a la sesin actual: a travs del mtodo esttico getSessionFactory() de laclase HibernateUtil creada anteriormente en el proyecto.
2. Abrir una transaccin: utilizando la sesin actual. Las consultas a bases de datostambin requieren de una transaccin en Hibernate.
-
7/16/2019 Hibernate
24/90
[24]
HIBERNATE
3. Obtener el conjunto de resultados: se obtiene una coleccin (List) de instancias de laclase Event cuyos datos coincidirn con los datos de los registros existentes en la
Base de datos. Existen varias formas de obtener datos de una tabla en Hibernate, en
este caso se ha utilizado un Query HQL. Posteriormente se tratarn en profundidad
los aspectos relacionados con los distintos tipos de consultas en Hibernate.
4. Confirmar la transaccin: utilizando tambin la sesin actual.
8. Ejecutar la primera versin.Para probar lo que se ha implementado hasta el momento se va a crear una sencilla
aplicacin Web.
Para ello en primer lugar se modificar la pgina index.jsp del proyecto para que
funcione como formulario para introducir los datos:
JSP Page
title
date
-
7/16/2019 Hibernate
25/90
[25]
HIBERNATE
A continuacin se crea el Servlet que se encargar de la lgica de la aplicacin. Para
crear un Servlet Netbeans tambin dispone de un Asistente a travs de la opcin New OtherWeb Servlet
Su nombre ser Servlet y se almacenar en el paquete servlet. En la siguiente pantalla
se dejan por defecto los parmetros que se aadirn al fichero web.xml.
-
7/16/2019 Hibernate
26/90
[26]
HIBERNATE
Para ejecutar la aplicacin simplemente usar la opcin Run Run Main Project (F6).
public class Servlet extends HttpServlet {
protected void processRequest(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {
EventManager mng = new EventManager();
//Parsear la fechaDate date = new SimpleDateFormat("dd/MM/yyyy").
parse(request.getParameter("date"));mng.createAndStoreEvent(request.getParameter("title"), date);
//Mostrar los datos almacenadosthis.mostrarTabla(out, mng.listEvents());
} catch (Exception ex) {out.println(ex);
} finally {
out.close();}}
private void mostrarTabla(PrintWriter out, List lista) {out.println("");Iterator it = lista.iterator();//Iterar sobre todos los eventoswhile (it.hasNext()) {
Event event = (Event) it.next();out.println("");
out.println("" + event.getTitle() + "");out.println("" + event.getDate() + "");out.println("");
}out.println("");
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
processRequest(request, response);}
}
-
7/16/2019 Hibernate
27/90
[27]
HIBERNATE
9. Asociar clases.La asociacin entre clases es uno de los aspectos ms importantes de Hibernate, as
como la asociacin entre tablas es la base del modelo relacional de Bases de datos.
Este aspecto puede resultar complejo en algunas ocasiones. Posteriormente se
tratarn en profundidad los aspectos relacionados con los distintos tipos de
asociaciones en Hibernate.
En los pasos 3 y 4 se definieron las clases Event y Person a travs de cdigo Java y
ficheros de mapeo. Ahora es necesario modelar la relacin que existe entre ambas a
travs de una asociacin Hibernate.
La relacin que existe entre ambas tablas es una relacin M a M, de forma que a un
Evento acudirn varias Personas, y una Persona puede acudir a diversos Eventos. A
nivel de Bases de datos, esta relacin dar lugar a una tabla intermedia
PERSON_EVENT. Esta relacin en Hibernate se puede modelar de diversas maneras, y
adems se puede reflejar de distintas formas en las clases implicadas.
En primer lugar, la relacin ms sencilla que se puede establecer es la relacin
Unidireccional entre 2 tablas, en este caso entre las tablas Person y Person_Event. Para
el ejemplo, el tipo de relacin escogido es algo complejo, denominado en Hibernate
como relacin con tabla intermedia (join table). En el captulo 4 se explicarn los tipos
de relaciones ms generales, y la forma de eludir las relaciones complejas, pero es
bueno presentar en el ejemplo otro tipos de relaciones que pueden encontrarse en
aplicaciones Hibernate.
Las relaciones se modelan con colecciones, normalmente conjuntos (Set) de forma que
se agregan los fragmentos de cdigo que aparecen a continuacin. En la clase
simplemente se crea el atributo de la clase Set y se generan los mtodos get/set para
el mismo.
-
7/16/2019 Hibernate
28/90
[28]
HIBERNATE
private Set events = new HashSet();
public Set getEvents() {
return events;
}
public void setEvents(Set events) {
this.events = events;
}
En Person.hbm.xml se genera una nueva propiedad para la tabla de tipo conjunto. Los
atributos de esa propiedad son los siguientes:
name: nombre de la propiedad de la clase a la que hace referencia. table: tabla intermedia de la base de datos. key: clave de la tabla intermedia (PERSON_EVENT) que aporta la clase actual.
La propiedad columna es el nombre de la columna de la tabla de Base de
datos. Es decir, esta etiqueta significa que el nombre del campo que relaciona
a la tabla que modela la clase Person (PERSON) y a la tabla intermedia
(PERSON_EVENT) es PERSON_ID, el cual estar relacionado con el campo id de
la clase Person (en este caso tambin se denomina PERSON_ID).
many-to-many: indica para la tabla intermedia (PERSON_EVENT) cul es la otraclase que est implicada en la relacin (la clase Event) y cul es la clave
fornea que esta clase aporta a la relacin.
Con todo esto nicamente se ha posibilitado que a travs de una persona concreta, es
decir, una instancia de la clase Person, se pueda conocer de forma directa los eventos
a los cuales est asociada. En Hibernate esto se traduce en acceder simplemente a los
atributos de dicha clase. Por ejemplo, el mtodo getEvents devuelve un Set con los
eventos asociados a una persona:
-
7/16/2019 Hibernate
29/90
[29]
HIBERNATE
Person aPerson = (Person) session.load(Person.class, personId);
aPerson.getEvents();
Esta utilidad es suficiente, pero se pueden realizar cosas ms avanzadas, como
manipular objetos persistentes y luego transformarlos en acciones contra la base de
datos. Por ejemplo, el siguiente mtodo asigna un evento a una persona de forma
sencilla, sin gestionar claves ni relaciones entre tablas, simplemente a travs de la
relacin normal entre conjuntos:
public void addPersonToEvent(Long personId, Long eventId) {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Cargar la persona por clave
Person aPerson = (Person) session.load(Person.class, personId);
//Cargar el evento por clave
Event anEvent = (Event) session.load(Event.class, eventId);
//Agregar el evento a la persona
aPerson.getEvents().add(anEvent);
//Confirmar transaccin
session.getTransaction().commit();
}
La lnea aPerson.getEvents().add(anEvent) es donde se crea la relacin entre ambos
elementos, y al realizar la confirmacin en la Base de datos se crean los registros
necesarios para satisfacer dicha relacin.
A continuacin se va a modelar la relacin inversa. Una relacin en Hibernate se puede
modelar de forma unidireccional o bidireccional. Para el segundo de los casos, se
establecen en los ficheros de configuracin 2 relaciones, por una parte la relacin
directa (que corresponde con la que ya se ha generado en el ejemplo), y por la otra
parte se modela la relacin inversa. Es decir, si en el ejemplo la relacin directa serva
para conocer cules eran los eventos a los que estaba asociada una persona, la
relacin inversa proporciona informacin sobre cules son las personas que participan
en un determinado evento.
-
7/16/2019 Hibernate
30/90
[30]
HIBERNATE
Para ello, en la clase Event se establece tambin una propiedad de tipo Set que
almacenar los datos de las personas asociadas a un evento concreto:
private Set participants = new HashSet();
public Set getParticipants() {
return participants;
}
public void setParticipants(Set participants) {
this.participants = participants;
}
El mapeo es muy similar al que se estableci para la clase Person, teniendo en cuenta que
hay que incluir la propiedad inverse (con valor true):
name: nombre de la propiedad de la clase a la que hace referencia. table: tabla intermedia de la base de datos. inverse: en toda relacin bidireccional uno de los 2 extremos debe ser
inverse=true, lo cual es utilizado por Hibernate a la hora de construir las
sentencias SQL para interactuar con la Base de datos.
key: el nombre del campo que relaciona a la tabla que modela la clase Event(EVENT) y a la tabla intermedia (PERSON_EVENT) es EVENT_ID, el cual estar
relacionado con el campo id de la clase Event (EVENT_ID).
many-to-many: indica para la tabla intermedia (PERSON_EVENT) cul es la otraclase que est implicada en la relacin (la clase Person) y cul es la clave
fornea que esta clase aporta a la relacin (PERSON_ID).
-
7/16/2019 Hibernate
31/90
[31]
HIBERNATE
Gracias a esta nueva relacin se pueden conocer las personas que pertenecen a un
determinado evento. La pregunta es, funcionar correctamente un mtodo como elsiguiente?
public void addPersonToEvent(Long personId, Long eventId) {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Cargar la persona por clavePerson aPerson = (Person) session.load(Person.class, personId);
//Cargar el evento por clave
Event anEvent = (Event) session.load(Event.class, eventId);
//Agregar la persona al evento
anEvent.getParticipants().add(aPerson);
//Confirmar transaccin
session.getTransaction().commit();
}
10.Ejecutar la aplicacin.Para probar todos los conceptos vistos hasta el momento, se crea un nuevo Servlet de
la misma forma especificada en el paso 8, donde se realizarn las siguientes pruebas:
Cargar eventos por clave (emng.loadEvent(new Long(1))), para comprobar siexiste un evento con identificador igual a 1.
Almacenar personas (mng.createAndStorePerson(): almacena una personade prueba.
Agregar personas a eventos (mng.addPersonToEvent(new Long(1), e.getId())):agrega la persona creada anteriormente al evento.
Listar participantes de un evento (e.getParticipants()): obtiene la lista departicipantes al evento para mostrar sus nombres y la lista de eventos.
-
7/16/2019 Hibernate
32/90
[32]
HIBERNATE
public class ServletP extends HttpServlet {
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
PersonManager mng = new PersonManager();
//Comprobar que existe el evento con id=1
EventManager emng = new EventManager();
Event e = emng.loadEvent(new Long(1));
if (e == null) { //No existe el evento
out.println("Debe crear un evento");
} else {
//Almacenar
mng.createAndStorePerson(new Integer(30), "Jos", "Guardiola");
//Agregar un evento como prueba (id=1)
mng.addPersonToEvent(new Long(1), e.getId());
//Refrescar los datos
e = emng.loadEvent(new Long(1));
//Mostrar los datos almacenados en el evento
this.mostrarTabla(out, e.getParticipants());}
} catch (Exception ex) {
out.println(ex);
} finally {
out.close();
}
}
-
7/16/2019 Hibernate
33/90
[33]
HIBERNATE
private void mostrarTabla(PrintWriter out, Set lista) {
out.println("");
Iterator it = lista.iterator();
//Iterar sobre todos los eventos
while (it.hasNext()) {
Person p = (Person) it.next();
out.println("");
out.println("" + p.getAge() + "");
out.println("" + p.getFirstname() + "");out.println("" + p.getLastname() + "");
out.println("" + p.getEvents() + "");
out.println("");
}
out.println("");
}
}
Ejemplo:
1. En primer lugar se crea un evento.
2. A continuacin se pulsa el enlace Prueba relaciones.
3. Tras la ejecucin del cdigo del Servlet se muestra la lista de participantes en el eventoinicial. Para el ejemplo, la persona que se almacena como prueba estar al menos en el
evento creado inicialmente.
-
7/16/2019 Hibernate
34/90
[34]
HIBERNATE
El cdigo del Servlet resulta sencillo ya que toda la lgica de interaccin con Hibernate se
encuentra en las clases PersonManager y EventManager, destacando la forma en que se
han realizado las operaciones basadas en relaciones:
Agregar personas a eventos (mng.addPersonToEvent(new Long(1), e.getId())): lapersona se agrega al evento a travs del conjunto de eventos en los que participa
una persona (ver PersonManager).
Listar participantes de un evento (e.getParticipants()): los participantes a unevento se obtienen a travs del conjunto de personas que participa en un evento.
Para ello se carga el evento, se obtienen sus participantes, y para cada uno de ellos
se muestra su nombre y la lista de eventos en los cuales participa.
El mtodo loadPerson carga una persona a travs del valor de su campo clave (id). Para ello
se utiliza el mtodo load del interfaz Session. El procedimiento de recuperacin de una
instancia tambin sigue el esquema de sesiones y transacciones explicado con anterioridad.
El mtodo listPerson devuelve un listado de todas las personas a travs de un Criteria. Esta
forma de recuperar datos se explica en el captulo 5.2 con detenimiento, pero por el
momento destacar que el mtodo setFetchMode posibilita la recuperacin de datos
relacionados, es decir, Hibernate por defecto no cargar los datos de los conjuntos que
estn relacionados con una instancia (por ejemplo, los eventos a los que est asociada una
persona) para no sobrecargar innecesariamente al sistema, as que en caso de querer
recuperarlos hay que notificarlo de esta forma, entre otras.
-
7/16/2019 Hibernate
35/90
[35]
HIBERNATE
public class EventManager {
/**
* Almacenar un evento
* @param title ttulo
* @param theDate fecha
*/
public void createAndStoreEvent(String title, Date theDate) {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Crear el evento
Event theEvent = new Event();
theEvent.setTitle(title);
theEvent.setDate(theDate);
//Almacenarlo
session.save(theEvent);
//Confirmar transaccin
session.getTransaction().commit();
}
/**
* Cargar un evento
* @return evento
*/
public Event loadEvent(Long eventId) {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Cargar el evento por clave
-
7/16/2019 Hibernate
36/90
[36]
HIBERNATE
El mtodo loadEvent carga un evento a travs del valor de su campo clave (id). Para
ello se utiliza un Criteria al cual se le aade una restriccin de igualdad
(Restrictions.eq) para filtrar por el campo clave (id). Adems se utilizan los mtodosnecesarios para que se carguen los participantes de un evento
Event anEvent = (Event) session.createCriteria(Event.class).
setFetchMode("participants", FetchMode.JOIN).
setFetchMode("participants.events", FetchMode.JOIN).
add(Restrictions.eq("id", eventId)).
uniqueResult();
//Confirmar transaccin
session.getTransaction().commit();
return anEvent;
}
/**
* Listar los eventos
* @return lista de eventos
*/
public List listEvents() {
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Comenzar la transaccin
session.beginTransaction();
//Obtener la lista de personas
List result = session.createCriteria(Event.class).
setFetchMode("participants", FetchMode.JOIN).
list();
//Confirmar transaccin
session.getTransaction().commit();
return result;
}
}
-
7/16/2019 Hibernate
37/90
[37]
HIBERNATE
(setFetchMode("participants", FetchMode.JOIN)) y para cada uno de dichos
participantes, que en su propiedad events (ver clase Person) se carguen los datos desus eventos (setFetchMode("participants", FetchMode.JOIN)). De esta forma, para
cada evento se podran conocer los datos completos de las personas asociadas (edad,
nombre, apellidos y eventos a los que se encuentra asociada). El mtodo uniqueResult
indica que la consulta deber devolver un nico valor, el cual es una instancia de la
clase solicitada.
Para estas 2 clases, los ficheros de mapeo quedan configurados segn los cambios que
se han comentado al introducir las relaciones entre ambas. Para ejecutar el proyecto
simplemente queda modificar la pgina JSP de inicio, para que incluya la opcin
Prueba relaciones:
JSP Page
title
date
Prueba relaciones
-
7/16/2019 Hibernate
38/90
[38]
HIBERNATE
3. FRAMEWORK HIBERNATE3.1.INTRODUCCIN
En el desarrollo de una aplicacin J2EE se trabaja continuamente con objetos. Sin embargo, las
bases de datos relacionales no trabajan con ellos, sino con conjuntos y relaciones entre
conjuntos. Entonces Cmo se almacena un objeto en una base de datos? Y cmo se
mantienen las relaciones cuando se convierte un elemento de una base de datos en un objeto
Java? La causa de esta disparidad es la llamada diferencia Objeto-Relacional.
El problema se agrava cuanto ms complejo sea el material a trasladar de un paradigma a otro.
En estos casos se hace necesario un puente entre ambos conceptos. Es lo que se llama un
mapeador objeto-relacional, tambin conocido por sus siglas en ingls ORM (Object-Relational
Mapping).
Un ORM permite al programador aislarse de los detalles bsicos. Basta definir cmo se deben
trasladar los datos entre ambos modelos y el mapeador se encargar de aplicarlo en cada
ocasin.
Hibernate es un potente servicio de consulta y persistencia objeto/relacional con el cual es
posible desarrollar clases persistentes mediante lenguajes orientados a objetos manteniendo
sus caractersticas bsicas (incluyendo herencia, polimorfismo, colecciones, etc...). Permite
expresar consultas tanto en SQL como en su propia extensin de este lenguaje, denominada
HSQL.
Hibernate es un proyecto de software libre con cdigo abierto, por lo que su desarrollo se
encuentra en continua evolucin. La pgina del proyecto:
http://www.hibernate.org/
-
7/16/2019 Hibernate
39/90
[39]
HIBERNATE
3.2.INSTALACIN
IMPORTANTE:
Este apartado sirve como gua de ayuda de instalacin manual de Hibernate para su usodentro de una aplicacin.
No es recomendable realizar la instalacin de Hibernate a mano. Normalmente, se utilizanentornos de desarrollo integrados como Netbeans, con los que se puede elegir durante lacreacin del proyecto que aada los frameworks deseados, entre ellos Hibernate, de forma
que el entorno los configurar adecuadamente de forma automtica.En caso de que se descargue la ltima versin, se recomienda seguir la ayuda oficial ya queestas instrucciones pueden estar obsoletas.
1. Descargar la distribucin de Hibernate Core de:https://www.hibernate.org/344.html
2. Descomprimir el fichero3. Copiar los archivos jar necesarios a la carpeta lib de nuestra aplicacin:
a. hibernate3.jarb. \lib\required\*.jarc. \lib\optional\*.jar
4. Crear el fichero hibernate.cfg.xml en el paquete por defecto de la aplicacin.
3.3.CONFIGURACIN
Hibernate se configura a travs hibernate.cfg.xml. En el paso 5 del ejemplo anterior se
explicaron algunos de los elementos de configuracin que se pueden encontrar en este
fichero:
-
7/16/2019 Hibernate
40/90
[40]
HIBERNATE
org.hibernate.dialect.MySQLDialect
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/firstapp
root
root
thread
org.hibernate.cache.NoCacheProvider
true
create
-
7/16/2019 Hibernate
41/90
[41]
HIBERNATE
Este archivo es ledo por el framework cuando arranca y contiene los siguientes elementos:
Sesiones:session factory utilizados en la aplicacin. Si la aplicacin accede a ms deuna Base de datos es necesario declarar ms de un session-factory, cada uno de ellos
identificado por un nombre distinto.
Propiedades: dentro de cada sesin se declaran una serie propiedades para laconexin y configuracin del acceso a la Base de datos:
Datos de la conexin: datos para conectar con la Base de datos.
hibernate.connection.driver_class Driver JDBC de la Base de datos
hibernate.connection.url URL de conexin a la Base de datos
hibernate.connection.username Usuario
hibernate.connection.password Clave
hibernate.connection.pool_size Mximo nmero de conexiones del pool
Propiedades de configuracin: parmetros de configuracin generales.
hibernate.max_fetch_depth Profundidad mxima dejoins para relaciones simples
hibernate.default_batch_fetch_size Tamao por defecto para elfetching de asociaciones
hibernate.default_entity_mode Modo por defecto para larepresentacin de entidades
dynamic-map
dom4j
pojohibernate.order_updates Ordenar las actualizaciones
por clave primariatrue
false
hibernate.generate_statistics Generar estadsticas derendimiento
true
false
hibernate.use_identifier_rollback Resetea el identificadorasociado en caso deeliminacin
true
false
hibernate.use_sql_comments Genera comentarios en lassentencias SQL
true
false
-
7/16/2019 Hibernate
42/90
[42]
HIBERNATE
Propiedades de conexin: otras propiedades de la conexin.
hibernate.jdbc.fetch_size Tamao de bsqueda
hibernate.jdbc.batch_size Actualizacin batch de JDBC2
hibernate.jdbc.batch_versioned_dataUtilizar el rowcount que devuelveexecuteBatch()
true
false
hibernate.jdbc.factory_class Seleccionar unorg.hibernate.jdbc.Batcher propio
hibernate.jdbc.use_scrollable_resultsetUso de resultsets scrollables deJDBC2
true
false
hibernate.jdbc.use_streams_for_binaryUso de streams para la escriturade tipos de datos serializables
true
false
hibernate.jdbc.use_get_generated_keysUso de getGeneratedKeys() deJDBC3
true
false
hibernate.connection.provider_classUso de un ConnectionProviderpropio
hibernate.connection.autocommit Habilita el Autocommittrue
false
hibernate.connection.release_modeModo de Liberacin de conexionesJDBC
auto
on_close
after_transaction
after_statement
hibernate.connection.Propiedad especfica de JDBC parala conexin
hibernate.jndi.Propiedad especfica de JNDI parala conexin
hibernate.connection.isolationNivel de aislamiento de
transacciones
-
7/16/2019 Hibernate
43/90
[43]
HIBERNATE
Propiedades de cach: gestin de la cach de segundo nivel.
hibernate.cache.provider_classNombre de CacheProviderpropio.
hibernate.cache.use_minimal_putsOptimizar la operacin de lacach al mnimo nmero deescrituras.
truefalse
hibernate.cache.use_query_cache Habilitar la cache de consultastruefalse
hibernate.cache.use_second_level_cache Deshabilitar completamente lacache
truefalse
hibernate.cache.query_cache_factoryNombre de un interfazQueryCache propio
hibernate.cache.region_prefixPrefijo de los nombresregionales de la cach
hibernate.cache.use_structured_entries Usar entradas de cache legiblestruefalse
Propiedades de transacciones: gestin de transacciones.
hibernate.transaction.factory_classNombre de la factora detransacciones
jta.UserTransactionNombre para obtener latransaccin JTA
hibernate.transaction.manager_lookup_class Nombre delTransactionManagerLookup
hibernate.transaction.flush_before_completionLa sesin se lanza antes deconcluir la transaccin
true
false
hibernate.transaction.auto_close_sessionCierra la sesin tras concluir la
transaccin
true
false
-
7/16/2019 Hibernate
44/90
[44]
HIBERNATE
Otras propiedades.
hibernate.current_session_context_class
Estrategia para
obtener la sesin
actual
jta
thread
managed
custom Class
hibernate.query.factory_classImplementacin del
HQL Parser
org.hibernate.hql.ast.
ASTQueryTranslatorFactory
org.hibernate.hql.classic.ClassicQueryTranslatorFactory
hibernate.query.substitutionsMapeo a consultasSQL
hibernate.hbm2ddl.autoGenera el esquemaautomticamente alcrear la Sesin
validate
update
create
create-drop
hibernate.cglib.use_reflection_optimizer Utilizacin de CGLIBen lugar de reflexin
truefalse
Mapeos: ficheros de mapeo de clases (hbm.xml) que se utilizan en la aplicacin.
3.3.1. MAPEOS
Los ficheros de mapeo que se utilizan en la aplicacin se definen en hibernate.cfg, indicando la
ruta donde se encuentran los mismos. Cada uno de estos ficheros con extensin hbm.xml
mapean una clase de la aplicacin con una de las tablas de la Base de datos especificada en la
conexin, y contienen los detalles de dicho mapeo.
-
7/16/2019 Hibernate
45/90
[45]
HIBERNATE
Los ficheros de mapeo normalmente incluyen el nombre de la tabla y clase relacionadas, y el
detalle del mapeo entre columnas de la tabla y propiedades de la clase, como puede
observarse en la ilustracin anterior. Un fichero de mapeo puede contener varias clases
mapeadas, aunque habitualmente se realiza con una sola clase (cuyo nombre debera coincidir
con el nombre del fichero de mapeo).
Los elementos bsicos de un fichero de mapeo aparecen a continuacin. Se marcarn en
negrita aquellos elementos importantes para su utilizacin:
1. hibernate-mapping: datos generales del mapeo.
a. schema (opcional): nombre del esquema de bases de datos.b. catalog (opcional): nombre del catlogo de la base de datos.c. default-cascade (opcional none por defecto): estilo de cascada por defecto.
-
7/16/2019 Hibernate
46/90
[46]
HIBERNATE
d. default-access (opcional property por defecto): estrategia de acceso a laspropiedades.
e. default-lazy (opcional true por defecto): valor por defecto del atributo lazyde los mapeos de clases y colecciones.
f. auto-import (opcional true por defecto): permite usar nombres de clases sincalificar en el lenguaje SQL. Si hay dos clases con el mismo nombre sin calificar,
esta propiedad tiene que tener el valor false.
g. package (opcional): prefijo de paquete para los nombres de clases sin cualificar.
2. class: datos de la clase persistente y su relacin con la tabla de la base de datos.
-
7/16/2019 Hibernate
47/90
[47]
HIBERNATE
a. name (opcional): nombre completo de la clase o interfaz Java. Tambin sepueden hacer persistentes clases estticas internas.
b. table (opcional por defecto el nombre de la clase sin cualificar): nombre dela tabla de la base de datos.
c. discriminator-value (opcional por defecto el nombre de la clase): distinguesubclases individuales, se usa para comportamiento polimrfico.
d. mutable (opcional true por defecto): especifica si las instancias son mutableso no. Las clases inmutables no se pueden modificar ni eliminar.
e. schema (opcional): sobreescribe el nombre de esquema especificado por.
f. catalog (opcional): sobreescribe el nombre de catlogo especificado por.
g. proxy (opcional): interfaz de proxy para la incializacin perezosa.h. dynamic-update (opcional false por defecto): la sentencia SQL UPDATE se
genera en tiempo de ejecucin y solamente contiene las columnas cuyos
valores hayan cambiado.
i. dynamic-insert (opcional false por defecto): la sentencia SQL INSERT segenera en tiempo de ejecucin y solamente contiene las columnas cuyos
valores son distintos a null.
j. select-before-update (opcional false por defecto): se produce una sentenciaSELECT antes de actualizar para comprobar si un objeto ha sido modificado. Si
no no se produce dicha actualizacin.
k. polymorphism (opcional implicit por defecto): determina si se utilizapolimorfismo implcito o explcito a la hora de recuperar objetos en las
consultas.
l. where (opcional): condicin WHERE a utilizar cuando se recuperan objetos deesta clase.
m. persister (opcional): especifica un ClassPersister propio, permitiendo laredefinicin de la estrategia de almacenamiento persistente.
n. batch-size (opcional 1 por defecto): tamao batch para la bsqueda deinstancias de esta clase por campo clave.
-
7/16/2019 Hibernate
48/90
[48]
HIBERNATE
o. optimistic-lock (opcional version por defecto): determina la estrategia debloqueo optimista.
p. lazy (opcional): bsqueda perezosa.q. entity-name (opcional por defecto el nombre de la clase): Hibernate3
permite mapear una misma clase distintas veces (con distintas tablas), y este
nombre ser el utilizado.
r. check (opcional): expression SQL para generar una comprobacin en lageneracin automtica de esquemas.
s. rowid (opcional): utilizacin de ROWID.t. subselect (opcional): mapea una entidad immutable de solo lectura con una
subconsulta de la base de datos, por ejemplo para usar vistas en lugar de
tablas.
u. abstract (opcional): marca superclases abstractas en jerarquas con .
3. id: dentro de la etiqueta class, se debe mapear la clave primaria de la tabla.
(e)
node="element-name|@attribute-name|element/@attribute|."
a. name (opcional): nombre de la propiedad.b. type (opcional): indica el tipo.c. column (opcional nombre de la propiedad por defecto): nombre de la
columna.
-
7/16/2019 Hibernate
49/90
[49]
HIBERNATE
d. unsaved-value (opcional): valor del identificador que indica que la instancia esnueva, para distinguir de instancias guardadas o cargadas en sesiones
anteriores. Casi nunca se utiliza en Hibernate 3.
e. access (opcional property por defecto): estrategia de acceso al valor de lapropiedad.
4. generator: dentro del id, es necesario definir un generador de identificadores nicospara la clase.
uid_table
next_hi_value_column
a. class: nombre de la clase que implementa el interfazorg.hibernate.id.IdentifierGenerator, a la cual se pueden pasar parmetros a
travs de los elementos . Asimismo, existe una serie de clases
predefinidas:
i. increment: identificadores nicos siempre que no existan otrosprocesos insertando en la tabla.
ii. identity: columna de tipo identity (autonumrica) para aquellossistemas que la soportan.
iii. sequence: asignacin basada en secuencia para aquellos sistemas quela soportan.
iv. hilo: genera identificadores con un algoritmo hi/lo dado un nombre detabla y de columna.
v. seqhilo: genera identificadores con un algoritmo hi/lo dado un nombrede secuencia.
vi. uuid: genera claves de tipo uuid de tamao 32.vii. guid: usa una cadena guid generada por la base de datos para aquellos
sistemas que la soportan.
-
7/16/2019 Hibernate
50/90
[50]
HIBERNATE
viii. native: selecciona identity, sequence o hilo dependiendo de la base dedatos en uso.
ix. assigned: asignado por la aplicacin. Es la opcin por defecto si no seincluye generator.
x. select: asignacin por trigger.xi. foreign: usa el identificador de otro objeto asociado, normalmente a
travs de un .
xii. sequence-identity: usa una secuencia y el mtodo getGeneratedKeysde JDBC3 para la generacin.
5. composite-id: utilizado en el caso que la clave primaria est compuesta por ms deuna columna.
(d)node="element-name|."
(e)
-
7/16/2019 Hibernate
51/90
[51]
HIBERNATE
e. key-property: dentro de la etiqueta composite-id, indica cada uno de los camposque forman la clave y que no corresponden a claves forneas de otras tablas:
i. name: nombre de la propiedad (de la clase que implementa elidentificador).
ii. type(opcional): tipo Hibernate de la propiedad.iii. column (opcional nombre de la propiedad por defecto): nombre de
la columna.
f. key-many-to-one: dentro de la etiqueta composite-id, indica cada uno de loscampos que forman la clave y que corresponden a claves forneas de otras tablas:
i. name: nombre de la propiedad (de la clase que implementa el identificador).ii. class: nombre de la clase relacionada a travs de la clave fornea.
iii. column (opcional nombre de la propiedad por defecto): nombre dela columna.
6. property: declaracin de propiedades de la clase.
-
7/16/2019 Hibernate
52/90
[52]
HIBERNATE
a. name: nombre de la propiedad (primera letra siempre en minuscule).b. column (opcional nombre de la propiedad por defecto): nombre de la
columna de base de datos mapeada. Tambin puede ser especificado a travs
de etiquetas .
c. type (opcional): indica el tipo Hibernate, que puede tratarse de uno de lossiguientes, aunque en caso de no especificar Hibernate lo asignar
automticamente en funcin del tipo de la columna de base de datos:
i. Tipo bsico Hibernate (integer, string, character, date, ).ii. Clase Java o tipo bsico (int, float, java.util.Date, ).
iii. Clase Java serializable.iv. Clase propia.
d. update (opcional true por defecto): las columnas mapeadas deben incluirseen las sentencias UPDATE.
e. insert (opcional true por defecto): las columnas mapeadas deben incluirse enlas sentencias INSERT.
f. formula (opcional): expresin SQL que define el valor de una propiedadcalculada. Las propiedades calculadas no se mapean a ninguna columna.
g. access (opcional property por defecto): estrategia utilizada para acceder a lapropiedad.
h. lazy (opcional false por defecto): indica si esta propiedad debe ser buscadade forma perezosa cuando la instancia se accede por vez primera.
i. unique (opcional): restriccin unique para esta columna.j. not-null (opcional): restriccin not-null para esta columna.k. optimistic-lock (opcional true por defecto): las actualizaciones de esta
propiedad requieren la adquisicin del bloqueo optimista.
l. generated (opcional never por defecto): esta propiedad es generada por labase de datos.
7. many-to-one
-
7/16/2019 Hibernate
53/90
[53]
HIBERNATE
a. name: nombre de la propiedad.b. column (opcional): nombre de la columna de clave fornea. Tambin puede
ser especificado a travs de etiquetas .
c. class (opcional): nombre de la clase asociada.d. cascade (opcional): operaciones que deben ejecutarse en cascada desde el
padre al objeto asociado.
e. fetch (opcional select por defecto): elige entre bsqueda mediante outer-join o select secuencial.
f. update (opcional true por defecto): las columnas mapeadas deben incluirseen las sentencias UPDATE.
g. insert (opcional true por defecto): las columnas mapeadas deben incluirse enlas sentencias INSERT.
-
7/16/2019 Hibernate
54/90
[54]
HIBERNATE
h. property-ref (opcional): nombre de la propiedad de la clase asociada relacionadacon esta foreign key. Si no se especifica se utiliza la clave de la clase asociada.
i. access (opcional property por defecto): estrategia utilizada para acceder a lapropiedad.
j. unique (opcional): restriccin unique para la clave fornea.k. not-null (opcional): restriccin not-null para la clave fornea.l. optimistic-lock (opcional true por defecto): las actualizaciones de esta
propiedad requieren la adquisicin del bloqueo optimista.
m. lazy (optional proxy por defecto): indica si esta propiedad debe ser buscadade forma perezosa cuando la instancia se accede por vez primera.
n. not-found (opcional exception por defecto): cmo se tratan las clavesforneas que referencian a filas inexistentes.
o. entity-name (opcional): nombre de entidad de la clase asociada.p. formula (opcional): expresin SQL que define el valor de una propiedad calculada.
8. one-to-one
a. name: nombre de la propiedad.b. class (opcional): nombre de la clase asociada.
-
7/16/2019 Hibernate
55/90
[55]
HIBERNATE
c. cascade (opcional): operaciones que deben ejecutarse en cascada desde elpadre al objeto asociado.
d. constrained (opcional): una clave fornea de la clave primaria de la tablamapeada referencia a la tabla de la clase asociada.
e. fetch (opcional select por defecto): elige entre bsqueda mediante outer-join o select secuencial.
f. property-ref (opcional): nombre de la propiedad de la clase asociada relacionadacon esta foreign key. Si no se especifica se utiliza la clave de la clase asociada.
g. access (opcional property por defecto): estrategia utilizada para acceder a lapropiedad.
h. formula (opcional): expresin SQL que define el valor de una propiedad calculada.i. lazy (optional proxy por defecto): indica si esta propiedad debe ser buscada
de forma perezosa cuando la instancia se accede por vez primera.
j. entity-name (opcional): nombre de entidad de la clase asociada.
9. set: las relaciones inversas normalmente se modelan a travs de un conjunto (set), peroexisten otros elementos que se pueden usar como list, map, bag, array o primitive-array.
-
7/16/2019 Hibernate
56/90
[56]
HIBERNATE
(o)
a. name: nombre de la propiedad.b. table (opcional nombre de la propiedad por defecto): nombre de la tabla de
la coleccin (no se usa para one-to-many).
c. schema (opcional): nombre del esquema para sobreescribir el esquemadefinido en el elemento raz.
d. lazy (opcional true por defecto).e. inverse (opcional false por defecto): indica el lado inverso en una asociacin
bidireccional.
f. cascade (opcional - none por defecto): permite operaciones en cascada sobrelos elementos hijos.
g. sort (opcional): especifica una coleccin ordenada mediante orden natural oespecificando una clase comparadora.
-
7/16/2019 Hibernate
57/90
[57]
HIBERNATE
h. order-by (opcional): solo en JDK 1.4, especifica un nombre de columna quedefine el orden de iteracin.
i. where (opcional): condicin WHERE a utilizar cuando se recuperan o eliminanobjetos de la coleccin.
j. fetch (opcional select por defecto): elige entre bsqueda mediante outer-join o select secuencial.
k. batch-size (opcional 1 por defecto): tamao batch para la bsqueda deinstancias de esta clase por campo clave.
l. access (opcional property por defecto): estrategia utilizada para acceder a lapropiedad.
m. optimistic-lock (opcional true por defecto): las actualizaciones del estado dela coleccin requieren la adquisicin del bloqueo optimista.
n. mutable (opcional true por defecto): los elementos de la coleccin nuncacambian.
o. key: dentro de la etiqueta set indica la clave fornea de la coleccin:
i. column (opcional): nombre de la columna que acta como clave fornea.Tambin puede especificarse a travs de elementos .
ii. on-delete (opcional noaction por defecto): la clave fornea tieneactivado el borrado en cascada en la base de datos.
iii. property-ref (opcional): la clave fornea se refiere a columnas que noson la clave primaria de la tabla original.
iv. not-null (opcional): las claves forneas no se pueden establecer comonull.
-
7/16/2019 Hibernate
58/90
[58]
HIBERNATE
v. update (opcional): las claves forneas no se pueden actualizar.vi. unique (opcional): la clave fornea debera tener una restriccin
unique.
p. one-to-many: indica
i. class: nombre de la clase asociada.ii. not-found (opcional exception por defecto): cmo se tratan las
claves forneas que referencian a filas inexistentes.
iii. entity-name (opcional): nombre de entidad de la clase asociada.
3.4.EL INTERFAZ SESSION
El interfaz Session es la principal va de interaccin entre la aplicacin Java e Hibernate. Representa
a la sesin actual, donde se producen transacciones para la interaccin con la Base de datos,efectuando operaciones de lectura, creacin, modificacin y eliminacin de instancias de clases
mapeadas. Las instancias de tales clases se pueden encontrar en tres estados posibles:
transient: no es persistente, no est asociada a ninguna sesin. Se pueden convertir enpersistent invocando a los mtodos save, persist o saveOrUpdate. Se encuentra en la
aplicacin pero no en la Base de datos.
persistent: asociado a una nica sesin. Se encuentra en la aplicacin y en la Base dedatos.
-
7/16/2019 Hibernate
59/90
[59]
HIBERNATE
detached: persistente previamente, no asociado con ninguna sesin. Se encuentra enla Base de datos, pero no se ha recuperado desde la aplicacin.
En la siguiente ilustracin aparecen estos estados, y cules son los mtodos que provocan la
transicin de uno a otro.
Para poder operar con una sesin es necesario obtener una instancia de la misma y comenzar
una transaccin. Cualquier operacin sobre dicha instancia debe contenerse dentro de una
transaccin.
Si se produce una excepcin dentro de la transaccin, sta debe ser cancelada (rollback), si no
hay que confirmarla para hacer persistentes los cambios (commit):
-
7/16/2019 Hibernate
60/90
[60]
HIBERNATE
//Obtener la sesin actual
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
try{
//Comenzar la transaccin
session.beginTransaction();
//Operaciones con session
}catch (Exception ex){
//Deshacer transaccin
session.getTransaction().rollback();}finally{
//Confirmar transaccin
session.getTransaction().commit();
}
Los mtodos que se invocan sobre la instancia de Session producen operaciones sobre la Base
de datos a travs de sentencias SQL, generadas en el dialecto concreto configurado en
hibernate.cfg. De esta forma, las siguientes sentencias se producen para los mtodos
enumerados anteriormente:
INSERT: save, persist, saveOrUpdate, replicate. UPDATE: update, merge, saveOrUpdate, replicate. DELETE: delete.
A continuacin se exponen algunos mtodos de la clase Session utilizados habitualmente. Para
mayor informacin se puede acceder a la API de Hibernate:
http://www.hibernate.org/hib_docs/v3/api/
-
7/16/2019 Hibernate
61/90
[61]
HIBERNATE
public Transaction beginTransaction()
Comienza una unidad de trabajo y devuelve
la instancia de la transaccin asociada. Elobjeto Transaction es quien tiene losmtodos commit y rollback.
public Transaction getTransaction()Obtiene la instancia de transaccin asociadacon esta sesin. El objeto Transaction esquien tiene los mtodos commit y rollback.
public Criteria createCriteria(Class pstClass) Crea una nueva instancia de Criteria.
public Query createQuery(String qryString)Crea una nueva instancia de Query para unacadena HQL.
public SQLQuerycreateSQLQuery(String qryString)
Crea una nueva instancia de SQLQuery parauna cadena SQL.
public Object get(Class clazz, Serializable id)
Devuelve la instancia persistente de unaclase, correspondiente al identificador id, onull si no existe un elemento con dichoidentificador.
public Object load(Class theClass, Serializable id)
Devuelve la instancia persistente de la clasedada, correspondiente al identificador id,asumiendo que la instancia existe. Estemtodo no debe utilizarse para determinar siexiste una instancia (utilizar get en su lugar).
public Serializable save(Object object)
Convierte en persistente la instancia actual,asignando en primer lugar un identificadorgenerado (o utilizando el id actual si se hautilizado un generador asigned).
public void saveOrUpdate(Object object)Guarda (save) o actualiza (update) unainstancia, dependiendo de si sta erapersistente anteriormente o no.
public void update(Object object)Actualiza una instancia persistente con el
identificador de la instancia actual.
public Object merge(Object object)
Copia el estado de una instancia en el objetopersistente con el mismo identificador. Si noexiste una instancia persistente en la sesinactual la carga. En otro caso, si la instanciano se haba guardado, guarda una copia y ladevuelve como una nueva instanciapersistente.
public void persist(Object object)Convierte una instancia transient enpersistente.
-
7/16/2019 Hibernate
62/90
[62]
HIBERNATE
public void delete(Object object)
Elimina una instancia persistente del
almacn de datos.
public voidreplicate(Object o,ReplicationMode rm)
Hace persistente el estado de una instancia,reutilizando su identificador.
public void refresh(Object object)
Vuelve a leer el estado de una instancia de labase de datos. til cuando se ejecutantriggers, se inserta un campo binario, o lassesiones son muy largas.
public Serializable getIdentifier(Object object)Devuelve el identificador asociado a unainstancia.
public boolean contains(Object object)Comprueba si una instancia est asociadacon esta sesin.
public void evict(Object object)Elimina una instancia de la sesin, con lo cuallas actualizaciones no tendrn reflejo en laBase de datos.
4. ASOCIACIONES
Las asociaciones en Hibernate representan las relaciones entre tablas. En un modelo ORM, las
claves forneas habitualmente no se modelan con el campo identificador nicamente, sino con
instancias completas de objetos para poder aprovechar la potencia del Framework.
-
7/16/2019 Hibernate
63/90
[63]
HIBERNATE
En la imagen anterior se puede observar la relacin que existe entre la tabla Person (Persona) y
Address (Direccin). Se trata de una relacin uno a muchos donde el campo AddressId acta comouna clave fornea de la tabla Address (maestro) en la tabla Person (detalle) lo cual modela que en
una Direccin pueden habitar muchas Personas. Este tipo de relacin es muy habitual en Bases de
datos y como se ha comentado, se suele denominar uno a muchos (leyendo en la direccin
Address Person). En Hibernate suele leerse de forma inversa, muchos a uno (many-to-one), pero
sigue tratndose de la misma relacin. Esta relacin a nivel de clases persistentes se modela de
forma sencilla a travs de un atributo address en la clase Person, de forma que si se dispone de una
instancia de Person se pueden conocer todos los datos de la instancia Address donde reside esa
persona, sin necesidad de realizar ningn tipo de consulta adicional a la Base de datos. En una Base
de datos irremediablemente habra que realizar una consulta cruzada para recuperar tales datos.
El otro atributo fruto de esta relacin que aparece a nivel de clases es el conjunto people. Esto
Hibernate se denomina la relacin inversa, ya que las relaciones se pueden modelar en ambos
sentidos. Este sentido de la relacin es el que habitualmente se utiliza al realizar una consulta
cruzada, es decir, cuando interesa conocer quines son los habitantes de una determinada
direccin. De nuevo Hibernate proporciona esta informacin de forma sencilla sin necesidad
de implementar consultas, ya que el atributo de tipo Set de la clase Address contendr todas
las instancias de la clase Person para aquellas personas que cumplan con la relacin.
Para poder aprovechar estas funcionalidades es necesario tener en cuenta otros factores como
la configuracin de los ficheros de mapeo, o los mtodos a utilizar para recuperar los valores
de la Base de datos. Ambos conceptos se explican ampliamente en este captulo y el siguiente.
4.1.RELACIONES EN BASES DE DATOS
En general, en una base de datos existen tres tipos de relacin:
-
7/16/2019 Hibernate
64/90
[64]
HIBERNATE
Las relaciones que existen entre las tablas dan lugar a modificaciones en las mismas a la hora
de normalizar el modelo, de forma que no existan campos duplicados ni prdidas de integridadpor un mal diseo.
De las imgenes anteriores cabe destacar un aspecto importante, todas los tipos de relaciones
que aparecan en primera instancia, se pueden reducir a un nico tipo, la relacin Muchos a
uno, ya que:
Las relaciones Uno a Uno se eliminan Las relaciones Muchos a Muchos se transforman en relaciones Muchos a Uno sobre la
tabla intermedia.
Este hecho va a simplificar considerablemente la gestin de asociaciones en Hibernate, ya que
solamente har falta controlar un tipo de relacin para poder construir modelos ORM que
representen modelos Entidad-Relacin de cierta complejidad.
Los tipos de asociaciones en Hibernate que servirn para modelar las relaciones citadas es la
siguiente:
Unidireccionales: solamente se representa un extremo de la relacin. Unidireccionales con tabla de unin. Bidireccionales: se representan ambos extremos. Bidireccionales con tabla de unin.
-
7/16/2019 Hibernate
65/90
[65]
HIBERNATE
Teniendo en cuenta esos tipos de relaciones y los dos sentidos de la relacin aparecen en
Hibernate 12 tipos distintos de relacin que se pueden modelar de forma directa. Todas estasrelaciones se pueden reducir bsicamente a tres tipos que sern explicados a continuacin.
Como se ha comentado, lo ms sencillo para el desarrollo puede resultar en el diseo
adecuado del modelo Entidad-Relacin de la Base de datos, y simplemente en utilizar mapeos
many-to-one para las relaciones entre las tablas.
Para mayor informacin se puede consultar la documentacin de Hibernate relativa a Asociaciones:
http://www.hibernate.org/hib_docs/v3/reference/en/html/associations.html
4.2.MANY-TO-ONE
La primera de las relaciones que se explicarn es la relacin Many-to-one. Para poder modelar
un sistema de Bases de datos puede resultar la nica relacin imprescindible ya que como se
ha explicado, el resto de ellas se pueden transformar.
Esta relacin normalmente se denomina Maestro-Detalle, donde existe un extremo Maestro
que dispone de las claves principales, y un Detalle donde esta clave aparece como fornea.
A nivel de Hibernate, la relacin bidireccional se modela de la siguiente forma:
Many-to-one en el Detalle. One-to-Many en el Maestro, incorporando el atributo inverse. No es obligatorio
modelar este sentido de la relacin.
En el siguiente ejemplo aparecen los mapeos que se producirn en las clases para modelar
esta relacin. En el apartado 3.3.1 se puede consultar el significado completo de los atributos
que aqu aparecen.
-
7/16/2019 Hibernate
66/90
[66]
HIBERNATE
En la clase Person se mapea el sentido many-to-one que es el ms sencillo:
A la clase se agrega un atributo Address address. En el fichero de mapeo se agrega una etiqueta many-to-one:
name: nombre del atributo. column: nombre de la columna de la tabla de base de datos que se
corresponde con el atributo (la clave fornea).
En la clase Address se mapea el sentido one-to-many, el sentido inverso:
A la clase se agrega un atributo Set people. En el fichero de mapeo se agrega una etiqueta set:
name: nombre del atributo. inverse (true): la relacin es inversa. key:
column: nombre de la columna de la tabla de base de datos que actacomo clave fornea en la otra tabla.
one-to-many
class: nombre de la clase que modela la otra tabla en la relacin.
-
7/16/2019 Hibernate
67/90
[67]
HIBERNATE
4.3.MANY-TO-MANYComo se ha comentado, esta relacin se puede reducir a dos relaciones Many-to-one sobre la
tabla intermedia de la Base de datos.
En Hibernate se pueden modelar relaciones Many-to-Many con tablas intermedias de forma
directa en lugar de recurrir a dos relaciones Many-to-One de la siguiente forma:
Many-to-many en cada tabla. No es necesario crear la clase persistente Person_Address.
-
7/16/2019 Hibernate
68/90
[68]
HIBERNATE
En la clase Person se mapea el sentido directo:
A la clase se agrega un atributo Set addresses. En el fichero de mapeo se agrega una etiqueta set:
name: nombre del atributo. table: nombre de la tabla intermedia de la base de datos. key:
column: nombre de la columna de la tabla que modela esta clase queacta como clave fornea en la otra tabla.
many-to-many class: nombre de la clase que modela la otra tabla en la relacin. column: nombre de la columna de la otra tabla en la relacin que
acta como la otra clave fornea en la tabla intermedia.
En la clase Address se mapea el sentido inverso:
A la clase se agrega un atributo Set people. En el fichero de mapeo se agrega una etiqueta set:
name: nombre del atributo. inverse (true): la relacin es inversa. table: nombre de la tabla intermedia de la base de datos. key:
column: nombre de la columna de la tabla que modela esta clase queacta como clave fornea en la otra tabla.
-
7/16/2019 Hibernate
69/90
[69]
HIBERNATE
many-to-many class: nombre de la clase que modela la otra tabla en la relacin. column: nombre de la columna de la otra tabla en la relacin que
acta como la otra clave fornea en la tabla intermedia.
4.4.ONE-TO-ONE
Como se ha comentado, esta relacin se puede eliminar de la Base de datos pasando los datosde una de las tablas a la otra.
En Hibernate se pueden modelar relaciones One-to-One de forma directa de la siguiente
forma:
Many-to-one en un sentido, incluyendo el atribute unique. One-to-one en el sentido inverso. Se mantienen ambos mapeos.
-
7/16/2019 Hibernate
70/90
[70]
HIBERNATE
En la clase Person se mapea el sentido directo:
A la clase se agrega un atributo Address address. En el fichero de mapeo se agrega una etiqueta many-to-one:
name: nombre del atributo. column: nombre de la columna de la tabla de base de datos que se
corresponde con el atributo (la clave fornea).
unique (true): restriccin de unicidad para cumplir la relacin.
En la clase Address se mapea el sentido inverso:
A la clase se agrega un atributo Person person. En el fichero de mapeo se agrega una etiqueta one-to-one:
name: nombre del atributo. property-ref: nombre de la propiedad que se corresponde con esta clase en el
otro extremo.
-
7/16/2019 Hibernate
71/90
[71]
HIBERNATE
5. RECUPERACIN DE DATOS
En las bases de datos relacionales, las operaciones ms frecuentes suelen ser las
recuperaciones de datos de una o ms tablas o vistas. Para poder realizar esta operacin, en
dichas bases de datos se recurre al lenguaje SQL, y ms concretamente a la sentencia SELECT.
De esta forma, especificando una sentencia ms o menos compleja es posible obtener la
informacin solicitada
Como se vio en el apartado anterior, la relacin ms habitual entre dos tablas es la relacin
Maestro-Detalle o many-to-one. Sobre esta relacin se pueden efectuar 2 tipos de consultascruzadas bastante habituales:
Obtener todos los datos de las personas y de la de la direccin donde viven:
SELECT PERSON.NAME, PERSON.AGE, ADDRESS.STREET, ADDRESS.NUMBER
FROM PERSON, ADDRESS
WHERE PERSON.ADDRESSID = ADDRESS.ADDRESSID
Obtener los nombres de todas las personas que viven en una direccin determinada:
SELECT PERSON.NAME
FROM PERSON, ADDRESS
WHERE PERSON.ADDRESSID = ADDRESS.ADDRESSID
AND ADDRESSID = 1
-
7/16/2019 Hibernate
72/90
[72]
HIBERNATE
En Hibernate se podra realizar de la misma forma (SQLQuery) pero lo ms habitual no es esto,
sino aprovechar las caractersticas del modelo ORM para acceder a esta informacin de formams eficiente. Para ello existen dos alternativas:
Usar una consulta HQL para ejecutar la consulta, de forma que usando un lenguajeorientado a objetos pero muy similar a SQL.
Usar un Criteria, de forma que a travs de programacin se puedan utilizar diversosmtodos para recuperar los datos deseados de forma similar a como lo hace HQL.
Como se ha venido comentando, la relacin entre las dos tablas anteriores se modela a nivelde clases con una asociacin many-to-one, y los siguientes atributos relacionados:
Address address en la clase Person, que permitir acceder a todos los datos de ladireccin de una Persona.
Set people en la clase Address, que permitir conocer todas las personas que habitanuna misma direccin.
Lo que se modela en las clases es exactamente lo que se estaba accediendo a travs desentencias SELECT anteriores. Por tanto casi todo el trabajo ya est hecho, solamente hace
falta acceder a los datos:
List list = (List) session.createQuery("from Person").list();
List list = (List) session.createCriteria(Person.class).list();
En ambos casos se obtiene una lista con una instancia de la clase Person por cada una de las
personas de la tabla Person, en cuyo atributo address se puede consultar toda la informacin
necesaria sobre la direccin. Sobre esta capacidad es necesario destacar que no siempre
Hibernate recupera todos los datos relacionados ya que suele comportarse en modo lazy, es
decir, solamente recupera los datos principales de la clase, mientras que los atributos de
asociaciones (como address) quedan sin inicializar por motivos de eficiencia. Para forzar que
estos atributos siempre se carguen se utilizan los fetch o alias a la hora de recuperar los datos,
los cuales se explican con mayor detalle en los apartados posteriores.
-
7/16/2019 Hibernate
73/90
[73]
HIBERNATE
Set set = ((Address)session.createQuery("from Address where id=1").list()).getPeople();
Set set = ((Address)session.createCriteria(Address.class).
add(Restrictions.eq("id", new Integer(1)))
.list()).getPeople();
5.1.HQL
Hibernate usa un potente lenguaje de consulta (HQL), que es similar en apariencia a SQL. En
comparacin con SQL, sin embargo, HQL es completamente orientado a objetos y es capaz de
gestionar conceptos como herencia, polimorfismo y asociaciones.
La informacin completa se puede encontrar en:
http://www.hibernate.org/hib_docs/v3/reference/en/html/queryhql.html
5.1.1.SENSIBILIDAD A MAYSCULAS
Exceptuando los nombres de clases y atributos, el lenguaje HQL es insensible a maysculas
(por ejemplo se admite SELECT, select o SEleCT).
5.1.2.DATOS DE LA CONSULTA
La consulta HQL ms simple es la siguiente:
from Cat
Devuelve todas las instancias de la clase Cat. Normalmente NO es necesario utilizar el nombre
de paquete (from eg.Cat) ya que la opcin auto-import es true por defecto.
A la hora de referirse a Cat desde otras partes de la consulta, normalmente se utiliza un alias a
continuacin de la clase. La especificacin del alias puede usar la palabra clave as (as cat) o no:
from Cat cat
-
7/16/2019 Hibernate
74/90
[74]
HIBERNATE
5.1.3.JOINS
Los joins son la forma de realizar cruces entre tablas en Bases de datos. Habitualmente no se
utilizan los joins porque la forma de escribir las consultas resulta ms amigable utilizando
condiciones where, de forma que es el gestor de la Base de datos quien se encarga de realizar
la transformacin necesaria para utilizar este tipo de unin. Las consultas siguientes son
equivalentes en cuanto al resultado obtenido:
SELECT e.nombre, d.nombre FROM empleados e, departamentos d
WHERE d.numero = e.dnumero
SELECT e.nombre, d.nombre FROM empleados e
INNER JOIN departamentos d ON d.numero = e.dnumero
Existen varios tipos de JOIN posibles entre 2 tablas de la Base de datos:
CROSS JOIN: unin de todos los datos de dos tablas sin especificar ningn criterio(producto cartesiano). Este tipo de JOIN es muy ineficiente.
10Javier2B
Manuel1B
12Antonio1A
GARAGENOMBREPISO
PROPIETARIOS
2212
2211
2010
TAMAONUMERO
GARAJES
2010Manuel1B
2211Manuel1B
201012Antonio1A
221112Antonio1A
221212Antonio1A
-
7/16/2019 Hibernate
75/90
[75]
HIBERNATE
En Hibernate se especifica de forma similar a SQL:
from Formula, Parameter
INNER JOIN o JOIN: unin de los datos de dos tablas solamente en aquellos casosdonde existan datos en el campo de combinacin. Este tipo de JOIN es el que resulta
equivalente a realizar la combinacin a travs de un WHERE.
En Hibernate tambin se especifica de forma similar a SQL, solamente teniendo en cuenta que
no se hacen uniones entre tablas propiamente dichas, sino con los atributos sobre los que se
han montado asociaciones. Se puede usar con las palabras clave inner join o inner outer join, o
incluso simplemente join:
from Cat as cat
inner join cat.mate as mate
10Javier2B
Manuel1B
12Antonio1A
GARAGENOMBREPISO
PROPIETARIOS
2212
2211
2010
TAMAONUMERO
GARAJES
2010Javier2B
2212Antonio1A
TAMAONUMERONOMBREPISO
-
7/16/2019 Hibernate
76/90
[76]
HIBERNATE
LEFT OUTER JOIN o LEFT JOIN: se seleccionan todos los datos de la primera tabla de lacombinacin, uniendo los datos de la segunda tabla solamente en los casos que sea
posible, y poniendo null en los casos que no sea posible.
De nuevo se pueden especificar con HQL sobre los atributos sobre los que se han
montado asociaciones uniones de este tipo a travs de left join o left outer join:
from Cat as cat
inner join cat.mate as mate
left outer join cat.kittens as kitten
RIGHT OUTER JOIN o RIGHT JOIN: se seleccionan todos los datos de la segunda tablade la combinacin, uniendo los datos de la primera tabla solamente en los casos que
sea posible, y poniendo null en los casos que no sea posible.
10Javier2B
Manuel1B
12Antonio1A
GARAGENOMBREPISO
PROPIETARIOS
2212
2211
2010
TAMAONUMERO
GARAJES
nullnullManuel1B
2010Javier2B
2212Antonio1A
TAMAONUMERONOMBREPISO
-
7/16/2019 Hibernate
77/90
[77]
HIBERNATE
Se puede especificar con HQL con right join o right outer join.
FULL OUTER JOIN o FULL JOIN: es una combinacin de los dos anteriores.
10Javier2B
Manuel1B
12Antonio1A
GARAGENOMBREPISO
PROPIETARIOS
2212
2211
2010
TAMAONUMERO
GARAJES
2211nullnull
nullnullManuel1B
2010Javier2B
2212Antonio1A
TAMAONUMERONOMBREPISO
10Javier2B
Manuel1B
12Antonio1A
GARAGENOMBREPISOPROPIETARIOS
2212
2211
2010
TAMAONUMEROGARAJES
2211nullnull
2010Javier2B
2212Antonio1A
TAMAONUMERONOMBREPISO
-
7/16/2019 Hibernate
78/90
[78]
HIBERNATE
from Formula form
full join form.parameter param
En general, sobre cualquier tipo de join se pueden establecer condiciones:
from Cat as cat
left join cat.kittens as kitten
with kitten.bodyWeight > 10.0
Por ltimo, es muy importante la utilizacin de la palabra clave fetch. Como se ha comentado,normalmente las colecciones o atr
