Spring MVC Form Validation

Spring Validation is used to validate the @Controller inputs. It is used to check and accept the user input in any web application. Using Spring validation, we can validate the user input on the server-side.

Bean Validation API

From Spring framework version 4 and above, the Spring framework supports Bean Validation 1.0 (JSR-303) and Bean Validation 1.1 (JSR-349).

Below is given an annotation used for validation:

@Valid – The @Valid annotation is used to annotate a method parameter, property, or method return type for validation. It is used to annotate a model object that we want to validate.

BindingResult – It is an interface that represents the binding results. It extends an interface for error registration, allowing a validator to be applied, and adds binding-specific analysis.

Validation Annotations

A variety of annotations are used in Spring MVC form Validation, which is available in javax.validation.constraints package.

Following is the list of commonly used Validation annotations:

Annotations	Description
@Size	It specifies that the size of the annotated element must be between the specified boundaries.
@Pattern	It specifies that the annotated CharSequence must match the regular expression.
@Past	It specifies that the annotated element must be a date in the past.
@Null	It specifies that the annotated element must be null.
@NotNull	It specifies that the annotated element should not be null.
@Min	It specifies that the annotated element must be a number whose value must be equal or greater than the specified minimum number.
@Max	It specifies that the annotated element must be a number whose value must be equal or smaller than the specified maximum.
@Future	It specifies that the annotated element must be a date in the future.
@Digits	It specifies that the annotated element must be a digit or number within the specified range. The supported types are short, int, long, byte, etc.
@DecimalMin	It specifies that the annotated element must be a number whose value must be equal or greater than the specified minimum. It is very similar to @Min annotation, but theonly difference is it supports CharSequence type.
@DecimalMax	It specifies that the annotated element must be a number whose value should be equal or smaller than the specified maximum. It is very similar to @Max annotation, but the only difference is it supports CharSequence type.
@AssertTrue	It determines that the annotated element must be true.
@AssertFalse	It determines that the annotated element must be false.

Example of Spring MVC Validation

Here, we are going to create an example of Spring MVC Validation using @Valid annotation in the Controller class.

Following are the steps to create an example of Spring Validator:

• Create a request page

In this step, we are going to create a request page named index.jsp.

index.jsp

 <html>
 <body>
 <h2> Spring MVC Web application </h2>
 <a href = "cust-regis-form"> Customer Registration Form </a>
 </body>
 </html> 

• Create a Model class

In this step, we are going to create a Model class named Customer.java, which stores the data. In the Customer class, we are going to use the @NotNull and @Size annotations on the “lname” variable. 

Customer.java

 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.Size;
 public class Customer {
                 private String fname;
                 @NotNull
                 @Size(min = 3, message = " This field is required ")
                 private String lname;
                 public String getFname() {
                                 return fname;
                 }
                 public void setFname(String fname) {
                                 this.fname = fname;
                 }
                 public String getLname() {
                                 return lname;
                 }
                 public void setLname(String lname) {
                                 this.lname = lname;
                 }
  } 

• Create the Controller

In this step, we are going to create the Controller named MainController.java, which returns the JSP view pages. In the Controller class, we are going to use the @Valid annotation and BindingResult for validation.

MainController.java

 import javax.validation.Valid;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.validation.BindingResult;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.bind.annotation.RequestMapping;
 @Controller
 public class MainController {
                 @RequestMapping("/cust-regis-form")
                 public String showCustomerForm(Model m) {
                                 m.addAttribute("customer", new Customer()) ;
                                 return "customerform" ;
                 }
                 @RequestMapping("/processForm")
                 public String showCustomerData( @Valid @ModelAttribute("customer") Customer custom,
                                                 BindingResult thebindingresult) {
                                 if (thebindingresult.hasErrors()) {
                                                 return "customerform" ;
                                 }
                                 else {
                                                 return "customerformdata" ;
                                 }
     }
  } 

• Add the entry of controller into web.xml

In this step, we are going to add the entry of the Controller inside the web.xml file.

web.xml

 <?xml version = "1.0" encoding = "UTF-8"?>
 <web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
                 xmlns = "http://xmlns.jcp.org/xml/ns/javaee"
                 xsi:schemaLocation = "http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
                 id = "WebApp_ID" version = "3.1">
                 <display-name>spring-mvc-demo</display-name>
                 <absolute-ordering />
                 <!-- Spring MVC Configs -->
                 <!-- Step 1: Configure Spring MVC Dispatcher Servlet -->
                 <servlet>
                                 <servlet-name>dispatcher</servlet-name>
                                 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
                                 <init-param>
                                                 <param-name>contextConfigLocation</param-name>
                                                 <param-value>/WEB-INF/spring-servlet.xml</param-value>
                                 </init-param>
                                 <load-on-startup>1</load-on-startup>
                 </servlet>
                 <!-- Step 2: Set up URL mapping for Spring MVC Dispatcher Servlet -->
                 <servlet-mapping>
                                 <servlet-name>dispatcher</servlet-name>
                                 <url-pattern>/</url-pattern>
                 </servlet-mapping>
 </web-app> 

• Add the entry of Model into another XML file

In this step, we are going to define the Model/ bean into another XML file named spring-servlet.xml.

spring-servlet.xml

  <?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:context = "http://www.springframework.org/schema/context"
                 xmlns:mvc = "http://www.springframework.org/schema/mvc"
                 xsi:schemaLocation = "  http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
 http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc.xsd">
                 <!-- Step 3: Add support for component scanning -->
                 <context:component-scan base-package = "com.app.SpringMVCValidation"  />
                 <!-- Step 4: Add support for conversion, formatting and validation support -->
                 <mvc:annotation-driven/>
                 <!-- Step 5: Define Spring MVC view resolver -->
                 <bean
                                 class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                                 <property name = "prefix" value = "/WEB-INF/view/" />
                                 <property name = "suffix" value = ".jsp" />
                 </bean>
 </beans> 

• Create other JSP pages

In this step, we are going to create the other view pages (JSP pages).

customerform.jsp

 <%@ taglib prefix = "form" uri = "http://www.springframework.org/tags/form" %>
 <!DOCTYPE html>
 <html>
 <head>
 <meta charset = "ISO-8859-1">
 <title> Customer Form </title>
   <style>
        .error {color:red}
    </style>
 </head>
 <body>
 <h3><i>The field with Asterisk(*) mark is required.</i></h3>
 <form:form action = "processForm" modelAttribute = "customer" >
 FIRST NAME: <form:input path = "fname" />
 <br></br>
 LAST NAME (*): <form:input path = "lname" />
   <form:errors path = "lname" cssClass = "error" >
   </form:errors>
 <br></br>
 <input type = "submit" value = "Submit" />
  </form:form>
 </body>
 </html> 

customerformdata.jsp

 <%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
 <!DOCTYPE html>
 <html>
 <head>
 <title>Customer data</title>
 </head>
 <body>
 The customer is confirmed: ${customer.fname} ${customer.lname}
 </body>
 </html> 

Output

Whitespaces problem with required Validator

If we pass whitespaces in the required Validator field, the String containing only whitespaces will pass the Validation. For example, we have created the LAST NAME as the required field, and if we enter whitespaces in that field, it will pass the Validation.

Following output shows the whitespaces problem:

To overcome the discussed problem, we are going to use the @InitBinder annotation inside the Controller. The @InitBinder works as a pre-processor and used to trim the whitespaces before the Strings.

Spring MVC @InitBinder

The @InitBinder annotation is used to initialize the WebDataBinder, which is used for spreading commands and form object arguments of annotated handler methods.

For accessing the @InitBinder annotation, we need to write the given code snippet in the Controller named MainController.java class.

MainController.java

 @InitBinder
 public void initBinder(WebDataBinder dataBinder)  {
                 StringTrimmerEditor stringEditor = new StringTrimmerEditor(true);
                 dataBinder.registerCustomEditor(String.class,stringEditor ); 
}

 After using the @InitBinder, the problem of whitespaces is removed from the application, as only whitespaces in the text field didn’t pass the validation, shown in the output.