Como anotações como @Override funcionam internamente em Java?

Alguém pode me explicar como as anotações funcionam internamente em java?

Eu sei como podemos criar anotações personalizadas usando a biblioteca java.lang.annotation em java. Mas ainda não entendi como funciona internamente, por exemplo, a anotação @Override.

Ficarei muito grato se alguém puder explicar isso em detalhes.

A primeira distinção principal entre os tipos de anotação é se eles são usados ​​em tempo de compilação e depois descartados (como @Override) ou colocados no arquivo de classe compilado e disponíveis em tempo de execução (como Spring @Component). Isso é determinado pela política @Retention da anotação. Se estiver escrevendo sua própria anotação, você precisará decidir se a anotação é útil em tempo de execução (para autoconfiguração, talvez) ou apenas em tempo de compilação (para verificação ou geração de código).

Ao compilar o código com anotações, o compilador vê a anotação da mesma forma que vê outros modificadores nos elementos de origem, como modificadores de acesso ( public/ private) ou final. Ao encontrar uma anotação, ele executa um processador de anotação, que é como uma classe de plug-in que diz que está interessado em uma anotação específica. O processador de anotação geralmente usa o Reflection API para inspecionar os elementos que estão sendo compilados e pode simplesmente executar verificações neles, modificá-los ou gerar um novo código a ser compilado. @Overrideé um exemplo do primeiro; ele usa a API do Reflection para garantir que pode encontrar uma correspondência para a assinatura do método em uma das superclasses e usa o Messagerpara causar um erro de compilação se não puder.

Existem vários tutoriais disponíveis sobre como escrever processadores de anotação; aqui está um útil . Olhe através dos métodos sobre a Processorinterface de por quanto o compilador invoca um processador de anotação; a operação principal ocorre no processmétodo, que é chamado sempre que o compilador vê um elemento que tem uma anotação correspondente.

Além do que outros sugeriram, recomendo que você escreva uma anotação personalizada e seu processador do zero para ver como a anotação funciona.

No meu, por exemplo, escrevi uma anotação para verificar se os métodos estão sobrecarregados em tempo de compilação.

Em primeiro lugar, crie uma anotação chamada Overload. Esta anotação é aplicada ao método, então eu a anoto com@Target(value=ElementType.METHOD)

package gearon.customAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(value=ElementType.METHOD)
public @interface Overload {

}

Em seguida, crie o processador correspondente para lidar com elementos anotados por anotação definida. Para o método anotado por @Overload, sua assinatura deve aparecer mais de uma vez. Ou o erro é impresso.

package gearon.customAnnotation;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;

@SupportedAnnotationTypes("gearon.customAnnotation.Overload")

public class OverloadProcessor extends AbstractProcessor{

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // TODO Auto-generated method stub
        HashMap<String, Integer> map = new HashMap<String, Integer>();

        for(Element element : roundEnv.getElementsAnnotatedWith(Overload.class)){
            String signature = element.getSimpleName().toString();
            int count = map.containsKey(signature) ? map.get(signature) : 0;
            map.put(signature, ++count);
        }

        for(Entry<String, Integer> entry: map.entrySet()){
            if(entry.getValue() == 1){
                processingEnv.getMessager().printMessage(Kind.ERROR, "The method which signature is " + entry.getKey() +  " has not been overloaded");
            }
        }
        return true;
    }
}

Após empacotar a anotação e seu processo em um arquivo jar, crie uma classe @Overloade use javac.exe para compilá-la.

import gearon.customAnnotation.Overload;

public class OverloadTest {
    @Overload
    public static void foo(){
    }

    @Overload
    public static void foo(String s){

    }

    @Overload
    public static void nonOverloadedMethod(){

    }
} 

Como nonOverloadedMethod()não foi realmente sobrecarregado, obteremos a saída como a seguir:

Aqui está @Override: http://www.docjar.com/html/api/java/lang/Override.java.html .

Não há nada de especial nele que o diferencie de uma anotação que você mesmo possa escrever. Os bits interessantes estão nos consumidores das anotações. Para uma anotação como @Override, isso seria no próprio compilador Java, ou uma ferramenta de análise de código estático, ou seu IDE.

Basicamente, as anotações são apenas marcadores que são lidos pelo compilador ou pelo aplicativo. Dependendo de sua política de retenção, eles estão disponíveis apenas em tempo de compilação ou podem ser lidos em tempo de execução usando reflexão.

Muitos frameworks usam retenção em tempo de execução, ou seja, eles verificam reflexivamente se algumas anotações estão presentes em uma classe, método, campo etc. e fazem algo se a anotação está presente (ou não). Além disso, os membros das anotações podem ser usados ​​para passar mais informações.

Siga este link . Isso fornecerá uma resposta próxima para o seu problema. Se nos concentramos nas anotações em Java, Annotations foram introduzidas no Java 5 e não são específicas do Spring. Em geral, as anotações permitem adicionar metadados a uma classe, método ou variável. Uma anotação pode ser interpretada pelo compilador (por exemplo, a anotação @Override) ou por uma estrutura como spring (por exemplo, a anotação @Component).

Além disso, estou adicionando mais referências.

1. http://www.codeproject.com/Articles/272736/Understanding-Annotations-in-Java
2. http://docs.oracle.com/javase/7/docs/api/java/lang/annotation/package-summary.html
3. http://www.coderanch.com/how-to/java/AnnotationsExample

Até eu procurava a resposta para a mesma pergunta. o link abaixo forneceu o material bom consolidado para obter o interior das anotações. https://dzone.com/articles/how-annotations-work-java Espero que ajude!