hibernate v1
TRANSCRIPT
HIBERNATE Guatemala, 30 de julio de 2013
i
Universidad Mariano Gálvez de Guatemala Maestría en Informática Curso: Programación en Java Dr. Orestes Febles
Karla Mesarina 092-07-0323
Gustavo Ruiz 092-07-0001
Walter García 092-08-411
Rodrigo de Matta 092-08-200
Estuardo Martínez 092-07-634
José Félix 092-06-3573
Benito González 092-07-1980
David González 092-07-2059
Juan Carlos Rizo 092-08-7303
Guatemala, 30 de julio de 2013
UMG HIBERNATE
HIBERNATE Guatemala, 30 de julio de 2013
ii
TABLA DE CONTENIDO
INTRODUCCIÓN ............................................................................................................................. iii
1. ¿Qué es Hibernate?.............................................................................................................. 1
1.1. Características principales .......................................................................................... 1
1.2. ¿Por qué es tan importante una herramienta como Hibernate? ................................. 2
2. Arquitectura de Hibernate ................................................................................................... 3
2.1. Arquitectura Mínima .................................................................................................. 3
2.2. Arquitectura Integral .................................................................................................. 4
3. APIs Básicas ......................................................................................................................... 5
3.1. SessionFactory (org.hibernate.SessionFactory) ........................................................... 5
3.2. Session (org.hibernate.Session) .................................................................................. 5
3.3. Objetos persistentes y colecciones ............................................................................. 5
3.4. Objetos transitorios y distantes y colecciones............................................................. 5
3.5. Transacción (org.hibernate.Transaction) .................................................................... 5
3.6. ConnectionProvider (org.hibernate.connection.ConnectionProvider) ......................... 6
3.7. TransactionFactory (org.hibernate.TransactionFactory) .............................................. 6
3.8. Interfaces de Extensión .............................................................................................. 6
3.9. Integración JMX ......................................................................................................... 6
4. Interfaces ............................................................................................................................. 6
5. Trayectoria de Hibernate (versiones).................................................................................... 8
6. Procedimiento de Instalación para Windows ........................................................................ 8
7. Configuración básica ............................................................................................................ 9
8. Ejemplo de uso (base de datos de empleados) ................................................................... 10
CONCLUSIONES ............................................................................................................................ 13
EGRAFIA....................................................................................................................................... 13
HIBERNATE Guatemala, 30 de julio de 2013
iii
INTRODUCCIÓN
Trabajar con software orientado a objetos y bases de datos relacionales, puede ser
embarazoso y puede demandar mucho tiempo, en los entornos corporativos actuales.
Hibernate es una herramienta de mapeo objeto/relacional para ambientes Java. El
término "mapeo objeto/relacional" (ORM por sus siglas en inglés) se refiere a esta
técnica de "mapear" la representación de los datos desde un modelo de objetos hacia
un modelo de datos relacional, con un esquema de base de datos basado en SQL.
Hibernate no sólo se hace cargo del mapeo de clases Java a las tablas de una base de
datos (y de los tipos Java a los tipos de la base de datos), sino que también provee
utilidades para consulta y captura de datos, y puede reducir considerablemente el
tiempo que, de otra manera, habría que invertir con el manejo manual de datos
mediante SQL y JDBC.
La meta de Hibernate es aliviar al programador del 95% de las tareas más comunes
relacionadas con persistencia. Probablemente, Hibernate no sea la mejor solución
para aplicaciones data-céntricas que tengan casi toda su lógica de negocios en
procedimientos almacenados (stored procedures) en la base de datos; es más útil con
modelos orientados a objetos cuya lógica de negocio reside en la capa intermedia. Sin
embargo, Hibernate puede proporcionar una ayuda para encapsular o eliminar código
SQL que sea específico de un proveedor de BD, y que además, ayudará en la tarea
usual de traducir desde una representación tabular a un gráfico de objetos.
A continuación, se presenta más ampliamente el funcionamiento y uso de Hibernate.
HIBERNATE Guatemala, 30 de julio de 2013
1
1. ¿Qué es Hibernate?
Hibernate surgió como una iniciativa de un grupo de desarrolladores de Cirrus
Technologies liderado por Gavin King, como una alternativa para EJB2-style. El
objetivo original era mejorar la capacidad y persistencia ofrecida por EJB2
simplificando las complejidades y complementando ciertas características.
Posteriormente, JBoss Inc. (empresa comprada por Red Hat) contrató a los principales
desarrolladores de Hibernate y trabajó con ellos en brindar soporte a este proyecto
que empezaba a tomar fuerza en el mercado.
Hibernate es un software libre (bajo licencia LGPL), y es una herramienta de Mapeo de
Objeto-relacional (ORM) para la plataforma Java (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.
1.1. Características principales
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, Hibernate 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 programación
orientada objetos.
Hibernate convertirá los datos entre los tipos utilizados por Java y los definidos por
SQL. 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.
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 Guatemala, 30 de julio de 2013
2
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.
1.2. ¿Por qué es tan importante una herramienta como Hibernate?
Es usual trabajar con programación orientada a objetos y utilizar bases de datos(BD)
relacionales. Resulta obvio que se trata de dos paradigmas diferentes. El modelo
relacional trata con relaciones, tuplas y conjuntos, y es muy matemático por
naturaleza. El paradigma orientado a objetos, sin embargo, trata con objetos, sus
atributos y relaciones entre objetos. Cuando se quiere hacer que los objetos sean
persistentes utilizando para ello una BD relacional, uno se da cuenta de que hay una
desavenencia entre estos dos paradigmas: es lo que se denomina un "object-relational
gap".
¿Cómo se manifiesta esta brecha entre ambos paradigmas?
Si se está utilizando objetos en alguna aplicación y en algún momento se espera que
éstos sean persistentes, normalmente se abre una conexión JDBC, se crea una
sentencia SQL y se copian todos los valores de las propiedades sobre una Prepared
Statement o en la cadena SQL que se esté construyendo. Esto puede resultar sencillo
para un objeto de tipo valor (value object: VO) de tamaño pequeño, pero ¿qué pasa
cuando un objeto tiene muchas propiedades?¿Qué ocurre con las asociaciones? ¿Y si el
objeto contiene a su vez a otros objetos? ¿Se almacenarán también en la BD?
¿Automáticamente? ¿Manualmente? ¿Qué pasará con las claves ajenas? Preguntas
similares surgen a la hora de "cargar" un dato de la BD en un VO (se denomina value
object o VO a un objeto que contiene información de negocio estructurada en grupos
de items de datos, también recibe el nombre de transfer object. Si Java tuviese una
construcción semejante a las estructuras de C/C++ u otros lenguajes, un VO sería una
estructura).
Como se puede comprobar lo anteriormente descrito, la brecha existente entre los
paradigmas de objetos y relacional se vuelve mucho mayor si se dispone de modelos
con objetos "grandes". De hecho, hay estudios que muestran que un 35% del código de
una aplicación se produce como consecuencia del mapeado (correspondencia) entre
los datos de la aplicación y el almacén de datos.
Dicho todo esto, lo que se necesita es una herramienta ORM (Object Relational
Mapping). Básicamente, una ORM intenta hacer todas estas tareas pesadas en lugar de
que las realice el desarrollador. Con una buena ORM, se tendrá que definir la forma en
la que se establecerá la correspondencia entre las clases y las tablas una sola vez
(indicando qué propiedad se corresponde con qué columna, qué clase con qué tabla,
HIBERNATE Guatemala, 30 de julio de 2013
3
etc.). En este punto, es donde Hibernate es la herramienta más utilizada para realizar
estas tareas.
2. Arquitectura de Hibernate
Primero que nada se presenta un diagrama que proporciona una visión de alto nivel
de la arquitectura de Hibernate:
A pesar de que Hibernate es suficientemente flexible para ser utilizado en un muchas
formas sobre diferentes arquitecturas, a continuación se presentan los dos casos más
relevantes:
2.1. Arquitectura Mínima
La arquitectura "mínima" tiene la aplicación de la gestión de sus propias conexiones
JDBC y proporciona las conexiones a Hibernate, además, la aplicación maneja
transacciones por sí misma. Este enfoque utiliza un subconjunto mínimo de las APIs
de Hibernate.
HIBERNATE Guatemala, 30 de julio de 2013
4
2.2. Arquitectura Integral
La arquitectura "integral" abstrae la aplicación de distancia del subyacente JDBC / JTA
API y permite que Hibernate se encargue de los detalles.
HIBERNATE Guatemala, 30 de julio de 2013
5
3. APIs Básicas
3.1. SessionFactory (org.hibernate.SessionFactory)
Un thread-safe, inmutable caché de asignaciones, compilados para una sola base de
datos. Una fábrica de instancias org.hibernate.Session.
Un cliente de org.hibernate.connection.ConnectionProvider. Opcionalmente mantiene
una caché de segundo nivel de datos que se puede reutilizar entre las transacciones en
un proceso o nivel de las agrupaciones.
3.2. Session (org.hibernate.Session)
Un objeto de un único subproceso, de vida corta que representa una conversación
entre la aplicación y el almacenamiento persistente. Envuelve un java.sql.Connection
JDBC. Fábrica de org.hibernate.Transaction. Mantiene un caché de primer nivel de
objetos persistentes y colecciones persistentes de la aplicación, esta caché se utiliza
cuando se navega en el gráfico de objetos o se busca objetos por identificador.
3.3. Objetos persistentes y colecciones
De corta duración, los objetos que contienen un solo subproceso persistente y función
de negocios. Estos pueden ser JavaBeans ordinarios / POJOs. Están asociados con
exactamente un org.hibernate.Session. Una vez el org.hibernate.Session está cerrado,
será independiente y libre para usarse en cualquier capa de la aplicación (por ejemplo,
directamente como objetos de transferencia de datos hacia y desde la presentación).
3.4. Objetos transitorios y distantes y colecciones
Las instancias de clases persistentes que no están asociadas actualmente con una
org.hibernate.Session. Es posible que hayan creado instancias de la solicitud y aún no
persistido, o pueden haber sido instanciadas por un org.hibernate.Session cerrado.
3.5. Transacción (org.hibernate.Transaction)
(Opcional) Un objeto de un único subproceso, de corta duración utilizado por la
aplicación para especificar unidades atómicas de trabajo. Se abstrae la aplicación de la
transacción JDBC, JTA o CORBA subyacente. Un org.hibernate.Session puede abarcar
varios org.hibernate.Transactions en algunos casos. Sin embargo, la demarcación de la
transacción, ya sea utilizando la API o org.hibernate.Transaction subyacente, no es
opcional.
HIBERNATE Guatemala, 30 de julio de 2013
6
3.6. ConnectionProvider
(org.hibernate.connection.ConnectionProvider)
(Opcional) Una fábrica y grupo de JDBC. Se abstrae la aplicación del subyacente
javax.sql.DataSource o java.sql.DriverManager. No se expone a la aplicación, pero se
puede extender y / o ejecutar por el desarrollador.
3.7. TransactionFactory (org.hibernate.TransactionFactory)
(Opcional) Una fábrica de instancias org.hibernate.Transaction. No se expone a la
aplicación, pero se puede extender y / o ejecutar por el desarrollador.
3.8. Interfaces de Extensión
Hibernate ofrece una amplia gama de interfaces de extensión opcionales que puede
implementar para personalizar el comportamiento de la capa de persistencia.
3.9. Integración JMX
JMX es el estándar J2EE para la gestión de los componentes de Java. Hibernate se
puede gestionar a través de un servicio estándar JMX. Una implementación MBean se
proporciona en la distribución: org.hibernate.jmx.HibernateService.
4. Interfaces
En la figura a continuación se muestran los roles de las interfaces Hibernate más
importantes en las capas de persistencia y de negocio de una aplicación J2EE. La capa
de negocio está situada sobre la capa de persistencia, ya que la capa de negocio actúa
como un cliente de la capa de persistencia.
HIBERNATE Guatemala, 30 de julio de 2013
7
Las interfaces mostradas pueden clasificarse como sigue:
Interfaces llamadas por la aplicación para realizar operaciones
básicas(inserciones, borrados, consultas,...): Session, Transaction, y Query.
Interfaces llamadas por el código de la infraestructura de la aplicación para
configurar Hibernate. La más importante es la clase Configuration.
Interfaces callback que permiten a la aplicación reaccionar ante determinados
eventos que ocurren dentro de la aplicación, tales como Interceptor, Lifecycle, y
Validatable.
Interfaces que permiten extender las funcionalidades de mapeado de Hibernate,
como por ejemplo UserType, CompositeUserType, e IdentifierGenerator.
Además, Hibernate hace uso de APIs de Java, tales como JDBC,JTA (JavaTransaction
Api) y JNDI (Java Naming Directory Interface).
Daremos un repaso breve a algunas de las interfaces mencionadas.
La interfaz Session es una de las interfaces primarias en cualquier aplicación
Hibernate. Una instancia de Session es "poco pesada" y su creación y destrucción es
muy "barata". Esto es importante, ya que nuestra aplicación necesitará crear y
destruir sesiones todo el tiempo, quizá en cada petición. Puede ser útil pensar en una
sesión como en una caché o colección de objetos cargados(a o desde una base de
datos) relacionados con una única unidad de trabajo. Hibernate puede detectar
cambios en los objetos pertenecientes a una unidad de trabajo.
La interfaz Session Factory permite obtener instancias Session. Esta interfaz no es
"ligera", y debería compartirse entre muchos hilos de ejecución. Típicamente hay una
única SessionFactory para toda la aplicación, creada durante la inicialización de la
misma. Sin embargo, si la aplicación accede a varias bases de datos se necesitará una
Session Factory por cada base de datos.
La interfaz Configuration se utiliza para configurar y "arrancar" Hibernate. La
aplicación utiliza una instancia de Configuration para especificar la ubicación de los
documentos que indican el mapeado de los objetos y propiedades específicas de
Hibernate, y a continuación crea la Session Factory.
La interfaz Query permite realizar peticiones a la base de datos y controla cómo se
ejecuta dicha petición (query). Las peticiones se escriben en HQL o en el dialecto SQL
nativo de la base de datos que estemos utilizando. Una instancia Query se utiliza para
enlazar los parámetros de la petición, limitar el número de resultados devueltos por la
petición, y para ejecutar dicha petición.
Un elemento fundamental y muy importante en la arquitectura Hibernate es la noción
de Type. Un objeto Type Hibernate hace corresponder un tipo Java con un tipo de una
HIBERNATE Guatemala, 30 de julio de 2013
8
columna de la base de datos. Todas las propiedades persistentes de las clases
persistentes, incluyendo las asociaciones, tienen un tipo Hibernate correspondiente.
Este diseño hace que Hibernate sea altamente flexible y extendible. Incluso se
permiten tipos definidos por el usuario (interfaz UserType yCompositeUserType).
5. Trayectoria de Hibernate (versiones)
Hibernate fue Iniciado en 2001 por Gavin King con sus colegas de Cirrus Technologies
como una alternativa para ejb2-style. A inicios del 2003 el grupo de desarrolladores
inicio Hibernate 2 la cual ofrecía algunas mejoras significativas sobre la primera
versión.
En 2005, hibernate versión 3.0 fue liberado.
En 2005, Hibernate versión 3.0 fue lanzado. Las características principales incluían
una nueva arquitectura Interceptor/Callback, filtros definidos por el usuario, y JDK 5.0
Anotaciones (función de los metadatos de Java).
A partir de 2010, Hibernate 3 (versión 3.5.0 o superior) era una aplicación certificada
de la especificación de Java Persistence API 2.0 a través de un contenedor para el
módulo Core proveniente del estándar JSR 317.
En diciembre de 2011, Hibernate Core 4.0.0 Final fue liberado. Este incluía nuevas
características como el soporte multi-tenancy, introducción de ServiceRegistry (un
cambio importante de cómo Hibernate construye y gestiona los "servicios"), mejora
en apertura de sesiones del SessionFactory, mejora en la integración a través
org.hibernate.integrator.spi.Integrator y auto descubrimiento, soporte de
internacionalización y códigos de mensaje en el registro, y una división más clara
entre el API, SPI e implementación de clases.
En Diciembre 2012, hibernate orm 4.1.9 fue liberado.
En 2012, los desarrolladores iniciaron Hibernate 5. Este contendrá soporte para JPA
2.1
6. Procedimiento de Instalación para Windows
1. Descargar la versión de Hibernate a utilizar (última versión 4.2.3)
2. Descomprimir los archivos descargados.
3. Crear en el ambiente una variable del sistema llamada Java_Home que
direcciona en el directorio de instalación del JDK si no existe.
4. Copiar los archivos descargados en el directorio + /bin o /lib de la variable
del sistema
HIBERNATE Guatemala, 30 de julio de 2013
9
5. Copiar el archivo hibernate3.jar en el directorio raíz de la variable de
sistema
6. Descargar las librerías y copiar a la carpeta /bin o /lib dentro de la
variable de sistema.
7. Configuración básica
Para utilizar Hibernate en una aplicación, es necesario conocer cómo configurarlo.
Hibernate puede configurarse y ejecutarse en la mayoría de aplicaciones Java y
entornos de desarrollo. Generalmente, Hibernate se utiliza en aplicaciones
cliente/servidor de dos y tres capas, desplegándose Hibernate únicamente en el
servidor. Las aplicaciones cliente normalmente utilizan un navegador web, pero las
aplicaciones swing y AWT también son usuales. Aunque solamente vamos a ver cómo
configurar Hibernate en un entorno no gestionado, es importante comprender la
diferencia entre la configuración de Hibernate para entornos gestionados y no
gestionados:
Entorno gestionado: los pools de recursos tales como conexiones a la base de
datos permiten establecer los límites de las transacciones y la seguridad se debe
especificar de forma declarativa, es decir, en sus metadatos. Un servidor de
aplicacionesJ2EE, tal como JBoss,Bea WebLogic o IBM WebSphere implementan un
entorno gestionado para Java.
Entorno no gestionado: proporciona una gestión básica de la concurrencia a
través de un pooling de threads. Un contenedor de servlets, como Tomcat proporciona
un entorno de servidor no gestionado para aplicaciones web Java. Una aplicación
stand-alone también se considera como no gestionada. Los entornos no gestionados
no proporcionan infraestructura para transacciones automáticas, gestión de recursos,
o seguridad. La propia aplicación es la que gestiona las conexiones con la base de
datos y establece los límites de las transacciones. Tanto en un entorno gestionado
como en uno no gestionado, lo primero que debemos hacer es iniciar Hibernate. Para
hacer esto debemos crear una Session Factory desde una Configuration. A
continuación explicamos cómo establecer las opciones de configuración de Hibernate.
HIBERNATE Guatemala, 30 de julio de 2013
10
8. Ejemplo de uso (base de datos de empleados)
Ejemplo Hibernate:
public class Employee { private int id; private String firstName; private String lastName; private int salary; public Employee() {} public Employee(String fname, String lname, int salary) { this.firstName = fname; this.lastName = lname; this.salary = salary; } public int getId() { return id; } public void setId( int id ) { this.id = id; } public String getFirstName() { return firstName; } public void setFirstName( String first_name ) { this.firstName = first_name; } public String getLastName() { return lastName; } public void setLastName( String last_name ) { this.lastName = last_name; } public int getSalary() { return salary; } public void setSalary( int salary ) { this.salary = salary; } } En la base de Datos: create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20) default NULL, salary INT default NULL, PRIMARY KEY (id) );
HIBERNATE Guatemala, 30 de julio de 2013
11
XML de Mapeo: <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="Employee" table="EMPLOYEE"> <meta attribute="class-description"> This class contains the employee detail. </meta> <id name="id" type="int" column="id"> <generator class="native"/> </id> <property name="firstName" column="first_name" type="string"/> <property name="lastName" column="last_name" type="string"/> <property name="salary" column="salary" type="int"/> </class> </hibernate-mapping> Método para Almacenar Empleados: public Integer addEmployee(String fname, String lname, int salary){ Session session = factory.openSession(); Transaction tx = null; Integer employeeID = null; try{ tx = session.beginTransaction(); Employee employee = new Employee(fname, lname, salary); employeeID = (Integer) session.save(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } return employeeID; } Método para Obtener todos los empleados: public void listEmployees( ){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); List employees = session.createQuery("FROM Employee").list(); for (Iterator iterator = employees.iterator(); iterator.hasNext();){ Employee employee = (Employee) iterator.next(); System.out.print("First Name: " + employee.getFirstName()); System.out.print(" Last Name: " + employee.getLastName());
HIBERNATE Guatemala, 30 de julio de 2013
12
System.out.println(" Salary: " + employee.getSalary()); } tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } }
HIBERNATE Guatemala, 30 de julio de 2013
13
CONCLUSIONES
Hibernate es una herramienta ágil que permite ahorrar tiempo de desarrollo,
buscando solucionar el problema de uso de diferentes modelos de datos
coexistentes entre una aplicación (orientada a objetos) y la base de datos,
permitiendo manipular la base de datos directamente desde la aplicación con
todas las características de la programación orientada a objetos.
Hibernate es muy flexible para ser utilizado en diferentes formas y puede ser
configurado y ejecutado en la mayoría de aplicaciones Java y entornos de
desarrollo.
EGRAFIA
Sitio oficial de Hibernate:
http://www.hibernate.org/about
http://docs.jboss.org/hibernate/orm/4.2/quickstart/en-US/html_single/
http://docs.jboss.org/hibernate/orm/4.2/manual/en-US/html_single/
http://docs.jboss.org/hibernate/orm/4.2/devguide/en-US/html_single/
Otras páginas:
http://www.jtech.ua.es/j2ee/2006-2007/doc/sesion03-apuntes.pdf
http://docs.jboss.org/hibernate/orm/3.6/reference/es-
ES/pdf/hibernate_reference.pdf
http://www.froses.com/Assets/Files/Articles/Hibernate_Introduccion_es.pdf