Requisitos previos: Spring MVC , Validación de Spring MVC
Es necesario validar la entrada del usuario en cualquier aplicación web para garantizar el procesamiento de datos válidos. El marco Spring MVC admite el uso de la API de validación . La API de validación impone restricciones a la entrada del usuario mediante anotaciones y puede validar tanto del lado del cliente como del lado del servidor. Proporciona validadores estándar predefinidos como @Min , @Max , @Size , @Pattern y @NotNull . En caso de que tengamos que procesar un resorte de entrada más específico, MVC también proporciona el concepto de validadores definidos por el usuario con lógica de validación personalizada. En este artículo, crearemos un validador personalizado para validar la dirección de un estudiante en un portal de estudiantes.
Pasos para crear un formulario de Estudiante con validación personalizada
En primer lugar, necesitamos crear un proyecto de aplicación web maven, en este tutorial usaremos Eclipse IDE. Ahora, elija crear maven mientras crea un nuevo proyecto y agregue un arquetipo de aplicación web maven . Ingrese la identificación del grupo y la identificación del artefacto para su proyecto y haga clic en finalizar.
Se crearía un proyecto web maven con un archivo de configuración pom.xml . La estructura del proyecto sería algo así:
Ahora, configuremos el archivo de configuración pom.xml para agregar dependencias. Maven obtendrá y administrará todas las dependencias definidas en este archivo. Deberá agregar todas estas dependencias para poder usar los métodos. La dependencia hibernate-validator permite expresar y validar las restricciones de la aplicación.
XML
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.gfg</groupId> <artifactId>SpringMvcStudentValidation</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>war</packaging> <name>SpringMvcStudentValidation Maven Webapp</name> <!-- FIXME change it to the project's website --> <url>http://www.example.com</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.7</maven.compiler.source> <maven.compiler.target>1.7</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.1.RELEASE</version> </dependency> <!-- https://mvnrepository.com/artifact/org.apache.tomcat/tomcat-jasper --> <dependency> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jasper</artifactId> <version>9.0.12</version> </dependency> <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api --> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>3.0-alpha-1</version> </dependency> <!-- https://mvnrepository.com/artifact/javax.servlet/jstl --> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> <!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator --> <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> <version>6.0.13.Final</version> </dependency> </dependencies> <build> <finalName>SpringMvcStudentValidation</finalName> <pluginManagement> <plugins> <plugin> <artifactId>maven-clean-plugin</artifactId> <version>3.1.0</version> </plugin> <plugin> <artifactId>maven-resources-plugin</artifactId> <version>3.0.2</version> </plugin> <plugin> <artifactId>maven-surefire-plugin</artifactId> <version>2.22.1</version> </plugin> <plugin> <artifactId>maven-war-plugin</artifactId> <version>3.2.2</version> </plugin> <plugin> <artifactId>maven-install-plugin</artifactId> <version>2.5.2</version> </plugin> <plugin> <artifactId>maven-deploy-plugin</artifactId> <version>2.8.2</version> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.2</version> <configuration> <verbose>true</verbose> <source>1.8</source> <target>1.8</target> <showWarnings>true</showWarnings> </configuration> </plugin> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <path>/</path> <contextReloadable>true</contextReloadable> </configuration> </plugin> </plugins> </pluginManagement> </build> </project>
El archivo web.xml en » webapp/WEB-INF/web.xml » define el mapeo con diferentes URL y servlets para manejar las requests de esas URL. En esto, hemos definido que el archivo XML del servlet se llamará gfg. El patrón de URL se establece como «/», lo que significa que cualquier solicitud con «/» se enviará al servlet del despachador para que la maneje.
XML
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <display-name>To do List</display-name> <welcome-file-list> <welcome-file>login.do</welcome-file> </welcome-file-list> <servlet> <servlet-name>gfg</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/gfg-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>gfg</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
El archivo gfg-servlet.xml se encuentra en » /src/main/webapp/WEB-INF/gfg.servlet.xml «. Este archivo lleva el nombre del nombre de servlet que hemos mencionado en el archivo web.xml, maneja todas las requests HTTP para las aplicaciones web. Las clases basadas en anotaciones habilitan las clases de anotaciones de primavera. La configuración del bean ayuda a identificar y escanear el jsp ubicado en la carpeta de vistas. El análisis de componentes localiza y asigna beans de acuerdo con la anotación definida. Es un archivo bastante simple para manejar llamadas HTTP entrantes.
XML
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:component-scan base-package="com.gfg" /> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix"> <value>/WEB-INF/views/</value> </property> <property name="suffix"> <value>.jsp</value> </property> </bean> <mvc:annotation-driven /> </beans>
Ahora, crearemos una clase de estudiante en el paquete com.gfg.model , para nuestro portal de estudiantes mostraremos cuatro atributos firstName, lastName, rollNo y address. Los primeros dos campos tienen una anotación de validación de tamaño @ como una restricción de tamaño mínimo como uno, por lo que no pueden estar vacíos. Para el número de rollo, hemos usado @ Min , que también es un validador predefinido. Ahora, para la dirección, hemos usado @ Dirección , que es un validador personalizado que vamos a definir y configurar.
Java
package com.gfg.model;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import com.gfg.validationconfig.Address;
public class Student {
@Size(min = 1, message = "Student first name can't be empty")
private String firstName;
@Size(min = 1, message = "Student last name can't be empty")
private String lastName;
@Min(value = 1000, message = "Roll number must be a four digit number")
private int rollNo;
// custom validation
@Address
private String address;
public Student(@NotNull String firstName, @NotNull String lastName,
@Min(value = 1000, message = "Roll number must be a four digit number")
int rollNo,
@Size(min = 20, message = "Address must contains atleast 20 letters") @Size(max = 40, message = "Address must contains atleast 20 letters")
String address) {
super();
this.firstName = firstName;
this.lastName = lastName;
this.rollNo = rollNo;
this.address = address;
}
public Student() {
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getRollNo() {
return rollNo;
}
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
public String getAddress() {
return this.address;
}
public void setAddress(String address) {
this.address = address;
}
}
La clase de controlador maneja las requests entrantes redirigiéndolas a la página de vista adecuada, cualquier URL debe estar definida en la clase de controlador para poder enviar una solicitud. En este proyecto, hemos definido una clase StudentController en el paquete com.gfg.controller . En esta clase tenemos dos métodos para dos requests, el primero simplemente redirige al portal de inicio de sesión y simplemente agrega un nuevo objeto de estudiante para que coincida con las entradas en el formulario usando el addAttribute del modelo . El segundo método redirige a la página de bienvenida, pero antes de eso, verifica si hay errores de validación usando BindingResult . Si existe un error se redirige al portal de lo contrario a la página de bienvenida.
Java
package com.gfg.controller;
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 com.gfg.model.Student;
@Controller
public class StudentController {
@RequestMapping("/login")
public String showForm(Model theModel) {
theModel.addAttribute("student", new Student());
return "portal";
}
@RequestMapping("/welcome")
public String processForm(@Valid @ModelAttribute("student") Student student, BindingResult result) {
if (result.hasErrors()) {
return "portal";
}
else {
return "welcome";
}
}
}
La clase AddressValidator en el paquete com.gfg.validationcongfig define la restricción para la cual se debe verificar el objeto, esta clase implementa ConstraintValidator que define la lógica para validar una restricción determinada. Anulamos una clase de método isValid desde la interfaz ConstrainValidator, donde definimos nuestra lógica de validación.
Java
package com.gfg.validationconfig;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
public class AddressValidator implements ConstraintValidator<Address, String> {
@Override
public boolean isValid(String s, ConstraintValidatorContext cvc) {
s = s.toLowerCase();
boolean result = s.contains("india");
return result;
}
}
Ahora, creamos una anotación de dirección usando la interfaz @. Esta clase debe tener tres anuladas para que funcione la lógica de validación. El primer método define el mensaje de error que se mostrará, el segundo método representa un grupo de restricciones, el tercer método representa información adicional sobre la anotación. Las anotaciones @Constraint , @ Target y @ Retention definen la lógica de validación, el elemento que se va a pasar e información adicional .
Java
package com.gfg.validationconfig;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
@Constraint(validatedBy = AddressValidator.class)
@Target( { ElementType.METHOD, ElementType.FIELD } )
@Retention(RetentionPolicy.RUNTIME)
public @interface Address {
public String message() default "You address must contains india";
public Class<?>[] groups() default {};
public Class<? extends Payload>[] payload() default {};
}
La página portal.jsp » /webapp/WEB-INF/views/portal.jsp » define el portal de inicio de sesión del estudiante. Hemos utilizado la configuración del formulario para formatear nuestro formulario. Este es un formulario bastante simple que define cuatro campos.
HTML
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<html>
<head>
<style>
.error {color:red}
</style>
</head>
<body>
<h1>Student Portal</h1>
<form:form action="welcome" modelAttribute="student">
<label>First name:</label>
<form:input path="firstName" />
<form:errors path="firstName" cssClass="error" /><br><br>
<label>Last name:</label>
<form:input path="lastName" />
<form:errors path="lastName" cssClass="error" /><br><br>
<label>Roll No:</label>
<form:input path="rollNo" />
<form:errors path="rollNo" cssClass="error" /><br><br>
<label>Address:</label>
<form:textarea path="address" />
<form:errors path="address" cssClass="error" /><br><br>
<input type="submit" value="Submit" />
</form:form>
</body>
</html>
La página welcome.jsp en “ /webapp/WEB-INF/views/welcome.jsp ” es la página de vista que se muestra después de un inicio de sesión exitoso.
HTML
<%-- <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
--%>
<!DOCTYPE html>
<html>
<body>
<div>
<h2>Welcome ${student.firstName} ${student.lastName} to Student portal<br><br>
Your Roll Number is ${student.rollNo} and you live in india.</h2>
</div>
</body>
</html>
Ahora que nuestro proyecto Spring MVC se ha completado con todos los archivos y clases de configuración. La estructura de su proyecto debería verse así:
Estructura del proyecto
Producción:
Es hora de ejecutar su aplicación web en el servidor tomcat. Supongo que sabe cómo ejecutar un servidor tomcat. Después de ejecutar con éxito el servidor tomcat, ingrese http://localhost:8080/SpringMvcStudentValidation/welcome en su navegador favorito.
Entonces, creamos un proyecto Spring MVC con nuestra propia validación y lo usamos en un formulario de portal para estudiantes.
Publicación traducida automáticamente
Artículo escrito por ashutosh44 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA