碼上快樂

相關內容    簡體    繁體

從深處去掌握數據校驗@Valid的作用（級聯校驗）

本文轉載自   查看原文   2019-07-31 15:44   1475    Java/ SpringBoot/ Spring

每篇一句

NBA里有兩大笑話：一是科比沒天賦，二是詹姆斯沒技術

相關閱讀

【小家Java】深入了解數據校驗：Java Bean Validation 2.0（JSR303、JSR349、JSR380）Hibernate-Validation 6.x使用案例
【小家Spring】讓Controller支持對平鋪參數執行數據校驗（默認Spring MVC使用@Valid只能對JavaBean進行校驗）
【小家Spring】Spring方法級別數據校驗：@Validated + MethodValidationPostProcessor優雅的完成數據校驗動作

對Spring感興趣可掃碼加入wx群：`Java高工、架構師3群`（文末有二維碼）

前言

關於Bean Validation的基本原理篇完結之后，接下來就是小伙伴最為關心的干貨：使用篇。
如果說要使用Bean Validation數據校驗，我十分相信小伙伴們都能夠使用，但估計大都是有個前提的：Spring MVC環境。我極其簡單的調查了一下，近乎99%的人都是只把數據校驗使用在Spring MVC的Controller層面的，而且幾乎90%的人都是讓它必須和@RequestBody一起來使用去校驗JavaBean入參~

如果這么去理解Bean Validation的使用，那就有點太過於片面了，畢竟被Spring包裹起來，你其實很難去知道它真正做的事。
熟悉我文章風格的人知道，每篇文章我都會帶你領略一些不一樣的風景，本章亦不例外，會讓你知道數據校驗在Spring框架之外的一些事~

分組校驗

在我的前置原理篇文章，分組校驗其實是沒太大必要說的，因為使用起來確實非常的簡單。此處還是給個分組校驗的使用案例吧：

@Getter
@Setter
@ToString
public class Person {
    // 錯誤消息message是可以自定義的
    @NotNull(message = "{message} -> 名字不能為null", groups = Simple.class)
    public String name;
    @Max(value = 10, groups = Simple.class)
    @Positive(groups = Default.class) // 內置的分組：default
    public Integer age;

    @NotNull(groups = Complex.class)
    @NotEmpty(groups = Complex.class)
    private List<@Email String> emails;
    @Future(groups = Complex.class)
    private Date start;

    // 定義兩個組 Simple組和Complex組
    interface Simple {
    }
    interface Complex {

    }
}

執行分組校驗：

    public static void main(String[] args) {
        Person person = new Person();
        //person.setName("fsx");
        person.setAge(18);
        // email校驗：雖然是List都可以校驗哦
        person.setEmails(Arrays.asList("fsx@gmail.com", "baidu@baidu.com", "aaa.com"));
        //person.setStart(new Date()); //start 需要是一個將來的時間: Sun Jul 21 10:45:03 CST 2019
        //person.setStart(new Date(System.currentTimeMillis() + 10000)); //校驗通過

        HibernateValidatorConfiguration configure = Validation.byProvider(HibernateValidator.class).configure();
        ValidatorFactory validatorFactory = configure.failFast(false).buildValidatorFactory();
        // 根據validatorFactory拿到一個Validator
        Validator validator = validatorFactory.getValidator();


        // 分組校驗（可以區分對待Default組、Simple組、Complex組）
        Set<ConstraintViolation<Person>> result = validator.validate(person, Person.Simple.class);
        //Set<ConstraintViolation<Person>> result = validator.validate(person, Person.Complex.class);

        // 對結果進行遍歷輸出
        result.stream().map(v -> v.getPropertyPath() + " " + v.getMessage() + ": " + v.getInvalidValue())
                .forEach(System.out::println);

    }

運行打印：

age 最大不能超過10: 18
name {message} -> 名字不能為null -> 名字不能為null: null

可以直觀的看到效果，此處的校驗只執行Person.Simple.class這個Group組上的約束~

分組約束在Spring MVC中的使用場景還是相對比較多的，但是需要注意的是：javax.validation.Valid沒有提供指定分組的，但是org.springframework.validation.annotation.Validated擴展提供了直接在注解層面指定分組的能力

@Valid注解

我們知道JSR提供了一個@Valid注解供以使用，在本文之前，絕大多數小伙伴都是在Controller中並且結合@RequestBody一起來使用它，但在本文之后，你定會對它有個全新的認識~

該注解用於驗證級聯的屬性、方法參數或方法返回類型。
當驗證屬性、方法參數或方法返回類型時，將驗證對象及其屬性上定義的約束，另外：此行為是遞歸應用的。

：：：為了理解@Valid，那就得知道處理它的時機：：：

MetaDataProvider

元數據提供者：約束相關元數據（如約束、默認組序列等）的Provider。它的作用和特點如下：

  1. 基於不同的元數據：如xml、注解。（還有個編程映射） 這三種類型。對應的枚舉類為：
public enum ConfigurationSource {
	ANNOTATION( 0 ),
	XML( 1 ),
	API( 2 ); //programmatic API
}
  1. MetaDataProvider只返回直接為一個類配置的元數據
  2. 它不處理從超類、接口合並的元數據（簡單的說你@Valid放在接口處是無效的）
public interface MetaDataProvider {

	// 將**注解處理選項**歸還給此Provider配置。  它的唯一實現類為：AnnotationProcessingOptionsImpl
	// 它可以配置比如：areMemberConstraintsIgnoredFor  areReturnValueConstraintsIgnoredFor
	// 也就說可以配置：讓免於被校驗~~~~~~(開綠燈用的)
	AnnotationProcessingOptions getAnnotationProcessingOptions();
	// 返回作用在此Bean上面的`BeanConfiguration`   若沒有就返回null了
	// BeanConfiguration持有ConfigurationSource的引用~
	<T> BeanConfiguration<? super T> getBeanConfiguration(Class<T> beanClass);
	
}

// 表示源於一個ConfigurationSource的一個Java類型的完整約束相關配置。  包含字段、方法、類級別上的元數據
// 當然還包含有默認組序列上的元數據（使用較少）
public class BeanConfiguration<T> {
	// 三種來源的枚舉
	private final ConfigurationSource source;
	private final Class<T> beanClass;
	// ConstrainedElement表示待校驗的元素，可以知道它會如下四個子類：
	// ConstrainedField/ConstrainedType/ConstrainedParameter/ConstrainedExecutable
	
	// 注意：ConstrainedExecutable持有的是java.lang.reflect.Executable對象
	//它的兩個子類是java.lang.reflect.Method和Constructor
	private final Set<ConstrainedElement> constrainedElements;

	private final List<Class<?>> defaultGroupSequence;
	private final DefaultGroupSequenceProvider<? super T> defaultGroupSequenceProvider;
	... // 它自己並不處理什么邏輯，參數都是通過構造器傳進來的
}

它的繼承樹：
在這里插入圖片描述
三個實現類對應着上面所述的三種元數據類型。本文很顯然只需要關注和注解相關的：AnnotationMetaDataProvider

AnnotationMetaDataProvider

這個元數據均來自於注解的標注，然后它是Hibernate Validation的默認configuration source。它這里會處理標注有@Valid的元素~

public class AnnotationMetaDataProvider implements MetaDataProvider {

	private final ConstraintHelper constraintHelper;
	private final TypeResolutionHelper typeResolutionHelper;
	private final AnnotationProcessingOptions annotationProcessingOptions;
	private final ValueExtractorManager valueExtractorManager;

	// 這是一個非常重要的屬性，它會記錄着當前Bean  所有的待校驗的Bean信息~~~
	private final BeanConfiguration<Object> objectBeanConfiguration;

	// 唯一構造函數
	public AnnotationMetaDataProvider(ConstraintHelper constraintHelper,
			TypeResolutionHelper typeResolutionHelper,
			ValueExtractorManager valueExtractorManager,
			AnnotationProcessingOptions annotationProcessingOptions) {
		this.constraintHelper = constraintHelper;
		this.typeResolutionHelper = typeResolutionHelper;
		this.valueExtractorManager = valueExtractorManager;
		this.annotationProcessingOptions = annotationProcessingOptions;

		// 默認情況下，它去把Object相關的所有的方法都retrieve:檢索出來放着  我比較費解這件事~~~  
		// 后面才發現：一切為了效率
		this.objectBeanConfiguration = retrieveBeanConfiguration( Object.class );
	}

	// 實現接口方法
	@Override
	public AnnotationProcessingOptions getAnnotationProcessingOptions() {
		return new AnnotationProcessingOptionsImpl();
	}


	// 如果你的Bean是Object  就直接返回了~~~（大多數情況下  都是Object）
	@Override
	@SuppressWarnings("unchecked")
	public <T> BeanConfiguration<T> getBeanConfiguration(Class<T> beanClass) {
		if ( Object.class.equals( beanClass ) ) {
			return (BeanConfiguration<T>) objectBeanConfiguration;
		}
		return retrieveBeanConfiguration( beanClass );
	}
}

如上可知，核心解析邏輯在retrieveBeanConfiguration()這個私有方法上。總結一下調用此方法的兩個原始入口（一個構造器，一個接口方法）：

  1. ValidatorFactory.getValidator()獲取校驗器的時候，初始化時會自己new一個，調用棧如下圖：
    在這里插入圖片描述
  2. 調用Validator.validate()方法的時候，beanMetaDataManager.getBeanMetaData( rootBeanClass )它會遍歷初始化時所有的metaDataProviders(默認情況下兩個，沒有xml方式的)，拿出所有的BeanConfiguration交給BeanMetaDataBuilder，最終構建出一個屬於此Bean的BeanMetaData。對此有一點注意事項描述如下：
    1. 處理MetaDataProvider時會調用ClassHierarchyHelper.getHierarchy( beanClass ) 方法，不僅僅處理本類。拿到本類自己和所有父類后，統一交給provider.getBeanConfiguration( clazz )處理（也就是說任何一個類都會把Object類處理一遍）
    在這里插入圖片描述
retrieveBeanConfiguration()詳情

這個方法說白了，就是從Bean里面去檢索屬性、方法、構造器等需要校驗的ConstrainedElement項。

	private <T> BeanConfiguration<T> retrieveBeanConfiguration(Class<T> beanClass) {
		// 它檢索的范圍是：clazz.getDeclaredFields()  什么意思：就是搜集到本類所有的字段  包括private等等  但是不包括父類的所有字段
		Set<ConstrainedElement> constrainedElements = getFieldMetaData( beanClass );
		constrainedElements.addAll( getMethodMetaData( beanClass ) );
		constrainedElements.addAll( getConstructorMetaData( beanClass ) );

		//TODO GM: currently class level constraints are represented by a PropertyMetaData. This
		//works but seems somewhat unnatural
		// 這個TODO很有意思：當前，類級約束由PropertyMetadata表示。這是可行的，但似乎有點不自然
		// ReturnValueMetaData、ExecutableMetaData、ParameterMetaData、PropertyMetaData

		// 總之吧：此處就是把類級別的校驗器放進來了（這個set大部分時候都是空的）
		Set<MetaConstraint<?>> classLevelConstraints = getClassLevelConstraints( beanClass );
		if (!classLevelConstraints.isEmpty()) {
			ConstrainedType classLevelMetaData = new ConstrainedType(ConfigurationSource.ANNOTATION, beanClass, classLevelConstraints);
			constrainedElements.add(classLevelMetaData);
		}
		
		// 組裝成一個BeanConfiguration返回
		return new BeanConfiguration<>(ConfigurationSource.ANNOTATION, beanClass,
				constrainedElements, 
				getDefaultGroupSequence( beanClass ),  //此類上標注的所有@GroupSequence注解
				getDefaultGroupSequenceProvider( beanClass ) // 此類上標注的所有@GroupSequenceProvider注解
		);
	}

這一步驟把該Bean上的字段、方法等等需要校驗的項都提取出來。就拿上例中的Demo校驗Person類來說，最終得出的BeanConfiguration如下：（兩個）
在這里插入圖片描述
在這里插入圖片描述
這是直觀的結論，可以看到僅僅是一個簡單的類其實所包含的項是挺多的。

此處說一句：項是有這么多，但是並不是每一個都需要走驗證邏輯的。因為畢竟大多數項上面並沒有約束（注解），大多數ConstrainedElement.getConstraints()為空嘛~

總得來說，我個人建議不能光只記憶結論，因為那很容易忘記，所以還是得稍微深入一點，讓記憶更深刻吧。那就從下面四個方面深入：

檢索Field：getFieldMetaData( beanClass )
  1. 拿到本類所有字段Field：clazz.getDeclaredFields()
  2. 把每個Field都包裝成ConstrainedElement存放起來~~~
    1. 注意：此步驟完成了對每個Field上標注的注解進行了保存
檢索Method：getMethodMetaData( beanClass )
  1. 拿到本類所有的方法Method：clazz.getDeclaredMethods()
  2. 排除掉靜態方法和合成(isSynthetic)方法
  3. 把每個Method都轉換成一個ConstrainedExecutable裝着~~(ConstrainedExecutable也是個ConstrainedElement)。在此期間它完成了如下事（方法和構造器都復雜點，因為包含入參和返回值）：
    1. 找到方法上所有的注解保存起來
    2. 處理入參、返回值（包括自動判斷是作用在入參還是返回值上）
檢索Constructor：getConstructorMetaData( beanClass )

完全同處理Method，略

檢索Type：getClassLevelConstraints( beanClass )
  1. 找打標注在此類上的所有的注解，轉換成ConstraintDescriptor
  2. 對已經找到每個ConstraintDescriptor進行處理，最終都轉換Set<MetaConstraint<?>>這個類型
    1.
  3. 把Set<MetaConstraint<?>>用一個ConstrainedType包裝起來（ConstrainedType是個ConstrainedElement）

關於級聯校驗此處補充說明一點，處理Type，都會處理級聯校驗情況，並且還是遞歸處理：
也就是這個方法（課件@Valid在此處生效）：

	// type解釋：分如下N中情況
	// Field為：.getGenericType() // 字段的類型
	// Method為：.getGenericReturnType() // 返回值類型
	// Constructor：.getDeclaringClass() // 構造器所在類

	// annotatedElement：可不一定說一定要有注解才能進來（每個字段、方法、構造器等都能傳進來）
	private CascadingMetaDataBuilder getCascadingMetaData(Type type, AnnotatedElement annotatedElement, Map<TypeVariable<?>, CascadingMetaDataBuilder> containerElementTypesCascadingMetaData) {
		return CascadingMetaDataBuilder.annotatedObject( type, annotatedElement.isAnnotationPresent( Valid.class ), containerElementTypesCascadingMetaData, getGroupConversions( annotatedElement ) );
	}

這里對我們理解級聯校驗最重要的一句是：annotatedElement.isAnnotationPresent(Valid.class)。也就是說：若元素被此注解標注了，那就證明需要對它進行級聯校驗，這就是JSR定位@Valid的作用~

Spring提升了它？？？請關注后文Spring對它的應用吧~

ConstraintValidator.isValid()調用處

我們知道，每個約束注解都是交給約束校驗器ConstraintValidator.isValid()這個方法來處理的，它被調用(生效)的地方在此(唯一處)：

public abstract class ConstraintTree<A extends Annotation> {
	...
	protected final <T, V> Set<ConstraintViolation<T>> validateSingleConstraint(ValidationContext<T> executionContext,
			ValueContext<?, ?> valueContext,
			ConstraintValidatorContextImpl constraintValidatorContext,
			ConstraintValidator<A, V> validator) {
		...
		V validatedValue = (V) valueContext.getCurrentValidatedValue();
		isValid = validator.isValid( validatedValue, constraintValidatorContext );
		...
		// 顯然校驗不通過就返回錯誤消息  否則返回空集合
		if ( !isValid ) {
			return executionContext.createConstraintViolations(valueContext, constraintValidatorContext);
		}
		return Collections.emptySet();
	}
	...
}

這個方法的調用，會在執行每個Group的時候

success = metaConstraint.validateConstraint( validationContext, valueContext );

MetaConstraint在上面檢索的時候就已經准備好了，最后通過ConstrainedElement.getConstraints就拿到了每個元素的校驗器們，繼續調用

// ConstraintTree<A>
boolean validationResult = constraintTree.validateConstraints( executionContext, valueContext );

so，最終就調用到了isValid這個真正做事的方法上了。

說了這么多，你可能還雲里霧里，那么就show一把吧：

Demo Show

上面用一個示例校驗Person這個JavaBean了，但是你會發現示例中我們全都是校驗的Field屬性。從理論里我們知道了Bean Validation它是有校驗方法、構造器、入參甚至遞歸校驗級聯屬性的能力的：

校驗屬性Field

略

校驗Method入參、返回值

校驗Constructor入參、返回值

既校驗入參，同時也校驗返回值

這些是不能直接使用的，需要在運行時進行校驗。具體使用可參考：【小家Spring】讓Controller支持對平鋪參數執行數據校驗（默認Spring MVC使用@Valid只能對JavaBean進行校驗）

級聯校驗

什么叫級聯校驗，其實就是帶校驗的成員里存在級聯對象時，也要對它完成校驗。這個在實際應用場景中是比較常見的，比如入參Person對象中，還持有Child對象，我們不僅僅要完成Person的校驗，也依舊還要對Child內的屬性校驗：

@Getter
@Setter
@ToString
public class Person {

    @NotNull
    private String name;
    @NotNull
    @Positive
    private Integer age;
    @Valid
    @NotNull
    private InnerChild child;

    @Getter
    @Setter
    @ToString
    public static class InnerChild {
        @NotNull
        private String name;
        @NotNull
        @Positive
        private Integer age;
    }

}

校驗邏輯如下：

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("fsx");
        Person.InnerChild child = new Person.InnerChild();
        child.setName("fsx-son");
        child.setAge(-1);
        person.setChild(child); // 放進去

        Validator validator = Validation.byProvider(HibernateValidator.class).configure().failFast(false)
                .buildValidatorFactory().getValidator();
        Set<ConstraintViolation<Person>> result = validator.validate(person);

        // 輸出錯誤消息
        result.stream().map(v -> v.getPropertyPath() + " " + v.getMessage() + ": " + v.getInvalidValue())
                .forEach(System.out::println);
    }

運行：

child.age 必須是正數: -1
age 不能為null: null

對child.age這個級聯屬性校驗成功~

總結

本文值得說是深入了解數據校驗（Bean Validation）了，對於數據校驗的基本使用一直都不是難事，特別是在Spring環境下使用就更簡單了~

知識交流

若文章格式混亂，可點擊：原文鏈接-原文鏈接-原文鏈接-原文鏈接-原文鏈接

The last：如果覺得本文對你有幫助，不妨點個贊唄。當然分享到你的朋友圈讓更多小伙伴看到也是被作者本人許可的~

若對技術內容感興趣可以加入wx群交流：Java高工、架構師3群。
若群二維碼失效，請加wx號：fsx641385712（或者掃描下方wx二維碼）。並且備注："java入群" 字樣，會手動邀請入群


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 @Validated和@Valid校驗參數、級聯屬性、List Spring MVC 數據校驗@Valid @Valid springMVC bean校驗不起作用 @Validated和@Valid的區別？校驗級聯屬性（內部類） @Valid 校驗嵌套對象 【springboot】@Valid參數校驗 valid 校驗方式 參數校驗@Valid SpringBoot - @Valid 參數校驗 @Valid springMVC bean校驗不起作用及如何統一處理校驗
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM