Quin debera leer este libro

Este libro cubre el Framework de hibernacin desde cero. Si usted est buscando una
introduccin breve, dulce y sencilla de Hibernate, impulsado principalmente por
ejemplos, este libro es para usted. Si usted tiene slo un fin de semana para pasar el
aprendizaje del Framework antes de iniciar un proyecto de Hibernate el lunes, este
libro es lo que ms le conviene. Si est familiarizado con el Framework, pero oxidado
con los detalles, este es un buen repaso!
Si usted es un desarrollador de Hibernate sazonada, este libro probablemente no es
para ti; se destina principalmente a traer a alguien al da en la tecnologa (pero no
dude en echar un vistazo a travs de, usted puede encontrar algo interesante!).
Una nota de precaucin: este libro no es en absoluto una biblia en el Framework de
hibernacin. He intentado muy duro para condensar el material en unas 100 pginas.
Si usted est buscando para los conceptos muy avanzados, no recomendara este
libro.
Por qu escrib este libro
Creo que hay dos niveles de aprendizaje, al igual que una comida de dos platos. El
primer curso es simple y fcil, pero crea expectativas para un segundo plato apetitoso.
No slo satisface nuestra hambre, hasta cierto punto, pero tambin nos da una idea
de lo que est por venir en el segundo curso.
Muchos libros ofrecen comidas de dos cursos de una sola vez. Esto es grande para
muchos de nosotros. Sin embargo, en mi opinin, es posible que no tenga tiempo o el
espacio adecuado para conocer las profundidades de la recta tecnologa.
Creo en servir una comida de primer curso, atrayente, apetitoso, que convence a los
huspedes a permanecer durante el segundo curso. Es una tarea difcil ya veces
desalentador para servir a este tipo de comida!
Trabajar con mi hijo de siete aos de edad, hijo, Joshua, en su tarea me ayud a
entender lo importante (y difcil) es para ensear conceptos bsicos y fundamentos de
una manera sencilla y fcil. Agarr incluso los temas ms difciles de forma rpida
cuando llegu a su nivel, explicando con ejemplos y lenguaje fcil de entender.
Hay personas que estn realmente interesados en el aprendizaje de la tecnologa,
pero pueden se deje intimidar por los grandes textos o manuales. Estas personas son
entusiastas y quieren comenzar a ejecutar, pero no tienen el tiempo o la paciencia
para leer y digerir volmenes de datos! Slo tienen tiempo para leer un libro sencillo,
aprender la tecnologa, y saltar directamente a la prctica. Una vez que consiguen la
cada de ella, su materia gris pedir ms y ms.
Cuando quiero aprender algo nuevo, empiezo a experimentar con el cdigo bsico,
mueva una pulgada ms, quemar un poco de cdigo, y as sucesivamente. Una vez
que tengo una sensacin para el Framework, me dirijo a otras vas para saciar mi sed.
En ese momento, yo busco los avanzados, manuales en profundidad y caractersticas,
y por supuesto, los grandes libros.
Este libro debe darle suficiente conocimiento y la confianza para empezar a trabajar
en proyectos del mundo real.

Cmo est organizado este libro

El libro se presenta en ocho captulos simples. Cada captulo se ocupar de uno o dos
temas especficos. Todos los captulos son presentados con fragmentos de cdigo para
ilustrar la tecnologa en detalle. Usted debe descargar y trabajar en estrecha
colaboracin con el cdigo fuente que acompaa.
La organizacin y los objetivos de los captulos son los siguientes:
Captulo 1, Fundamentos
En este captulo se establece el escenario para el uso de Hibernate. Definimos el
dominio del problema, encontrar una solucin utilizando JDBC, y re disear el
problema empleando Hibernate. Tendremos el gusto del Framework de un nivel muy
alto.
Captulo 2, Fundamentos
Usted aprendi sobre el problema de Hibernate est tratando de resolver en el primer
captulo. Aqu, en el segundo captulo, nos sumergimos en el Framework de explorar
sus partes mviles y su trabajo en la accin. Caminamos a travs de Hibernate piezas
fundamentales en detalle.
Captulo 3, Anotaciones
En este captulo, nos centraremos en la creacin de aplicaciones de Hibernate
utilizando anotaciones. Este captulo cubre los aspectos bsicos de las anotaciones,
saltar a las anotaciones de Hibernate que vamos a estar utilizando en el resto del
libro.
Captulo 4, persistiendo Colecciones
La persistencia de las colecciones es una tarea difcil para los desarrolladores. Este
captulo est dedicado a ayudar a entender la mecnica de la persistencia y la forma
de trabajar con las colecciones.
Captulo 5, Asociaciones
Usted aprender acerca de la compatibilidad de Hibernate para las asociaciones y
relaciones en este captulo. Cubre las asociaciones fundamentales, como uno-amuchos y muchos-a-muchos, con ejemplos pertinentes. Trat de mantener este
captulo tan delgado como sea posible, pero dada la magnitud del material pertinente,
me perd un poco mi objetivo!
Captulo 6, Conceptos Avanzados
Este captulo trata de unos conceptos avanzados tales como el almacenamiento en
cach, estrategias de herencia, tipos y filtros. Debe ejecutar este captulo para
obtener una mejor comprensin de la estructura y lo que ofrece en relacin a la
herencia, el almacenamiento en cach, y otras caractersticas.
Captulo 7, Hibernate Query Language
De manera similar a SQL, Hibernate expone su propio lenguaje de consulta para
trabajar con objetos. Este captulo es una introduccin a HQL y le gua a travs de la
API con ejemplos.
Captulo 8, Java Persistence API

Este captulo se centra en un estndar en el mundo Java Persistence, JPA, a la vista de

hibernate. Se discute el apoyo de Hibernate en la aplicacin de las normas de la APP y
cmo podemos utilizarlas en nuestras aplicaciones.
Utilizando Ejemplos de cdigo
Material Suplementario (ejemplos de cdigo, ejercicios, etc.) est disponible para su
descarga en https://github.com/madhusudhankonda/jh.git.
Este libro est aqu para ayudarle a hacer su trabajo. En general, los ejemplos de
cdigo que se ofrecen con este libro, usted puede utilizarlos en sus programas y la
documentacin.
Captulo 1
Fundamentos
Hay dos mundos de software diferentes: uno es el mundo Java, donde nada menos
que los objetos son conocidos, mientras que el otro es el mundo base de datos
relacional, donde los datos es el rey.
Los desarrolladores de Java siempre funcionan con objetos que representan el estado
y el comportamiento modelado de problemas del mundo real. La persistencia de
objetos es un requisito fundamental de las aplicaciones Java. El estado es el modelo
que se persiste en el almacenamiento duradero por lo que ser permanente.
Por otro lado, cuando es hora de almacenar los datos, tenemos que confiar en las
bases de datos relacionales, donde los datos se representan tradicionalmente en un
formato de fila-columna con las relaciones y asociaciones. Llevar objetos Java en el
mundo relacional es siempre una tarea difcil y compleja para los desarrolladores de
Java. Este proceso se refiere a menudo como el mapeo objeto-relacional (ORM).
En este captulo se establecen los fundamentos para nuestra discusin de Hibernate,
primero buscando en el dominio del problema de la persistencia de objetos. Vamos a
explorar las tecnologas y herramientas, tales como JDBC e Hibernate, que nos ayudan
a hacer frente a este desafo. Vamos a comparar y contrastar estas dos tecnologas y
aprender como Hibernate logra mapeo objeto-relacional de persistencia con facilidad y
comodidad.
Nacimiento de Hibernate
Digamos que estamos diseando un sistema de banca en lnea. Esperamos que el
banco para mantener una copia de seguridad de nuestras cuentas, datos personales,
preferencias y transacciones. Esto significa, con el fin de ser duraderos, los datos de
aplicacin debe ser persisti a un espacio de almacenamiento permanente. En el
contexto de esta aplicacin bancaria, por los datos persistentes me refiero a los
clientes, direccin, cuenta y otros objetos de dominio que podemos haber modelados
en nuestro diseo. Los datos que se ha persistido por su aplicacin sobrevivir a la
aplicacin en s, por ejemplo, que puede haberse movido fuera de lnea para la banca
telefnica, pero los datos creados por nuestra aplicacin banco an debe ser visible o
disponible si se requiere.
As que, ahora sabemos que la persistencia de los objetos (su estado es el dato que
tenemos que persistir) es un requisito fundamental para la mayora de aplicaciones
del mundo real. Para guardar los datos, necesitamos espacios de almacenamiento
duraderos llamados bases de datos. Hay una gran cantidad de proveedores de bases
de datos (tales como Oracle, MySQL, DB2, Java DB, y otros) con una larga lista de
comodidades y lujos.

Cmo podemos persistir un grfico de objetos a una base de datos?

Las empresas emplean lenguajes orientados a objetos (como Java) como sus
plataformas de programacin y bases de datos relacionales (como Oracle, MySQL,
Sybase, etc.) para el almacenamiento de datos. La existencia de estas dos tecnologas
de software es una necesidad para la mayora de aplicaciones del mundo real, a pesar
de la llamada "impedancia desajuste objeto-relacional." Vamos a hablar de la falta de
coincidencia en el prximo captulo en detalle, pero para darle una introduccin, voy a
explicar sus principales puntos aqu:
La herencia es el principio fundamental de la programacin orientada a objetos
sin el cual las asociaciones de objetos sera imposible disear. Las bases de
datos no entienden la herencia.
Cuando se trata del rico conjunto de asociaciones de objetos como uno-a-uno,
uno-a-muchos y muchos-a-muchos, bases de datos decae, ya que no pueden
soportar todo tipo de relaciones.
Por ltimo, tambin hay una falta de coincidencia de identidad: los objetos
llevan tanto una identidad y la igualdad, mientras que los registros de base de
datos se identifican con sus valores de columna.
Desarrolladores mitigan estas diferencias mediante el empleo de diversos Frameworks
de cosecha propia y otras soluciones tcnicas y estrategias.
Java tiene una herramienta estndar establecido para el acceso a bases de datos. Se
llama el Java Database Connectivity (JDBC) Interfaz de programacin de aplicaciones
(API). El API fue muy bien utilizado en aplicaciones Java hasta hace poco. Mientras que
el API es muy adecuado para pequeos proyectos, se convierte bastante engorroso (y
a veces fuera de la mano) como el modelo de dominio aumenta en la complejidad. La
API tambin incluye una gran cantidad de cdigo repetitivo, lo que requiere el
desarrollador para hacer un montn de codificacin manual. Adems, el manejo del
mapeo objeto-relacional es demasiado torpe!
Este fue el punto de dolor para los desarrolladores: que todos deseamos una sencilla
herramienta para persistir los datos sin tanta molestia. El equipo de Hibernate
encontr los huecos en el espacio de mapeo ORM y aprovech mediante la creacin
de un Framework sencillo que hara que fcil el desarrollo de aplicaciones.
Fue entonces cuando naci Hibernate! Hibernate se convirti en un xito instantneo y
es sin duda la herramienta de cdigo abierto ms popular en el dominio de las
herramientas ORM. El Framework fue adoptado durante la noche por la comunidad por
su sencillez y potentes caractersticas.
mbito del problema
Antes de saltar a la exploracin de Hibernate en detalle, vamos a ver un ejemplo del
tipo de problema que Hibernate se invent para resolver.
Todos nosotros (bueno, al menos la mayora de nosotros!) Le encanta ver pelculas.
Obviamente, no tenemos todo el tiempo del mundo para ver esas pelculas cuando
llegan a la pantalla. As creamos una "lista de deseos" de las pelculas que nos
gustara ver. Por esta razn, nos despertamos una maana y decidimos escribir una
sencilla aplicacin llamada JustMoviez! Se trata de una aplicacin basada en web que
permite a los usuarios suscribirse por cuenta propia para crear su lista de pelculas
deseadas por ver. Pueden volver a la pgina web en cualquier momento para agregar,
modificar o eliminar las pelculas en su lista de deseos. Como tenemos que almacenar
la lista de cada usuario, es imprescindible que almacenamos esta lista de deseos en el
almacenamiento duradero, como una base de datos.

Primero vamos a crear una aplicacin Java sencilla para almacenar y recuperar
pelculas desde una base de datos.
Aplicacin MovieManager
Considere la posibilidad de una aplicacin Java llamada MovieManager cuyo trabajo
principal es guardar, encontrar y recuperar las pelculas desde una base de datos.
Adems de la codificacin de la aplicacin Java, necesitamos una tabla de base para
almacenar la informacin de la pelcula. Esta tabla MOVIES almacenar los datos sobre
pelculas como filas, como se muestra en la Tabla 1-1.

Cada fila representar

VanillaMovieManager.

una

instancia

de

la

pelcula

en

nuestra

aplicacin

Hagamos de cuenta que vivimos en un mundo sin Hibernate. Vamos a escribir un

cdigo de ejemplo utilizando JDBC que, con suerte, cumplir con nuestros requisitos.
El uso de JDBC
El primer paso en cualquier aplicacin de base de datos es establecer una conexin
con la base de datos. Una conexin es una puerta de entrada a la base de datos para
la realizacin de las operaciones sobre los datos de una aplicacin Java. JDBC
proporciona una API de conexin para crear conexiones basadas en las propiedades de
base de datos que nos ofrecen. Los proveedores de bases de datos suelen
implementar una clase que tiene el mecanismo de ejemplo para la conexin de base
de datos, para la base de datos MySQL, esta clase es com.mysql.jdbc.Driver y de la
base de datos JavaDB (derby) es org.apache.derby.jdbc.EmbeddedDriver.
Tenga en cuenta que utilizamos la base de datos MySQL a travs del libro.
Consulte "Configuracin de Hibernate" en la pgina 14 para obtener detalles
sobre cmo configurar el proyecto y las bases de datos.
El mtodo CreateConnection, que se muestra en el siguiente fragmento, demuestra
el procedimiento para crear una conexin de base de datos:
public class VanillaMovieManager {
private Connection connection = null;
// Database properties
private String url = "jdbc:mysql://localhost:3307/JH";
private String driverClass = "com.mysql.jdbc.Driver";
private String username = "mkonda";
private String password = "mypass";
...
private Connection getConnection() {
try {
Class.forName(driverClass).newInstance();
connection = DriverManager.getConnection(url, username, password);
} catch (Exception ex) {
System.err.println("Exception:"+ ex.getMessage());
}
return connection;
}
}

En este fragmento, primero se genera una instancia de la clase del controlador y, a

continuacin, obtener una conexin utilizando el DriverManager.
Una vez que hemos establecido nuestra conexin con la base de datos con xito,
nuestro siguiente paso es escribir un mtodo para persistir y consultar una entidad de
la pelcula. La mayor parte de los mtodos deben conocer si ha tenido alguna
experiencia con cdigo JDBC. Continuando con nuestro desarrollo de la aplicacin,
vamos a aadir un par de mtodos que guardara las pelculas y recuperarlas de la
base de datos. Llamamos a estos mtodos como persistMovie y queryMovies,
respectivamente. La aplicacin de estos mtodos se muestra en el siguiente listado de
cdigo:
public class VanillaMovieManager {
private String insertSql = "INSERT INTO MOVIES VALUES (?,?,?,?)";
private String selectSql = "SELECT * FROM MOVIES";
...
private void persistMovie() {
try {
PreparedStatement pst = getConnection().prepareStatement(insertSql);
pst.setInt(1, 1001);
pst.setString(2, "Top Gun");
pst.setString(3, "Action Film");
pst.setString(4, "Tony Scott");
// Execute the statement
pst.execute();
System.out.println("Movie persisted successfully!");
}
catch (SQLException ex) {
System.err.println(ex.getMessage());
ex.printStackTrace();
}
}
private void queryMovies() {
try {
Statement st = getConnection().createStatement();
ResultSet rs = st.executeQuery("SELECT * FROM MOVIES");
while (rs.next()) {
System.out.println("Movie Found: "
+ rs.getInt("ID")
+ ", Title:"
+ rs.getString("TITLE"));
}
}
catch (SQLException ex)
{
System.err.println(ex.getMessage());
}
}
}

Esto es lo que hemos hecho en el cdigo de ejemplo anterior:

1. Hemos creado un PreparedStatement de la conexin con la cadena SQL
INSERT.
2. Hemos establecido la declaracin con valores (valores de columna contra
nmeros de columna: 1 es ID, 2 es el ttulo, etc.).
3. Hemos ejecuta la sentencia que debe insertar la pelcula en la tabla.
4. Hemos pregunt la base de datos para todas las pelculas y los imprimimos a
la consola.
Los pasos son bastante auto-explicativo. Creamos una declaracin preparada y
ejecutarlo despus de establecer los valores apropiados en l para cada columna. Una
vez que sabemos que la ejecucin trabaj, consultamos la base de datos con una

instruccin SELECT con el fin de obtener todas los pelculas disponibles e imprimirlos a
la consola.
Sin embargo, hay algunas cosas a tener en cuenta:
Utilizamos una declaracin SQL predefinida para insertar (o seleccione) los
valores de columna.
Establecemos la columna con valores uno por uno usando el nmero de
posicin (o el nombre de la columna).
Cogemos la SQLException si el cdigo se porta mal.
Para programas sencillos, esta forma de creacin de los estados con los valores y la
ejecucin de ellos est muy bien. Sin embargo, los tipos de programas que tenemos
que tratar en el mundo real son mucho ms complejos. JDBC funcionar, si usted est
dispuesto y capaz de escribir y manejar una gran cantidad de cdigo no comercial.
Adems, el uso de JDBC podra plantear un reto cuando se tiene una gran cantidad de
tablas o relaciones complejas entre los objetos.
Improvisando la Aplicacin de la pelcula
No sera ideal para llamar a un mtodo como persisten ( ) en una clase de utilidad
para que el objeto de la pelcula se conserva en seguida?
Para lograr este objetivo, vamos a crear un objeto viejo y simple de Java (POJO) en
representacin de una pelcula. Para cada pelcula que se libera (o an no se ha
lanzado), tendremos un nuevo objeto de pelcula creado. La pelcula POJO se define
aqu:
public class Movie {
private int id = 0;
private String title = null;
private String synopsis = null;
private String director = null;
...
// Setters and getters omitted
}

Por lo tanto, todo lo que necesitamos ahora es que una instalacin de persistir este
objeto POJO en nuestra Tabla MOVIES en esencia de bases de datos que convierten el
modelo de objetos (objeto Pelcula) a un (fila de la tabla) modelo relacional.
Vamos a crear una clase MoviePersistor que podra hacer este trabajo:
// Pseudocode
public class MoviePersistor {
public void persist(Movie movie) {
// Persisting a movie goes here
}
public void fetch(String title) {
// Fetching a movie by title goes here
}
...
}

No hemos escrito el persisten o ir a buscar la funcionalidad todava; ese no es el tema

del programa. Ahora vamos a ver lo fcil que es persistir cualquier pelcula utilizando
la clase de utilidad MoviePersistor, como se demuestra en esta prueba de la muestra:
//Pseudocode
MoviePersistor moviePersistor = new MoviePersistor();
Movie movie = new Movie();
movie.setId(1);
movie.setTitle("Jaws");
movie.setDirector("Steven Spielberg");

movie.setSynopsis("Story of a great white shark!");

moviePersistor.persist(movie);

Cun genial es eso? Un POJO que representa una pelcula se conserva como una fila
de expedientes en un modelo de tabla a objetos de base de datos de modelo
relacional a travs de una clase de utilidad!
Eso es todo bien, excepto por el actual persisten a buscar implementaciones de
mtodo. Para implementar esta funcionalidad, no slo necesitamos la instalacin de la
conexin a una base de datos, tambin necesitamos un mecanismo para convertir el
objeto a una fila (como la cartografa de nuestras propiedades de objeto a las
columnas de base de datos).
Podramos escribir nuestro propio framework de clases para ocultar el meollo de estas
conversiones y mecanismos de persistencia (que pueden utilizar buenas declaraciones
JDBC detrs de las escenas). Aunque la redaccin de este framework no es ciencia de
cohetes, sera una prdida de tiempo y esfuerzo engorroso para empezar.
Con el tiempo, los requisitos de persistencia de una organizacin pueden cambiar o
incluso puede migrar la base de datos, por ejemplo, Oracle a MySQL. Esto significa
que el framework tendra que ser muy genrica y dar cuenta de una gran cantidad de
requisitos funcionales y tcnicos antes de golpear el suelo.
En mi experiencia, estos framework de cosecha propia son inmanejables, inflexible,
inescalable, y a veces fuera de fecha tambin! A menos que el requisito est apegado
especficamente a una organizacin (la organizacin puede querer persistir datos a
Marte!), Le recomiendo encarecidamente que usted busca en Internet para elegir uno
que satisfaga estrechamente nuestros predicados.
Pero antes de ir en su manera de empezar a escribir el cdigo, quiero ser el portador
de buenas noticias (si an no lo ha de haber escuchado esto): ya hay un gran
framework que hace exactamente esto, persistencia de objetos a una base de datos
relacional, llamado Hibernate!
Ahora que tenemos un framework de persistencia, vamos a ver cmo el mismo
mtodo que persiste nuestra pelcula se puede refactorizar travs de Hibernate:
public class BasicMovieManager {
private void persistMovie(Movie movie) {
Session session = sessionFactory.getCurrentSession();
...
session.save(movie);
}
...
}

Te diste cuenta de que nos ahorramos la instancia de la pelcula a una base de datos
por una ejecucin de una sola lnea de cdigo: Session.save (movie)? No es esto lo
que haba deseado antes, una clase que simplemente guardar los objetos persistentes
de una manera orientada a objetos? Las clases de la API de Hibernate exponen varios
mtodos para manipular los objetos Java con facilidad y comodidad. Nosotros no
tenemos que escribir pginas y pginas de cdigo utilizando JDBC ni doblar las
mangas y escribir un framework mientras se la pasa rascando la cabeza y tragar litros
de cafena!
Hibernate proporciona la capacidad de persistencia de objetos; Sin embargo, hay una
configuracin de una sola vez y el mapeo tenemos que dejar que Hibernate sabe

nuestras intenciones. Nos adentramos en estos detalles en un nivel muy alto en el

prximo par de secciones.
El uso de Hibernate
Las medidas estndar a seguir en la creacin de una aplicacin de Hibernate son:
1. Configurar la conexin de base de datos.
2. Cree definiciones de asignacin.
3. Persistir las clases.
Estos son los pasos comunes que intervienen en el desarrollo de la versin Java
Hibernate de nuestra aplicacin MovieManager:
1. Crear un objeto de dominio Pelcula (dominio POJOs modelo que representan las
tablas de datos).
2. Crear archivos de configuracin como propiedades de Hibernate y archivos de
asignacin.
3. Crear un cliente de prueba que administra (insertar / actualizar / borrar /
busqueda) las pelculas.
Ya hemos preparado un POJO pelcula, como se muestra en fragmentos anteriores, por
lo que no tiene que ir sobre ella de nuevo.
El corazn de cualquier aplicacin Hibernate est en su configuracin. Hay dos piezas
de configuracin requeridos en cualquier aplicacin Hibernate: uno crea las
conexiones de base de datos, y la otra crea el mapeo de objetos a la tabla. Al igual
que con JDBC, tenemos que proporcionar la informacin de la base de datos de
nuestra aplicacin por lo que se abrir una conexin para la manipulacin de los
datos. Los define la configuracin de mapeo que se oponen propiedades se asignan a
las columnas de la tabla. No vamos a entrar en detalles acerca de ellos aqu, ya que el
objetivo de este captulo es que pueda empezar rpidamente!
Echemos un vistazo a los pasos estndar para la creacin de una aplicacin de
Hibernate en las siguientes secciones.
Configure la conexin con la base
Para crear una conexin con la base de datos, Hibernate debe conocer los detalles de
nuestras bases de datos, tablas, clases y otros mecnicos. Esta informacin est
definida en un archivo XML (generalmente llamado hibernate.cfg.xml) o como un
archivo de texto simple con pares nombre / valor (hibernate.properties).
Para este ejercicio, se utiliza el estilo XML. Nombramos este archivo hibernate.cfg.xml
por lo que el marco puede cargar este archivo automticamente.
El siguiente fragmento describe un archivo de este tipo de configuracin. Porque yo
estoy usando MySQL como base de datos, los detalles de la conexin de la base de
datos MySQL se declaran en este archivo hibernate.cfg.xml:
<hibernate-configuration>
<session-factory>
<property name="connection.url">jdbc:mysql://localhost:3307/JH</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.username">mkonda</property>
<property name="connection.password">password</property>
<property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
<mapping resource="Movie.hbm.xml" />
</session-factory>
</hibernate-configuration>

Este archivo tiene suficiente informacin para obtener una conexin en directo a una
base de datos MySQL. Las propiedades anteriores tambin se pueden expresar como
pares de nombre / valor. Por ejemplo, aqu est la misma informacin representada
como pares nombre / valor en un archivo de texto hibernate.properties tituladas:
hibernate.connection.driver_class = com.mysql.jdbc.Driver
hibernate.connection.url = jdbc:mysql://localhost:3307/JH
hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

indica la URL a la que debemos estar conectados, driver_class representa la

clase del controlador correspondiente para hacer una conexin, y el dialect indica que la
base de datos dialecto que estamos utilizando (MySQL, en este caso).
connection.url

Si usted est siguiendo el enfoque archivo hibernate.properties, tenga en cuenta que

todas las propiedades tienen el prefijo "hibernate", y siguen un patrn de Hibernate. *
Propiedades, por instancia.
Ms all de proporcionar las propiedades de configuracin, tambin tenemos que
proporcionar archivos de asignacin y sus ubicaciones. Como se mencion
anteriormente, un archivo de asignacin indica el mapeo de las propiedades de los
objetos a los valores de columna de fila. Esta asignacin se realiza en un archivo
separado, por lo general sufijo .hbm.xml. Debemos dejar que Hibernate sepa de
nuestros archivos de definicin de asignacin mediante la inclusin de una propiedad
mapeo elemento en el archivo de configuracin anterior, como se muestra aqu:
<hibernate-configuration>
<session-factory>
...
<mapping resource="Movie.hbm.xml" />
<mapping resource="Account.hbm.xml" />
<mapping resource="Trade.hbm.xml" />
</session-factory>
</hibernate-configuration>

El atributo d resource indica el nombre del recurso de mapeo que Hibernate debe cargar.
En este caso, Movie.hbm.xml es el archivo de asignacin y consta de detalles sobre
cmo un objeto de MOVIE se asigna a una Tabla MOVIE. Usted puede ver a los dems,
as, como Account.hbm.xml y Trade.hbm.xml. Vamos a ver estos archivos de
asignacin en un minuto. Qu hace Hibernate con este archivo de propiedades?
El framework Hibernate carga este archivo para crear un SessionFactory, que es una
caja fuerte clase de fbrica mundial de hilo para la creacin de Sesiones. Idealmente
Debemos crear un nico SessionFactory y compartirlo a travs de la aplicacin. Tenga
en cuenta que una SessionFactory se define por una, y slo una, la base de datos. Por
ejemplo, si usted tiene otra base de datos junto a MySQL, debe definir la configuracin
relevante en hibernate.hbm.xml crear una SessionFactory separado para esa base de
datos tambin.
El objetivo de la SessionFactory es crear objetos Session. Sesin es una puerta de
entrada a nuestra base de datos. Es el trabajo de la Sesin a cargo de todas las
operaciones de base de datos como el insertar, carga y recuperacin de los registros
de las tablas correspondientes. El framework tambin mantiene un medio
transaccional alrededor de nuestra aplicacin. Las operaciones que implican el acceso
a la base de datos estn envueltos en una sola unidad de trabajo llamada transaccin.
As, todas las operaciones en esa transaccin son ya sea exitosa o se deshace.
Tenga en cuenta que la configuracin se utiliza para crear una sesin a travs de una
instancia SessionFactory. Antes de continuar, tenga en cuenta que los objetos de
sesin no se thread-safe y por lo tanto no deben ser compartidos a travs de

diferentes clases. Vamos a ver los detalles de la forma en que deben utilizarse a
medida que avanzamos en este libro.
Crear definiciones de asignacin
Una vez que tenemos la configuracin de conexin lista, el siguiente paso es preparar
el archivo Movie.hbm.xml que consiste en las definiciones de mapeo objeto-tabla. El
siguiente fragmento de XML define el mapeo de nuestro objeto de pelcula contra la
Tabla MOVIES:
<hibernate-mapping>
<class name="com.madhusudhan.jh.domain.Movie" table="MOVIES">
<id name="id" column="ID">
<generator class="native"/>
</id>
<property name="title" column="TITLE"/>
<property name="director" column="DIRECTOR"/>
<property name="synopsis" column="SYNOPSIS"/>
</class>
</hibernate-mapping>

Hay mucho que hacer en este archivo de asignacin. El elemento hibernate-mapping

tiene todas las definiciones de asignacin de clase en tabla. Asignaciones individuales
por objeto se declaran bajo el elemento de clase. El atributo name de la etiqueta de la
clase se refiere a nuestra clase de dominio POJO com.madhusudan.jh.domain.Movie,
mientras que el atributo table se refiere a la tabla a la que se conservaran los objetos
en BD.
Las propiedades restantes indican la correspondencia entre las variables del objeto a
las columnas de la tabla (por ejemplo, la identificacin se asigna a ID, el ttulo a ttulo,
director de DIRECTOR, etc.). Cada objeto debe tener un identificador similar a una
clave principal en la tabla nica. Hemos creado este identificador de la aplicacin de la
etiqueta de la identificacin mediante una estrategia nativa. No prestar demasiada
atencin a este ID y la estrategia de generacin todava. Vamos a discutir en detalle
en los prximos captulos.
Persistencia de los objetos
Ahora que la configuracin est fuera de nuestro camino, vamos a crear un cliente que
persiste los objetos con la ayuda de Hibernate.
Necesitamos la instancia SessionFactory desde el que creamos un objeto Session. El
siguiente fragmento muestra la configuracin inicial para la creacin de la clase
SessionFactory:
public class BasicMovieManager {
private SessionFactory sessionFactory = null;
// Creating SessionFactory using 4.2 version of Hibernate
private void initSessionFactory(){
Configuration config = new Configuration().configure();
// Build a Registry with our configuration properties
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(
config.getProperties()).buildServiceRegistry();
// create the session factory
sessionFactory = config.buildSessionFactory(serviceRegistry);
}
...
}

Tenga en cuenta que no tenemos que mencionar explcitamente el mapeo o archivos

de configuracin o propiedades, ya que el tiempo de ejecucin de Hibernate busca
nombres de archivo por defecto, como hibernacin.cfg.xml o hibernate.properties, en
la ruta de clase y los carga. Si tenemos un nombre no predeterminado, asegrese de
que pase eso como un argumento de configure similar ("my-hib.cfg.xml"), por ejemplo.

Los ajustes anteriores para inicializar la clase SessionFactory son para la versin ms
reciente de hibernate en el momento de escribir estas lneas, 4.2. La versin 4.x
Hibernate introdujo registros de servicio, que veremos en captulos posteriores.
En las versiones 3.x, el mtodo configure hurga a travs de la ruta de clases
buscando un archivo llamado hibernate.cfg.xml (o hibernate.properties) para
crear un objeto de configuracin. Este objeto de configuracin se utiliza para
crear una instancia de SessionFactory. Si est utilizando una versin pre-4.x
de Hibernate, utilice el siguiente cdigo para inicializar el SessionFactory:
//Creating SessionFactory using 3.x version of Hibernate
private void init3x(){
sessionFactory =
new Configuration().configure().buildSessionFactory();
}

En las versiones 4.x, esto se modific ligeramente por la introduccin de Service

Registry, que toma un mapa de las propiedades que se pueden alimentar desde
un objeto de configuracin, simplemente ha mostrado.
Sea cual sea la versin que elija, la SessionFactory as creado es el mismo y tambin lo
son las Sesiones.
Creacin del Mtodo de Persistencia
Ahora el funcionamiento real de la clase bsica MovieManager. El mtodo de
persistencia se define en la clase de persistir Movie utilizando el mtodo de guardar
Sesin. Esto se muestra en el siguiente fragmento:
public class BasicMovieManager {
private void persistMovie(Movie movie) {
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
session.save(movie);
session.getTransaction().commit();
}
}

Parece sencillo, no? No escribimos cdigo innecesario o repetitivo en absoluto, pero

concentrado en la funcin de negocio de guardar el objeto.
En el fragmento anterior, lo primero que agarramos es una Sesin de la fbrica. Luego
creamos un objeto de transaccin (vamos a aprender ms sobre las transacciones en
captulos posteriores), y persistir el objeto Pelcula entrante utilizando el mtodo
Session.save. Por ltimo, nos comprometemos la transaccin, y la pelcula se
almacena de forma permanente en nuestra base de datos.
Prueba de la datos persistentes
Tenemos dos formas de visualizar los datos persistentes: ejecutar una consulta SQL
nativo en la base de datos, o crear un cliente de prueba.
Podemos ejecutar la consulta SQL en la base de datos usando algo como SELECT *
FROM MOVIES, que recupera todos los registros almacenados por nuestra aplicacin.
La consulta de seleccin SQL imprime la salida, como se muestra en la Tabla 1-2.

Alternativamente, podemos crear otro mtodo en nuestro cliente de prueba, decir

findMovie. Este mtodo se utilice el mtodo de carga de la Sesin a buscar el registro
de la base de datos. Invocamos el mtodo findMovie, pasando el ID de la pelcula
como el argumento, se ha podido recuperar la pelcula:
public class BasicMovieManager {
...
private void findMovie(int movieId) {
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
Movie movie = (Movie)session.load(Movie.class, movieId);
System.out.println("Movie:"+movie);
session.getTransaction().commit();
}
}

El mtodo de carga en el API Sesin obtiene el objeto de pelcula apropiada para un

identificador dado. Si usted est pensando que Hibernate puede utilizar una
instruccin SELECT detrs de las escenas, ests en lo correcto!
Si usted desea a buscar todas las pelculas de la tabla, se crea un objeto de consulta
con la cadena de consulta sencilla "de pelculas" y ejecutarlo. El mtodo de la lista en
la consulta (creada mediante session.createQuery) devuelve una lista de las pelculas,
como se muestra aqu:
public class BasicMovieManager {
// Finding all movies
private void findAll() {
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
List<Movie> movies = session.createQuery("from Movie").list();*
session.getTransaction().commit();
System.out.println("All Movies:"+movies);
}
...
}

Configuracin de Hibernate
La creacin de un proyecto de Hibernate es fcil. El proyecto que he preparado para
este libro es un cdigo basado en Maven desarrollado en NetBeans IDE. No voy a
entrar en detalles sobre la configuracin del entorno, pero los siguientes pasos debera
ayudarle. Aunque he utilizado NetBeans para el desarrollo de cdigo, puede utilizar
cualquiera de sus IDEs favoritos para trabajar en este proyecto. Tambin, usted puede
intercambiar MySQL con otras bases de datos, incluidos los de la memoria como Derby
o HyperSQL.
En primer lugar, debe configurar el entorno de desarrollo esencial consiste en JDK 5.0
y versiones posteriores, NetBeans IDE, Maven, y la base de datos MySQL (que puede
haber tenido este entorno ya!). He utilizado JDK 6, NetBeans 7.3, Maven 3.2 y MySQL
5.2 para desarrollar el cdigo y la versin Hibernate es 4.2.3.Final.
Una vez que tenga el entorno dev ordenados, el siguiente paso es crear un proyecto
Maven en NetBeans (o Eclipse). Aadir las dependencias de Hibernate apropiadas para
el archivo pom.xml como se muestra aqu:

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.madhusudhan</groupId>
<artifactId>just-hibernate</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.2.3.Final</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.18</version>
</dependency>
...
</project>

Maven resolver las dependencias relacionadas en la construccin del proyecto.

Recomiendo descargar el cdigo fuente del libro y de importar el proyecto en su IDE
favorito.
El siguiente paso es la creacin de su base de datos. Si usted ya tiene una base de
datos, puede omitir este paso. Estoy utilizando la base de datos MySQL. Descargue el
ltimo paquete MySQL e instalarlo en su equipo (puede que tenga que pasar por el
manual para configurar esto correctamente). Usted puede probar los ejemplos de este
libro utilizando cualquier otra base de datos.
Una vez que tenga MySQL (o cualquier otra base de datos) instalado, asegrese de
crear un esquema llamado JH, como se muestra aqu:
CREATE SCHEMA JH;

La mayora de las tablas de este proyecto fue auto generada por Hibernate; es decir,
Hibernate creara sobre la marcha (si no existen) mediante la lectura de la
configuracin. Tenemos que establecer una propiedad, hbm2ddl.auto, en el archivo de
configuracin de Hibernate (hibernacin cfg.xml.) Al valor apropiado para esta
generacin automtica a suceder, de la siguiente manera:
<property name="hbm2ddl.auto">update</property>

Cuando establecimos esta propiedad, las tablas se crean automticamente si no

existen o se actualizan si hay un cambio en el esquema de la tabla.
Nunca utilice la propiedad hbm2ddl.auto en la produccin! Debe crear un esquema
con todas las definiciones de tabla y desplegar a la produccin a travs de un proceso
de liberacin adecuado.
Eso es practicamente todo!
Nos hubiera gustado un mecanismo que se esconde el meollo de la cuestin de las
declaraciones JDBC torpes y conexiones. Soamos con la creacin de mtodos de
instalacin que almacenar un objeto POJO directamente a la base de datos sin la
molestia de establecer / obtener las columnas. Hemos cumplido nuestros sueos y
deseos, abrazando Hibernate!
Usted puede tener un montn de preguntas, pero le desmitificado a medida que
avanzamos a travs de nuestro viaje, as que estar atentos!

Resumen
En este captulo, aprendimos sobre el dominio del problema objeto-relacional-modelo
caminando a travs de un ejemplo. Aunque podemos utilizar JDBC para el acceso a
datos, se encontr que se requiere una gran cantidad de mapeo manual y cdigo
innecesariamente repetitivo. Nos tomamos un pequeo paso y present Hibernate
para resolver el problema de la persistencia objeto a relacional de datos. A partir de
un alto nivel, tomamos un vistazo a los conceptos de Hibernate SessionFactory y
Sesiones. Refactorizamos el ejemplo de JDBC para usar el framework de Hibernate y
con xito persisti y pregunt los POJOs como se esperaba. En el prximo captulo,
vamos a ir a travs de los fundamentos de la hibernacin en detalle.

Ejemplo conexin con JDBC

package cadillacs.example.jdbc;
import
import
import
import

java.sql.Connection;
java.sql.PreparedStatement;
java.sql.ResultSet;
java.sql.SQLException;

import cadillacs.beans.Movie;
public class JDBCexample {
public static OracleConnection conexionOracle = new OracleConnection();
public static Connection conn;
public static void main(String[] args) throws Exception {
// Conecction
conn = conexionOracle.getOracleConnection();
System.out.println("Conexion exitosa...");
// insert movie table:
Movie movie = new Movie();
movie.setIdMovie(1);
movie.setTitle("The Thing");
movie.setSynopsis("habia una vez...");
movie.setDirector("Pedrito Jr.");
// insertMovie(movie);
System.out.println("Se inserto registro exitosamente.");
// read (select)
queryMovies();
// update
// ...
// read (select)
// ...
// delete
// ...
conn.close();
}

System.out.println("Conexion cerrada.");

private static void queryMovies() {

try {
PreparedStatement pstmt1 = conn

.prepareStatement("Select * from movies order by

movies_id");

ResultSet rset = pstmt1.executeQuery();

while (rset.next()) {
System.out.println(rset.getInt(1) + ". Movie:"
+ rset.getString(2));
}
} catch (SQLException ex) {
System.err.println(ex.getMessage());
}

}
public static void insertMovie(Movie movie) throws SQLException {
PreparedStatement pst = conn
.prepareStatement("insert into movies (movies_id, title, director,
synopsis) values(movies_sequence.NEXTVAL,?,?,?)");
pst.setString(1, movie.getTitle());
pst.setString(2, movie.getDirector());
pst.setString(3, movie.getSynopsis());
pst.execute();
pst.close();
}
public static void getMovies(Movie movie) throws SQLException {
PreparedStatement pst = conn
.prepareStatement("insert into movies (movies_id, title, director,
synopsis) values(movies_sequence.NEXTVAL,?,?,?)");
pst.setString(1, movie.getTitle());
pst.setString(2, movie.getDirector());
pst.setString(3, movie.getSynopsis());
pst.execute();
pst.close();
}
}

Ejemplo conexin con Hibernate 3.x