Spring MVC Validation

Ejemplo de Spring Validation en pocos pasos.
Spring 3 incorpora el soporte para el api de validacion JSR-303 (JSR-303 Bean Validation API).

1-Configurar el Contexto de Spring agregando

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="

http://www.springframework.org/schema/beans


http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/mvc


http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <mvc:annotation-driven/>
   <context:component-scan base-package="mvc" />

   <bean id="viewResolver"
       class="org.springframework.web.servlet.view.UrlBasedViewResolver">
       <property name="viewClass"
           value="org.springframework.web.servlet.view.JstlView" />
       <property name="prefix" value="/WEB-INF/jsp/" />
       <property name="suffix" value=".jsp" />
   </bean>
   <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
       <property name="basename" value="/WEB-INF/messages" />
   </bean>
</beans>

2-Agregar las anotaciones con los constraints que necesitemos en el bean.

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

public class Person {

   @NotNull
   @Size(min = 1, max = 25)
   private String name;

   @NotNull
   @Size(min = 1, max = 25)
   private String surname;

   @Min(value = 1)
   @Max(value = 100)
   private String age;

}

3-Crear el .properties con los mensajes para cada constraints

Size.person.name=Insert a valid name Size 1 to 25
Size.person.surname=Insert a valid surname Size 1 to 25
Min.person.age=Insert a valid age Min 1
Max.person.age=Insert a valid age Max 100

4-Creamos nuestro jsp con el form y agregamos path para mostrar los errores (form:errors path)

<form:form method="post" action="add" commandName="person">

   <form:errors path="*" element="div" />    

   <h3>${message}</h3>
   
   <table>
       <tr>
           <td>
               Name
               <form:input path="name"/><form:errors path="name"/>
           </td>
       </tr>
       <tr>
           <td>
               Surname
               <form:input path="surname"/><form:errors path="surname"/>            
           </td>
       </tr>
       <tr>
           <td>
               Age
               <form:input path="age"/><form:errors path="age"/>            
           </td>
       </tr>
       
   </table>
   
   <input type="submit" value="Submit" />
   
</form:form>    

5-Implementando el Controller anotando con @Valid
Anotamos @Valid el bean que Spring validara según los constraints del bean, en nuestro metodo para el POST


import java.util.ArrayList;
import java.util.List;

import javax.validation.Valid;

import mvc.model.Person;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/person")
public class PersonController {

	// only for demonstration propose
	private final List<Person> listPersons = new ArrayList<Person>();
	
	@RequestMapping(value = { "/list" }, method = RequestMethod.GET)
	public String list(ModelMap modelMap) {
		modelMap.put("persons", listPersons);
		return "personList";
	}

	@RequestMapping(value = { "/new" }, method = RequestMethod.GET)
	public String newPerson(ModelMap modelMap) {
		modelMap.put("person", new Person());
		return "person";
	}

	@RequestMapping(value = { "/add" }, method = RequestMethod.POST)
	public String create(@Valid Person person, BindingResult result, ModelMap modelMap) {
		if (result.hasErrors()) {
                        // hubo errores segun los constraint definidos!
			return "person";
		}
                // ok guardamos..
		listPersons.add(person);
		modelMap.put("message", "Person has been updated");
		return "person";
	}

}

6-Creamos un jsp simple para mostrar una lista con las Personas correctamente insertadas

<h2>List of Persons</h2>
<body>
	<table border="1px" bordercolor="green">
  	<tr>
  		<td>
  			Name
		</td>
		<td>
			Surname
		</td>
		<td>
			Age
		</td>
	</tr>

  	<c:forEach var="person" items="${persons}">
  	<tr>
  		<td>
  			<c:out value="${person.name}"/>
		</td>
		<td>
			<c:out value="${person.surname}"/>
		</td>
		<td>
			<c:out value="${person.age}"/>
		</td>
	</tr>
	</c:forEach>
	</table>
</body>

Probando nuestro Controller con @Valid

1-Iniciamos nuestro form.
Llamamos a nuestro controler “/person/new”

2-Insertamos valores invalidos según nuestros ‘constraint’.
Spring validará y cargará en el BindingResult los errores producidos (ver el metodo create de nuestro Controller).
Los mensajes los buscará en el archivo .propertie donde hemos definido para tipo de Contraint y para nuestro bean.

3-Luego ingresamos correctamente los datos

4-Corroboramos con nuestra lista

Todo OK!

Be Sociable, Share!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

Puedes usar las siguientes etiquetas y atributos HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>