As anotações Java fornecem algumas informações sobre o código, mas não afetam diretamente o conteúdo do código que anota. Neste tutorial, aprenderemos sobre as anotações Java, como personalizar anotações, o uso de anotações e como analisar anotações através da reflexão.
O Java 1.5 apresenta anotações, e muitas estruturas Java atualmente usam anotações amplamente, como Hibernate, Jersey e Spring. As anotações são incorporadas no programa como metadados do programa. As anotações podem ser analisadas por algumas ferramentas de análise ou ferramentas de compilação. Também podemos declarar que as anotações têm um efeito durante a compilação ou execução.
Antes de usar as anotações, os dados de origem do programa passam apenas pelas anotações Java e Javadoc, mas as anotações fornecem muito mais do que essas. As anotações não apenas contêm metadados, mas também podem atuar na sequência de execução do programa. O intérprete da anotação pode resolver a ordem de execução do programa por meio da anotação. Por exemplo, em Jersey Web Service, adicionamos uma anotação ** Path ** na forma de uma string de Uri ao método e, durante o programa em execução, o intérprete de Jerser determinará que o método chamará o URI fornecido.
Crie anotações personalizadas de Java
Criar uma anotação personalizada é semelhante à criação de uma interface, mas a palavra -chave da interface anotada precisa começar com o símbolo @. Podemos declarar métodos para anotação. Vamos primeiro olhar para o exemplo da anotação e depois discutiremos algumas de suas características.
pacote com.journaldev.annotações; importar java.lang.annotation.documented; importar java.lang.annotation.ElementType; importar java.lang.annotation.inseited; importar java.lang.annotation.retention; importação java.lang.annotation.retEntionPolicy; importar java.lang.langation.annotation.AnnOnTation.ANTENTEGETIGETIGENCIAL; @Documentado@target (elementType.method)@herdado@retention (retentionpolicy.runtime) public @Interface Methodinfo {string autor () padrão 'pankaj'; String date (); int revision () padrão 1; String Comments ();} O método de anotação não pode transportar parâmetros;
Os tipos de valor de retorno do método de anotação são limitados a: tipos básicos, string, enums, anotação ou matrizes desses tipos;
Os métodos de anotação podem ter valores padrão;
As próprias anotações podem conter meta -anotações, que são usadas para anotar outras anotações.
Aqui estão quatro tipos de meta -anotações :
1. @Documented - indica que os elementos que têm essa anotação podem ser documentados por ferramentas como o Javadoc. Esse tipo deve ser usado para anotar esses tipos que afetam a declaração do cliente de usar elementos anotados. Se uma declaração for anotada usando documentado, esse tipo de anotação anotada será usada como uma API pública para o membro do programa anotado.
2. @Target - indica o escopo dos elementos do programa que as anotações desse tipo podem anotar. Os valores desta meta -anotação podem ser do tipo, método, construtor, campo etc. Se a meta -anotação de destino não aparecer, a anotação definida poderá ser aplicada a qualquer elemento do programa.
3. @InHerited - indica que o tipo de anotação é herdado automaticamente. Se o usuário consultar esse tipo de anotação na classe atual e a declaração da classe atual não contiver esse tipo de anotação, ele também consultará automaticamente se a classe pai da classe atual possui uma meta -anotação herdada. Essa ação será repetida para saber que o tipo de anotação foi encontrado, ou a classe pai no nível superior é consultada.
4.@Retenção - Especifica o período de tempo em que a anotação é mantida. Os valores de retenção de policiências são de origem, classe, tempo de execução.
Anotações internas de Java
O Java fornece três anotações internas.
1. @Override - Quando queremos reescrever o método na classe pai, precisamos usar essa anotação para informar o compilador que queremos reescrever esse método. Dessa forma, o compilador solicitará uma mensagem de erro quando o método da classe pai for removido ou ocorrer alterações.
2. @Deprecated - Quando queremos que o compilador saiba que um método não é recomendado, devemos usar essa anotação. Java recomenda esta anotação no Javadoc, devemos fornecer por que esse método não é recomendado e métodos alternativos.
3. @suppresswarnings - Isso é apenas para dizer ao compilador para ignorar mensagens de aviso específicas, como o uso de tipos de dados nativos em genéricos. Sua política de retenção é fonte (Nota do tradutor: válida no arquivo de origem) e é descartada pelo compilador.
Vamos dar uma olhada em um exemplo de anotações internas em Java, consulte as anotações personalizadas mencionadas acima.
pacote com.journaldev.annotações; importar java.io.filenotfoundException; importar java.util.arraylist; importar java.util.list; public class AnnotationExample { public static void main(String[] args) {} @Override@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 1)public String toString() { return 'Overriden toString method';} @Deprecated@MethodInfo(comments = 'deprecated method', date = 'Nov 17 2012')public static Void OldMethod () {System.out.println ('Método antigo, não use -o. ArrayList (); L.Add ('ABC'); OldMethod ();}}Acredito que este exemplo pode ser auto-explicativo e pode ser exibido em diferentes cenários.
Análise de anotação de Java
Usaremos a tecnologia de reflexão para analisar as anotações das classes Java. Em seguida, a retenção de anotação deve ser definida como tempo de execução, caso contrário, as informações de anotação da classe Java não estarão disponíveis durante a execução; portanto, não podemos obter dados relacionados à anotação.
pacote com.journaldev.annotações; importar java.lang.annotation.annotation; importar java.lang.reflect.method; public class AnnotationParsing {public static void main (string [] args) {try {for (método método: anotoationParsing.class .getclassloader () .loadclass (('com.journalDev.annotations.annotation'). (Method.isannotationPresent (com.journalDev.annotações.methodinfo.class)) {try {// itera todas as anotações disponíveis no método para (anotação anno: method.getDecLaredannaTations ()) {System.out.println ('annation in métod' + Method ' +' '' '' '' '': ' + ANSTLO; } MétodInfo Metodanno = Method.getAnnotation (MethodInfo.class); if (Methodanno.Revision () == 1) {System.out.println ('Método com revisão nº 1 ='+ método); }} Catch (ex -jogável ex) {ex.PrintStackTrace (); }}}} Catch (SegurançaException | ClassNotFoundException e) {E.PrintStackTrace (); }}} Executar o programa acima será lançado:
Anotação no método 'public java.lang.string com.journalDev.annotações.annotationExample.toString ()': @com.journaldev.annotações.methodinfo (autor = pankaj, revision = 1, comentários = método principal, data = 17 de novembro de 2012) com revisão no 1 = public Java. com.journaldev.annotações.annotationExample.toString () anotação no método 'public static void com.journalDev.annotações.annotationExample.oldmethod ()': @java.lang.dev.deprecated () anotação no método 'public static com com.journaldSmmmmmmmmmmmmmmmmmmmmomation () annotation no método' public static com.JournalDsMmmmmmmmmmmmmmmmMott () Anotation no métod ' @com.journalDev.annoTations.methodinfo (autor = pankaj, revisão = 1, comentários = método depreciado, data = 17 de novembro de 2012) com revisão nº 1 = public static com.journalDev.annotations.annotationExample.oldmethod () anotation in metodstatic.notations com.journaldV. java.io.filenotfoundException ': @com.journaldev.annotações.methodinfo (autor = pankaj, revision = 10, comentários = método principal, data = 17 de novembro de 2012)
É tudo sobre este tutorial, e espero que você possa aprender algo com ele.