spring method validation的优化【自己动手实现校验切面】

浅浅的花香味﹌ 2022-04-13 14:30 148阅读 0赞

建议首先阅读笔者的[Spring method validation的不足][Spring method validation]

在【Spring method validation的不足】的文章中，笔者提出了如下问题：

*  spring method validation 不支持方法对象视图的校验；
 *  校验过程没有对应的快速失败机制。

## 解决方案：实现自己的MethodValidationAspect ##

#### 步骤1：自定义@EnableValidation注解 ####

/**
     * @author Te
     * @date created at 2018/11/29
     */
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    public @interface EnableValidation {
    
        @AliasFor("groups")
        Class<?>[] value() default {};
    
        /**
         * validation groups
         *
         * @return groups default {}
         */
        @AliasFor("value")
        Class<?>[] groups() default {};
    }

自定义EnableValidation注解，该注解可以应用在类或者方法层级，标注在类上表示校验类下的所有方法，标注在方法上表示仅对该方法进行校验。  
其中groups表示执行方法校验时的**校验组**。  
同时该注解标注了@Inherited，表明该注解支持继承。

> 在这里简单说明下校验组的概念  
> **假设数据库有user表，有id和name属性。**  
> 如果对应的javabean中id和name属性都标注了对应的约束，比如@NotNull，那么在删除和新增操作的时候都会去校验两个属性是否为空。但是其实删除的时候我们只需要去校验id属性，新增的时候只需要校验name属性，那么上面就会出问题。这时候就可以使用校验组，进行分组校验。

具体可以参考如下代码：

//删除分组
    public interface DeleteGroup {
    }
    
    //新增分组
    public interface SaveGroup {
    }
    
    public class User{
    
    	@NotNull(groups = {DeleteGroup.class})
    	private Long id;
    	
    	@NotNull(groups = {SaveGroup.class})
    	private Long name;
    }

只需要在进行具体操作的时候指定对应的校验组就OK了，如下代码所示

public interface UserService{
    	//新增的时候使用SaveGroup的规范去校验
    	void save(@Validated(SaveGroup.class) User user);
    	//删除的时候使用DeleteGroup的规范去校验
    	void delete(@Validated(DeleteGroup.class) User user);
    }

#### 步骤2：自定义切面 ####

package com.mtdp.mtdp.aspect;
    
    import com.mtdp.mtdp.annotations.EnableValidation;
    import org.apache.commons.lang3.ArrayUtils;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.stereotype.Component;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
    
    import javax.validation.ConstraintViolation;
    import javax.validation.ConstraintViolationException;
    import javax.validation.Validator;
    import javax.validation.executable.ExecutableValidator;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * @author wangte
     * @date created at 2018/11/29
     */
    @Aspect
    @Component
    public class MethodValidationAspect implements InitializingBean {
    
        private final LocalValidatorFactoryBean localValidatorFactoryBean;
    
    
        private final Class<? extends Annotation> ANNOTATION_TYPE = EnableValidation.class;
    
        /**
         * javax validator
         */
        private Validator validator;
    
        @Autowired
        public MethodValidationAspect(LocalValidatorFactoryBean localValidatorFactoryBean) {
            this.localValidatorFactoryBean = localValidatorFactoryBean;
        }
    
        @Pointcut(value = "@annotation(com.mtdp.mtdp.annotations.EnableValidation)")
        private void methodLevelAnnotationPointcut() {
            //methodLevel pointcut,nothing to do
        }
    
        /**
         * with in annotation pointcut
         */
        @Pointcut(value = "@within(com.mtdp.mtdp.annotations.EnableValidation)")
        private void classLevelPointcut() {
            //classLevel pointcut,nothing to do
        }
    
        @Before(value = "methodLevelAnnotationPointcut() || classLevelPointcut()")
        public void before(JoinPoint joinPoint) {
            //1、获取方法参数列表
            Object[] args = joinPoint.getArgs();
    
            Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
            EnableValidation enableValidation = ((EnableValidation) obtainValidation(method));
    
            //2、获取校验组
            Class<?>[] methodValidationGroups = determineValidationGroups(enableValidation);
    
            //3、获取方法校验器
            ExecutableValidator executableValidator = validator.forExecutables();
    
            Set<ConstraintViolation<Object>> result = new HashSet<>();
    
            //4、只有在方法参数列表不为空的情况下才会去校验参数列表，如果方法参数列表为空，则没有必要执行方法参数的验证
            if (ArrayUtils.isNotEmpty(args)) {
                //4.1 首先进行方法级别的基本校验
                Set<ConstraintViolation<Object>> methodConstraintViolations = executableValidator.validateParameters(joinPoint.getThis(), method, args, methodValidationGroups);
                result.addAll(methodConstraintViolations);
    
                //4.2 进行方法Bean级别的校验
                Annotation[][] parameterAnnotations = method.getParameterAnnotations();
    
                if (ArrayUtils.isNotEmpty(parameterAnnotations)) {
                    for (int i = 0; i < parameterAnnotations.length; i++) {
                        //4.2.1 判断是否需要执行bean级别的校验
                        //校验标准：判断方法参数bean上是否标注了spring Validated注解
                        Annotation[] parameterAnnotation = parameterAnnotations[i];
                        for (Annotation annotation : parameterAnnotation) {
                            if (annotation.annotationType() == Validated.class) {
                                Class<?>[] beanValidationGroups = ((Validated) annotation).value();
    
                                if (args[i] == null) {
                                    continue;
                                }
                                //spring 4.x不支持容器级别Bean视图的校验，在这里只实现了基本Bean的校验，如果要实现容器级别Bean视图校验，可以抽出一个方法，判断bean的类型，如果是List，则校验List泛型中的元素，Set、Map、Optional等等，也是如此，这里读者可以自己实现
                                Set<ConstraintViolation<Object>> beanConstraintViolations = validator.validate(args[i], beanValidationGroups);
                                result.addAll(beanConstraintViolations);
                            }
                        }
                    }
                }
            }
    
            if (!result.isEmpty()) {
                throw new ConstraintViolationException(result);
            }
        }
    
        /**
         * 获取方法对应的校验组
         */
        private Class<?>[] determineValidationGroups(EnableValidation enableValidation) {
            Class<?>[] groups = enableValidation.groups();
            return ArrayUtils.isEmpty(groups) ? enableValidation.value() : groups;
        }
    
    
        @Override
        public void afterPropertiesSet() throws Exception {
        
           //如果通过Validation工厂方法获取到的validator，底层的validator是使用Hibernate validator进行反射创建，不归spring容器管理，不能在validator中使用依赖注入。
            //使用以下这种方式得到的validator可以进行spring的依赖注入。这种方式其实是将validator的创建交给spring创建管理而已。
            validator = localValidatorFactoryBean.getValidator();
        }
    
        private Annotation obtainValidation(Method method) {
            Annotation validatedAnn = AnnotationUtils.findAnnotation(method, ANNOTATION_TYPE);
            if (validatedAnn == null) {
                validatedAnn = AnnotationUtils.findAnnotation(method.getClass(), ANNOTATION_TYPE);
            }
            return validatedAnn;
        }
    }

[Spring method validation]: https://blog.csdn.net/wt_better/article/details/84636181