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，当然不一定是新特性：
-
集成Bean Validation 1.1到SpringMVC
-
分组验证、分组顺序及级联验证
-
消息中使用EL表达式
-
方法参数/返回值验证
-
自定义验证规则
-
类级别验证器
-
脚本验证器
-
cross-parameter，跨参数验证
-
混合类级别验证器和跨参数验证器
-
组合多个验证注解
-
本地化
因为大多数时候验证都配合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依赖：
|
1
2
3
4
5
|
5.0
.
2
.Final
|
如果想在消息中使用EL表达式，请确保EL表达式版本是 2.2或以上，如使用Tomcat6，请到Tomcat7中拷贝相应的EL jar包到Tomcat6中。
|
1
2
3
4
5
6
|
2.2
.
4
|
请确保您使用的Web容器有相应版本的el jar包。
对于其他POM依赖请下载附件中的项目参考。
1.2、Spring MVC配置文件（spring-mvc.xml）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
|
此处主要把bean validation的消息查找委托给spring的messageSource。
1.3、实体验证注解：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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：
|
1
2
3
4
5
|
user.id.
null
=用户编号不能为空
user.name.
null
=用户名不能为空
user.name.length.illegal=用户名长度必须在
5
到
20
之间
user.name.illegal=用户名必须是字母
user.password.
null
=密码不能为空
|
1.5、控制器
|
1
2
3
4
5
6
7
8
9
10
11
|
@Controller
public
class
UserController {
@RequestMapping
(
"/save"
)
public
String save(
@Valid
User user, BindingResult result) {
if
(result.hasErrors()) {
return
"error"
;
}
return
"success"
;
}
}
|
1.6、错误页面：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
字段错误：
${error.field}------${message}
全局错误：
${message}
|
大家以后可以根据这个做通用的错误消息显示规则。比如我前端页面使用validationEngine显示错误消息，那么我可以定义一个tag来通用化错误消息的显示：showFieldError.tag。
1.7、测试
输入如：http://localhost:9080/spring4/save?name=123 ， 我们得到如下错误：
|
1
2
3
4
|
name------用户名必须是字母
name------用户名长度必须在
5
到
20
之间
password------密码不能为空
id------用户编号不能为空
|
基本的集成就完成了。
如上测试有几个小问题：
1、错误消息顺序，大家可以看到name的错误消息顺序不是按照书写顺序的，即不确定；
2、我想显示如：用户名【zhangsan】必须在5到20之间；其中我们想动态显示：用户名、min，max；而不是写死了；
3、我想在修改的时候只验证用户名，其他的不验证怎么办。
接下来我们挨着试试吧。
2、分组验证及分组顺序
如果我们想在新增的情况验证id和name，而修改的情况验证name和password，怎么办？ 那么就需要分组了。
首先定义分组接口：
|
1
2
3
4
5
|
public
interface
First {
}
public
interface
Second {
}
|
分组接口就是两个普通的接口，用于标识，类似于java.io.Serializable。
接着我们使用分组接口标识实体：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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;
}
|
验证时使用如：
|
1
2
3
4
5
6
7
|
@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指定分组验证顺序：
|
1
2
3
4
5
6
7
8
9
10
|
@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表示那些没有分组的在最后。这样我们就可以实现按顺序验证分组了。
另一个比较常见的就是级联验证：
如：
|
1
2
3
4
5
6
7
|
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表达式。
如：
|
1
|
@Length
(min =
5
, max =
20
, message =
"{user.name.length.illegal}"
, groups = {First.
class
})
|
错误消息：
|
1
|
user.name.length.illegal=用户名长度必须在{min}到{max}之间
|
其中我们可以使用{验证注解的属性}得到这些值；如{min}得到@Length中的min值；其他的也是类似的。
到此，我们还是无法得到出错的那个输入值，如name=zhangsan。此时就需要EL表达式的支持，首先确定引入EL jar包且版本正确。然后使用如：
|
1
|
user.name.length.illegal=用户名[${validatedValue}]长度必须在
5
到
20
之间
|
使用如EL表达式：${validatedValue}得到输入的值，如zhangsan。当然我们还可以使用如${min > 1 ? '大于1' : '小于等于1'}，及在EL表达式中也能拿到如@Length的min等数据。
另外我们还可以拿到一个java.util.Formatter类型的formatter变量进行格式化：
|
1
|
${formatter.format(
"%04d"
, min)}
|
4、方法参数/返回值验证
这个可以参考《Spring3.1 对Bean Validation规范的新支持(方法级别验证) 》，概念是类似的，具体可以参考Bean Validation 文档。
5、自定义验证规则
有时候默认的规则可能还不够，有时候还需要自定义规则，比如屏蔽关键词验证是非常常见的一个功能，比如在发帖时帖子中不允许出现admin等关键词。
1、定义验证注解
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
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.*;
/**
*
*
*
*/
@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
//指定多个时使用
@Target
({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })
@Retention
(RUNTIME)
@Documented
@interface
List {
Forbidden[] value();
}
}
|
2、 定义验证器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
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;
/**
*
*
*
*/
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、使用
|
1
2
3
4
|
public
class
User
implements
Serializable {
@Forbidden
()
private
String name;
}
|
4、当我们在提交name中含有admin的时候会输出错误消息：
|
1
|
forbidden.word=您输入的数据中有非法关键词
|
问题来了，哪个词是非法的呢？bean validation 和 hibernate validator都没有提供相应的api提供这个数据，怎么办呢？通过跟踪代码，发现一种不是特别好的方法：我们可以覆盖org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl实现（即复制一份代码放到我们的src中），然后覆盖buildAnnotationParameterMap方法；
|
1
2
3
4
5
|
private
Map
……
//将Collections.unmodifiableMap( parameters );替换为如下语句
return
parameters;
}
|
即允许这个数据可以修改；然后在ForbiddenValidator中：
|
1
2
3
4
5
6
|
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中的数据可以通过${} 获取。然后消息就可以变成：
|
1
|
forbidden.word=您输入的数据中有非法关键词【{word}】
|
这种方式不是很友好，但是可以解决我们的问题。
典型的如密码、确认密码的场景，非常常用；如果没有这个功能我们需要自己写代码来完成；而且经常重复自己。接下来看看bean validation 1.1如何实现的。
6、类级别验证器
6.1、定义验证注解
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
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.*;
/**
*
*
*
*/
@Target
({ TYPE, ANNOTATION_TYPE})
@Retention
(RUNTIME)
//指定验证器
@Constraint
(validatedBy = CheckPasswordValidator.
class
)
@Documented
public
@interface
CheckPassword {
//默认错误消息
String message()
default
""
;
//分组
Class[] groups()
default
{ };
//负载
Class
//指定多个时使用
@Target
({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })
@Retention
(RUNTIME)
@Documented
@interface
List {
CheckPassword[] value();
}
}
|
6.2、 定义验证器