SpringMVC参数校验，包括JavaBean和基本类型的校验（转载）

参考博客： SpringMVC参数校验，包括JavaBean和基本类型的校验

---

一、spingmvc引入Hibernate Validator校验框架，参考地址：http://blog.csdn.net/menghuanzhiming/article/details/78059876

二、校验JavaBean

1、javaben的实体类注解校验：

package edu.hrbeu.platform.modeling.pojo;

import java.io.Serializable;
import javax.validation.constraints.Pattern;

import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;

public class User implements Serializable{
    private Integer userId;
    @NotEmpty
    @Pattern(regexp="^[A-Za-z\u4e00-\u9fa5]{2,10}$", message="登录名:2-10位以内中文或英文或数字")
    private String username;

    @NotEmpty
    @Pattern(regexp="^[A-Za-z\u4e00-\u9fa5]{2,10}$", message="用户名:2-10位以内中文或英文或数字")
    private String alias;

    @NotEmpty
    @Pattern(regexp="^(?=.*[a-z])(?=.*[A-Z])[a-zA-Z\\d]{6,18}$", message="密码:6-18位以内数字和字母，至少各一个大小写字母")
    private String password;

    @NotEmpty
    @Email
    private String email;

    @NotEmpty
    @Pattern(regexp="^1[0-9]{10}$", message="手机号:11位以内中国大陆手机号")
    private String phone;   
}

2、javaben定义了注解校验等标签后，结合在Controller里使用@Valid和BindingResult即可完成参数的校验。
譬如registerUser方法里，只需要加上@Valid标签即可完成校验。如果校验不通过，那么错误信息就会封装到BindingResult对象了，可以通过bindingResult的相关方法获取详细的错误信息并返回给用户。
如果不加BindingResult则会抛出异常。
此时即可完成表单类，或者用户注册之类的类似请求的参数校验了，可以选择获取bindingResult信息后直接return给用户。如果这样的需要校验的地方比较多，每个都单独处理比较麻烦，可以通过aop统一处理返回，后面会讲到。
校验的标签可参考：http://blog.csdn.net/catoop/article/details/51278675
相关文章：http://412887952-qq-com.iteye.com/blog/2312356

/**
     * 
    * @Title: RegisterUser
    * @Description: TODO(用户注册)
    * @return Map<String,Object>    返回类型
    * @return
     */
    @RequestMapping("registerUser")
    @ResponseBody
    @Operationlog(desc="用户注册")
    public Map<String, Object> registerUser(
            @Valid 
            User user, 
            BindingResult bindingResult
            ) {
        while(bindingResult.hasErrors()) {
            System.out.println("没有通过校验");
            return null;
        }
        return null;
    }

---

二、校验基本类型

在很多场景下，我们不需要校验一个javaBean，更多的是校验单个的int，String等。但是直接写上去，是不起作用的，校验框架并没有去校验，我们需要做的就是让它生效。
参考如下：https://diamondfsd.com/article/78fa12cd-b530-4a90-b438-13d5a0c4e26c
这里写链接内容

1、controller层添加注解校验：
controller层方法代码如下，既有javabean的校验也有简单参数的校验：

/**
     * 
    * @Title: RegisterUser
    * @Description: TODO(用户注册)
    * @return Map<String,Object>    返回类型
    * @param user
    * @param confirmPassword
    * @param vercode
    * @param request
    * @return
     */
    @RequestMapping("registerUser")
    @ResponseBody
    @Operationlog(desc="用户注册")
    public Map<String, Object> registerUser(
            @Valid 
            User user, 
            BindingResult bindingResult,
            @NotEmpty
            String confirmPassword,
            @NotEmpty
            String vercode) {
        return null;
    }

2、配置aop统一管理javabean的校验信息BindingResult以及使简单参数的注解校验生效：
（1）springmvc的controller配置aop注意事项：
参考连接：http://blog.csdn.net/menghuanzhiming/article/details/78780612
如果仍然无法使用aop请检查jar包是否冲突；

（2）配置文件：spring-aspect.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
                            http://www.springframework.org/schema/beans/spring-beans-3.1.xsd    
                            http://www.springframework.org/schema/context    
                            http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                            http://www.springframework.org/schema/mvc    
                            http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                            http://www.springframework.org/schema/tx
                            http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
                            http://www.springframework.org/schema/aop 
                            http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

    <!-- 开启asepctj注解扫描 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <!-- AOP的XML的aspectj配置 -->
    <bean id="requestParamValidAspect" class="edu.hrbeu.platform.modeling.common.aspect.RequestParamValidAspect"/>
</beans>  

springmvc配置文件引入spring-aspect.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
                            http://www.springframework.org/schema/beans/spring-beans-3.1.xsd    
                            http://www.springframework.org/schema/context    
                            http://www.springframework.org/schema/context/spring-context-3.1.xsd 
                            http://www.springframework.org/schema/task
                            http://www.springframework.org/schema/task/spring-task-3.1.xsd   
                            http://www.springframework.org/schema/mvc    
                            http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    ...
    省略
    ...
    <import resource="spring-aspect.xml"/>
</beans>

切面类RequestParamValidAspect ：

package edu.hrbeu.platform.modeling.common.aspect;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.validation.ConstraintViolation;
import javax.validation.ElementKind;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import javax.validation.executable.ExecutableValidator;

import org.aspectj.lang.JoinPoint;
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.NodeImpl;
import org.hibernate.validator.internal.engine.path.PathImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;

import edu.hrbeu.platform.modeling.exception.ParamValidException;
import edu.hrbeu.platform.modeling.pojo.SimpleFiledError;

/**
 * 
* @ClassName: RequestParamValidAspect 
* @Description: TODO(controller参数校验aspectj) 
* @author chenliming
* @date 2017年12月12日 上午10:27:36 
*
 */
@Aspect
public class RequestParamValidAspect {
    private final ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    private final ExecutableValidator validator = factory.getValidator().forExecutables();
    Logger log = LoggerFactory.getLogger(getClass());

    @Pointcut("execution(public java.util.Map edu.hrbeu.platform.modeling.*.controller.*.*(..))")
    public void controllerAround() {
    }

    ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();

    /**
     * 
    * @Title: around
    * @Description: TODO(环绕增强，校验controller参数)
    * @return Object    返回类型
    * @param pjp
    * @return
    * @throws Throwable
     */
    @Around("controllerAround()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("aspect参数校验start.....");
        try {
            // 取参数，如果没参数，那肯定不校验了
            Object[] args = pjp.getArgs();
            if (args.length == 0) {
                return pjp.proceed();
            }

            List<SimpleFiledError> simpleFiledErrors = new ArrayList<>();
            /************************** 校验封装好的javabean **********************/
            // 寻找带BindingResult参数的方法，然后判断是否有error，如果有则是校验不通过
            for (Object arg : args) {
                if (arg instanceof BeanPropertyBindingResult) {
                    // 有校验
                    BeanPropertyBindingResult result = (BeanPropertyBindingResult) arg;
                    if (result.hasErrors()) {
                        List<ObjectError> list = result.getAllErrors();
                        for (ObjectError error : list) {
//                          System.out.println(
//                                  error.getCode() + "---" + error.getArguments() + "--" + error.getDefaultMessage());
                            String name = null;
                            if(error instanceof FieldError) {
                                //字段名称
                                name = ((FieldError)error).getField();
                            } else {
                                //对象名称
                                name = error.getObjectName();
                            }

                            SimpleFiledError simpleFiledError = new SimpleFiledError();
                            simpleFiledError.setName(name);
                            simpleFiledError.setMessage(error.getDefaultMessage());
                            simpleFiledErrors.add(simpleFiledError);
                        }
                    }
                }
            }

            /************************** 校验普通参数 *************************/
            // 获得切入目标对象
            Object target = pjp.getThis();
            // 获得切入的方法
            Method method = ((MethodSignature) pjp.getSignature()).getMethod();
            // 执行校验，获得校验结果
            Set<ConstraintViolation<Object>> validResult = validMethodParams(target, method, args);
            // 如果有校验不通过的
            if (!validResult.isEmpty()) {
                String[] parameterNames = parameterNameDiscoverer.getParameterNames(method); // 获得方法的参数名称

                for (ConstraintViolation<Object> constraintViolation : validResult) {
                    PathImpl pathImpl = (PathImpl) constraintViolation.getPropertyPath(); // 获得校验的参数路径信息
                    NodeImpl leafNode = pathImpl.getLeafNode();

                    //判断是否是参数类型（如果是bean的属性无法获取index，抛出异常）
                    if(leafNode.getKind() == ElementKind.PARAMETER) {
                        int paramIndex = leafNode.getParameterIndex(); // 获得校验的参数位置
                        String paramName = parameterNames[paramIndex]; // 获得校验的参数名称

//                      //参数名称
//                      System.out.println(paramName);
//                      // 校验信息
//                      System.out.println(constraintViolation.getMessage());

                        SimpleFiledError simpleFiledError = new SimpleFiledError();
                        simpleFiledError.setName(paramName);
                        simpleFiledError.setMessage(constraintViolation.getMessage());
                        simpleFiledErrors.add(simpleFiledError);
                    }

                }
            }

            if(!simpleFiledErrors.isEmpty()) {
                Map map = new HashMap();
                map.put("success", false);//是否成功
                map.put("message", "参数校验不成功");//文本消息
                map.put("filedErrors", simpleFiledErrors);
                return map;
            }

            return pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
            throw e;
        }
    }

    public void before(JoinPoint point) throws ParamValidException {
        // 获得切入目标对象
        Object target = point.getThis();
        // 获得切入方法参数
        Object[] args = point.getArgs();
        // 获得切入的方法
        Method method = ((MethodSignature) point.getSignature()).getMethod();

        // 执行校验，获得校验结果
        Set<ConstraintViolation<Object>> validResult = validMethodParams(target, method, args);

        if (!validResult.isEmpty()) {
            String[] parameterNames = parameterNameDiscoverer.getParameterNames(method); // 获得方法的参数名称

            List<SimpleFiledError> errors = new ArrayList<>();
            for (ConstraintViolation<Object> constraintViolation : validResult) {
                PathImpl pathImpl = (PathImpl) constraintViolation.getPropertyPath(); // 获得校验的参数路径信息
                int paramIndex = pathImpl.getLeafNode().getParameterIndex(); // 获得校验的参数位置
                String paramName = parameterNames[paramIndex]; // 获得校验的参数名称

                SimpleFiledError error = new SimpleFiledError(); // 将需要的信息包装成简单的对象，方便后面处理
                error.setName(paramName); // 参数名称（校验错误的参数名称）
                error.setMessage(constraintViolation.getMessage()); // 校验的错误信息
                errors.add(error);

                System.out.println(paramName);
                // 校验信息
                System.out.println(constraintViolation.getMessage());
            }

            throw new ParamValidException(errors); // 我个人的处理方式，抛出异常，交给上层处理

        }
    }

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

切面类中的环绕增强将校验错误汇总并返回；

---

参数异常处理类ParamValidException：

package edu.hrbeu.platform.modeling.exception;

import java.util.List;

import edu.hrbeu.platform.modeling.pojo.SimpleFiledError;

public class ParamValidException extends Exception{
    private static final long serialVersionUID = 1L;

    private List<SimpleFiledError> fieldErrors;
    public ParamValidException(List<SimpleFiledError> fieldErrors) {
        this.fieldErrors = fieldErrors;
    }
}

---

自定义校验错误实体类SimpleFiledError ：

package edu.hrbeu.platform.modeling.pojo;

public class SimpleFiledError {
    private String name;
    private String message;

    public SimpleFiledError() {
        super();
        // TODO Auto-generated constructor stub
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }


}

---