Etude de cas avec ASP.NET 2.0, C#, Spring.NET et NHibernate

Le fichier [App.config] est le suivant :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <!-- sections de configuration -->
    <configSections>
        <sectionGroup name="spring">
            <section name="parsers" type="Spring.Context.Support.NamespaceParsersSectionHandler, Spring.Core" />
            <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
            <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" />
        </sectionGroup>
        <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
    </configSections>


    <!-- configuration Spring -->
    <spring>
        <parsers>
            <parser type="Spring.Data.Config.DatabaseNamespaceParser, Spring.Data" />
        </parsers>
        <context>
            <resource uri="Dao.xml" />
        </context>
    </spring>

    <!-- This section contains the log4net configuration settings -->
    <!-- NOTE IMPORTANTE : les logs ne sont pas actifs par défaut. Il faut les activer par programme
    avec l'instruction log4net.Config.XmlConfigurator.Configure();
    ! -->
    <log4net>
        <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%-5level %logger - %message%newline" />
            </layout>
        </appender>

        <!-- Set default logging level to DEBUG -->
        <root>
            <level value="DEBUG" />
            <appender-ref ref="ConsoleAppender" />
        </root>

        <!-- Set logging for Spring.  Logger names in Spring correspond to the namespace -->
        <logger name="Spring">
            <level value="INFO" />
        </logger>

        <logger name="Spring.Data">
            <level value="DEBUG" />
        </logger>

        <logger name="NHibernate">
            <level value="DEBUG" />
        </logger>
    </log4net>

</configuration>

Le fichier [App.config] ci-dessus configure Spring (lignes 5-9, 15-22), log4net (ligne 10, lignes 28-53) mais pas NHibernate. Les objets de Spring ne sont pas configurés dans [App.config] mais dans le fichier [Dao.xml] (ligne 20). La configuration de Spring / NHibernate qui consiste à déclarer des objets Spring particuliers sera donc trouvée dans ce fichier.

Le fichier [Dao.xml] qui rassemble les objets gérés par Spring est le suivant :

<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net"
         xmlns:db="http://www.springframework.net/database">

    <!-- Referenced by main application context configuration file -->
    <description>
        Application Spring / NHibernate
    </description>

    <!-- Database and NHibernate Configuration -->
    <db:provider id="DbProvider"
                   provider="MySql.Data.MySqlClient"
                   connectionString="Server=localhost;Database=dbpam_nhibernate;Uid=root;Pwd=;"/>

    <object id="NHibernateSessionFactory" type="Spring.Data.NHibernate.LocalSessionFactoryObject, Spring.Data.NHibernate12">
        <property name="DbProvider" ref="DbProvider"/>
        <property name="MappingAssemblies">
            <list>
                <value>pam-dao-spring-nhibernate</value>
            </list>
        </property>
        <property name="HibernateProperties">
            <dictionary>
                <entry key="hibernate.dialect" value="NHibernate.Dialect.MySQLDialect"/>
                <entry key="hibernate.show_sql" value="false"/>
            </dictionary>
        </property>
        <property name="ExposeTransactionAwareSessionFactory" value="true" />
    </object>

    <!-- gestionnaire de transactions -->
    <object id="transactionManager"
        type="Spring.Data.NHibernate.HibernateTransactionManager, Spring.Data.NHibernate12">
        <property name="DbProvider" ref="DbProvider"/>
        <property name="SessionFactory" ref="NHibernateSessionFactory"/>
    </object>

    <!-- Hibernate Template -->
    <object id="HibernateTemplate" type="Spring.Data.NHibernate.Generic.HibernateTemplate">
        <property name="SessionFactory" ref="NHibernateSessionFactory" />
        <property name="TemplateFlushMode" value="Auto" />
        <property name="CacheQueries" value="true" />
    </object>

    <!-- Data Access Objects -->
    <object id="pamdao" type="Pam.Dao.Service.PamDaoSpringNHibernate, pam-dao-spring-nhibernate" init-method="init" destroy-method="destroy">
        <property name="HibernateTemplate" ref="HibernateTemplate"/>
    </object>
</objects>

• les lignes 11-13 configurent la connexion à la base de données [dbpam_nhibernate]. On y trouve :
• le provider ADO.NET nécessaire à la connexion, ici le provider du SGBD MySQL. Cela implique d'avoir la Dll [Mysql.Data] dans les références du projet.
• la chaîne de connexion à la base de données (serveur, nom de la base, propriétaire de la connexion, son mot de passe)
• les lignes 15-29 configurent la SessionFactory de NHibernate, l'objet qui sert à obtenir des sessions NHibernate. On rappelle que toute opération sur la base de données se fait à l'intérieur d'une session NHibernate. Ligne 15, on peut voir que la SessionFactory est implémentée par la classe Spring Spring.Data.NHibernate.LocalSessionFactoryObject trouvée dans la Dll Spring.Data.NHibernate12.
• ligne 16 : la propriété DbProvider fixe les paramètres de la connexion à la base de données (provider ADO.NET et chaîne de connexion). Ici cette propriété référence l'objet DbProvider défini précédemment aux lignes 11-13.
• lignes 17-20 : fixent la liste des assembly contenant des fichiers [*.hbm.xml] configurant des entités gérées par NHibernate. La ligne 19 indique que ces fichiers seront trouvés dans l'assembly du projet. Nous rappelons que ce nom est trouvé dans les propriétés du projet C#. Nous rappelons également que tous les fichiers [*.hbm.xml] ont été configurés pour être incorporés dans l'assembly du projet.
• lignes 22-27 : propriétés spécifiques de NHibernate.
• ligne 24 : le dialecte SQL utilisé sera celui de MySQL
• ligne 25 : le SQL émis par NHibernate n'apparaîtra pas dans les logs de la console. Mettre cette propriété à true permet de connaître les ordres SQL émis par NHibernate. Cela peut aider à comprendre par exemple pourquoi une application est lente lors de l'accès à la base.
• ligne 28 : la propriété ExposeTransactionAwareSessionFactory à true va faire que Spring va gérer les annotations de gestion des transactions qui seront trouvées dans le code C#. Nous y reviendrons lorsque nous écrirons la classe implémentant la couche [dao].
• les lignes 32-36 définissent le gestionnaire de transactions. Là encore ce gestionnaire est une classe Spring de la Dll Spring.Data.NHibernate12. Ce gestionnaire a besoin de connaître les paramètres de connexion à la base de données (ligne 34) ainsi que la SessionFactory de NHibernate (ligne 35).
• les lignes 39-43 définissent les propriétés de la classe HibernateTemplate, là encore une classe de Spring. Cette classe sera utilisée comme classe utilitaire dans la classe implémentant la couche [dao]. Elle facilite les interactions avec les objets NHibernate. Cette classe a certaines propriétés qu'il faut initialiser :
• ligne 40 : la SessionFactory de NHibernate
• ligne 41 : la propriété TemplateFlushMode fixe le mode de synchronisation du contexte de persistance NHibernate avec la base de données. Le mode Auto fait qu'il y aura synchronisation :
• à la fin d'une transaction
• avant une opération select
• ligne 42 : les requêtes HQL (Hibernate Query Language) seront mises en cache. Cela peut amener un gain de performance.
• les lignes 46-48 définissent la classe d'implémentation de la couche [dao]
• ligne 46 : la couche [dao] va être implémentée par la classe [PamdaoSpringNHibernate] de la Dll [pam-dao-spring-nhibernate]. Après instanciation de la classe, la méthode init de la classe sera immédiatement exécutée. A la fermeture du conteneur Spring, la méthode destroy de la classe sera exécutée.
• ligne 47 : la classe [PamDaoSpringNHibernate] aura une propriété HibernateTemplate qui sera initialisée avec la propriété HibernateTemplate de la ligne 39.

L'interface [IPamDao] est la même que dans le projet [pam-dao-nhibernate] :

using Pam.Dao.Entites;

namespace Pam.Dao.Service {
    public interface IPamDao {
        // liste de toutes les identités des employés 
        Employe[] GetAllIdentitesEmployes();
        // un employé particulier avec ses indemnités 
        Employe GetEmploye(string ss);
        // liste de toutes les cotisations 
        Cotisations GetCotisations();
    }
}

• ligne 1 : on importe l'espace de noms des entités de la couche [dao].
• ligne 3 : la couche [dao] est dans l'espace de noms [Pam.Dao.Service]. Les éléments de l'espace de noms [Pam.Dao.Entites] peuvent être créés en plusieurs exemplaires. Les éléments de l'espace de noms [Pam.Dao.Service] sont créés en un unique exemplaire (singleton). C'est ce qui a justifié le choix des noms des espaces de noms.
• ligne 4 : l'interface s'appelle [IPamDao]. Elle définit trois méthodes :
• ligne 6, [GetAllIdentitesEmployes] rend un tableau d'objets de type [Employe] qui représente la liste des assistantes maternelles sous une forme simplifiée (nom, prénom, SS).
• ligne 8, [GetEmploye] rend un objet [Employe] : l'employé qui a le n° de sécurité sociale passé en paramètre à la méthode avec les indemnités liées à son indice.
• ligne 10, [GetCotisations] rend l'objet [Cotisations] qui encapsule les taux des différentes cotisations sociales à prélever sur le salaire brut.

Le squelette de la classe d'implémentation de cette interface avec le support Spring / NHibernate pourrait être le suivant :

using System;
using System.Collections;
using System.Collections.Generic;
using Pam.Dao.Entites;
using Spring.Data.NHibernate.Generic.Support;
using Spring.Transaction.Interceptor;

namespace Pam.Dao.Service {
    public class PamDaoSpringNHibernate : HibernateDaoSupport, IPamDao {
        // champs privés 
        private Cotisations cotisations;
        private Employe[] employes;

        // init 
        [Transaction(ReadOnly = true)]
        public void init() {
...
        }

        // suppression objet
        public void destroy() {
            if (HibernateTemplate.SessionFactory != null) {
                HibernateTemplate.SessionFactory.Close();
            }
        }

        // liste de toutes les identités des employés
        public Employe[] GetAllIdentitesEmployes() {
            return employes;
        }


        // un employé particulier avec ses indemnités 
        [Transaction(ReadOnly = true)]
        public Employe GetEmploye(string ss) {
....
        }

        // liste des cotisations 
        public Cotisations GetCotisations() {
            return cotisations;
        }
    }
}

• ligne 9 : la classe [PamDaoSpringNHibernate] implémente bien l'interface de la couche [dao] [IPamDao]. Elle dérive également de la classe Spring [HibernateDaoSupport]. Cette classe a une propriété [HibernateTemplate] qui est initialisée par la configuration Spring qui a été faite (ligne 2 ci-dessous) :

    <object id="pamdao" type="Pam.Dao.Service.PamDaoSpringNHibernate, pam-dao-spring-nhibernate" init-method="init" destroy-method="destroy">
        <property name="HibernateTemplate" ref="HibernateTemplate"/>
</object>

• ligne 1 ci-dessus, on voit que la définition de l'objet [pamdao] indique que les méthodes init et destroy de la classe [PamDaoSpringNHibernate] doivent être exécutées à des moments précis. Ces deux méthodes sont bien présentes dans la classe aux lignes 16 et 21.
• lignes 15, 34 : annotations qui font que la méthode annotée sera exécutée dans une transaction. L'attribut ReadOnly=true indique que la transaction est en lecture seule. La méthode qui est exécutée dans la transaction peut lancer une exception. Dans ce cas, un Rollback automatique de la transaction est fait par Spring. Cette annotation élimine le besoin de gérer une transaction au sein de la méthode.
• ligne 16 : la méthode init est exécutée par Spring immédiatement après l'instanciation de la classe. Nous verrons qu'elle a pour but d'initialiser les champs privés des lignes 11 et 12. Elle se déroulera dans une transaction (ligne 15).
• les méthodes de l'interface [IPamDao] sont implémentées aux lignes 28, 35 et 40.
• lignes 28-30 : la méthode [GetAllIdentitesEmployes] se contente de rendre l'attribut de la ligne 12 initialisé par la méthode init.
• lignes 40-42 : la méthode [GetCotisations] se contente de rendre l'attribut de la ligne 11 initialisé par la méthode init.

Nous utiliserons les méthodes suivantes de la classe HibernateTemplate :

Il existe d'autres méthodes utiles que nous n'aurons pas l'occasion d'utiliser qui permettent de retrouver, sauvegarder, mettre à jour et supprimer des entités :

La méthode init de la classe [PamDaoSpringNHibernate] est par configuration la méthode exécutée après instanciation par Spring de la classe. Elle a pour but de mettre en cache local, les identités simplifiées des employés (nom, prénom, SS) et les taux de cotisations. Son code pourrait être le suivant.

[Transaction(ReadOnly = true)]
        public void init() {
            try {
                // on récupère la liste simplifiée des employés
                IList<object[]> lignes = HibernateTemplate.Find<object[]>("select e.SS,e.Nom,e.Prenom from Employe e");
                // on la met dans un tableau
                employes = new Employe[lignes.Count];
                int i = 0;
                foreach (object[] ligne in lignes) {
                    employes[i] = new Employe() { SS = ligne[0].ToString(), Nom = ligne[1].ToString(), Prenom = ligne[2].ToString() };
                    i++;
                }
                // on met les taux de cotisations dans un objet 
                cotisations = (HibernateTemplate.LoadAll<Cotisations>())[0];
            } catch (Exception ex) {
                // on transforme l'exception 
                throw new PamException(string.Format("Erreur d'accès à la BD : [{0}]", ex.ToString()), 43);
            }
        }

• ligne 5 : une requête HQL est exécutée. Elle demande les champs SS, Nom, Prenom de toutes les entités Employé. Elle rend une liste d'objets. Si on avait demandé l'intégralité de l'employé sous la forme "select e from Employe e", on aurait récupéré une liste d'objets de type Employe.
• lignes 7-12 : cette liste d'objets est copiée dans un tableau d'ojets de type Employe.
• ligne 14 : on demande la liste de toutes les entités de type Cotisations. On sait que cette liste n'a qu'un élément. On récupère donc le premier élément de la liste pour avoir les taux de cotisations.
• les lignes 7 et 14 initialisent les deux champs privés de la classe.

La méthode GetEmploye doit rendre l'entité Employé ayant un n° SS donné. Son code pourrait être le suivant :

[Transaction(ReadOnly = true)]
        public Employe GetEmploye(string ss) {
            IList<Employe> employés = null;
            try {
                // requête
                employés = HibernateTemplate.Find<Employe>("select e from Employe e where e.SS=?", new object[]{ss});
            } catch (Exception ex) {
                // on transforme l'exception 
                throw new PamException(string.Format("Erreur d'accès à la BD lors de la demande de l'employé de n° ss [{0}] : [{1}]", ss, ex.ToString()), 41);
            }
            // a-t-on récupéré un employé ? 
            if (employés.Count == 0) {
                // on signale le fait 
                throw new PamException(string.Format("L'employé de n° ss [{0}] n'existe pas", ss), 42);
            } else {
                return employés[0];
            }
        }

• ligne 6 : obtient la liste des employés ayant un n° SS donné
• ligne 12 : normalement si l'employé existe on doit obtenir une liste à un élément
• ligne 14 : si ce n'est pas le cas, on lance une exception
• ligne 16 : si c'est le cas, on rend le premier employé de la liste

Si on compare le code de la couche [dao] dans le cas d'une utilisation

• du seul framework NHibernate
• du framework Spring / NHibernate

on réalise que la seconde solution a permis d'écrire du code plus simple.