Este artigo apresenta a redação de uma AOP baseada na inicialização do Spring e no JDK8, combinando anotações personalizadas para obter verificação de parâmetros de interface comum.
razão
Atualmente, o método comumente usado de verificação de parâmetros é adicionar anotações na classe de entidade, mas para diferentes métodos, as regras de verificação aplicadas também são diferentes. Por exemplo, existe uma entidade da conta:
public class AccountVo {private String Name; // nome da idade inteira privada; // Idade}Suponha que haja um negócio: quando um usuário se registra, ele ou ela precisa preencher seu nome e, quando um usuário faz login, ele ou ela só precisa preencher seu nome. Obviamente, é obviamente inapropriado adicionar regras de verificação às classes de entidade.
Portanto, sempre quis implementar uma verificação de parâmetros no nível do método. Métodos diferentes podem aplicar regras de verificação diferentes para os mesmos parâmetros da entidade, que deram origem a essa ferramenta e têm sido usados no trabalho diário há muito tempo.
introduzir
Vamos dar uma olhada em como usá -lo primeiro:
@ServicePublic Classe Testimpl implementa o itestService {@Override @Check ({"Name", "Age"}) public void testValid (Accountvo Vo) {// ...}}A anotação @Check no método indica que as propriedades de nome e idade no parâmetro contaVo não podem estar vazias. Além da verificação não vazia, também suporta o julgamento de tamanho e a verificação da igualdade:
@Check ({"id> = 8", "nome! = Aaa", "título <10"})A mensagem de erro padrão retorna campos, causas de erro e métodos chamados, como:
UpdateUserID não deve nulo enquanto chama o testValidid deve> = 8 enquanto chama testValidName deve! = AAA enquanto chama o testValid
As informações de retorno de erro personalizado também são suportadas:
@Check ({"Title <= 8: O número de caracteres de título não excede 8 caracteres, incluindo marcas de pontuação"}) public void testValid (testpo po) {// ...}Basta adicionar: após a regra de verificação e gravar informações personalizadas, que substituirão a mensagem de erro padrão.
PS: O princípio principal é obter o valor do campo na entidade do parâmetro através da reflexão e verificá -lo de acordo com as regras. Portanto, atualmente apenas métodos que contêm um parâmetro são suportados e os parâmetros não podem ser do tipo básico.
usar
Como usar o AOP no Spring-Boot Não entrarei em detalhes aqui e introduzirei principalmente o código principal na AOP.
Dependências do MAVEN
Além das dependências de botas de primavera, as dependências de terceiros necessárias não são dependências essenciais e você pode escolher de acordo com seus hábitos pessoais:
<!-para verificação de string-> <pendency> <puperiD> org.apache.commons </foupiD> <TRAFACTID> Commons-lang3 </stifactId> <versão> 3.3.2 </versão> </dependency> <!-para a impressão de log-> <pendency> <purgiD> org.slf4j </grupo> <Versão> 1.7.25 </sisters> </dependency>
Anotações personalizadas
importar java.lang.annotation.ElementType; importar java.lang.annotation.retention; importar java.lang.annotation.target; importar java.lang.annotation.retentionpolicy.runtime;/** ** ** parâmetro AnnOtation* criado por cipher em 2017/99/20. */@Target ({ElementType.Type, ElementType.Method})@Retention (RUNTIME) Public @Interface Verificação {// Regras de verificação de campo, formato: Nome do campo + Regras de verificação + Mensagem de Erro, por exemplo: ID <10: ID deve ser menor que 10 String [] valor ();}Código central
Ao interceptar o método da interface com a anotação @Check, execute a verificação de parâmetros antes que o método seja executado. Se houver uma mensagem de erro, ele será devolvido diretamente:
@Around (value = "@com.cipher.checker.check") // Aqui você precisa alterar para o caminho da anotação de anotação personalizada Verificação de objetos públicos (prosseguir o ponto de ponto) lança arremesso {objeto obj; // String de verificação de parâmetros msg = DOCHECK (ponto); if (! stringUtils.IsEmpty (msg)) {// Aqui você pode retornar a classe de retorno encapsulada lançar novo ilegalargumentException (msg); } obj = Point.proeced (); retornar obj;}O método de verificação do núcleo no método DOCHECK, o principal princípio é obter o nome do campo e as regras de verificação especificadas na anotação, obter o valor do campo correspondente na entidade do parâmetro através da reflexão e, em seguida, execute a verificação:
/*** Verificação de parâmetros** @param Point ProceedingJoinPoint* @return Error Message*/Private String Docheck (Ponto de ProssingJoinPoint) {// Get Method Parâmetro Valor Object [] Argumments = Point.getargs (); // Método do método Get Método = GetMethod (Point); String MethodInfo = StringUtils.isEmpty (Method.getName ())? "": "enquanto chama" + métod.getName (); String msg = ""; if (ischeck (método, argumentos)) {verifique a anotação = métod.getannotation (check.class); String [] campos = anotação.value (); Objeto vo = argumentos [0]; if (vo == null) {msg = "param não pode ser nulo"; } else {for (campo de string: campos) {// analisando o campo FieldInfo info = resolvefield (campo, métodInfo); // obtenha o valor do valor do objeto de campo = refletionUtil.invokegetter (vo, info.field); // execute a regra de verificação booleana isValid = info.optenum.fun.apply (valor, info.operatornum); msg = isValid? msg: info.innermsg; }}} retornar msg;}Você pode ver que a lógica principal é:
Parse Campos -> Obtenha o valor dos campos -> Regras de verificação de execução
Uma classe de enumeração é mantida internamente e as operações de verificação relevantes são especificadas nela:
/** * Operação enum */enum Operador {/** * maior que */maior_than (">", checkParamaspect :: isGreaterthan),/** * maior ou igual a */maior_thean_equal ("> =", checkParamaspect :: isGreaterThanequal,/** * menos */menos */" / *** Menos ou igual a* / less_than_equal ("<=", checkParamaspect :: islessThanequal), / *** não é igual a* / não_equal ("! Valor de String Private; bifuncionamento privado <objeto, string, boolean> diversão; Operador (valor da string, bifuncionamento <objeto, string, boolean> diversão) {this.value = value; this.fun = diversão; }} Por razões de espaço, não expandirei todos os códigos um por um. Amigos interessados podem obter todos os códigos de origem no seguinte endereço: Ciphermagic/Java-Learn/Sandbox/Checker
PENDÊNCIA
afinal
Obrigado pela sua leitura. Amigos que gostam pode gostar no Github. Se você tiver alguma dúvida ou sugestão, deixe uma mensagem abaixo e aguarde sua resposta.
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.