Récemment, il est nécessaire de soumettre des données dynamiques, c'est-à-dire que vous devez analyser et soumettre des informations de définition de champ de données avant de pouvoir clarifier les types de champs spécifiques correspondants, puis effectuer la conversion du type de données et la vérification de la validité du champ. Ensuite, après avoir effectué un traitement commercial, soumettre la base de données et développer un ensemble de logique de vérification par vous-même, le cycle est trop long. Par conséquent, le principe de mise en œuvre de la validation du ressort a été analysé et les divers validateurs sous-jacents ont été réutilisés. Ici, le processus d'analyse du principe de validation du ressort sera enregistré sans entrer dans les détails.
Comment utiliser la validation du ressort
Vérifiez si le haricot est conforme aux spécifications JSR-303 lors de l'initialisation du haricot de ressort
1. Ajouter manuellement le haricotage de haricot
2. Définir les règles de vérification dans la classe de modèle, comme @max, @min, @Notempty
3. Déclarer le Bean, le code complet est le suivant:
@BeanPublic BeanPostProcessor BeanValidationPostProcessor () {return new BeanValidationPostProcessor ();} @ beanPublic UserModel GetUserModel () {UserModel UserModel = New UserModel (); userModel.SetUsername (null); userModel.SetPassword ("123"); return userModel;} @ dataclass userModel {@notnull (message = "nom d'utilisateur ne peut pas être null") @Pattern (regexp = "[a-za-z0-9 _] {5,10}", message = "username est illégal") String Private String username; @Size (min = 5, max = 10, message = "la longueur du mot de passe est illégal") Mot de passe de chaîne privée;}4. BeanValidationPostProcessor Il y a une propriété de type booléen après insialisation, qui est fausse par défaut. S'il est faux, le haricot est vérifié dans le processus de post-processus. Sinon, le haricot est vérifié dans le processus de post-procédure.
5. Cette vérification utilise la logique de Spring BeanPostProcessor
6. Vérifiez que la méthode Dovalidate est appelée et en outre un validateur d'appel. Valider. Le validateur par défaut est HiberNateValidator, le package de validation-API est la spécification Java et la spécification de ressort par défaut est implémentée comme le package Hibernate-validator. Ce cadre Hibernate Hibernate Hibernate
protégé void dovalidate (objet bean) {assert.state (this.validator! = null, "no validator set"); SET <CONSTRAINTVIOLATION <BOSE>> Result = this.validator.Validate (Bean);7. HiberNateValidator appelle ValidatorFactoryImpl par défaut pour générer un validateur, puis développer le validatorfactoryIMP
Spécifications JSR-303 au niveau de la méthode de support
1. Ajouter manuellement la méthodevalidationPostProcessor Bean
2. Ajouter une annotation @validated à la classe (l'annotation personnalisée est également prise en charge, et elle est transmise lors de la création d'une méthodevalidationPostProcessor Bean)
3. Ajouter des annotations de vérification aux paramètres de la méthode, tels que @max, @min, @notempty, @notnull, etc.
@ Composant @ ValidatedPublic Class beanformEtHodValidation {public void validate (@Notempty String Name, @min (10) int Age) {System.out.println ("valider, name:" + name + ", Âge:" + Age); }}4. MethodValidationPostProcessor utilise AOP pour terminer l'appel à la méthode
public void afterpropertiesset () {Pointcut PointCut = new `annotationmatchingpointcut` (this.validatenotationType, true); this.advisor = new `defaultPointCutAdvisor` (pointcut, createMethodValidationAdvice (this.validator));} conseils protégé CreateMethodValidationAdvice (@Nullable Validator Validator) {return (validator! = null? New` MethodvalidationInterceptor` (Validator): new5. La couche sous-jacente appelle également ValidatorFactoryImpl par défaut pour générer un validateur, et le validateur termine la vérification.
Logique directe de vérification des appels d'encodage, comme
classe publique Personne {@notnull (message = "Gender ne peut pas être vide") Gender privé Gender; @min (10) Age entier privé; ...} ValidatorFactory ValidatorFactory = Validation.BuildDefaultValidatorFactory (); Validator Validator = ValidatorFactory.getValidator (); Person Person) Personne (); personne.setgender (genre.Man); validator.validate (personne);Identique à ci-dessus, l'appel par défaut à ValidatorFactoryIMP est appelé pour générer un validateur et le validateur termine la vérification spécifique.
Utilisez une annotation valide ou validée pour annoter les paramètres à vérifier dans les paramètres de la méthode du contrôleur de printemps
1. Tout d'abord, familiarisez-vous avec le processus de demande et d'appel du printemps
2. Vous pouvez voir que la vérification des paramètres est effectuée pendant le processus de divers paramètres de demande de traitement des résolveurs.
3. La couche sous-jacente appelle uniformément la méthode Validate de Databinder
4. Le rôle de Databinder: Binder qui permet de définir les valeurs de propriété sur un objet cible, y compris la prise en charge de la validation et l'analyse des résultats de liaison, c'est-à-dire que le liant traite les paramètres de forme de chaîne soumis par demande et les convertit en type dont le serveur a vraiment besoin. Le liant prend en charge la validation et peut stocker les résultats de vérification.
5. Le validateur de Databinder est initialisé dans le configurablewebbindingInitializer par défaut. FacultationalValidatorFactoryBean est utilisé par défaut. Ce haricot hérite de la ValidatorfactoryBean local. LocalValidatorFactoryBean combine diverses informations de vérification telles que ValidatorFactory, les propriétés de vérification personnalisées, etc., et utilise ValidatorFactoryImpl pour obtenir le validateur par défaut.
À ce stade, tous les indices pointent sur ValidatorFactoryImpl. L'analyse suivante est la suivante
Validator public `getValidator` () {return` createvalidator` (contraintvalidatormanager.getDefaultConstraintValidatorFactory (), valuextractormanager, validatorfactoryscopedContex ValueExtractorManager ValueExtractorManager, ValidatorFactoryScopedContext validatorfactoryscopedContext, méthodyValidationConfiguration methodvalidationConfiguration) {beanMetadatamanager ValidatorFactoryScopedContext.getParameterAmprovider (), ValueExtractorManager, méthodyValidationConfiguration), Key -> New BeanMetadatamanager (`CONSTRAINTHELPER`, EXECTATILEHELPER, TYPERESOSTICHEHELPER, VALIDATORFACTORYSCORMER ValideOrderGenerator, BuildDataproviders (), méthodyValidationConfiguration)); Renvoie `nouveau validatorIMPL` (CONSTRAINTVALIDATORFACTORY, BeanMetAdatAranager, ValueExtractorManager, CONSTRAINTVALIDATORMANAGER, ValidingOrderGenerator, ValidatorFactoryScopedContext);} public Final <T> Set <CONSTRAINTVIOLATION <T>> Validate (T objet, Classic <?> ... Messages.validatedObjectMustNotBenull ()); Groupes de SanityCheck (groupes); ValidationContext <T> validationContext = `getValidationContextBuilder (). Forvalidate (objet)`; if (! validationContext.getRootBeanMetAdata (). HasConstraints ()) {return Collection.EmptySet (); } Validation ValideOrder = déterminerGroupValidingOrder (groupes); ValuonText <?, Object> ValuonText = `ValuEContext.getLocalexEcutionContext` (ValidatorsCopedContext.getParameterNameProvider (), objet, validationContext.getRootBeanMetadata (), PathIMPL.CreaRoOtOtPath ()); return validerInConText (validationContext, ValuEContext, ValideOrder);}1. GetValidator-> createValidator-> validatorImpl-> valider
Pendant le processus d'exécution, BeanMetAdatamanager, ValidationContext, ValueContex etc., et le contenu est relativement complexe.
2. La vérification du groupe est ignorée, et le traitement par défaut de groupe est validateconstraintesfordefaultGroup-> validateconstaintsforsingledEfaultGroupElement-> validatemetaconstraint (note: Metaconstraints maintient toutes les vérifications du type de haricot et de sa classe et de l'interface parent, et il est nécessaire de traduire et d'appeler ValidateMetAmonstraintwe
3. Continuez à appeler la méthode DovalidateConstraintraine de Metaconstraint et suivez différentes contraintes en fonction de différents types d'annotation.
Public Static <u étend Annotation> CONSTRAINTTREE <u> de (CONSTRAINTDESCRIPTORIMP <u> ComposingDescriptor, Type ValidatedValuetype) {if (ComposingDescriptor.getCompositingConstreAnIMPLS (). IsEmpty ()) {retourner new SimplestraintTree <> (ComposingDescriptor, ValliatedValueType); } else {return new ComposingConstraintTree <> (ComposingDescriptor, ValidatedValuType); }}4. Que dois-je aller simple et que devrait être composé? Parce qu'ils appellent tous les deux la méthode «getInitializedConstraintValidator» de CONSTRAINTTREE. Cette étape est utilisée pour obtenir le validateur correspondant à l'annotation (tel que DeciMalmax, Notorempty, etc.) et initialiser le validateur.
5. ConstraintHelper maintient tous les validateurs intégrés et les classe en fonction de l'annotation de vérification (comme DeciMalmax). La classe de description du validateur maintient le modèle générique du validateur (comme BigDecimal) comme suit:
putConstraints (tmpConstraints, decimalmax.class, arrays.aslist (decimalmaxvalidatorforbigdecimal.class, decimalmaxvalidatorforbiginteger.class, decimalmaxvalidatorfordouble.class, decimalmaxvalidat DecimalmaxValidatorForNumber.class, decimalmaxValidator forcharsence.class, decimalmaxValidatorFormOnetaryAmount.class));
Lors de l'obtention du validateur de la classe de haricots spécifiques, obtenez d'abord tous les validateurs en fonction de l'annotation. La méthode correspondante est ContraintManager.FindMatchingValidatorScriptor, puis obtient le validateur unique en fonction du type de vérification de l'objet.
6. Ensuite, initializevalidator en fonction des informations de contexte, puis appelez la méthode isvalid du validateur pour vérifier
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.