Bean Validation-2.0

最新推荐文章于 2022-07-07 14:57:02 发布
最新推荐文章于 2022-07-07 14:57:02 发布
阅读量452 收藏 1
点赞数 2
分类专栏： spring 文章标签： bean validation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guo_xl/article/details/97320596
版权
为什么会写?

最近项目中用到了校验，原来的校验逻辑都是在代码java里写死的，这样的坏处是代码没法重用,例如需要对下面的name和email做不为空的校验，age做必须在1-200的校验

public class User{
 private String name;
 private String email;
 private int age;
}

旧的逻辑就是在某个校验类里去判断

public class UserValidator{
 public boolean validate(User user){
 	if(user.getName()!=null){
 	  logError("user.name.isNull");
 	  return false;
 	}
 	if(user.getEmail()!=null){
 	  logError("user.email.isNull");
 	  return false;
 	} 	
 	if(user.getAge()<1){
 	  logError("user age less than 1");
 	  return false;
 	}
 	if(user.getAge()>200){
 	 logError("user age larger than 200");
 	  return false;
 	}
 	return true;
 }
}

可以从上面代码里看出!=null的逻辑基本是一样的，都是判读不为空后记录。这个代码不能复用，之前做过的springboot里使用到的对某个bean做validate，只需要在参数里加入
@Validate即可。查找了下springboot里的validate用的是JSR333:Bean Validation specification

对上面校验的改造

用bean Validation来对之前的代码做个简单demo如下

public class User {
   @NotNull(message = "email can not be null")
   private String email;
   
   @NotNull(message = "age can not be null")
   @Min(value = 1,message ="age can not less than 1" )
   @Max(value = 200,message ="age can not more than 200" )
   private  int age;
   
   @NotNull(message = "name can not be null")
   private String name;
}

public class demo {
    public static void main(String[] args) {
        User user=new User();        
        javax.validation.Validator beanValidator = Validation.buildDefaultValidatorFactory()
                .getValidator();
        Set<ConstraintViolation<User>> set=beanValidator.validate(user,Default.class);
       Iterator it=set.iterator();
       while(it.hasNext()){
           ConstraintViolation cv= (ConstraintViolation) it.next();
           System.out.println(cv.getMessage());
       }
    }
}

打印结果

name can not be null
email can not be null
age can not more than 200

以上就是简单的校验，是不是比单纯的写if…else 好多了

内置（build-in）的注解校验

上面的注解比如@NotNull ，@Min, @Max是validation包里已有的一些校验注解，其它的还有如下图：
在这里插入图片描述
比如上面的@Email, 我们就可以直接使用

   @NotNull(message = "email can not be null")
   @Email
   private String email;

校验不通过的话就会打印出

不是一个合法的电子邮件地址

自定义注解

当已经存在的校验注解不满足我们的需求时候，就需要客户化自己的注解

  • 需求1 ：假如User 里有个number,这个number是一个以某个值开头，例如CCC开头
Class User{
   //自定义注解
   @UserNumber(prefix="CCC")
   private String number;
   }

实现上面的@UserNumber 主要有2个类：
第一个类是注解即UserNumber ，如下

@Target({ FIELD}) 
@Retention(RUNTIME)
@Documented
//指定一个校验类
@Constraint(validatedBy = UserNumberConstraintValidator.class)
public @interface UserNumber {
    String message() default "{user.number.invalid}";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };
    String prefix();
}

注意 message() groups() payload() 这3个 方法必须存在

第2个类是校验的逻辑类，也就是上面指定的
@Constraint(validatedBy = UserNumberConstraintValidator.class)

UserNumberConstraintValidator

public class UserNumberConstraintValidator implements ConstraintValidator<UserNumber,String> {
    private String prefix;
    //真正的逻辑校验
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if(value==null)
            return false;
        return value.startsWith(prefix);
    }
    //初始化，这里可以获取到注解
    public void initialize(UserNumber constraintAnnotation) {
        this.prefix = constraintAnnotation.prefix();
    }
}

public class demo {
    public static void main(String[] args) {
        User user=new SubUser();
        user.setEmail("haha");
        user.setAge(230);
        user.setNumber("AAA");
        javax.validation.Validator beanValidator = Validation.buildDefaultValidatorFactory()
                .getValidator();
        Set<ConstraintViolation<User>> set=beanValidator.validate(user,Default.class);
       Iterator it=set.iterator();
       while(it.hasNext()){
           ConstraintViolation cv= (ConstraintViolation) it.next();
           System.out.println(cv.getMessage());
       }
    }
}

会打印出
{user.number.invalid}

以上就是简单的自定义注解的实现。这里最重要的类就是ConstraintValidator

public interface ConstraintValidator<A extends Annotation, T> {
	default void initialize(A constraintAnnotation) {
	}
	boolean isValid(T value, ConstraintValidatorContext context);
}

注意泛型的使用，A extends Annotation 必须是注解类，例如上面的UserNumber,T 表示的是被该注解标识的类，例如

@UserNumber(prefix="CCC")
   private String number;

T 就是String。如果将注解放到某个类上，那么T 就是那个类。

  • 需求2 ：假设增加当user.hasEmail为true的时候，才会去校验email ，user类定义如下
Class User{
   private boolean hasEmail;   
   private String email;
}

对于这种需求一般是写在user类上，比如定一个UserEmailValidator

@Target({ TYPE})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = UserEmailConstraintValidator.class)
public @interface UserEmailValidator {

    String message() default "{user.email.is.empty}";

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

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

逻辑校验类

public class UserEmailConstraintValidator implements ConstraintValidator<UserEmailValidator,User> {
    public boolean isValid(User user, ConstraintValidatorContext context) {
        if (user.isHasEmail()&& user.getEmail()==null) {
            return false;
        }
        return true;
    }
    public void initialize(UserEmailValidator constraintAnnotation) {
    }
}

写完后将注解放到类上。注解放到User上后，T就是User

@UserEmailValidator
public class User{}

public class demo {
    public static void main(String[] args) {
        User user=new User();
        user.setHasEmail(true);   //设成true而没有给email的话就会报错    
        javax.validation.Validator beanValidator = Validation.buildDefaultValidatorFactory()
                .getValidator();
        Set<ConstraintViolation<User>> set=beanValidator.validate(user,Default.class);
       Iterator it=set.iterator();
       while(it.hasNext()){
           ConstraintViolation cv= (ConstraintViolation) it.next();
           System.out.println(cv.getMessage());
       }
    }
}

结果会报错{user.email.is.empty}

注解放到类上的不足

上面的注解是为了校验email这个字段，这样的注释放到类上总觉的不是专门的地方，能否直接放到email 这个字段上，例如

  @UserEmailValidator
   private String email;

由于ConstraintValidator的方法isValid中的参数ConstraintValidatorContext 里拿不到email对应的类(User)

public boolean isValid(String value, ConstraintValidatorContext context) {
}

所以要想从context里获取到email，可以通过改源码来实现,主要是修改2个类

  • org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorContextImpl
    这个类是ConstraintValidatorContext的实现类，在这个类中，增加了Object rootbean，以及getter和setter方法，如下：
public class ConstraintValidatorContextImpl implements HibernateConstraintValidatorContext {
 private Object rootbean;
  public Object getRootbean() {
        return rootbean;
    }
    public void setRootbean(Object rootbean) {
        this.rootbean = rootbean;
    }
 }
  • org.hibernate.validator.internal.engine.constraintvalidation.SimpleConstraintTree
    这个类是构造出ConstraintValidatorContextImpl的地方，需要将rootbean塞值。
    注意下面//!!!的标注
package org.hibernate.validator.internal.engine.constraintvalidation;
class SimpleConstraintTree<B extends Annotation> extends ConstraintTree<B> {

    private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );

    public SimpleConstraintTree(ConstraintDescriptorImpl<B> descriptor, Type validatedValueType) {
        super( descriptor, validatedValueType );
    }

    @Override
    protected <T> void validateConstraints(ValidationContext<T> validationContext,
                                           ValueContext<?, ?> valueContext,
                                           Set<ConstraintViolation<T>> constraintViolations) {

        if ( LOG.isTraceEnabled() ) {
            LOG.tracef(
                    "Validating value %s against constraint defined by %s.",
                    valueContext.getCurrentValidatedValue(),
                    descriptor
            );
        }

        // find the right constraint validator
        ConstraintValidator<B, ?> validator = getInitializedConstraintValidator( validationContext, valueContext );

        // create a constraint validator context
        ConstraintValidatorContextImpl constraintValidatorContext = new ConstraintValidatorContextImpl(
                validationContext.getParameterNames(),
                validationContext.getClockProvider(),
                valueContext.getPropertyPath(),
                descriptor,
                validationContext.getConstraintValidatorPayload()
        );
        
//!!! 就是这行了，将valueContext.getCurrentBean()设置到context中
        constraintValidatorContext.setRootbean(valueContext.getCurrentBean());
        // validate
        constraintViolations.addAll(
                validateSingleConstraint(
                        validationContext,
                        valueContext,
                        constraintValidatorContext,
                        validator
                )
        );
    }
}

这样UserEmailConstraintValidator 就可以改成如下

public class UserEmailConstraintValidator implements ConstraintValidator<UserEmailValidator,String> {
       public boolean isValid(String  email, ConstraintValidatorContext context) {
        Object root=((ConstraintValidatorContextImpl)context).getRootbean();
        if(root instanceof User){
            User user=(User)root;
            if (user.isHasEmail()&& user.getEmail()==null) {
                return false;
            }else{
                return true;
            }
        }
        return false;
    }

    public void initialize(UserEmailValidator constraintAnnotation) {
    }
}
spring validator

对于某些校验只会有一次使用，并不需要复用。例如对于上面提要的email的依赖hasEmail为true的时候才进行校验。基本上不会是复用，对于这类的校验还需要去写个annotaion和validation的类就显得不太合适。因为我们写annotation的目的就是为了复用。对于这样的，还有一种就是使用spring提供的接口类：org.springframework.validation.Validator，注意区别于javax.validation.Validator

使用的时候放在controller里的 @InitBinder

@Controller
public class UserController{

    @RequestMapping("/user/save")
    public String save(@Valid @ModelAttribute("user") User user){
            return "user_detail";
    }

    
  @InitBinder
    protected void initBinder(WebDataBinder binder) {
        //binder里已经含有全局的BeanValidator提供的validator
        //这里可以再加如一个本地的validator
        binder.addValidators(new UserValidator());
    }

    static class UserValidator implements org.springframework.validation.Validator{
        public boolean supports(Class<?> clazz) {
            return User.class.isAssignableFrom(clazz);
        }

        public void validate(Object target, Errors errors) {
            User  user = (User) target;
            if (user.isHasEmail() && StringUtils.isEmpty(user.getMail())) {
                errors.reject("field.email.empty",
                        "the email can not empty");
            }
            ValidationUtils.rejectIfEmptyOrWhitespace(errors, "password", "field.required","password can not be empty");
        }
    }
 }

User 类

public class User{
 private boolean hasEmail;
 private String email;
 private String password;
}
xiao_long_guo
关注
专栏目录
深入剖析数据校验：Bean Validation 2.0
Java_JV的博客
07-23 555
QQ交流群：点击有任何问题可以加群交流 Java最新一线架构技术讲解请：点击 内容实用讲解简单易懂 前言 前几篇文章在讲Spring的数据绑定的时候，多次提到过数据校验。可能有人认为数据校验模块并不是那么的重要，因为硬编码都可以做。若是这么想的话，那就大错特错了~前面讲解DataBinder的时候一个小细节，它所在的包是：org.springframework.validation...
Hibernate Validator第5篇：校验Bean的约束
顽木芽的博客
10-16 297
Validator接口在Bean Validation中是很重要的一个对象。这篇文章将展示如何获得一个Validator实例，之后将介绍如何使用Validator接口中很多不同的方法。
Hibernate Bean Validation jar包
08-08
Bean Validation 规范对 Java Bean 的验证流程如下：在实际使用中调用 Validator.validate(JavaBeanInstance) 方法后，Bean Validation 会查找在 JavaBeanInstance上所有的约束声明，对每一个约束调用对应的约束验证器进行验证，最后的结果由约束验证器的 isValid 方法产生，如果该方法返回 true，则约束验证成功，否则验证失败。验证失败的约束将产生约束违规对象（ConstraintViolation 的实例）并放到约束违规列表中。验证完成后所有的验证失败信息均能在该列表中查找并输出。 前提条件 Bean Validation 规范规定在对 Java Bean 进行约束验证前，目标元素必须满足以下条件： 如果验证的是属性（getter 方法），那么必须遵从 Java Bean 的命名习惯（JavaBeans 规范）； 静态的字段和方法不能进行约束验证； 约束适用于接口和基类； 约束注解定义的目标元素可以是字段、属性或者类型等； 可以在类或者接口上使用约束验证，它将对该类或实现该接口的实例进行状态验证； 字段和属性均可以使用约束验证，但是不能将相同的约束重复声明在字段和相关属性（字段的 getter 方法）上。
java的Bean Validation 2.0
weixin_34363171的博客
05-06 528
2019独角兽企业重金招聘Python工程师标准>>> ...
JSR 303 - Bean Validation 介绍及最佳实践
GarfieldEr007的专栏
06-11 893
关于 Bean Validation 在任何时候，当你要处理一个应用程序的业务逻辑，数据校验是你必须要考虑和面对的事情。应用程序必须通过某种手段来确保输入进来的数据从语义上来讲是正确的。在通常的情况下，应用程序是分层的，不同的层由不同的开发人员来完成。很多时候同样的数据验证逻辑会出现在不同的层，这样就会导致代码冗余和一些管理的问题，比如说语义的一致性等。为了避免这样的情况发生，最好是将验证逻辑与相应的域模型进行绑定。 Bean Validation 为 JavaBean 验证定义了相应的元数据模型和 A
bean-validation-webapp-2.0-sources.jar
03-15
官方版本，亲测可用
bean-validation-webapp-2.0-m13-sources.jar
03-15
官方版本，亲测可用
bean-validation-webapp-2.0-m12-sources.jar
03-15
官方版本，亲测可用
bean-validation-webapp-2.0-m11-sources.jar
03-15
官方版本，亲测可用
bean-validation-webapp-2.0-m13-3-sources.jar
03-15
官方版本，亲测可用
bean-validator.jar 官方下载
11-17
bean-validator.jar 官方下载 字段验证
Bean Validation
GAMELOFT9----纸上得来终觉浅，绝知此事要躬行
08-15 824
         Bean的校验主要是校验Bean的属性是否满足给定的约束条件。具体实现方式有Hibernate Validator和Spring Validator，它们都是对validation-api的实现。这里主要介绍Hibernate Validator(Hibernate出品的一个校验框架，跟数据库没关系)，在Spring MVC的Controller参数校验时会结合用到Spring ...
使用ConstraintValidator自定义注解和校验器
进击的豌豆的博客
07-07 1214
在开发过程中，使用validation框架提供的注解大大降低了我们编码的复杂度，但是有一些需求需要我们自定义校验逻辑，比如用户名的唯一校验，这类需要查询数据库或者其他复杂的需求。然后我们又不想在业务代码中掺杂大量的if-else判断，这时候我们可以自定义注解，然后使用aop切面完成校验。 但是有更优雅的方式来做，就是实现ConstraintValidator接口。我们有一张用户表，现在需要开发其增、删、改、查的接口。对于增加的接口内有大量的校验，于是我们打算自定义校验接口实现。 使用mybatisplus生
springboot中@Vlidated注解校验源码
weixin_43401380的博客
09-12 1344
springboot中支持JSR-303校验规范,该规范的默认实现为hibernate,关于常用校验注解的使用参考:springboot中注解校验@Valid@Validated(亲测有效)_卖柴火的小伙子的博客-CSDN博客 本文重在原理,下面从常用的两种注解校验方式看一下源码原理. 1.请求对象参数注解 2.请求单个参数注解 此种实现方式是利用cglib动态代理获取动态获取方法拦截切面,主要逻辑在MethodVa...
实现ConstraintValidator完成自定义校验注解
weixin_44248000的博客
04-09 2693
一、导包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> 二、自定义注解类 此处我用一个非常简单的例子来说明，主要是看结构。 OnlyNumber ： /** * @Description: 只能包含数字，同时可以
自定义集合类型校验
wangdaoyin2010的专栏
05-14 978
在对集合校验的时候，通过对集合中每一个对象记性校验来完成集合校验 1、自定义一个校验注解类 import javax.validation.Constraint; import javax.validation.Payload; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.l
java系列之-自定义valid校验器
weinichendian的博客
12-27 2580
一、依赖包 <!-- https://mvnrepository.com/artifact/javax.validation/validation-api --> <dependency> <groupId>javax.validation</groupId> <artifactId>validation-api&lt...
java validator ip_自定义参数校验注解 （实现ConstraintValidator方法）
weixin_39763953的博客
02-16 682
Hibernate Validator常用注解(图网上找的) 2.自定义校验器a.注解类@Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE})@Retention(RUNTIME)@Documented@Constraint(validatedBy = PasswordValidator.class)public @interface Passwo...
Spring容器中获取 Bean 实例的七种方式
Java笔记虾
07-07 6148
点击关注公众号，利用碎片时间学习说明一、写作原因首先解释一下写这篇博文的原因，因为在使用spring框架的过程中获取bean是非常常见的操作，但是网上非常的博文大多承自一家之言，因此很多可操作性上并不强，本文是通过自己实战，亲自尝试之后提供的几种方案，供大家一起学习探讨。二、源码出处本文提供的测试代码为chapter-1-springmvc-quickstart中的单元测...
JSF 2.0核心技术：Facelets, Conversion与Validation
验证是JSF中的关键特性，它利用JSR 303（Bean Validation框架）实现。可以在页面级别和组件级别进行验证，确保用户输入的数据符合预定义的规则。如果数据无效，JSF会显示错误消息。例如，可以在`page.xhtml`中定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值