SpringMVC——类型转换和格式化、数据校验、客户端显示错误消息

时间：2016-08-29 12:38:43 阅读：609 评论：0 收藏：0 [点我收藏+]

标签：

在介绍类型转换和格式化之前，我首先来介绍 <mvc:annotation-driven />。

需要导入的 schema：

xmlns:mvc="http://www.springframework.org/schema/mvc"

一、作用：

1.会自动注册 RequestMappingHandlerMapping、RequestMappingHandlerAdapter 以及 ExceptionHandlerExceptionResolver 三个 Bean。

若配置该注解后，对于一般的 springmvc 请求来说，不再使用未配置之前的过期的 AnnotationHandlerMapping 和 AnnotationMethodHandlerAdapter。

而是使用 RequestMappingHandlerMapping、RequestMappingHandlerAdatapter，作为对 AnnotationHandlerMapping 和 AnnotationHandlerAdapter 的一种替代。。

所以 DispatcherServlet 中的 HandlerAdapter 的 handler() 方法发生了改变，相当于一套新的逻辑。

清晰内容，请参见：

AnnotationMethodHandlerAdapter 下的 springmvc 运行流程分析。

RequestMappingHandlerAdapter 下的 springmvc 运行流程分析。

2. 支持使用 ConversionService 实例对表单参数进行类型转换。详细内容请参见：类型转换和格式化

3.支持使用 @Valid 对 java bean 进行 JSR-303 校验。详细内容请参见：数据校验

4.支持使用 @RequestBody 和 @ResponseBody 注解。详细内容请参见：springmvc 对 Ajax 的支持。

二、详细分析

添加 <mvc:annotation-driven /> 配置后：

默认情况下：

HandlerMapping 注册了 RequestMappingHandlerMapping 和 BeanNameUrlHandlerMapping。

HandlerAdapter 注册了 RequestMappingHandlerAdapter 和 HttpReqestHandlerAdapter 和 SimpleControllerHandlerAdapter。

org.springframework.beans.factory.xml.BeanDefinitionParser 用来解析 <beans/> 标签的。

<mvc:annotation-driven /> 属于 <beans/> 的子节点，由 org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser进行解析。

这个类注册了下面两个 HandlerMapping:RequestMappingHandlerMapping 和 BeanNameUrlHandlerMapping。

此外，也可以通过 <mvc:resources mapping="" location=""/>或 <mvc:view-controller path=""/> 来指定需要被注册的 HandlerMapping。

同时注册了三个 HandlerAdatper:RequestMappingHandlerAdapter,HttpRequestHandlerAdapter,SimpleControllerHandlerAdapter。

同时注册了三个 HandlerExceptionResolver：ExceptionHandlerExceptionResolver，ResponseStatusExceptionResolver和DefaultHandlerExceptionResolver。

RequestMappingHandlerAdapter 和 ExceptionHandlerExceptionResolver 作为一个默认的配置，由下列实例指定：

ContentNegotiationManager

DefaultFormattingConversionService

LocalValidatorFactoryBean——支持 JSR303

HttpMessageConverter

并在 org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser#parse 这里进行的注册。

并且发现 RequestMappingHandlerMapping 的 order 为 0，BeanNameUrlHandlerMapping 的 order 为2。所以请求先去映射 RequestMappingHandlerMapping。

上面介绍了 <mvc:annotation-driven /> 。下面介绍类型转换和格式化、数据校验。

一、在介绍每个模块之前，首先对整体流程有个清晰的认识。

SpringMVC 通过反射机制对目标方法的签名进行分析，将请求消息绑定到处理方法入参中。

SpringMVC 将 ServletReqeust 对象以及处理方法入参对象实例传递给 DataBinder，DataBinder 调用装配在 springmvc 上下文的 ConversionService 进行类型转换和格式化，

将请求信息填充到入参对象中，然后调用 Validator 组件对已入参的对象进行数据合法性校验，并生成数据绑定结果 BindingResult 对象，若数据转换或数据格式化失败，或验证失败，

都会将失败的信息填充到 BinddingResult 对象中。

二、SpringMVC 的类型转换和格式化：

ConversionService 是 spring 类型转换体系的核心接口。位于 org.springframework.core.convert 包下，可以利用 org.springframework.context.support.ConversionServiceFactoryBean

在 springmvc 上下文中配置一个 ConversionService 的实例。SpringMVC 配置文件会自动识别上下文中的 ConversionService，并在类型转换的时候使用它。

使用<mvc:annotation-driven /> 注解后：

默认会注册一个 ConversionService ，即 FromattingConversionServiceFactoryBean，生产的 ConversionService 可以进行类型（日期和数字）的格式化。

若添加自定义类型转换器后，需要对其装配自定义的 ConversionService 。如：

<bean id="customizeConversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <bean class="com.nucsoft.springmvc.converter.PersonConversionService"/>
            <bean class="com.nucsoft.springmvc.converter.String2MapConversionService"/>
        </set>
    </property>
</bean>
<mvc:annotation-driven conversion-service="customizeConversionService"/>

这里装配的自定义 ConversionService 为 customerConversionService，是由 ConversionServiceFactoryBean 生产的。

这里会有一个问题，由 ConversionServiceFactoryBean 生产的 ConversionService 会覆盖默认的 FormattingConversionServiceFactoryBean，会导致类型（日期和数字）的给石化出错。

Spring 中定义了一个 ConversionService 实现类 FormattingConversionService ，该类扩展于 GenericConversionService ，它既有类型转换也有格式化的功能。

FormattingConversionService 也拥有一个 FormattingConversionServiceFactoryBean 。通过在 Spring 上下文中构造一个 FormattingConversionService，

既可以注册自定义类型转换器，也可以注册自定义注解格式化。NumberFormatAnnotationFormatterFactoryBean、JodaDateTimeFormatAnnotationFormatFactory

会自定注册到 FormattingConversionServiceFactoryBean 中。因此配置 FormattingConversionServiceFactoryBean 后，能很好的解决上述问题。如：

<bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="FormattingConversionService">
    <property name="converters">
        <set>
            <bean class="com.nucsoft.springmvc.converter.PersonConverster"/>
            <bean class="com.nucsoft.springmvc.converter.String2MapConverter"/>
        </set>
    </property>
</bean>
<mvc:annotation-driven conversion-service="FormattingConversionService"/>

来看一个具体的转换器：

/**
 * @author solverpeng
 * @create 2016-08-15-14:50
 */
public class PersonConverter implements Converter<String, Person>{
    Person person = null;
    @Override
    public Person convert(String s) {
        try {
            if(s != null && s.length() > 0) {
                String[] strings = s.split("\\|");
                person = Person.class.newInstance();
                for(String str : strings) {
                    String[] properties = str.split(":");
                    Field field = Person.class.getDeclaredField(properties[0]);
                    field.setAccessible(true);
                    Class<?> type = field.getType();
                    if(type.equals(Integer.class)) {
                        field.set(person, Integer.parseInt(properties[1]));
                        continue;
                    }
                    field.set(person, properties[1]);
                }
            }
        } catch(InstantiationException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
        return person;
    }
}

可以看出，具体解决转换问题的是：一个个的 Converter。

在 core.convert.support 包下提供了许多默认的类型转化器，为类型转换提供和极大的方便。

这些类型转换器虽然包含了大部分常用类型的转换，但是有时候我们有些特殊需求，就需要自定义类型转换器。

1.自定义类型转换器：

（1）实现 Converter 接口

package org.springframework.core.convert.converter;
public interface Converter<S, T> {
      T convert(S source);
}

创建自定义类型转换器，只需要实现该接口，参数 S 表示需要转换的类型，T 表示转换后的类型。对于每次调用 convert() 方法，必须保证参数 source 不能为 null。

如果转换失败，可能会抛出异常。特别的，一个 IllegalArgumentException 会被抛出来指明无效的 source 值。

请注意，需要保证转换器是线程安全的。

e1: 需要将 person=name:lily|age:23 转换为对应的 person 对象

自定义的类型转换器：

/**
 * @author solverpeng
 * @create 2016-08-15-14:50
 */
public class PersonConverter implements Converter<String, Person>{
    Person person = null;
    @Override
    public Person convert(String s) {
        try {
            if(s != null && s.length() > 0) {
                String[] strings = s.split("\\|");
                person = Person.class.newInstance();
                for(String str : strings) {
                    String[] properties = str.split(":");
                    Field field = Person.class.getDeclaredField(properties[0]);
                    field.setAccessible(true);
                    Class<?> type = field.getType();
                    if(type.equals(Integer.class)) {
                        field.set(person, Integer.parseInt(properties[1]));
                        continue;
                    }
                    field.set(person, properties[1]);
                }
            }
        } catch(InstantiationException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
        return person;
    }
}

在 SpringMVC 配置文件中添加如下配置：

<bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="FormattingConversionService">
    <property name="converters">
        <set>
            <bean class="com.nucsoft.springmvc.converter.PersonConverter"/>
        </set>
    </property>
</bean>
<mvc:annotation-driven conversion-service="FormattingConversionService"/>

请求：

<a href="testConverter?person=name:lily|age:23">test converter</a>

目标 handler 方法：

@RequestMapping("/testConverter")
public String testSpring2Person(Person person) {
    System.out.println("persont:" + person);
    return "success";
}

控制台输出：

persont:Person{name=‘lily‘, age=23}

e2：在介绍参数获取问题是，对 @RequestParam 的 “如果方法的入参类型是一个 Map，不包含泛型类型，并且请求参数名称是被指定” 这种情况没有进行详细说明，这里通过一个例子说明。

将 String 转换为 Map，将 params=a:1|b:2 转换为 Map 类型。

自定义类型转换器：

/**
 * @author solverpeng
 * @create 2016-08-15-15:40
 */
public class String2MapConverter implements Converter<String, Map<String, Object>>{
    @Override
    public Map<String, Object> convert(String s) {
        Map<String, Object> map = new HashMap<>();
        if(s != null & s.length() > 0) {
            String[] strings = s.split("\\|");
            for(String string : strings) {
                String[] split = string.split(":");
                map.put(split[0], split[1]);
            }
        }
        return map;
    }
}

在 SpringMVC 配置文件中添加如下配置：

<bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="FormattingConversionService">
    <property name="converters">
        <set>
            <bean class="com.nucsoft.springmvc.converter.String2MapConverter"/>
        </set>
    </property>
</bean>
<mvc:annotation-driven conversion-service="FormattingConversionService"/>

请求：

<a href="testConverter2?params=a:1|b:2">test converter2</a>

目标 handler 方法：

@RequestMapping("/testConverter2")
public String testString2Map(@RequestParam("params") Map map) {
    System.out.println(map);
    return "success";
}

控制台输出：

{b=2, a=1}

（2）实现 ConverterFactory

package org.springframework.core.convert.converter;
public interface ConverterFactory<S, R> {
     <T extends R> Converter<S, T> getConverter(Class<T> targetType);
}

如果希望将一种类型转换为另一种类型及其子类对象时，那么使用这个接口。

e: num=23&num2=33.33 将 num 转换为对应的 Integer 类型，将 num2 转换为对应的 Double 类型。

类型转换器：org.springframework.core.convert.support.StringToNumberConverterFactory

final class StringToNumberConverterFactory implements ConverterFactory<String, Number> {

    @Override
    public <T extends Number> Converter<String, T> getConverter(Class<T> targetType) {
        return new StringToNumber<T>(targetType);
    }

    private static final class StringToNumber<T extends Number> implements Converter<String, T> {

        private final Class<T> targetType;

        public StringToNumber(Class<T> targetType) {
            this.targetType = targetType;
        }

        @Override
        public T convert(String source) {
            if (source.length() == 0) {
                return null;
            }
            return NumberUtils.parseNumber(source, this.targetType);
        }
    }

}

请求：

<a href="testString2Number?num=23&num2=33.33">test String to Number</a>

目标 handler 方法：

@RequestMapping("/testString2Number")
public String testString2Number(@RequestParam("num") Integer num, @RequestParam("num2") Double num2) {
    System.out.println("num:" + num);
    System.out.println("num2:" + num2);
    return "success";
}

控制台输出：

num:23
num2:33.33

（3）还有一种 GenericConverter ，这里不对其进行说明。有兴趣的童鞋，可自行研究，用到的情况比较少。

2.格式化

这里所说的格式化，主要指的是日期和数字的格式化。SpringMVC 支持使用 @DateTimeFormat 和 @NumberFormat 来完成数据类型的格式化。看一个例子。

/**
 * @author solverpeng
 * @create 2016-08-16-11:14
 */
public class Employee {
    private String empName;
    private String email;
    private Date birth;
    private Double salary;

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    @Email
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Past
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    @NumberFormat(pattern = "#,###,###.##")
    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "  empName=‘" + empName + ‘\‘‘ +
                ", email=‘" + email + ‘\‘‘ +
                ", birth=" + birth +
                ", salary=" + salary +
                ‘}‘;
    }
}

请求：

<a href="testFormat?empName=lily&email=lily@bb.com&birth=1992-12-23&salary=1,234,567.89">test Format</a>

控制台输出：

employee:Employee{ empName=‘null‘, email=‘lily@bb.com‘, birth=Wed Dec 23 00:00:00 CST 1992, salary=1234567.89}

请求：

<a href="testFormat?empName=lily&email=lily@bb.com&birth=2992-12-23&salary=1,234,567.89">test Format</a>

控制台输出：

allError:Field error in object ‘employee‘ on field ‘birth‘: rejected value [Sun Dec 23 00:00:00 CST 2992]; codes [Past.employee.birth,Past.birth,Past.java.util.Date,Past];

arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [employee.birth,birth]; arguments []; default message [birth]]; default message [需要是一个过去的事件]

employee:Employee{ empName=‘null‘, email=‘lily@bb.com‘, birth=Sun Dec 23 00:00:00 CST 2992, salary=1234567.89}

二、SpringMVC 使用 DataBinder 进行数据的绑定。在类型转换和格式化之后，会进行数据的绑定。

三、SpringMVC 的数据校验：

Spring 4.0 之后，支持 Bean Validation 1.0（JSR-303）和 Bean Validation 1.1（JSR-349）校验。同时也支持 Spring Validator 接口校验。

Spring 提供一个验证接口，你可以用它来验证对象。这个 Validator 接口使用一个 Errors 对象来工作，验证器验证失败的时候向 Errors 对象填充验证失败信息。

1.使用 Spring Validator 接口校验

（1）一个简单对象的验证

实体类：

/**
 * @author solverpeng
 * @create 2016-08-12-10:50
 */
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

Person.java

创建验证器（即创建 Validator 的实现类）

/**
 * @author solverpeng
 * @create 2016-08-12-10:51
 */
public class PersonValidator implements Validator{
    /**
     * This Validator validates *just* for Person
     */
    @Override
    public boolean supports(Class<?> aClass) {
        return Person.class.equals(aClass);
    }

    @Override
    public void validate(Object o, Errors errors) {
        ValidationUtils.rejectIfEmpty(errors, "name", "name.empty", "人名不能为空.");
        Person person = (Person) o;
        if(person.getAge() < 0) {
            errors.rejectValue("age", "negativevalue", "年龄不能为负数.");
        } else if(person.getAge() > 110) {
            errors.rejectValue("age", "too.darn.old", "年龄不得超过110岁.");
        }
    }
}

使用：

/**
 * @author solverpeng
 * @create 2016-08-12-10:49
 */
@Controller
public class TargetHandler {

    @InitBinder
    public void initBinder(DataBinder binder) {
        binder.setValidator(new PersonValidator());
    }

    @RequestMapping("/testPersonValidator")
    public String testPersonValidator(@Valid Person person, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError allError : allErrors) {
                    System.out.println("error: " + allError.getDefaultMessage());
                }
            }
        }
        System.out.println(person);
        return "success";
    }

}

（2）一个复杂对象的验证

实体类：

/**
 * @author solverpeng
 * @create 2016-08-12-11:14
 */
public class Customer {
    private String firstName;
    private String surname;
    private Address address;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }


    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "firstName=‘" + firstName + ‘\‘‘ +
                ", surname=‘" + surname + ‘\‘‘ +
                ", address=" + address +
                ‘}‘;
    }
}

Customer.java

/**
 * @author solverpeng
 * @create 2016-08-12-11:15
 */
public class Address {
    private String addressName;

    public String getAddressName() {
        return addressName;
    }

    public void setAddressName(String addressName) {
        this.addressName = addressName;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addressName=‘" + addressName + ‘\‘‘ +
                ‘}‘;
    }
}

Address.java

验证器类：

/**
 * @author solverpeng
 * @create 2016-08-12-11:16
 */
public class AddressValidator implements Validator{
    @Override
    public boolean supports(Class<?> clazz) {
        return Address.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "addressName", "field.required", "地址名称必须输入.");
    }
}

/**
 * @author solverpeng
 * @create 2016-08-12-11:18
 */
public class CustomerValidator implements Validator{
    private final Validator addressValidator;

    public CustomerValidator(Validator addressValidator) {
        if(addressValidator == null) {
            throw new IllegalArgumentException("the validator is required and must be null.");
        }
        if(!addressValidator.supports(Address.class)) {
            throw new IllegalArgumentException("the validator must be [Address] instance.");
        }

        this.addressValidator = addressValidator;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return Customer.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "field.required", "firstName 必须输入.");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "surname", "field.required", "surname 必须输入.");
        Customer customer = (Customer) target;

        try {
            errors.pushNestedPath("address");
            ValidationUtils.invokeValidator(this.addressValidator, customer.getAddress(), errors);
        } finally {
            errors.popNestedPath();
        }
    }
}

使用

/**
 * @author solverpeng
 * @create 2016-08-12-10:49
 */
@Controller
public class TargetHandler {

    @InitBinder
    public void initBinder(DataBinder binder) {
        binder.setValidator(new CustomerValidator(new AddressValidator()));
    }

    @RequestMapping("/testCustomerValidator")
    public String testCustomerValidator(@Valid Customer customer, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError error : allErrors) {
                    System.out.println("error: " + error.getDefaultMessage());
                }
            }
        }
        return "success";
    }

}

说明：对于复杂对象来说，创建验证器的时候，可以使用嵌套的方式

通过实现 Validator 接口的方式创建的验证器，不是通过配置吗，也不是通过注解来调用，而是通过 @InitBinder 标注的方法，进而去调每个验证器进行验证。

Spring 没有对 @Valid 添加某个属性来指定使用哪个验证器进行验证。所以下面这种情况会报异常。

/**
 * @author solverpeng
 * @create 2016-08-12-10:49
 */
@Controller
public class TargetHandler {

    @InitBinder
    public void initBinder(DataBinder binder) {
        binder.setValidator(new PersonValidator());
        binder.setValidator(new CustomerValidator(new AddressValidator()));
    }

    @RequestMapping("/testCustomerValidator")
    public String testCustomerValidator(@Valid Customer customer, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError error : allErrors) {
                    System.out.println("error: " + error.getDefaultMessage());
                }
            }
        }
        return "success";
    }

    @RequestMapping("/testPersonValidator")
    public String testPersonValidator(@Valid Person person, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError allError : allErrors) {
                    System.out.println("error: " + allError.getDefaultMessage());
                }
            }
        }
        System.out.println(person);
        return "success";
    }

}

同时指定了两个验证器，不论是请求 testCustomerValidator，还是请求 testPersonValidator 都会报异常，因为在 initBinder() 中设置的两个 validator 是一个且的关系，只要是验证，必须同时满足这两个 validator 的验证规则。

默认情况下，如果不对 @InitBinder 注解指定 value 属性值，那么这个方法对每个入参存在 model 参数的目标 handler 方法起作用，在目标方法调用前，对入参处的 model 执行校验。

如果对 @InitBinder 注解指定 value 属性值，那么它只会对对应的目标 handler 方法的入参 model 执行校验.

如：

/**
 * @author solverpeng
 * @create 2016-08-12-10:49
 */
@Controller
public class TargetHandler {

    @InitBinder("customer")
    public void initBinder(DataBinder binder) {
        binder.setValidator(new CustomerValidator(new AddressValidator()));
    }

    @RequestMapping("/testCustomerValidator")
    public String testCustomerValidator(@Valid Customer customer, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError error : allErrors) {
                    System.out.println("error: " + error.getDefaultMessage());
                }
            }
        }
        return "success";
    }

    @RequestMapping("/test")
    public String test(@Valid Person person) {
        System.out.println(person);
        return "success";
    }

}

如此时，只会对 testCustomerValidator() 方法处的 customer 参数执行校验，而不会对 test() 方法处的 person 参数执行校验。

目标 handler 方法处的 BindingResult 类型的参数，它是 Errors 的子接口，验证失败之后的错误信息会存放到 Erros 中，在目标方法处，验证出错的信息可以通过 BindingResult 来获取。

需要注意的是，如果在目标方法处存在多个需要校验的对象，需要在每个对象后添加 BindingResult 来获取验证失败的错误信息，而不能只通过一个 BindingResult 来获取所有的错误信息，即 BindignResult 必须紧挨着要验证的参数后。

2.使用 JSR-303 进行校验

JSR-303 校验是一个数据校验规范，Spring 没有对其进行实现，所以使用的时候，需要添加一个实现，这里添加 Hibernate Validator 作为 JSR-303 的实现.

需要额外添加的 jar 包：

validation-api-1.1.0.CR1.jar
hibernate-validator-5.0.0.CR2.jar
hibernate-validator-annotation-processor-5.0.0.CR2.jar
jboss-logging-3.1.1.GA.jar
classmate-0.8.0.jar

在 Bean 的 getXxx() 或属性名上添加验证规则注解.

（1）一个简单对象的验证

实体类：

public class Person {
    private String name;
    private int age;

    @NotBlank(message = "人名不能为空")
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Min(value = 10, message = "年龄最小为10.")
    @Max(value = 110, message = "年龄最大不得超过110.")
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

使用：

@RequestMapping("/testPersonValidator")
public String testPersonValidator(@Valid Person person, BindingResult result) {
    if(result.hasErrors()) {
        List<ObjectError> allErrors = result.getAllErrors();
        if(!CollectionUtils.isEmpty(allErrors)) {
            for(ObjectError allError : allErrors) {
                System.out.println("error: " + allError.getDefaultMessage());
            }
        }
    }
    System.out.println(person);
    return "success";
}

不需要通过 @InitBinder 来指定验证器，只需要在目标 handler 方法处对需要验证的对象标注 @Valid 注解。可以对一个属性标有多个验证规则的注解。

（2）一个复杂对象的验证

实体：

public class Address {
    private String addressName;

    @NotBlank
    public String getAddressName() {
        return addressName;
    }

    public void setAddressName(String addressName) {
        this.addressName = addressName;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addressName=‘" + addressName + ‘\‘‘ +
                ‘}‘;
    }
}

public class Customer {
    private String firstName;
    private String surname;
    private Address address;

    @NotBlank(message = "firstName must be not null.")
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    @Valid
    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @NotBlank(message = "surname must be not null.")
    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "firstName=‘" + firstName + ‘\‘‘ +
                ", surname=‘" + surname + ‘\‘‘ +
                ", address=" + address +
                ‘}‘;
    }
}

说明：对复杂对象的验证和简单对象的验证使用方式相同，对内嵌对象的验证使用 @Valid 注解就行。

和实现 Validator 接口不同，在 Spring 中使用 JSR-303 可以在一个 handler 中验证多个不同的的 bean 。如：

@Controller
public class TargetHandler {

    @RequestMapping("/testCustomerValidator")
    public String testCustomerValidator(@Valid Customer customer, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError error : allErrors) {
                    System.out.println("error: " + error.getDefaultMessage());
                }
            }
        }
        return "success";
    }

    @RequestMapping("/testPersonValidator")
    public String testPersonValidator(@Valid Person person, BindingResult result) {
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            if(!CollectionUtils.isEmpty(allErrors)) {
                for(ObjectError allError : allErrors) {
                    System.out.println("error: " + allError.getDefaultMessage());
                }
            }
        }
        System.out.println(person);
        return "success";
    }

}

说明：不论是请求 testCustomerValidator 对 Customer 进行验证还是请求testPersonValidator 对 Person 进行验证，不会报异常

3.自定义验证规则约束注解

（1）参照已经实现的验证规则。自定义的验证规则注解需要使用 @Constraint 注解，同时指定其属性 validatedBy 的值，即使用哪个验证器类进行校验。

（2）必须对验证器注解类添加三个属性：message、groups和payload。

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = NumberValidator.class)
public @interface Number {
    String message() default "must be a number.";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

定义验证器类，必须实现 public interface ConstraintValidator<A extends java.lang.annotation.Annotation, T> 这个接口，如：

public class NumberValidator implements ConstraintValidator<Number, String> {
    private Number number;

    @Override
    public void initialize(Number number) {
        this.number = number;
    }

    @Override
    public boolean isValid(String str, ConstraintValidatorContext constraintValidatorContext) {
        try {
            Integer.parseInt(str);
            return true;
        } catch(NumberFormatException e) {
            return false;
        }
    }
}

可以看出，需要实现两个方法，initialize() 方法进行初始化，isValid() 方法进行验证，其中 A 为验证器注解类名，也是initialize() 方法的入参，T 为要验证的对象，也是 isValid() 方法的的第一个参数。

（3）对验证规则注解进行分组

问题：通过验证接口的方式，可以为一个 bean 定义多个验证器，可以适用于不同的情况。那么使用 JSR-303 该如何达到这种效果？

<1>定义分组接口（普通接口就行），用于标识分组

<2>对要验证的 bean 标注的注解进行分组。

public class Person {
    private String name;
    private int age;

    @NotBlank(message = "人名不能为空")
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Min(value = 10, message = "年龄最小为10.", groups = First.class)
    @Max(value = 110, message = "年龄最大不得超过110.", groups = Second.class)
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

验证时指定分组

@RequestMapping("/testPersonValidator")
public String testPersonValidator(@Validated({First.class}) Person person, BindingResult result) {
    if(result.hasErrors()) {
        List<ObjectError> allErrors = result.getAllErrors();
        if(!CollectionUtils.isEmpty(allErrors)) {
            for(ObjectError allError : allErrors) {
                System.out.println("error: " + allError.getDefaultMessage());
            }
        }
    }
    System.out.println(person);
    return "success";
}

说明：

在使用时，可以指定同时使用多个分组，按照先后顺序进行验证，若第一个不通过，则不验证第二个。

为同一个 Bean 定义的多个验证器注解名称不能重复，若想添加相同的规则，需要自定义注解。

四、客户端错误消息的显示：

上面已经介绍过，不论是类型转换和格式化失败，还是数据校验失败，都会将错误信息填充到 BindingResult 中，那么在客户端如何获取呢？

使用 SpringMVC 标签显示错误消息。当使用 springmvc 标签显示错误消息时，SpringMVC 会查看 Web 上下文是否装配了对应的国际化资源文件，在国际化资源文件中查找对应的国际化消息。如果没有找到，则显示默认的错误消息。

每个属性在数据绑定或数据校验发生错误的时候，都会生成一个 fieldError 对象。当一个属性校验失败后，校验框架会为该属性生成4个消息代码。

如 User 的 password 属性标注了一个 @Pattern 注解，当不满足 @Pattern 定义的规则时，就会产生以下4个错误代码。

Pattern.user.password
Pattern.password
Pattern.java.lang.String
Pattern

若类型转换或数据格式化出错时，或该有的参数不存在时，或调用处理方法发生错误时，都会在隐含模型中创建错误消息。

错误代码前缀：

required:必要的参数不存在。如 @RequestParam("param1") 标注了一个入参，但是该参数不存在。

typeMismatch: 在数据绑定时，发生数据类型不匹配的问题。

methodInvocation: 调用处理方法时发生了错误。

注册国际化资源文件：

在SpringMVC配置文件中添加 ResourceBundleMessageSource 类型的 Bean ，同时指定其 id 为 messageSource。设置其国际化基名。如：

<bean class="org.springframework.context.support.ResourceBundleMessageSource" id="messageSource">
　　<property name="basename" value="i18n"/>
</bean>

五、总结

本篇文章从 <mvc:annotation-driven /> 说起，主要说明了 SpringMVC 的类型转换、格式化以及数据校验。只是对用法进行了说明，没有更深层次的深入。以后深入的时候再写文章来介绍吧。

六、外传

（1）

在 idea 下，无法对国际化资源文件中的中文转为 Unicode,这里提供一个中文汉字 | ASCII | Unicode互相转换工具在线工具：

http://www.atool.org/chinese2unicode.php

（2）

@InitBinder 详解

标注有 @InitBinder 注解的方法。可以对 WebDataBinder 对象进行初始化，WebDataBinder 是 DataBinder 的子类，用于完成表单属性对 Bean 属性的绑定。

@InitBinder 标注的方法不能有返回值，参数一般为 WebDataBinder 。

如不自动绑定对象中的 name 值。

@InitBinder
public void initBinder(WebDataBinder dataBinder) {
    dataBinder.setDisAllowedField("name");
}

SpringMVC——类型转换和格式化、数据校验、客户端显示错误消息

标签：

原文地址：http://www.cnblogs.com/solverpeng/p/5816964.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行