Recentemente, é necessário enviar dados dinâmicos, ou seja, você precisa analisar e enviar informações de definição de campo de dados antes de esclarecer os tipos de campo específicos correspondentes e, em seguida, fazer o tipo de dados de conversão e verificação de validade de campo. Então, depois de fazer processamento de negócios, enviar o banco de dados e desenvolver um conjunto de lógica de verificação por si mesmo, o ciclo é muito longo. Portanto, o princípio da implementação da validação da primavera foi analisado e os vários validadores subjacentes foram reutilizados. Aqui, o processo de análise do princípio de validação da primavera será registrado sem entrar em detalhes.
Como usar a validação da primavera
Verifique se o feijão cumpre as especificações do JSR-303 ao inicializar o feijão da mola
1. Adicione manualmente BeanValidationPostProcessor Bean
2. Defina regras de verificação na classe modelo, como @Max, @Min, @NotEmpty
3. Declare o feijão, o código abrangente é o seguinte:
@BeanPublic BeanPostProcessor BeanValidationPostProcessor () {return New BeanValidationPostProcessor ();}@beanpublic Usermodel getUsermodel () {userModel Usermodel = new Usermodel (); Usermodel.setUsername (null); Usermodel.setPassword ("123"); Retornar UserModel;} @dataclass UserModel {@NotNull (message = "Nome de usuário não pode ser nulo") @pattern (regexp = "[a-za-z0-9 _] {5,10}", message = "Username é ilegal). @Size (min = 5, max = 10, message = "comprimento da senha é ilegal") Private String senha;}4. BeanValidationPostProcessor Existe uma propriedade do tipo booleano após a ativação, que é falsa por padrão. Se for falso, o feijão será verificado no processo de pós -processamento parainitialização. Caso contrário, o feijão é verificado no processo de pós -processados aterinicalizações.
5. Esta verificação usa a lógica do Spring BeanPostProcessor
6. Verifique se o método dovalidato é chamado e mais um validador de chamada.Validate. O validador padrão é o HibernateValidator, o pacote de validação-api é a especificação Java e a especificação padrão da mola é implementada como o pacote Hibernate-Validator. Este hibernato não hibernato de hibernação
Void protegido Dovalidate (objeto Bean) {Assert.State (this.Validator! = NULL, "nenhum conjunto de validador"); SET <restrinsiolation <ject>> resultado = this.validator.validate (bean);7. O HibernateValidator chama validatorFactoryImpl por padrão para gerar validador e depois expandir o validatorFactoryImpl
Suportar especificações JSR-303 no nível do método
1. Adicione manualmente MethodValidationPostProcessor Bean
2. Adicione a anotação @validada à classe (anotação personalizada também é suportada e é transmitida ao criar um MethodValidationPostProcessor Bean)
3. Adicione anotações de verificação aos parâmetros do método, como @Max, @min, @NotEmpty, @NotNull, etc.
@Componente@validatedpublic classe beanformethodValidation {public void validate (@NotEmpty String Name, @min (10) int Age) {System.out.println ("Validar, nome:" + nome + ", idade:" + idade); }}4. MethodValidationPostProcessor usa a AOP para completar a chamada para o método
public void depoisPROPERTIESTET () {Pointcut Pointcut = new `AnoTationMatchingPointCut` (this.validatedannotationType, true); this.advisor = new `defaultPointCutadVisor` (Pointcut, CreateMethodValidationAdvice (this.validator));} Conselho protegido CreateMethodValidationAdvice (@NullLable Validator) {Return (Null? New? New` MetodValIdationInterCeptIntenter`Iator) {Return (Null? New? New?5. A camada subjacente também chama o validatorFactoryImpl por padrão para gerar validador e o validador conclui a verificação.
Lógica de verificação de chamadas de codificação direta, como
public class Pessoa {@NotNull (message = "Gênero não pode estar vazia") Gênero de gênero privado; @Min (10) Idade inteira privada; ...} validatorFactory ValidatorFactory = validation.buildDefaultValidatorFactory (); Validator Validator = ValidatorFactory.getLidator (); Person = Pessoa;O mesmo que acima, a chamada padrão para o validatorFactoryImpl é chamada para gerar validador e o validador completa a verificação específica.
Use anotação válida ou validada para anotar os parâmetros a serem verificados nos parâmetros do método do controlador de mola
1. Primeiro, familiarize -se com a solicitação e o processo de chamada da primavera
2. Você pode ver que a verificação de parâmetros é feita durante o processo de vários parâmetros de solicitação de processamento de resolvedores.
3. A camada subjacente chama o método validado de banco de dados uniformemente
4. A função do banco de dados: aglutinante que permite definir os valores das propriedades em um objeto de destino, incluindo suporte para validação e análise de resultados de ligação, ou seja, processa os parâmetros do formulário de string enviados por solicitação e os converte no tipo que o servidor realmente precisa. O fichário fornece suporte para validação e pode armazenar resultados de verificação.
5. O validador do banco de dados é inicializado no ConfigurableWebBindingInitializer por padrão. OpcionalValidatorFactoryBean é usado por padrão. Este feijão herda o LocalValidFactoryBean. O LocalValidatorFactoryBean combina várias informações de verificação, como validatorFactory, propriedades de verificação personalizadas, etc., e usa o validatorFactoryImpl para obter o validador por padrão.
Neste ponto, todas as pistas apontam para validatorFactoryImpl. A análise a seguir é a seguinte
public Validator `getValidator`() { return `createValidator`(constraintValidatorManager.getDefaultConstraintValidatorFactory(), valueExtractorManager, validatorFactoryScopedContext, methodValidationConfiguration );}Validator `createValidator`(ConstraintValidatorFactory constraintValidatorFactory, ValueExtractorManager valueExtractorManager, ValidatorFactoryScopedContext validatorFactoryScopedContext, MethodValidationConfiguration methodValidationConfiguration) { BeanMetaDataManager beanMetaDataManager = beanMetaDataManagers.computeIfAbsent( new BeanMetaDataManagerKey( validatorFactoryScopedContext.getParameterNameProvider(), valueExtractorManager, methodValidationConfiguration ), key -> new BeanMetaDataManager( `constraintHelper`, executableHelper, typeResolutionHelper, validatorFactoryScopedContext.getParameterNameProvider(), valueExtractorManager, validationOrderGenerator, buildDataProviders(), methodValidationConfiguration ) ); Retornar `novo validatorImpl` (restantValidatorFactory, beanmetAdatamanager, valuextractRorManager, restrintValidatormanager, validationorderGenerator, validatorFactoryScopedContext); Mensagens.ValidatedObjectMustNotBenull ()); SanityCheckGroups (Grupos); ValidationContext <T> validationContext = `getValidationContextBuilder (). Forvalidate (object)`; se (! } ValidationOrder ValidationOrder = DetermGroupValidationOrder (Grupos); ValueContext <?, Object> valuEcontext = `valuEcontext.getLocalexecutionContext` (validatorscopedContext.getParameterNameProvider (), objeto, validationContext.GretrootBeanMetadata (), pathimpl.CreaterOotPath (); Return Validatencontext (ValidationContext, ValuEcontext, ValidationOrder);}1. GetValidator-> Createvalidator-> ValidatorImpl-> Validar
During the execution process, beanMetaDataManager, validationContext, valueContext and other contents are encapsulated, which are context information that will be used during verification, such as all verification items of the bean to be checked (including parent class and interface), property, and method parameter verification information, and various tool classes commonly used by validator (such as processing of message, script, etc.) inherited from ValidatorFactoryScopedContext, etc., e o conteúdo é relativamente complexo.
2. A verificação do grupo é ignorada e o processamento de grupo padrão é validateConstraintsSfordEfAultGroup-> validateConstraintsSforsingLeFaultGroupeLement-> Validatemetaconstraint (Nota: as metaconstrações mantêm todas as verificações do tipo de bean e sua classe parental), e é necessária para exigir e válido
3. Continue chamando o método do Metaconstransntion do DovalidateConstraint e siga diferentes restrições de acordo com diferentes tipos de anotação.
public static <u estende a anotação> restantTree <u> de (restrintDescriptorImpl <u> compostDescriptor, tipo validatedValuetype) {if (compostDescriptor.getCompositingConstraIntImpls (). } else {return novo compostConstintTree <> (compostDescriptor, validatedValuetype); }}4. O que devo ir simples e o que deve estar compondo? Porque ambos chamam o método de 'GetinitializedConstraIntAntValidator' de restrinstree. Esta etapa é usada para obter o validador correspondente à anotação (como Decimalmax, NotEmpty, etc.) e inicializar o validador.
5. ConstraintHelper mantém todos os validadores construídos e os classifica de acordo com a anotação de verificação (como Decimalmax). A classe de descrição do validador mantém o modelo genérico do validador (como BigDecimal) da seguinte forma:
putConstraints( tmpConstraints, DecimalMax.class, Arrays.asList( DecimalMaxValidatorForBigDecimal.class, DecimalMaxValidatorForBigInteger.class, DecimalMaxValidatorForDouble.class, DecimalMaxValidatorForFloat.class, DecimalMaxValidatorForLong.class, DecimalmaxValidatorFornumber.class, decimalmaxValidatorForCharSequence.class, decimalmaxValidatorForMoneTaryAmount.class));
Ao obter o validador da classe de feijão específica, primeiro obtenha todos os validadores de acordo com a anotação. O método correspondente é restrintManager.FindMatchingValidArdArdescriptor e, em seguida, obtenha o validador exclusivo de acordo com o tipo de objeto que está sendo verificado.
6. Em seguida, InitializeValidator com base nas informações de contexto e depois chame o método ISValid do validador para verificar
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.