Les méta-annotations standards

Résume
Ce billet à pour but d'expliquer ce que c'est que les méta-annotations; ce sont des annotation appliqué au annotation lors de la définition;bien que  Java SE5 propose quatre annotations dédiées aux types d'annotations.
Il existe trois types d'annotations :
Jusqu’ici, nous nous sommes préoccupés que par :
• Des marqueurs (markers) : ces annotations ne possèdent pas d'attribut.
Rappel :@Override, @Deprecated ,@SuppressWarning et @Generated dans j’ai pas parlé la dernier fois car, elle a était intégré dans Java 6 .
Ces quatre annotations sont dites Built-In annotation, car ils sont prédéfinis dans la JDK.
Bien qu’il existe d’autres types d’annotations :
• Les annotations simples (single value annotations) : ces annotations ne possèdent qu'un seul attribut.
• Les annotations complètes (full annotations) : ces annotations possèdent plusieurs attributs.
Les utilisations des annotations concernent plusieurs fonctionnalités :
• Utilisation par le compilateur pour détecter des erreurs ou ignorer des avertissements, c’est ce qu’on a vu jusqu'à présent avec les annotations Buit-in.
• Documentation
• Génération de code (Jusqu'à Java 6 que nous allons voir sur le Billet Amélioration apporter à l’annotation)
• Génération de fichiers (Jusqu'à Java 6 que nous allons voir sur le Billet Amélioration apporter à l’annotation)


Exemple d’utilisation :
Supposons que je veux créer mes propres annotations et les exploitées :
• pendant l’exécution du code lui-même.
• par d’autres outils qui viendront exploiter soit les fichiers sources (.java), soit les fichiers de byte codes (.class) ;
Je préfère commencer par un simple exemple dans lequel je veux crée une annotation @Copyright qui sera afficher dans mon fichier (.class), pour dire que je suis le propriétaire de cette classe et après donné une explication des différents Méta-annotation , et faire l’appel de cette annotation sur le type Class.


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.CLASS)// l’annotation sera conservée dans les fichiers .class
@Target(ElementType.TYPE)// déclarations de type class


public @interface Copyright {


String value();//dans le cas ou on un seul attribut value est l’attribut par défaut.
//attention à ne pas la confondre avec une méthode c’est un attribut.
//vers la fin de ce Billet on verra comment faire l’appel de cette annotation dans une //classe est qui si on vérifie au niveau du fichier (.class) on trouvera la valeur de //l’appel qu’on a spécifié au niveau de @Retention.


}


Explication des différents Méta-annotation :


Il est possible d’annoter une annotation lors de sa définition, On parle alors de méta-annotations, La version Java 5 propose quatre annotations dédiées aux types d'annotations :
L'annotation :
@Target : Spécifie à quelles entités il sera possible de l’appliquer


ElementType.ANNOTATION_TYPE annotations
ElementType.CONSTRUCTOR constructeurs
ElementType.FIELD champs
ElementType.LOCAL_VARIABLE variables locales
ElementType.METHOD méthodes
ElementType.PACKAGE package
ElementType.PARAMETER paramètres d’une méthode ou d’un constructeur
ElementType.TYPE déclarations de type (class, inteface ou énumération)


L'annotation :
@Retention "durée de vie",


RetentionPolicy.SOURCE L’annotation ne sera conservée que dans les fichiers sources. Elle ne pourra donc plus être exploitée lors de l’exécution (par introspection, notamment). Elle restera toutefois exploitable par des outils d’analyse de fichiers sources.


RetentionPolicy.CLASS L’annotation sera conservée dans les fichiers .class, (en plus des fichiers sources) mais ne sera pas accessible à la machine virtuelle.
L’instrospection ne sera pas possible. L’annotation pourra cependant être exploitée par des outils qui travaillent directement sur des fichiers .class.
Il s’agit de la durée de vie par défaut (c’est-à-dire lorsque aucune méta-annotation @Retention ne figure devant la définition de l’annotation.


RetentionPolicy.RUNTIME L’annotation sera conservée dans les fichiers .class, (en plus des fichiers sources) et sera accessible à la machine virtuelle. L’instrospection sera possible.
L'annotation :


@Documented : Marquer les annotations que vous souhaitent voir prises en compte dans un outil de documentation automatique de code.


L'annotation :
@Inherited : prévoir, lors de sa définition, qu’une annotation sera héritée.


Appel de l’annotation sur une classe :
@Copyright("2010 Naoufal Ben Bouazza")
En bas de l’annotation la classe sur la quelle elle sera appliquée.
Remarque : Dans Java SE 6, la prise en compte des annotations est intégrée dans le compilateur : ceci permet un traitement à la compilation des annotations sans avoir un recours à un outil tiers comme apt.