Tutoriel Tapestry5 Spring Hibernate

5/9/2018 Tutoriel Tapestry5 Spring Hibernate - slidepdf.com

http://slidepdf.com/reader/full/tutoriel-tapestry5-spring-hibernate 1/54

Premier projet avec Tapestry5, Spring et Hibernate

par Baptiste Meurant (baptiste-meurant.developpez.com)

Date de publication : 03/10/2007

Dernière mise à jour : 30/03/2009

Ce tutoriel a pour objectif de guider vos premiers pas dans la création d'un projet Web basésur Tapestry5, Spring et Hibernate à travers un exemple très simple de page de login.Ce tutoriel a fait l'objet d'une mise à jour technologique en collaboration avec Loïc Frering :ici

http://loic-frering.developpez.com/tutoriels/java/hibernate-jpa-spring-tapestry/

http://baptiste-meurant.developpez.com/

http://www.developpez.com/



Premier projet avec Tapestry5, Spring et Hibernate par Baptiste Meurant (baptiste-meurant.developpez.com)

- 2 -Copyright © 2007 - . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images,etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.


I - Introduction..............................................................................................................................................................3II - Pré requis...............................................................................................................................................................4

II.A - Installations....................................................................................................................................................4II.B - Préparation de la BDD..................................................................................................................................4

III - Création du projet................................................................................................................................................. 5IV - Architecture logicielle..........................................................................................................................................11

V - Mise en place d'Hibernate...................................................................................................................................13V.A - Installation d'Hibernate Tools...................................................................................................................... 13V.B - Ajout des librairies.......................................................................................................................................13V.C - Configuration de la connexion.................................................................................................................... 14V.D - Génération de la couche model et du mapping O/R..................................................................................19V.E - Ajout des classes mappées à la configuration Hibernate...........................................................................23

VI - Mise en place de Spring.................................................................................................................................... 24VI.A - Couche d'accès aux données................................................................................................................... 24VI.B - Couche de services...................................................................................................................................30VI.C - Gestion des Transactions..........................................................................................................................33VI.D - Integration de Spring au lancement du projet...........................................................................................35

VII - Mise en place de Tapestry................................................................................................................................ 37

VII.A - Simple login.............................................................................................................................................. 37VII.B - Intégration avec Spring.............................................................................................................................41VIII - Mise en place du chargement retardé pour Hibernate.................................................................................... 45IX - Conclusion.......................................................................................................................................................... 52X - Remerciements....................................................................................................................................................53XI - Dans la même série .......................................................................................................................................... 54










I - Introduction

Ce tutoriel propose une application blanche pour un projet Tapestry5-Spring-Hibernate. Elle propose une page delogin et une page principale et recherche l'existence du user en BDD. Le tutoriel se décompose en deux parties : uneapplication blanche Spring-Hibernate autonome puis l'intégration de Tapestry5 à cette application. Ceci permettra de

réutiliser la première partie avec un autre framework front.

Les sources de ce tutoriel sont téléchargeables ici [mirroir http]la version pdf de ce tutoriel est disponible ici [mirroir http]


http://baptiste-meurant.ftp-developpez.com/tutoriaux/tapestry5-spring-hibernate/tutoriel-tapestry5-spring-hibernate.pdf

ftp://ftp-developpez.com/baptiste-meurant/tutoriaux/tapestry5-spring-hibernate/tutoriel-tapestry5-spring-hibernate.pdf

http://baptiste-meurant.ftp-developpez.com/tutoriaux/tapestry5-spring-hibernate/tuto-Tapestry5-Spring-Hibernate-src.zip

ftp://ftp-developpez.com/baptiste-meurant/tutoriaux/tapestry5-spring-hibernate/tuto-Tapestry5-Spring-Hibernate-src.zip









II - Pré requis

II.A - Installations

• Installer Eclipse et WTP téléchargeables ici ou à défaut, sur le site officiel d'eclipse• Installer Tomcat 5.5, téléchargeable ici• Installer mySQL, téléchargeable ici

II.B - Préparation de la BDD

• Créer une base de données et créer la table user :

creation de la table user

CREATE TABLE ùser` (ìd_user` int(10) unsigned NOT NULL auto_increment,

`login_user` varchar(25) NOT NULL default '',

`password_user` varchar(25) NOT NULL default '',

PRIMARY KEY (ìd_user`)) ENGINE=InnoDB;

Remarque : les tables MySQL doivent être au format InnoDB pour que la génération des classes du modèle (voir mapping Hibernate) fonctionne correctement sous Eclipse.

• Créer un utilisateur :

insertion du user de test

INSERT INTO user VALUES ('test', 'test');



http://dev.mysql.com/downloads/

http://tomcat.apache.org/download-55.cgi#5.5.23

http://eclipse.org/

http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/20070702/eclipse-jee-europa-win32.zip&r=1&protocol=http









III - Création du projet

Note : Si vous avez déjà un projet existant, passez directement au chapitre suivant.

• Créer un nouveau projet de type Dynamic Web : Aller dans File -> new Project et choisir Web -> Dynamic

Web Project. Cliquer sur Next.

Figure1 : Création du projet

• Renseigner le nom du projet et choisir un Target Runtime. Si rien n'est défini, cliquer sur new.










Figure2 : Configuration du projet

• Choisir un runtime (ici tomcat 5.5). Attention, il est nécessaire d'avoir installé le serveur.










Figure3 : Choix du runtime

• Renseigner les informations demandées et cliquer sur Finish.










Figure4 : Configuration du serveur

• De retour à l'interface de la Figure2, cliquer sur Next puis encore sur Next.










Figure5 : Finalisation du projet

• Changer le content directory à 'docs' (non obligatoire). Cliquer sur Finish.• A l'issue de ces étapes, le package explorer devrait avoir l'allure de la Figure6 : un projet de type Dynamic

Web créé ainsi qu'une configuration Server intégrée à Eclipse.










Figure6 : Projet vide










IV - Architecture logicielle

L'un des intérêts de l'intégration de ces différents frameworks est de permettre la mise en place d'une architecturelogicielle rigoureuse, de manière à garantir la maintenabilité, l'évolutivité et l'exploitabilité des applications. La figureci-dessous montre l'architecture qui sera mise en place dans le cadre de ce tutoriel. Ce type d'architecture est très

largement admise comme efficace et est généralisable à n'importe quel projet Web.

Figure7 : Architecture Logicielle

La principale caractéristique de cette architecture est la séparation des préoccupations (données vs métier vs web)grâce à la séparation stricte des couches applicatives. En effet, on peut observer sur la figure ci-dessus, les troiscouches de cette application :

• Couche DAO : cette couche permet les accès à la BDD à travers le framework Hibernate.• Couche Service : cette couche contient l'ensemble du code métier de l'application, elle organise et orchestre

les accès à la couche DAO et ses aspects transactionnels. Ces différents aspects sont gérés et organisés par le framework Spring.

• Couche Front : cette couche est la couche d'entrée dans l'application du point de vue du client. Elle appelleles traitements de la couche Service en fonction des actions effectuées par le client et récupère les donnéesretournées. Elle met ensuite en forme ces données pour les afficher au client. Cette couche est réalisée grâceau framework Tapestry5.

Ces trois couches sont rigoureusement séparées les unes des autres en ce sens qu'il ne doit exister idéalementaucune dépendance entre elles. Concrètement, chaque couche ne connaît que les interfaces de la couche

immédiatement inférieure. Ainsi la couche Service ne connaît que les interfaces de la couche DAO et la coucheFront ne connaît que les interfaces de la couche Service. De cette manière, chaque couche publie, via sesinterfaces, l'ensemble des traitements qu'elle met à disposition des couches supérieures. Le lien entre interface










et implémentation, qui introduit un couplage technologique (c'est dans l'implémentation uniquement que l'on faitréférence à Hibernate par exemple) est géré par Spring.

C'est en effet Spring qui va nous permettre d'effectuer, au chargement de l'application, le lien entre Interface etImplémentation grâce à son moteur d'Inversion de Contrôle et d'injection de dépendances (voir plus loin). Ledéveloppeur ne travaille ensuite que sur des appels d'interfaces et non sur l'implémentation directement ce qui

favorise grandement, on l'imagine, l'évolutivité et le faible couplage d'une application.

Enfin, on remarque une couche particulière, la couche model . Cette couche est la seule couche transverse àl'application puisqu'elle permet en effet de faire correspondre au modèle BDD le modèle objet que l'on va utiliser dansl'application pour manipuler les entités métier. Chaque couche peut donc naturellement manipuler les différentesentités métiers représentées par une hiérarchie de JavaBean correspondant chacun à une entité relationnelle.

Cette correspondance est appelée mapping Object/Relationnel et est permise par l'utilisation d'Hibernate. Chaquenotion relationnelle est ainsi représentée sous sa forme objet ainsi que ses dépendances. Cela permet ensuite defaire persister les objets vers la BDD de manière complètement transparente. Ainsi, comme on le verra plus tard,chaque modification effectuée sur un objet mappé dans un contexte transactionnel sera automatiquement répercutéeen base de donnée sans action explicite de la part du développeur. C'est ce que l'on appelle la persistance.

Insistons quelques instants sur la manipulation de la BDD. Le schéma et les explications ci-dessus montrent en effetque cette manipulation comporte deux aspects :

• La couche DAO publie des méthodes d'accès à la BDD de type création, recherche et suppression

d'enregistrements (CREATE, SELECT et DELETE). En bref, cette couche permet de récupérer desinstances d'objets à partir d'enregistrement BDD, de créer des nouvelles instances d'objets en créant lesenregistrements BDD ou de supprimer des instances existantes en supprimant les enregistrements BDD.

• Le mapping O/R et la persistance des données permettent, dans un contexte transactionnel, d'effectuer toutes les opérations de type mise à jour (UPDATE). En effet, une fois récupérées des instances d'objetspersistés grâce à la couche DAO, toute modification de l'instance entraînera une modification del'enregistrement mappé.

Ainsi :

• Aucune méthodes de mises à jour d'instances n'est nécessaire pour les objets qui ont été obtenus dans uncontext transactionnel depuis la couche DAO.

• Cependant, les méthodes de création d'objet correspondant à des INSERT en base de données restentnecessaires, car même dans un contexte transactionnel la couche Services ne peut décider à votre place s'ilfaut persister ou non une nouvelle instance de la couche model. Lorsque l'on crée un objet du model, il peuten effet s'agir d'une variable de travail temporaire par exemple qu'on ne souhaite donc pas enregistrer.

Ces différents aspects seront détaillés par la suite.










V - Mise en place d'Hibernate

Note : La version d'Hibernate considérée ici est une version 3.2 ou supérieure.

Dans cette partie nous allons nous charger de générer le modèle objet à partir du modèle relationnel et de mettre

en place la persistance de ce modèle grâce à Hibernate.

Télécharger Hibernate Core, Hibernate Annotations et Hibernate Tools sur http://www.hibernate.org/30.htmlou récupérer l'archive du projet.

V.A - Installation d'Hibernate Tools

Hibernate Tools est un plugin Eclipse permettant de générer automatiquement les classes de mapping du modèleà partir de la BDD :

• Extraire le zip téléchargé.

• Copier les deux répertoires plugins et features qu'il contient dans le répertoire d'installation d'Eclipse.• Redémarrer Eclipse.• Un certain nombre de nouveaux éléments apparaissent dans l'interface, prouvant l'installation du plugin :

Figure8 : Hibernate Tools Installé

V.B - Ajout des librairies

• Récupérer le driver de votre BDD (pour MySQL, voir ici) et le copier dans WEB-INF/lib• Faire un refresh sur le projet dans Eclipse, le jar doit apparaître dans les Web App librairies.• Inclure l'ensemble des jar nécessaires à Hibernate.

Figure9 : Ajout des jar Hibernate


http://dev.mysql.com/downloads/connector/j/3.1.html

http://www.hibernate.org/30.html









V.C - Configuration de la connexion

• Créer un répertoire config et l'inclure en tant que source folder.

Figure10 : Création du répertoire config

• Sélectionner le répertoire config et cliquer sur File/New/Other. Puis choisir Hibernate/Hibernate configurationfile.










Figure11 : Création du fichier de configuration Hibernate

• Configurer la connexion à la BDD en fonction des paramètres locaux. Penser à bien cocher la case 'CreateConsole configuration'










Figure12 : Configuration des paramètres de connexion

• Nous allons en profiter pour configurer la console Hibernate Tools afin de disposer d'un outil simple degénération de mapping. Configurer la console comme indiqué ci-dessous :










Figure13 : Configuration de la console

• Cliquer sur Classpath/Add JAR et ajouter le driver BDD puis cliquez sur Finish.










Figure14 : Création du lien entre la console et le driver

Le fichier de configuration Hibernate a été créé comme ceci :

Fichier de configuration Hibernate - hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</property> <property name="hibernate.connection.password">root</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/experiments </property>

<property name="hibernate.connection.username">root</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect </property> </session-factory>

</hibernate-configuration>

• Ouvrir la vue Console et explorer la BDD. Le résultat devrait être celui-ci. Dans le cas contraire, vérifier lesparamètres de connexion.










Figure15 : Exploration de la BDD via la console

V.D - Génération de la couche model et du mapping O/R

• Lancer la génération de code automatique :

Figure16 : Lancement de la génération automatique

• Configurer la génération de code comme ceci :










Figure17 : Configuration de la génération automatique 1

• Cliquer sur Exporters et cocher uniquement la génération de Domain code. Cliquer sur Run.










Figure18 : Configuration de la génération automatique 2

• Le code de la classe User a été généré avec l'ensemble des annotations nécessaires au mapping Hibernate.










Figure19 : Génération du JavaBean User mappé

Classe User générée

package tuto.webssh.domain.model;

import javax.persistence.Column;

import javax.persistence.Entity;import javax.persistence.Id;

import javax.persistence.Table;

@Entity@Table(name = "user", catalog = "experiments")

public class User implements java.io.Serializable {

private int idUser;

private String loginUser;

private String passwordUser;

public User() {

}

public User(int idUser, String loginUser, String passwordUser) {

this.idUser = idUser;

this.loginUser = loginUser; this.passwordUser = passwordUser;

}

@Id @Column(name = "id_user", unique = true, nullable = false)

public int getIdUser() {

return this.idUser;

}

public void setIdUser(int idUser) {


}

@Column(name = "login_user", nullable = false, length = 25)

public String getLoginUser() {

return this.loginUser; }










Classe User générée public void setLoginUser(String loginUser) {

this.loginUser = loginUser; }

@Column(name = "password_user", nullable = false, length = 25)

public String getPasswordUser() {

return this.passwordUser; }

public void setPasswordUser(String passwordUser) {

this.passwordUser = passwordUser;

}

}

On note les annotations :• @Entity qui permet de déclarer la classe comme une entité persistante Hibernate.• @Table qui permet d'associer l'entité à une table d'un catalogue, d'un schéma, d'une database donnée.

• @Id qui définit une propriétaire comme identifiant de l'entité (clé primaire).• @Column qui associe la propriété avec un champ BDD et gère un certain nombre d'options. La propriété

id par exemple, est unique et ne peut être commitée à null. On peut ainsi définir si la propriété peut êtremodifiée, etc. Cela permet à Hibernate d'effectuer les contrôles de cohérence et de sécurité en amont del'enregistrement en base.

V.E - Ajout des classes mappées à la configuration Hibernate

Modifier le fichier hibernate.cfg.xml pour mapper la classe générée.

Modification du fichier hibernate.cfg.xml

<hibernate-configuration>

<session-factory> <property name="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.password">root</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/experiments </property>

<property name="hibernate.connection.username">root</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect </property>

<mapping class="tuto.webssh.domain.model.User"/>

</session-factory>

</hibernate-configuration>

Suite à cela, l'objet User est un objet persistant. Toute instance de User correspondra à un enregistrement BDD.










VI - Mise en place de Spring

Note : La version de Spring considérée ici est une version 2.0 ou supérieure.

• Télécharger Spring ici

• Décompresser le zip et copier le spring.jar dans WEB-INF/lib

Figure20 : Ajout des librairies Spring

Le framework Spring repose sur un moteur d'inversion de contrôle et d'injection de dépendances. Il s'agit dedévelopper l'application en se basant uniquement sur des interfaces - ce qui permet de découper proprementl'application en couches bien distinctes. C'est ensuite le framework - en tant que contrôleur du flot d'exécution de

l'application - d'injecter, au démarrage de l'application, le code de l'implémentation dans les différentes classesutilisant l'interface qu'elle étend. Ceci est fait grâce à un mécanisme d'injection de beans Spring grâce à des settersfournis par le développeur dans ses classes et à la configuration de chacun des couples interface/implémentation entant que bean Spring configuré dans différents fichiers xml.

En se reposant sur ces mécanismes, nous allons créer deux couches distinctes : la couche d'accès aux données(dao) et la couche de services métiers (service) et leur permettre de travailler ensemble.

VI.A - Couche d'accès aux données

• Créer l'interface UserDao dans le package dao


http://sourceforge.net/project/showfiles.php?group_id=73357&package_id=173644&release_id=512513









Figure21 : Création de l'interface UserDao

• Créer l'implémentation de cette interface UserDaoImpl dans le package dao.hibernate3. Afin de bénéficier des fonctionnalités avancées et des API de Spring en ce qui concerne l'intégration avec Hibernate, fairedériver cette classe de la classe HibernateDaoSupport .










Figure22 : Création de l'implémentation UserDaoImpl 1












Voici les interfaces et classes créées. On en profite pour ajouter tout de suite le code dont on aura besoin par la suite :

Interface UserDao

package tuto.webssh.domain.dao;

import org.springframework.dao.DataAccessException;

import tuto.webssh.domain.model.User;

/*** Allows performing complex actions on persistent data










Interface UserDao* @author bmeurant

*/

public interface UserDao {

/**

* Check if the login exists and if the password is correct in datasource.

* @param login : user login* @param password : user password

* @return true if the login exists and if the password is correct.

* Otherwise, return false.

* @throws DataAccessException in case of Data access errors

* (database unreachable, etc.)*/

public boolean checkLogin (String login, String password);

/**

* Return a User object from a given login.

* @param login : user login

* @return the corresponding user object.

* @throws DataAccessException in case of Data access errors

* (database unreachable, etc.)

*/ public User getUser(String login);

}

Implémentation UserDaoImpl

package tuto.webssh.domain.dao.hibernate3;

import org.hibernate.Criteria;

import org.hibernate.Session;

import org.hibernate.criterion.Expression;import org.springframework.dao.DataAccessException;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import tuto.webssh.domain.dao.UserDao;import tuto.webssh.domain.model.User;

/**

* Implements a strategy to perform complex actions on persistent data.

* @author bmeurant

*/

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

/**

* {@inheritDoc}

*/

public boolean checkLogin(String login, String password) {

if (null == login || null == password) {

throw new IllegalArgumentException("Login and password are mandatory. Null values are forbidden.");

} try {

logger.info("Check user with login: "+login+" and password : [PROTECTED]");

Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();

// create a new criteriaCriteria crit = session.createCriteria(User.class);

crit.add(Expression.ilike("loginUser", login));

crit.add(Expression.eq("passwordUser", password));

User user = (User)crit.uniqueResult();

return (user != null);

}

catch(DataAccessException e) {

// Critical errors : database unreachable, etc.logger.error("Exception - DataAccessException occurs : "+e.getMessage()

+" on complete checkLogin().");

return false;

}

}










Implémentation UserDaoImpl

/**

* {@inheritDoc}

*/

public User getUser(String login) {

if (null == login) {

throw new IllegalArgumentException("Login is mandatory. Null value is forbidden."); }

try {

logger.info("get User with login: "+login);Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();

// create a new criteria

Criteria crit = session.createCriteria(User.class);

crit.add(Expression.eq("loginUser", login));

User user = (User)crit.uniqueResult();

return user;

}

catch(DataAccessException e) {

// Critical errors : database unreachable, etc.

logger.error("Exception - DataAccessException occurs : "+e.getMessage()

+" on complete getUser().");

return null;

}

}}

On remarquera :• l'utilisation du logger (API commons-logging) nativement intégré du fait de l'extension de la classe

HibernateDaoSupport - l'utilisation de l'API générique commons-logging permet de greffer un système de logbeaucoup plus puissant comme log4j par exemple.

• l'utilisation de la très riche API Hibernate Criteria permettant d'effectuer des requêtes en 'mode objet'. Noter que le même résultat peut être obtenu en HQL mais paraît - de mon point de vue - beaucoup moins élégant.

• l'utilisation des diverses interfaces Spring d'accès à la couche Hibernate qui permet de simplifier grandementles accès à la couche de mapping (par exemple le getHibernateTemplate(), etc.).

Créer un fichier xml ApplicationContextDao.xml dans WEB-INF et déclarer le couple interface implémentation sousla forme de bean Spring. Par défaut, les beans Spring sont des singleton et sont donc ThreadSafe. Cela garantitque le code peut être appelé sans risque de manière concurrente par deux process différents. Ce mécanisme estentièrement géré en interne par Spring.

Ce fichier définit un bean userDao correspondant à une interface et y associe l'implémentation correspondante.Ce bean contient une propriété (au sens des JavaBeans) sessionFactory définissant la configuration de la sessionHibernate et notamment le lien vers le fichier de configuration Hibernate ainsi que la stratégie permettant de récupérer les différents objets mappés dans Hibernate. Ici, il s'agit de la stratégie basée sur les annotations.

Fichier xml Spring Généré - ApplicationContextDao.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">



<beans>



<bean id="userDao" class="tuto.webssh.domain.dao.hibernate3.UserDaoImpl" >

<property name="sessionFactory"> <ref bean="sessionFactory" />

</property> </bean>













Fichier xml Spring Généré - ApplicationContextDao.xml 

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >

<property name="configLocation">

<value>classpath:hibernate.cfg.xml</value> </property>

<property name="configurationClass">

<value>org.hibernate.cfg.AnnotationConfiguration </value> </property>

</bean></beans>

VI.B - Couche de services

Les éléments de la couche dao vont être utilisés par les services métiers de la couche service supérieure :

• Dans deux nouveaux packages service et service.impl , créer l'interface UserManager et son implémentationUserManagerImpl .

Figure25 : Création du UserManager

Interface UserManager

package tuto.webssh.service;


/*** This interface publishes business features to handler users

* @author bmeurant

*/

public interface UserManager {

/**

* Check if the login exists and if the password is correct.


* @param password : user password* @return true if the login exists and if the password is correct.











Interface UserManager */


/**

* Return a User object from a given login.


* @return the corresponding user object.*/

public User getUser(String login);

/**

* Change the password to 'password' for the given login


* @param password : user new password

* @return the new User object

*/

public User changePassword (String login, String password);

}

Implémentation UserManagerImpl

package tuto.webssh.service.impl;

import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;

import tuto.webssh.domain.dao.UserDao;

import tuto.webssh.domain.model.User;import tuto.webssh.service.UserManager;

/**

* Implements business features to handler users

* @author bmeurant

*/

public class UserManagerImpl implements UserManager {

private final Log logger = LogFactory.getLog(UserManagerImpl. class);

/**

* {@inheritDoc}

*/

public boolean checkLogin (String login, String password) {

return userDao.checkLogin(login, password);

}

/**

* {@inheritDoc}

*/

public User changePassword(String login, String password) {User user = userDao.getUser(login);

if (user != null) {

user.setPasswordUser(password);

}

return user;

}

/**

* {@inheritDoc}

*/

@SuppressWarnings("finally")


return userDao.getUser(login);

}

}










On désire que la couche service accède à la couche dao. Cependant, partant du principe de séparation stricte descouches, l'ensemble des implémentations de services ne vont accéder directement qu'aux interfaces des dao etnon aux implémentations. C'est Spring qui se chargera d'injecter les implémentations dans les objets (du type del'interface) prévus à cet effet. Cette opération est possible grâce, d'une part à l'association faite entre l'interfaceet l'implémentation au niveau du fichier xml et, d'autre part par un injecteur (setter) prévu à cet effet dans chaqueimplémentation de la couche service.

• Editer la classe UserManagerImpl pour créer l'injecteur qui lui permettra d'accéder aux dao. On en profitepour ajouter les méthodes dont on aura besoin par la suite.

Modification de UserManagerImpl

package tuto.webssh.service.impl;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import tuto.webssh.domain.dao.UserDao;


import tuto.webssh.service.UserManager;

/*** Implements business features to handler users

* @author bmeurant

*/

public class UserManagerImpl implements UserManager {

private final Log logger = LogFactory.getLog(UserManagerImpl. class);

private UserDao userDao = null;

/**

* setter to allows spring to inject userDao implementation

* @param userDao : object (implementation of UserDao interface) to inject.

*/

public void setUserDao(UserDao userDao) { this.userDao = userDao;

}

/**

* {@inheritDoc}

*/

public boolean checkLogin (String login, String password) {

return userDao.checkLogin(login, password);

}

/**

* {@inheritDoc}

*/

public User changePassword(String login, String password) {

User user = userDao.getUser(login); if (user != null) {

user.setPasswordUser(password);

}

return user;

}

/**

* {@inheritDoc}

*/

@SuppressWarnings("finally")


return userDao.getUser(login);

}}

On remarque qu'il n'est fait mention ici d'aucune implémentation : seule l'interface est connue et accédée via lavariable locale userDao. Au moment du démarrage de l'application, Spring utilisera le setter fournit pour injecter










l'implémentation de l'interface UserDao définie dans le bean userDao du fichier ApplicationContextDao.xml dansl'objet userDao de la classe UserManagerImpl . Grâce à des appels à celui-ci et à la configuration effectuée dansle fichier ApplicationContextDao.xml , l'ensemble des méthodes de l'objet UserDao seront accessibles (Attention :seules les méthodes déclarées dans l'interfaces pourront être utilisées).

Pour pouvoir effectuer cette injection correctement, Spring a besoin que soit définit le bean userManager et qu'il

référence, en tant que propriété interne, le bean userDao.

• Créer un fichier ApplicationContext.xml dans WEB-INF et y placer le code suivant :

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="userManager" class=" tuto.webssh.service.impl.UserManagerImpl">

<property name="userDao">

<ref bean="userDao" /> </property>

</bean>

</beans>

On retrouve le mécanisme d'association interface/implémentation et on découvre l'injection de dépendance avec ladéfinition de la propriété userDao qui fait référence au bean définit plus haut de même nom. Attention aux règlesde nommage : le nom de la propriété du bean doit correspondre exactement au nom de la propriété du beanuserManager . Pour y accéder, Spring transformera le nom de cette propriété en la faisant commencer par unemajuscule puis en ajoutant 'set' devant.

VI.C - Gestion des Transactions

Outre l'inversion de contrôle, l'injection de dépendances, la structuration en couche, Spring offre des mécanismesde gestion des transactions BDD très puissants et très élégants dont on souhaite pouvoir bénéficier ici. Cestransactions sont gérées par des mécanismes de proxy et de PAO (Programmation Orientée Aspect), mécanismesqui sont au c� ur même du framework Spring. La configuration des transactions se fait en trois temps :

• Définition du proxy général abstrait de manière globale à l'application dans un fichier xml Spring : dans ApplicationContextDao.xml , ajouter :

applicationcontextDao.xml - configuration des transactions

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" >

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

<bean id="transactionProxy" abstract="true"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" >

<property name="transactionManager">

<ref bean="transactionManager"/>

</property> <property name="transactionAttributes">

<props>

<prop key="insert*">PROPAGATION_REQUIRED</prop>

<prop key="update*">PROPAGATION_REQUIRED</prop> <prop key="save*">PROPAGATION_REQUIRED</prop>

<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>

</props>

</property>

</bean>

• Configuration de proxy spécifiques, héritant du proxy général, devant chaque bean potentiellementtransactionnel. modifier ApplicationContext.xml :















configuration des transactions dans applicationcontextDao.xml

<beans>

<bean id="userManagerTarget" class="tuto.webssh.service.impl.UserManagerImpl">

<property name="userDao"> <ref bean="userDao" />

</property>

</bean> <bean id="userManager" parent="transactionProxy">

<property name="target"> <ref bean="userManagerTarget"/>

</property>

<property name="transactionAttributeSource">

<bean class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource" /> </property>

</bean>

</beans>

On a donc définit un proxy transactionnel devant le bean. La configuration de la transaction est indiquée par laréférence au bean transactionManager et on indique que la configuration détaillée de la transaction se fera par desannotations au niveau de l'interface du UserManager .

• Configuration par annotations au niveau de chaque implémentation de la couche métier pour la configurationdétaillée de la transaction. Modifier UserManager :

gestion des transactions - modification de UserManager

package tuto.webssh.service;

import org.springframework.transaction.annotation.Propagation;import org.springframework.transaction.annotation.Transactional;


/**

* This interface publishes business features to handler users* @author bmeurant

*/

@Transactional (readOnly=true, propagation=Propagation.REQUIRED)

public interface UserManager {

/*** Check if the login exists and if the password is correct.


* @param password : user password

* @return true if the login exists and if the password is correct.


*/


/*** Return a User object from a given login.


* @return the corresponding user object.

*/

public User getUser(String login);

/**

* Change the password to 'password' for the given login


* @param password : user new password

* @return the new User object

*/ @Transactional (readOnly=false)

public User changePassword (String login, String password);

}











Après ça, Spring se chargera tout seul de l'ensemble des mécanismes transactionnels : commit, rollback, persistancedes objets mappés pour autant que la configuration choisie place le flot exécuté dans un contexte transactionnel.A noter que c'est l'execution d'une methode de service qui marque la fin de la transaction et non l'execution d'uneméthode de DAO.

Suite à cela, on peut examiner l'implémentation de la méthode changePassword plus haut et remarquer l'utilisation

du caractère persistant de l'objet User : dans la méthode changePassword en effet, l'objet User est récupéré à partir du login fournit en paramètre. C'est ensuite le champ password de l'objet récupéré qui est alors modifié et aucunaccès n'est fait à la couche DAO. Simplement, puisque cette méthode est transactionnelle (et n'est pas en lectureseule), toute modification effectuée sur l'objet sera persistée en BDD à la fermeture de la transaction (si celle-ci s'estdéroulée correctement et qu'aucune exception n'a été générée), c'est-à-dire à la fin de l'exécution de la méthode.Le password sera alors modifié.

VI.D - Integration de Spring au lancement du projet

La dernière étape consiste à intégrer ces deux fichiers xml de définition des beans ainsi que la configuration du filtreSpring dans le web.xml afin de demander à Spring de construire les beans au chargement de l'application :

web.xml - configuration de Spring

<context-param>

<param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml /WEB-INF/applicationContextDao.xml</param-value>

</context-param>

<listener> <listener-class>org.springframework.web.context.ContextLoaderListener </listener-class>

</listener>

• Ajouter ensuite les dépendances de Spring :

Figure26 : Ajout des dépendances de Spring

Spring va alors charger l'ensemble de la configuration au démarrage de l'application en remontant les éventuelleserreurs. Il ne reste plus qu'à lancer le serveur et traquer les messages d'erreur.










Pour d'avantage d'informations, ajouter le jar log4j au classpath ainsi que le fichier log4j.properties dans le répertoireconfig.

Configuration de log4J

# Set root logger level to DEBUG and its only appender to CONSOLE.

log4j.rootLogger=DEBUG,CONSOLE_APP

# le appender CONSOL_APP est associé à la console

log4j.appender.CONSOLE_APP=org.apache.log4j.ConsoleAppender# CONSOLE_APP utilise un PatternLayout qui affiche : le nom du thread, la priorité,

# le nom du logger et le message

log4j.appender.CONSOLE_APP.layout=org.apache.log4j.PatternLayout

log4j.appender.CONSOLE_APP.layout.ConversionPattern= %d{dd-MM-yyyy HH:mm:ss:SSS} %-4r %-5p %c %x - %m%n

# Change the level of messages for various packages.

log4j.logger.org.apache=DEBUG

log4j.logger.org.springframework=DEBUGlog4j.logger.org.hibernate.cache=DEBUG

log4j.logger.org.hibernate.cfg=DEBUG

log4j.logger.org.hibernate=DEBUG

Au démarrage, Spring doit loguer :

INFO: Pre-instantiating singletons in

org.springframework.beans.factory.support.Defa ultListableBeanFactory@bf7190:defining beans

[userManagerTarget,userManager,userDao,sessionFactory,transactionManager,transactionProxy];

root of factory hierarchy











VII - Mise en place de Tapestry

Note : la version de Tapestry considérée ici est la version 5 ou supérieure.

VII.A - Simple login

Maintenant que Spring et Hibernate sont configurés à blanc, il reste à intégrer le framework Front Tapestry à cettearchitecture.

• La première étape est de récupérer les jar Tapestry et de les ajouter au projet :

Figure27 : Ajout des jar Tapestry

• Créer un fichier nommé Login.html sous WEB-INF :

Login.html

<html xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd" >

<head>

<title>Login</title>

</head>

<body> <div id="login_box">

<t:form>

<t:errors />

<table> <tr>

<td><label t:type="Label" for="login" class="login_label"/></td>

<td><input t:type="TextField" t:id="login" t:value="login" t:label="login "

class="login_input" /></td> </tr>

<tr>










Login.html <td><label t:type="Label" for="password" class="login_label"/></td>

<td><input t:type="PasswordField" t:id="password" t:value="password" t:label="password "

class="login_input" /></td>

</tr> <tr>

<td><input t:id="submitform" t:type="Submit" t:value="submit" class="login_submit"/></td>

</tr> </table>

</t:form> </div>

</body>

</html>

On note les attributs t :value qui permettent de lier un élément html à une variable java. Les attributs for permettentde lier un label à un input html.

• Créer un package pages et une classe Login.java qui est l'image Java du formulaire html :

classe Login

package tuto.webssh.pages;

import org.apache.tapestry.annotations.ApplicationState;import org.apache.tapestry.beaneditor.Validate;

public class Login {

@ApplicationState

private String login;

private String password;

public String getLogin() {

return login;

}

@Validate("required")

public void setLogin(String login) {

this.login = login;

}

public String getPassword() {

return password;

}


public void setPassword(String password) {

this.password = password;

}

String onSuccess() { //mon code métier

String ret = "Home";

return ret;

}

}

On note :• L'annotation @ApplicationState qui permet de spécifier qu'une variable doit persister en session. Ainsi,

au rechargement de la page login (ou d'une autre page contenant la même variable accompagnée d'uneannotation @ApplicationState), la valeur de la variable sera récupérée depuis la session dans la variablelocale.

• L'annotation @Validate("required") qui précise que le champs html associé est obligatoire. Ainsi, si au

submit du formulaire, la valeur n'est pas définie, un message d'erreur sera affiché.










• La méthode onSuccess qui est exécutée automatiquement au submit du formulaire et qui retourne le nom dela page vers laquelle l'utilisateur sera redirigé (ici Home).

• Créer une page Home.html sous WEB-INF, page vers laquelle sera redirigé l'utilisateur après le login

Page Home.html


<head> <title>Congratulation</title>

</head>

<body>

Congratulations, you are logged with login: ${login} !!<br/><br/> <span id="LogoutLink"><span class="moduleTitle"><t:actionlink

t:id="logout">Deconnexion</t:actionlink></span></span>

</body>

</html>

L'instruction ${login} permet de récupérer la valeur de la variable login dans la session, si elle est définie. Larécupération de cette variable se fait grâce au contexte ApplicationState qui lui a été associé dans les classes java

associées. Il est important que la variable login soit présente dans les deux objets java et associée, dans ces deuxclasses, au contexte ApplicationState.

L'élément t :actionLink permet de définir un lien vers une autre page Tapestry.

• Créer un package pages et une classe Home.java à l'intérieur de ce package, image java du formulaire html :

page Home.java

package tuto.webssh.web.pages;

import javax.servlet.http.HttpSession;

import org.apache.tapestry.ComponentResources;import org.apache.tapestry.Link;

import org.apache.tapestry.annotations.ApplicationState;

import org.apache.tapestry.annotations.Inject;import org.apache.tapestry.annotations.OnEvent;

import org.apache.tapestry.services.RequestGlobals;

public class Home {

@Inject

private ComponentResources resources;

@Inject

private RequestGlobals requestGlobals;

@ApplicationState private String login;


return login;

}


this.login = login;

}

@OnEvent(component = "logout")

public Link onLogout()

{HttpSession session = requestGlobals.getHTTPServletRequest().getSession();

session.invalidate(); return resources.createPageLink("login", false);

}










page Home.java

}

On note :• Encore une fois, l'annotation @ApplicationState qui permet de récupérer la variable login depuis la session

pour l'afficher.• L'annotation @Inject qui permet à Tapestry d'effectuer de l'injection de dépendances depuis des

implémentations tierces (ici J2EE core).• La méthode onLogout qui, grâce à l'annotation @onEvent(component="logout") est exécutée à chaque

évènement définit (en fonction de son type) sur le composant spécifié. Ici, le composant est un lien et, àchaque clic sur ce lien, la session sera invalidée et l'utilisateur redirigé vers la page de login.

Editer le web.xml pour configurer le filtre Tapestry et le package de base grâce auquel il sera capable de retrouver le package pages contenant l'ensemble des bean Java représentant des pages html.

web.xml - Intégration de Tapestry

<?xml version="1.0" encoding="UTF-8"?><web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>BlankApplication</display-name>

<context-param>

<param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml /WEB-INF/applicationContextDao.xml</param-value>

</context-param>

<context-param> <param-name>tapestry.app-package</param-name>

<param-value>tuto.webssh.web</param-value>

</context-param>

<filter> <filter-name>app</filter-name>

<filter-class>org.apache.tapestry.TapestryFilter </filter-class>

</filter>

<filter-mapping>

<filter-name>app</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener </listener-class>

</listener>

<welcome-file-list>

<welcome-file>Login</welcome-file> </welcome-file-list>

</web-app>

• Lancer le serveur et taper l'url : http://localhost:8080/BlankApplicationTapestry/login. On obtient la pagesuivante :



http://localhost:8080/BlankApplicationTapestry/login









Figure28 : Formulaire de login

On remarque au passage que si on clique sur Submit avant d'avoir rempli les deux champs login et password, deserreurs sont affichées. Ceci est le comportement et l'affichage par défaut de Tapestry suite à l'instruction @Validate.

Figure29 : validation du formulaire de login

Si les deux champs sont remplis et que l'on clique sur Submit, la page home s'affiche. On remarque que le login abien été passé en session et qu'il est bien affiché sur la page home alors que renseigné sur la page Login.

Figure30 : Page Home

Le lien déconnexion nous ramène sur la page Login.

VII.B - Intégration avec Spring

Si l'on peut trouver que le résultat est déjà pas mal par rapport au travail effectué, il est tout à fait insuffisant. Il vamaintenant s'agir d'aller chercher l'utilisateur en base et de vérifier son existence, la validité de son mot de passe,etc. Pour cela, nous allons traverser successivement les différentes couches de notre application, depuis la coucheTapestry (couche application) jusqu'à la couche dao en passant par la couche service.

Comme expliqué plus haut, la communication entre ces différentes couches - ainsi qu'un certain nombre de fonctionsavancées associées (transactions, etc.) - sont gérées par Spring. Il va donc s'agir d'intégrer Spring et Tapestry. Celaest possible de manière native avec Tapestry5.

La première étape est la modification du filtre Tapestry dans le web.xml afin de permettre l'intégration avec Spring :il faut remplacer la classe org.apache.tapestry.TapestryFilter par org.apache.tapestry.spring.TapestrySpringFilter .

Intégration de Tapestry et Spring - modification du web.xml










Intégration de Tapestry et Spring - modification du web.xml<filter>

<filter-name>app</filter-name>

 <filter-class>org.apache.tapestry.spring.TapestrySpringFilter </filter-class>

</filter>

Une fois que Tapestry est configuré pour fonctionner avec Spring, on doit injecter les beans Spring dans les pagesTapestry. Modifier le fichier Login.java :

Tapestry - classe Login.java

package tuto.webssh.pages;

import org.apache.tapestry.annotations.ApplicationState;import org.apache.tapestry.annotations.Inject;

import org.apache.tapestry.annotations.Persist;

import org.apache.tapestry.annotations.Service;

import org.apache.tapestry.beaneditor.Validate;


public class Login {

private static final String BAD_CREDENTIALS

= "Bad login and/or password. Please retry.";

@Persist

private boolean error = false;

@ApplicationState


@Inject

@Service("userManager")

private UserManager userManager;

private String password;


return login;

}



this.login = login; }

public String getPassword() {

return password;

}

public String getErrorMessage() {

String ret = null;

if (error) {

ret = BAD_CREDENTIALS;

}

return ret;

}


public void setPassword(String password) {

this.password = password; }

String onSuccess() {

String ret = "Login";error=true;

if (userManager.checkLogin(login, password)) {











Tapestry - classe Login.javaerror= false;

ret = "Home";

}

return ret;

}

}

On note :• Les annotations @Inject et @Service qui permettent d'injecter un bean service (Manager) Spring dans

Tapestry. Une fois ceci fait, il est possible d'utiliser dans cette classe java l'ensemble des services définisdans les managers Spring. Ici on modifie la méthode onSucces pour qu'au post du formulaire, l'applicationappelle le service Spring userManager afin d'aller exécuter la méthode checkLogin et vérifier que les loginet password sont corrects. Dans le cas positif on redirige vers la page Home. Dans le cas contraire, onpositionne une variable d'erreur pour afficher un message à l'utilisateur.

• L'annotation @Persist positionnée sur l'attribut error permet de faire persister ce champs à l'intérieur decette page : lors d'un rechargement de la page, la valeur de ce champ sera préservée. Ceci permet, qu'encas d'erreur, on soit capable, via la méthode getErrorMessage, d'afficher le message d'erreur à l'utilisateur.Attention : à la différence de l'annotation @ApplicationState, @Persist ne définit la persistance d'une

propriété qu'à l'intérieur d'une même page et non entre deux pages différentes.• La méthode getErrorMessage permet de publier à la page Login.html , la propriété errorMessage afin

d'afficher le message. Pour cela, modifier la page Login.html :

Intégration de Tapestry et Spring - modification de la page Login.html


<head>

<title>Login</title>

</head> <body>

<div id="login_box">

<t:form>

<t:errors />

<label style="color:red; font-weight:bold;">${errorMessage}</label> <table>

<tr>

<td><label t:type="Label" for="login" class="login_label"/></td>

<td><input t:type="TextField" t:id="login" t:value="login" t:label="login " class="login_input" /></td>

</tr>

<tr> <td><label t:type="Label" for="password" class="login_label"/></td>

<td><input t:type="PasswordField" t:id="password" t:value="password" t:label="password " class="login_input" />

</tr>

<tr> <td><input t:id="submitform" t:type="Submit" t:value="submit" class="login_submit"/></td>

</tr>

</table>

</t:form> </div>

</body>

</html>

• Lancer enfin le serveur et entrer l'url http://localhost:8080/BlankApplicationTapestry/login. Entrer un loginet/ou password incorrect, on est redirigé vers la page de login et le message d'erreur attendu s'affiche :



















Figure31 : Echec de la connexion

• Entrer ensuite le bon login/password ('test', 'test') et valider. On est bien redirigé vers la page Home :

Figure32 : Connexion










VIII - Mise en place du chargement retardé pour Hibernate

Comme on a vu lors de la création de la couche de persistance avec Hibernate, chaque entité BDD est mappée par un objet Java. On obtient ainsi un graphe complet d'objet représentant les entités et leurs dépendances. Ainsi uneentité relationnelle E1 ayant une relation 1,n avec une entité E2 se traduira par un objet JavaBean O1 de type T1

contenant une propriété O2 de type collection de T2 � et ainsi de suite.

On se rend compte facilement que la gestion des dépendances peut rapidement devenir très lourde dès lors quepour charger un objet persistant en mémoire on doit charger l'ensemble de ses dépendances et donc l'intégralitédu graphe d'objet associé. Pour remédier à cela, Hibernate fonctionne en mode par défaut lazy. Le lazy loadingou chargement retardé signifie que lorsque l'on charge un objet en mémoire, seul cet objet est chargé sans sesdépendances ; le graphe de ses dépendances ne sera récupéré que lorsque l'on essaiera d'accéder explicitementà la propriété contenant la dépendance. L'inverse du lazy loading est le mode eager loading : lors du chargementd'un objet, on charge également l'ensemble des graphes d'objets dépendants de cet objet persistant. Contrairementau mode lazy, cela se fait de manière explicite lors du mapping de la relation (1,n ; n,1 ou n,n) par l'annotation :@OneToMany, @ManyToMany ou @ManyToOne(cascade = {}, fetch = FetchType.EAGER).

Cependant, le mode lazy est nativement limité au contexte transactionnel en cours. Cela signifie qu'on pourra, aprèsavoir récupéré un objet persistant en mode lazy, récupérer l'ensemble de ses dépendances par un simple accès à lapropriété dépendante à l'intérieur même de la transaction dans laquelle l'objet a été récupéré. Cela signifie égalementque dès lors que l'on sort de la transaction, cette opération n'est plus possible. En effet, l'opération de chargementretardé n'est possible que parce que la session Hibernate est toujours active et ouverte, afin que le moteur puissey accéder pour récupérer le graphe demandé. Or la session est fermée au sortir de la transaction et cette opérationn'est plus possible ; une tentative d'utilisation déclenchera une exception de type LazyInitializationException.

Il existe cependant une technique permettant de prolonger la durée de vie de la session Hibernate jusque dans lacouche front, permettant ainsi de ne charger réellement que ce dont on a besoin. Attention cependant, cela ne signifieen aucun cas que l'on peut effectuer un chargement retardé n'importe quand dans la couche front. En effet, la sessionn'est gardée active que dans le cadre d'une requête ; cela signifie que l'on pourra effectuer un chargement retardé

juste après avoir récupéré l'objet dans une méthode transactionnelle de la couche service mais que l'on ne pourraen aucun cas récupérer un objet, le mettre en session puis le récupérer ailleurs et tenter un chargement retardépar exemple.

• Etendre la durée de la session Hibernate est une opération que Spring permet très facilement par la mise àdisposition d'un filtre dédié : OpenSessionInViewFilter . Pour cela il suffit de rajouter au web.xml :

Modification du webxml pour le chargement retardé Hibernate

<filter>

<filter-name>Hibernate Session In View Filter</filter-name> <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter </filter-class>

</filter>

<filter-mapping>

<filter-name>Hibernate Session In View Filter</filter-name>

<url-pattern>/*</url-pattern></filter-mapping>

Attention à bien configurer le mapping de ce filtre avant le mapping du filtre Tapestry, afin que toute requête transiteprioritairement par celui-ci avant d'atteindre le filtre Tapestry. Dans le cas contraire, une exception sera générée.Grâce à ce code on étend la durée de vie de la session Hibernate pour toutes les urls, autorisant ainsi l'utilisation dulazy loading dans la couche front aux conditions décrites ci-dessus.

• Pour tester ce nouveau filtre nous allons créer une nouvelle table 'rights' qui va contenir les droits d'un user donné :

Création d'une table rights

CREATE TABLE èxperiments`.`rights` (











Création d'une table rightsìd` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,

`label` VARCHAR(45) NOT NULL,

ìd_user` INTEGER UNSIGNED NOT NULL,

PRIMARY KEY(ìd`), CONSTRAINT `FK_user` FOREIGN KEY `FK_user` (ìd_user`)

REFERENCES ùser` (ìd_user`)

ON DELETE CASCADE)

• On insère ensuite un jeu de test pour notre user :

Insertion des données

INSERT INTO rights (label, id_user) VALUES ('USER', 1);INSERT INTO rights (label, id_user) VALUES ('ADMIN', 1);

• On doit ensuite mapper un nouvel objet java dans la couche model (pour la procédure, voir le chapitre dédiéau mapping Hibernate). On obtient ainsi les nouvelles classes User et Rights suivantes :

Modification de la classe User


import java.util.HashSet;

import java.util.Set;

import javax.persistence.CascadeType;


import javax.persistence.Entity;import javax.persistence.FetchType;

import javax.persistence.Id;

import javax.persistence.OneToMany;


@Entity@Table(name = "user", catalog = "experiments")

public class User implements java.io.Serializable {

private static final long serialVersionUID = 1073256708139002061L;

private int idUser;

private String loginUser;

private String passwordUser;

private Set<Rights> rights = new HashSet<Rights>(0);

public User() {

}

public User(int idUser, String loginUser, String passwordUser) {

this.idUser = idUser; this.loginUser = loginUser;


}

public User(int idUser, String loginUser, String passwordUser,

Set<Rights> rights) { this.idUser = idUser;

this.loginUser = loginUser;


this.rights = rights;

}

@Id

@Column(name = "id_user", unique = true, nullable = false)

public int getIdUser() { return this.idUser;

}














Modification de la classe User

public void setIdUser(int idUser) {


}

@Column(name = "login_user", nullable = false, length = 25)

public String getLoginUser() { return this.loginUser;

}

public void setLoginUser(String loginUser) {

this.loginUser = loginUser;

}

@Column(name = "password_user", nullable = false, length = 25)

public String getPasswordUser() {

return this.passwordUser;

}

public void setPasswordUser(String passwordUser) {


}

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "user")

public Set<Rights> getRights() {

return this.rights;

}

public void setRights(Set<Rights> rights) {

this.rights = rights;

}

}

Nouvelle classe Rights



import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.Id;import javax.persistence.JoinColumn;

import javax.persistence.ManyToOne;


@Entity

@Table(name = "rights", catalog = "experiments")

public class Rights implements java.io.Serializable {

private static final long serialVersionUID = -8905167784828935704L;

private int id;

private User user;

private String label;

public Rights() {

}

public Rights(int id, User user, String label) {

this.id = id;

this.user = user;

this.label = label;

}

@Id @Column(name = "id", unique = true, nullable = false)

public int getId() {










Nouvelle classe Rights return this.id;

}

public void setId(int id) {

this.id = id;

}

@ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "id_user", nullable = false)

public User getUser() {

return this.user;

}

public void setUser(User user) {

this.user = user; }

@Column(name = "label", nullable = false, length = 45)

public String getLabel() {

return this.label;

}

public void setLabel(String label) {

this.label = label;

}

}

On remarque que deux associations ont été créées : l'une pour accéder aux droits du user, l'autre pour accéder aux user ayant un droit. La déclaration de ces associations se fait par l'ajout de l'annotation @JoinColumn au lieude la simple annotation @Column. Une autre annotation est ajoutée qui permet de configurer plus précisémentl'annotation (respectivement @OneToMany et @ManyToOne) en en définissant la cardinalité. On remarque enfinles attributs de ces annotations et la présence de l'attribut fetch précisant le type LAZY ou EAGER du chargement.Enfin, sur l'association de type OneToMany on retiendra la présence de l'attribut mappedBy qui, dans ce genre decas détermine quelle est la propriété de la classe associée qui définit l'association entre les deux classes : ici lapropriété user de l'objet Rights définit la relation entre un objet User et un objet Rights.

• Ajouter la nouvelle classe mappée au mapping Hibernate :

Modification de hibernate.cfg.xml

<mapping class="tuto.webssh.domain.model.Rights" />

Pour tester le lazy loading, nous allons afficher des informations détaillées sur le user dans la page Home :

• Modifier Home.java : Nous ajoutons une propriété user qui sera remplie au chargement de la page par unappel au UserManager grâce à l'annotation @PageLoaded.

Modification de Home.java

package tuto.webssh.web.pages;

import javax.servlet.http.HttpSession;

import org.apache.tapestry.ComponentResources;

import org.apache.tapestry.Link;

import org.apache.tapestry.annotations.ApplicationState;

import org.apache.tapestry.annotations.Inject;

import org.apache.tapestry.annotations.OnEvent;import org.apache.tapestry.annotations.PageLoaded;

import org.apache.tapestry.annotations.Persist;

import org.apache.tapestry.annotations.Service;import org.apache.tapestry.services.RequestGlobals;










Modification de Home.javaimport tuto.webssh.domain.model.User;


public class Home {

@Inject

private ComponentResources resources; @Inject

private RequestGlobals requestGlobals;

@Inject

@Service("userManager")

private UserManager userManager;

@ApplicationState


@Persist

private User user;


return login;

}


this.login = login; }

@PageLoaded

public void onLoad() {

user = userManager.getUser(login);

}

@OnEvent(component = "logout")

public Link onLogout()

{HttpSession session = requestGlobals.getHTTPServletRequest().getSession();

session.invalidate();

return resources.createPageLink("login", false);

}

public User getUser() {

return user;

}

public void setUser(User user) {

this.user = user;

}

}

• Modifier Home.html :

Modification de Home.html

<html xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd" > <head>

<title>Congratulation</title>

</head>

<body>Congratulations, you are logged with login: ${login} !!<br/><br/>

Details of logged user are: ${user} <br/><br/>

<span id="LogoutLink"><span class="moduleTitle"><t:actionlink t:id="logout">Deconnexion</t:actionlink></span></

</body>

</html>










• Modifier User.java : nous allons surcharger la méthode toString qui sera automatiquement appelées par l'instruction $(user). Dans un premier temps nous n'afficherons pas l'objet associé Rights :

Modification de User

@Override

public String toString() { return "User: [id: "+idUser+",login: "+loginUser+"]";

}

A l'exécution, on obtient l'écran suivant sans problème :

Figure33 : Connexion avec détails

On va maintenant essayer d'afficher le détails des droits pour un User.

• Modifier les fonctions toString des classes User et Rights :

Modification de User

@Override

public String toString() { return "User: [id: "+idUser+",login: "+loginUser+", rights: "+rights+"]";

}

Modification de Rights

@Override

public String toString() {

return "Rights: [ id: "+id+", label: "+label+"]";

}

A l'exécution, on obtient l'erreur suivante :

Erreur de chargement retardé

org.apache.tapestry.ioc.internal.util.TapestryException: failed to lazily initialize a collection of

role:

tuto.webssh.domain.model.User.rights, no session or session was closed

Cela peut surprendre puisque nous avons configuré le filter OpenSessionInView, on pouvait penser que l'on étaitcapable, comme ici, de récupérer un objet (ici rights) inclus dans un autre (ici user) en retardé. Un point fondamentalà comprendre dans la gestion du lazy : cette fonctionnalité est disponible uniquement juste derrière la fermeture detransaction. Dans le cas présent, lors du chargement de la page html, la session a été fermée depuis longtemps,à la fin de la méthode onLoad().

• Pour s'en rendre compte, modifions une dernière fois la page Home.java :










Modification de la page Home.java

@PageLoaded

public void onLoad() {

User tempUser = userManager.getUser(login);

System.out.println(tempUser);

user = tempUser;

}

Dans le code ci-dessus, le lazy loading est déclenché par le print forcé au retour de l'appel au userManager .

A l'exécution, on obtient l'écran suivant qui prouve que le lazy loading s'est correctement déroulé :

Figure34 : Exécution du lazy loading

Cet exemple montre l'utilisation et les limitations du lazy loading. Il faut bien garder à l'esprit que la fonctionnalité n'estdisponible que dans le cadre de la méthode appelante la méthode transactionnelle et pas plus loin. On peut objecter que dans ce cas le lazy loading ne sert à rien � je le concède volontiers d'autant que l'objet associé étant très léger,il n'y a aucun intérêt à définir l'association en LAZY , on aurait pu la définir en EAGER .

Cependant, dans de nombreux cas, il est très pratique - notamment lors de la manipulation de listes à gros volumes.Ceci dit, dans le cas présent, la définition de l'association en EAGER nous aurait obligé à définir une nouvelle méthodedans les couches Service et DAO pour récupérer les droits d'un user donné.

En conclusion, le chargement retardé peut s'avérer très pratique et très puissant mais est à utiliser avec précautionscompte tenu des erreurs fréquentes qu'il peut générer. Cependant, lorsque le principe est compris, les bénéficessont indéniables.










IX - Conclusion

On a donc à présent une application blanche implémentant une forme simpliste de login grâce au trio Tapestry/Spring/

Hibernate.

Ce tutoriel nous a permis de nous familiariser avec les bases de chacun de ces trois frameworks. Evidemment, leur portée et leur puissance sont bien supérieures à ce qui a pu être évoqué dans le cadre de ce tutoriel. Il est à noter également qu'un certain travail reste à faire pour disposer d'un réel environnement de production - essentiellementau niveau d'Hibernate : mise en place d'un vrai pool de connexion (c3p0 par exemple), d'une solution de cache depremier et de second niveau (ehcache, etc.), etc.

Globalement on peut cependant s'apercevoir, suite à ce tutoriel, que la mise en place de ces trois frameworks n'estpas extraordinairement complexe. En outre, il est certain que l'utilisation de Spring et Hibernate permettra un gainde temps très important de part l'ensemble des problématiques qu'ils adressent de manière interne, permettant ainsiaux développeurs de s'en décharger (mapping O/R, accès BDD, gestion des Transaction, cycle de vie des objets,ThreadSafe, etc.). En outre, il y a fort à parier que leur utilisation rende le code de l'application plus robuste - Spring etHibernate addressant, sans doute, bien d'avantage de problèmes que ne peut le faire une équipe projet spécialisée

dans son domaine métier.

Enfin, il est indiscutable que ces frameworks apportent, de part leur architecture propre, une structuration forte del'architecture logicielle, une séparation des préoccupations (Technique vs Métier) des applications qui les utilisentet contribuent ainsi à leur robustesse, leur maintenabilité et leur évolutivité. Si l'on ajoute que l'ensemble de cesframework sont openSource et supportés par de très grandes et très actives communautés (Spring, Hibernate/JBoss,Apache), il me semble qu'il ne peut être qu'extrêmement profitable d'en user largement.










X - Remerciements

Merci à Ricky81, Hikage et aznowicz pour leur aide, leurs conseils et leur relecture technique.Merci à Dut pour la relecture orthographique.Ce document a été publié avec l'autorisation de la société qui m'emploie : Atos Worldline.


http://www.atosworldline.com/

http://www.developpez.net/forums/member.php?u=125006












XI - Dans la même série ...

Ce tutoriel est le premier d'une série de 3. Accéder aux autres tutoriels de cette série :

• Premier volet : Premier projet avec Tapestry5, Spring et Hibernate

• Deuxième volet : Intégration simple et élégante d'AJAX avec DWR• Troisième volet : Sécuriser vos applications Web avec Spring acegi security -> En Relecture


http://baptiste-meurant.developpez.com/tutoriaux/acegi-dwr-tapestry5-spring-hibernate/

http://baptiste-meurant.developpez.com/tutoriaux/dwr-tapestry5-spring-hibernate/

Documents

Tutoriel Tapestry5 Spring Hibernate