Les annotations de Java 5.0

public @interface TODO {
}

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.SOURCE;

@Documented
@Retention(SOURCE)
public @interface TODO {
}

    @TODO
    public void doSometing () {
        /* ... */
    }

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.SOURCE;

@Documented
@Retention(SOURCE)
public @interface TODO {
    /** Message décrivant la tâche à effectuer. */
    String value();
}

    /**
     * Commentaire de la méthode...
     */
    @TODO(value="La gestion des exceptions est incorrecte...")
    public void doSometing () {
        /* ... */
    }

    /**
     * Commentaire de la méthode...
     */
    @TODO("La gestion des exceptions est incorrecte...")
    public void doSometing () {
        /* ... */
    }

  @TODO(value="La gestion des exceptions est incorrecte...")
  public void doSometing()
  
        Commentaire de la méthode...

    @MonAnnotation (tab={1,2,3,4,5})
    public clas MaClasse {
    }

    @MonAnnotation (tab=1)
    public clas MaClasse {
    }

@Documented
@Retention(SOURCE)
public @interface TODO {
    
    /** Message décrivant la tâche à effectuer. */
    String value();
    /** Niveau de criticité de la tâche. */
    Level  level();
    
    /** Énumération des différents niveaux de criticités. */
    public static enum Level { MINEUR, NORMAL, IMPORTANT };
    
}

    @TODO(value="La gestion des exceptions est incorrecte...", level=TODO.Level.NORMAL)
    public void doSometing () {
        /* ... */
    }

import static com.developpez.adiguba.annotation.TODO.Level.*;

/* ... */

    @TODO(value="La gestion des exceptions est incorrecte...", level=NORMAL)
    public void doSometing () {
        /* ... */
    }

@Documented
@Retention(SOURCE)
public @interface TODO {
    
    /** Message décrivant la tâche à effectuer. */
    String value();
    /** Niveau de criticité de la tâche (défaut : NORMAL). */
    Level  level() default Level.NORMAL;
    
    /** Énumération des différents niveaux de criticités. */
    public static enum Level { MINEUR, NORMAL, IMPORTANT };
    
}

    @TODO("La gestion des exceptions est incorrecte...")
    public void doSometing () {
        /* ... */
    }
    
    @TODO(value="La gestion des exceptions est incorrecte...")
    public void doSometing () {
        /* ... */
    }
    
    @TODO(value="La gestion des exceptions est incorrecte...", level=NORMAL)
    public void doSometing () {
        /* ... */
    }

    @TODO(level=NORMAL, value="La gestion des exceptions est incorrecte...")
    public void doSometing () {
        /* ... */
    }

@Documented
@Retention(SOURCE)
public @interface TODOs {
    /** Le Tableau des différentes annotations TODO. */
    TODO[] value();
}

    @TODOs({
        @TODO("La gestion des exceptions est incorrecte..."),
        @TODO(value="NullPointerException possible dans certain cas.",level=IMPORTANT)
    })
    public void doSometing () {
        /* ... */
    }

public class SimpleAnnotationProcessorFactory implements AnnotationProcessorFactory {
    
    /** Collection contenant le nom des Annotations supportées. */
    protected Collection<String> supportedAnnotationTypes =
        Arrays.asList( TODO.class.getName(), TODOs.class.getName() );
    
    /** Collection des options supportées. */
    protected Collection<String> supportedOptions =
        Collections.emptyList();

    /**
     * Retourne la liste des annotations supportées par cette Factory.
     */
    public Collection<String> supportedAnnotationTypes() {
        return supportedAnnotationTypes;
    }

    /**
     * Retourne la liste des options supportées par cette Factory.
     */
    public Collection<String> supportedOptions() {
        return supportedOptions;
    }
    
    /**
     * Retourne l'AnnotationProcessor associé avec cette Factory...
     */
    public AnnotationProcessor getProcessorFor(Set<AnnotationTypeDeclaration> atds,
            AnnotationProcessorEnvironment env) {
        // Si aucune annotation n'est présente on retourne un processeur "vide"
        if (atds.isEmpty())
            return AnnotationProcessors.NO_OP;
        return new SimpleAnnotationProcessor(env);
    }

}

public class SimpleAnnotationProcessor implements AnnotationProcessor {
    
    /** L'environnement du processeur d'annotation. */
    protected final AnnotationProcessorEnvironment env;
    
    /**
     * Constructeur.
     * @param env L'environnement du processeur d'annotation.
     */
    public SimpleAnnotationProcessor (AnnotationProcessorEnvironment env) {
        this.env = env;
    }

    /**
     * Traitement des fichiers sources.
     */
    public void process() {
        // Instanciation du Visitor
        TODOVisitor todoVisitor = new TODOVisitor(env);
        
        // On boucle sur toutes les Annotations :
        for ( Declaration d : env.getTypeDeclarations()) {

            // On "visite" chacune des déclarations trouvées :
            d.accept( DeclarationVisitors.getSourceOrderDeclarationScanner(
                    todoVisitor, DeclarationVisitors.NO_OP) );
        }
    }
}

public class TODOVisitor extends SimpleDeclarationVisitor{

    protected final AnnotationProcessorEnvironment env;
    
    public TODOVisitor (AnnotationProcessorEnvironment env) {
        this.env = env;
    }

    /**
     * Pour tout type de déclaration, on affiche un message si
     * l'Annotation @TODO est présente...
     * De même, on affiche un message pour tous les @TODO
     * contenu dans l'annotation @TODOs
     */
    @Override
    public void visitDeclaration(Declaration decl) {
        
        // On regarde si la déclaration possède une annotation TODO
        TODO todo = decl.getAnnotation(TODO.class);
        // Et on l'affiche éventuellement :
        if (todo!=null)
            printMessage(decl, todo);
        
        // On fait la même chose pour l'annotation TODOs :
        TODOs todos = decl.getAnnotation(TODOs.class);
        if (todos!=null) {
            // On affiche les messages pour tous les TODOs :
            for ( TODO t : todos.value() )
                printMessage(decl,t);
        }
    }
    
    /**
     * Affiche dans la console l'annotation TODO.
     * @param decl
     * @param todo
     */
    public void printMessage (Declaration decl, TODO todo) {
        m.printNotice(decl.getSimpleName() + " : " + todo.value() );
    }

import com.developpez.adiguba.annotation.TODO;
import static com.developpez.adiguba.annotation.TODO.Level.*;

public class Test {

    @TODO("Utiliser une annotation à la place d'une String")
    protected String day;


    @TODO(value="Ecrire le code de la methode", level=IMPORTANT)
    public void method() {
    }

}

Note: day : Utiliser une annotation à la place d'une String
Note: method : Ecrire le code de la methode

public class TODOVisitor extends SimpleDeclarationVisitor{

    protected final AnnotationProcessorEnvironment env;
    /** Indique si l'option -Arelease fait partie de la ligne de commande. */
    protected final boolean isRelease;
    
    public TODOVisitor (AnnotationProcessorEnvironment env) {
        this.env = env;
        isRelease = env.getOptions().containsKey(SimpleAnnotationProcessorFactory.RELEASE);
    }

    /**
     * Pour tout type de déclaration, on affiche un message si
     * l'Annotation @TODO est présente...
     * De même, on affiche un message pour tous les @TODO
     * contenu dans l'annotation @TODOs
     */
    @Override
    public void visitDeclaration(Declaration decl) {
        
        // On regarde si la déclaration possède une annotation TODO
        TODO todo = decl.getAnnotation(TODO.class);
        // Et on l'affiche éventuellement :
        if (todo!=null)
            printMessage(decl, todo);
        
        // On fait la même chose pour l'annotation TODOs :
        TODOs todos = decl.getAnnotation(TODOs.class);
        if (todos!=null) {
            // On affiche les messages pour tous les TODOs :
            for ( TODO t : todos.value() )
                printMessage(decl,t);
        }
    }
    
    /**
     * Affiche dans la console l'annotation TODO.
     * @param decl
     * @param todo
     */
    public void printMessage (Declaration decl, TODO todo) {
        if (isRelease)
            printReleaseError (decl, todo);
        else
            printDebugingInfo (decl, todo);
    }
    
    /**
     * Affiche le message pendant la phase de developpement.
     * Les messages IMPORTANT sont affichés comme des 'warnings'.
     * Les messages NORMAL sont affichés comme des 'notes'.
     * Les messages MINEUR sont affichés comme des 'notes' simples (sans position dans le code).
     * @param decl La déclaration qui contient l'annotation.
     * @param todo L'Annotation affichée.
     */
    public void printDebugingInfo (Declaration decl, TODO todo) {
        Messager m = env.getMessager();
        
        switch (todo.level()) {
            case IMPORTANT:
                m.printWarning(decl.getPosition(),
                    decl.getSimpleName() + " : " + todo.value() );
                break;
            case NORMAL:
                m.printNotice(decl.getPosition(),
                    decl.getSimpleName() + " : " + todo.value() );
                break;
            case MINEUR:
                m.printNotice(decl.getSimpleName() + " : " + todo.value() );
                break;
        }
    }
    
    /**
     * Affiche le message pendant la compilation en mode release.
     * Les messages IMPORTANT sont affichés comme des 'erreurs'.
     * Les messages NORMAL sont affichés comme des 'warning'.
     * Les messages MINEUR sont affichés comme des 'notes'.
     * @param decl La déclaration qui contient l'annotation.
     * @param todo L'Annotation affichée.
     */
    public void printReleaseError (Declaration decl, TODO todo) {
        Messager m = env.getMessager();
        
        switch (todo.level()) {
            case IMPORTANT:
                m.printError(decl.getPosition(),
                    decl.getSimpleName() + " : " + todo.value() );
                break;
            case NORMAL:
                m.printWarning(decl.getPosition(),
                    decl.getSimpleName() + " : " + todo.value() );
                break;
            case MINEUR:
                m.printNotice(decl.getPosition(),
                    decl.getSimpleName() + " : " + todo.value() );
                break;
        }
    }
}

Test.java:7: Note: day : Utiliser une annotation à la place d'une String
        protected String day;
                         ^
Test.java:11: warning: method : Ecrire le code de la methode
        public void method() {
                    ^
1 warning

Test.java:7: warning: day : Utiliser une annotation à la place d'une String
        protected String day;
                         ^
Test.java:11: method : Ecrire le code de la methode
        public void method() {
                    ^
1 error
1 warning

warning: Annotation types without processors

public class StandardAnnotationProcessorFactory implements AnnotationProcessorFactory  {
    
    /** Collection contenant le nom des Annotations supportées. */
    protected Collection<String> supportedAnnotationTypes =
        Arrays.asList( 
                // Annotation Standard
                "java.lang.*",
                // Meta-Annotation
                "java.lang.annotation.*"
        );
    
    /**
     * Retourne la liste des annotations supportées par cette Factory.
     */
    public Collection<String> supportedAnnotationTypes() {
        return supportedAnnotationTypes;
    }

    /**
     * Retourne la liste des options supportées par cette Factory.
     */
    public Collection<String> supportedOptions() {
        return Collections.emptyList();
    }
    
    /**
     * Retourne AnnotationProcessors.NO_OP (Pas de traitement).
     */
    public AnnotationProcessor getProcessorFor(Set<AnnotationTypeDeclaration> atds,
            AnnotationProcessorEnvironment env) {        
        return AnnotationProcessors.NO_OP;
    }
}

@Inherited
@Documented
@Target(ElementType.TYPE)
public @interface EmptyConstructor {
}

public class EmptyConstructorVisitor extends SimpleDeclarationVisitor {
    
    /** L'environnement du processeur d'annotation. */
    protected final AnnotationProcessorEnvironment env;
    
    /**
     * Constructeur.
     * @param env L'environnement du processeur d'annotation.
     */
    public EmptyConstructorVisitor (AnnotationProcessorEnvironment env) {
        this.env = env;
    }

    /**
     * Méthode appelée pour chaque déclaration d'une classe.
     */
    @Override
    public void visitClassDeclaration(ClassDeclaration classDecl) {

        // Si on n'a pas de constructeur vide et
        // que l'annotation EmptyConstructor a été trouvée
        // --> On affiche un message d'erreur :
        if ( !hasEmptyConstructor(classDecl) && 
                hasAnnotation(classDecl,EmptyConstructor.class) ) {
            env.getMessager().printError( classDecl.getPosition(),
                    "Un constructeur vide est requis par @EmptyConstructor.");
        }
    }
    
    /**
     * Cette méthode indique si la déclaration de classe passée en
     * paramètre possède un constructeur vide.
     * @param classDecl La déclaration de classe à analyser.
     * @return true si la classe possède un constructeur vide, false sinon.
     */
    public boolean hasEmptyConstructor (ClassDeclaration classDecl) {
        // On parcourt la liste des constructeurs :
        for ( ConstructorDeclaration c : classDecl.getConstructors() ) {
            if ( c.getParameters().isEmpty() )
                return true; // On a trouvé un constructeur vide
        }
        return false; // Pas de constructeur vide
    }

    /**
     * Recherche récursivement dans les interfaces si une Annotation est présente.<br/>
     * En effet, les annotations présentes dans les interfaces ne sont pas héritées...
     * @param typeDecl Le type de base de la recherche.
     * @param annotationClass La classe de l'annotation à rechercher
     * @return <b>true</b> si une annotation de type <b>annotationClass</b> est trouvée, <b>false</b> sinon.
     */
    public boolean hasAnnotation (TypeDeclaration typeDecl, Class<? extends Annotation> annotationClass) {

        // Pour chaque interface directement implémentée :
        for ( InterfaceType iType : typeDecl.getSuperinterfaces() ) {
            InterfaceDeclaration superInterface = iType.getDeclaration();

            // On regarde si l'interface possède l'annotation
            if ( superInterface.getAnnotation(EmptyConstructor.class)!=null )
                return true; // On en a trouvé une : pas la peine de continuer ;)
            
            // Sinon on regarde dans les interfaces parentes :
            if ( hasAnnotation(superInterface,annotationClass) )
                return true; // On en a trouvé une : pas la peine de continuer ;)
            
        }
        // Si on arrive ici cela signifie que l'on n'a pas trouvé l'Annotation.
        return false;
    }
}

    <javac fork="yes" executable="apt" srcdir="${src}" destdir="${build}">
        <classpath>
            <pathelement path="tutoriel-annotations.jar"/>
        </classpath>
        <compilerarg value="-Arelease"/>
    </javac>

    // Instanciation de l'objet
    Exemple objet = new Exemple();
    
    // On récupère la classe de l'objet :
    Class<Exemple> classInstance = objet.getClass();
    
    // On regarde si la classe possède une annotation :
    MonAnnotation annotation = classInstance.getAnnotation(MonAnnotation.class);
    if (annotation!=null) {
        System.out.println ("Annotation TODO : " + annotation.value() );
    }

public MaClasse {
    private String config1 = Manager.getInstance().getProperty("property_1");
    private String config2 = Manager.getInstance().getProperty("property_2");
    private String config3 = Manager.getInstance().getProperty("property_3");
    private String config4 = Manager.getInstance().getProperty("property_4");
    
    public MaClasse () {
    }
}

/**
 * Permet d'indiquer la propriété associée à un champ ou une méthode.
 * @author adiGuba
 */
@Documented
@Retention(RUNTIME)
@Target(FIELD)
public @interface Property {
    
    /** Nom de la propriété liée à cet élément. */
    String value ();
    /** Valeur si l'élément est absent (optionnel / "" par défaut). */
    String missing() default "";
}

public MaClasse {
    @Property("property_1") private String config1;
    @Property("property_2") private String config2;
    @Property("property_3") private String config3;
    @Property("property_4") private String config4;
    
    public MaClasse () {
        Manager.getInstance().initialize(this);
    }
}

public void initialize (Object pObjectInstance) 
    throws PropertyManagerException {

    // On récupère la classe de l'objet.
    Class<?> lClassInstance = pObjectInstance.getClass();
    
    // Pour tous les champs de l'objet :
    for ( Field f : pClassInstance.getDeclaredFields() ) {
        // On recherche l'annotation @Property :
        Property property = f.getAnnotation(Property.class);
        if (property!=null) {
            // On récupère la valeur dans le Properties
            String value = lProp.getProperty(lPrefix+property.value());
            // Si la propriété n'existe pas on met la valeur par défaut :
            if (value==null)
                value= property.missing();
            
            try {
                // Si on n'a pas accès aux champs, on force son accessibilité
                // Cela permet de modifier les champs firendly, protected et private :
                boolean pAccessible = f.isAccessible();
                if (!pAccessible)
                    f.setAccessible(true);
                f.set(pObjectInstance, value);
            } catch (Exception lException) {
                throw new PropertyManagerException(
                    "Impossible d'assigner le champ '" +
                    value + "'.", lException );
            }
        } // fin property!=null
    } // fin for getDeclaredFields()
}