Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Introduction à l'utilisation d'annotations

JavaBeans et l'introspection Coder un nouveau type d'annotation



Accès rapide :
Qu'est-ce qu'une annotation Java ?
Annotations relatives à la compréhension du code
Annotations propagées dans le code binaire
La JSR 250 et le package javax.annotations

Qu'est-ce qu'une annotation Java ?

Une annotation est un marqueur particulier (introduit par un caractère @) permettant d'ajouter une méta-données à un élément de votre programme. On peut ajouter une annotation à un type (classe, interface, type énuméré, ...), un attribut, une méthode ou encore un constructeur. En soi, une annotation ne fait pas grand-chose : il faut qu'un framework (ou une librairie) recherche ces annotations pour les traiter.

la différence entre une librairie ou un framework réside dans le fait qu'un framework (littéralement, un cadre de travail) impose une manière structurante de développer. Ce n'est pas le cas d'une librairie. En termes de frameworks Java, on peut notamment parler de Spring Framework, d'Hibernate, de JUnit ou encore de JSF : dans ces trois cas, ces frameworks utilisent des annotations.

Les annotations Java étant des méta-données, pour les rechercher et les manipuler, on doit utiliser le moteur de réflexion Java. Il existe cependant quelques annotations qui n'ont de sens que pour la compréhension du code source, par exemple l'annotation @Override. Ce type d'annotations est non manipulable par le moteur de réflexion.

Annotations relatives à la compréhension du code

On dit d'une telle annotation qu'elle a une rétention de type « Source ». Dit autrement, l'annotation n'est pas stockée dans le .class produit par le compilateur.

Il existe quelques annotations de ce type. La plus connue est certainement java.lang.@Override. Elle permet d'indiquer au développeur relisant le code qu'une méthode réalise une redéfinition : il existe donc une méthode de signature équivalente sur un type parent (classe héritée ou interface implémentée). Le cas le plus classique d'utilisation de cette annotation consiste en la redéfinition de la méthode toString. En voici un exemple, pour rappel.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
package fr.koor.annotations;

public class Start {
    
    public static void main( String[] args ) throws Exception {
        Start instance = new Start();
        System.out.println( instance );
    }
    
    @Override 
    public String toString() {
        return "This is my toString implementation";
    }
}
Exemple d'utilisation de l'annotation @Override.
n'oubliez pas qu'il est possible de générer automatiquement une version initiale du toString en utilisant les assistants de votre IDE. Sous Eclipse, placez-vous à l'endroit ou vous souhaitez générer la méthode et saisissez-y le mot toString. Appuyez ensuite sur la séquence de touche CTRL+ESPACE. La méthode doit être générée automatiquement et vous devriez y retrouver l'annotation @Override.

Une autre annotation n'ayant du sens qu'au sein du code source est l'annotation java.lang.SuppressWarnings. Elle permet d'indiquer au compilateur ou à votre IDE de ne pas tenir compte de certains avertissements (warnings). Voici un exemple d'utilisation de cette annotation pour demander à ne pas signaler les éléments de code non utilisés.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
package fr.koor.annotations;

@SuppressWarnings( "unused" )   // Essayez de supprimer cette annotation.
public class Start {

    private void unusedMethod() {
        // Un warning peut être produit, car la méthode 
        // est privée et non utilisée dans la classe.
    }
    
    public static void main( String[] args ) throws Exception {

        int unusedInteger = 10;
        
        System.out.println( "Bye bye" );
    }
    
}
Exemple d'utilisation de l'annotation @SuppressWarnings.

Annotations propagées dans le code binaire

Pour les autres annotations, il faut savoir qu'elles sont poussées dans le fichier .class produit par le compilateur. Il est donc possible de les manipuler au « runtime » (durant l'exécution de votre programme) via le moteur de réflexion Java. C'est le cas de l'annotation java.lang.Deprecated. Voici un exemple de code listant l'ensemble de méthodes dépréciées portées par la classe.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
package fr.koor.annotations;

import java.lang.reflect.Method;

public class Start {

    public static void methode1() {}
    
    @Deprecated
    public static void methode2() {}
    
    public static void methode3() {}
    
    @Deprecated
    public static void methode4() {}
    
    
    public static void main( String[] args ) throws Exception {

        // Récupération des méta-données à partir de la classe.
        Class<Start> metadata = Start.class;
        
        // On récupère les méthodes déclarées dans le type courant.
        Method [] methods = metadata.getDeclaredMethods();
        
        // On affiche des informations sur les méthodes dépréciées de la classe.
        for( Method method : methods ) {
            if ( method.isAnnotationPresent( Deprecated.class ) ) {
                System.out.println( method.getName() );                
            }
        }
    }
    
}
On liste les méthodes dépréciées portées par la classe Start.

Et voici les résultats produits par ce programme.

methode2
methode4

La JSR 250 et le package javax.annotations

La JSR 250 définit un ensemble d'annotations communes (Common Annotations) pour la plate-forme Java. Voici un descriptif de ces annotations.



JavaBeans et l'introspection Coder un nouveau type d'annotation