Hibernate v1

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


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


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.


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").


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,


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.


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.


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.


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.


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


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


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.


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) );


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());


12

System.out.println(" Salary: " + employee.getSalary()); } tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } }


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

Hibernate v1

Documents

Transcript of Hibernate v1