Le blog

Ce billet a pour objectif de définir la validation et de décrire sa mise en place au sein d’une application spring-mvc utilisant le paramétrage XML.

Je définirais la validation comme un procédé permettant de pouvoir s’assurer de la présence d’une donnée dans un formulaire et d'en vérifier le type ou la nature. Par exemple, on doit pouvoir s’assurer que lorsqu’on s’attend à recevoir une donnée numérique, celle-ci est bien de type numérique.

Comme présenté dans mon précédent billet, on peut définir deux phases dans le cycle de vie d’un controller spring-mvc :

• La première phase consiste à afficher le formulaire. Dans cette phase, toutes les méthodes destinées à préparer les informations qui devront être affichées, seront appelées.
• Dans la seconde phase, le controller procède au traitement des données saisies. C’est dans cette deuxième phase que le procédé de validation intervient. Si un valideur est déclaré, celui-ci est appelé avant toute autre méthode du controller. S’il ne trouve pas d’erreur, il passe la main au controller qui procède au traitement. S'il trouve au moins une erreur, le traitement prend fin et la page du formulaire est réaffichée pour une nouvelle saisie.

Déclaration du valideur

La validation est effectuée par l’intermédiaire d’un « valideur ». Pour pouvoir effectuer la validation d’un formulaire vous devrez donc déclarer votre valideur. Ci-dessous un exemple de déclaration :

<bean id="saisieArticleReceptionValidator" 
	class="com.madura.validator.SaisieArticleReceptionValidator>
			<property name="articleManager" ref="articleManager" />
</bean>

Comme vous pouvez le voir ci-dessus, les valideurs spring-mvc se déclarent comme tous les autres beans coté XML. Ils ont un id qui permet de les référencer dans le contexte spring-mvc et le nom pleinement qualifié de la classe du valideur.
Et comme tous les autres beans, on peut y injecter d’autres beans.
Coté java, le valideur se présente de la manière suivante :

public class PersonValidator implements Validator {
       /**
         * This Validator validates just Person instances
      */
            public boolean supports(Class clazz) {
	        return Person.class.equals(clazz);
            }
          public void validate(Object obj, Errors e) {
	        //code
          }
      }

Pour pouvoir écrire un valideur, vous devez déclarer comme ci-dessus une classe implémentant l’interface « validator » fournie par spring-mvc.
Validator possède deux méthodes que vous devrez implémenter.

• La méthode « supports » qui permet d’indiquer au valideur quelle classe il va devoir valider.
• La méthode « validate » qui contiendra le code destiné à valider les informations saisies par l’utilisateur.

Utilisation du valideur

Une fois votre valideur écrit, il faut l’utiliser. Pour cela vous allez devoir le déclarer au sein de votre classe controller.
Ci-dessous, dans le cas d’un SimpleFormController :

<bean id="identificationController"  class="com.madura.controller.IdentificationController">
	<property name="formView" value="identification" />
	<property name="commandName" value="utilisateur" >
	<property name="commandClass"  value="com.madura.view.impl.UtilisateurInfo">
	<property name="userManager" ref="utilisateurManager" />
	<property name="validator" ref="identificationValidator"/>
</bean>

Comme vous pouvez le voir, pour utiliser votre valideur, il vous suffira de l’injecter au sein de la configuration du controller sous la propriété « validator » en indiquant la classe à laquelle il fait référence.
Note : vous avez la possibilité de déclarer directement votre valideur au sein de votre controller. L’avantage de le déclarer à l’extérieur, selon moi, est d’avoir une meilleure lisibilité et de pouvoir le réutiliser dans un autre controller.

ValidationUtils et Errors

Pour effectuer la validation, spring-mvc met à votre disposition la classe abstraite ValidationUtils et l’interface Errors. ValidationUtils vous permettra d’utiliser tout un panel de méthodes statics qui vous permettront de vérifier les champs de votre objet formulaire.
Lors de chaque vérification, si la classe ValidationUtils trouve une erreur dans la saisie, ou une information manquante, elle ajoutera une erreur dans Errors.
Une fois la validation terminée, si l’objet contient ne serait ce qu’une seule erreur, la page du formulaire est renvoyée à nouveau pour une nouvelle saisie.
Si aucune des méthodes utilitaire fournies avec ValidationUtils ne convient, vous avez la possibilité d’effectuer par vous-même le contrôle de vos champs en utilisant Errors.
Voici un exemple d’utilisation :

ValidationUtils.rejectIfEmptyOrWhitespace(errors,  "matricule",  
                                                "Veuillez saisir un identifiant utilisateur");

Vous trouverez plusieurs surcharges pour chaque type de contrôle. Ici la méthode « rejectIfEmptyOrWhitespace » contrôle que la donnée du champ « matricule » n’est pas vide et ne contient pas d’espace. Dans le cas ou la donnée n’est pas valide, elle permet de définir un message de retour et ajoute une erreur dans l’objet « errors ».
Ci-dessous, vous trouverez la méthode correspondante de l’objet errors. La différence, dans ce cas, est que vous devrez procéder vous-même à tous les contrôles.

errors.rejectValue("matricule",  "utilisateur.matricule", 
                                               " Veuillez saisir un identifiant utilisateur ");

Validation dans le AbstractWizardFormController

Maintenant que nous avons vu comment on procéde à la validation dans le SimpleFormController, voyons le cas du AbstractWizardFormController. Comme je l’ai indiqué dans mon billet sur les différents controllers, l’AbstractWizardFormController est un controller qui vous permet de créer des formulaires multi pages. La validation dans ce controller est donc assez spécifique.
En effet, il n’y a pas la possibilité de créer de valideur dans celui-ci. Pour pouvoir procéder à la validation de votre formulaire vous devrez réécrire la méthode validate au sein même du controller.

@Override    
protected void validatePage(final Object command, final Errors errors, final int page)  {        
	switch (page) {            
		case 0 : validatePage0(command, errors);                		
break;            
		case 1 : validatePage1(command, errors);                
			break;
		default : break;        
	}        	
	super.validatePage(command, errors, page);
 
}

Le paramètre « page » vous permettra de pouvoir effectuer un traitement spécifique pour chacune des pages que vous souhaiterez valider.

Cas du MultiActionFormController

Le MultiActionFormController est un cas encore plus spécifique. Celui-ci n’est pas vraiment fait pour les procédés de validation. En effet, son utilisation est préconisée seulement pour les pages qui ne nécessitent que de l’affichage. Je vous déconseille donc de vous en servir pour le traitement de formulaire.

Affichage des erreurs dans le formulaire

Une fois que les erreurs ont été trouvées, il faut indiquer à l’utilisateur les champs qu’il n’a pas saisis ou mal saisis. Pour cela spring-mvc met à votre disposition le tag <form :errors> qui récupère l’information et affiche les messages d’erreurs.

<tr>		
		<td colspan="3" align="center">					
                      <font color="red">							
                         <b>						
                                <form:errors path="matricule"/>				
                         </b>
		       </font>		
		</td>	
	</tr>

Ce tag prend pour simple paramètre le nom du champ du formulaire. Vous avez la possibilité d’afficher tous les messages d’erreur en une seule fois en plaçant le paramètre path à « * ».