【源码解析】SpringBoot接口参数校验原理

已于 2023-05-12 21:16:51 修改
阅读量455 收藏 1
点赞数 1
分类专栏： 源码解析 spring boot 文章标签： spring boot java spring
于 2023-05-11 09:20:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/130614427
版权

使用示例

入门

web接口

@RestController
public class HelloController {

    @PostMapping("/t1")
    public void t1(@Validated @RequestBody Request request) {
        System.out.println(11);
    }
}

实体类

@Data
public class Request {

    @NotEmpty(message = "title不为空")
    private String title;

    @NotEmpty(message = "name不为空")
    private String name;
}

访问接口，会校验message和name的数据

自定义的校验器

注解

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy ={StatusValidator.class})
public @interface Status {
 
    String[] statusType() default {};
 
    String message() default "状态传递有误";
 
    Class<?>[] groups() default {};
 
    Class<? extends Payload>[] payload() default {};
 
}

StatusValidator自定义的校验器

public class StatusValidator implements ConstraintValidator<Status, Integer> {

    private List<String> typeStatus;

    @Override
    public void initialize(Status constraintAnnotation) {
        typeStatus = Arrays.asList(constraintAnnotation.statusType());
        ConstraintValidator.super.initialize(constraintAnnotation);
    }

    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext constraintValidatorContext) {
        if (value != null) {
            if (!typeStatus.contains(String.valueOf(value))) {
                return false;
            }
        }
        return true;
    }
}

在实体类上添加校验属性

@Data
public class Request {

    @NotEmpty(message = "title不为空")
    private String title;

    @NotEmpty(message = "name不为空")
    private String name;

    @Status(statusType = {"1","2"})
    private Integer loginStatus;
}

非web接口校验

@Service
@Validated
public class HelloService {

    public void sayHello(@Valid Request request) {
        System.out.println(request);
    }
}

嵌套校验

实体类Request，包含嵌套校验的属性User

@Data
public class Request {

    @NotEmpty(message = "title不为空")
    private String title;

    @NotEmpty(message = "name不为空")
    private String name;

    @Status(statusType = {"1","2"})
    private Integer loginStatus;

    @Valid
    @NotNull
    private User user;

}

实体类

@Data
public class User {

    @NotEmpty(message = "密码不能为空")
    private String password;

    @Max(value = 1)
    private Integer age;
}

分组校验

校验属性设置分组

@Data
public class Request {

    @NotEmpty(message = "title不为空", groups = Group1.class)
    private String title;

    @NotEmpty(message = "name不为空", groups = Group2.class)
    private String name;

    @Status(statusType = {"1","2"})
    private Integer loginStatus;

    private User user;


    public interface Group1 {
    }

    public interface Group2 {
    }
}

对参数进行分组校验

@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @PostMapping("/t1")
    public void t1(@Validated(Request.Group1.class) @RequestBody Request request) {
        System.out.println(11);
    }
}

快速失败

@Configuration
public class ValidationConfig {
    @Bean
    public Validator validator() {
        ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
                .configure()
                // 开启 fail fast 机制
                .failFast(true)
                .buildValidatorFactory();
        return validatorFactory.getValidator();
    }
}

  • failFast设置为true表示开启快速失败，即当一个规则校验不通过时，就不在校验其他的规则了。

  • failFast设置为false表示不开启快速失败，会校验所有的规则。

标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理 标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理 标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理

源码解析

web参数校验

RequestResponseBodyMethodProcessor#resolveArgument，解析接口中的参数。判断校验结果是否有错，抛出异常。MethodArgumentNotValidException属于BindException的一种。

	@Override
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		parameter = parameter.nestedIfOptional();
		Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
		String name = Conventions.getVariableNameForParameter(parameter);

		if (binderFactory != null) {
			WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
			if (arg != null) {
				validateIfApplicable(binder, parameter);
				if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
					throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
				}
			}
			if (mavContainer != null) {
				mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
			}
		}

		return adaptArgumentIfNecessary(arg, parameter);
	}

AbstractMessageConverterMethodArgumentResolver#validateIfApplicable，进行校验

	protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
		Annotation[] annotations = parameter.getParameterAnnotations();
		for (Annotation ann : annotations) {
			Object[] validationHints = ValidationAnnotationUtils.determineValidationHints(ann);
			if (validationHints != null) {
				binder.validate(validationHints);
				break;
			}
		}
	}

ValidationAnnotationUtils#determineValidationHints，判断是否存在注解，Valid和Validated。

	public static Object[] determineValidationHints(Annotation ann) {
		Class<? extends Annotation> annotationType = ann.annotationType();
		String annotationName = annotationType.getName();
		if ("javax.validation.Valid".equals(annotationName)) {
			return EMPTY_OBJECT_ARRAY;
		}
		Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
		if (validatedAnn != null) {
			Object hints = validatedAnn.value();
			return convertValidationHints(hints);
		}
		if (annotationType.getSimpleName().startsWith("Valid")) {
			Object hints = AnnotationUtils.getValue(ann);
			return convertValidationHints(hints);
		}
		return null;
	}

	private static Object[] convertValidationHints(@Nullable Object hints) {
		if (hints == null) {
			return EMPTY_OBJECT_ARRAY;
		}
		return (hints instanceof Object[] ? (Object[]) hints : new Object[]{hints});
	}

DataBinder#validate(java.lang.Object...)，遍历校验器。

	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);
			}
		}
	}

ValidatorImpl#validate，对实体类进行校验

    public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) {
        Contracts.assertNotNull(object, Messages.MESSAGES.validatedObjectMustNotBeNull());
        this.sanityCheckGroups(groups);
        Class<T> rootBeanClass = object.getClass();
        BeanMetaData<T> rootBeanMetaData = this.beanMetaDataManager.getBeanMetaData(rootBeanClass);
        if (!rootBeanMetaData.hasConstraints()) {
            return Collections.emptySet();
        } else {
            BaseBeanValidationContext<T> validationContext = this.getValidationContextBuilder().forValidate(rootBeanClass, rootBeanMetaData, object);
            ValidationOrder validationOrder = this.determineGroupValidationOrder(groups);
            BeanValueContext<?, Object> valueContext = ValueContexts.getLocalExecutionContextForBean(this.validatorScopedContext.getParameterNameProvider(), object, validationContext.getRootBeanMetaData(), PathImpl.createRootPath());
            return this.validateInContext(validationContext, valueContext, validationOrder);
        }
    }

ValidatorImpl#validateConstraintsForDefaultGroup，根据组级别获取MetaConstraint。

	private <U> void validateConstraintsForDefaultGroup(BaseBeanValidationContext<?> validationContext, BeanValueContext<U, Object> valueContext) {
		final BeanMetaData<U> beanMetaData = valueContext.getCurrentBeanMetaData();
		final Map<Class<?>, Class<?>> validatedInterfaces = new HashMap<>();

		// evaluating the constraints of a bean per class in hierarchy, this is necessary to detect potential default group re-definitions
		for ( Class<? super U> clazz : beanMetaData.getClassHierarchy() ) {
			BeanMetaData<? super U> hostingBeanMetaData = beanMetaDataManager.getBeanMetaData( clazz );
			boolean defaultGroupSequenceIsRedefined = hostingBeanMetaData.isDefaultGroupSequenceRedefined();

			// if the current class redefined the default group sequence, this sequence has to be applied to all the class hierarchy.
			if ( defaultGroupSequenceIsRedefined ) {
				Iterator<Sequence> defaultGroupSequence = hostingBeanMetaData.getDefaultValidationSequence( valueContext.getCurrentBean() );
				Set<MetaConstraint<?>> metaConstraints = hostingBeanMetaData.getMetaConstraints();

				while ( defaultGroupSequence.hasNext() ) {
					for ( GroupWithInheritance groupOfGroups : defaultGroupSequence.next() ) {
						boolean validationSuccessful = true;

						for ( Group defaultSequenceMember : groupOfGroups ) {
							validationSuccessful = validateConstraintsForSingleDefaultGroupElement( validationContext, valueContext, validatedInterfaces, clazz,
									metaConstraints, defaultSequenceMember ) && validationSuccessful;
						}

						validationContext.markCurrentBeanAsProcessed( valueContext );

						if ( !validationSuccessful ) {
							break;
						}
					}
				}
			}
			// fast path in case the default group sequence hasn't been redefined
			else {
				Set<MetaConstraint<?>> metaConstraints = hostingBeanMetaData.getDirectMetaConstraints();
				validateConstraintsForSingleDefaultGroupElement( validationContext, valueContext, validatedInterfaces, clazz, metaConstraints,
						Group.DEFAULT_GROUP );
				validationContext.markCurrentBeanAsProcessed( valueContext );
			}

			// all constraints in the hierarchy has been validated, stop validation.
			if ( defaultGroupSequenceIsRedefined ) {
				break;
			}
		}
	}

ValidatorImpl#validateConstraintsForSingleDefaultGroupElement，对于每一个MetaConstraint执行校验

	private <U> boolean validateConstraintsForSingleDefaultGroupElement(BaseBeanValidationContext<?> validationContext, ValueContext<U, Object> valueContext, final Map<Class<?>, Class<?>> validatedInterfaces,
			Class<? super U> clazz, Set<MetaConstraint<?>> metaConstraints, Group defaultSequenceMember) {
		boolean validationSuccessful = true;

		valueContext.setCurrentGroup( defaultSequenceMember.getDefiningClass() );

		for ( MetaConstraint<?> metaConstraint : metaConstraints ) {
			// HV-466, an interface implemented more than one time in the hierarchy has to be validated only one
			// time. An interface can define more than one constraint, we have to check the class we are validating.
			final Class<?> declaringClass = metaConstraint.getLocation().getDeclaringClass();
			if ( declaringClass.isInterface() ) {
				Class<?> validatedForClass = validatedInterfaces.get( declaringClass );
				if ( validatedForClass != null && !validatedForClass.equals( clazz ) ) {
					continue;
				}
				validatedInterfaces.put( declaringClass, clazz );
			}

			boolean tmp = validateMetaConstraint( validationContext, valueContext, valueContext.getCurrentBean(), metaConstraint );
			if ( shouldFailFast( validationContext ) ) {
				return false;
			}

			validationSuccessful = validationSuccessful && tmp;
		}
		return validationSuccessful;
	}

SimpleConstraintTree#validateConstraints，获取校验器。

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

		if ( LOG.isTraceEnabled() ) {
			LOG.tracef(
					"Validating value %s against constraint defined by %s.",
					valueContext.getCurrentValidatedValue(),
					descriptor
			);
		}

		// 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 );
		}
	}

ConstraintValidatorManagerImpl#getInitializedValidator，获取校验器

	public <A extends Annotation> ConstraintValidator<A, ?> getInitializedValidator(
			Type validatedValueType,
			ConstraintDescriptorImpl<A> descriptor,
			ConstraintValidatorFactory constraintValidatorFactory,
			HibernateConstraintValidatorInitializationContext initializationContext) {
		Contracts.assertNotNull( validatedValueType );
		Contracts.assertNotNull( descriptor );
		Contracts.assertNotNull( constraintValidatorFactory );
		Contracts.assertNotNull( initializationContext );

		CacheKey key = new CacheKey( descriptor.getAnnotationDescriptor(), validatedValueType, constraintValidatorFactory, initializationContext );

		@SuppressWarnings("unchecked")
		ConstraintValidator<A, ?> constraintValidator = (ConstraintValidator<A, ?>) constraintValidatorCache.get( key );

		if ( constraintValidator == null ) {
			constraintValidator = createAndInitializeValidator( validatedValueType, descriptor, constraintValidatorFactory, initializationContext );
			constraintValidator = cacheValidator( key, constraintValidator );
		}
		else {
			LOG.tracef( "Constraint validator %s found in cache.", constraintValidator );
		}

		return DUMMY_CONSTRAINT_VALIDATOR == constraintValidator ? null : constraintValidator;
	}

	protected <A extends Annotation> ConstraintValidator<A, ?> createAndInitializeValidator(
			Type validatedValueType,
			ConstraintDescriptorImpl<A> descriptor,
			ConstraintValidatorFactory constraintValidatorFactory,
			HibernateConstraintValidatorInitializationContext initializationContext) {

		ConstraintValidatorDescriptor<A> validatorDescriptor = findMatchingValidatorDescriptor( descriptor, validatedValueType );
		ConstraintValidator<A, ?> constraintValidator;

		if ( validatorDescriptor == null ) {
			return null;
		}

		constraintValidator = validatorDescriptor.newInstance( constraintValidatorFactory );
		initializeValidator( descriptor, constraintValidator, initializationContext );

		return constraintValidator;
	}

ConstraintTree#validateSingleConstraint，用校验器执行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();
	}

非web接口校验

ValidationAutoConfiguration会注入MethodValidationPostProcessor

    @Bean
    @ConditionalOnMissingBean(
        search = SearchStrategy.CURRENT
    )
    public static MethodValidationPostProcessor methodValidationPostProcessor(Environment environment, @Lazy Validator validator, ObjectProvider<MethodValidationExcludeFilter> excludeFilters) {
        FilteredMethodValidationPostProcessor processor = new FilteredMethodValidationPostProcessor(excludeFilters.orderedStream());
        boolean proxyTargetClass = (Boolean)environment.getProperty("spring.aop.proxy-target-class", Boolean.class, true);
        processor.setProxyTargetClass(proxyTargetClass);
        processor.setValidator(validator);
        return processor;
    }

MethodValidationPostProcessor#afterPropertiesSet，创建切面和拦截器。

	private Class<? extends Annotation> validatedAnnotationType = Validated.class;

	@Override
	public void afterPropertiesSet() {
		Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
		this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
	}

	protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
		return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
	}

AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization，MethodValidationPostProcessor继承了AbstractAdvisingBeanPostProcessor，添加到advised 中，通过ProxyFactory 返回代理对象。

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (this.advisor == null || bean instanceof AopInfrastructureBean) {
			// Ignore AOP infrastructure such as scoped proxies.
			return bean;
		}

		if (bean instanceof Advised) {
			Advised advised = (Advised) bean;
			if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
				// Add our local Advisor to the existing proxy's Advisor chain...
				if (this.beforeExistingAdvisors) {
					advised.addAdvisor(0, this.advisor);
				}
				else {
					advised.addAdvisor(this.advisor);
				}
				return bean;
			}
		}

		if (isEligible(bean, beanName)) {
			ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
			if (!proxyFactory.isProxyTargetClass()) {
				evaluateProxyInterfaces(bean.getClass(), proxyFactory);
			}
			proxyFactory.addAdvisor(this.advisor);
			customizeProxyFactory(proxyFactory);

			// Use original ClassLoader if bean class not locally loaded in overriding class loader
			ClassLoader classLoader = getProxyClassLoader();
			if (classLoader instanceof SmartClassLoader && classLoader != bean.getClass().getClassLoader()) {
				classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
			}
			return proxyFactory.getProxy(classLoader);
		}

		// No proxy needed.
		return bean;
	}

MethodValidationInterceptor#invoke，进行方法校验，校验不通过则报错。可以对参数和返回值进行校验。

	@Override
	@Nullable
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// Avoid Validator invocation on FactoryBean.getObjectType/isSingleton
		if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
			return invocation.proceed();
		}

		Class<?>[] groups = determineValidationGroups(invocation);

		// Standard Bean Validation 1.1 API
		ExecutableValidator execVal = this.validator.forExecutables();
		Method methodToValidate = invocation.getMethod();
		Set<ConstraintViolation<Object>> result;

		Object target = invocation.getThis();
		Assert.state(target != null, "Target must not be null");

		try {
			result = execVal.validateParameters(target, methodToValidate, invocation.getArguments(), groups);
		}
		catch (IllegalArgumentException ex) {
			// Probably a generic type mismatch between interface and impl as reported in SPR-12237 / HV-1011
			// Let's try to find the bridged method on the implementation class...
			methodToValidate = BridgeMethodResolver.findBridgedMethod(
					ClassUtils.getMostSpecificMethod(invocation.getMethod(), target.getClass()));
			result = execVal.validateParameters(target, methodToValidate, invocation.getArguments(), groups);
		}
		if (!result.isEmpty()) {
			throw new ConstraintViolationException(result);
		}

		Object returnValue = invocation.proceed();

		result = execVal.validateReturnValue(target, methodToValidate, returnValue, groups);
		if (!result.isEmpty()) {
			throw new ConstraintViolationException(result);
		}

		return returnValue;
	}

MethodValidationInterceptor#determineValidationGroups，获取方法或者类上的注解Validated。

	protected Class<?>[] determineValidationGroups(MethodInvocation invocation) {
		Validated validatedAnn = AnnotationUtils.findAnnotation(invocation.getMethod(), Validated.class);
		if (validatedAnn == null) {
			Object target = invocation.getThis();
			Assert.state(target != null, "Target must not be null");
			validatedAnn = AnnotationUtils.findAnnotation(target.getClass(), Validated.class);
		}
		return (validatedAnn != null ? validatedAnn.value() : new Class<?>[0]);
	}
标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理 标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理 标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理 标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理 标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理

在这里插入图片描述

标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理
标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理
标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理
标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理
标题复制10行，并且每行大于10个字符【源码解析】SpringBoot接口参数校验原理

秋装什么
关注
专栏目录
Spring Boot 实现接口的各种参数校验
Bejpse的博客
03-01 2260
在我们进行接口开发时，在对参数的接收时，我们需要冗余复杂的校验规则 来进行接口参数的校验，接下来推荐一个好用的校验工具Spring Validation。 Java API规范 (JSR303) 定义了Bean校验的标准validation-api，但没有提供实现。hibernate validation是对这个规范的实现，并增加了校验注解如@Email、@Length等。 Spring Validation是对hibernate validation的二次封装，用于支持spring mvc参数自动校验
SpringBoot参数非空校验的非最优实现历程
weixin_30263277的博客
06-16 1409
　　SpringBoot参数非空校验在网上已经有很多资料了，自己最近要实现这一个功能，大概看了下觉得没什么难度，不想在过程中还是遇到了一些问题，在此记录，希望有遇到和我一样问题的人和过路大神不吝指教。 　　需求是做一个全局请求参数非空校验和异常拦截，spring提供的@Validated和Hibernate提供的@Valid目前不支持请求参数为基本类型的非空判断，只能是请求参数封装为对象时，判断...
《使用Validator做SpringMVC的验证框架》教程源码（完整版）
06-06
《使用Validator做SpringMVC的验证框架》教程源码 教程地址： http://blog.csdn.net/devefx/article/details/51565139 http://blog.csdn.net/devefx/article/details/51567533 http://blog.csdn.net/devefx/article/details/51576672 http://blog.csdn.net/devefx/article/details/51595671
SpringBoot 使用validation数据校验之自定义校验注解·源码分析+实例 - 第410篇
qq_44600824的博客
10-03 481
SpringBoot 使用validation数据校验之自定义校验注解·源码分析+实例 - 第410篇
SpringBoot源码解析之集成hibernate-validator验证框架
夫礼者的专栏
08-18 2438
本文尝试探究SpringBoot为集成验证框架而做的一些架构设计与实现，以期在实际运用中能够更加自如，做到心里有底。
spring validation 的几种方式
huohuosh的专栏
04-19 194
@Validated@ValidValidatorConstraintValidatorMethodValidationPostProcessor @Validated @Valid Validator 实现 org.springframework.validation.Validator 接口方式 ConstraintValidator 实现 javax.validation.ConstraintValidator 接口方式 以上几种都可以使用 @Validate
【源码】Spring validation参数校验原理解析之基本类型参数及Service层方法参数校验实现原理
最新发布
JingAi_jia917的博客
04-11 1449
本文从源码的角度分析了MethodValidationPostProcessor、MethodValidationInterceptor以及ValidatorImpl.validateParameters()，从而了解Spring Validation针对基本数据类型及Service层方法参数校验的实现原理
Spring Boot 实现各种参数校验，非常实用
Trouvailless的博客
07-07 1751
Java API规范 (JSR303) 定义了Bean校验的标准validation-api，但没有提供实现。hibernate validation是对这个规范的实现，并增加了校验注解如@Email、@Length等。Spring Validation是对hibernate validation的二次封装，用于支持spring mvc参数自动校验...
Spring Validation最佳实践及其实现原理，参数校验没那么简单！
伍六七
08-03 2935
之前也写过一篇关于Spring Validation使用的文章，不过自我感觉还是浮于表面，本次打算彻底搞懂Spring Validation。本文会详细介绍Spring Validation各种场景下的最佳实践及其实现原理，死磕到底！ 项目源码：spring-validation 简单使用 Java API规范(JSR303)定义了Bean校验的标准validation-api，但没有提供实现。hibernate validation是对这个规范的实现，并增加了校验注解如@Email、@Length等。S
springcloud fail-fast机制
bugAndMe的博客
05-09 3444
在整合mqtt时，发现有时候启动客户端会出现失败的问题，发现是由于网络原因，config响应无效时导致的，在bootstrap.yml（application.yml也可以）中设置即可。 cloud: config: fail-fast: true #是否启动快速失败功能，功能开启则优先判断config server是否正常 retry: initi...
spring-boot-validator使用汇总
yi_chao_jiang的专栏
04-19 1051
在写业务代码时，对参数的校验必不可少，基于Hibernate的Validator，可以非常便捷的实现参数校验。本文以SpringBoot为例，介绍一下如何使用Validator 基本操作 1、maven依赖 首先需要引入validator的starter依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validatio
拓展 LocalValidatorFactoryBean指定自定义值提取器？看看 Spring Boot 开发团队怎么说
小水牛的博客
01-16 1644
【Spring】Spring Boot 下拓展 LocalValidatorFactoryBean 实现对自定义结果的解析前言ValidationAutoConfigurationAddValueExtractorLocalValidatorFactoryBeanResultValueExtractorBeanValidationConfigMethodValidationPostProcessorMethodValidationInterceptor总结 前言 一般的，Spring Boot 项目引入 J
系统设计之二妙用验证器Validator改善代码
yangyanping20108的博客
11-15 845
使用 Preconditions 验证入参 在开发中，我们常常会使用 Preconditions 来验证接口的入参是否符合要求，代码如下 @Component public class FlowCmdServiceImpl implements FlowCmdService { @Override public void withdraw(@Valid FlowWithdrawCmd cmd) { Preconditions.checkArgument(cmd !=
SpringBoot使用Validation校验参数
热门推荐
JustryDeng
01-21 14万+
JSR(Java Specification Requests)是Java界的重要标准；JSR又细分很多标准，其中JSR303就代表Bean Validation。更多细节可参考：https://jcp.org/en/jsr/detail?id=303。 目录 准备工作 约束性注解(简单)说明 @Validated的使用时机 @Validated与@Valid的简单对比说明...
【SpringBoot】——Hibernator-Validator校验框架
山山来驰的博客
06-28 4073
介绍 首先说下大家常用的hibernate-validator，它是对JSR-303/JSR-349标准的实现，然后spring为了给开发者提供便捷集成了hibernate-validator，默认在springmvc模块。 依赖 本文所介绍皆在springboot应用的基础上，首先加上web模块： <dependency> <groupId>org.sp...
SpringBoot使用validator校验
weixin_34064653的博客
05-01 543
在前台表单验证的时候，通常会校验一些数据的可行性，比如是否为空，长度，身份证，邮箱等等，那么这样是否是安全的呢，答案是否定的。因为也可以通过模拟前台请求等工具来直接提交到后台，比如postman这样的工具，那么遇到这样的问题怎么办呢，我们可以在后台也做相应的校验。 新建项目，因为本文会使用postman模拟前...
SpringBoot validator 完美实现+统一封装错误提示
小单的博客专栏
07-10 2万+
1、杜绝通篇 if else 参数判断！！！ 2、普通参数方式 3、实体对象参数方式 效果 参数不合法，自动使用统一异常返回错误，例如： { "code": "-3", "message": "参数{age}最小18" } 实现代码 代码一次性给全，主要包含如下几个Java类，拿过去拷贝到项目中就能用： 1、ValidatorController 2、ValidatorVo 3、...
Spring 方法级别参数校验 之MethodValidationPostProcessor
追逐消失的记忆
10-22 4384
你在书写业务逻辑的时候，是否会经常书写大量的判空校验。比如Service层或者Dao层的方法入参、入参对象、出参中你是否都有自己的一套校验规则？比如有些字段必传，有的非必传；返回值中有些字段必须有值，有的非必须等等~ 若你追求干净的代码，甚至有代码洁癖，如上众多if else的重复无意义劳动无疑是你的痛点，那么本文应该能够帮到你。 Bean Validation校验其实是基于DDD思想设计的，我们虽然可以不完全的遵从这种思考方式编程，但是其优雅的优点还是可取的，本文将介绍Spring为此提供的解决方案~
SpringBoot高效参数校验：优雅处理与示例
在SpringBoot中优雅地处理参数校验是一项关键任务，尤其是在处理大量接口时，保持代码简洁性和可维护性至关重要。本文将介绍如何利用Java BeanValidation标准，结合SpringBoot的内置支持，实现参数验证的自动化和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值