HIBERNATE - Persistencia Relacional para Java Idiomático

Documentación de Referencia de Hibernate

por Gavin King, Christian Bauer, Max Rydahl Andersen, Emmanuel Bernard, y Steve Ebersole

and thanks to James Cobb (Graphic Design), Cheyenne Weaver (Graphic Design), y Bernardo Antonio Buffa Colom&#x00e9

3.3.2.GA

Legal Notice

June 24, 2009

Prefacio

1. Feedback

1. Tutorial

1.1. Parte 1 - La primera Aplicación Hibernate

1.1.1. Setup
1.1.2. La primera clase
1.1.3. El fichero de mapeo
1.1.4. Configuración de Hibernate
1.1.5. Building with Maven
1.1.6. Esto dirá a Ant que agregue todos los ficheros en el directorio lib que terminen con .jar al classpath usado para la compilación. También copiará todos los ficheros que no sean código Java al directorio objetivo, por ejemplo, ficheros de configuración y mapeos de Hibernate. Si ahora corres Ant, debes obtener esta salida:
1.1.7. Esto también debe compilar sin problemas. Finalmente necesitamos configurar un sistema de logging (registro). Hibernate usa commons logging y te deja la elección entre Log4J y logging de JDK 1.4. La mayoría de los desarrolladores prefieren Log4J: copia log4j.properties de la distribución de Hibernate (está en el directorio etc/) a tu directorio src, junto a hibernate.cfg.xml. Echa una mirada a la configuración de ejemplo y cambia los ajustes si te gusta tener una salida más verborrágica. Por defecto, sólo se muestra el mensaje de arranque de Hibernate en la salida.

1.2. Note: Most new Hibernate users fail at this point and we see questions about Table not found error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again.

1.2.1. Hemos mapeado un clase de entidad persistente a una tabla. Construyamos sobre esto y agreguemos algunas asociaciones de clase. Primero agregaremos personas a nuestra aplicación, y almacenaremos una lista de eventos en las que participan.
1.2.2. Crearemos ahora una asociación entre estas dos entidades. Obviamente, las personas pueden participar en eventos, y los eventos tienen participantes. Las cuestiones de diseño con que tenemos que tratar son: direccionalidad, multiplicidad y comportamiento de colección.
1.2.3. _____________ __________________ | | | | _____________ | EVENTS | | PERSON_EVENT | | | |_____________| |__________________| | PERSON | | | | | |_____________| | *EVENT_ID | <--> | *EVENT_ID | | | | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | | TITLE | |__________________| | AGE | |_____________| | FIRSTNAME | | LASTNAME | |_____________|
1.2.4. Colección de valores
1.2.5. Asociaciones bidireccionales
1.2.6. Trabajando enlaces bidireccionales

1.3. Part 3 - The EventManager web application

1.3.1. Writing the basic servlet
1.3.2. Processing and rendering
1.3.3. Deploying and testing

1.4. Summary

2. Arquitectura

2.1. Visión General
2.2. Estados de instancia
2.3. Integración JMX
2.4. Soporte JCA:
2.5. Contextual sessions

3. Configuración

3.1. Configuración programática

3.2. Obteniendo una SessionFactory

3.3. Conexiones JDBC

3.4. Parámetros de configuración opcionales

3.4.1. SQL Dialects
3.4.2. Recuperación por Unión Externa (Outer Join Fetching)
3.4.3. Flujos Binarios
3.4.4. Caché de segundo nivel y de lectura
3.4.5. Sustitución de Lenguaje de Consulta
3.4.6. Hibernate statistics

3.5. Registros de mensajes (Logging)

3.6. Implementando una NamingStrategy

3.7. Fichero de configuración XML

3.8. Integració con Servidores de Aplicaciones J2EE

3.8.1. Configuración de la estrategia de transacción
3.8.2. SessionFactory ligada a JNDI
3.8.3. Ligado automático de JTA y Session
3.8.4. Despliegue JMX

4. Clases Persistentes

4.1. Un ejemplo simple de POJO

4.1.1. Implementa un constructor sin argumentos
4.1.2. Provee una propiedad identificadora (opcional)
4.1.3. Prefiere las clases no finales (opcional)
4.1.4. Declara métodos de acceso y modificación para los campos persistentes (opcional)

4.2. Implementando herencia

4.3. Implementando equals() y hashCode()

4.4. Modelos dinámicos

4.5. UNTRANSLATED!!! Tuplizers

4.6. EntityNameResolvers

5. Mapeo O/R Básico

5.1. Declaración de mapeo

5.1.1. Doctype
5.1.2. Hibernate-mapping
5.1.3. Class
5.1.4. id
5.1.5. Enhanced identifier generators
5.1.6. Identifier generator optimization
5.1.7. composite-id
5.1.8. Discriminator
5.1.9. Version (optional)
5.1.10. Timestamp (optional)
5.1.11. Property
5.1.12. Many-to-one
5.1.13. One-to-one
5.1.14. Natural-id
5.1.15. Component and dynamic-component
5.1.16. Properties
5.1.17. Subclass
5.1.18. Joined-subclass
5.1.19. Union-subclass
5.1.20. Join
5.1.21. Key
5.1.22. Column and formula elements
5.1.23. Import
5.1.24. Any

5.2. Hibernate types

5.2.1. Entidades y Valores
5.2.2. Tipos de valores básicos
5.2.3. Tipos de valor personalizados

5.3. Mapeando una clase más de una vez

5.4. identificadores SQL encomillados

5.5. Alternativas de metadatos

5.5.1. Usando marcado de XDoclet
5.5.2. Usando anotaciones JDK 5.0

5.6. Generated properties

5.7. Auxiliary database objects

6. Collection mapping

6.1. Colecciones persistentes

6.2. Mapeos de colección

6.2.1. Claves foráneas de collección
6.2.2. Elementos de collección
6.2.3. Colecciones indexadas
6.2.4. Colecciones de valores y asociaciones muchos-a-muchos
6.2.5. Asociaciones uno-a-muchos

6.3. Mapeos de colección avanzados

6.3.1. Colecciones ordenadas
6.3.2. Asociaciones bidireccionales
6.3.3. Asociaciones bidireccionales con colecciones indexadas
6.3.4. Asociaciones ternarias
6.3.5. Usando un <idbag>

6.4. Ejemplos de colección

7. Mapeos de Asociación

7.1. Introducción

7.2. Asociaciones Unidireccionales

7.2.1. Many-to-one
7.2.2. One-to-one
7.2.3. One-to-many

7.3. Asociaciones unidireccionales con tablas de unión

7.3.1. One-to-many
7.3.2. Many-to-one
7.3.3. One-to-one
7.3.4. Many-to-many

7.4. Asociaciones Bidireccionales

7.4.1. one-to-many / many-to-one
7.4.2. One-to-one

7.5. Asociaciones bidireccionales con tablas de unión

7.5.1. one-to-many / many-to-one
7.5.2. uno a uno
7.5.3. Many-to-many

7.6. UNTRANSLATED! More complex association mappings

8. Mapeo de Componentes

8.1. Objetos dependientes
8.2. Colecciones de objetos dependientes
8.3. Componentes como índices de Map
8.4. Componentes como identificadores compuestos
8.5. Componentes dinámicos

9. Inheritance mapping

9.1. The three strategies

9.1.1. Tabla por jerarquía de clases
9.1.2. Tabla por subclase
9.1.3. Table per subclass: using a discriminator
9.1.4. Mezclando tabla por jerarquía de clases con tabla por subclase
9.1.5. Tabla por clase concreta
9.1.6. Table per concrete class using implicit polymorphism
9.1.7. Mezclando polimorfismo implícito con otros mapeos de herencia

9.2. Limitaciones

10. Trabajando con objetos

10.1. Estados de objeto de Hibernate

10.2. Haciendo los objetos persistentes

10.3. Cargando un objeto

10.4. Consultando

10.4.1. Ejecutando consultas
10.4.2. Filtrando colecciones
10.4.3. Consultas de criterios
10.4.4. Consultas en SQL nativo

10.5. Modificando objetos persistentes

10.6. Modificando objetos separados

10.7. Detección automática de estado

10.8. Borrando objetos persistentes

10.9. Replicando objetos entre dos almacénes de datos diferentes

10.10. Limpiando (flushing) la sesión

10.11. Persistencia transitiva

10.12. Usando metadatos

11. Transactions and Concurrency

11.1. Ámbitos de sesión y de transacción

11.1.1. Unidad de trabajo
11.1.2. Transacciones de aplicación
11.1.3. Considerando la identidad del objeto
11.1.4. Temas comunes

11.2. Demarcación de la transacción de base de datos

11.2.1. Entorno no manejado
11.2.2. Usando JTA
11.2.3. Manejo de excepciones
11.2.4. Transaction timeout

11.3. Control optimista de concurrencia

11.3.1. Chequeo de versiones de aplicación
11.3.2. Sesión larga y versionado automático
11.3.3. Objetos separados y versionado automático
11.3.4. Personalizando el versionado automático

11.4. Pessimistic locking

11.5. Connection release modes

12. Interceptores y eventos

12.1. Interceptores
12.2. Sistema de eventos
12.3. Seguridad declarativa de Hibernate

13. Procesamiento por lotes

13.1. Inserciones en lote
13.2. Actualizaciones en lote
13.3. UNTRANSLATED! The StatelessSession interface
13.4. update/delete en masa

14. HQL: El Lenguaje de Consulta de Hibernate

14.1. Sensibilidad a Mayúsculas
14.2. La cláusula from
14.3. Asociaciones y uniones (joins)
14.4. UNTRANSLATED!!! Forms of join syntax
14.5. Referring to identifier property
14.6. La cláusula select
14.7. Funciones de agregación
14.8. Consultas polimórficas
14.9. La cláusula where
14.10. Expresiones
14.11. La cláusula order by
14.12. La cláusula group by
14.13. Subconsultas
14.14. Ejemplos de HQL
14.15. Sentencias UPDATE y DELETE masivas
14.16. Consejos y Trucos
14.17. UNTRANSLATED! Components
14.18. Row value constructor syntax

15. Consultas por Criterios

15.1. Creando una instancia de Criteria
15.2. Estrechando el conjunto resultado
15.3. Ordenando los resultados
15.4. Asociaciones
15.5. Recuperación dinámica de asociaciones
15.6. Consultas por ejemplos
15.7. Proyecciones, agregación y agrupamiento
15.8. Consultas y subconsultas separadas
15.9. Consultas por identificador natural

16. SQL Nativo

16.1. Using a SQLQuery

16.1.1. Scalar queries
16.1.2. Entity queries
16.1.3. Handling associations and collections
16.1.4. Returning multiple entities
16.1.5. Returning non-managed entities
16.1.6. Handling inheritance
16.1.7. Parameters

16.2. Consultas SQL con nombre

16.2.1. Usando return-property para especificar explícitamente nombres de columna/alias
16.2.2. Usando procedimientos almacenados para consultar

16.3. SQL personalizado para crear, actualizar y borrar

16.4. SQL personalizado para carga

17. Filtrando datos

17.1. Filtros de Hibernate

18. Mapeo XML

18.1. Trabajando con datos XML

18.1.1. Especificando los mapeos de XML y de clase juntos
18.1.2. Especificando sólo un mapeo XML

18.2. Mapeo de metadatos XML

18.3. Manipulando datos XML

19. Mejorando el rendimiento

19.1. Estrategias de recuperación

19.1.1. Trabajando con asociaciones perezosas
19.1.2. Afinando las estrategias de recuperación
19.1.3. Proxies de asociaciones de un solo extremo
19.1.4. Inicializando colecciones y proxies
19.1.5. Usando recuperación en lotes
19.1.6. Usando recuperación por subselección
19.1.7. Usando recuperación perezosa de propiedades

19.2. El Caché de Segundo Nivel

19.2.1. Mapeos de caché
19.2.2. Estrategia: sólo lectura (read only)
19.2.3. Estrategia: lectura/escritura (read/write)
19.2.4. Estrategia: lectura/escritura no estricta (nonstrict read/write)
19.2.5. Estrategia: transaccional
19.2.6. Cache-provider/concurrency-strategy compatibility

19.3. Gestionando los cachés

19.4. El Caché de Consultas

19.5. Entendiendo el rendimiento de Colecciones

19.5.1. Taxonomia
19.5.2. Las listas, mapas, idbags y conjuntos son las colecciones más eficientes de actualizar
19.5.3. Los Bags y las listas son las colecciones inversas más eficientes
19.5.4. Borrado de un solo tiro

19.6. Monitoreando el rendimiento

19.6.1. Monitoreando una SessionFactory
19.6.2. Métricas

20. Guía del Conjunto de Herramientas

20.1. Generación automática de esquemas

20.1.1. Personalizando el esquema
20.1.2. Ejecutando la herramienta
20.1.3. Propiedades
20.1.4. Usando Ant
20.1.5. Actualizaciones incrementales de esquema
20.1.6. Usando Ant para actualizaciones incrementales de esquema
20.1.7. Schema validation
20.1.8. Using Ant for schema validation

21. Ejemplo: Padre/Hijo

21.1. Una nota sobre las colecciones
21.2. Uno-a-muchos bidirectional
21.3. Ciclo de vida en cascada
21.4. Tratamiento en cascada y unsaved-value
21.5. Conclusión

22. Ejemplo: Aplicación de Weblog

22.1. Clases Persistentes
22.2. Mapeos de Hibernate
22.3. Código Hibernate

23. Ejemplo: Varios Mapeos

23.1. Empleador/Empleado

23.2. Autor/Obra

23.3. Cliente/Orden/Producto

23.4. Mapeos misceláneos de ejemplo

23.4.1. Asociación uno-a-uno "Tipificada"
23.4.2. Ejemplo de clave compuesta
23.4.3. Muchos-a-muchos con atributo de clave compuesta compartido
23.4.4. Discriminación basada en contenido
23.4.5. Asociaciones sobre claves alternativas

24. Mejores Prácticas

25. Database Portability Considerations

25.1. Portability Basics
25.2. Dialect
25.3. Dialect resolution
25.4. Identifier generation
25.5. Database functions
25.6. Type mappings

References

SiguientePrefacio