Spring MVC – Validación de número

Spring Web model-view-controller (MVC) es un marco de código abierto que se utiliza para crear aplicaciones web J2EE. Se basa en el patrón de diseño Modelo-Vista-Controlador e implementa las características básicas de un marco de resorte central: Inyección de dependencia. Está diseñado en torno a un ‘DispatcherServlet’ que envía requests a los controladores, con asignaciones de controladores configurables, resolución de vista, configuración regional y resolución de temas, así como soporte para cargar archivos. Spring Framework admite la validación de Bean utilizando anotaciones de validación estándar.

Aplicación de primavera

En este ejemplo, crearemos una aplicación Spring MVC simple en Spring Tool Suite (STS) que toma la entrada del usuario y valida la entrada con números mediante el uso de anotaciones de validación estándar. Además, cómo mostrar el mensaje de error en la pantalla para que el usuario pueda volver a ingresar la entrada para que sea válida. Como estamos validando las propiedades del bean usando anotaciones estándar, también necesitamos incluir algunas dependencias adicionales en el archivo ‘pom.xml’, a saber, validation-api e hibernate-validator .

validación-api: 

Contiene todas las restricciones proporcionadas por Bean Validation, también llamadas restricciones integradas en el paquete,  javax.validation.constraints. A continuación se muestran algunos de los tipos de anotaciones proporcionados en este paquete.

Para usar estas anotaciones, debemos agregar la dependencia a continuación en el archivo ‘pom.xml’.

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

hibernate-validador:

Contiene todas las restricciones específicas del validador de Hibernate para la validación de beans en el paquete, org.hibernate.validator.constraints. A continuación se muestran algunos de los tipos de anotaciones proporcionados en este paquete.

Para usar estas anotaciones, debemos agregar la dependencia a continuación en el archivo ‘pom.xml’.

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

Pasos para crear la aplicación

1) Cree un proyecto Spring MVC en Spring Tool Suite.

2) En STS, al crear el proyecto basado en la selección del desarrollador, descargará todas las dependencias maven requeridas, *.jar, archivos lib y proporcionará un servidor integrado.

3) Podemos ver que todas las dependencias que se requieren están disponibles en el archivo ‘pom.xml’.

4) Cree una clase de Bean, una clase de Controlador y las páginas de vista JSP.

5) A continuación se muestra la estructura final del proyecto Spring MVC después de crear los archivos *.java y *.jsp.

Estructura del proyecto

Implementación

Los archivos a crear son los siguientes:

1. Info.java – Clase Bean – Para definir las propiedades del campo y los métodos getter/setter de las propiedades.
2. InfoController.java – Clase de controlador – Para procesar la solicitud del usuario y generar la salida.
3. info.jsp : archivo JSP para interactuar con el usuario para la entrada.
4. summary.jsp : archivo JSP para mostrar la salida al usuario después de procesar la entrada.

1) archivo Info.java:

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;
    }
      
}

La clase ‘ Info ‘ tiene cinco atributos: nombre, fecha de nacimiento, phNum, tarjeta y correo electrónico. Estos están marcados con algunas anotaciones de validación estándar:

• @NotEmpty: el valor del elemento ‘nombre’ no debe estar vacío.
• @Past: el valor del elemento ‘birthDate’ debe ser la fecha en el pasado.
• @Digits(fraction=0, integer=10): El valor del elemento ‘phNum’ debe contener 10 dígitos.
• @Correo electrónico: el valor del elemento ‘correo electrónico’ debe tener el formato de correo electrónico adecuado.
• @CreditCardNumber: El valor del elemento ‘tarjeta’ debe ser un número de tarjeta válido.
• @DateTimeFormat(pattern=”dd/MM/yyyy”): El valor del elemento ‘birthDate’ estará en el patrón especificado donde ‘dd’ representa ‘Fecha’, ‘MM’ representa ‘Mes’ y ‘yyyy’ representa el ‘Año’ .

Si alguna de las validaciones anteriores falla, muestra el mensaje que especificamos junto con el tipo de anotación. Además de eso, también necesitamos agregar getters y setters para todas las propiedades para obtener y establecer los valores. Para usar la anotación ‘@DateTimeFormat’, debemos incluir la siguiente dependencia en el archivo ‘pom.xml’.

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

2) Archivo InfoController.java:

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";
        }
    }
  
}

Este controlador tiene un método GET asignado a ‘/’ y un método POST asignado a ‘/submit’.

Anotaciones utilizadas:

• @Controller transmite al contenedor que esta clase es la clase de controlador de resorte. Para usar esta anotación, necesitamos importar el paquete org.springframework.stereotype.Controller.
• @RequestMapping, asigna las URL de solicitud al método especificado en función del valor proporcionado. Para usar esta anotación, debemos importar el paquete org.springframework.web.bind.annotation.RequestMapping.
• @ModelAttribute, que se usa para vincular un parámetro de método o un valor de retorno de método al atributo del modelo nombrado. Necesitamos importar el paquete org.springframework.web.bind.annotation.ModelAttribute.
• @Valid, utilizado para marcar una propiedad, un parámetro de método o un tipo de retorno de método para la validación en cascada.

El método ‘viewPage’ devuelve la plantilla de formulario ‘info’. Incluye el atributo de modelo ‘info’ para que la plantilla pueda asociar atributos de formulario con un objeto ‘Info’. El método ‘enviar’ acepta dos argumentos: un objeto ‘info’ marcado con @Valid para recopilar los atributos completados en el formulario y un objeto bindingResult para que podamos probar y recuperar errores de validación. En el código, estamos comprobando el ‘resultado’, si encontramos un error, enviamos al usuario de vuelta a la plantilla de formulario original. En esa situación, todos los atributos de error se muestran con el mensaje. Si todos los atributos son válidos, redirige el navegador a la página de resumen.

3) archivo info.jsp:

<%@ 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>

La página contiene un formulario simple, con cada uno de sus campos en una celda separada en una tabla. El formulario está diseñado para publicar en ‘/submit’. Está marcado como respaldado por el atributo de modelo ‘info’ y el método ‘POST’ – ‘enviar’ en el controlador web. Estamos utilizando la biblioteca de etiquetas de Spring Form para mostrar los nombres de las etiquetas, los campos de entrada y las etiquetas de error. Estas etiquetas de error están al lado de cada campo, es un elemento secundario que se usa para mostrar cualquier error de validación. Finalmente, tenemos un botón que envía el formulario. Si el usuario ingresa una entrada no válida que viola las restricciones de @Valid, regresa a esta página con el mensaje de error que se muestra. Si todas las entradas del usuario son válidas, se dirige al usuario a la siguiente página web, que es «resumen».

4) archivo resumen.jsp:

<%@ 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>

Esta es la página JSP de resultados para mostrar los valores ingresados ​​por el usuario en el navegador después del procesamiento de la entrada. Cada campo se mostrará en una celda separada en una tabla.

Ejecute la aplicación:

• Haga clic con el botón derecho en el Proyecto, Ejecutar como -> Ejecutar en el servidor.
• Seleccione el servidor en el host local para ejecutar la aplicación.
• Abra la URL: http://localhost:8080/app/ en el navegador para obtener la siguiente pantalla.

Formulario de Bienvenida

• Si ingresamos las entradas no válidas, se mostrará la misma página con la información de error como se muestra a continuación,

Entradas inválidas

• Como proporcionamos las entradas no válidas, el formulario se envió pero violó la restricción @Valid y, por lo tanto, regresó a la misma página con los mensajes de error respectivos que especificamos en la clase de bean.
• Ahora, ingrese las entradas válidas para procesar el formulario con éxito.

Entradas válidas

• Haga clic en enviar para obtener el resultado.

Producción

Conclusión

De esta forma, podemos crear las aplicaciones web Spring MVC con validación integrada en el objeto de dominio mediante la anotación de validación estándar según nuestros requisitos. Spring también proporciona una interfaz de ‘Validador’ para proporcionar nuestra propia validación personalizada a los beans de formulario.