HIBERNATE - Persistenza Relazionale Idiomatica per Java

Documentazione di Riferimento

2.1.6


Sommario

Prefazione
1. Primi passi con Tomcat
1.1. Iniziare a lavorare con Hibernate
1.2. La prima classe persistente
1.3. Mappare il gatto
1.4. Giochiamo con i gatti
1.5. Infine
2. Architettura
2.1. Introduzione
2.2. Integrazione con JMX
2.3. Supporto a JCA
3. Configurazione della SessionFactory
3.1. Configurazione programmativa
3.2. Ottenere una SessionFactory
3.3. Connessioni JDBC fornite dall'utente
3.4. Connessioni JDBC fornite da Hibernate
3.5. Configurazione di proprietà opzionali
3.5.1. Dialetti SQL
3.5.2. Reperimento via join esterno
3.5.3. Flussi (stream) binari
3.5.4. CacheProvider personalizzati
3.5.5. Configurazione della strategia transazionale
3.5.6. SessionFactory pubblicata sul JNDI
3.5.7. Sostituzioni per il linguaggio di interrogazione
3.6. Traccia di esecuzione (logging)
3.7. Implementazione di una strategia di denominazione (NamingStrategy)
3.8. File di configurazione XML
4. Le classi persistenti
4.1. Un semplice esempio POJO
4.1.1. Dichiarate metodi di accesso e di impostazione (get e set) per i campi persistenti
4.1.2. Implementate un costruttore di default
4.1.3. Fornite una proprietà identificatore (opzionale)
4.1.4. Preferite classi non-final (opzionale)
4.2. Utilizzo dell'ereditarietà
4.3. Implementate equals() e hashCode()
4.4. Punti di richiamo del ciclo di vita degli oggetti ("lifecycle callbacks")
4.5. Punto di aggancio (callback) Validatable
4.6. Utilizzo del contrassegno (markup) di XDoclet
5. Mappaggio O/R di base
5.1. Dichiarazione dei mappaggi
5.1.1. Doctype
5.1.2. hibernate-mapping
5.1.3. class
5.1.4. id
5.1.4.1. generator
5.1.4.2. Algoritmo Hi/Lo
5.1.4.3. Algoritmo UUID
5.1.4.4. Colonne "Identity" e "Sequence"
5.1.4.5. Identificatori assegnati
5.1.5. composite-id
5.1.6. discriminatori
5.1.7. versione (opzionale)
5.1.8. timestamp (opzionale)
5.1.9. property
5.1.10. many-to-one
5.1.11. one-to-one
5.1.12. component, dynamic-component
5.1.13. subclass
5.1.14. joined-subclass
5.1.15. map, set, list, bag
5.1.16. import
5.2. Tipi di Hibernate
5.2.1. Entità e valori
5.2.2. Tipi di valore di base
5.2.3. Tipi di enumerazione persistente
5.2.4. Tipi di valore personalizzati
5.2.5. Tipi di mappaggio "any"
5.3. Identificatori SQL tra virgolette
5.4. File di mappaggio modulari
6. Mappaggio delle collezioni
6.1. Collezioni persistenti
6.2. Come mappare una collezione
6.3. Collezioni di valori e associazioni molti-a-molti
6.4. Associazioni uno-a-molti
6.5. Inizializzazione differita (lazy)
6.6. Collezioni ordinate
6.7. L'uso degli <idbag>
6.8. Associazioni bidirezionali
6.9. Associazioni ternarie
6.10. Associazioni eterogenee
6.11. Esempi di collezioni
7. Mappaggio dei componenti
7.1. Oggetti dipendenti
7.2. Collezioni di oggetti dipendenti
7.3. Componenti come indici delle mappe
7.4. Componenti come identificatori composti
7.5. Componenti dinamici
8. Mappaggio di gerarchie di ereditarietà
8.1. Le tre strategie
8.2. Limitazioni
9. Lavorare con i dati persistenti
9.1. Creazione di un oggetto persistente
9.2. Caricamento di un oggetto
9.3. Interrogazioni
9.3.1. Interrogazioni scalari
9.3.2. L'interfaccia Query
9.3.3. Iterazioni scrollabili
9.3.4. Filtraggio delle collezioni
9.3.5. Interrogazioni per criteri
9.3.6. Interrogazioni in SQL nativo
9.4. Aggiornamento degli oggetti
9.4.1. Aggiornamento nella stessa Session
9.4.2. Aggiornamento di oggetti sganciati
9.4.3. Riaggancio di oggetti sganciati
9.5. Cancellazione di oggetti persistenti
9.6. Scaricamento (flush)
9.7. Fine di una sessione
9.7.1. Scaricamento della sessione
9.7.2. Commit della transazione sul database
9.7.3. Chiusura della sessione
9.7.4. Gestione delle eccezioni
9.8. Cicli di vita e grafi di oggetti
9.9. Intercettatori (interceptors)
9.10. API dei metadati
10. Transazioni e concorrenza
10.1. Configurazioni, sessioni e "factory"
10.2. Thread e connessioni
10.3. Considerazioni sull'identità degli oggetti
10.4. Controllo di concorrenza ottimistico
10.4.1. Sessione lunga con versionamento automatico
10.4.2. Sessioni multiple con versionamento automatico
10.4.3. Controllo delle versioni da parte dell'applicazione
10.5. Disconnessione della sessione
10.6. Locking Pessimistico
11. HQL: Il linguaggio di interrogazione di Hibernate (Hibernate Query Language)
11.1. Dipendenza da maiuscole e minuscole
11.2. La clausola from
11.3. Associazioni e join
11.4. La clausola select
11.5. Funzioni aggregate
11.6. Interrogazioni polimorfiche
11.7. La clausola where
11.8. Espressioni
11.9. La clausola order by
11.10. La clausola group by
11.11. Sottointerrogazioni
11.12. Esempi HQL
11.13. Suggerimenti
12. Interrogazioni per criteri
12.1. Creazione di un'istanza di Criteria
12.2. Riduzione dell'insieme dei risultati
12.3. Ordinamento dei risultati
12.4. Associazioni
12.5. Caricamento dinamico delle associazioni
12.6. Interrogazioni per esempi
13. Interrogazioni SQL native
13.1. Creazione di una Query basaa su SQL
13.2. Alias e riferimenti alle proprietà
13.3. Interrogazioni SQL con nome
14. Ottimizzare le prestazioni di Hibernate
14.1. Capire gli aspetti legati alle prestazioni delle collezioni
14.1.1. Tassonomia
14.1.2. Liste, mappe e insiemi sono le collezioni più efficienti da modificare
14.1.3. I bag e le liste sono le collezioni inverse più efficienti
14.1.4. Cancellazione in un colpo solo
14.2. Mediatori (proxy) per l'inizializzazione a richiesta (lazy)
14.3. La cache di secondo livello
14.3.1. Mappaggi e cache
14.3.2. Strategia: sola lettura
14.3.3. Strategia: lettura/scrittura
14.3.4. Strategia: lettura/scrittura non stretta
14.3.5. Strategia: transazionale
14.4. Gestione della cache di Session
14.5. La cache delle query
15. Guida degli strumenti
15.1. Generazione dello schema
15.1.1. Personalizzazione dello schema
15.1.2. Esecuzione del programma
15.1.3. Proprietà
15.1.4. Utilizzo di Ant
15.1.5. Aggiornamenti incrementali dello schema
15.1.6. Utilizzo di Ant per gli aggiornamenti incrementali dello schema
15.2. Generazione di codice
15.2.1. Il file di configurazione (opzionale)
15.2.2. L'attributo meta
15.2.3. Generatore elementare di metodi individuatori ("finder")
15.2.4. Generatore basato su Velocity
15.3. Generazione dei file di mappaggio
15.3.1. Esecuzione dello strumento
16. Esempio: Genitore/Figlio (Parent/Child)
16.1. Una nota sulle collezioni
16.2. Uno-a-molti bidirezionale
16.3. Ciclo di vita con cascate
16.4. Come utilizzare update() in cascata
16.5. Conclusione
17. Esempio: una applicazione che realizza un weblog
17.1. Classi persistenti
17.2. Mappaggi di hibernate
17.3. Codice di Hibernate
18. Alcuni mappaggi di esempio
18.1. Employer/Employee (Datore di lavoro / impiegato)
18.2. Autore/Opera (Author/Work)
18.3. Cliente/Ordine/Prodotto (Customer/Order/Product)
19. Buone abitudini (best practices)