De fato, é um método que pode ser usado para definir anotações personalizadas através do @Constraint.
@Constraint (validadoBy = xxxx.class)
Abaixo está um exemplo de código da anotação personalizada Java que fiz para implementar a verificação de parâmetros frontal e de back -end
Se você estiver interessado nisso, leia -o com cuidado e aprenda com cuidado:
pacote sonn.sonnannotation; importar java.lang.annotation.documented; importar java.lang.annotation.ElementType; importar java.lang.annotation.retEntion; importação java.lang.annotation.retEntionPolicy; import java.lang.annOtation.target; javax.validation.ConstraintValidator;import javax.validation.ConstraintValidatorContext;import javax.validation.Payload;import sonn.util.StringUtill;/*** @ClassName: IsValidString * @Description: Custom annotations implement front and backend parameter verification to determine whether they contain illegal characters* @author Unnamed* @date 2016-7-25 20:22:58 PM * @Version 1.0 */@Target ({ElementType.Field, ElementType.method})@Retention (retentionPolicy.Runtime) @Constraint (ValidatedBy = ISValidstring.ValidstringChecker.class) @DocumentDedPublic @Interface IsValid. Classe <?> [] Grupos () padrão {}; Classe <? estende a carga de pagamento> [] Payload () padrão {}; classe ValidStringChecker implementa restrintValidator <isValidString, string> {@Override public void Initialize (isValidString arg0) {} @Override public boolean isValid (string strvalue, restrintValidContext context) {if (stringutill.IsstringEmpty (StrValue) {render; } if (strvalue.contains ("<")) {return false; } retornar true; }}}O código acima define a lógica do método da anotação através do @Constraint (validadoBy = isValidString.ValidStringChecker.class)-A classe interna da classe de anotação chamada ValidStringChecker.
Esta classe interna implementa o restrintValidator <isValidString, string> interface
A documentação oficial descreve assim:
javax.validação
Interface restantValidator <a estende a anotação, t>
•
--------------------------------------------------------------------------------------------------------------------------------------------------
Public Interface restantValidator <a estende a anotação, t> define a lógica para validar uma determinada restrição a para um determinado tipo de objeto T.
As implementações devem cumprir as seguintes restrições:
• T deve resolver um tipo não parametrizado
• ou parâmetros genéricos de t devem ser tipos de curinga ilimitados
A anotação suportada ValidationTarget pode ser colocada em uma implementação do restrintValidator para marcá-lo como restrições de parâmetros cruzados. Confira o suporte da SupportedValidationTerget e a restrição para obter mais informações.
O método ISValid implementado é o método de verificação dessa interface.
Teste o efeito e adicione anotações ao campo da classe de entidade a ser verificado:
Escreva a página do artigo, adicione '<' no título do artigo e envie:
A submissão falhou, com um erro de 500, indicando que a anotação entra em vigor:
Mas ainda há problemas com isso. O site do meu blog não pode imprimir a mensagem de erro diretamente. Você ainda precisa criar uma página de erro.
Isso é simples, adicione o caminho da página de erro no web.xml e, em seguida, faça uma página:
<rort-Page>
<Code> 500 </code>
<Cathery> /error.jsp </catching>
</error-página>
Primeiro, vamos apresentar alguns conceitos básicos:
1.java define uma anotação com @interface xx {}.
A anotação não é realmente misteriosa, é apenas uma marca. Quando o programa é executado na marca, ele executa a lógica correspondente. As próprias anotações são uma classe.
2. Ao definir anotações, rotular algumas anotações pode representar significados específicos:
@Retention (retentionPolicy.source) // A anotação existe apenas no código -fonte e não o contém no arquivo ByteCode de classe.
@Retention (retentionpolicy.class) // A política de retenção padrão, a anotação existirá no arquivo ByteCode de classe, mas não pode ser obtido durante o tempo de execução.
@Retention (retentionpolicy.runtime) // A anotação existirá no arquivo ByteCode Class e pode ser obtida através da reflexão no tempo de execução.
(Vale a pena notar o tempo de execução porque significa que pode ser recuperado por reflexão)
@Target (elementType.type) // interface, classe, enumeração, anotação
@Target (elementType.field) // constante para campos e enums
@Target (elementType.method) // Método
@Target (elementType.parameter) // parâmetros do método
@Target (elementType.Constructor) // construtor
@Target (elementType.local_variable) // variáveis locais
@Target (elementType.annotation_type) // anotação
@Target (elementType.package) // pacote
Existe uma maneira de adicionar @Taget (xx) e @retention (retentionpolicy.runtime) ao definir anotações, mas não escrevem métodos nas anotações. Eles apenas usam o mecanismo de reflexão para obter as anotações em tempo de execução e depois escrevem a lógica correspondente (o chamado analisador de anotação)
Provavelmente uma maneira semelhante de escrever:
importar java.lang.annotation.documented; importar java.lang.annotation.ElementType; importar java.lang.annotation.Irited; importar java.lang.annotation.retention; importação java.lang.annotation.retEntionPolicy; importar java.lang.langation.annOtation.annTation.annotation.retEntionPolicy; importar ElementType.Field, ElementType.Method}) @Retention (RetentionPolicy.Runtime) Public @Interface validate {public int min () padrão 1; public int max () padrão 10; public boolean isNotNull () padrão true;}Ao executar mais tarde, use a reflexão para obter anotações e não discutirei os detalhes.
Encontrei esse tipo de artigos técnicos sobre isso antes de procurar artigos técnicos na internet, o que me trouxe uma grande confusão naquele momento. Acho que não quero.
O exemplo acima da anotação personalizada Java para implementar a verificação de parâmetros frontal e back -end é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.