Como e onde as anotações são usadas em Java?

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

Anotações são meta-meta-objetos que podem ser usados ​​para descrever outros meta-objetos . Meta-objetos são classes, campos e métodos. Pedir um objeto para seu meta-objeto (por exemplo anObj.getClass()) é chamado de introspecção . A introspecção pode ir além e podemos perguntar a um meta-objeto quais são suas anotações (por exemplo aClass.getAnnotations). Introspecção e anotações pertencem ao que é chamado de reflexão e metaprogramação .

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

O processamento de anotações é 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 que agora são expressas com anotações precisavam ser armazenadas em outro lugar e os arquivos XML eram frequentemente usados. Mas é mais conveniente usar anotações porque elas pertencerão ao próprio código Java e, portanto, são muito mais fáceis de manipular que XML.

Uso de anotações:

• Documentação, por exemplo, XDoclet
• Compilação
• IDE
• Estrutura de teste, por exemplo, JUnit
• Recipiente 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...

... veja, por exemplo, o projeto Lombok , que usa anotações para definir como gerar equalsou hashCodemétodos.

Existem vários aplicativos para anotações 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 incorporado ao Java JDK. O compilador sinalizará um erro, se algum método for marcado com ele, o que não substitui um método herdado de uma classe base. Essa anotação pode ser útil para evitar o erro comum, no qual você realmente deseja substituir um método, mas falha ao fazê-lo, porque a assinatura fornecida no 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 ...;
    }
}

A partir do JDK7, as anotações são permitidas em qualquer tipo. Agora, esse recurso pode ser usado para anotações do compilador, como NotNull , como em:

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

que permite que o compilador avise sobre usos impróprios / não verificados de variáveis ​​e valores nulos .

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

As anotações são uma forma de metadados (dados sobre dados) adicionados a um arquivo de origem Java. Eles são amplamente utilizados por estruturas para simplificar a integração do código do cliente. Alguns exemplos do mundo real em cima da minha cabeça:

• JUnit 4 - você adiciona a @Testanotação a cada método de teste que deseja que o corredor JUnit execute. Também há anotações adicionais relacionadas à configuração de testes (como @Beforee @BeforeClass). Tudo isso é processado pelo corredor JUnit, que executa os testes de acordo. Você poderia dizer que é um substituto para a configuração XML, mas às vezes as anotações são mais poderosas (elas podem usar reflexão, por exemplo) e também estão mais próximas do código ao qual estão se referindo (a @Testanotação é logo antes do método de teste, portanto, o objetivo desse método é claro - também serve como documentação). Por outro lado, a configuração XML pode ser mais complexa e incluir muito mais dados do que as anotações.

• Terracota - usa anotações e arquivos de configuração XML. Por exemplo, a @Rootanotação informa ao tempo de execução Terracotta que o campo anotado é uma raiz e sua memória deve ser compartilhada entre instâncias da VM. O arquivo de configuração XML é usado para configurar o servidor e informar quais classes instrumentar.

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

Espero que tenha lhe dado uma amostra de como as anotações são usadas em diferentes estruturas.

As anotações em Java fornecem um meio para descrever classes, campos e métodos. Essencialmente, eles são uma forma de metadados adicionados a um arquivo de origem Java, não podem afetar diretamente a semântica de um programa. No entanto, as anotações podem ser lidas em tempo de execução usando o Reflection e esse processo é conhecido como Introspecção. Então poderia ser usado para modificar classes, campos ou métodos.

Esse recurso é frequentemente explorado por Bibliotecas e SDKs (hibernate, JUnit, Spring Framework) para simplificar ou reduzir a quantidade de código que um programador faria, a menos que fosse necessário para trabalhar com essas bibliotecas ou SDKs. Portanto, é justo dizer Anotações e Trabalho de reflexão em Java.

Também limitamos a disponibilidade de uma anotação ao tempo de compilação ou ao 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<TestAlpha> 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 estreitamente às estruturas de código (como mapeamentos JPA ou injeção de dependência no Spring) geralmente pode ser substituída por anotações e, em seguida, geralmente é muito menos detalhada, irritante e dolorosa. Praticamente todas as estruturas notáveis ​​fizeram essa troca, embora a configuração XML antiga geralmente permaneça como uma opção.

Existem 2 visualizações de anotações

1. na visualização do usuário, na maioria das vezes, as anotações funcionam como um atalho, economizam algumas teclas ou tornam seu programa mais legível

2. visão do fornecedor, a visão do processador da anotação é mais leve 'interface', seu programa enfrenta algo, mas sem explicitamente "implementa" a interface específica (aqui também conhecida como anotação)

por exemplo, no jpa você define algo como

@Entity class Foo {...}

ao invés de

class Foo implements Entity {...}

ambos falam a mesma coisa "Foo é uma classe de entidade"

Onde as anotações podem ser usadas

As anotações podem ser aplicadas a declarações: declarações de classes, campos, métodos 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: anotações também podem ser aplicadas ao uso de tipos. aqui estão alguns exemplos:

• Expressão de criação da instância de classe:

  novo @Interned MyObject ();

• Tipo de elenco:

  myString = (@NonNull String) str;

• implementa a cláusula:

  classe UnmodifiableList implementa @Readonly List <@Readonly T> {...}

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

  void monitorTemperature () lança @Critical TemperatureException {...}

Estruturas como o Hibernate, onde muitas configurações / mapeamentos são necessários, usam muito as anotações.

Dê uma olhada nas anotações do Hibernate

O JPA (do Java EE 5) é um excelente exemplo do uso (excessivo) de anotações. O Java EE 6 também apresentará anotações em muitas áreas novas, como serviços da web RESTful e novas anotações para cada uma das boas e antigas API Servlet.

Aqui estão vários recursos:

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

Não são apenas as especificidades da configuração que devem / podem ser assumidas pelas anotações, mas também podem ser usadas para controlar o comportamento. Você vê isso de bom nos exemplos JAX-RS do Java EE 6.

É útil para anotar suas classes, no nível de método, classe ou campo, algo sobre essa classe que não esteja totalmente relacionado à classe.

Você pode ter suas próprias anotações, usadas para marcar determinadas classes apenas como uso de teste. Pode ser simplesmente para fins de documentação ou você pode aplicá-lo filtrando-o durante a compilação de um candidato a release de produção.

Você pode usar anotações para armazenar alguns metadados, como em uma estrutura de plugins, por exemplo, nome do plug-in.

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

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

**

• A seguir estão as anotações 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 anotações:

@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 subclasses of annotated class (by default annotations are not inherited to subclasses).

**

• Anotações personalizadas:

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

PARA UMA COMPREENSÃO MELHOR DA TENTATIVA ABAIXO DO LINK: ELABORAR COM EXEMPLOS

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

As anotações 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 as anotações foram usadas para substituir arquivos de configuração, como Hibernate, JPA, EJB 3 e quase todas as tecnologias incluídas no Java EE.

Enfim, isso nem sempre é uma boa escolha. O objetivo de usar arquivos de configuração é geralmente separar o código dos detalhes do ambiente em que o aplicativo está sendo executado. Nessas situações, e principalmente quando a configuração é usada para mapear o aplicativo para a estrutura de um sistema externo, a anotação não é um bom substituto para o arquivo de configuração, pois permite incluir os detalhes do sistema externo no código-fonte do sua aplicação. Aqui, os arquivos externos devem ser considerados a melhor opção; 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 anotações 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 compilação quanto em tempo de execução, a lidar com classes e estruturas de classes de maneira especial. @Overridee os JUnit @Testsão bons exemplos desse uso, já explicados em detalhes em outras respostas.

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

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

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

As anotações Java também podem ser usadas em constantes enum. Tais anotações são colocadas imediatamente antes da constante enum que anotam. As 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 em detalhes as anotações Java .

A seguir, estão alguns dos lugares onde você pode usar anotações.

a. Annotations can be used by compiler to detect errors and suppress warnings
b. Software tools can use annotations to generate code, xml files, documentation etc., For example, Javadoc use annotations while generating java documentation for your class.
c. Runtime processing of the application can be possible via annotations.
d. You can use annotations to describe the constraints (Ex: @Null, @NotNull, @Max, @Min, @Email).
e. Annotations can be used to describe type of an element. Ex: @Entity, @Repository, @Service, @Controller, @RestController, @Resource etc.,
f. Annotation can be used to specify the behaviour. Ex: @Transactional, @Stateful
g. Annotation are used to specify how to process an element. Ex: @Column, @Embeddable, @EmbeddedId
h. Test frameworks like junit and testing use annotations to define test cases (@Test), define test suites (@Suite) etc.,
i. AOP (Aspect Oriented programming) use annotations (@Before, @After, @Around etc.,)
j. ORM tools like Hibernate, Eclipselink use annotations

Você pode consultar este link para obter mais detalhes sobre anotações.

Você pode consultar este link para ver como as anotações são usadas para criar um conjunto de testes simples.