Netapsys Blog

Avertissement: Dépendances/classpath: le jar spring-modules-0.9.jar de Spring validation doit être dans le classpath car il n' est pas inclus dans les spring_xxxx.jar.
Pour un projet maven, ajouter dans le pom.xml la ligne:

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-modules</artifactId>
      <version>0.9</version>
    </dependency>

Le framework de validation de Spring se décline en quatre actes qui vont être détaillés par la suite:

ACTE 1:

  - Ecrire vos beans (POJO) entités.

Puis, pour leurs attributs à valider, ajouter les annotations appropriées tels @NotBlank, @Length, @Email, @Range, @InThePast, @InTheFuture,....

ACTE 2:

  - Déclarer un des validators prédéfinis de Spring
 dans son fichier de config comme suit:

<!-- Enable annotation-based validation
        using Bean Validation Framework -->
   <bean id="configurationLoader"  
    class=
     "o.springmodules.validation.bean.
       conf.loader.annotation.
      AnnotationBeanValidationConfigurationLoader"/>
   <bean id="validator" class=
      "o.springmodules.validation.bean
      .BeanValidator" 
      p:configurationLoader-ref="configurationLoader"/>

Notez que l'utilisation du namespace p: va rendre la configuration xml plus concise comme nous le verrons par la suite.

ACTE 3:

  
  - Dans le Controller du spring MVC, déclarer

le Validator annoté avec @Autowired comme suit:

//*** validator de spring validation	
  private Validator validator;
  @Autowired
  public setValidator(Validator validator){
    this.validator=validator;
  }

Pour le projet java Standalone, nous donnerons toutes les précisions utiles au moment de présenter l'exemple.

ACTE 4:

  - Ajouter dans cette même classe une seule ligne de code:

validator.validate(YOUR_BEAN_POJO, ..)

Et voilà !

Pour le peu d'effort déployé nous avons obtenu ceci :

Et cela :

Ok, tout ça est bien! Mais comment cela fonctionne t-il ?

Avant de répondre, construisons ensemble un exemple de projet Spring MVC simple et détaillons chacun des 4 actes.

  Projet démo Web Spring MVC

Pour ce projet web exemple en Spring MVC nommé spring-mvc, nous aurons à manipuler :

• Le(s) classe(s) POJOs : Personne.java et Client.java
  
• Le fichier de configuration du contexte web de Spring : spring-mvc-servlet.xml
  
• La classe du controller de Spring nommée ClientControllerSpringMVC.java
  
• Le fichier « properties » nommé : messages.properties
  

ACTE1:

Ecrire les POJOs:

public class Personne implements Serializable {
	String nom;
	String prenom;
	// + setters/getters omis
}

public class Client extends Personne{
	long cliId;
	@NotBlank 
	@Length( max = 15) 
	private String cliNom;
        //***aucune regle de validation sur prenom
	private String cliPrenom;
	@NotBlank @Length(min=4) @Email
	private String cliEmail;
       //+setters / getters omis
	public String toString(){
		return "Id="+getCliId()+ " nom="+getNom()+
                      " prenom="+getPrenom();
	}
}

ACTE2:

Le fichier spring-mvc-servlet.xml contient ces lignes:

<?xml version="1.0" encoding="UTF-8"?>
<beans 
        xmlns=
"http://www.springframework.org/schema/beans" xmlns:xsi=
"http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p=
"http://www.springframework.org/schema/p" xmlns:context=
"http://www.springframework.org/schema/context"
	xsi:schemaLocation=
 "http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/
  beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/
   context/spring-context-2.5.xsd"
 default-autowire="byName">
   <bean id="configurationLoader"  
    class=
     "o.springmodules.validation.bean.conf.
     loader.annotation.
    AnnotationBeanValidationConfigurationLoader"/> 
   <bean id="validator" class=
    "org.springmodules.validation.bean.BeanValidator" 
    p:configurationLoader-ref="configurationLoader"/> 
 
    <!-- Load messages --> 
   <bean id="messageSource"  
      class=
       "o.s.context.support.ResourceBundleMessageSource"
	   p:basenames="messages"/> 
   <bean class=
       "o.s.web.servlet.view.
        InternalResourceViewResolver"
	   p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>

Notez que certaines écritures des packages connus sont abrégées: par exemple, o.s pour désigner org.springframework.


ACTES 3 et 4Le controller et le fichier properties:

- La validation dans le controller:

Dans le controller, ajouter la déclaration du validator, par exemple, dans la méthode createClient comme suit :

//*** Controller de spring MVC avec les annotations	
@Controller("clientControllerSpring")
public class ClientControllerSpringMVC {
	final Logger logger=Logger.getLogger(getClass().getName());
 
 
==>	private Validator validator;  
	@Autowired         
	public void setValidator(Validator validator) {  
		this.validator = validator;  
	}  
 
	@RequestMapping(value = "/createClient.html", 
                                        method = RequestMethod.GET)  
	public ModelMap get() {     
		return new ModelMap("client", new Client());  
	}  
	@RequestMapping(value="/createClient.html",
                                       method = RequestMethod.POST)
	public String createClient(	@ModelAttribute("client") Client client,
                                      	BindingResult result,	ModelMap model) {
 
==>		validator.validate(client, result);
==>		if(result.hasErrors()){
			logger.warn("Erreurs sur le client "+result.toString());
			return null;
		}
			//Traitement métier;
 
		return Constants.SUCCESS;
	}
}

Les trois passages intéressants à observer sont précédés de la flèche "==>".



Enfin, compléter le fichier « messages.properties » sur l’exemple qui suit :

Client.cliNom[not.blank]=Merci de saisir votre nom.  
Client.cliNom[length]=Merci de saisir moins de {2} caracteres.

Pour finir, lancer la commande:

mvn jetty:run

Avec le navigateur saisir le lien:
http://localhost:8080/spring-mvc/createClient.html
Vous obtenez alors les formulaires des captures présentées précédemment.
Il ne vous reste qu'à tester les différentes possibilités de saisie dans les 2 champs "nom" et "email".

Conclusion :
Cette première partie a révélé la puissance de ce framework (add-on) de Spring intégré dans un projet Web MVC.
Seules les annotations @NotBlank, @Length et @Email ont été évoquées.
Nous poursuivons, dans la seconde partie de ce billet, la démonstration sur un projet Java standard.
D’autres annotations de validation vont être présentées : @InThePast, @Size, @Range,…

Nous montrons également comment créer notre propre classe de validation qui permet d’étendre les fonctionnalités de validation existantes.
D’un point de vue économique et de gestion de projet, l’effort et le temps gagnés avec ce framework sont manifestement énormes.