Comment faire des annotations comme @Override de travail en interne en Java?

En plus de ce que d'autres ont suggéré, je vous recommande de rédiger une mesure d'annotation et de son processeur à partir de zéro pour voir comment l'annotation des œuvres.

Dans le mien, par exemple, j'ai écrit une annotation pour vérifier si les méthodes sont surchargées au moment de la compilation.

Tout d'abord, créez une annotation nommé Overload. Cette annotation est appliqué à la méthode donc je l'annoter avec @Target(value=ElementType.METHOD)

package gearon.customAnnotation;

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

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

}

Ensuite, créez processeur correspondant à manipuler les éléments annotés par annotation définie. Pour la méthode annotée par @Overload, sa signature doit apparaître plus d'une fois. Ou l'erreur est imprimé.

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;
}
}

Après l'emballage, d'annotation et de ses processus dans un fichier jar, créer une classe avec @Overload et l'utilisation javac.exe pour le compiler.

import gearon.customAnnotation.Overload;
public class OverloadTest {
@Overload
public static void foo(){
}
@Overload
public static void foo(String s){
}
@Overload
public static void nonOverloadedMethod(){
}
} 

Depuis nonOverloadedMethod() n'a pas été surchargé, nous allons obtenir le résultat comme ci-dessous:

Fondamentalement, les annotations sont juste des marqueurs qui sont lus par le compilateur ou de l'application.
En fonction de leur stratégie de rétention, ils sont disponibles au moment de la compilation uniquement ou sont lisibles au moment de l'exécution à l'aide de la réflexion.

De nombreux cadres de l'utilisation d'exécution de rétention, c'est à dire qu'ils reflectively vérifier si certaines d'entre elles sont présentes sur une classe, une méthode, terrain etc. et de faire quelque chose si l'annotation est présente (ou pas). En outre, les membres des annotations peuvent être utilisés pour transmettre de plus amples informations.