spring validation是什么

在平时的需求开发中，经常会有参数校验的需求，比如一个接收用户注册请求的接口，要校验用户传入的用户名不能为空、用户名长度不超过20个字符、传入的手机号是合法的手机号格式等等。遇到这种情况很多人会在controller接口中去写一些判断代码。但是如果我们又提供了一个修改用户信息的接口，这个接口也需要对用户的参数进行校验，那么我们的校验代码就会散落在两个地方，和真正的业务处理逻辑耦合在一起，而且如果未来要新增一种校验逻辑也需要在修改多个地方。

spring validation允许通过注解的方式来定义对象校验规则，把校验和业务逻辑分离开，让代码编写更加方便。

例如我们定义了一个UserRegisterParam类，并且给username和age字段加上了javax.validation包中的已有的一些validation注解。

@Data
class UserRegisterParam {
    @NotBlank
    @Size(min = 1, max = 20)
    private String username;
    @Min(1)
    private int age;
}

然后在一个Controller的RequestMapping方法中，我们定义这个类为方法入参，并且给这个参数加上@Valid注解

@RequestMapping("/register")
public Object register(@Validated UserRegisterParam param) {
    // 正常处理逻辑
}

如果这个请求的参数不符合UserRegisterParam类中定义的validation要求，spring就会抛出异常。比如用户名超长的情况，我们可以在统一的异常拦截器对异常进行捕获处理返回给用户，在后面的使用部分会进行介绍。

org.springframework.validation.BindException: org.springframework.validation.BeanPropertyBindingResult: 1 errors
Field error in object 'userRegisterParam' on field 'username': rejected value [11111111111111111111111]; codes [Size.userRegisterParam.username,Size.username,Size.java.lang.String,Size]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [userRegisterParam.username,username]; arguments []; default message [username],20,1]; default message [个数必须在1和20之间]

spring validation怎么用

spring-boot/spring-mvc中使用

当classpath里包含了validator的实现包（比如org.hibernate.validator:hibernate-validator)，spring就会自动配置好validator相关的配置，不需要我们做额外配置。

例如我们在springboot项目中引入hibernate-validator的依赖，spring就会自动注册一个默认Validator。

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
</dependency>

然后就可以在controller中增加@Validated注解来对参数进行校验了

给参数类增加注解限制，常见的注解可以在javax.validation.constraints包中看到。

比如@Max @Min @PositiveOrZero, @Positive限制数字的大小, @NotBlank限制字符串不能为null或只包含空字符串, @NotEmpty限制字符串、集合、map、数组等不能为空，@NotNull限制对象不能为空

public class UserRegisterParam {
    @NotNull
    @Size(min = 2, max = 5, message = "用户名长度必须在2到5之间")
    private String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

在controller参数上增加@Validated注解。

@RequestMapping("/register")
public Result<?> register(@Validated UserRegisterParam requestParam) {
    return null;
}

转换验证异常为返回值

默认情况下spring对不符合validation验证的请求的处理是返回一个http400错误码，但是如果我们想给请求的用户返回一些更详细的信息，该怎么实现呢？

可以通过spring的ExceptionAdvice功能对异常进行统一的捕获和处理，校验失败返回的异常是BindException。

比如我们下面的代码返回一个Result对象，其中的code、message可以根据自己的需求进行映射，比如如果对错误信息进行修改，可以通过BindException的getFieldErrors方法获取详细的字段和错误原因。

@RestControllerAdvice
public class ApplicationExceptionAdvice {

    @ExceptionHandler(BindException.class)
    public Result<?> handleThrowable(HttpServletRequest request, BindException e) {
        Result result = new Result();
        result.setCode(1);
        result.setMessage(e.getMessage());
        return result;
    }
}

自定义validation

javax.validation中的注解能够满足大部分的校验需求，但是如果有一些特殊的校验，我们也可以进行自定义校验注解和规则。 只需要两步，先定义注解，然后定义注解对应的ConstraintValidator。

下面我们以实现一个校验数字必须是奇数的校验注解为例，展示一下实现过程。

首先定义一个注解，命名为OddNum，其中@Constraint的validatedBy用于指定对应的ConstraintValidator即注解校验规则实现。 message() groups() payload()几个方法要默认加上。

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = OddNumConstraintValidator.class)
public @interface OddNum {
    String message() default "必须是奇数";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };
}

然后定义对应的OddNumConstraintValidator，这个类要实现ConstraintValidator然后用泛型引用对应的注解和支持的校验对象类型。 我们这里奇数可以支持数字类型，使用Number类。然后会需要实现两个方法，一个是initialize方法可以用来从注解中获取用户配置的值比如@Max中的value值，保存在字段中在isValid方法中使用。由于我们的判断奇数校验不需要用户传入配置参数，所以这一步就省略了。 然后实现isValid方法负责校验，value是对应的要校验的值，我们这里做了一个简单的数字奇数校验，校验通过返回true否则返回false。

public class OddNumConstraintValidator implements ConstraintValidator<OddNum, Number> {

    @Override
    public void initialize(OddNum constraintAnnotation) {
        ConstraintValidator.super.initialize(constraintAnnotation);
    }

    @Override
    public boolean isValid(Number value, ConstraintValidatorContext context) {
        return value != null && value.longValue() % 2 == 1;
    }
}

定义完成后，就可以和javax.validation包中的注解一样使用了。

spring validation(hibernate-validator)怎么实现的

javax.validation是Jakarta Bean Validation中定义的一些规范，规范对应的实现最常用的是hibernate validator。

在spring mvc中，有ModelAttributeMethodProcessor类负责将请求参数绑定到RequestMapping方法的参数对象上，同时会进行参数校验。

在validateIfApplicable中会调用binder.validate，spring会找到加载的validatator来进行validate。

protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
	for (Annotation ann : parameter.getParameterAnnotations()) {
		Object[] validationHints = ValidationAnnotationUtils.determineValidationHints(ann);
		if (validationHints != null) {
			binder.validate(validationHints);
			break;
		}
	}
}
public void validate(Object... validationHints) {
	Object target = getTarget();
	Assert.state(target != null, "No target to validate");
	BindingResult bindingResult = getBindingResult();
	// Call each validator with the same binding result
	for (Validator validator : getValidators()) {
		if (!ObjectUtils.isEmpty(validationHints) && validator instanceof SmartValidator) {
			((SmartValidator) validator).validate(target, bindingResult, validationHints);
		}
		else if (validator != null) {
			validator.validate(target, bindingResult);
		}
	}
}

在classloader中具有hibernate-validator的情况下，会委托给hibernate的ValidatorImpl进行校验。 ValidatorImpl中，先从对应的类中读取相关的校验规则注解信息构成BeanMetaData，构建上下文信息BaseBeanValidationContext，然后调用validateInContext。

public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) {
	Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() );
	sanityCheckGroups( groups );

	@SuppressWarnings("unchecked")
	Class<T> rootBeanClass = (Class<T>) object.getClass();
	BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );

	if ( !rootBeanMetaData.hasConstraints() ) {
		return Collections.emptySet();
	}

	BaseBeanValidationContext<T> validationContext = getValidationContextBuilder().forValidate( rootBeanClass, rootBeanMetaData, object );

	ValidationOrder validationOrder = determineGroupValidationOrder( groups );
	BeanValueContext<?, Object> valueContext = ValueContexts.getLocalExecutionContextForBean(
			validatorScopedContext.getParameterNameProvider(),
			object,
			validationContext.getRootBeanMetaData(),
			PathImpl.createRootPath()
	);

	return validateInContext( validationContext, valueContext, validationOrder );
}

最终会加载各个Constraint校验实现逻辑对目标bean进行校验，比如我们刚定义的OddNumConstraintValidator会在SimpleConstraintTree.validateConstraints中进行加载调用。 validateConstraints首先根据validationContext和valueContext获取对应的validator，在处理我们的@OddNum注解的参数时会获取到OddNumConstraintValidator。

protected void validateConstraints(ValidationContext<?> validationContext,
			ValueContext<?, ?> valueContext,
			Collection<ConstraintValidatorContextImpl> violatedConstraintValidatorContexts) {

	// find the right constraint validator
	ConstraintValidator<B, ?> validator = getInitializedConstraintValidator( validationContext, valueContext );

	// create a constraint validator context
	ConstraintValidatorContextImpl constraintValidatorContext = validationContext.createConstraintValidatorContextFor(
			descriptor, valueContext.getPropertyPath()
	);

	// validate
	if ( validateSingleConstraint( valueContext, constraintValidatorContext, validator ).isPresent() ) {
		violatedConstraintValidatorContexts.add( constraintValidatorContext );
	}
}

最后validateSingleConstraint方法，会调用OddNumConstraintValidator的isValid方法。

protected final <V> Optional<ConstraintValidatorContextImpl> validateSingleConstraint(
			ValueContext<?, ?> valueContext,
			ConstraintValidatorContextImpl constraintValidatorContext,
			ConstraintValidator<A, V> validator) {
	boolean isValid;
	try {
		@SuppressWarnings("unchecked")
		V validatedValue = (V) valueContext.getCurrentValidatedValue();
		isValid = validator.isValid( validatedValue, constraintValidatorContext );
	}
	catch (RuntimeException e) {
		if ( e instanceof ConstraintDeclarationException ) {
			throw e;
		}
		throw LOG.getExceptionDuringIsValidCallException( e );
	}
	if ( !isValid ) {
		//We do not add these violations yet, since we don't know how they are
		//going to influence the final boolean evaluation
		return Optional.of( constraintValidatorContext );
	}
	return Optional.empty();
}