HIBERNATE Guatemala,
30 de julio
de 2013
i
Universidad Mariano Gálvez de Guatemala
Maestría en Informática
Curso: Programa...
HIBERNATE Guatemala,
30 de julio
de 2013
ii
TABLA DE CONTENIDO
INTRODUCCIÓN .................................................
HIBERNATE Guatemala,
30 de julio
de 2013
iii
INTRODUCCIÓN
Trabajar con software orientado a objetos y bases de datos relac...
HIBERNATE Guatemala,
30 de julio
de 2013
1
1. ¿Qué es Hibernate?
Hibernate surgió como una iniciativa de un grupo de desar...
HIBERNATE Guatemala,
30 de julio
de 2013
2
Hibernate para Java puede ser utilizado en aplicaciones Java independientes o e...
HIBERNATE Guatemala,
30 de julio
de 2013
3
etc.). En este punto, es donde Hibernate es la herramienta más utilizada para r...
HIBERNATE Guatemala,
30 de julio
de 2013
4
2.2. Arquitectura Integral
La arquitectura "integral" abstrae la aplicación de ...
HIBERNATE Guatemala,
30 de julio
de 2013
5
3. APIs Básicas
3.1. SessionFactory (org.hibernate.SessionFactory)
Un thread-sa...
HIBERNATE Guatemala,
30 de julio
de 2013
6
3.6. ConnectionProvider
(org.hibernate.connection.ConnectionProvider)
(Opcional...
HIBERNATE Guatemala,
30 de julio
de 2013
7
Las interfaces mostradas pueden clasificarse como sigue:
 Interfaces llamadas ...
HIBERNATE Guatemala,
30 de julio
de 2013
8
columna de la base de datos. Todas las propiedades persistentes de las clases
p...
HIBERNATE Guatemala,
30 de julio
de 2013
9
5. Copiar el archivo hibernate3.jar en el directorio raíz de la variable de
sis...
HIBERNATE Guatemala,
30 de julio
de 2013
10
8. Ejemplo de uso (base de datos de empleados)
Ejemplo Hibernate:
public class...
HIBERNATE Guatemala,
30 de julio
de 2013
11
XML de Mapeo:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mappi...
HIBERNATE Guatemala,
30 de julio
de 2013
12
System.out.println(" Salary: " + employee.getSalary());
}
tx.commit();
}catch ...
HIBERNATE Guatemala,
30 de julio
de 2013
13
CONCLUSIONES
 Hibernate es una herramienta ágil que permite ahorrar tiempo de...
Próxima SlideShare
Cargando en…5
×

Hibernate v1

923 visualizaciones

Publicado el

0 comentarios
1 recomendación
Estadísticas
Notas
  • Sé el primero en comentar

Sin descargas
Visualizaciones
Visualizaciones totales
923
En SlideShare
0
De insertados
0
Número de insertados
131
Acciones
Compartido
0
Descargas
40
Comentarios
0
Recomendaciones
1
Insertados 0
No insertados

No hay notas en la diapositiva.

Hibernate v1

  1. 1. 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
  2. 2. 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
  3. 3. 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.
  4. 4. 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").
  5. 5. 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,
  6. 6. 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.
  7. 7. 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.
  8. 8. 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.
  9. 9. 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.
  10. 10. 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
  11. 11. 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
  12. 12. 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.
  13. 13. 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) );
  14. 14. 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());
  15. 15. 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(); } }
  16. 16. 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

×