Hibernate y XML

Diseño de
HIBERNATE Y XML Sistemas
Ay. Facundo Ciancio

Ay. Nicolás Minelli
Ay. Pablo Bismach
Coordinador: JTP. Ing. Cristian Ghilardi
Año: 2016
Diseño de Sistemas UTN – Facultad Regional Mendoza. Versión 1.4 Año 2016
CONTENIDO
Introducción................................................................................................................................................ 2
Sobre el diseño de las clases ..................................................................................................................... 2
¿Cómo realizar el mapeo de objetos en Hibernate? ............................................................................... 3
¿Qué es XML? .............................................................................................................................................. 4
Sintaxis XML y reglas de uso ..................................................................................................................... 4
Declaración XML......................................................................................................................................................................... 4
Reglas de sintaxis de declaración XML .............................................................................................................................. 4
Las etiquetas y elementos ...................................................................................................................................................... 5
Las reglas de la sintaxis de las etiquetas y elementos............................................................................................. 5
Atributos ........................................................................................................................................................................................ 5
Reglas de sintaxis de atributos XML............................................................................................................................... 6
XML Referencias ......................................................................................................................................................................... 6
Texto XML ..................................................................................................................................................................................... 6
Ejemplo Simple XML ................................................................................................................................................................. 7
¿Qué es Hibernate?..................................................................................................................................... 8
¿Cómo configurar Hibernate? ................................................................................................................... 8
Empezando a persistir clases ...............................................................................................................................................10
Desglosando una clase en un archivo XML ........................................................................................... 11
¿Cómo mapeamos en nuestro XML las relaciones? .............................................................................. 13
Relación N a 1 ...........................................................................................................................................................................14
Relación 1 a N ...........................................................................................................................................................................16
Relación N a N ..........................................................................................................................................................................17
Generalización ...........................................................................................................................................................................19
Consideraciones a tener en cuenta con Hibernate ............................................................................... 22
Ejemplo Práctico ....................................................................................................................................... 24
Ay. Facundo Ciancio; Ay. Nicolás Minelli; Ay. Pablo Bismach. Coordinador: JTP. Ing Cristian Ghilardi 1
INTRODUCCIÓN
Hibernate es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma Java (y disponible
también para .Net con el nombre de NHibernate) que facilita el mapeo de atributos entre una base de datos
relacional tradicional y el modelo de objetos de una aplicación, mediante archivos declarativos (XML) o
anotaciones en los beans de las entidades que permiten establecer estas relaciones.
Hibernate es un framework que agiliza la relación entre la aplicación y la base de datos.
SOBRE EL DISEÑO DE LAS CLASES

Las clases de Java cuyos objetos o instancias serán almacenados en tablas de la base de datos se llaman
clases persistentes en Hibernate. Hibernate trabaja mejor si éstas clases se diseñan siguiendo simples reglas,
conocido modelo de programación POJO (Plain Old Java Object). Pueden darse las siguientes como reglas
principales de las clases persistentes, sin embargo, ninguna de éstas reglas es requerida estrictamente.
 Todas las clases de Java que serán persistidas necesitan un constructor por defecto.
 Todas las clases deberán contener un ID (OID) para permitir una fácil identificación de sus objetos
entre Hibernate y la base de datos. Esta propiedad se mapea a la clave primaria de la columna de la
tabla de la base de datos.
 Todos los atributos que van a ser persistidos deben ser declarados privados y tener sus métodos
getXXX y setXXX (isXXX para atributos booleanos) definidos en el estilo de JavaBean style.
El nombre de POJO se utiliza para enfatizar que un objeto dado es un Object ordinario de Java, no un
objeto especial, y en particular no un Enterprise JavaBean.
En el caso de las listas o colecciones los únicos métodos que se necesitan son get y set. Los métodos add
son para uso práctico del negocio.
package Entidades;
import Java.util.Date;
import Java.util.*;
public class Reposicion

{
private int numero;

private Date fecha;
private Estado estado;
private List<DetalleReposicion> detalleReposicionList = new ArrayList<>();
public Reposicion ()
{
}
public int getNumero ()

{
return numero;
}
public void setNumero (int numero)

{
this.numero = numero;
}
public Date getFecha ()

{
return fecha;
}
public void setFecha (Date fecha)

{
this.fecha = fecha;
}
public Estado getEstado ()

{
return estado;
}
public void setEstado (Estado estado)

{
this.estado = estado;
}
public List<DetalleReposicion> getDetalleReposicionList ()

{
return detalleReposicionList;
}
public void setDetalleReposicionList (List<DetalleReposicion> detalleReposicionList)

{
this.detalleReposicionList = detalleReposicionList;
}
public void addDetalleReposicionList (DetalleReposicion detalleReposicion)

{
detalleReposicionList.add(detalleReposicion);
}
¿CÓMO REALIZAR EL MAPEO DE OBJETOS EN HIBERNATE?

El mapeo de objetos al utilizar Hibernate se realiza por lo general en un documento XML. Este lenguaje
XML está centrado en Java, lo que significa que está construido alrededor de clases persistentes Java y no
tablas.
Muchos usuarios de Hibernate deciden escribir estos documentos a mano, pero sin embargo existen
algunas herramientas que permiten generarlos automáticamente, tales como XDoclet, Middlegen y
AndroMDA.
Por lo tanto, primero tendremos que tener una primera aproximación a XML para poder empezar a
comprender el tema.
¿QUÉ ES XML?
XML (Extensible Markup Language) es un lenguaje de etiquetas, es decir, cada paquete de información
está delimitado por dos etiquetas como se hace también en el lenguaje HTML, pero XML separa el contenido
de la presentación. XML se preocupa del significado del texto que encierra y no de la apariencia de cómo se
muestre el texto en la página web.
XML se plantea como un lenguaje estándar para el intercambio de información entre diferentes
programas de una manera segura, fiable y libre, ya que no pertenece a ninguna compañía.
XML no ha nacido sólo para su aplicación para Internet, sino que se propone como un estándar para el
intercambio de información estructurada entre diferentes plataformas. Se puede usar en bases de datos,
editores de texto, hojas de cálculo y casi cualquier cosa imaginable.
XML es una tecnología sencilla que tiene a su alrededor otras que la complementan y la hacen mucho
más grande y con unas posibilidades mucho mayores. Tiene un papel muy importante en la actualidad ya
que permite la compatibilidad entre sistemas para compartir la información de una manera segura, fiable y
fácil.
XML, con todas las tecnologías relacionadas, representa una manera distinta de hacer las cosas, más
avanzada, cuya principal novedad consiste en permitir compartir los datos con los que se trabaja a todos los
niveles, por todas las aplicaciones y soportes. Así pues, el XML juega un papel importantísimo en este mundo
actual, que tiende a la globalización y la compatibilidad entre los sistemas, ya que es la tecnología que
permitirá compartir la información de una manera segura, fiable, fácil. Además, XML permite al programador
y los soportes dedicar sus esfuerzos a las tareas importantes cuando trabaja con los datos, ya que algunas
tareas tediosas como la validación de estos o el recorrido de las estructuras corre a cargo del lenguaje y está
especificado por el estándar, de modo que el programador no tiene que preocuparse por ello.
SINTAXIS XML Y REGLAS DE USO

DECLARACIÓN XML
El documento XML puede tener una declaración XML. Está escrito, como se indica a continuación:
<?xml version="1.0" encoding="UTF-8"?>
Donde version es la versión de XML y encoding especifica la codificación de caracteres usada en el

documento.
REGLAS DE SINTAXIS DE DECLARACIÓN XML
 La declaración XML es sensible a mayúsculas y minúsculas y debe empezar por "<?xml>" donde "xml"
se escriben en minúsculas.
 Si el documento contiene declaración XML, estrictamente tiene que ser la primera declaración del
documento XML.
 La declaración XML debe ser estrictamente la primera declaración en el documento XML.
 Un protocolo HTTP puede alterar el valor de la codificación que se coloca en la declaración XML.
LAS ETIQUETAS Y ELEMENTOS
Un archivo XML está estructurado por varios elementos XML, también llamados XML-nodos o etiquetas
XML. Los nombres de los elementos están encerrados por corchetes triangulares < >, tal y como se indica a
continuación:
<element>
Las reglas de la sintaxis de las etiquetas y elementos

Sintaxis de Elemento: Cada elemento XML debe tener una etiqueta de inicio y una de fin:
<element>....</element>
O en el más simple de los casos, sólo en esta forma:

<element/>
Anidamiento de elementos: un documento XML puede contener varias etiquetas, pero estas no deben
superponerse entre sí, es decir, una etiqueta de cierre del elemento debe tener el mismo nombre que el de
la más reciente etiqueta de inicio sin precedentes.
Aquí se muestran las etiquetas anidadas de forma incorrecta:
<?xml version="1.0"?>
<contact-info>
<company>McDonald
</contact-info>
</company>
La manera correcta para las etiquetas anidadas es:

<?xml version="1.0"?>
<pelicula>
<titulo>Star Wars VI: El retorno del Jedi</titulo>
</pelicula>
Elemento raíz: Un documento XML sólo puede tener un elemento raíz. El siguiente no es un documento
XML correcto, ya que tanto los elementos x e y se producen en el nivel superior sin un elemento raíz:
<x>...</x>
<y>...</y>
El ejemplo siguiente muestra un documento XML con formato correcto:

<root>
<x>...</x>
<y>...</y>
</root>
Mayúsculas y minúsculas: Los nombres de los elementos XML son sensibles a las mayúsculas y
minúsculas. Esto significa que el nombre de los elementos de inicio y de final ser iguales.
Por ejemplo <pelicula> es diferente de <Pelicula>.
Comentarios: Se escriben de la misma forma que los de HTML
<!—Comentario-->
ATRIBUTOS
Un atributo especifica una propiedad para el elemento, utilizando un par nombre/valor. Un elemento
XML puede tener uno o más atributos. Por ejemplo:
<a href="http://www.facebook.com/">Facebook!</a>
Aquí href es el nombre del atributo y http://www.facebook.com/ es valor de atributo.
Reglas de sintaxis de atributos XML
 Nombres de atributos en XML (a diferencia del HTML) son sensibles a mayúsculas. Es
decir, HREF y href son dos atributos XML diferentes.
 Mismo atributo no puede tener dos valores en una sintaxis. El ejemplo siguiente muestra una sintaxis
incorrecta porque el atributo b se especifica dos veces:
<a b="x" c="y" b="z">....</a>
 Los nombres de los atributos se definen sin comillas, mientras que los valores de los atributos siempre
deben aparecer entre comillas. Ejemplo incorrecto:
<a b=x>....</a>
En la sintaxis anterior, el valor del atributo no está definido entre comillas.

XML REFERENCIAS
Por lo general las referencias permiten agregar o incluir texto adicional o de marcado en un documento
XML. Las referencias siempre comienzan con el símbolo "&", que es un carácter reservado y al final con el
símbolo ";". XML tiene dos tipos de referencias:
Referencias de entidad: Una referencia de entidad contiene un nombre entre el principio y el final
delimitando. Por ejemplo, & donde amp es nombre. El nombre se refiere a la cadena de texto predefinidos
y/o el marcado.
Referencias de caracteres: Estos contienen referencias, como A, contiene un hash (“#”) seguido de
un número. El número se refiere siempre al código Unicode de un carácter. En este caso, el 65 se refiere al
alfabeto "A".
TEXTO XML
 Los nombres de elementos XML y XML-atributos son sensibles a las mayúsculas y minúsculas, lo que
significa que el nombre de los elementos de inicio y fin deben ser iguales.
 Para evitar problemas de codificación, todos archivos XML debe guardarse como archivos Unicode
UTF-8 o UTF-16.
 Caracteres de espacio en blanco como los espacios en blanco, los tabuladores y line-breaks entre XML
y entre los elementos XML-atributos serán ignorados.
Caracteres no permitidos Sustitución de la entidad Descripción del caracter
< < Menos de
> > Mayor que
& & AMPERSAND
' ' Apóstrofe
" " Signo de interrogación
EJEMPLO SIMPLE XML
Observemos por qué el XML es tan interesante para el intercambio de datos con el siguiente ejemplo:
“Pedido para el señor Juan Delgado Martínez. El pedido se compone de una bicicleta A2023. A entregar
en la calle Barco 4, tercer piso, letra A, el día 19-5-2000.”
Podemos representar esta situación con un simple documento XML como el siguiente:
<PEDIDO>
<Destinatario>Juan Delgado Martínez</Destinatario>
<Articulo>bicicleta A2023</Articulo>
<Direccion>calle Barco 4, tercer piso, letra A</Direccion>
<Fecha>19-5-2000</Fecha>
</PEDIDO>
¿QUÉ ES HIBERNATE?
Como todas las herramientas de su tipo, Hibernate busca solucionar el problema de la diferencia entre
los dos modelos de datos coexistentes en una aplicación: el usado en la memoria de la computadora
(orientación a objetos) y el usado en las bases de datos (modelo relacional). Para lograr esto permite al
desarrollador detallar cómo es su modelo de datos, qué relaciones existen y qué forma tienen. Con esta
información Hibernate le permite a la aplicación manipular los datos en la base de datos operando sobre
objetos, con todas las características de la POO.
Hibernate convertirá los datos entre los tipos utilizados por Java y los definidos por SQL. Hibernate genera
las sentencias SQL y libera al desarrollador del manejo manual de los datos que resultan de la ejecución de
dichas sentencias, manteniendo la portabilidad entre todos los motores de bases de datos con un ligero
incremento en el tiempo de ejecución.
Hibernate está diseñado para ser flexible en cuanto al esquema de tablas utilizado, para poder adaptarse
a su uso sobre una base de datos ya existente. También tiene la funcionalidad de crear la base de datos a
partir de la información disponible.
Hibernate ofrece también un lenguaje de consulta de datos llamado HQL (Hibernate Query Language), al
mismo tiempo que una API para construir las consultas programáticamente (conocida como "criteria").
Hibernate para Java puede ser utilizado en aplicaciones Java independientes o en aplicaciones Java EE,
mediante el componente Hibernate Annotations que implementa el estándar JPA, que es parte de esta
plataforma.
¿CÓMO CONFIGURAR HIBERNATE?

Necesitamos un archivo xml de configuración el cual se llamará hibernate.cfg.xml y se ubicará en la
carpeta src de nuestro proyecto. Para ello vamos al lugar donde está guardado el proyecto:
Y luego dentro de la carpeta src colocamos el archivo como se muestra en la siguiente imagen:
Desde el panel del NetBeans el archivo hibernate.cfg.xml se visualizará de la siguiente forma:
Este archivo hibernate.cfg.xml contiene el nombre del driver para jdbc, la dirección de la base de
datos, su nombre y la contraseña y además dentro de las etiquetas mapping los archivos xml de las entidades
específicas que se mapearán, a continuación, se muestra un archivo xml de configuración:
<!DOCTYPE Hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/diseño</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.timeout">300</property>
<property name="hibernate.c3p0.max_statements">50</property>
<property name="hibernate.c3p0.idle_test_period">3000</property>

<mapping resource="estado.hbm.xml"/>
<mapping resource="articulo.hbm.xml"/>
<mapping resource="detallereposicion.hbm.xml"/>
<mapping resource="reposicion.hbm.xml"/>
<mapping resource="materia.hbm.xml"/>
<mapping resource="alumno.hbm.xml"/>
<mapping resource="persona.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Podemos ver que el fichero hibernate.cfg.xml es un típico fichero xml.

 En la línea 1 vemos la declaración de que es un fichero XML.
 En la línea 2 se aprecia la declaración del DOCTYPE junto con la referencia al
documento http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd, DTD que
permite validarlo. Es decir que si nos descargamos el fichero hibernate-configuration-
3.0.dtd podremos saber todos los elementos que hay en un fichero de mapeo.
 El tag raiz del documento xml se llama <hibernate-configuration> y se encuentra en la línea 3.
 Dentro del tag <hibernate-configuration> encontramos, en la línea 4, el tag <session-
factory> que contendrá la configuración de Hibernate.
 Las siguientes 5 líneas (desde la 5 a la 10) contienen propiedades de configuración mediante el
tag <property>
 El atributo name contiene el nombre de la propiedad de configuración.
 El contenido del tag <property> define el valor de la propiedad de configuración.
 Estas propiedades se usan para poder conectarse mediante JDBC a la base de datos.
Propiedad de
Explicación
configuración
El lenguaje de SQL que usará Hibernate contra la base de datos. Este parámetro es
opcional ya que Hibernate lo puede intentar deducir a partir de los datos de la conexión.
dialect Los posibles valores de esta propiedad de configuración son la FQCN de una clase Java
que extienda de la clase org.hibernate.dialect.Dialect. La lista de dialectos que
soporta Hibernate se encuentra en el paquete org.hibernate.dialect.
connection.driver_class Contiene la FQCN del driver de la base de datos a usar.
connection.url La URL de conexión a la base de datos tal y como se usa en JDBC
connection.username El usuario de la base de datos
connection.password La contraseña del usuario de base de datos
Propiedad opcional que indica si se mostrará por la consola la SQL que lanza Hibernate
contra la base de datos. Sus posibles valores son true o false. Esta propiedad es muy
hibernate.show_sql
útil mientras programamos ya que nos ayudará a entender cómo está funcionanado
Hibernate
 Las siguientes líneas contienen el tag <mapping> que se usa para indicarle a Hibernate las clases que
queremos usar desde Hibernate.
 El atributo resource contiene el nombre de un fichero .hbm.xml asociado a la clase que
queremos persistir. En nuestro caso del fichero estado.hbm.xml.
EMPEZANDO A PERSISTIR CLASES
Para cada clase que queremos persistir se creará un fichero xml con la información que permitirá mapear
la clase a una base de datos relacional. Tenemos dos opciones respecto a la ubicación del fichero:
1. Almacenar el fichero .hbm.xml en el mismo paquete que la clase Java a la que hace referencia.
2. Crear un árbol alternativo de paquetes donde almacenar los ficheros .hbm.xml. Por ejemplo, si
tenemos el paquete raíz com.miempresa.proyecto.dominio donde se guardan todas las clases Java
a persistir, crear otro paquete llamado com.miempresa.proyecto.persistencia donde almacenar
los ficheros .hbm.xml.
La ventaja de la segunda opción es que en caso de que no queramos usar Hibernate, simplemente hay
que borrar toda la carpeta com.miempresa.proyecto.persistencia y ya está, mientras que la ventaja de
la primera opción es que la clase Java y su correspondiente fichero de mapeo está más juntos facilitando en
caso de algún cambio en la clase Java el cambio en el fichero de mapeo.
En nuestro caso colocaremos cada uno de los ficheros .hbm.xml en la misma carpeta src. Veamos su
visualización desde el explorador:
Y ahora desde NetBeans:
DESGLOSANDO UNA CLASE EN UN ARCHIVO XML

Vamos a nombrar las principales etiquetas XML y para qué se usan. Posteriormente en otro ejemplo
veremos etiquetas más específicas para poder solucionar las relaciones entre las tablas.
Tenemos el siguiente ejemplo:
Las clases con el estereotipo de análisis entidad de nuestro modelo no tienen el atributo OID necesario
en los framework de persistencia. Para solucionar este problema, sin modificar las clases de negocio, podemos
definir una clase Entidad de la que heredaran todas las clases persistentes.
De esta forma todas las clases con el estereotipo entidad persistente tendrán como clase padre la clase
Entidad que contiene los métodos setOID y getOID. La clase Entidad no debe ser mapeada a través de un
XML; se utiliza solamente para agregar a las clases hijas el comportamiento correspondiente al OID.
El esquema quedaría de la siguiente forma:

<!DOCTYPE Hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="entidades.Articulo" table="articulo">
<id name="OID" type="string">

<column name="OIDArticulo"/>
<generator class="uuid2"/>
</id>
<property name="codigo" type="int">

<column name="codigo"/>
</property>
<property name="nombre" type="string">

<column name="nombre"/>
</property>
</class>
</hibernate-mapping>
 En la línea 1 vemos la declaración de que es un fichero XML.

 En la línea 2 se aprecia la declaración del DOCTYPE junto con la referencia al
documento http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd DTD que
permite validarlo.
Es decir que si nos descargamos el fichero hibernate-mapping-3.0.dtd podremos saber todos los
elementos que hay en un fichero de mapeo. Respecto a esta línea se puede decir que dependiendo
de la versión de Hibernate puede tener algunos leves cambios, por lo tanto, en caso de tener una
versión distinta lo que debemos hacer es ingresar a la página de Hibernate hibernate.org para
poder obtener esta dirección.
 El document XML tiene las etiquetas <hibernate-mapping> como el element raíz que contiene
todos los elementos <class>.
 Los elementos <class> se usan para definir mapeos específicos de clases Java a tablas de la base
datos. El nombre de la clase Java se especifica en el atributo name del element clase y el nombre de
la tabla de la base de datos se especifica usando usando el atributo table.
 El elemento <meta> es opcional y puede ser usado para crear una descripción de la clase en cuestión.
 El elemento <id> mapea el atributo ID único de la clase en la clave primaria de tabla de la base de
datos. El atributo name del elemento id se refiere a la propiedad de la clase, en este caso OID, que se
hereda de la clase Entidad; y el atributo column hace referencia a la columna de la base de datos. El
atributo type contiene el tipo de mapeo de Hibernate, este tipo de mapeo convertirá desde Java a
un dato de tipo SQL.
 El elemento <property> es usado para mapear un atributo de la clase Java en una columna de la
table de la base de datos. El atributo name del elemento id se refiere a la propiedad de la clase y el
atributo column hace referencia a la columna de la base de datos. El atributo type contiene el tipo
de mapeo de Hibernate, este tipo de mapeo convertirá desde Java a un dato de tipo SQL.
¿CÓMO MAPEAMOS EN NUESTRO XML LAS RELACIONES?

Esto lo realizamos de una manera simple, que varía ligeramente dependiendo del tipo de relación. Dado
que por lo general y en casi la totalidad de los casos no utilizamos relaciones bidireccionales debemos indicar
la cardinalidad de nuestra relación en el documento XML de la clase fuente de la relación. Esto quedará más
claro con los siguientes ejemplos.
Teniendo en cuenta el diagrama de clases:
Y el siguiente Diagrama Entidad Relación:
Estado = OIDEstado + codigo + nombre

Articulo = OIDArticulo + codigo + nombre
Reposicion = OIDReposicion + fecha + numero + OIDEstado
DetalleReposicion = OIDDetalleReposicion + cantidad + OIDArticulo + OIDReposicion
Teniendo en cuenta que los atributos subrayados son las claves primarias y los atributos con líneas
discontinuas son las claves foráneas.
RELACIÓN N A 1
Supongamos una relación N a 1 tal como la de DetalleReposicion a Articulo.
El modelo entidad relación que representa esta relación sería el siguiente.
Articulo = OIDArticulo + codigo + nombre

DetalleReposicion = OIDDetalleReposicion + cantidad + OIDArticulo
Tenemos que el archivo xml correspondiente a DetalleReposicion es:
<hibernate-mapping>
<class name="entidades.DetalleReposicion" table="detallereposicion">

<column name="OIDDetalleReposicion"/>
</id>
<property name="cantidad" type="int">

<column name="cantidad"/>
</property>
<many-to-one name="articulo" class="entidades.Articulo" column="OIDArticulo" not-

null="true"/>
</class>
Nos centraremos en la última etiqueta. La frase many-to-one es la que nos indica que la tabla
detallereposicion tendrá una relación N a 1 con la entidad artículo, y esta relación se mapeará en la
columna llamada OIDArticulo que hará referencia al OID de la tupla correspondiente en la tabla articulo.
El elemento name es el nombre del atributo articulo de las clases Java. El elemento class es para indicar
cómo se llama la clase de la relación y el not-null se usa para decir que la columna OIDArticulo no puede
estar vacía.
Veamos el XML de la entidad Articulo:
<hibernate-mapping>
<class name="entidades.Articulo" table="articulo">

<column name="OIDArticulo"/>
</id>
<property name="codigo" type="int">

<column name="codigo"/>
</property>

</property>
</class>
Como podemos observar aquí no hay ninguna etiqueta que haga referencia a la entidad
DetalleReposicion que la referencia, lo cual es correcto ya que el detalle conoce al artículo y no al revés.
RELACIÓN 1 A N
Ahora pasemos a una relación 1 a N:
Su modelo entidad-relación sería el siguiente:
Reposicion = OIDReposicion + fecha + numero + OIDEstado

DetalleReposicion = OIDDetalleReposicion + cantidad + OIDArticulo + OIDReposicion
Veamos el XML de la entidad Reposicion:

<hibernate-mapping>
<class name="entidades.Reposicion" table="reposicion">

<column name="OIDReposicion"/>
</id>
<property name="numero" type="int">

<column name="numero"/>
</property>
<property name="fecha" type="date">

<column name="fecha"/>
</property>
<many-to-one name="estado" class="entidades.Estado" column="OIDEstado"

not-null="true"/>
<bag name="detalleReposicionList" table="detallereposicion" cascade="none"

inverse="false">
<key column="OIDReposicion" not-null="true"/>
<one-to-many class="entidades.DetalleReposicion"/>
</bag>
</class>
Como la reposición contiene una lista de detalles reposición en el documento XML debemos utilizar las
etiquetas bag, la cual es una colección Java que no tiene en cuenta el orden de sus elementos y permite que
haya duplicados. El elemento name nos dice que en las clases Java esta relación se da mediante el atributo
detalleReposiciónList. El elemento cascade=”none” significa que al guardarse la reposición en la base
de datos no se guardarán también sus detalles, lo cual resulta lógico ya que es una relación de agregación.
En caso de tratarse de una composición el elemento cascade será igual a “save-update” para indicar
que cuando se guarde la reposición se guarden todos los detalles.
El elemento table hace referencia al nombre de la tabla de la relación, en este caso
“detallereposicion”. Luego tenemos la etiqueta key, aquí tenemos un poco más de complejidad, ya que
si bien en el modelo de clases la reposición conoce a los detalles en el modelo relacional o de base de datos
las claves foráneas se guardan en el lado de la relación que tiene cardinalidad n; es por ello que tenemos que
indicar que en la tabla detallereposicion habrá una columna llamada OIDReposicion que contendrá el
OID de la Reposicion correspondiente. Luego vienen las etiquetas one-to-many para indicar que la clase a
la que se hará referencia será DetalleReposicion.
Como vimos en la otra imagen en el documento xml de la entidad DetalleReposicion no hay ninguna
referencia a la Reposicion, lo cual es correcto ya que el detalle no conoce a la Reposicion en el diagrama
de clases.
RELACIÓN N A N
Supongamos la siguiente relación N a N con su correspondiente diagrama de clases:
Y el siguiente MER:
Alumno = OIDAlumno + nombre + apellido

Materia = OIDMateria + nombre + horasSemanales
AlumnoMateria = OIDAlumno + OIDMateria
Podemos observar que aparece una clave intermedia entre Alumno y Materia, ya que a nivel de modelo
entidad relación las relaciones N a N se modelan con una tabla intermedia, en este caso se llama
AlumnoMateria, y contiene los OID de las Materias y los Alumnos. Cada registro de esta tabla contendrá el
OID de un alumno junto con el OID de la respectiva materia que esté cursando, en caso de cursar más de una
materia existirán dos tuplas, cada una con el mismo OIDAlumno y con distinto OIDMateria.
Veamos el documento XML de Materia:
<hibernate-mapping>
<class name="entidades.Materia" table="materia">

<column name="OIDMateria"/>
</id>

</property>
<property name="horasSemanales" type="int">

<column name="horasSemanales"/>
</property>
</class>
Podemos observar que no hay ninguna complicación. Ahora veamos el XML de Alumno:
<hibernate-mapping>
<class name="entidades.Alumno" table="alumno">

<column name="OIDAlumno"/>
</id>

</property>
<property name="apellido" type="string">
<column name="apellido"/>
</property>
<bag name="materiaList" table="alumnomateria" cascade="none">

<key column="OIDAlumno" not-null="true"/>
<many-to-many class="entidades.Materia" column="OIDMateria"/>
</bag>
</class>
Como la clase Alumno es la que conoce a la clase Materia tenemos que mapear la relación en el XML
de la entidad Alumno. Las etiquetas bag son para indicar que el Alumno tendrá una lista de materias. Dentro
encontramos una propiedad llamada table, que toma el valor “alumnomateria”, lo que indica que se creará
una tabla intermedia con este nombre. Luego tenemos la etiqueta para key con la propiedad
column=”OIDAlumno” lo cual significa que habrá una columna “OIDAlumno” en la tabla “alumnomateria”,
que adoptará el valor del OID de la tabla original “Alumno” (en este caso adoptará el OID del Alumno en
cuestión). La propiedad not-null=”true” es para indicar que este atributo no puede ser nulo. Luego
tenemos las etiquetas many-to-many en la cual se indica que esta tabla intermedia tendrá otra columna que
se llamará “OIDMateria” y que apuntará a la clave primaria de la clase “Materia” (La palabra Entidades
es sólo para indicar el paquete donde se encuentra la clase Materia).
GENERALIZACIÓN
Por último, nos queda ver como mapear las relaciones de generalización. Observemos el siguiente
diagrama de clases:
Vale la pena aclarar que Persona no es abstracto, por lo tanto, en nuestro modelo podemos tener
Personas, Clientes y Empleados.
El siguiente es el Modelo Entidad Relación:
Persona = OIDPersona + nombre + dni + fechaNacimiento + tipo

Cliente = OIDCliente + numero
Empleado = OIDEmpleado + legajo
Para mapear este tipo de relación necesitamos un solo documento XML.
<hibernate-mapping>
<class name="entidades.Persona" table="persona">

<column name="OIDPersona"/>
</id>
<property name="dni" type="long">

<column name="dni"/>
</property>
<property name="fechaNacimiento" type="date">

<column name="fechaNacimiento"/>
</property>

</property>
<property name="tipo" type="string">

<column name="tipo"/>
</property>
<joined-subclass name="entidades.Cliente" table="cliente">
<key column="OIDCliente"/>
<property name="numero" type="int">

<column name="numero"/>
</property>
</joined-subclass>
<joined-subclass name="entidades.Empleado" table="empleado">
<key column="OIDEmpleado"/>
<property name="legajo" type="long">

<column name="legajo"/>
</property>
</joined-subclass>
</class>
La entidad que se mapea es la de la superclase, en este caso Persona. Podemos observar que tiene una
columna que se llamará tipo, que sirve para identificar qué tipo de Persona será, este puede ser Persona,
Empleado o Cliente.
Para indicar que existirán entidades hijas de la entidad Persona utilizamos las etiquetas joined-
subclass, que tiene una propiedad name para indicar cuál será la clase que mapearemos y otra
propiedad llamada table para decir que se mapeará en una tabla llamada cliente. Dentro de las
etiquetas joined-subclass tenemos la etiqueta key con el atributo column=“OIDNombreSubClase”
para indicar que habrá una columna llamada OID que adoptará el mismo valor que el OID de la
entidad Persona. ¿Qué quiere decir esto? Que cuando guardemos un objeto cliente se guardarán los
atributos que hereda de persona en una tupla de la tabla persona, que tendrá un determinado OID,
el cual será el mismo que el OID de la tupla en la tabla cliente que se creará. En esta tabla cliente
estarán también las columnas con los atributos correspondientes al Cliente. Lo mismo ocurrirá en
caso de que deseemos guardar un Empleado. En caso de que guardemos un objeto que sea
simplemente una persona sólo se guardará el objeto en una tupla en la tabla persona.
Luego de la etiqueta key tenemos las etiquetas property que indicarán como se mapean los atributos
específicos de la clase en cuestión en sus columnas correspondientes.
CONSIDERACIONES A TENER EN CUENTA CON HIBERNATE

Para poder utilizar correctamente Hibernate deberemos implementar una clase utilitaria llamada
HibernateUtil la cual se encargará de manejar las sesiones y las transacciones de nuestros casos de uso. A
continuación, se expone el código de dicha clase:
import org.hibernate.*;
import org.hibernate.boot.registry.*;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.*;
public class HibernateUtil

{
private static SessionFactory sessionFactory;
public HibernateUtil ()
{
}
private static SessionFactory buildSessionFactory ()

{
Configuration configuration = new Configuration();
configuration.configure();
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(
configuration.getProperties()).build();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
public static SessionFactory getSessionFactory ()

{
if (sessionFactory == null || sessionFactory.isClosed())
{
sessionFactory = buildSessionFactory();
}
return sessionFactory;
}
public static Session getSession ()

{
if (sessionFactory == null || sessionFactory.isClosed())
{
sessionFactory = getSessionFactory();
}
try
{
return sessionFactory.getCurrentSession();
}
catch (NullPointerException e)
{
return sessionFactory.openSession();
}
}
También especificaremos el código de la FachadaInterna que se encargará de realizar las acciones con
Hibernate. El código se especifica a continuación:
import java.util.*;
import org.hibernate.*;
import org.hibernate.criterion.*;
public class FachadaInterna

{
private static FachadaInterna fachadaInterna;
public FachadaInterna ()
{
}
public static FachadaInterna getInstance ()

{
if (fachadaInterna == null)
{
fachadaInterna = new FachadaInterna();
}
return fachadaInterna;
}
public List<Object> buscar (String claseABuscar, List<DTOCriterio> criterioList)

{
Criteria cr = null;
try
{
cr = HibernateUtil.getSession().createCriteria(Class.forName("entidades." +
claseABuscar), claseABuscar.toLowerCase());
}
catch (ClassNotFoundException e)
{
System.out.println("Error creating criteria. " + e);
}
if (criterioList != null)
{
for (DTOCriterio criterio : criterioList)
{
String atributo = criterio.getAtributo();
String operacion = criterio.getOperacion();
Object valor = criterio.getValor();
switch (operacion)
{
case "=":
cr.add(Restrictions.conjunction(Restrictions.eq(atributo, valor)));
break;
case "<":
cr.add(Restrictions.conjunction(Restrictions.lt(atributo, valor)));
break;
case ">":
cr.add(Restrictions.conjunction(Restrictions.gt(atributo, valor)));
break;
case "<=":
cr.add(Restrictions.conjunction(Restrictions.le(atributo, valor)));
break;
case ">=":
cr.add(Restrictions.conjunction(Restrictions.ge(atributo, valor)));
break;
case "<>":
cr.add(Restrictions.conjunction(Restrictions.ne(atributo, valor)));
break;
case "contains":
//Todas las colecciones deben empezar de la siguiente manera:
claseColeccionList
//Generamos el nombre de esa colección a partir del atributo
String lista = String.valueOf(atributo.charAt(0))
.toLowerCase() + atributo.substring(1) + "List"; //materiaList,
detalleReposicionList
cr.createAlias(lista, "lista")
.add(Restrictions.conjunction(Restrictions.eq("lista.OID" +
claseABuscar, ((entidades.Entidad) valor).getOID())));
break;
}
}
}
return cr.list();
public void guardar (Object objeto)

{
HibernateUtil.getSession().save(objeto);
}
public void iniciarTransaccion ()

{
HibernateUtil.getSession().beginTransaction();
}
public void finalizarTransaccion ()

{
HibernateUtil.getSession().getTransaction().commit();
HibernateUtil.getSession().close();
HibernateUtil.getSessionFactory().close();
}
}
EJEMPLO PRÁCTICO
A continuación, mostraremos un ejemplo práctico a partir de una secuencia sin aplicar ningún framework
de persistencia, luego veremos dicha secuencia con Hibernate aplica y por último se adjuntará el código
correspondiente al experto de ejercicio.
Ahora la secuencia aplicando Hibernate sería la siguiente:
Y el código correspondiente al experto del ejercicio es el siguiente:
public class Experto
{
public void Metodo ()

{
List<DTOCriterio> criterioList = new ArrayList<>();
DTOCriterio criterio1 = new DTOCriterio();
criterio1.setAtributo("numero");
criterio1.setOperacion("=");
criterio1.setValor(3);
criterioList.add(criterio1);
Reposicion reposicion = (Reposicion)

FachadaPersistencia.getInstance().buscar("Reposicion", criterioList).get(0);
//Acá se realizan los gets que no afectan en nada

Estado estado = reposicion.getEstado();
int codigoEstado = estado.getCodigo();
for(DetalleReposicion detalleReposicion : reposicion.getDetalleReposicionList())
{
detalleReposicion.getCantidad();
Articulo articulo = detalleReposicion.getArticulo();
articulo.getCodigo();
}
Reposicion nueva = new Reposicion();

nueva.setFecha(new Date());
nueva.setNumero(6);

criterio2.setAtributo("codigo");
criterioList.clear();
Estado e = (Estado) FachadaPersistencia.getInstance().buscar("Estado",

criterioList).get(0);
nueva.setEstado(e);
DetalleReposicion nuevoDetalle = new DetalleReposicion();

nuevoDetalle.setCantidad(5);

criterio3.setAtributo("codigo");
criterioList.clear();
Articulo a = (Articulo) FachadaPersistencia.getInstance().buscar("Articulo",

criterioList).get(0);
nuevoDetalle.setArticulo(a);
reposicion.addDetalleReposicionList(nuevoDetalle);
FachadaPersistencia.getInstance().guardar(nueva);
FachadaPersistencia.getInstance().guardar(nuevoDetalle);
}

Hibernate y XML

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Hibernate y XML

Încărcat de

Drepturi de autor:

Formate disponibile

Diseño de

HIBERNATE Y XML Sistemas

Ay. Facundo Ciancio

SOBRE EL DISEÑO DE LAS CLASES

public class Reposicion

private int numero;

public int getNumero ()

public void setNumero (int numero)

public Date getFecha ()

public void setFecha (Date fecha)

public Estado getEstado ()

public void setEstado (Estado estado)

public List<DetalleReposicion> getDetalleReposicionList ()

public void setDetalleReposicionList (List<DetalleReposicion> detalleReposicionList)

public void addDetalleReposicionList (DetalleReposicion detalleReposicion)

¿CÓMO REALIZAR EL MAPEO DE OBJETOS EN HIBERNATE?

SINTAXIS XML Y REGLAS DE USO

Donde version es la versión de XML y encoding especifica la codificación de caracteres usada en el

Las reglas de la sintaxis de las etiquetas y elementos

O en el más simple de los casos, sólo en esta forma:

La manera correcta para las etiquetas anidadas es:

El ejemplo siguiente muestra un documento XML con formato correcto:

En la sintaxis anterior, el valor del atributo no está definido entre comillas.

Caracteres no permitidos Sustitución de la entidad Descripción del caracter

< &lt; Menos de

> &gt; Mayor que

& &amp; AMPERSAND

' &apos; Apóstrofe

" &quot; Signo de interrogación

¿CÓMO CONFIGURAR HIBERNATE?

Desde el panel del NetBeans el archivo hibernate.cfg.xml se visualizará de la siguiente forma:

Podemos ver que el fichero hibernate.cfg.xml es un típico fichero xml.

Y ahora desde NetBeans:

DESGLOSANDO UNA CLASE EN UN ARCHIVO XML

<?xml version="1.0" encoding="UTF-8"?>

<class name="entidades.Articulo" table="articulo">

<id name="OID" type="string">

<property name="codigo" type="int">

<property name="nombre" type="string">

 En la línea 1 vemos la declaración de que es un fichero XML.

¿CÓMO MAPEAMOS EN NUESTRO XML LAS RELACIONES?

Y el siguiente Diagrama Entidad Relación:

Estado = OIDEstado + codigo + nombre

El modelo entidad relación que representa esta relación sería el siguiente.

Articulo = OIDArticulo + codigo + nombre

Tenemos que el archivo xml correspondiente a DetalleReposicion es:

<class name="entidades.DetalleReposicion" table="detallereposicion">

<id name="OID" type="string">

<property name="cantidad" type="int">

<many-to-one name="articulo" class="entidades.Articulo" column="OIDArticulo" not-

<class name="entidades.Articulo" table="articulo">

<id name="OID" type="string">

<property name="codigo" type="int">

<property name="nombre" type="string">

Su modelo entidad-relación sería el siguiente:

Reposicion = OIDReposicion + fecha + numero + OIDEstado

Veamos el XML de la entidad Reposicion:

<class name="entidades.Reposicion" table="reposicion">

<id name="OID" type="string">

<property name="numero" type="int">

<property name="fecha" type="date">

<many-to-one name="estado" class="entidades.Estado" column="OIDEstado"

<bag name="detalleReposicionList" table="detallereposicion" cascade="none"

< < Menos de

> > Mayor que

& & AMPERSAND

' ' Apóstrofe

" " Signo de interrogación