使用vlidator校验器校验

spring boot 虽然集成了 valid 验证，但是只是针对单个参数，不能是整个类，这时就可以使用 hibernate 的 validator 验证器，而且有分组的功能，例如：在注册时要验证 A 类三个字段，但在登录时只需要验证 A  类的两个字段，如果要另外创建一个 VO 类就很没必要，这时就可以使用分组来解决

依赖pom

<dependencies>  
    
    <dependency>  
        <groupId>javax.el</groupId>  
        <artifactId>javax.el-api</artifactId>  
        <version>2.2.4</version>  
    </dependency>  
      
  <dependency>  
        <groupId>org.hibernate</groupId>  
        <artifactId>hibernate-validator</artifactId>  
        <version>5.1.3.Final</version>  
    </dependency>  
    
  </dependencies>  

 

 

 

创建一个验证的工具类(以下有两种实现方式，根据业务场景选择)

package io.xiongdi.common.validator;

import io.xiongdi.common.exception.XDException;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.util.Set;


/**
 * @author wujiaxing


 * @date 2019-07-07
 * <p>
 *     hibernate-validator校验工具类
 *     可以参考 http://docs.jboss.org/hibernate/validator/5.4/reference/en-US/html_single/
 * </p>
 */
public class ValidatorUtils {
    /**
     * 验证器
     */
    private static Validator validator;

    static {
        validator = Validation.buildDefaultValidatorFactory().getValidator();
    }

    /**
     *  验证方法
     *  <p>
     *      同一个pojo类，可能会被多个controller使用验证，而每个controller的验证规则有不同，
     *      这是就需要分组验证，其实就是几个要分组的空接口，指定属性A属于哪个组，属性B又属于
     *      哪个组，这样在controller验证时就指定我要验证哪个组
     *  </p>
     * @param object 被校验的对象
     * @param groups 被校验的组
     * @throws XDException 校验不通过抛出自定义异常
     */
    public static void validateEntity(Object object, Class<?>... groups) throws XDException{
        // 用验证器执行验证，返回一个违反约束的set集合
        Set<ConstraintViolation<Object>> violationSet = validator.validate(object, groups);
        // 判断是否为空，空：说明验证通过，否则就验证失败
        if(!violationSet.isEmpty()) {

            List<String> errorMsglist = new ArrayList<String>();

           Iterator it = violationSet.iterator();

           while(it.hasNext()){             

                  ConstraintViolation<Object> violation = it.next;
                  errorMsglist.add(violation.getMessage());

            }   
           
            // 抛出自定义异常
            throw new XDException(errorMsglist);
        }

    }
}

public class ValidatorUtil {  
    private static Validator validator = Validation.buildDefaultValidatorFactory()  
            .getValidator();  
      
    public static <T> Map<String,StringBuffer> validate(T obj){  
        Map<String,StringBuffer> errorMap = null;  
        Set<ConstraintViolation<T>> set = validator.validate(obj,Default.class);  
        if(set != null && set.size() >0 ){  
            errorMap = new HashMap<String,StringBuffer>();  
            String property = null;  
            for(ConstraintViolation<T> cv : set){  
                //这里循环获取错误信息，可以自定义格式  
                property = cv.getPropertyPath().toString();  
                if(errorMap.get(property) != null){  
                    errorMap.get(property).append("," + cv.getMessage());  
                }else{  
                    StringBuffer sb = new StringBuffer();  
                    sb.append(cv.getMessage());  
                    errorMap.put(property, sb);  
                }  
            }  
        }  
        return errorMap;  
    }  
  
     
}