Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC

Spring4新特性——泛型限定式依赖注入

Spring4新特性——核心容器的其他改进

Spring4新特性——Web开发的增强

Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 

Spring4新特性——Groovy Bean定义DSL

Spring4新特性——更好的Java泛型操作API 

Spring4新特性——JSR310日期API的支持

Spring4新特性——注解、脚本、任务、MVC等其他特性改进 

 

在之前的《跟我学SpringMVC》中的《第七章 注解式控制器的数据验证、类型转换及格式化》中已经介绍过SpringMVC集成Bean Validation 1.0（JSR-303），目前Bean Validation最新版本是Bean Validation 1.1（JSR-349），新特性可以到官网查看，笔者最喜欢的两个特性是：跨参数验证（比如密码和确认密码的验证）和支持在消息中使用EL表达式，其他的还有如方法参数/返回值验证、CDI和依赖注入、分组转换等。对于方法参数/返回值验证，大家可以参阅《Spring3.1 对Bean Validation规范的新支持(方法级别验证) 》。

 

Bean Validation 1.1当前实现是Hibernate validator 5，且spring4才支持。接下来我们从以下几个方法讲解Bean Validation 1.1，当然不一定是新特性：

1.  集成Bean Validation 1.1到SpringMVC

2.  分组验证、分组顺序及级联验证

3.  消息中使用EL表达式

4.  方法参数/返回值验证

5.  自定义验证规则

6.  类级别验证器

7.  脚本验证器

8.  cross-parameter，跨参数验证

9. 混合类级别验证器和跨参数验证器

10. 组合多个验证注解

11. 本地化

因为大多数时候验证都配合web框架使用，而且很多朋友都咨询过如分组/跨参数验证，所以本文介绍下这些，且是和SpringMVC框架集成的例子，其他使用方式（比如集成到JPA中）可以参考其官方文档：

规范：http://beanvalidation.org/1.1/spec/

hibernate validator文档：http://hibernate.org/validator/ 

 

 1、集成Bean Validation 1.1到SpringMVC

1.1、项目搭建

首先添加hibernate validator 5依赖：

            org.hibernate
            hibernate-validator
            5.0 . 2 .Final

如果想在消息中使用EL表达式，请确保EL表达式版本是 2.2或以上，如使用Tomcat6，请到Tomcat7中拷贝相应的EL jar包到Tomcat6中。

            javax.el
            javax.el-api
            2.2 . 4
            provided

请确保您使用的Web容器有相应版本的el jar包。

 

对于其他POM依赖请下载附件中的项目参考。

 

1.2、Spring MVC配置文件（spring-mvc.xml）：

    "validator" />


    "validator"  class = "org.springframework.validation.beanvalidation.LocalValidatorFactoryBean" >
        "providerClass"  value= "org.hibernate.validator.HibernateValidator" />

        "validationMessageSource"  ref= "messageSource" />



    "messageSource"  class = "org.springframework.context.support.ReloadableResourceBundleMessageSource" >
        "basenames" >


                classpath:messages
                classpath:org/hibernate/validator/ValidationMessages


        "useCodeAsDefaultMessage"  value= "false" />
        "defaultEncoding"  value= "UTF-8" />
        "cacheSeconds"  value= "60" />

此处主要把bean validation的消息查找委托给spring的messageSource。

 

1.3、实体验证注解：

public  class  User  implements  Serializable {
    @NotNull (message =  "{user.id.null}" )
    private  Long id;

    @NotEmpty (message =  "{user.name.null}" )
    @Length (min =  5 , max =  20 , message =  "{user.name.length.illegal}" )
    @Pattern (regexp =  "[a-zA-Z]{5,20}" , message =  "{user.name.illegal}" )
    private  String name;

    @NotNull (message =  "{user.password.null}" )
    private  String password;
}

对于验证规则可以参考官方文档，或者《第七章 注解式控制器的数据验证、类型转换及格式化》。

 

1.4、错误消息文件messages.properties：

user.id. null =用户编号不能为空
user.name. null =用户名不能为空
user.name.length.illegal=用户名长度必须在 5 到 20 之间
user.name.illegal=用户名必须是字母
user.password. null =密码不能为空

 

1.5、控制器

@Controller
public  class  UserController {

    @RequestMapping ( "/save" )
    public  String save( @Valid  User user, BindingResult result) {
        if (result.hasErrors()) {
            return  "error" ;
        }
        return  "success" ;
    }
}

 

1.6、错误页面：

"user" >
    if  test= "${errors.fieldErrorCount > 0}" >
        字段错误：
        "${errors.fieldErrors}"  var= "error" >
            "message"  code= "${error.code}"  arguments= "${error.arguments}"  text= "${error.defaultMessage}" />
            ${error.field}------${message}

    if >

    if  test= "${errors.globalErrorCount > 0}" >
        全局错误：
        "${errors.globalErrors}"  var= "error" >
            "message"  code= "${error.code}"  arguments= "${error.arguments}"  text= "${error.defaultMessage}" />
            if  test= "${not empty message}" >
                ${message}
            if >

    if >

 

大家以后可以根据这个做通用的错误消息显示规则。比如我前端页面使用validationEngine显示错误消息，那么我可以定义一个tag来通用化错误消息的显示：showFieldError.tag。  

 

1.7、测试

输入如：http://localhost:9080/spring4/save?name=123 ， 我们得到如下错误：

name------用户名必须是字母
name------用户名长度必须在 5 到 20 之间
password------密码不能为空
id------用户编号不能为空

 

基本的集成就完成了。

 

如上测试有几个小问题：

1、错误消息顺序，大家可以看到name的错误消息顺序不是按照书写顺序的，即不确定；

2、我想显示如：用户名【zhangsan】必须在5到20之间；其中我们想动态显示：用户名、min，max；而不是写死了；

3、我想在修改的时候只验证用户名，其他的不验证怎么办。

接下来我们挨着试试吧。

 

2、分组验证及分组顺序

如果我们想在新增的情况验证id和name，而修改的情况验证name和password，怎么办？ 那么就需要分组了。

首先定义分组接口：

public  interface  First {
}

public  interface  Second {
}

分组接口就是两个普通的接口，用于标识，类似于java.io.Serializable。

 

接着我们使用分组接口标识实体：

public  class  User  implements  Serializable {

    @NotNull (message =  "{user.id.null}" , groups = {First. class })
    private  Long id;

    @Length (min =  5 , max =  20 , message =  "{user.name.length.illegal}" , groups = {Second. class })
    @Pattern (regexp =  "[a-zA-Z]{5,20}" , message =  "{user.name.illegal}" , groups = {Second. class })
    private  String name;

    @NotNull (message =  "{user.password.null}" , groups = {First. class , Second. class })
    private  String password;
}

 

验证时使用如：

@RequestMapping ( "/save" )
    public  String save( @Validated ({Second. class }) User user, BindingResult result) {
        if (result.hasErrors()) {
            return  "error" ;
        }
        return  "success" ;
    }

即通过@Validate注解标识要验证的分组；如果要验证两个的话，可以这样@Validated({First.class, Second.class})。

 

接下来我们来看看通过分组来指定顺序；还记得之前的错误消息吗？ user.name会显示两个错误消息，而且顺序不确定；如果我们先验证一个消息；如果不通过再验证另一个怎么办？可以通过@GroupSequence指定分组验证顺序：

 

@GroupSequence ({First. class , Second. class , User. class })
public  class  User  implements  Serializable {
    private  Long id;

    @Length (min =  5 , max =  20 , message =  "{user.name.length.illegal}" , groups = {First. class })
    @Pattern (regexp =  "[a-zA-Z]{5,20}" , message =  "{user.name.illegal}" , groups = {Second. class })
    private  String name;

    private  String password;
}

通过@GroupSequence指定验证顺序：先验证First分组，如果有错误立即返回而不会验证Second分组，接着如果First分组验证通过了，那么才去验证Second分组，最后指定User.class表示那些没有分组的在最后。这样我们就可以实现按顺序验证分组了。

 

另一个比较常见的就是级联验证：

如：

public  class  User {

    @Valid
    @ConvertGroup (from=First. class , to=Second. class )
    private  Organization o;

}

 1、级联验证只要在相应的字段上加@Valid即可，会进行级联验证；@ConvertGroup的作用是当验证o的分组是First时，那么验证o的分组是Second，即分组验证的转换。

 

3、消息中使用EL表达式

假设我们需要显示如：用户名[NAME]长度必须在[MIN]到[MAX]之间，此处大家可以看到，我们不想把一些数据写死，如NAME、MIN、MAX；此时我们可以使用EL表达式。

 

如：

@Length (min =  5 , max =  20 , message =  "{user.name.length.illegal}" , groups = {First. class })

错误消息：

user.name.length.illegal=用户名长度必须在{min}到{max}之间

 

其中我们可以使用{验证注解的属性}得到这些值；如{min}得到@Length中的min值；其他的也是类似的。

 

到此，我们还是无法得到出错的那个输入值，如name=zhangsan。此时就需要EL表达式的支持，首先确定引入EL jar包且版本正确。然后使用如：

user.name.length.illegal=用户名[${validatedValue}]长度必须在 5 到 20 之间

使用如EL表达式：${validatedValue}得到输入的值，如zhangsan。当然我们还可以使用如${min > 1 ? '大于1' : '小于等于1'}，及在EL表达式中也能拿到如@Length的min等数据。

 

另外我们还可以拿到一个java.util.Formatter类型的formatter变量进行格式化：

${formatter.format( "%04d" , min)}

 

4、方法参数/返回值验证

这个可以参考《Spring3.1 对Bean Validation规范的新支持(方法级别验证) 》，概念是类似的，具体可以参考Bean Validation 文档。

 

5、自定义验证规则

有时候默认的规则可能还不够，有时候还需要自定义规则，比如屏蔽关键词验证是非常常见的一个功能，比如在发帖时帖子中不允许出现admin等关键词。

 

1、定义验证注解

package  com.sishuok.spring4.validator;

import  javax.validation.Constraint;
import  javax.validation.Payload;
import  java.lang.annotation.Documented;
import  java.lang.annotation.Retention;
import  java.lang.annotation.Target;
import  static  java.lang.annotation.ElementType.*;
import  static  java.lang.annotation.RetentionPolicy.*;
/**
 * User: Zhang Kaitao
 * Date: 13-12-15
 * Version: 1.0
 */

@Target ({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })
@Retention (RUNTIME)
//指定验证器
@Constraint (validatedBy = ForbiddenValidator. class )
@Documented
public  @interface  Forbidden {

    //默认错误消息
    String message()  default  "{forbidden.word}" ;

    //分组
    Class[] groups()  default  { };

    //负载
    Class extends  Payload>[] payload()  default  { };

    //指定多个时使用
    @Target ({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })
    @Retention (RUNTIME)
    @Documented
    @interface  List {
        Forbidden[] value();
    }
}

 

2、 定义验证器

package  com.sishuok.spring4.validator;

import  org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorContextImpl;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.context.ApplicationContext;
import  org.springframework.util.StringUtils;

import  javax.validation.ConstraintValidator;
import  javax.validation.ConstraintValidatorContext;
import  java.io.Serializable;

/**
 * User: Zhang Kaitao
 * Date: 13-12-15
 * Version: 1.0
 */
public  class  ForbiddenValidator  implements  ConstraintValidator {

    private  String[] forbiddenWords = { "admin" };

    @Override
    public  void  initialize(Forbidden constraintAnnotation) {
        //初始化，得到注解数据
    }

    @Override
    public  boolean  isValid(String value, ConstraintValidatorContext context) {
        if (StringUtils.isEmpty(value)) {
            return  true ;
        }

        for (String word : forbiddenWords) {
            if (value.contains(word)) {
                return  false ; //验证失败
            }
        }
        return  true ;
    }
}

 验证器中可以使用spring的依赖注入，如注入：@Autowired  private ApplicationContext ctx; 

 

3、使用

public  class  User  implements  Serializable {
    @Forbidden ()
    private  String name;
}

 

4、当我们在提交name中含有admin的时候会输出错误消息：

forbidden.word=您输入的数据中有非法关键词

 

问题来了，哪个词是非法的呢？bean validation 和 hibernate validator都没有提供相应的api提供这个数据，怎么办呢？通过跟踪代码，发现一种不是特别好的方法：我们可以覆盖org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl实现（即复制一份代码放到我们的src中），然后覆盖buildAnnotationParameterMap方法；

private  Map buildAnnotationParameterMap(Annotation annotation) {
        ……
        //将Collections.unmodifiableMap( parameters );替换为如下语句
        return  parameters;
    }

 即允许这个数据可以修改；然后在ForbiddenValidator中：

for (String word : forbiddenWords) {
            if (value.contains(word)) {
                ((ConstraintValidatorContextImpl)context).getConstraintDescriptor().getAttributes().put( "word" , word);
                return  false ; //验证失败
            }
        }

通过((ConstraintValidatorContextImpl)context).getConstraintDescriptor().getAttributes().put("word", word);添加自己的属性；放到attributes中的数据可以通过${} 获取。然后消息就可以变成：

forbidden.word=您输入的数据中有非法关键词【{word}】

这种方式不是很友好，但是可以解决我们的问题。

 

典型的如密码、确认密码的场景，非常常用；如果没有这个功能我们需要自己写代码来完成；而且经常重复自己。接下来看看bean validation 1.1如何实现的。

 

6、类级别验证器

6.1、定义验证注解

package  com.sishuok.spring4.validator;

import  javax.validation.Constraint;
import  javax.validation.Payload;
import  javax.validation.constraints.NotNull;
import  java.lang.annotation.Documented;
import  java.lang.annotation.Retention;
import  java.lang.annotation.Target;
import  static  java.lang.annotation.ElementType.*;
import  static  java.lang.annotation.RetentionPolicy.*;
/**
 * User: Zhang Kaitao
 * Date: 13-12-15
 * Version: 1.0
 */

@Target ({ TYPE, ANNOTATION_TYPE})
@Retention (RUNTIME)
//指定验证器
@Constraint (validatedBy = CheckPasswordValidator. class )
@Documented
public  @interface  CheckPassword {

    //默认错误消息
    String message()  default  "" ;

    //分组
    Class[] groups()  default  { };

    //负载
    Class extends  Payload>[] payload()  default  { };

    //指定多个时使用
    @Target ({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })
    @Retention (RUNTIME)
    @Documented
    @interface  List {
        CheckPassword[] value();
    }
}

6.2、 定义验证器

?