Manual introductorio a Hibernate 3.2

1. Sistemas de persistencia (orm)hibernate 3.2 Licensed under Creative Commons Attribution 3

2. Guión Teoría Práctica Introducción Elementos principales Librerías Compatibilidad Diagramas de Arquitectura Clases persistentes Utilización Operaciones CRUD Transacciones HQL Cache Hibernate y Spring Instalacion Ejemplo simple Hibernate tools Ejemplo completo

3. Parte teóricaHibernate 3.2

4. 1.- Introducción JDBC es laborioso y muy dependiente de la estructura de datos. Lo mas natural en desarrollo con lenguajes OO es utilizar objetos, lamentablemente las BBDD orientadas a objetos aún no adquieren suficiente madurez. La solución mas adecuada a estos problemas es usar sistemas de persistencia que abstraigan a los desarrolladores del conocimiento de sentencias SQL, los cuales traducen objetos a registros y vice-versa. Internamente utiliza reflexión, lo cual permite a un objeto examinarse y manipularse en tiempo de ejecución.

5. 1.- Introducción JavaObject SQL Table int id; String name; String getName() intgetId() void setName(String) void setId(int) id [int] primary key, name [varchar(50)] La función de un O/R Mappertiene lugaraquí Dos paradigmas muy diferentes Objetos, atributos, asociaciones con otros objetos, herencia, UML … Columnas, claves ajenas, consultas lenguaje SQL

6. 1.- Introducción Es una potente herramienta que permite controlar la persistencia de nuestras aplicaciones contra cualquier base de datos, encapsulando la persistencia de objetos Java a bases de datos relacionales. Existen otras soluciones alternativas a Hibernate pero esta es una de las mas completas y con una amplia difusión en el desarrollo Java. Hibernate realiza automáticamente la inserción y recuperación en base de datos de cualquier objeto Java, haciendo transparente todo el proceso de conexión y las consultas SQL necesarias para insertar, actulizar, eliminar o recuperar la información. También permite manejar colecciones de objetos Java como ArrayList, Vector, Hashtable, Collection, Set y Map. ¿Qué es?

7. 1.- Introducción Hibernate es un motor de persistencia de código abierto que nos facilitará tareas como recuperar, guardar, modificar o eliminar objetos en una base de datos relacional. session.get(string tipo,id);|session.load(string tipo,id); session.save(miObjeto); session.saveOrUpdate(miObjeto); session.delete(miObjeto); Se configura mediante un archivo de configuración hibernate.properties ó hibernate.cfg.xml donde se definen los objetos con sus equivalencias en base de datos. En el archivo de configuración se asocia una Clase a una Tabla y cada Propiedad de la clase a una Columna de dicha tabla. ¿Qué es?

8. 1.- Introducción Resumen de características Reduce el código a escribir Fácil modelo de programación (POJO) Tiene estrategias avanzadas de cache (L1 y L2) Optimiza las SQL (nunca actualiza datos vacios) Tiene estrategias de carga perezosas Da independencia y abstracción sobre los proveedores de base de datos Mapea relaciones de tipos de objetos (one-to-one, one-to-many, many-to-many) Provee objetos desconectados Tiene soporte completo para JTA Tiene excelente integración con Spring

9. 2.- Elementos principales Modelo Clases a persistir Han de seguir las especificaciones JavaBeans Archivo de mapeo Relaciona el objeto a persistir co nuna entidad de la base de datos Archivo de configuración Se configura por ficheros de configuración en los cuales se indica Origen de datos Transacciones etc DAO Clase que aglomera todo el tratamiento de la persistencia

10. 3.- Librerías swarmcache-1.0rc2.jar (1.0rc2) runtime, optional jboss-cache.jar (1.2.2 alpha) TreeCache clustered cache- runtime, optional jgroups-2.2.8.jar (2.2.8) JGroups multicast library runtime, optional (required by replicated caches) jta.jar Standard JTA API runtime, required for standalone operation (outside application server) xml-apis.jar Standard JAXP API runtime, some SAX parser is required commons-logging-1.0.4.jar (1.0.4) Commons Logging runtime, required c3p0-0.9.1.jar (0.9.1) C3P0 JDBC connection pool runtime, optional (needed if using c3p0 as the connection pooling library) jboss-system.jar runtime, optional (required by TreeCache)

11. 3.- Librerias asm-attrs.jar (unknown) ASM bytecode library runtime, required if using 'cglib' bytecode provider jacc-1_0-fr.jar (1.0-fr) JACC Library runtime, optional checkstyle-all.jar Checkstyle Buildtime log4j-1.2.11.jar (1.2.11) Log4j Library runtime, optional junit-3.8.1.jar (3.8.1) JUnit test framework buildtime javassist.jar (3.4) Javassist bytecode generator runtime, required if using 'javassist' bytecode provider dom4j-1.6.1.jar (1.6.1) XML configuration & mapping parser runtime, required antlr-2.7.6.jar (2.7.6) ANother Tool for Language Recognition runtime, required cglib-2.1.3.jar (2.1.3) CGLIB bytecode generator runtime, required if using 'cglib' bytecode provider jboss-common.jar runtime, optional (required by TreeCache)

12. 3.- Librerias oscache-2.1.jar (2.1) OpenSymphony OSCache runtime, optional asm.jar ASM bytecode library runtime, required if using 'cglib' bytecode provider ant-launcher-1.6.5.jar (1.6.5) Ant launcher buildtime jaas.jar Standard JAAS API runtime, optional (required by JCA) ant-antlr-1.6.5.jar (1.6.5) Ant antlr support buildtime jboss-jmx.jar runtime, optional (required by TreeCache) cleanimports.jar Cleanimports buildtime xerces-2.6.2.jar (2.6.2) SAX parser runtime, required for JDK < 1.4 jaxen-1.1-beta-7.jar (1.1-beta-7) Jaxen - universal java xpath engine runtime, required if you want to deserialize a Configuration to improve startup performance ant-junit-1.6.5.jar (1.6.5) Ant junit support buildtime

13. 3.- Librerias ant-swing-1.6.5.jar (1.6.5) Ant swing support buildtime commons-collections-2.1.1.jar (2.1.1) Commons Collections runtime, required ant-1.6.5.jar (1.6.5) Ant core- buildtime proxool-0.8.3.jar (0.8.3) Proxool JDBC connection pool- runtime, optional (needed if using proxool as the connection pooling library) concurrent-1.3.2.jar (1.3.2) runtime, optional (required by TreeCache) syndiag2.jar (2.0) antlr to bnf image generator buildtime

14. 4.- Compatibilidad Oracle DB2 Sysbase MS SQL Server MySQL Interbase Informix Firebird Otras… Soporta algunas bases de datos como

15. 5.- diagrama de Arquitectura Arquitectura multicapas Hibernate usa los ficheros de configuración para proporcionar servicios de persistencia a las aplicaciones

16. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate

17. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate org.hibernate.SessionFactory Cache inmutable de los mapeos compilados para una base de datos. Es una factoria de Session y un cliente de ConnectionProvider. Puede almacenar un segundo nivel de cache de datos rehusables, entre transacciones, procesos o a nivel de cluster. SessionFactory

18. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate org.hibernate.Session Envuelve una conexión JDBC. Factoria de transaccionse Almacena el primer nivel de cache para los objetos persistentes cuando son buscados por identificador o mediante queries. Tiene un corto periodo de vida mientras la aplicación y la DB intercambian información. Session

19. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate Los objetos persistentes y las colecciones. Llamados también POJOS o JavaBeans Contienen el estado los datos persistentes Se asocian únicamente a una Session. Tan pronto como la Session se cierra, estos son desligados y liberados para ser utilizados en cualquier capa de la aplicación (DTO) Objetos persistentes

20. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate Todos los objetos que involucra hibernate (clases-tablas) pueden tener tres estados: Transient La instancia no esta asociada con ningún contexto de persistencia. No tiene identificador de persistencia (PK). Persistent Instancia asociada a un contexto persistente, su PK tiene valor y puede corresponder con una fila de base de datos. Detached La instancia estuvo asociada a un contexto pero este fue cerrado o fue serializada a otro proceso Estados de las instancias de los objetos persistentes

21. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate Objetos transitorios y colecciones Son instancias de las clases persistentes que no estan asociadas a una Session. Pueden ser instanciadas por la aplicación y no ser persistidas o pueden ser el resultado de un correcto cierre de la sesion (session.close()) Objetos transitorios

22. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate org.hibernate.Transaction (Opcional) Usado por las aplicaciones para indicar unidades de trabajo atómicas. Abstrae a la aplicación de las transacciones subjacentes de JDBC, JTA o CORBA. Una session puede crear múltiples transacciones en algunos casos. Toda transaccion se ha confirmar o rechazar. Transaction

23. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate org.hibernate.connection.ConnectionProvider (Opcional) Factoria de conexiones JDBC Abstrae a la aplicación del uso de DataSource o DriverManager. No esta expuesta para la aplicación, per o los desarrolladores lo pueden extender o implementar. ConnectionProvider

24. 5.- diagrama de Arquitectura Vista detallada de la arquitectura de Hibernate org.hibernate.TransactionFactory (Opcional) Factoria de instancias de transacciones. No esta expuesta para la aplicación, pero los desarrolladores pueden implementarla o extenderla. TransactionFactory

25. 5.- diagrama de Arquitectura API de Hibernate

26. Hibernate.cfg.xml Archivo XML principal de configuración de Hiberntate. Su estructura viene marcada por un fichero descriptivo llamado hibernate-configuration-3.0.dtd Contiene los datos de conexión con la base de datos. Contiene los mapeos a los ficheros descriptivos de las clases persistentes del dominio.

27. Hibernate.cfg.xml SessionFactory Property Mapping resource Si la SessionFactory no tiene un nombre se utiliza por defecto a nivel global de la aplicación, si se dispone de varias bases de datos hay que tener un SessionFactory por cada una, en diferentes ficheros de configuración. En las propiedades (Property) se definen los elementos necesarios para establecer las conexiones. Mediante la etiqueta Mapping se señala donde esta el fichero xml con el mapeo entre las clases Java y la tabla de la base de datos enlazada. Principales etiquetas

28. Hibernate.cfg.xml Principales etiquetas Las propiedades (property) hibernate.connection.driver_class : oracle.jdbc.driver.OracleDriver hibernate.connection.username : test hibernate.connection.password : test hibernate.connection.url : jdbc:oracle:thin:@localhost:1521:xe hibernate.dialect : org.hibernate.dialect.Oracle10gDialect hibernate.connection.autocommit : true Hibernate.showsql : true hibernate.default_schema : test cache.provider_class : org.hibernate.cache.NoCacheProvider hbm2ddl.auto : create hibernate.use_sql_comments : true Implemetación particular de SQL que Hibernate genera Muestra las sentencias SQL que Hibernate ejecuta Crea automáticamente el esquema de base de datos Desactiva la cache de segundo nivel Genera comentadios dentro de las sentencias SQL para facilitar la depuración

29. Hibernate.cfg.xml Principales dialectos de hibernate

30. Hibernate.cfg.xml En el apartado 7 se cubre la forma como se carga la configuración de hibernte con una clase utilitaria llamada HibernateUtil. Todos los nombres de las propiedades que soporta Hibernate estan definidos en org.hibernate.cfg.Environment Utilización y carga

31. 6.- Las clases persistentes Son las clases del modelo que se guardan en la base de datos y se pueden recuperar. Usualmente denominadas POJO(Plain Old Java Object) Toda clase persistente tiene un fichero descriptivo .hbm, el cual describe el mapeo entre la clase y la tabla de la base de datos asociada., Asi como parametros de actualización en cascada, composición del método ToString, y otros.

32. 6.- Las clases persistentes Han de cumplir una serie de requisitos: Métodos get y set para cada atributo de la clase. Constructor por defecto sin argumentos para que hibernate pueda instanciarla. Atributo identificador, en la clase persona el atributo id es el identificador de la clase y la PK de la tabla correspondiente. Es recomendable implementar los métodos equals() y hashcode(). Interfaz Lifecycle.- de forma opcional una clase persistente puede implementar esta interfaz, la cual permite ejecutar acciones después de alguna operación

33. 6.- Las clases persistentes Las clases persistentes pueden implementar esta interfaz de manera opcional. Proporciona callbacks desde la session hacia el objeto persistente. onSave .- invocado antes que el objeto sea almacenado. onUpdate .- Invocado antes que el objeto sea actualizado. onDelete .- Invocado antes que el objeto sea eliminado. onLoad .- invocado después que el objeto sea cargado de la base de datos. Interfaz Lifecycle

34. 6.- Las clases persistentes En aplicaciones reales se dan estructuras complicadas de base de datos, existiendo a veces múltiple dependencias entre objetos y diversas restricciones de integridad. Los ficheros de mapeo dan cobertura a los requisitos mencionados anteriormente mediante etiquetas que definen diversos tipos de clases como colecciones de objetos, herencias o clases persistentes cuyos atributos son otras clases persistentes. Mapeo de las clases

35. 6.- Las clases persistentes Mapeo de tipos de datos Mapeo de las clases

36. 6.- Las clases persistentes Ejemplo de clase mapeada - Categoria.hbm.xml <hibernate-mapping> <class name="edu.training.hibernate.Categoria" table="CATEGORIA"> <id name="idCategoria" type="big_decimal"> <column name="ID_CATEGORIA" precision="22" scale="0" /> <generator class="assigned" /> </id> <property name="nombre" type="string"> <column name="NOMBRE" length="100" /> </property> <set name="productos" inverse="true"> <key> <column name="ID_CATEGORIA" precision="22" scale="0" /> </key> <one-to-many class="edu.training.hibernate.Producto" /> </set> </class> </hibernate-mapping> El generador de claves primarias además de ser asignado manualmenete, tambien se puede establecer mediante una secuence: <generatorclass="sequence"> <param name="sequence">SEQ_de_oracle</param> </generator> Aunque tambien una clase personalizada que implemente de org.hibernate.id.IdentifierGenerator <generatorclass="edu.training.hibernate.generator.CustomGenerator">

37. 6.- Las clases persistentes Ejemplo de clase mapeada - Categoria.java public class Categoria implements java.io.Serializable { private BigDecimal idCategoria; private String nombre; private Set<Producto> productos = new HashSet<Producto>(0); public Categoria() { } public Categoria(BigDecimal idCategoria) { this.idCategoria = idCategoria; } public Categoria(BigDecimal idCategoria, String nombre, Set<Producto> productos) { this.idCategoria = idCategoria; this.nombre = nombre; this.productos = productos; }

38. 6.- Las clases persistentes Ejemplo de clase mapeada - Categoria.java public BigDecimal getIdCategoria() { return this.idCategoria; } public void setIdCategoria(BigDecimal idCategoria) { this.idCategoria = idCategoria; } public String getNombre() { return this.nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public Set<Producto> getProductos() { return this.productos; } public void setProductos(Set<Producto> productos) { this.productos = productos; } }

39. 6.- Las clases persistentes Restricciones de seguridad <Many-to-one>: Utilizada para definir relaciones de muchos a uno, como por ejemplo varios productos que pertenecen a un único pedido. <One-to-Many>: Es el caso contrario al anterior, en el fichero de mapeo de la clase pedido se podrá indicar que este puede contener varios productos. <One-to-one>: Para definir relaciones uno a uno y se utiliza para tablas que compartan la clave primaria o para referencias a una clave foránea. Mapeo de las clases

40. 6.- Las clases persistentes Colecciones de objetos Hibernate puede tratar instancias de: Map, Set, SortedMap, SortedSet, List, Cualquier array de objetos persistentes. Las etiquetas que pueden mapear esto son: <map>, <set>, <list>, <bag>, <array> y <primitive-array> Mapeo de las clases

41. 6.- Las clases persistentes La Herencia, en Hibernate es abordada de tres formas distintas. La más elegante es usar la misma tabla para almacenar los datos de las distintas clases de la misma familia Se puede observar que de la clase Perro heredan dos clases hijas que serian Mastin y Bulldog, esto se hace con la etiqueta <subclass>. Mapeo de las clases

42. 6.- Las clases persistentes La Herencia, en Hibernate es abordada de tres formas distintas. La segunda forma de herencia es guardar los datos de una subclase en otra tabla distinta sustituyendo la etiqueta <subclass>. La tercera forma es definir la herencia con una etiqueta class para cada clase de la familia, con lo que se guardarían en tablas independientes, sin ninguna relación entre ellas. Mapeo de las clases

43. 7.- utilización Lo primero que se deberíamos hacer para utilizar Hibernate es crear un objeto Configuration para indicarle donde esta el archivo de configuración.Configuration cfg = new Configuration();cfg.configure(“…ibernate.cfg.xml”); Ahora deberiamos abrir una sesión en Hibernate con el SessionFactory.SessionFactory sessionFactory = cfg.buildSessionFactory();Session session = sessionFactory.openSession(); Una session representa una conexión con la base de datos, es recomendable tener una clase que se especialice en darnos acceso de forma conveniente al SessionFactory Carga de configuración y el SessionFactory

44. 7.- utilización HibernateUtil publicclassHibernateUtil { privatestatic final SessionFactorysessionFactory; static { try { sessionFactory = new Configuration().configure().buildSessionFactory(); } catch (Throwable ex) { // Makesureyou log theexception, as itmight be swallowed System.err.println("InitialSessionFactorycreationfailed." + ex); throw new ExceptionInInitializerError(ex); } } publicstaticSessionFactorygetSessionFactory() { returnsessionFactory; } }

45. 7.- utilización Carga de un SessionFactory desde JNDI private final SessionFactorysessionFactory = getSessionFactory(); protectedSessionFactorygetSessionFactory() { try { return (SessionFactory) new InitialContext().lookup("SessionFactory"); } catch (Exception e) { log.error("CouldnotlocateSessionFactory in JNDI", e); throw new IllegalStateException( "CouldnotlocateSessionFactory in JNDI"); } }

46. 8.- carga de objetos por su id CRUD Para recuperar un objeto de la base de datos el objeto session dispone de los métodos load y get. Solo se debe utilizar load si se esta seguro que el objeto existe. El método get devuelve la instancia de un objeto o null si esta no existe. public Usuario findById(java.math.BigDecimalid) { log.debug("getting Usuario instancewith id: " + id); try { Usuario instance = (Usuario) sessionFactory.getCurrentSession() .get("edu.training.hibernate.Usuario", id); if (instance == null) { log.debug("getsuccessful, no instancefound"); } else { log.debug("getsuccessful, instancefound"); } returninstance; …………..

47. 8.- nuevos objetos persistentes CRUD Para almacenar todos los objetos de nueva creación en la base de datos es necesario invocar el método save del objeto session. Usuario usr = new Usuario(); usr.setApellidos("apellidos hibernate"); usr.setNombre("nombre hibernate"); usr.setPassword("password"); usr.setTipo("admin2"); usr.setUsuario("hib@hib.org2"); ses.save(usr);

48. 8.- búsqueda de objetos Uso de criterios de búsqueda La clase org.hibernate.Criteria, esta es un API para recuperar entidades mediante la composición de criterios y que es capaz de devolver múltiples resultados. publicList<Usuario> findByExample(Usuario instance) { log.debug("finding Usuario instancebyexample"); try { Criteriacriterio = sessionFactory .getCurrentSession().createCriteria("edu.training.hibernate.Usuario"); criterio.add(create(instance)); List<Usuario> results = (List<Usuario>) criterio.list(); log.debug("findbyexamplesuccessful, resultsize: "+ results.size()); returnresults; } catch (RuntimeException re) { } …………..

49. 8.- búsqueda de objetos Uso de criterios de búsqueda Listcats = session.createCriteria(Cat.class) .add( Restrictions.like("name", "Iz%") ) .add( Restrictions.gt( "weight", new Float(minWeight) ) ) .addOrder( Order.asc("age") ) .list();

50. 8.- Actualización de objetos La actualización de la base de datos se puede hacer de dos formas distintas La primera mediante el método flush del objeto session. Este método hace que se actualice en la base de datos que estén en memoria en el estado actual. Se recomienda su uso antes de : Hacer un commit Cerrar una session Dependiendo del parametro flush-mode, Transaction.commit() llama al método flush. La otra forma es utilizando el método saveOrUpdate, el cual graba un objeto nuevo o lo actualiza, dependiendo del valor almacenado en unsaved-value.Esta operación se lanza en cascada en sus instancias asociadas si en el fichero de mapeo se encuentra cascade="save-update". CRUD

51. 8.- Actualización de objetos CRUD publicvoidattachDirty(Usuario instance) { log.debug("attachingdirty Usuario instance"); try { sessionFactory.getCurrentSession().saveOrUpdate(instance); log.debug("attachsuccessful"); } catch (RuntimeException re) { log.error("attachfailed", re); throw re; } }

52. 8.- Borrado de objetos CRUD Para eliminar un objeto existe el método delete del objeto session. También es posible eliminar varios objetos con una sola llamada al método delete pasándole una query. publicvoiddelete(Usuario persistentInstance) { log.debug("deleting Usuario instance"); try { sessionFactory.getCurrentSession().delete(persistentInstance); log.debug("deletesuccessful"); } catch (RuntimeException re) { log.error("deletefailed", re); throw re; } }

53. 8.- Sincronización de datos CRUD - session.flush() Llegado el momento en que la session ha ejecutar las sentencias SQL y volcar el estado de los objetos en la base de datos, la session dispone de un método llamado flush, el cual se encarga de hacer esto. El proceso de flush ocurre por defecto en los siguientes puntos: Antes de la ejecución de las queries Desde el commit de una transaccion Desde session.flush() Las sentencias SQL son ejecutadas en el siguiente orden: Todos los inserts en el orden en el que hayan sido guardados (session.save()) Todas las actualizaciones Todas las sentencias de borrado

54. 9.- Transacciones Hibernate utiliza directamente conexiones JDBC y recursos JTA sin añadir comportamientos adicionales de bloqueo. Hibernate no bloquea los objetos en memoria. Mediante el objeto Session, Hibernate proporciona multiples lecturas de objetos por su identificador y las queries de entidades. El objeto SessionFactory es costoso de crear, pero puede ser compartido por todos los threads de la aplicación, este suele ser creado una vez cuando la aplicación se inicia desde una instancia del objeto Configuration. Transacciones y concurrencia

55. 9.- Transacciones Una Session no es cara de crear (no es threadsafe), se suele utilizar en una petición o unidad de trabajo y posteriormente es descatado y sobre todo no obtiene una conexión JDBC hasta que no es realmente necesario. Una transaccion ha de durar lo menos posible para reducir la contención de bloqueo en la base de datos. Las transacciones de periodos muy largos pueden impedir que la aplicación escale durante una fuerte carga de concurrencia. Transacciones y concurrencia

56. 9.- Transacciones Transaction tx = session.beginTransaction(); tx.commit(); tx.rollback(); Transaction

57. 9.- Transacciones Ejemplo simple de Transaction publicstaticvoidmain(String[] args) { Configurationcfg = new Configuration(); SessionFactoryfactory = cfg.configure().buildSessionFactory(); Sessionsession = factory.openSession(); Transactiontx = session.beginTransaction(); Messagesmessage = new Messages(); message.setMessageText(“HelloWorld); session.save(message); tx.commit(); }

58. 10.- hibernatequerylanguage SQL orientado a objetos Clases y atributos vs. Tablas y columnas Asociaciones, polimorfismo Soporta operaciones relacionales Proyección, agregación, grupos Subconsultas Funciones SQL HQL

59. 10.- hibernatequerylanguage Lenguaje de consultas de Hibernate similar al SQL, pero orientado a objetos. Ej.: from paquete.Persona La cláusula select es opcional, es necesario indicar el paquete al que pertenece la clase, por que en las consultas es el nombre de las clases el que se utiliza y NO el de la tabla de base de datos. En la cláusula select hay que hacer referencia a los atributos de la clase, ya que es la propia clase la que es referenciada en la consulta y NO la tabla en la que se almacena. Select per.nombre from paquete.Persona per Como en SQL se pueden usar alias en los nombres de las tablas. HQL

60. 10.- hibernatequerylanguage Cuenta con las típicas funciones matemáticas que se pueden utilizar. El polimorfismo en las consultas se trata de una manera muy sencilla, si se hace una consulta sobre una clase, también se devolverán sus subclases from java.lang.Object o Esta consulta devolverá todos los objetos persistentes. HQL

61. 10.- hibernatequerylanguage La cláusula where, es muy similar a la de SQL. La ventaja es que se pueden referenciar los atributos de la clase que se consulte, incluso si es un array. Los operadores habituales disponibles son : =, >=, <=, <>, ¡=, like. HQL

62. 10.- hibernatequerylanguage El resto de cláusulas típicas de SQL tambien se pueden utilizar en HQL como: group by having order by Etc... HQL

63. 10.- Consultas hql Métodos Cuando no se conoce el identificador de los objetos a cargar, Hibernate nos proporciona un mecanismo de consultas para ubicarlos y cargarlos desde la base de datos. Este mecanismo se conoce como HQL, el cual permite hacer consultas directamente sobre las clases java. El método createQuery (String consulta) del objeto session permite crear consultas HQL, para luego invocar al método list(). Las consultas tambien se pueden expresar en SQL nativo con el soporte de Hiberntate para convertir el conjunto de resultados en objetos Java. Las consultas HQL y el SQL nativo se representa con una instancia de org.hibernate.Query, este ofrece métodos para enlazar parametros, manejo de resultados y ejecución de la query asociada.

64. 10.- Consultas hql Métodos Para poder controlar los resultados que devuelve una consulta, como puede ser el número máximo de filas o la primera fila que se debe devolver, se puede crear una instancia de la clase Query. Como se aprecia hay diferentes maneras de recuperar los datos de las tablas con Hibernate, sin utilizar SQL, de todas maneras es posible realizar consultas en SQL nativo, si así se desea.

65. 10.- Consultas hql Consultas con parámetros Query q = session.createQuery("from Categoria where nombre like :pnombre order by nombre desc"); q.setString("pnombre", "%ad%"); List<Categoria> results = (List<Categoria>) q.list(); System.out.println("resultados devueltos : " + results.size()); if(results.size() > 0 ){ for(Categoria c : results){ System.out.println("Id : " + c.getIdCategoria()); System.out.println("Nombre : " + c.getNombre()); } }

66. 10.- Consultas hql Resultados escalares Iterator results = sess.createQuery( "select cat.color, min(cat.birthdate), count(cat) from Cat cat " + "group by cat.color") .list() .iterator(); while ( results.hasNext() ) { Object[] row = (Object[]) results.next(); Color type = (Color) row[0]; Date oldest = (Date) row[1]; Integer count = (Integer) row[2]; ..... }

67. 10.- Consultas hql Filtrado por conjunto de valores //named parameter list List names = new ArrayList(); names.add("Izi"); names.add("Fritz"); Query q = sess.createQuery( "from DomesticCat cat where cat.name in (:namesList)"); q.setParameterList("namesList", names); List cats = q.list();

68. 10.- Consultas sql Nativas Externalización de consultas en ficheros Se pueden definir consultas HQL y almacenarlas en un fichero asignandoles un nombre a cada una de ellas y estableciendo el mapping dentro del Hibernte.cfg.xml como si fuera el mapeo de una clase. <hibernate-mapping> <query name="CategoriasPorNombre"><![CDATA[ from Categoria where nombre like :pnombre order by nombredesc ]]></query> </hibernate-mapping> Query q = session.getNamedQuery("CategoriasPorNombre"); q.setString("pnombre", "%ad%"); List<Categoria> results = (List<Categoria>) q.list();

69. 10.- Consultas nativas sql createSQLQuery Se pueden definir consultas HQL y almacenarlas en un fichero asignandoles un nombre a cada una de ellas y estableciendo el mapping dentro del Hibernte.cfg.xml como si fuera el mapeo de una clase. Las consultas sql tambien pueden ser externalizadas y tener parametros. Listcats = session.createSQLQuery( "SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, " + "{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... " + "FROM CAT {cat} WHERE ROWNUM<10", "cat", Cat.class ).list()

70. 11.- caché La caché es un mecanismo que nos permite almacenar nuestras estructuras de datos en memoria, evitándonos volver a buscar nuevamente los datos en la BBDD que además se puede compartir con otros sistemas. El usuario consulta Si la aplicación la tiene en caché se devuelven los datos directamente. Si la aplicación NO la tiene la recupera de la fuente de datos asociada, la almacena en caché y devuelve los datos. Presenta problemas de inconsistencia de datos cuando hay mas de una caché con los mismos datos cargados ya que podrían cambiar sin que una de las caches se entere.

71. 11.- caché Ofrece una caché de dos niveles (L1 y L2), donde solo el primero es obligatorio. También incluye una caché de consultas, pudiendo obtener rápidamente resultados que hayan sido consultados previamente.

72. Presentación Interpretación Servicios Spring Framework IoC, AOP Integración 12.- hibernate y spring Arquitectura de aplicaciones Spring con Hibernate JSP/ JSF / Struts / Spring MVC Managers – Classes Java Orientación a Aspectos Services – Classes Java Hibernate Wrappers JAAS PL/SQL LDAP Relational DDBB

73. 12.- hibernate y spring Diseño Spring con Hibernate Manager / Delegate <<interfaz>> Service Service Impl Spring <<interfaz>> DAO HibernateDaoSupport DAO Impl Modelo / POJOs Ficheros de mapping Hibernate

74. 12.- hibernate y spring Administra la SessionFactory y la Session. Administración declarativa de transacciones en contenedores ligeros. Fácil de testear (se puede añadir una SessionFactory vía ficheros XML) Pocas lineas de código (enfocado más en el negocio) Modulo Spring ORM : Soporte para Hibernate

75. 12.- hibernate y spring HibernateTemplate Proporcionado por Spring Hibernate AOP Los DAO necesitan extender de HibernateDAOSupport Los métodos de los DAO son limpios TransactionTemplate Permite la ejecución de código transaccional sin necesidad de re-implementar los workflows Ejecuta rollbacks si los callbacks originan alguna excepción TransactionInterceptor Los bussines objects no necesitan ser conscientes de las transacciones. Soporta excepciones checked y unchecked Modulo Spring ORM : Soporte para Hibernate

76. 12.- hibernate y spring Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); try { session.saveOrUpdate(timesheet); session.getTransaction().commit(); } catch (HibernateException e) { session.getTransaction().rollback(); throw e; } getHibernateTemplate().saveOrUpdate(timesheet); Modulo Spring ORM : Soporte para Hibernate

77. 13.- Logging Modo Debug activado

78. Parte prácticahibernate 3.2

79. Instalación Tenemos que descargarlo de http://www.hibernate.org/ Hay que colocar sus JARs dentro del directorio LIB de nuestra aplicación. Los ficheros de configuración de cada clase deben ir acompañando a sus fuentes (src....) Debemos colocar el fichero de configuración de Hibernate hibernate.cfg.xml en la raíz del directorio src

80. Utilización – Ejemplo simple Pasos Crear una tabla en la base de datos Clase equivalente en código java Crear el fichero de mapeo, los cuales indican la correspondencia entre los atributos de la clase y los de la tabla de la base de datos. Código Java de utilización del API de Hibernate.

81. Utilización – Ejemplo simple Creación de la tabla en la base de datos.CREATE TABLE persona (id VARCHAR(32) NOT NULL PRIMARY KEY, edad INTEGER NOT NULL, nombre VARCHAR(255) NOT NULL);

82. Utilización – Ejemplo simple La clase persistente

83. Utilización – Ejemplo simple Fichero de mapeo Persona.hbm.xml, ubicado en el mismo directorio que la clase compilada.

84. Utilización – Ejemplo simple Código Java de utilización del API de Hibernate Insertando en la base de datos Recuperando un objeto por su identificador

85. Jboss ide - hibernate tools Una herramienta útil para hacer proyectos Hibernate es Hibernate-Tools, que viene incorporada dentro de JBossIDE El update-site de eclipse es: http://download.jboss.org/jbosstools/updates/stable/ Diapositivas con un el desarrollo de un proyecto de persistencia.

86. - FIN - Licensed under Creative Commons Attribution 3