springboot使用validator进行参数校验

前言

公司项目是前后端分离的，为了保证前端传输数据的合法性，对参数进行校验就很有必要。hibernate-validator就是一个不错的参数校验的解决方法。spring-boot-starter-web包里面有hibernate-validator的包，所以不需要引用hibernate validator依赖，直接就可以用。

一、配置validator

Validator是javax包下的一个接口，hibernate对其进行了一系列的实现。我们需要构建Validator，注入spring中，然后就可以直接引用使用了。

先写个配置类，配置一下Validator。

failFast(true)的意思是快速失败，当检测到第一处不符合的时候就直接返回，不再校验下一个参数。

MethodValidationPostProcessor是controller层参数校验必须的一个Bean。

@Configuration
public class ValidatorConfig {

    @Bean
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        MethodValidationPostProcessor postProcessor = new MethodValidationPostProcessor();
        /**设置validator模式为快速失败返回*/
        postProcessor.setValidator(validator());
        return postProcessor;
    }
	
	@Bean
	public Validator validator(){
        ValidatorFactory validatorFactory = Validation.byProvider( HibernateValidator.class )
                .configure()
                .failFast(true)
                .buildValidatorFactory();
        Validator validator = validatorFactory.getValidator();

        return validator;
    }
	
}

二、设置校验规则

大多数时候，参数校验是对象属性的校验，所以需要对对象的属性设置校验的规则，java和hibernate提供了一系列注解来帮助我们实现规则的设置。

注解	释义
@Null	被注释的元素必须为 null
@NotNull	被注释的元素必须不为 null
@AssertTrue	被注释的元素必须为 true
@AssertFalse	被注释的元素必须为 false
@Min(value)	被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value)	被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value)	被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value)	被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max=, min=)	被注释的元素的大小必须在指定的范围内
@Digits (integer, fraction)	被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past	被注释的元素必须是一个过去的日期
@Future	被注释的元素必须是一个将来的日期
@Pattern(regex=,flag=)	被注释的元素必须符合指定的正则表达式
以下为Hibernate提供
@NotBlank(message =)	验证字符串非null，且长度必须大于0
@Email	被注释的元素必须是电子邮箱地址
@Length(min=,max=)	被注释的字符串的大小必须在指定的范围内
@NotEmpty	被注释的字符串的必须非空
@Range(min=,max=,message=)	被注释的元素必须在合适的范围内

写一个实体类，使用这些注解，@IsPhone是自定义的注解，后面会说到。

public class User {
	
	private Integer id;
	
	@NotBlank(message="手机号不能为空")
	@IsPhone
	private String phone;
	
	@NotEmpty(message = "用户名不能为空")
	private String username;
	
	@Range(min=1,max=200,message="年龄不能小于1大于200")
	private Integer age;

    //省略setter和getter
}

二、@RequestBody 请求参数校验

当使用标准的Restful格式的请求时，参数是json格式，参数会自动转为对象。在@RequestBody后面加个@Valid注解就可以进行参数校验了，参数里添加一个BindingResult就可以接受参数校验结果了。当有错误时，可以返回错误结果响应前端了。

	@PutMapping("/user")
	public ResponseEntity<Object> changeUser(@RequestBody @Valid User user,BindingResult result)throws Exception{
		
            if(result.hasErrors()){
                for (ObjectError error : result.getAllErrors()) {
                    System.out.println(error.getDefaultMessage());
                }
            }

		return ResponseEntity.ok().build();
	}

 

三、@RequestParam 请求参数校验

但是当我们使用@RequestParam来接收参数时，再使用上面的方法就不太好使了。毕竟没有自动生成实体类，无法校验实体类里属性的规则。这时候就需要直接在请求参数上进行校验了。

首先，我们要在类上加一个@Validated注解，然后再使用第二部的注解来标明参数的规则。

@RestController
@Validated
public class UserController {

	@GetMapping("/user")
	public ResponseEntity<Object> getUser(@NotBlank(message="手机号不能为空")
                                        @IsPhone(message="手机号格式不正确")
                                        @RequestParam String phone,

                                        @NotEmpty(message="用户名不能为空")
                                        @RequestParam String username,
									
                                        @Range(min = 1, max = 200, message = "年龄范围为1-200")
                                        @RequestParam Integer age)throws Exception{
		
		
		return ResponseEntity.ok().build();
	}
}

当参数不符合规范的时候，就会抛出ConstraintViolationException，所以我们就要捕获这个异常，响应前端。因为设置了快速失败，所以msg信息里只会有一条错误信息。

@ControllerAdvice
@Component
@Order(1)
public class ValidatorExceptionHandler {
	
	@ExceptionHandler(value=ValidationException.class)
	@ResponseBody
	public Object exceptionHandler(ValidationException e,HttpServletRequest request){
		
		String msg = new String();
		if(e instanceof ConstraintViolationException){
			ConstraintViolationException exs = (ConstraintViolationException) e;

			Set<ConstraintViolation<?>> violations = exs.getConstraintViolations();
			for (ConstraintViolation<?> item : violations) {
				msg = item.getMessage();
	        }
		}
		return ResponseEntity.badRequest().body(msg);
	}

}

四、自定义校验过程

如果要校验的参数不是请求参数或者以上方法都不适用，我们也可以自定义校验的过程。直接注入Validator进行校验即可。

首先写一个存放校验结果的类

import org.apache.commons.lang3.StringUtils;

public class ValidationResultBO {

	private boolean hasErrors = false;
	
	private Map<String,String> errorMsgMap = new HashMap<String, String>();

	//返回错误信息
	public String getErrorMsg(){
		return StringUtils.join(errorMsgMap.values().toArray(),",");
	}

    //省略setter和getter
	
}

然后自定义校验过程

@Component
public class ValidatorImpl{
	
	@Autowired
	private Validator validator;

	
	/**
	 * 实现校验方式并返回检验结果
	 * @param value
	 * @return
	 */
	public ValidationResultBO validate(Object value){
		ValidationResultBO result = new ValidationResultBO();
		Set<ConstraintViolation<Object>> validateSet = validator.validate(value);
		if (!validateSet.isEmpty()) {
			result.setHasErrors(true);
			
			validateSet.forEach( (validation) -> {
				String errorMsg = validation.getMessage();
				String propertyName = validation.getPropertyPath().toString();
				result.getErrorMsgMap().put(propertyName, errorMsg);
			});
		}
		
		return result;
	}

}

这样我们就可以在任何spring管理的类里直接注入ValidatorImpl来进行参数校验了。当校验结果ValidationResultBO里hasErrors为true时，就可以做相应的处理了。

举个栗子：

@Service
public class UserService {

	private static final Logger logger = LoggerFactory.getLogger(UserService.class);

	@Autowired
	private ValidatorImpl validator;
	
	public ReturnDataDTO<Object> addUser(String phone,String username,Integer age){
		
		User user = new User();
		user.setPhone(phone);
		user.setUsername(username);
		user.setAge(age);
		
		logger.info("{}",user);
		
		ValidationResultBO validate = validator.validate(user);
		if (validate.isHasErrors()) {
			String errorMsg = validate.getErrorMsg();
			logger.info("错误信息：{}",errorMsg);
			throw new MyException(111,errorMsg);
		}
		
		return ReturnDataDTO.ok();
	}
	
}

@RestController
public class UserController {

	@Autowired
	private UserService userService;
	
	@PostMapping("/user")
	public ResponseEntity<Object> addUser(@RequestParam String phone,
									@RequestParam String username,
									@RequestParam Integer age)throws Exception{
		
		userService.addUser(phone, username, age);
		
		return ResponseEntity.ok().build();
	}

}

ReturnDataDTO只是封装的返回参数，随便什么都可以。

MyException是全局异常处理自定义的异常，继承RuntimeException。

五、自定义校验注解

有时候我们也会需要其他的校验规则，但是官方没有，怎么办？这个简单，自己实现呗。

照着官方注解的样子写一个。

@Target({ElementType.METHOD,ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR,
	ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = {IsPhoneValidator.class})
public @interface IsPhone {

	String message() default "手机号格式错误";
	
	Class<?>[] groups() default {};
	
	Class<? extends Payload>[] payload() default {};
}

最主要的还是@Constraint这个注解，它指定了实现校验的类。这个类实现了ConstraintValidator接口，主要是重写isValid方法来进行校验。 

ConstraintValidator<IsPhone,String>有两个泛型，第一个是自定义的注解，也就是说自定义注解和实现校验的类是互相指定的关系。第二个是校验参数的类型，这里是校验手机号，所以是String。

public class IsPhoneValidator implements ConstraintValidator<IsPhone,String>{
	
	@Override
	public void initialize(IsPhone constraintAnnotation) {
		
	}

	@Override
	public boolean isValid(String value, ConstraintValidatorContext context) {
		
		
		if ("".equals(value) || value.equals(null)) {
			return false;
		}else{
			return isPhone(value);
		}
		
	}

	/** 验证是否为手机号
	 * @param phone
	 * @return
	 */
	public static boolean isPhone (String phone){
		String pattern  = "^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\\d{8}$";
		if (Pattern.matches(pattern, phone)) {
			return true;
		}else{
			return false;
		}
	}
}

写好的注解，和其他注解使用方法一样，在上文中已经使用过了，再次不再赘述了。

写在最后的话

参数校验有三种使用方法，应该能满足大部分情况下的使用。所以，就这样。