voyager624 - Fotolia

Créer une SessionFactory Hibernate : 3 méthodes illustrées

Dans ce conseil, Cameron McKenzie détaille trois méthodes pour créer des SessionFactory avec le framework de persistance de données Hibernate. L’outil doit faciliter les opérations CRUD (Create, Read, Update, Delete) associées à l’utilisation du serveur applicatif JBoss.

Les développeurs qui utilisent le framework Hibernate doivent commencer par créer une SessionFactory pour assurer la persistance des données au sein d’une application Web développée en Java. Une SessionFactory (textuellement, une « fabrique de sessions ») permet de créer des sessions Hibernate. Sans ces dernières, les opérations CRUD (création, mise à niveau, extraction, suppression de données) sont impossibles. Dans ce cas de figure, la base de données associée s’avère pratiquement inutile.

Voici trois approches plébiscitées pour créer une SessionFactory Hibernate et structurer une solution d’entreprise avec le framework Hibernate :

  1. Générer une SessionFactory Hibernate avec le fichier hibernate.cfg.xml.
  2. Créer une SessionFactory dans Hibernate avec les classes Metatada et ServiceRegistry.
  3. Récupérer, par un petit stratagème, une SessionFactory Hibernate via l’EntityManager de JPA (Java Persistence API, la spécification conçue pour organiser des données relationnelles dans le framework, NDR).

Il existe d’autres procédés, mais nous allons examiner et illustrer ces trois principales méthodes.

Qu’est-ce qu’une SessionFactory dans Hibernate ?

Une SessionFactory Hibernate est le composant principal de la bibliothèque de classes du framework de persistance de JBoss. La SessionFactory amorce la couche de persistance des données au démarrage. Ensuite, elle administre d’importantes tâches de connectivité de la base de données, le regroupement de connexions, le regroupement de threads, les interactions JNDI, voire la création de la table de base de données si les entités persistantes en ont besoin.

Mais, surtout, c’est elle qui crée les objets Session. La Session d’Hibernate fournit des méthodes (par exemple, save, delete et update), qui permettent d’exécuter des opérations CRUD sur la base de données à laquelle se connecte la SessionFactory. La plupart des applications créent un singleton (un patron de conception) SessionFactory Hibernate mis en cache pour le cycle de vie de l’application, car la création de l’objet mobilise un grand nombre de ressources.

Hibernate est l’implémentation JBoss de JPA, et la plupart des applications n’interagissent pas directement avec les classes Hibernate. EntityManagerFactory est la classe compagnon JPA de SessionFactory, et il est recommandé d’utiliser les applications récentes avec JPA, dans la mesure du possible. Mais, parfois, une SessionFactory Hibernate est requise. Voici trois méthodes pour en créer.

1. Générer la SessionFactory avec hibernate.cfg.xml.

À titre personnel, je préfère les fichiers sources Java aux fichiers de configuration XML. Pour autant, les SessionFactory Hibernate sont presque toujours développées avec le fichier hibernate.cfg.xml.

Voici un exemple de fichier hibernate.cfg.xml récent, compatible avec Hibernate version 5.4 et les pilotes MySQL 8 :

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-configuration PUBLIC 
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
  "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
      <property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
      <!-- property name="connection.driver_class">com.mysql.jdbc.Driver</property -->
      <property name="connection.url">jdbc:mysql://localhost/hibernate_examples</property>
      <property name="connection.username">root</property>
      <property name="connection.password">password</property>
      <property name="connection.pool_size">3</property>
      <property name="dialect">org.hibernate.dialect.MySQL8Dialect</property>
      <property name="current_session_context_class">thread</property>
      <property name="show_sql">true</property>
      <property name="format_sql">true</property>
      <property name="hbm2ddl.auto">update</property>
      <!-- mapping  class="com.mcnz.jpa.examples.Player" / -->
  </session-factory>
</hibernate-configuration>

Le fichier de configuration, enregistré dans le classpath, permet de créer la SessionFactory Hibernate avec le code suivant :

public static Session getCurrentSessionFromConfig() {
  // SessionFactory in Hibernate 5 example
  Configuration config = new Configuration();
  config.configure();
  // local SessionFactory bean created
  SessionFactory sessionFactory = config.buildSessionFactory();
  Session session = sessionFactory.getCurrentSession();
  return session;
}

2. Créer la SessionFactory Hibernate sans XML

J’évite XML autant que possible, car j’aime travailler de façon pragmatique. Dans l’exemple de SessionFactory Hibernate suivant, toutes les informations ont été enregistrées dans une HashMap Java et passées à un ServiceRegistry, au lieu d’être stockées dans un fichier XML. Le ServiceRegistry Hibernate a été ensuite fusionné avec les métadonnées sur les différentes classes JPA annotées dans le modèle de domaine. La SessionFactory Hibernate peut donc être créée sans le fichier hibernate.cfg.xml.

public static Session getCurrentSession() {
  // Hibernate 5.4 SessionFactory example without XML
  Map<String, String> settings = new HashMap<>();
  settings.put("connection.driver_class", "com.mysql.jdbc.Driver");
  settings.put("dialect", "org.hibernate.dialect.MySQL8Dialect");
  settings.put("hibernate.connection.url", 
    "jdbc:mysql://localhost/hibernate_examples");
  settings.put("hibernate.connection.username", "root");
  settings.put("hibernate.connection.password", "password");
  settings.put("hibernate.current_session_context_class", "thread");
  settings.put("hibernate.show_sql", "true");
  settings.put("hibernate.format_sql", "true");

  ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                                    .applySettings(settings).build();

  MetadataSources metadataSources = new MetadataSources(serviceRegistry);
  // metadataSources.addAnnotatedClass(Player.class);
  Metadata metadata = metadataSources.buildMetadata();

  // here we build the SessionFactory (Hibernate 5.4)
  SessionFactory sessionFactory = metadata.getSessionFactoryBuilder().build();
  Session session = sessionFactory.getCurrentSession();
  return session;
}

3. Obtenir un composant bean SessionFactory local par l’EntityManager de JPA

Pour les développeurs qui utilisent JPA, voici une petite astuce pour obtenir la SessionFactory Hibernate par l’EntityManager. Lancez d’abord un appel de la méthode unwrap, puis appelez la méthode getSessionFactory() de la Session Hibernate. C’est une méthode détournée, certes, mais qui se justifie si la gestion de la persistance de données est assurée principalement par l’API standard et que le développeur n’a pas souvent besoin d’accéder à la SessionFactory Hibernate.

public static SessionFactory getCurrentSessionFromJPA() {
  // JPA and Hibernate SessionFactory example
  EntityManagerFactory emf = 
      Persistence.createEntityManagerFactory("jpa-tutorial");
  EntityManager entityManager = emf.createEntityManager();
  // Get the Hibernate Session from the EntityManager in JPA
  Session session = entityManager.unwrap(org.hibernate.Session.class);
  SessionFactory factory = session.getSessionFactory();
  return factory;
}

Hibernate SessionFactory JPA

La SessionFactory dans Hibernate peut être extraite de JPA.

Même si les développeurs ont tout intérêt à se conformer au standard JPA la plupart du temps, il est bon de rappeler qu’il existe de nombreuses autres options pour développer une SessionFactory Hibernate.

Le code correspondant à cet exemple de Session Hibernate est disponible sur GitHub.

Pour approfondir sur Middleware

Close