Spring MVC - Number Validation

The Spring Web model-view-controller (MVC) is an open-source framework used to build J2EE web applications. It is based on the Model-View-Controller design pattern and implements the basic features of a core spring framework - Dependency Injection. It is designed around a 'DispatcherServlet' that dispatches requests to handlers, with configurable handler mappings, view resolution, locale, and theme resolution as well as support for uploading files. The Spring Framework supports Bean validation using standard validation annotations.

Spring Application

In this example, we will build a simple Spring MVC application in Spring Tool Suite(STS) that takes user input and validates the input with numbers by using standard validation annotations. Also, how to display the error message on the screen so that the user can re-enter input to make it be valid.  As we are validating the bean properties using standard annotations, we need to include some additional dependencies also in the 'pom.xml' file namely, validation-api and hibernate-validator.

validation-api: 

It contains all the Bean Validation provided constraints also called built-in constraints under the package,  javax.validation.constraints. Below are some of the annotation types provided in this package.

To use these annotations, we need to add the below dependency in the 'pom.xml' file.

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.1.0.Final</version>
</dependency>

hibernate-validator:

It contains all the Hibernate validator-specific constraints for bean validation under the package, org.hibernate.validator.constraints. Below are some of the annotation types provided in this package.

To use these annotations, we need to add the below dependency in the 'pom.xml' file.

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>5.2.4.Final</version>
</dependency>

Steps to create the application

1) Create a Spring MVC project in Spring Tool Suite.

2) In STS while creating the project based on the developer selection, it will download all the required maven dependencies, *.jar, lib files and it will provide an embedded server.

3) We can see all the dependencies that are required are available in the 'pom.xml' file.

4) Create a Bean class, Controller class and the JSP view pages.

5) Below is the final project structure of the Spring MVC project after creating *.java and *.jsp files.

Implementation

Files to be created are as follows:

1. Info.java - Bean class - To define the field properties and getter/setter methods of the properties.
2. InfoController.java - Controller class - To process the user request and generate the output.
3. info.jsp - JSP file to interact with the user for the input.
4. summary.jsp - JSP file to display the output to the user after processing the input.

1) Info.java file:

package com.geeksforgeeks.app;

import java.util.Date;

import javax.validation.constraints.Digits;
import javax.validation.constraints.Past;

import org.hibernate.validator.constraints.CreditCardNumber;
import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.format.annotation.DateTimeFormat;

public class Info {
    
    @NotEmpty(message = "Enter your name.")
    private String name;
    @DateTimeFormat(pattern = "dd/MM/yyyy")
    @Past(message = "Enter valid date.")
    private Date birthDate;
    @Digits(message="Number should contain 10 digits.", fraction = 0, integer = 10)
    private String phNum;
    @Email(message="Enter valid Email Id.")
    private String email;
    @CreditCardNumber(message="Enter valid card number.")
    private String card;
    
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getCard() {
        return card;
    }
    public void setCard(String card) {
        this.card = card;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthDate() {
        return birthDate;
    }
    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }
    public String getPhNum() {
        return phNum;
    }
    public void setPhNum(String phNum) {
        this.phNum = phNum;
    }
    
}

The 'Info' class has five attributes: name, birthDate, phNum, card and email. These are flagged with a few standard validation annotations:

• @NotEmpty: The element 'name' value should not be empty.
• @Past: The element 'birthDate' value should be the date in past.
• @Digits(fraction=0, integer=10): The element 'phNum' value should contains 10 digits.
• @Email: The element 'email' value should be in proper email format.
• @CreditCardNumber: The element 'card' value should be a valid card number.
• @DateTimeFormat(pattern="dd/MM/yyyy"): The element 'birthDate' value will be in specified pattern where 'dd' represents 'Date', 'MM' represents 'Month' and 'yyyy' represents the 'Year'.

If any of the above validation fails, it displays the message we specified along with the annotation type. In addition to those, we also need to add getters and setters for all the properties to get and set the values. To use the '@DateTimeFormat' annotation, we need to include the below dependency in the 'pom.xml' file.

<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.10.10</version>
</dependency>

2) InfoController.java file:

package com.geeksforgeeks.app;

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;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class InfoController {
    
    @RequestMapping(value = "/")
    public String viewPage(Model model) {

        Info info = new Info();
        model.addAttribute("info", info);
        return "info";
    }

    @RequestMapping(value = "/submit", method = RequestMethod.POST)
    public String submit(@Valid @ModelAttribute("info") Info info, BindingResult result) {
        if (result.hasErrors()) {
            return "info";
        }
        else {
            return "summary";
        }
    }

}

This controller has a GET method mapped to '/' and a POST method mapped to '/submit'.

Annotations used:

• @Controller conveys to the container that this class is the spring controller class. To use this annotation we need to import org.springframework.stereotype.Controller package.
• @RequestMapping, maps the request URLs to the specified method based on the value provided. To use this annotation, we need to import org.springframework.web.bind.annotation.RequestMapping package.
• @ModelAttribute, used to bind a method parameter or method return value to the named model attribute. We need to import org.springframework.web.bind.annotation.ModelAttribute package.
• @Valid, used to mark a property, method parameter, or method return type for validation cascading.

The 'viewPage' method returns the 'info' form template. It includes the 'info' model attribute so that the template can associate form attributes with an 'Info' object. The 'submit' method accepts two arguments: A 'info' object marked with @Valid to gather the attributes filled out in the form and a bindingResult object so that we can test for and retrieve validation errors. In the code, we are checking the 'result', if we encounter an error, we send the user back to the original form template. In that situation, all the error attributes are displayed with the message. If all of the attributes are valid, it redirects the browser to the summary page.

3) info.jsp file:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Welcome Page</title>
</head>
<body>

    <h2>Welcome to GeeksforGeeks!!</h2>
    <h3>Please fill in the form</h3>
    <form:form action="submit" method="post" modelAttribute="info">
        <table>
            <tr>
                <td><form:label path="name">Full Name: </form:label></td>
                <td><form:input path="name" />
                <form:errors path="name" cssStyle="color:red"/></td>
            </tr>
            <tr>
                <td><form:label path="birthDate">Date of Birth: </form:label></td>
                <td><form:input path="birthDate" />
                <form:errors path="birthDate" cssStyle="color:red"/></td>
            </tr>
            <tr>
                <td><form:label path="phNum">Phone Number: </form:label></td>
                <td><form:input path="phNum" />
                <form:errors path="phNum" cssStyle="color:red"/></td>
            </tr>
            <tr>
                <td><form:label path="email">Email Id: </form:label></td>
                <td><form:input path="email" />
                <form:errors path="email" cssStyle="color:red"/></td>
            </tr>
            <tr>
                <td><form:label path="card">Card Number: </form:label></td>
                <td><form:input path="card" />
                <form:errors path="card" cssStyle="color:red"/></td>
            </tr>
            <tr>
                <td><form:button>Submit</form:button></td>
            </tr>
        </table>
    </form:form>

</body>
</html>

The page contains a simple form, with each of its fields in a separate cell in a table. The form is geared to post to '/submit'. It is marked as being backed up by the 'info' model attribute and to the 'POST' method - 'submit' in the web controller. We are using Spring form's tag library to display the label names, input fields, and error tags. These error tags are next to each field is a secondary element that is used to show any validation errors. Finally, we have a button that submits the form. If the user enters any invalid input that violates the @Valid constraints, it bounces back to this page with the error message displayed. If all the user inputs are valid, then the user is routed to the next web page which is 'summary'.

4) summary.jsp file:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Summary page</title>
</head>
<body>

    <h3>Details submitted!</h3>

    <table>
        <tr>
            <td>Name:</td>
            <td>${info.name}</td>
        </tr>
        <tr>
            <td>Date of Birth:</td>
            <td>${info.birthDate}</td>
        </tr>
        <tr>
            <td>Phone Number:</td>
            <td>${info.phNum}</td>
        </tr>
        <tr>
            <td>Email:</td>
            <td>${info.email}</td>
        </tr>
        <tr>
            <td>Card Number:</td>
            <td>${info.card}</td>
        </tr>
    </table>

</body>
</html>

This is the result JSP page to display the user entered values in the browser after the processing of the input. Each field will be displayed in a separate cell in a table.

Run the Application:

• Right-click on the Project, Run as -> Run on Server.
• Select the server in the localhost to run the application.
• Open the URL: http://localhost:8080/app/ in the browser to get the below screen.

• If we enter the invalid inputs, it will display the same page with the error information like below,

• As we are providing the invalid inputs, the form got submitted but it violated the @Valid constraint and so it bounced back to the same page with the respective error messages we specified in the bean class.
• Now, enter the valid inputs to process the form successfully.

• Click on submit to get the output.

Conclusion

This way, we can build the Spring MVC web applications with validation built in the domain object using standard validation annotation based on our requirement. Spring also provides a 'Validator' interface to provide our own custom validation to the form beans.