Hibernate.org Community Documentation

- Précédent
- Suivant

## Chapitre 2. Architecture

## 2.1. Généralités

Le diagramme ci-dessus procure une vue - (très) haut niveau - de l'architecture Hibernate :

Unfortunately we cannot provide a detailed view of all possible runtime architectures. Hibernate is sufficiently flexible to be used in a number of ways in many, many architectures. We will, however, illustrate 2 specifically since they are extremes.

### 2.1.1. Minimal architecture

The "minimal" architecture has the application manage its own JDBC connections and provide those connections to Hibernate; additionally the application manages transactions for itself. This approach uses a minimal subset of Hibernate APIs.

### 2.1.2. Comprehensive architecture

L'architecture "complète" abstrait l'application des API JDBC/JTA sous-jacentes et permet à Hibernate de s'occuper des détails.

### 2.1.3. Basic APIs

Here are quick discussions about some of the API objects depicted in the preceding diagrams (you will see them again in more detail in later chapters).

SessionFactory (`org.hibernate.SessionFactory`)

  A thread-safe, immutable cache of compiled mappings for a single database. A factory for `org.hibernate.Session` instances. A client of `org.hibernate.connection.ConnectionProvider`. Optionally maintains a `second level cache` of data that is reusable between transactions at a process or cluster level.

Session (`org.hibernate.Session`)

  A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC `java.sql.Connection`. Factory for `org.hibernate.Transaction`. Maintains a `first level cache` of persistent the application's persistent objects and collections; this cache is used when navigating the object graph or looking up objects by identifier.

Objets et collections persistants

  Short-lived, single threaded objects containing persistent state and business function. These can be ordinary JavaBeans/POJOs. They are associated with exactly one `org.hibernate.Session`. Once the `org.hibernate.Session` is closed, they will be detached and free to use in any application layer (for example, directly as data transfer objects to and from presentation). Chapitre 11, Travailler avec des objets discusses transient, persistent and detached object states.

Objets et collections éphémères (transient) et détachés

  Instances of persistent classes that are not currently associated with a `org.hibernate.Session`. They may have been instantiated by the application and not yet persisted, or they may have been instantiated by a closed `org.hibernate.Session`. Chapitre 11, Travailler avec des objets discusses transient, persistent and detached object states.

Transaction (`org.hibernate.Transaction`)

  (Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. It abstracts the application from the underlying JDBC, JTA or CORBA transaction. A `org.hibernate.Session` might span several `org.hibernate.Transaction`s in some cases. However, transaction demarcation, either using the underlying API or `org.hibernate.Transaction`, is never optional.

ConnectionProvider (`org.hibernate.connection.ConnectionProvider`)

  (Optional) A factory for, and pool of, JDBC connections. It abstracts the application from underlying `javax.sql.DataSource` or `java.sql.DriverManager`. It is not exposed to application, but it can be extended and/or implemented by the developer.

TransactionFactory (`org.hibernate.TransactionFactory`)

  (Optional) A factory for `org.hibernate.Transaction` instances. It is not exposed to the application, but it can be extended and/or implemented by the developer.

Extension Interfaces

  Hibernate fournit de nombreuses interfaces d'extensions optionnelles que vous pouvez implémenter pour personnaliser le comportement de votre couche de persistance. Reportez vous à la documentation de l'API pour plus de détails.

## 2.2. Intégration JMX

JMX est le standard J2EE de gestion des composants Java. Hibernate peut être géré via un service JMX standard. Nous fournissons une implémentation d'un MBean dans la distribution : `org.hibernate.jmx.HibernateService`.

Another feature available as a JMX service is runtime Hibernate statistics. See Section 3.4.6, « Statistiques Hibernate » for more information.

## 2.3. Sessions contextuelles

Certaines applications utilisant Hibernate ont besoin d'une sorte de session "contextuelle", où une session donnée est en effet liée à la portée d'un contexte particulier. Cependant, les applications ne définissent pas toutes la notion de contexte de la même manière, et différents contextes définissent différentes portées à la notion de "courant". Les applications qui utilisaient Hibernate, versions précédentes à la 3.0, avaient tendance à employer un principe maison de sessions contextuelles basées sur le `ThreadLocal`, ainsi que sur des classes utilitaires comme `HibernateUtil`, ou utilisaient des framework tiers (comme Spring ou Pico) qui fournissaient des sessions contextuelles basées sur l'utilisation de proxy/interception.

A partir de la version 3.0.1, Hibernate a ajouté la méthode `SessionFactory.getCurrentSession()`. Initialement, cela demandait l'usage de transactions `JTA`, où la transaction `JTA` définissait la portée et le contexte de la session courante. L'équipe Hibernate pense que, étant donnée la maturité des nombreuses implémentations autonomes du `JTA TransactionManager`, la plupart (sinon toutes) des applications devraient utiliser la gestion des transactions par `JTA` qu'elles soient ou non déployées dans un conteneur `J2EE`. Par conséquent, il vous suffira de contextualiser vos sessions via la méthode basée sur `JTA`.

Cependant, depuis la version 3.1, la logique derrière `SessionFactory.getCurrentSession()` est désormais enfichable. A cette fin, une nouvelle interface d'extension(`org.hibernate.context.CurrentSessionContext` et un nouveau paramètre de configuration `hibernate.current_session_context_class` ont été ajoutés pour enficher la portée et le contexte de sessions courantes caractéristiques.

Pour une description détaillée de son contrat, consultez les Javadocs de l'interface `org.hibernate.context.CurrentSessionContext`. Elle définit une seule méthode, `currentSession()`, par laquelle l'implémentation est responsable de traquer la session contextuelle courante. Hibernate fournit trois implémentations de cette interface :

- `org.hibernate.context.JTASessionContext` - les sessions courantes sont associées à une transaction `JTA`. La logique est la même que l'ancienne approche basée sur JTA. Consultez les javadocs pour pour plus d'informations.

- `org.hibernate.context.ThreadLocalSessionContext` - les sessions courantes sont traquées par l'exécution du thread. Consultez les javadocs pour plus d'informations.

- `org.hibernate.context.ManagedSessionContext` - les sessions courantes sont traquées par l'exécution du thread. Toutefois, vous êtes responsable de lier et de délier une instance de `Session` avec des méthodes statiques de cette classe. Elle n'ouvre jamais, ni ne nettoie ou ne ferme une `Session`.

The first two implementations provide a "one session - one database transaction" programming model. This is also known and used as session-per-request. The beginning and end of a Hibernate session is defined by the duration of a database transaction. If you use programmatic transaction demarcation in plain JSE without JTA, you are advised to use the Hibernate `Transaction` API to hide the underlying transaction system from your code. If you use JTA, you can utilize the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you do not need any transaction or session demarcation operations in your code. Refer to Chapitre 13, Transactions et Accès concurrents for more information and code examples.

Le paramètre de configuration `hibernate.current_session_context_class` définit quelle implémentation de `org.hibernate.context.CurrentSessionContext` doit être utilisée. Notez que pour assurer la compatibilité avec les versions précédentes, si ce paramètre n'est pas défini mais qu'un `org.hibernate.transaction.TransactionManagerLookup` est configuré, Hibernate utilisera le `org.hibernate.context.JTASessionContext`. La valeur de ce paramètre devrait juste nommer la classe d'implémentation à utiliser. Pour les trois implémentations prêtes à utiliser, toutefois, il y a trois noms brefs correspondants : "jta", "thread" et "managed".

Copyright © 2004 Red Hat, Inc.

- PrécédentChapitre 1. Tutoriel
- Niveau supérieur
- Sommaire
- SuivantChapitre 3. Configuration