Prefácio
O componente do validador da estrutura da mola é um componente auxiliar, que é muito útil para a integridade e a validade dos dados. Ao definir um determinado validador, ele pode ser usado em outros lugares onde é necessário e é muito comum.
Antes de executar a lógica de negócios, é necessário garantir que os dados de entrada recebidos sejam legais e corretos através da verificação. No entanto, muitas vezes a mesma verificação ocorre muitas vezes, o que leva à redundância do código, perdeu o tempo e viola o princípio seco.
Você pode considerar encapsular o código de verificação para resolver esses problemas.
JSR-303
O JSR-303 é uma estrutura padrão fornecida pelo Java para a verificação da legalidade dos dados do feijão. Ele define um conjunto de anotações de verificação que podem ser anotadas nas variáveis de membros e nos métodos de atributo.
A validação de hibernato fornece esse conjunto de implementações padrão. Quando introduzimos a validação inicial da Web Spring Boot Web ou da Spring Boot Starter, a validação do Hibernate será introduzida por padrão.
Exemplo de uso
Depois de dizer tanta bobagem, adicione o código.
1. Introduzir Projeto de Springboot
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> </dependency> <!-- Introducing lomhok --> <dependency> <GrupidId> org.projectlombok </frupid> <stifactId> LOMOMBOK </STIFACTID> </pendendence>
2. Escreva objetos de verificação
@Datapublic Classe Usuário {// O nome não pode estar vazio, e a duração do nome estará entre 2 e 30 bits // se o comprimento do nome não passar, a mensagem de erro será solicitada @NotNull @size (min = 2, max = 30, "Mensagem" "Verifique se há algum problema com o comprimento do nome") String privado; // O nome não pode estar vazio, e a idade mínima é de 18 @NotNull @min (18) Idade do número inteiro privado;}3. Crie um controlador
@SpringbooTApplication@RestControllerPublic Classe APplication {public static void main (string [] args) {springapplication.run (userApplication.class, args); } // 1. Adicione a anotação @Valid antes do parâmetro a ser verificado // 2. Siga -o imediatamente, siga um BindingResult para armazenar as informações de verificação @RequestMapping ("/test1") public Object test1 (@Valid User, um usuário RETORNET RETORNED RELAST RETORNE RELAST RETORN RETORNED. De fato, as informações personalizadas podem ser retornadas de acordo com o método BindingResult, conforme necessário. // A solução usual é: JSR-303 + Global ExceptionHandler if (bindingResult.haserrors ()) {return bindingResult.getallerrorrors (); } retornar "OK"; }} 4. Execute o aplicativo
Após uma breve demonstração dos resultados da operação, pode -se observar que a estrutura de verificação entrou em vigor.
Verifique a idade
Verifique o nome
Verificação passada
Anotações comuns de verificação
@NULL O elemento anotado deve ser nulo
@NotNull O elemento anotado não deve ser nulo
@AssertTrue O elemento anotado deve ser verdadeiro
@Assertfalse O elemento anotado deve ser falso
@Min (valor) O elemento anotado deve ser um número e seu valor deve ser maior ou igual ao valor mínimo especificado.
@Max (valor) O elemento anotado deve ser um número e seu valor deve ser menor ou igual ao valor máximo especificado.
@Decimalmin (valor) O elemento anotado deve ser um número, e seu valor deve ser maior ou igual ao valor mínimo especificado
@Decimalmax (valor) O elemento anotado deve ser um número, e seu valor deve ser menor ou igual ao valor máximo especificado
@Size (max =, min =) O tamanho do elemento anotado deve estar dentro do intervalo especificado.
@Digits (número inteiro, fração) O elemento anotado deve ser um número e seu valor deve estar dentro de um intervalo aceitável.
@Past O elemento anotado deve ser uma data passada
@Future O elemento anotado deve ser uma data futura
@Pattern (regex =, flag =) O elemento anotado deve cumprir com a expressão regular especificada
Verifique as anotações fornecidas pelo Validador de Hibernato:
@NotBlank (mensagem =) Verifique se a string não é nula e deve ser maior que 0
@Email O elemento anotado deve ser um endereço de e -mail
@Length (min =, max =) O tamanho da sequência anotada deve estar dentro do intervalo especificado.
@NotEmpty A string comentada deve estar sem vazio
@Range (min =, max =, mensagem =) O elemento anotado deve estar dentro do intervalo apropriado
Anotações de verificação personalizadas
Às vezes, o tipo de verificação que queremos não está na biblioteca de terceiros. Felizmente, o sistema fornece boas recursos de expansão e podemos personalizar a verificação.
Por exemplo, queremos verificar o formato do telefone celular do usuário e escrever o dispositivo de verificação do número de telefone celular.
1. Escreva anotações de verificação
// Podemos copiar diretamente a anotação no sistema como @min, copiá -lo para nossa nova anotação e modificá -lo conforme necessário. @Target ({Método, campo, anotação_type, construtor, parâmetro})@retenção (tempo de execução)@documentado // a classe de implementação do anotação. @ConsTrant (validadoBy = {isMobileValidator.class}) public @Interface isMobile {// Informações padrão para verificação de erros string message () padrão "há um problema no formato do número de telefone celular"; // se deve forçar a verificação booleana isRequired () padrão false; Classe <?> [] Grupos () padrão {}; Classe <? estende a carga de pagamento> [] Payload () padrão {};} 2. Escreva classes de implementação específicas
Sabemos que as anotações são apenas uma marca e a lógica real deve ser implementada em uma classe específica. A anotação na etapa anterior especifica que a classe que implementa a função de verificação é IsMobileValidator.
// anotações personalizadas devem implementar a interface do restrintValidator, dois parâmetros nele // o primeiro é a anotação específica a ser verificada // O segundo é o tipo de parâmetro da classe pública de verificação ismobileValidator implementa restrintValidator <ismobile, string> {private boolean requery = false; Padrão final estático privado móvel_pattern = padrony.compile ("1 // d {10}"); // Método da ferramenta, determine se é um número de telefone celular public estático booleano ismobile (string src) {if (stringUtils.isEmpty (src)) {return false; } Matcher M = Mobile_pattern.Matcher (SRC); retornar m.matches (); } @Override public void Initialize (ismobile restrinsannotation) {requerir = restrintannotation.isRequired (); } @Override public boolean iSValid (String Phone, restrintValidatorContext restrintValidatorContext) {// É uma implementação de um número de telefone celular se (requerido) {return ismobile (telefone); } else {if (stringUtils.isEmpty (telefone)) {return true; } else {return ismobile (telefone); }}}} 3. Teste a função das anotações personalizadas
@Datapublic Class User {@NotNull @Size (min = 2, max = 30, message = "Por favor, verifique se há algum problema com o comprimento do nome") Nome da sequência privada; @NotNull @min (18) Idade do número inteiro privado; // Esta é a recém -adicionada anotação @ismobile Private String Phone;}4. Teste
passar
Há um problema com o número de celular
Pode -se observar que a anotação personalizada entrou em vigor.
Também podemos continuar a otimizar o local e criar uma nova exceção global. Se a verificação falhar, jogue exceções comerciais globais, pegue exceções comerciais e retorne informações rápidas amigáveis.
adicional
Também pode passar a verificação do método.
1. Adicione a anotação @validada ao controlador
2. Adicione anotações de verificação, @min, @max, etc. ao método do controlador.
@Validado@RestController@SpringBootApplicationPublic Classe APplication {public static void main (string [] args) {springapplication.run (userApplication.class, args); } @RequestMapping ("/test2") public String test2 (@ismobile string telefone) {return telefone + "ok"; } @ExceptionHandler (restrintviolationException.class) @ResponseBody Public Object handleconstraIntIolationException (restrintiolationException cve) {hashSet <String> messenset = new HashSet (); para (restrição de vínculo de violação: cve.getConstraintviolations ()) {messenset.add (restrintiolation.getMessage ()); } retornar mensagens; }} Regras de verificação de classe
afinal
Ao usar o dispositivo de verificação, não precisamos mais verificar todos os controladores. Se o código for muito refrescante, será. Escrevemos o código muito brevemente, mas devemos pensar em como escrever o código mais simples, mais claro e mais propício à manutenção. Escrever código duplicado é um desperdício do seu tempo.
Quando você encontra a verificação de parâmetros no futuro, a primeira coisa que você pensa é não verificar diretamente. Você pode descobrir se escreveu um certo tipo de verificador e pode usá -lo diretamente.
Resumir
O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.