AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2016-04-04 2685
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： <p>Bean Validation 1.1当前实现是Hibernate validator 5，且spring4才支持。接下来我们从以下几个方法讲解Bean Validation 1.1，当然不一定是新特性：</p> <ol style="font-size:14px"><li> 集成Bean Validation 1.1到SpringMVC</li><li> 分组验证、分组顺序及

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依赖：

Java代码   收藏代码
  1. <dependency>  
  2.     <groupId>org.hibernate</groupId>  
  3.     <artifactId>hibernate-validator</artifactId>  
  4.     <version>5.0.2.Final</version>  
  5. </dependency>  

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

Java代码   收藏代码
  1. <dependency>  
  2.     <groupId>javax.el</groupId>  
  3.     <artifactId>javax.el-api</artifactId>  
  4.     <version>2.2.4</version>  
  5.     <scope>provided</scope>  
  6. </dependency>  

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

 

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

 

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

Java代码   收藏代码
  1. <!-- 指定自己定义的validator -->  
  2. <mvc:annotation-driven validator="validator"/>  
  3.   
  4. <!-- 以下 validator  ConversionService 在使用 mvc:annotation-driven 会 自动注册-->  
  5. <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">  
  6.     <property name="providerClass" value="org.hibernate.validator.HibernateValidator"/>  
  7.     <!-- 如果不加默认到 使用classpath下的 ValidationMessages.properties -->  
  8.     <property name="validationMessageSource" ref="messageSource"/>  
  9. </bean>  
  10.   
  11. <!-- 国际化的消息资源文件（本系统中主要用于显示/错误消息定制） -->  
  12. <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">  
  13.     <property name="basenames">  
  14.         <list>  
  15.             <!-- 在web环境中一定要定位到classpath 否则默认到当前web应用下找  -->  
  16.             <value>classpath:messages</value>  
  17.             <value>classpath:org/hibernate/validator/ValidationMessages</value>  
  18.         </list>  
  19.     </property>  
  20.     <property name="useCodeAsDefaultMessage" value="false"/>  
  21.     <property name="defaultEncoding" value="UTF-8"/>  
  22.     <property name="cacheSeconds" value="60"/>  
  23. </bean>  

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

 

1.3、实体验证注解：

Java代码   收藏代码
  1. public class User implements Serializable {  
  2.     @NotNull(message = "{user.id.null}")  
  3.     private Long id;  
  4.   
  5.     @NotEmpty(message = "{user.name.null}")  
  6.     @Length(min = 5, max = 20, message = "{user.name.length.illegal}")  
  7.     @Pattern(regexp = "[a-zA-Z]{5,20}", message = "{user.name.illegal}")  
  8.     private String name;  
  9.   
  10.     @NotNull(message = "{user.password.null}")  
  11.     private String password;  
  12. }  

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

 

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

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

 

1.5、控制器

Java代码   收藏代码
  1. @Controller  
  2. public class UserController {  
  3.   
  4.     @RequestMapping("/save")  
  5.     public String save(@Valid User user, BindingResult result) {  
  6.         if(result.hasErrors()) {  
  7.             return "error";  
  8.         }  
  9.         return "success";  
  10.     }  
  11. }  

 

1.6、错误页面：

Java代码   收藏代码
  1. <spring:hasBindErrors name="user">  
  2.     <c:if test="${errors.fieldErrorCount > 0}">  
  3.         字段错误：<br/>  
  4.         <c:forEach items="${errors.fieldErrors}" var="error">  
  5.             <spring:message var="message" code="${error.code}" arguments="${error.arguments}" text="${error.defaultMessage}"/>  
  6.             ${error.field}------${message}<br/>  
  7.         </c:forEach>  
  8.     </c:if>  
  9.   
  10.     <c:if test="${errors.globalErrorCount > 0}">  
  11.         全局错误：<br/>  
  12.         <c:forEach items="${errors.globalErrors}" var="error">  
  13.             <spring:message var="message" code="${error.code}" arguments="${error.arguments}" text="${error.defaultMessage}"/>  
  14.             <c:if test="${not empty message}">  
  15.                 ${message}<br/>  
  16.             </c:if>  
  17.         </c:forEach>  
  18.     </c:if>  
  19. </spring:hasBindErrors>  

 

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

 

1.7、测试

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

Java代码   收藏代码
  1. name------用户名必须是字母  
  2. name------用户名长度必须在5到20之间  
  3. password------密码不能为空  
  4. id------用户编号不能为空  

 

基本的集成就完成了。

 

如上测试有几个小问题：

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

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

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

接下来我们挨着试试吧。

 

2、分组验证及分组顺序

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

首先定义分组接口：

Java代码   收藏代码
  1. public interface First {  
  2. }  
  3.   
  4. public interface Second {  
  5. }  

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

 

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

Java代码   收藏代码
  1. public class User implements Serializable {  
  2.   
  3.     @NotNull(message = "{user.id.null}", groups = {First.class})  
  4.     private Long id;  
  5.   
  6.     @Length(min = 5, max = 20, message = "{user.name.length.illegal}", groups = {Second.class})  
  7.     @Pattern(regexp = "[a-zA-Z]{5,20}", message = "{user.name.illegal}", groups = {Second.class})  
  8.     private String name;  
  9.   
  10.     @NotNull(message = "{user.password.null}", groups = {First.class, Second.class})  
  11.     private String password;  
  12. }  

 

验证时使用如：

Java代码   收藏代码
  1. @RequestMapping("/save")  
  2. public String save(@Validated({Second.class}) User user, BindingResult result) {  
  3.     if(result.hasErrors()) {  
  4.         return "error";  
  5.     }  
  6.     return "success";  
  7. }  

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

 

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

 

Java代码   收藏代码
  1. @GroupSequence({First.class, Second.class, User.class})  
  2. public class User implements Serializable {  
  3.     private Long id;  
  4.   
  5.     @Length(min = 5, max = 20, message = "{user.name.length.illegal}", groups = {First.class})  
  6.     @Pattern(regexp = "[a-zA-Z]{5,20}", message = "{user.name.illegal}", groups = {Second.class})  
  7.     private String name;  
  8.       
  9.     private String password;  
  10. }  

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

 

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

如：

Java代码   收藏代码
  1. public class User {  
  2.   
  3.     @Valid   
  4.     @ConvertGroup(from=First.class, to=Second.class)  
  5.     private Organization o;  
  6.   
  7. }  

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

 

3、消息中使用EL表达式

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

 

如：

Java代码   收藏代码
  1. @Length(min = 5, max = 20, message = "{user.name.length.illegal}", groups = {First.class})  

错误消息：

Java代码   收藏代码
  1. user.name.length.illegal=用户名长度必须在{min}到{max}之间  

 

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

 

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

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

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

 

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

Java代码   收藏代码
  1. ${formatter.format("%04d", min)}  

 

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

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

 

5、自定义验证规则

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

 

1、定义验证注解

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. import javax.validation.Constraint;  
  4. import javax.validation.Payload;  
  5. import java.lang.annotation.Documented;  
  6. import java.lang.annotation.Retention;  
  7. import java.lang.annotation.Target;  
  8. import static java.lang.annotation.ElementType.*;  
  9. import static java.lang.annotation.RetentionPolicy.*;  
  10. /** 
  11.  * <p>User: Zhang Kaitao 
  12.  * <p>Date: 13-12-15 
  13.  * <p>Version: 1.0 
  14.  */  
  15.   
  16. @Target({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })  
  17. @Retention(RUNTIME)  
  18. //指定验证器  
  19. @Constraint(validatedBy = ForbiddenValidator.class)  
  20. @Documented  
  21. public @interface Forbidden {  
  22.   
  23.     //默认错误消息  
  24.     String message() default "{forbidden.word}";  
  25.   
  26.     //分组  
  27.     Class<?>[] groups() default { };  
  28.   
  29.     //负载  
  30.     Class<? extends Payload>[] payload() default { };  
  31.   
  32.     //指定多个时使用  
  33.     @Target({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })  
  34.     @Retention(RUNTIME)  
  35.     @Documented  
  36.     @interface List {  
  37.         Forbidden[] value();  
  38.     }  
  39. }  

 

2、 定义验证器

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorContextImpl;  
  4. import org.springframework.beans.factory.annotation.Autowired;  
  5. import org.springframework.context.ApplicationContext;  
  6. import org.springframework.util.StringUtils;  
  7.   
  8. import javax.validation.ConstraintValidator;  
  9. import javax.validation.ConstraintValidatorContext;  
  10. import java.io.Serializable;  
  11.   
  12. /** 
  13.  * <p>User: Zhang Kaitao 
  14.  * <p>Date: 13-12-15 
  15.  * <p>Version: 1.0 
  16.  */  
  17. public class ForbiddenValidator implements ConstraintValidator<Forbidden, String> {  
  18.   
  19.     private String[] forbiddenWords = {"admin"};  
  20.   
  21.     @Override  
  22.     public void initialize(Forbidden constraintAnnotation) {  
  23.         //初始化，得到注解数据  
  24.     }  
  25.   
  26.     @Override  
  27.     public boolean isValid(String value, ConstraintValidatorContext context) {  
  28.         if(StringUtils.isEmpty(value)) {  
  29.             return true;  
  30.         }  
  31.   
  32.         for(String word : forbiddenWords) {  
  33.             if(value.contains(word)) {  
  34.                 return false;//验证失败  
  35.             }  
  36.         }  
  37.         return true;  
  38.     }  
  39. }  

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

 

3、使用

Java代码   收藏代码
  1. public class User implements Serializable {  
  2.     @Forbidden()  
  3.     private String name;  
  4. }  

 

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

Java代码   收藏代码
  1. forbidden.word=您输入的数据中有非法关键词  

 

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

Java代码   收藏代码
  1. private Map<String, Object> buildAnnotationParameterMap(Annotation annotation) {  
  2.     ……  
  3.     //将Collections.unmodifiableMap( parameters );替换为如下语句  
  4.     return parameters;  
  5. }  

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

Java代码   收藏代码
  1. for(String word : forbiddenWords) {  
  2.     if(value.contains(word)) {  
  3.         ((ConstraintValidatorContextImpl)context).getConstraintDescriptor().getAttributes().put("word", word);  
  4.         return false;//验证失败  
  5.     }  
  6. }  

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

Java代码   收藏代码
  1. forbidden.word=您输入的数据中有非法关键词【{word}】  

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

 

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

 

6、类级别验证器

6.1、定义验证注解

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. import javax.validation.Constraint;  
  4. import javax.validation.Payload;  
  5. import javax.validation.constraints.NotNull;  
  6. import java.lang.annotation.Documented;  
  7. import java.lang.annotation.Retention;  
  8. import java.lang.annotation.Target;  
  9. import static java.lang.annotation.ElementType.*;  
  10. import static java.lang.annotation.RetentionPolicy.*;  
  11. /** 
  12.  * <p>User: Zhang Kaitao 
  13.  * <p>Date: 13-12-15 
  14.  * <p>Version: 1.0 
  15.  */  
  16.   
  17. @Target({ TYPE, ANNOTATION_TYPE})  
  18. @Retention(RUNTIME)  
  19. //指定验证器  
  20. @Constraint(validatedBy = CheckPasswordValidator.class)  
  21. @Documented  
  22. public @interface CheckPassword {  
  23.   
  24.     //默认错误消息  
  25.     String message() default "";  
  26.   
  27.     //分组  
  28.     Class<?>[] groups() default { };  
  29.   
  30.     //负载  
  31.     Class<? extends Payload>[] payload() default { };  
  32.   
  33.     //指定多个时使用  
  34.     @Target({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })  
  35.     @Retention(RUNTIME)  
  36.     @Documented  
  37.     @interface List {  
  38.         CheckPassword[] value();  
  39.     }  
  40. }  

6.2、 定义验证器

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. import com.sishuok.spring4.entity.User;  
  4. import org.springframework.util.StringUtils;  
  5.   
  6. import javax.validation.ConstraintValidator;  
  7. import javax.validation.ConstraintValidatorContext;  
  8.   
  9. /** 
  10.  * <p>User: Zhang Kaitao 
  11.  * <p>Date: 13-12-15 
  12.  * <p>Version: 1.0 
  13.  */  
  14. public class CheckPasswordValidator implements ConstraintValidator<CheckPassword, User> {  
  15.   
  16.     @Override  
  17.     public void initialize(CheckPassword constraintAnnotation) {  
  18.     }  
  19.   
  20.     @Override  
  21.     public boolean isValid(User user, ConstraintValidatorContext context) {  
  22.         if(user == null) {  
  23.             return true;  
  24.         }  
  25.   
  26.         //没有填密码  
  27.         if(!StringUtils.hasText(user.getPassword())) {  
  28.             context.disableDefaultConstraintViolation();  
  29.             context.buildConstraintViolationWithTemplate("{password.null}")  
  30.                     .addPropertyNode("password")  
  31.                     .addConstraintViolation();  
  32.             return false;  
  33.         }  
  34.   
  35.         if(!StringUtils.hasText(user.getConfirmation())) {  
  36.             context.disableDefaultConstraintViolation();  
  37.             context.buildConstraintViolationWithTemplate("{password.confirmation.null}")  
  38.                     .addPropertyNode("confirmation")  
  39.                     .addConstraintViolation();  
  40.             return false;  
  41.         }  
  42.   
  43.         //两次密码不一样  
  44.         if (!user.getPassword().trim().equals(user.getConfirmation().trim())) {  
  45.             context.disableDefaultConstraintViolation();  
  46.             context.buildConstraintViolationWithTemplate("{password.confirmation.error}")  
  47.                     .addPropertyNode("confirmation")  
  48.                     .addConstraintViolation();  
  49.             return false;  
  50.         }  
  51.         return true;  
  52.     }  
  53. }  

其中我们通过disableDefaultConstraintViolation禁用默认的约束；然后通过buildConstraintViolationWithTemplate(消息模板)/addPropertyNode(所属属性)/addConstraintViolation定义我们自己的约束。

 

6.3、使用

Java代码   收藏代码
  1. @CheckPassword()  
  2. public class User implements Serializable {  
  3. }  

 放到类头上即可。

 

7、通过脚本验证

Java代码   收藏代码
  1. @ScriptAssert(script = "_this.password==_this.confirmation", lang = "javascript", alias = "_this", message = "{password.confirmation.error}")  
  2. public class User implements Serializable {  
  3. }  

通过脚本验证是非常简单而且强大的，lang指定脚本语言（请参考javax.script.ScriptEngineManager JSR-223），alias是在脚本验证中User对象的名字，但是大家会发现一个问题：错误消息怎么显示呢？ 在springmvc 中会添加到全局错误消息中，这肯定不是我们想要的，我们改造下吧。

 

7.1、定义验证注解

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. import org.hibernate.validator.internal.constraintvalidators.ScriptAssertValidator;  
  4.   
  5. import java.lang.annotation.Documented;  
  6. import java.lang.annotation.Retention;  
  7. import java.lang.annotation.Target;  
  8. import javax.validation.Constraint;  
  9. import javax.validation.Payload;  
  10.   
  11. import static java.lang.annotation.ElementType.TYPE;  
  12. import static java.lang.annotation.RetentionPolicy.RUNTIME;  
  13.   
  14. @Target({ TYPE })  
  15. @Retention(RUNTIME)  
  16. @Constraint(validatedBy = {PropertyScriptAssertValidator.class})  
  17. @Documented  
  18. public @interface PropertyScriptAssert {  
  19.   
  20.     String message() default "{org.hibernate.validator.constraints.ScriptAssert.message}";  
  21.   
  22.     Class<?>[] groups() default { };  
  23.   
  24.     Class<? extends Payload>[] payload() default { };  
  25.   
  26.     String lang();  
  27.   
  28.     String script();  
  29.   
  30.     String alias() default "_this";  
  31.   
  32.     String property();  
  33.   
  34.     @Target({ TYPE })  
  35.     @Retention(RUNTIME)  
  36.     @Documented  
  37.     public @interface List {  
  38.         PropertyScriptAssert[] value();  
  39.     }  
  40. }  

和ScriptAssert没什么区别，只是多了个property用来指定出错后给实体的哪个属性。

 

7.2、验证器

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. import javax.script.ScriptException;  
  4. import javax.validation.ConstraintDeclarationException;  
  5. import javax.validation.ConstraintValidator;  
  6. import javax.validation.ConstraintValidatorContext;  
  7.   
  8. import com.sishuok.spring4.validator.PropertyScriptAssert;  
  9. import org.hibernate.validator.constraints.ScriptAssert;  
  10. import org.hibernate.validator.internal.util.Contracts;  
  11. import org.hibernate.validator.internal.util.logging.Log;  
  12. import org.hibernate.validator.internal.util.logging.LoggerFactory;  
  13. import org.hibernate.validator.internal.util.scriptengine.ScriptEvaluator;  
  14. import org.hibernate.validator.internal.util.scriptengine.ScriptEvaluatorFactory;  
  15.   
  16. import static org.hibernate.validator.internal.util.logging.Messages.MESSAGES;  
  17.   
  18. public class PropertyScriptAssertValidator implements ConstraintValidator<PropertyScriptAssert, Object> {  
  19.   
  20.     private static final Log log = LoggerFactory.make();  
  21.   
  22.     private String script;  
  23.     private String languageName;  
  24.     private String alias;  
  25.     private String property;  
  26.     private String message;  
  27.   
  28.     public void initialize(PropertyScriptAssert constraintAnnotation) {  
  29.         validateParameters( constraintAnnotation );  
  30.   
  31.         this.script = constraintAnnotation.script();  
  32.         this.languageName = constraintAnnotation.lang();  
  33.         this.alias = constraintAnnotation.alias();  
  34.         this.property = constraintAnnotation.property();  
  35.         this.message = constraintAnnotation.message();  
  36.     }  
  37.   
  38.     public boolean isValid(Object value, ConstraintValidatorContext constraintValidatorContext) {  
  39.   
  40.         Object evaluationResult;  
  41.         ScriptEvaluator scriptEvaluator;  
  42.   
  43.         try {  
  44.             ScriptEvaluatorFactory evaluatorFactory = ScriptEvaluatorFactory.getInstance();  
  45.             scriptEvaluator = evaluatorFactory.getScriptEvaluatorByLanguageName( languageName );  
  46.         }  
  47.         catch ( ScriptException e ) {  
  48.             throw new ConstraintDeclarationException( e );  
  49.         }  
  50.   
  51.         try {  
  52.             evaluationResult = scriptEvaluator.evaluate( script, value, alias );  
  53.         }  
  54.         catch ( ScriptException e ) {  
  55.             throw log.getErrorDuringScriptExecutionException( script, e );  
  56.         }  
  57.   
  58.         if ( evaluationResult == null ) {  
  59.             throw log.getScriptMustReturnTrueOrFalseException( script );  
  60.         }  
  61.         if ( !( evaluationResult instanceof Boolean ) ) {  
  62.             throw log.getScriptMustReturnTrueOrFalseException(  
  63.                     script,  
  64.                     evaluationResult,  
  65.                     evaluationResult.getClass().getCanonicalName()  
  66.             );  
  67.         }  
  68.   
  69.         if(Boolean.FALSE.equals(evaluationResult)) {  
  70.             constraintValidatorContext.disableDefaultConstraintViolation();  
  71.             constraintValidatorContext  
  72.                     .buildConstraintViolationWithTemplate(message)  
  73.                     .addPropertyNode(property)  
  74.                     .addConstraintViolation();  
  75.         }  
  76.   
  77.         return Boolean.TRUE.equals( evaluationResult );  
  78.     }  
  79.   
  80.     private void validateParameters(PropertyScriptAssert constraintAnnotation) {  
  81.         Contracts.assertNotEmpty( constraintAnnotation.script(), MESSAGES.parameterMustNotBeEmpty( "script" ) );  
  82.         Contracts.assertNotEmpty( constraintAnnotation.lang(), MESSAGES.parameterMustNotBeEmpty( "lang" ) );  
  83.         Contracts.assertNotEmpty( constraintAnnotation.alias(), MESSAGES.parameterMustNotBeEmpty( "alias" ) );  
  84.         Contracts.assertNotEmpty( constraintAnnotation.property(), MESSAGES.parameterMustNotBeEmpty( "property" ) );  
  85.         Contracts.assertNotEmpty( constraintAnnotation.message(), MESSAGES.parameterMustNotBeEmpty( "message" ) );  
  86.     }  
  87. }  

和之前的类级别验证器类似，就不多解释了，其他代码全部拷贝自org.hibernate.validator.internal.constraintvalidators.ScriptAssertValidator。

 

7.3、使用

Java代码   收藏代码
  1. @PropertyScriptAssert(property = "confirmation", script = "_this.password==_this.confirmation", lang = "javascript", alias = "_this", message = "{password.confirmation.error}")  

和之前的区别就是多了个property，用来指定出错时给哪个字段。 这个相对之前的类级别验证器更通用一点。

 

8、cross-parameter，跨参数验证

直接看示例；

 

8.1、首先注册MethodValidationPostProcessor，起作用请参考《Spring3.1 对Bean Validation规范的新支持(方法级别验证) 》 

Java代码   收藏代码
  1. <bean class="org.springframework.validation.beanvalidation.MethodValidationPostProcessor">  
  2.     <property name="validator" ref="validator"/>  
  3. </bean>  

 

8.2、Service 

Java代码   收藏代码
  1. @Validated  
  2. @Service  
  3. public class UserService {  
  4.   
  5.     @CrossParameter  
  6.     public void changePassword(String password, String confirmation) {  
  7.   
  8.     }  
  9. }  

通过@Validated注解UserService表示该类中有需要进行方法参数/返回值验证；   @CrossParameter注解方法表示要进行跨参数验证；即验证password和confirmation是否相等。

 

8.3、验证注解 

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. //省略import  
  4.   
  5. @Constraint(validatedBy = CrossParameterValidator.class)  
  6. @Target({ METHOD, CONSTRUCTOR, ANNOTATION_TYPE })  
  7. @Retention(RUNTIME)  
  8. @Documented  
  9. public @interface CrossParameter {  
  10.   
  11.     String message() default "{password.confirmation.error}";  
  12.     Class<?>[] groups() default { };  
  13.     Class<? extends Payload>[] payload() default { };  
  14.   
  15. }  

 

8.4、验证器 

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. //省略import  
  4.   
  5. @SupportedValidationTarget(ValidationTarget.PARAMETERS)  
  6. public class CrossParameterValidator implements ConstraintValidator<CrossParameter, Object[]> {  
  7.   
  8.     @Override  
  9.     public void initialize(CrossParameter constraintAnnotation) {  
  10.     }  
  11.   
  12.     @Override  
  13.     public boolean isValid(Object[] value, ConstraintValidatorContext context) {  
  14.         if(value == null || value.length != 2) {  
  15.             throw new IllegalArgumentException("must have two args");  
  16.         }  
  17.         if(value[0] == null || value[1] == null) {  
  18.             return true;  
  19.         }  
  20.         if(value[0].equals(value[1])) {  
  21.             return true;  
  22.         }  
  23.         return false;  
  24.     }  
  25. }  

其中@SupportedValidationTarget(ValidationTarget.PARAMETERS)表示验证参数； value将是参数列表。 

 

8.5、使用

Java代码   收藏代码
  1. @RequestMapping("/changePassword")  
  2. public String changePassword(  
  3.         @RequestParam("password") String password,  
  4.         @RequestParam("confirmation") String confirmation, Model model) {  
  5.     try {  
  6.         userService.changePassword(password, confirmation);  
  7.     } catch (ConstraintViolationException e) {  
  8.         for(ConstraintViolation violation : e.getConstraintViolations()) {  
  9.             System.out.println(violation.getMessage());  
  10.         }  
  11.     }  
  12.     return "success";  
  13. }  

调用userService.changePassword方法，如果验证失败将抛出ConstraintViolationException异常，然后得到ConstraintViolation，调用getMessage即可得到错误消息；然后到前台显示即可。

 

从以上来看，不如之前的使用方便，需要自己对错误消息进行处理。 下一节我们也写个脚本方式的跨参数验证器。

 

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

9.1、验证注解

Java代码   收藏代码
  1. package com.sishuok.spring4.validator;  
  2.   
  3. //省略import  
  4.   
  5. @Constraint(validatedBy = {  
  6.         CrossParameterScriptAssertClassValidator.class,  
  7.         CrossParameterScriptAssertParameterValidator.class  
  8. })  
  9. @Target({ TYPE, FIELD, PARAMETER, METHOD, CONSTRUCTOR, ANNOTATION_TYPE })  
  10. @Retention(RUNTIME)  
  11. @Documented  
  12. public @interface CrossParameterScriptAssert {  
  13.     String message() default "error";  
  14.     Class<?>[] groups() default { };  
  15.     Class<? extends Payload>[] payload() default { };  
  16.     String script();  
  17.     String lang();  
  18.     String alias() default "_this";  
  19.     String property() default "";  
  20.     ConstraintTarget validationAppliesTo() default ConstraintTarget.IMPLICIT;  
  21. }   

 

此处我们通过@Constraint指定了两个验证器，一个类级别的，一个跨参数的。validationAppliesTo指定为ConstraintTarget.IMPLICIT，表示隐式自动判断。

 

9.2、验证器

请下载源码查看

 

9.3、使用

9.3.1、类级别使用

Java代码   收藏代码
  1. @CrossParameterScriptAssert(property = "confirmation", script = "_this.password==_this.confirmation", lang = "javascript", alias = "_this", message = "{password.confirmation.error}")  

指定property即可，其他和之前的一样。

9.3.2、跨参数验证

Java代码   收藏代码
  1. @CrossParameterScriptAssert(script = "args[0] == args[1]", lang = "javascript", alias = "args", message = "{password.confirmation.error}")  
  2. public void changePassword(String password, String confirmation) {  
  3.   
  4. }  

通过args[0]==args[1] 来判断是否相等。

 

这样，我们的验证注解就自动适应两种验证规则了。  

 

10、组合验证注解 

有时候，可能有好几个注解需要一起使用，此时就可以使用组合验证注解

Java代码   收藏代码
  1. @Target({ FIELD})  
  2. @Retention(RUNTIME)  
  3. @Documented  
  4. @NotNull(message = "{user.name.null}")  
  5. @Length(min = 5, max = 20, message = "{user.name.length.illegal}")  
  6. @Pattern(regexp = "[a-zA-Z]{5,20}", message = "{user.name.length.illegal}")  
  7. @Constraint(validatedBy = { })  
  8. public @interface Composition {  
  9.     String message() default "";  
  10.     Class<?>[] groups() default { };  
  11.     Class<? extends Payload>[] payload() default { };  
  12. }  

这样我们验证时只需要：

Java代码   收藏代码
  1. @Composition()  
  2. private String name;  

简洁多了。 

 

11、本地化 

即根据不同的语言选择不同的错误消息显示。

1、本地化解析器

Java代码   收藏代码
  1. <bean id="localeResolver" class="org.springframework.web.servlet.i18n.CookieLocaleResolver">  
  2.     <property name="cookieName" value="locale"/>  
  3.     <property name="cookieMaxAge" value="-1"/>  
  4.     <property name="defaultLocale" value="zh_CN"/>  
  5. </bean>  

此处使用cookie存储本地化信息，当然也可以选择其他的，如Session存储。

 

2、设置本地化信息的拦截器

Java代码   收藏代码
  1. <mvc:interceptors>  
  2.     <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">  
  3.         <property name="paramName" value="language"/>  
  4.     </bean>  
  5. </mvc:interceptors>  

即请求参数中通过language设置语言。

 

3、消息文件

 

4、 浏览器输入

http://localhost:9080/spring4/changePassword?password=1&confirmation=2&language=en_US


转自：http://jinnianshilongnian.iteye.com/blog/1990081

文章标签：
Java
前端开发
Spring
数据安全/隐私保护
数据库连接
关键词：
Spring Bean
Spring集成
Spring特性
Spring Spring mvc
集成bean
jeanheo
目录
相关文章
喜欢猪猪
|
19天前
|
XML 安全 Java
深度探索Spring Context：框架式的Bean访问与企业级功能
【12月更文挑战第1天】
喜欢猪猪
33 1
龙大吉
|
2月前
|
Java API 数据库
Spring Boot框架因其简洁的配置、快速的启动特性及丰富的功能集而备受开发者青睐
本文通过在线图书管理系统案例，详细介绍如何使用Spring Boot构建RESTful API。从项目基础环境搭建、实体类与数据访问层定义，到业务逻辑实现和控制器编写，逐步展示了Spring Boot的简洁配置和强大功能。最后，通过Postman测试API，并介绍了如何添加安全性和异常处理，确保API的稳定性和安全性。
龙大吉
44 0
蓝易云
|
2天前
|
XML Java 数据格式
Spring容器Bean之XML配置方式
通过对以上内容的掌握，开发人员可以灵活地使用Spring的XML配置方式来管理应用程序的Bean，提高代码的模块化和可维护性。
蓝易云
17 6
路卿老师
|
4天前
|
XML Java 数据格式
🌱 深入Spring的心脏：Bean配置的艺术与实践 🌟
本文深入探讨了Spring框架中Bean配置的奥秘，从基本概念到XML配置文件的使用，再到静态工厂方式实例化Bean的详细步骤，通过实际代码示例帮助读者更好地理解和应用Spring的Bean配置。希望对你的Spring开发之旅有所助益。
路卿老师
30 3
互联网课堂
|
1月前
|
缓存 Java Spring
实战指南：四种调整 Spring Bean 初始化顺序的方案
本文探讨了如何调整 Spring Boot 中 Bean 的初始化顺序，以满足业务需求。文章通过四种方案进行了详细分析： 1. **方案一 (@Order)**：通过 `@Order` 注解设置 Bean 的初始化顺序，但发现 `@PostConstruct` 会影响顺序。 2. **方案二 (SmartInitializingSingleton)**：在所有单例 Bean 初始化后执行额外的初始化工作，但无法精确控制特定 Bean 的顺序。 3. **方案三 (@DependsOn)**：通过 `@DependsOn` 注解指定 Bean 之间的依赖关系，成功实现顺序控制，但耦合性较高。
互联网课堂
68 4
实战指南：四种调整 Spring Bean 初始化顺序的方案
WangBai
|
17天前
|
安全 Java 开发者
Spring容器中的bean是线程安全的吗?
Spring容器中的bean默认为单例模式，多线程环境下若操作共享成员变量，易引发线程安全问题。Spring未对单例bean做线程安全处理，需开发者自行解决。通常，Spring bean（如Controller、Service、Dao）无状态变化，故多为线程安全。若涉及线程安全问题，可通过编码或设置bean作用域为prototype解决。
WangBai
27 1
路卿老师
|
1月前
|
Java Kotlin 索引
学习Spring框架特性及jiar包下载
Spring 5作为最新版本，更新了JDK基线至8，修订了核心框架，增强了反射和接口功能，支持响应式编程及Kotlin语言，引入了函数式Web框架，并提升了测试功能。Spring框架可在其官网下载，包括文档、jar包和XML Schema文档，适用于Java SE和Java EE项目。
路卿老师
32 0
菜菜的后端私房菜
|
2月前
|
Java 测试技术 Windows
咦！Spring容器里为什么没有我需要的Bean？
【10月更文挑战第11天】项目经理给小菜分配了一个紧急需求，小菜迅速搭建了一个SpringBoot项目并完成了开发。然而，启动测试时发现接口404，原因是控制器包不在默认扫描路径下。通过配置`@ComponentScan`的`basePackages`字段，解决了问题。总结：`@SpringBootApplication`默认只扫描当前包下的组件，需要扫描其他包时需配置`@ComponentScan`。
菜菜的后端私房菜
17 2
余二五
|
Java 数据库连接 数据库
Hibernate与Spring集成示例
余二五
1185 0
最好zzz
|
2月前
|
人工智能 自然语言处理 前端开发
SpringBoot + 通义千问 + 自定义React组件：支持EventStream数据解析的技术实践
【10月更文挑战第7天】在现代Web开发中，集成多种技术栈以实现复杂的功能需求已成为常态。本文将详细介绍如何使用SpringBoot作为后端框架，结合阿里巴巴的通义千问（一个强大的自然语言处理服务），并通过自定义React组件来支持服务器发送事件（SSE, Server-Sent Events）的EventStream数据解析。这一组合不仅能够实现高效的实时通信，还能利用AI技术提升用户体验。
最好zzz
224 2

热门文章

最新文章

  • 1
    SpringMVC介绍之视图解析器ViewResolver
  • 2
    SpringMVC标签用法
  • 3
    02springmvc架构原理分析
  • 4
    SpringMVC多视图技术
  • 5
    Spring MVC 参数的绑定方法
  • 6
    JavaEE SpringMVC
  • 7
    springMVC初探--环境搭建和第一个HelloWorld简单项目
  • 8
    SOA中springmvc中restful服务的数据权限加密方式分享
  • 9
    SpringMVC控制器接收不了PUT提交的参数的解决方案
  • 10
    springmvc中@PathVariable和@RequestParam的区别
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    95
  • 2
    Spring Boot中一般如何使用线程池？
    753
  • 3
    Spring Boot 源码面试知识点
    101
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    253
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    105
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    350
  • 7
    springboot全局自定义异常
    44
  • 8
    RabbitMQ的springboot项目集成使用-01
    147
  • 9
    什么是Spring Boot 自动配置？
    60
  • 10
    Spring cloud原理详解
    79

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第四阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战

    • 相关电子书

    更多
  • 阿里邮箱—安全高效集成
  • 集成智能接入网关APP：优化企业级移动办公网络
  • 云效助力企业集成安全到DevOps中

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DataWorks