Principe de la configuration

L'ORM Hibernate fonctionne dans différents environnements (Windows, Unix, Linux, etc ...) et avec différentes bases de données (Oracle, Mysql, PostGresql, etc ...); cela nécessite donc beaucoup de paramètres de configuration et la plupart d'entre eux ont des valeurs par défaut; chaque distribution d'hibernate contient dans son répertoire "etc/", un exemple de fichier hibernate.properties avec ces paramètres et leurs différentes valeurs. Si on utilise ce fichier "hibernate.properties", on le place dans le classpath du projet et on l'adapte en fonction des paramètres appropriées.
La Configuration de Hibernate se fait soit :

1. - par programmation
2. - via un fichier de configuration XML (hibernate.cfg.xml)
3. - par Intégration de Hibernate à un serveur d'application J2EE

Dans tous les cas, une instance de la classe Configuration précise pour une application donnée, les propriétés (properties) à utiliser lorsqu'on crée une SessionFactory et par défaut, une instance de org.hibernate.cfg.Configuration utilise le fichier hibernate.properties.

Configuration par programmation

Principe

Une instance de la classe  "org.hibernate.cfg.Configuration" représente un ensemble de mappages des classes Java d'une application vers une base de données SQL. Ces  mappages sont constitués d'un ensemble de fichiers XML. Cette instance de la classe "Configuration" est utilisée pour construire un objet immuable, instance de la classe SessionFactory. On obtient une instance de la classe Configuration en l'instanciant directement et en spécifiant la liste des fichiers XML de mappage; si ces fichiers de mappage sont dans le classpath, on fait l'instanciation à l'aide de la méthode addResource() en procédant comme suit :

Configuration cfg = new Configuration()
      .addClass("Item.hbm.xml")
      .addClass("Bid.hbm.xml");

Les fichiers de mappages ici sont "Item.hbm.xml" et "Bid.hbm.xml".
Une alternative (parfois meilleure) est de construire les classes mappées et de laisser Hibernate trouver les fichiers XML  de mappage comme suit :

Configuration cfg = new Configuration()
      .addClass(org.hibernate.auction.Item.class)
      .addClass(org.hibernate.auction.Bid.class);

En procédant comme ci-dessus, Hibernate va rechercher les fichiers de mappages  /org/hibernate/auction/Item.hbm.xml et /org/hibernate/auction/Bid.hbm.xml dans le classpath. Cette approche élimine les noms de fichiers en dur dans l' application.
La Configuration permet également de préciser des propriétés de configuration:

Configuration cfg = new Configuration()
    .addClass(org.hibernate.auction.Item.class)
    .addClass(org.hibernate.auction.Bid.class)
    .setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect")
    .setProperty("hibernate.connection.datasource", "java:comp/env/jdbc/test")
    .setProperty("hibernate.order_updates", "true");

Ce n'est pas le seul moyen de passer des propriétés de configuration à Hibernate. Les différentes options sont :

1. passer une instance de java.util.Properties à Configuration.setProperties().
2. Placer hibernate.properties dans un répertoire racine du classpath
3. Positionner les propriétés System en utilisant java -Dproperty=value.
4. Inclure des éléments <property> dans le fichier hibernate.cfg.xml (voir plus loin).

L'utilisation d'hibernate.properties est l'approche la plus simple si vous voulez démarrer rapidement; L'objet Configuration est un objet de démarrage qui sera supprimé une fois qu'une SessionFactory aura été créée.....

Configuration par fichier XML

Principe

Une des approches alternatives à celle citée ci-dessus est de spécifier toute la configuration dans un fichier nommé hibernate.cfg.xml. Ce fichier peut être utilisé à la place du fichier hibernate.properties, voire même peut servir à surcharger les propriétés si les deux fichiers sont présents. Ce fichier hibernate.cfg.xml de configuration XML doit par défaut se placer à la racine du CLASSPATH. Voici un exemple de fichier hibernate.cfg.xml :

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    
    <session-factory
        name="java:hibernate/SessionFactory">
        
        <property name="connection.datasource" >java:/comp/env/jdbc/MyDB</property >
        <property name="dialect" > org.hibernate.dialect.MySQLDialect</property >
        <property name="show_sql" > false</property >
        <property name="transaction.factory_class" >
            org.hibernate.transaction.JTATransactionFactory
        </property >
        <property name="jta.UserTransaction" >java:comp/UserTransaction</property >
        
        <mapping resource="org/hibernate/auction/Item.hbm.xml"/>
        <mapping resource="org/hibernate/auction/Bid.hbm.xml"/>
        
        <class-cache class="org.hibernate.auction.Item" usage="read-write"/>
        <class-cache class="org.hibernate.auction.Bid" usage="read-only"/ >
        <collection-cache collection="org.hibernate.auction.Item.bids" usage="read-write"/>
    </session-factory >
</hibernate-configuration >

L'avantage de cette approche est l'externalisation des noms des fichiers de mapping de la configuration. Le fichier hibernate.cfg.xml est également plus pratique quand on commence à régler le cache d'Hibernate.
Avec la configuration par fichier XML, démarrer Hibernate devient simple - voir comment fonctionne la déclaration de la variable sessionFactory -

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

Configuration par intégration de Hibernate à un serveur d'application J2EE

Principe

Hibernate possède les points suivants d'intégration à l'infrastructure 2EE:

1. Source de données gérée par le conteneur :
   .....
2. Association JNDI automatique :
   .....
3. Association de la Session à JTA :
   ....
4. Déploiement JMX :
   .....

La Classe Configuration

La classe "org.hibernate.cfg.Configuration" permet d'atteindre les propriétés de configuration d'une application java utilisant Hibernate et les fichiers de mapping des classes mappées; ces propriétés de configuration et les mapping servent à créer une SessionFactory (Fabrique de Session). Toute application java utilisant Hibernate a normalement besoin d'une seule configuration, donc d'une seule instance de SessionFactory et toutes les sessions de l'application seront ouvertes via l'interface Session et s’appuieront sur l'instance unique de SessionFactory. Hibernate permet à une application d'instancier plus d'une SessionFactory ce qui est pratique lorsqu'on utilise plus d'une base de données .
Habituellement, vous voulez que la SessionFactory crée les connexions JDBC et les mette dans un pool pour vous. Si vous suivez cette approche, ouvrir une Session est aussi simple que :

Session session = sessionFactory.openSession();