Lorsque nous acceptons des entrées utilisateur dans n’importe quelle application Web, il devient nécessaire de les valider. Nous pouvons valider l’entrée utilisateur côté client en utilisant JavaScript, mais il est également nécessaire de les valider côté serveur pour nous assurer que nous traitons des données valides au cas où l’utilisateur aurait désactivé JavaScript.
Validation Spring
Le cadre Spring MVC prend en charge les spécifications JSR-303 par défaut et tout ce dont nous avons besoin est d’ajouter JSR-303 et ses dépendances d’implémentation dans l’application Spring MVC. Spring fournit également l’annotation @Validator et la classe BindingResult à travers lesquelles nous pouvons obtenir les erreurs générées par l’implémentation du validateur dans la méthode de gestion de la requête du contrôleur. Nous pouvons créer nos propres implémentations de validateurs de deux manières – la première consiste à créer une annotation qui est conforme aux spécifications JSR-303 et à implémenter sa classe de validateur. La deuxième approche consiste à implémenter l’interface org.springframework.validation.Validator et à l’ajouter en tant que validateur dans la classe du contrôleur à l’aide de l’annotation @InitBinder. Créons un projet simple Spring MVC dans Spring Tool Suite où nous utiliserons les spécifications JSR-303 avec son artefact d’implémentation hibernate-validator. Nous utiliserons une validation de formulaire basée sur des annotations et créerons notre propre classe de validateur personnalisée basée sur les normes JSR-303. Nous créerons également notre propre classe de validateur personnalisée en implémentant l’interface Validator et l’utiliserons dans l’une des méthodes de gestion du contrôleur. Notre projet final ressemble à l’image ci-dessous. 
Examinons chacun des composants un par un.
Validateur de formulaire Spring MVC
Notre fichier pom.xml final ressemble à ce qui suit. En plus des artefacts Spring MVC standard, nous avons des dépendances validation-api et hibernate-validator dans le projet.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev</groupId>
<artifactId>spring</artifactId>
<name>SpringFormValidation</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.7</java-version>
<org.springframework-version>4.0.2.RELEASE</org.springframework-version>
<org.aspectj-version>1.7.4</org.aspectj-version>
<org.slf4j-version>1.7.5</org.slf4j-version>
</properties>
<dependencies>
<!-- Form Validation using Annotations -->
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.1.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>4.1.0.Final</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
Descripteur de déploiement
Lorsque vous créez un projet Spring MVC à partir de STS, il crée deux fichiers de configuration de contexte. J’ai un peu nettoyé et n’ai qu’un seul fichier de configuration de bean Spring. Mon fichier web.xml final ressemble à ce qui suit.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/spring.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
Fichier de configuration de bean Spring
Habituellement, nous examinons les configurations Spring en dernier, mais cette fois-ci nous n’avons pas beaucoup de configurations dans le fichier de configuration de bean Spring. Notre fichier spring.xml final ressemble à ce qui suit.
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="https://www.springframework.org/schema/beans"
xmlns:context="https://www.springframework.org/schema/context"
xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<resources mapping="/resources/**" location="/resources/" />
<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<beans:bean id="employeeValidator" class="com.journaldev.spring.form.validator.EmployeeFormValidator" />
<beans:bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<beans:property name="basename" value="classpath:message" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
<context:component-scan base-package="com.journaldev.spring" />
</beans:beans>
Le seul point important à noter est le bean employeeValidator que nous injecterons dans l’un des contrôleurs et le bean messageSource pour lire les données localisées à partir de paquets de ressources. Le reste de la partie consiste à prendre en charge les annotations, les résolveurs de vue et à fournir un package à analyser pour les classes de contrôleur et autres composants.
Classes de modèle
Nous avons deux classes de modèle dans ce projet – la première où nous utiliserons l’annotation JSR-303 et notre validateur basé sur une annotation personnalisée, et la deuxième où nous utiliserons uniquement notre implémentation de validateur. Code de Customer.java :
package com.journaldev.spring.form.model;
import java.util.Date;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Past;
import javax.validation.constraints.Size;
import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.format.annotation.DateTimeFormat;
import com.journaldev.spring.form.validator.Phone;
public class Customer {
@Size(min=2, max=30)
private String name;
@NotEmpty @Email
private String email;
@NotNull @Min(18) @Max(100)
private Integer age;
@NotNull
private Gender gender;
@DateTimeFormat(pattern="MM/dd/yyyy")
@NotNull @Past
private Date birthday;
@Phone
private String phone;
public enum Gender {
MALE, FEMALE
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
}
Remarquez que nous utilisons les annotations @Email, @NotEmpty et @DateTimeFormat qui sont supplémentaires à JSR-303 et fournies par l’implémentation du validateur Hibernate. Certaines des annotations JSR-303 que nous utilisons sont @Size, @NotNull, etc. L’annotation @Phone utilisée est notre implémentation personnalisée basée sur les spécifications JSR-303, nous y reviendrons dans la section suivante. Code de Employee.java :
package com.journaldev.spring.form.model;
public class Employee {
private int id;
private String name;
private String role;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
}
L’employé est un bean java standard et nous utiliserons notre implémentation de validateur personnalisé pour valider le formulaire avec le bean Employee.
Implémentations de validateur personnalisé
Code de Phone.java :
package com.journaldev.spring.form.validator;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
import javax.validation.Constraint;
import javax.validation.Payload;
@Documented
@Constraint(validatedBy = PhoneValidator.class)
@Target( { ElementType.METHOD, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Phone {
String message() default "{Phone}";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
La plupart de la partie est du code boilerplate pour se conformer aux spécifications JSR-303. La partie la plus importante est l’annotation @Constraint où nous fournissons la classe qui sera utilisée pour la validation, c’est-à-dire PhoneValidator. Code de PhoneValidator.java :
package com.journaldev.spring.form.validator;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
public class PhoneValidator implements ConstraintValidator {
@Override
public void initialize(Phone paramA) {
}
@Override
public boolean isValid(String phoneNo, ConstraintValidatorContext ctx) {
if(phoneNo == null){
return false;
}
//valider les numéros de téléphone au format "1234567890"
if (phoneNo.matches("\\d{10}")) return true;
//validation du numéro de téléphone avec -, . ou des espaces
else if(phoneNo.matches("\\d{3}[-\\.\\s]\\d{3}[-\\.\\s]\\d{4}")) return true;
//validation du numéro de téléphone avec une longueur d'extension de 3 à 5
else if(phoneNo.matches("\\d{3}-\\d{3}-\\d{4}\\s(x|(ext))\\d{3,5}")) return true;
//validation du numéro de téléphone où le code régional est entre parenthèses ()
else if(phoneNo.matches("\\(\\d{3}\\)-\\d{3}-\\d{4}")) return true;
//renvoie faux si rien ne correspond à l'entrée
else return false;
}
}
Notre implémentation de validateur de spécifications JSR-303 devrait implémenter l’interface javax.validation.ConstraintValidator. Si nous utilisons des ressources telles que DataSource, nous pouvons les initialiser dans la méthode initialize(). La méthode de validation est isValid et elle renvoie vrai si les données sont valides, sinon elle doit renvoyer faux. Si vous êtes nouveau dans les expressions régulières, vous pouvez en savoir plus à ce sujet sur Tutoriel sur les Expressions Régulières en Java. Code de la classe EmployeeFormValidator.java :
package com.journaldev.spring.form.validator;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import com.journaldev.spring.form.model.Employee;
public class EmployeeFormValidator implements Validator {
//quels objets peuvent être validés par ce validateur
@Override
public boolean supports(Class paramClass) {
return Employee.class.equals(paramClass);
}
@Override
public void validate(Object obj, Errors errors) {
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "id", "id.required");
Employee emp = (Employee) obj;
if(emp.getId() <=0){
errors.rejectValue("id", "negativeValue", new Object[]{"'id'"}, "id can't be negative");
}
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.required");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "role", "role.required");
}
}
EmployeeFormValidator est l’implémentation du validateur spécifique au framework Spring. La méthode supports() est implémentée par le framework Spring pour connaître les objets sur lesquels cette validation peut être utilisée. Nous implémentons la méthode validate() et ajoutons des erreurs si la validation d’un champ échoue. Spring fournit la classe utilitaire org.springframework.validation.ValidationUtils pour les validations de base telles que la nullité ou l’emptiness. Une fois que cette méthode retourne, le framework Spring lie l’objet Errors à l’objet BindingResult que nous utilisons dans notre méthode de gestionnaire du contrôleur. Remarquez que le dernier argument de ValidationUtils.rejectIfEmptyOrWhitespace() prend le nom de clé pour les ressources des messages. De cette manière, nous pouvons fournir des messages d’erreur localisés à l’utilisateur. Pour plus d’informations sur i18n dans Spring, consultez Spring i18n Example.
Classes de Contrôleur
Nous avons deux classes de contrôleur, l’une pour la validation de formulaire basée sur les annotations et l’autre pour notre validateur personnalisé. Code de la classe CustomerController.java :
package com.journaldev.spring.form.controllers;
import java.util.HashMap;
import java.util.Map;
import javax.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.journaldev.spring.form.model.Customer;
@Controller
public class CustomerController {
private static final Logger logger = LoggerFactory
.getLogger(CustomerController.class);
private Map<String, Customer> customers = null;
public CustomerController(){
customers = new HashMap<String, Customer>();
}
@RequestMapping(value = "/cust/save", method = RequestMethod.GET)
public String saveCustomerPage(Model model) {
logger.info("Returning custSave.jsp page");
model.addAttribute("customer", new Customer());
return "custSave";
}
@RequestMapping(value = "/cust/save.do", method = RequestMethod.POST)
public String saveCustomerAction(
@Valid Customer customer,
BindingResult bindingResult, Model model) {
if (bindingResult.hasErrors()) {
logger.info("Returning custSave.jsp page");
return "custSave";
}
logger.info("Returning custSaveSuccess.jsp page");
model.addAttribute("customer", customer);
customers.put(customer.getEmail(), customer);
return "custSaveSuccess";
}
}
Quand nous utilisons la validation de formulaire basée sur l’annotation, nous avons juste besoin d’apporter de petites modifications à la mise en œuvre de notre méthode de gestionnaire du contrôleur pour que cela fonctionne. Tout d’abord, nous devons annoter l’objet modèle que nous voulons valider avec l’annotation @Valid. Ensuite, nous devons avoir un argument BindingResult dans la méthode, Spring se charge de le peupler avec des messages d’erreur. La logique de la méthode du gestionnaire est très simple, s’il y a des erreurs, nous répondons avec la même page, sinon nous redirigeons l’utilisateur vers la page de réussite. Un autre point important à noter est que nous ajoutons l’attribut « customer » au modèle, cela est nécessaire pour informer le framework Spring de l’objet modèle à utiliser dans la page du formulaire. Si nous ne le faisons pas, la liaison d’objet aux données du formulaire ne se fera pas et notre validation de formulaire ne fonctionnera pas. Code de la classe EmployeeController.java :
package com.journaldev.spring.form.controllers;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.journaldev.spring.form.model.Employee;
@Controller
public class EmployeeController {
private static final Logger logger = LoggerFactory
.getLogger(EmployeeController.class);
private Map emps = null;
@Autowired
@Qualifier("employeeValidator")
private Validator validator;
@InitBinder
private void initBinder(WebDataBinder binder) {
binder.setValidator(validator);
}
public EmployeeController() {
emps = new HashMap();
}
@ModelAttribute("employee")
public Employee createEmployeeModel() {
// La valeur de ModelAttribute doit être la même que celle utilisée dans le fichier empSave.jsp
return new Employee();
}
@RequestMapping(value = "/emp/save", method = RequestMethod.GET)
public String saveEmployeePage(Model model) {
logger.info("Returning empSave.jsp page");
return "empSave";
}
@RequestMapping(value = "/emp/save.do", method = RequestMethod.POST)
public String saveEmployeeAction(
@ModelAttribute("employee") @Validated Employee employee,
BindingResult bindingResult, Model model) {
if (bindingResult.hasErrors()) {
logger.info("Returning empSave.jsp page");
return "empSave";
}
logger.info("Returning empSaveSuccess.jsp page");
model.addAttribute("emp", employee);
emps.put(employee.getId(), employee);
return "empSaveSuccess";
}
}
Pour utiliser un validateur personnalisé, nous devons d’abord l’injecter dans la classe du contrôleur. Nous utilisons l’auto-câblage du bean Spring pour y parvenir en utilisant les annotations @Autowired et @Qualifier. Ensuite, nous devons avoir une méthode qui prendra WebDataBinder comme argument et nous définissons notre validateur personnalisé à utiliser. Cette méthode doit être annotée avec @InitBinder. Utiliser @ModelAttribute est une autre manière d’ajouter notre objet bean au modèle. Le reste du code est similaire à l’implémentation du contrôleur de client.
Bundle de ressources des messages d’erreur de validation de formulaire
Il est temps de consulter notre bundle de ressources où nous avons différents types de messages à utiliser pour les erreurs de validation. Fichier message_en.properties:
#messages d'erreur définis par l'application
id.required=Employee ID is required
name.required=Employee Name is required
role.required=Employee Role is required
negativeValue={0} can't be negative or zero
#messages d'erreur du framework Spring à utiliser lorsque la conversion des données de formulaire en bean échoue
typeMismatch.int={0} Value must be an integer
typeMismatch.java.lang.Integer={0} must be an integer
typeMismatch={0} is of invalid format
#messages d'application pour les annotations, {ValidationClass}.{modelObjectName}.{field}
#le {0} est le nom du champ, les autres champs sont dans l'ordre alphabétique, max puis min
Size.customer.name=Customer {0} should be between {2} and {1} characters long
NotEmpty.customer.email=Email is a required field
NotNull.customer.age=Customer {0} should be in years
#messages de la classe d'annotation générique
Email=Email address is not valid
NotNull=This is a required field
NotEmpty=This is a required field
Past=Date should be Past
#Annotation de validation personnalisée
Phone=Invalid format, valid formats are 1234567890, 123-456-7890 x1234
I have provided message key details in the comment itself, so I will skip them here. The only important point to note here is the way messages will be looked up, first key name {ValidationClass}.{modelObjectName}.{field} is looked up and if that is not found then {ValidationClass}.{modelObjectName} is looked up. If that is missing, then finally {ValidationClass} key is looked up. If nothing is found then the default message provided will be returned. Read more about resource messages at Spring Localization Example.
Pages de visualisation avec formulaire et erreurs
Étant donné que nous utilisons l’implémentation de validation du framework Spring, nous devrons utiliser les balises de formulaire Spring pour obtenir les erreurs et définir les noms de bean et de variable du formulaire. Le code de notre fichier custSave.jsp est donné ci-dessous.
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="https://www.springframework.org/tags/form"
prefix="springForm"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Customer Save Page</title>
<style>
.error {
color: #ff0000;
font-style: italic;
font-weight: bold;
}
</style>
</head>
<body>
<springForm:form method="POST" commandName="customer"
action="save.do">
<table>
<tr>
<td>Name:</td>
<td><springForm:input path="name" /></td>
<td><springForm:errors path="name" cssClass="error" /></td>
</tr>
<tr>
<td>Email:</td>
<td><springForm:input path="email" /></td>
<td><springForm:errors path="email" cssClass="error" /></td>
</tr>
<tr>
<td>Age:</td>
<td><springForm:input path="age" /></td>
<td><springForm:errors path="age" cssClass="error" /></td>
</tr>
<tr>
<td>Gender:</td>
<td><springForm:select path="gender">
<springForm:option value="" label="Select Gender" />
<springForm:option value="MALE" label="Male" />
<springForm:option value="FEMALE" label="Female" />
</springForm:select></td>
<td><springForm:errors path="gender" cssClass="error" /></td>
</tr>
<tr>
<td>Birthday:</td>
<td><springForm:input path="birthday" placeholder="MM/dd/yyyy"/></td>
<td><springForm:errors path="birthday" cssClass="error" /></td>
</tr>
<tr>
<td>Phone:</td>
<td><springForm:input path="phone" /></td>
<td><springForm:errors path="phone" cssClass="error" /></td>
</tr>
<tr>
<td colspan="3"><input type="submit" value="Save Customer"></td>
</tr>
</table>
</springForm:form>
</body>
</html>
commandName="customer" est utilisé pour définir le nom de l’attribut du modèle sous lequel l’objet de formulaire est exposé. Sa valeur par défaut est « command », donc nous devrions le définir sur le nom de l’attribut du modèle que nous utilisons dans nos classes de contrôleur. springForm:errors est utilisé pour afficher les erreurs, le cas échéant, trouvées lors du rendu de la page. L’attribut path est utilisé pour définir la propriété de l’objet à utiliser pour la liaison de données. Le reste du code est du HTML standard avec un peu de CSS pour le style des messages d’erreur. Notre fichier custSaveSuccess.jsp est donné ci-dessous.
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib prefix="fmt" uri="https://java.sun.com/jsp/jstl/fmt" %>
<%@ page session="false" %>
<html>
<head>
<title>Customer Saved Successfully</title>
</head>
<body>
<h3>
Customer Saved Successfully.
</h3>
<strong>Customer Name:${customer.name}</strong><br>
<strong>Customer Email:${customer.email}</strong><br>
<strong>Customer Age:${customer.age}</strong><br>
<strong>Customer Gender:${customer.gender}</strong><br>
<strong>Customer Birthday:<fmt:formatDate value="${customer.birthday}" type="date" /></strong><br>
</body>
</html>
Page JSP simple montrant les valeurs du client s’il n’y a pas d’erreurs de validation et cette page est renvoyée en réponse. Son nom est empSave.jsp.
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="https://www.springframework.org/tags/form"
prefix="springForm"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Employee Save Page</title>
<style>
.error {
color: #ff0000;
font-style: italic;
font-weight: bold;
}
</style>
</head>
<body>
<springForm:form method="POST" commandName="employee"
action="save.do">
<table>
<tr>
<td>Employee ID:</td>
<td><springForm:input path="id" /></td>
<td><springForm:errors path="id" cssClass="error" /></td>
</tr>
<tr>
<td>Employee Name:</td>
<td><springForm:input path="name" /></td>
<td><springForm:errors path="name" cssClass="error" /></td>
</tr>
<tr>
<td>Employee Role:</td>
<td><springForm:select path="role">
<springForm:option value="" label="Select Role" />
<springForm:option value="ceo" label="CEO" />
<springForm:option value="developer" label="Developer" />
<springForm:option value="manager" label="Manager" />
</springForm:select></td>
<td><springForm:errors path="role" cssClass="error" /></td>
</tr>
<tr>
<td colspan="3"><input type="submit" value="Save"></td>
</tr>
</table>
</springForm:form>
</body>
</html>
Le fichier empSaveSuccess.jsp:
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<title>Employee Saved Successfully</title>
</head>
<body>
<h3>
Employee Saved Successfully.
</h3>
<strong>Employee ID:${emp.id}</strong><br>
<strong>Employee Name:${emp.name}</strong><br>
<strong>Employee Role:${emp.role}</strong><br>
</body>
</html>
Testez l’application de validation de formulaire Spring MVC
Notre application est prête à être déployée et à exécuter quelques tests, déployez-la dans votre conteneur de servlet préféré. J’utilise Apache Tomcat 7 et les images ci-dessous montrent certaines des pages avec des messages d’erreur de validation. En fonction de vos données d’entrée, vous pourriez également obtenir différents messages d’erreur. 
C’est tout pour la validation de formulaire Spring MVC avec différentes méthodes et en utilisant des bundles de ressources pour les messages d’erreur localisés. Vous pouvez télécharger le projet d’exemple à partir du lien ci-dessous et jouer avec pour en savoir plus.
Source:
https://www.digitalocean.com/community/tutorials/spring-validation-example-mvc-validator