Tutoriel Struts2 – Réaliser un formulaire identification login avec session et OGNL en utilisant MVC 2

Posted on février 8th, 2010 by admin

Tutoriel Struts2 – Réaliser un formulaire de login avec session en utilisant MVC 2. A l’issue de ce tutoriel vous saurez manipuler un modèle et utiliser les ONGL (pour ObjectGraph Navigation Language) dans la couche vue.

Ce tutoriel implique que vous maîtrisiez déja l’environnement struts 2 tels que décrit ici.

Nous allons réalisé un simple formulaire de login en utilisant struts 2 et en respectant le modele MVC. Vous trouverez le code source java de l’application en bas de cette page.

Couche vue – Couche Action (controlleur) – couche modèle – Couche Données

1 – Création des beans et des classes Action

Commençons par créer un premier package dans notre répertoire source (src) que nous nommerons beans.

Dans ce package nous codons notre première classe que nous appellerons Utilisateur.

Utilisateur.java

View Code JAVA

package bean;
 
/**
 * @author Olivier Guillou
 * 2009 février
 *
 * Bean simpleUtilisateur.
 */
 
public class Utilisateur {
 
	/*
	 * Attributs
	 */
 
	/**
	 * L'identifiant
	 */
	String identifiant;
	/**
	 * Le mot de passe
	 */
	String mdp;
 
	/*
	 * Constructeurs
	 */
 
	/**
	 * Constructeur vide
	 */
	public Utilisateur() {
		// vide
	}	
 
	/**
	 * Constructeur qualifié
	 * @param identifiant
	 * @param mdp
	 */
	public Utilisateur(String identifiant, String mdp) {
		super();
		this.identifiant = identifiant;
		this.mdp = mdp;
	}
 
	/*
	 * Getters et setters
	 */	
 
	/**
	 * @return identifiant
	 */
	public String getIdentifiant() {
		return identifiant;
	}
 
	/**
	 * @param identifiant
	 */
	public void setIdentifiant(String identifiant) {
		this.identifiant = identifiant;
	}
	/**
	 * @return mdp
	 */
	public String getMdp() {
		return mdp;
	}
	/**
	 * @param mdp
	 */
	public void setMdp(String mdp) {
		this.mdp = mdp;
	}
 
}

Nous allons maintenant créer un package beanAction et une classe UtilisateurAction

View Code JAVA

package beanAction;
 
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import model.UtilisateurModel;
import bean.Utilisateur;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
 
/**
 * @author Guillou Olivier
 *
 * JEE Tutoriel 2009-2010
 *
 * Action Classe : UtilisateurAction
 */
 
public class UtilisateurAction extends ActionSupport {
 
	//-------------------------------------------------------------
	// Properties
	//-------------------------------------------------------------
 
	/**
	 * Description :
	 * long serialVersionUID
	 */
	private static final long serialVersionUID = 1L;
 
	// Objets
	private Utilisateur utilisateur;
 
	/**
	 * utilisateur identifié ?
	 */
	private boolean identificationUtilisateur;
 
	//-------------------------------------------------------------
	// Getters et setters
	//-------------------------------------------------------------		
 
	/**
	 * Accesseur
	 * @return the utilisateur
	 */
	public Utilisateur getUtilisateur() {
		return utilisateur;
	}
 
	/**
	 * Mutateur
	 * @param utilisateur the utilisateur to set
	 */
	public void setUtilisateur(Utilisateur utilisateur) {
		this.utilisateur = utilisateur;
	}
 
	/* (non-Javadoc)
	 * @see org.apache.struts2.interceptor.ServletRequestAware#setServletRequest(javax.servlet.http.HttpServletRequest)
	 */
	public void setServletRequest(HttpServletRequest arg0) {
		// TODO Auto-generated method stub
 
	}
 
	//-------------------------------------------------------------
	// Others methods
	//-------------------------------------------------------------	
 
	/**
	 * Methode
	 * Description : Permet d'identifier un utilisateur en fonction de son mot de passe et login.
	 * @return @struts Error or SUCCESS
	 */
 
	public String identifierUtilisateurs()  {
 
		// on créé un nouveau model
		UtilisateurModel utilisateurModel = new UtilisateurModel();
 
		// on récupère les données du formulaire
 
		String loginForm = utilisateur.getIdentifiant();
		String passwordForm = utilisateur.getMdp();
 
		// on interroge le model
		identificationUtilisateur = utilisateurModel.isIdentifier(loginForm, passwordForm);
		// test métier si l'identification est ok
		if (identificationUtilisateur == true) {
 
			// on récupère la session courante
			Map session = ActionContext.getContext().getSession();
			// on renseigne la session
			session.put("authentification","true");
			session.put("nomUtilisateur",utilisateur.getIdentifiant());
			session.put("erreur", "noErreur");
			System.out.println("Vous êtes loggué avec succès enjoy :)");
 
			return SUCCESS;
		}
		return ERROR;
	}
 
}

Nous allons maintenant créer un package model et une classe UtilisateurModel

View Code JAVA

package model;
 
import java.util.List;
import Bdd.TableUtilisateur;
import bean.Utilisateur;
 
/**
 * @author Olivier Guillou
 * 2009 février
 *
 *  Model Utilisateur.
 */
 
public class UtilisateurModel {
 
	//-------------------------------------------------------------
	// Methodes du model
	//-------------------------------------------------------------	
 
	/**
	 * Methode d'identifiacation de l'utilisateur
	 * @param loginForm
	 * @param passwordForm
	 * @return
	 */
	public boolean isIdentifier(String loginForm, String passwordForm) {
 
		// on récupère la liste dans la base de donnée (ici en dur)
		TableUtilisateur currentListe = new TableUtilisateur();
		List malist = currentListe.creationList();
 
		//on parcour la liste et on teste les entrées du formulaire.
		for (int i = 0; i &lt; malist.size(); i++) {
			if(loginForm.equalsIgnoreCase(malist.get(i).getIdentifiant()) &amp; passwordForm.equalsIgnoreCase(malist.get(i).getMdp())) {
				return true;
			}
		}
		return false;
	}
 
}

Nous allons maintenant créer un package nommé bdd et une classe TableUtilisateur

View Code JAVA

package Bdd;
 
import java.util.ArrayList;
import java.util.List;
import bean.Utilisateur;
 
/**
 * @author Olivier Guillou
 * 2009 février
 *
 * Table Utilisateurs.
 */
 
public class TableUtilisateur {
 
	/**
	 * On créé une lise d'utilisateur.
	 * @return
	 * @return malist
	 */
	public List<utilisateur /> creationList() {
 
		List<utilisateur /> malist = new ArrayList<utilisateur />();
 
		Utilisateur a = new Utilisateur("olivier", "pass");
		Utilisateur b = new Utilisateur("jérome", "pass2");
		Utilisateur c = new Utilisateur("admin", "admin");
		Utilisateur d = new Utilisateur("user", "user");
 
		malist.add(a);
		malist.add(b);
		malist.add(c);
		malist.add(d);
 
		return malist;
 
	}
 
}

2 – Création de la couche vue JSP et css

Dans le répertoire WebContent de votre application :

Nous allons créer une première page JSP contenant le formulaire de login que nous appellerons index.jsp

View Code XML

 
< %@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
< %@ taglib prefix="s" uri="/struts-tags"%>
 
< !DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
		<link rel="stylesheet" type="text/css" href="<s:url value="styles.css"/>" media="all" />
		<title>Formulaire de login</title>
 
	</meta></head>
 
	<body>
 
		<s :form action="identificationUtilisateur" method="post" theme="simple"
			cssClass="formulaireLogin">
 
			<p><s :textfield name="utilisateur.identifiant"
				value="Nom d'utilisateur" size="20" cssClass="inputs" /> <s :textfield
				name="utilisateur.mdp" value="Mot de passe" size="20"
				cssClass="inputs" /> <s :submit value="Login" align="center"
				cssClass="boutonLogin" /></p>
 
		</s>
 
	</body>
 
</html>

Nous allons créer une seconde page JSP indiquant à l’utilisateur qu’il est bien identifié. Nous la nommerons success.jsp

View Code XML

 
< %@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
< %@ taglib prefix="s" uri="/struts-tags"%>
 
< !DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
		<link rel="stylesheet" type="text/css" href="<s:url value="styles.css"/>" media="all" />
		<title>Formulaire de login</title>
 
	</meta></head>
 
	<body>
 
		<s :form action="identificationUtilisateur" method="post" theme="simple"
			cssClass="formulaireLogin">
 
 
 
 
 
			</s><s :if test="#session.authentification = 'true'">
				<h3>Vous êtes identifié : <span><s :property
					value="#session.nomUtilisateur" /></span></h3>
			</s>
 
 
 
	</body>
 
</html>

et pour finir cette couche vue nous allons mettre en forme nos pages JSP grâce à une feuille de style nommée styles.css

View Code CSS

@CHARSET "ISO-8859-1";
 
/* reset */
body,ul {
	margin: 0px;
	padding: 0px;
}
 
.formulaireLogin {
	font-family: Verdana, Arial, Helvetica, sans-serif;
	border: 1px solid #ccc;
	width: 200px;
	margin: auto;
	margin-top: 100px;
	text-align: center;
	-moz-border-radius: 70px 10px;
	padding: 10px;
}
 
.inputs {
	display: block;
	margin: auto;
	margin-bottom: 5px;
	border: 1px solid #ccc;
	color: #333;
}
 
.boutonLogin {
	margin: auto;
	margin-top: 15px;
	border: 1px solid #ccc;
}
 
.formulaireLogin span {
	display: block;
	color: #cccc00;
	font-family: Verdana, Arial, Helvetica, sans-serif;
	border: 1px solid #ccc;
	margin: auto;
	margin-top: 10px;
	text-align: center;
	-moz-border-radius: 70px 10px;
	padding: 10px;
}

3 – Création de la couche XML, les fichiers struts.xml et web.xml

Voici le contenu de notre fichier web.xml (rien de très particulier).

View Code XML

< ?xml version="1.0" encoding="UTF-8"?>
<web -app>
  <display -name>Application</display>
 
<!-- Les welcomes Files -->  
 
  <welcome -file-list>
    </welcome><welcome -file>index.html</welcome>
    <welcome -file>index.htm</welcome>
    <welcome -file>index.jsp</welcome>
 
 
	<!-- Le filtre de struts  --> 
 
    <filter>
        </filter><filter -name>struts2</filter>
        <filter -class>org.apache.struts2.dispatcher.FilterDispatcher</filter>
 
 
    <filter -mapping>
        </filter><filter -name>struts2</filter>
        <url -pattern>/*</url>
 
 
 
	<context -param>
        <param -name>toto</param>
        <param -value>Un Parametre</param>
    </context>
 
 
</web>

Et voici le contenu de notre fichier struts.xml

View Code XML

< ?xml version="1.0" encoding="UTF-8"?>
 
< !DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
 
<struts>
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <constant name="struts.devMode" value="true" /> 
    <constant name="struts.custom.i18n.resources" value="package"  />
 
    <package name="frontoffice" namespace="/" extends="struts-default">
        <default -action-ref name="index" /> 
 
        <!--  Ident rules -->
 
        <action name="identificationUtilisateur" class="beanAction.UtilisateurAction" method="identifierUtilisateurs">
            <result name="success">success.jsp</result>
        	<result name="error">index.jsp</result>
        </action>
 
	</package>
 
</struts>

La structure de votre projet doit ressembler à ceci :

Lancez la page index.jsp et testez le résultat : mot de passe : admin, identifiant : admin

Nous allons maintenant décortiquer tous ces fichiers.

4 – Analyses et explications

4.1 – Création des beans, des classes Action et des classes Model

Nous sommes ici dans la couche modèle.

A - Dans un premier temps nous avons créé ce que l’on appelle un bean simple (utilisateur.java). Un bean est une classe qui contient des attributs, des getters et setters ainsi qu’un contructeur par défaut (et rien d’autre). Sun les définit comme « des composants logiciels réutilisables manipulables visuellement dans un outil de conception ».

B – Nous avons ensuite créé une ActionClass ( UtilisateurAction.java ) qui va interagir avec le fichier struts.xml et interroger les classes modèle le cas échant (accès aux données). Les actions classes sont mappés dans le fichier struts.xml.

Les classes action sont le nerf du framework Struts 2. Ce framework est d’ailleurs dit « orienté action ». Comme bour les bean les Classes Actions obéissent à des conventions :

- Elle doivent contenir des getters et setters pour tous leurs attributs.

- Elle doivent contenir un constructeur par défaut sans arguments.

- Elle contiennent une ou plusieurs action pour réaliser les traitments.

- Elle hérite en général de la classe actionSupport.

L’implémentation d’ActionSupport donne accès à plusieurs constantes :

- SUCCESS : l’éxécution de l’action s’est bien déroulée.

- NONE : l’action ne retourne aucun résultat mais est correcte.

- ERROR : l’éxécution de l’action est en erreur.

- INPUT : s’utilise avec les formulaires en cas d’erreur retourne sur la page courante.

- LOGIN : utilisée lors de l’authentification.

Mais iln’est pas obligatoire d’utiliser cette terminologie, les méthodes d’action peuvent renvoyer n’importe quelle String à condition qu’il y ai une correspondance dans les actions du fichiers Struts.xml ( <result name= »maString »/>).

C - Nous avons ensuite créé une ModelClass ( UtilisateurModel.java ) qui est notre classe d’accès aux données (DAO). Dans notre exemple les données sont stockées en dur dans TableUtilisateur.java . Dans notre exemple ce sont les ActionsClass qui interagisserons avec les classes modèles.

4.2 – Création de la couche vue JSP et css

Nous sommes ici dans la couche vue.

A - Nous n’allons pas nous attarder sur le fichier styles.css qui à pour fonction de mettre en forme les fichiers Jsp de notre IHM.

B - Nous avons créé un formulaire ( index.jsp ) en utilisant les tags stuts :

<s:form/>

Voici les attributs les plus utilisés de cette balise :

action= »identificationUtilisateur » /* nous envoyons une action qui sera récupérée et traitée par le fichier struts.xml

method= »post » /* type d’envoi en mode post

theme= »simple » /* supression de la mise en forme automatique de struts 2. Notre formualire sera codé en xhtml sans balises superflues.

cssClass= »formulaireLogin » /* cssClass est l’équivalent de l’attribut class en Xhtml et permet d’appliquer un style sur l’élement courant.

<s:textfield/>

C’est l’équivalent de la balise <input type= »text »/>

name= »utilisateur.identifiant » /* nous indiquons à struts qu’il devra utiliser un objet utilisateur et renseigner son attribut identifiant. Cet objet utilisateur est de type Utilisateur qui est une instance de la classe Utilisateur.java.

value= »identifiant d’utilisateur » /* la valeur par défaut du champ input.

<s:submit> /* le bouton de soumission

Pour un approfondissement sur les différents tag struts 2 je vous renvoi vers la documentation officielle : http://struts.apache.org/2.0.14/docs/tag-reference.html

C – Nous avons également créé une page success.jsp qui s’affiche en cas d’authentification correcte.

Nous y faisons un test grâce à la balise <s :if/> et affichons (ou non ) les variables contenues dans la session grâce à cette notation : test= »#session.authentification = ‘true’ ».

Certains attributs des balises struts 2 permettent d’afficher du contenu statique ou dynamique. On utilise pour cela la notation ONGL (pour Object Graph Navigation Language). Nous pouvons directement comme dans notre exemple récupérer des valeurs dans une session :

notation value= »#session.valeur » et également y faire des traitement comme des comparaisons ( = ‘true’)

Nous pouvons également grace à ONGL récupérer nos valeurs :

request.getAttribute() : value= »#request.utilisateur.mdp »

request.getParameter() : value= »#request.xxx »

etc…

liste exhaustive ici

4.3 – Création de la couche Controller

Il s’agit ici de notre fichier struts.xml qui mappe nos actions et applique des règle de redirection ou de chainage.

Décortiquons :

View Code XML

<action name="identificationUtilisateur" class="beanAction.UtilisateurAction" method="identifierUtilisateurs">
            <result name="success">success.jsp</result>
        	<result name="error">index.jsp</result>
</action>

Nous avons défini une action nommée identificationUtilisateur. Cette action est appelée lorsque l’on soumet le formulaire présent sur la page index.jsp.

A cette action nous associons une classe d’action ici beanAction.UtilisateurAction.

Cette classAction va réaliser le traitement en appelent notre classeModel et renvoyer un result. Nous définissons donc les règles de redirection en cas de result=Success ou result=error vers les pages jsp correspondantes.

Vous pouvez télécharger le projet complet au format war ici

En cas d’erreur au démarrage du filtre struts 2 il faut passer le dev.mode dans le struts.xml à false.

14 Responses to “Tutoriel Struts2 – Réaliser un formulaire identification login avec session et OGNL en utilisant MVC 2”

bbr31

1 year ago

Pour la classe TableUtilisateur, vous avez mis le contenu de la classe ModelUtilisateur
admin

1 year ago

merci du retour c’est corrigé.
olivier92

1 year ago

Salut, pour la classe UtilisateurModel, tu as fait ceci :
List malist = currentListe.creationList();
mais il faut définir plus précisément la List pour que malist.get(i).getIdentifiant() fonctionne :
List malist = currentListe.creationList();
Olivier Guillou

1 year ago

@olivier92, merci pour la remarque, c’est corrigé

List malist<Utilisateur> = currentListe.creationList();
Jay Goncalves

1 year ago

c’est normal qu’il y ait » media= »all » > dans les deux fichiers jsp?????????? à mon avis il y a dû y avoir un problème dans l’affichage des codes. ce serait sympa si tu pourrais arranger ça pour moi et pour les autres qui aimerait suivre ton tutoriel.
admin

1 year ago

merci du retour, le site s’est fait attaqué via un plugin (codebox) -> (injection de code). Je n’avais pas remarqué que cela avait altéré le code des exemples. J’y remédie au plus vite.
tarik

1 year ago

bonsoir;
j ai téléchargé le projet complet au format war et j’ai ajouté au eclipse mais quand j ai exécuté le navigateur (projectNameSimple) m’affiche le message d’erreur 404 et d’ailleurs cette erreur est s affiche sur tout les projet que j’ai voulu créer avec le framework struts mais l exemple fourni par apatch » struts2-blank-… » est tourne bien.
je ne sais pas affaire je suis débutant sur struts. veuillez m aide s’il vous plait.
je vous remercie d’avance.
Pierre

1 year ago

Encore merci pour ce tuto, qui m’éclaire beaucoup sur struts =)
Corvus

1 year ago

Le war fonctionne correctement, en revanche le code exposé sur la page ne correspond pas au code des classes du war. Par exemple, sur la page les List n’ont pas de classe associée entre , et ça crée des erreurs dans le code quand il s’agit de faire appel à des méthodes de la classe qui est censée être associée à la List.
Même chose pour les Map.

C’est pas grand chose au final, mais je tenais à le signaler car ça peut perturber.
admin

1 year ago

Merci pour cette remarque je vais vérifier et corriger ce pb. cdlt
Baracouda

1 year ago

Salut

Je sais pas si j ai tout bien saisi de OGNL
Parce que je me suis dit que dans success.jsp , on pourrait aussi éCrire

Vous êtes identifié :
mdp :
mdp :

Merci pour vos lumières !

Pourtant mdp : ne retourne rien alors qu’ il est bien défini dans utilisateurAction.java

ie String passwordForm = utilisateur.getMdp(); // attribut mdp défini dans la classe utilisateur
Baracouda

1 year ago

if test= »#session.authentification = ‘true’ »>
Vous êtes identifié :
mdp :
mdp :
MCHENAFA

1 month ago

Merci encore pour ce tuto très utile pour les débutant comme moi.

Juste une petite remarque, des erreur sont présent dans le code des fichier jsp ainsi que les xml.
Ex :

index.html
index.htm
index.jsp