Como e onde as annotations são usadas em Java?

Quais são as principais áreas em que podemos usar Anotações? O recurso é um substituto para a configuração baseada em XML?

Anotações são meta-meta-objects que podem ser usados ​​para descrever outros meta-objects . Meta-objects são classs, campos e methods. Pedir um object para seu meta-object (por exemplo, anObj.getClass() ) é chamado de introspecção . A introspecção pode ir mais longe e podemos perguntar a um meta-object quais são suas annotations (por exemplo, aClass.getAnnotations ). Introspecção e annotations pertencem ao que é chamado de reflection e meta-programação .

Uma anotação precisa ser interpretada de uma maneira ou de outra para ser útil. Anotações podem ser interpretadas em tempo de desenvolvimento pelo IDE ou pelo compilador, ou em tempo de execução por uma estrutura.

O processamento de annotations é um mecanismo muito poderoso e pode ser usado de várias maneiras diferentes:

  • para descrever restrições ou uso de um elemento: por exemplo @Deprecated, @Override ou @NotNull
  • para descrever a “natureza” de um elemento, por exemplo @Entity, @TestCase, @WebService
  • para descrever o comportamento de um elemento: @Statefull, @Transaction
  • para descrever como processar o elemento: @Column, @XmlElement

Em todos os casos, uma anotação é usada para descrever o elemento e esclarecer seu significado .

Antes do JDK5, as informações agora expressas com annotations precisavam ser armazenadas em outro local e os arquivos XML eram usados ​​com frequência. Mas é mais conveniente usar annotations porque elas pertencem ao próprio código Java e, portanto, são muito mais fáceis de manipular do que XML.

Uso de annotations:

  • Documentação, por exemplo, XDoclet
  • Compilação
  • IDE
  • Estrutura de teste, por exemplo, JUnit
  • Contêiner IoC, por exemplo, como Spring
  • Serialização, por exemplo, XML
  • Programação orientada a aspectos (AOP), por exemplo, Spring AOP
  • Servidores de aplicativos, por exemplo, contêiner EJB, serviço da Web
  • Mapeamento Objeto-Relacional (ORM), por exemplo, Hibernate, JPA
  • e muitos mais…

… dê uma olhada, por exemplo, no projeto Lombok , que usa annotations para definir como gerar methods equals ou hashCode .

Existem vários aplicativos para as annotations do Java. Primeiro de tudo, eles podem ser usados ​​pelo compilador (ou extensões do compilador). Considere, por exemplo, a anotação Substituir :

 class Foo { @Override public boolean equals(Object other) { return ...; } } 

Este é realmente construído no Java JDK. O compilador sinalizará um erro, se algum método estiver marcado com ele, o que não substitui um método herdado de uma class base. Essa anotação pode ser útil para evitar o erro comum, no qual você realmente pretende replace um método, mas não consegue, porque a assinatura fornecida em seu método não corresponde à assinatura do método que está sendo substituído:

 class Foo { @Override public boolean equals(Foo other) { // Compiler signals an error for this one return ...; } } 

O próximo JDK7 permitirá annotations em qualquer tipo. Já existem propostas para usar esse recurso para annotations do compilador, como NotNull , como em:

 public void processSomething(@NotNull String text) { ... } 

o que pode permitir ao compilador avisá-lo sobre usos impróprios / não-verificados de variables ​​e valores nulos .

Outro aplicativo mais avançado para annotations envolve o processamento de reflexões e annotations em tempo de execução. Isso é (eu acho) o que você tinha em mente quando fala de annotations como “substituto para configuração baseada em XML”. Esse é o tipo de processamento de anotação usado, por exemplo, por vários frameworks e padrões JCP (persistência, injeção de dependência, o nome dele) para fornecer os metadados e as informações de configuração necessárias.

Anotações são uma forma de metadados (dados sobre dados) adicionados a um arquivo de origem Java. Eles são amplamente usados ​​por frameworks para simplificar a integração do código do cliente. Um par de exemplos do mundo real fora do topo da minha cabeça:

  • JUnit 4 – você adiciona a anotação @Test a cada método de teste que deseja que o executor da JUnit execute. Há também annotations adicionais relacionadas à configuração de testes (como @BeforeClass e @BeforeClass ). Todos estes são processados ​​pelo corredor JUnit, que executa os testes de acordo. Você poderia dizer que é um substituto para a configuração XML, mas as annotations às vezes são mais poderosas (elas podem usar reflection, por exemplo) e também estão mais próximas do código que estão referenciando (a anotação @Test está correta antes do método de teste a finalidade desse método é clara – serve também como documentação). A configuração XML, por outro lado, pode ser mais complexa e pode include muito mais dados do que as annotations.

  • Terracotta – usa annotations e arquivos de configuração XML. Por exemplo, a anotação @Root informa ao tempo de execução do Terracotta que o campo anotado é uma raiz e sua memory deve ser compartilhada entre as instâncias da VM. O arquivo de configuração XML é usado para configurar o servidor e informar quais classs instrumentar.

  • Google Guice – um exemplo seria a anotação @Inject , que, quando aplicada a um construtor, faz com que o runtime do Guice procure valores para cada parâmetro, com base nos injetores definidos. A anotação @Inject seria bastante difícil de replicar usando arquivos de configuração XML, e sua proximidade com o construtor ao qual faz referência é bastante útil (imagine ter que procurar um arquivo XML enorme para encontrar todas as injeções de dependência que você configurou).

Espero ter dado a você uma ideia de como as annotations são usadas em diferentes estruturas.

Anotações em Java, fornecem um meio para descrever classs, campos e methods. Essencialmente, eles são uma forma de metadados adicionados a um arquivo de origem Java, eles não podem afetar a semântica de um programa diretamente. No entanto, as annotations podem ser lidas em tempo de execução usando o Reflection e esse processo é conhecido como Introspection. Em seguida, ele poderia ser usado para modificar classs, campos ou methods.

Esse recurso é frequentemente explorado por Bibliotecas e SDKs (hibernação, JUnit, Spring Framework) para simplificar ou reduzir a quantidade de código que um programador faria a não ser para trabalhar com essas bibliotecas ou SDKs.Por isso, é justo dizer Anotações e Trabalho de reflection em conjunto em Java.

Também podemos limitar a disponibilidade de uma anotação para tempo de compilation ou tempo de execução. Abaixo, um exemplo simples de como criar uma anotação personalizada

Driver.java

 package io.hamzeen; import java.lang.annotation.Annotation; public class Driver { public static void main(String[] args) { Class obj = TestAlpha.class; if (obj.isAnnotationPresent(IssueInfo.class)) { Annotation annotation = obj.getAnnotation(IssueInfo.class); IssueInfo testerInfo = (IssueInfo) annotation; System.out.printf("%nType: %s", testerInfo.type()); System.out.printf("%nReporter: %s", testerInfo.reporter()); System.out.printf("%nCreated On: %s%n%n", testerInfo.created()); } } } 

TestAlpha.java

 package io.hamzeen; import io.hamzeen.IssueInfo; import io.hamzeen.IssueInfo.Type; @IssueInfo(type = Type.IMPROVEMENT, reporter = "Hamzeen. H.") public class TestAlpha { } 

IssueInfo.java

 package io.hamzeen; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * @author Hamzeen. H. * @created 10/01/2015 * * IssueInfo annotation definition */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface IssueInfo { public enum Type { BUG, IMPROVEMENT, FEATURE } Type type() default Type.BUG; String reporter() default "Vimesh"; String created() default "10/01/2015"; } 

É um substituto para a configuração baseada em XML?

Não completamente, mas a configuração que corresponde de perto a estruturas de código (como mapeamentos de JPA ou injeção de dependência no Spring) pode ser substituída por annotations e, em geral, é muito menos detalhada, irritante e dolorosa. Quase todos os frameworks notáveis ​​fizeram essa mudança, embora a antiga configuração XML geralmente permaneça como uma opção.

Existem 2 visualizações de annotations

  1. visualização do usuário, na maioria das vezes, as annotations funcionam como um atalho, economizam alguns toques de tecla ou tornam seu programa mais legível

  2. visão vendor, visão de anotação do processador é mais leve ‘interface’ ponderada, o seu programa faz o confronto com algo, mas sem explicitamente “implementa” a interface particular (aqui também conhecido como a anotação)

por exemplo, em jpa você define algo como

 @Entity class Foo {...} 

ao invés de

 class Foo implements Entity {...} 

ambos falam a mesma coisa “Foo é uma class de entidade”

Estruturas como o Hibernate foram muitas configurações / mapeamento é necessário usa Anotações fortemente.

Dê uma olhada nas annotations do Hibernate

O JPA (do Java EE 5) é um excelente exemplo do uso (excessivo) de annotations. O Java EE 6 também introduzirá annotations em várias áreas novas, como serviços da Web RESTful e novas annotations para cada uma das boas e antigas API do Servlet.

Aqui estão vários resources:

  • Sun – A API de persistência de Java
  • Tutorial do Java EE 5 – JPA
  • Apresentando a plataforma Java EE 6 (verifique todas as três páginas).

Não são apenas as especificidades de configuração que são / podem ser tomadas pelas annotations, mas elas também podem ser usadas para controlar o comportamento. Você vê isso de volta nos exemplos JAX-RS do Java EE 6.

Onde as annotations podem ser usadas

Anotações podem ser aplicadas a declarações: declarações de classs, campos, methods e outros elementos do programa. Quando usado em uma declaração, cada anotação geralmente aparece, por convenção, em sua própria linha.

Atualização do Java SE 8: as annotations também podem ser aplicadas ao uso de tipos. aqui estão alguns exemplos:

  • Expressão de criação de instância de class:

    novo @Interned MyObject ();

  • Digite cast:

    myString = (@NonNull String) str;

  • cláusula de implementos:

    class UnmodifiableList implementa @Readonly List < @Readonly T> {…}

  • Declaração de exceção lançada:

    void monitorTemperature () gera @Critical TemperatureException {…}

É útil para anotar suas classs, no nível de método, class ou campo, algo sobre essa class que não é bem relacionada à class.

Você pode ter suas próprias annotations, usadas para marcar determinadas classs apenas como teste. Pode ser simplesmente para propósitos de documentação ou você pode aplicá-lo filtrando-o durante a compilation de um release candidate de produção.

Você poderia usar annotations para armazenar alguns metadados, como em uma estrutura de plugins, por exemplo, o nome do plugin.

É apenas mais uma ferramenta, tem muitos propósitos.

Ele anexa informações adicionais sobre o código por (a) verificação de compilador ou (b) análise de código

**

  • A seguir estão as annotations internas: 2 tipos

**

Tipo 1) Anotações aplicadas ao código java:

 @Override // gives error if signature is wrong while overriding. Public boolean equals (Object Obj) @Deprecated // indicates the deprecated method Public doSomething().... @SuppressWarnings() // stops the warnings from printing while compiling. SuppressWarnings({"unchecked","fallthrough"}) 

Tipo 2) Anotações aplicadas a outras annotations:

 @Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at run-time through reflection. @Documented - Marks another annotation for inclusion in the documentation. @Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to @Inherited - Marks another annotation to be inherited to subclasss of annotated class (by default annotations are not inherited to subclasss). 

**

  • Anotações Personalizadas ::

** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations


PARA MELHOR COMPREENDER TENTE ABAIXO LINK: ELABORAR COM EXEMPLOS


http://www.javabeat.net/2007/08/annotations-in-java-5-0/

As annotations podem ser usadas como uma alternativa aos arquivos de configuração externos, mas não podem ser consideradas uma substituição completa. Você pode encontrar muitos exemplos em que annotationi foram usados ​​para replace arquivos de configuração, como Hibernate, JPA, EJB 3 e quase todas as tecnologias incluídas no Java EE.

De qualquer forma, isso nem sempre é uma boa escolha. O propósito de usar arquivos de configuração é geralmente separar o código dos detalhes do ambiente onde o aplicativo está sendo executado. Em tais situações, e principalmente quando a configuração é usada para mapear o aplicativo para a estrutura de um sistema externo, as annotations não são um bom substituto para o arquivo de configuração, pois elas trazem os detalhes do sistema externo dentro do código fonte do arquivo de configuração. sua aplicação. Aqui, arquivos externos devem ser considerados a melhor escolha, caso contrário, você precisará modificar o código-fonte e recompilar toda vez que alterar um detalhe relevante no ambiente de execução.

As annotations são muito mais adequadas para decorar o código-fonte com informações extras que instruem as ferramentas de processamento, tanto em tempo de compilation como em tempo de execução, para manipular classs e estruturas de classs de maneira especial. @Override e @Test da JUnit são bons exemplos de tal uso, já explicados em detalhes em outras respostas.

No final, a regra é sempre a mesma: manter dentro da fonte as coisas que mudam com a fonte e manter fora da fonte as coisas que mudam independentemente da fonte.

O Java EE 5 favorece o uso de annotations sobre a configuração XML. Por exemplo, no EJB3, os atributos de transação em um método EJB são especificados usando annotations. Eles ainda usam annotations para marcar POJOs como EJBs e para especificar methods específicos como methods de ciclo de vida, em vez de exigir essa implementação de uma interface.

O objective de uma anotação Java é simplesmente associar informações ao elemento do programa anotado. Anotações Java podem ser usadas como modificadores em qualquer declaração, seja pacote, class (incluindo enums), interface (incluindo tipos de anotação), campo, método, parâmetro formal, construtor ou variável local.

Anotações Java também podem ser usadas em constantes enum. Essas annotations são colocadas imediatamente antes da constante de enumeração que anotam. Anotações Java são colocadas convencionalmente antes de todos os outros modificadores, mas isso não é um requisito; eles podem ser livremente misturados com outros modificadores.

Leia detalhadamente em Anotações Java .