SpringMvc切面校验JavaBean及基础类型

先配置好aop需要的配置，文：https://www.cnblogs.com/jiangxishicheng/p/10896498.html

编写校验切面类：

package com.aspect;/**
 * Description:
 *
 * @Author: dab0
 * Version: 1.0
 * Create Date Time: 2019/5/20 10:29
 * Update Date Time:
 * @see
 */

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.hibernate.validator.internal.engine.path.PathImpl;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.stereotype.Component;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.ObjectError;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import javax.validation.executable.ExecutableValidator;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Set;

/**
 * @author: dab0
 * @date:2019/5/20
 * @package:com.aspect
 **/
@Component
@Aspect
public class ValidAspect {
    private ObjectError error;

    @Pointcut("execution(public * com.controller.*.*(..))")
    public void valid() {

    }

    /**
     * 环绕上面的valid方法切入的controller包下面的所有类方法
     * 环绕通知,环绕增强，相当于MethodInterceptor
     * @param pjp
     * @return
     */
    @Around("valid()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("方法环绕start......");
        Object[] objects = pjp.getArgs();
        System.out.println("------arg objects：" + objects);
        if (objects.length <= 0) {
            return pjp.proceed();
        }
//        校验封装好的javabean
//        寻找带BindingResult参数的方法，然后判断是否有error，如果有则是校验不通过
        for (Object object : objects) {
            if (object instanceof BeanPropertyBindingResult) {
                BeanPropertyBindingResult result = (BeanPropertyBindingResult) object;
                if (result.hasErrors()) {
                    List<ObjectError> errorList = result.getAllErrors();
                    for (ObjectError objectError : errorList) {
                        System.out.println(objectError.getCode() + "：" + objectError.getDefaultMessage());
                    }
//                    返回第一条
                    return errorList.get(0).getDefaultMessage();
                }
            }
        }

//        校验普通类型参数
//        //  获得切入目标对象
        Object target = pjp.getThis();
//           获得切入的方法
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
//        执行校验，获得校验结果
        Set<ConstraintViolation<Object>> validResult = validMethodParams(target, method, objects);
//        如果有校验不通过的
        if (!validResult.isEmpty()) {
            // 获得方法的参数名称
            String[] parameterNames = parameterNameDiscoverer.getParameterNames(method);
            for (ConstraintViolation<Object> violation : validResult) {
//                获得校验的参数路径信息
                PathImpl pathImpl = (PathImpl) violation.getPropertyPath();
                if (pathImpl == null) {
                    System.out.println("------sorry pathImpl is null.");
                }
                System.out.println("------pathImpl：" + pathImpl.getLeafNode());
//                获得校验的参数位置
                Integer paramIndex = pathImpl.getLeafNode().getParameterIndex();
                if (paramIndex == null) {
                    System.out.println("------sorry paramIndex is null.");
                }
//                获得校验的参数名称
                String paramName = parameterNames[paramIndex];

                System.out.println("---------普通类型参数校验  参数名：" + paramName);
                System.out.println("---------校验信息：" + violation.getMessage());
            }
//            返回第一条
            return validResult.iterator().next().getMessage();
        }
        return null;
    }



    private ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
    private final ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    private final ExecutableValidator validator = factory.getValidator().forExecutables();


    private <T> Set<ConstraintViolation<T>> validMethodParams(T obj, Method method, Object[] params) {
        return validator.validateParameters(obj, method, params);
    }

}

本文摘于： https://blog.csdn.net/tianyaleixiaowu/article/details/71173059