Your SlideShare is downloading. ×
Hibernate 3.2 short manual
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Hibernate 3.2 short manual

27,366
views

Published on

Manual introductorio a Hibernate 3.2

Manual introductorio a Hibernate 3.2

Published in: Technology

4 Comments
19 Likes
Statistics
Notes
No Downloads
Views
Total Views
27,366
On Slideshare
0
From Embeds
0
Number of Embeds
9
Actions
Shares
0
Downloads
0
Comments
4
Likes
19
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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(“…hibernate.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

×