SlideShare une entreprise Scribd logo
1  sur  61
Télécharger pour lire hors ligne
Les Annotations Java

                  Enfin 
                expliquées 
               simplement !




©Zenika                          1
Olivier Croisier
                                                J'aime 
  • Consultant Zenika                       tellement ses 
                                            quizz Java !
  • Certifié Java 5.0 (100%)
  • Certifié Spring Framework

  • Formateur certifié JavaSpecialist
    (javaspecialists.eu)
  • Formateur certifié Terracotta

  • Blog : The Coder's Breakfast
    ( thecodersbreakfast.net )
  • Twitter : @OlivierCroisier
                                        (Effet dramatisé en post-production)
©Zenika                                                                    2
Plan


  •   Présentation
  •   Annotations, mode d'emploi
  •   Annotations personnalisées
  •   Outillage compile-time
  •   Outillage runtime
  •   Injection d'annotations
  •   Conclusion




©Zenika                            3
Plan


  • Présentation
      • Historique
      • Où trouver des annotations ?
  • Annotations, mode d'emploi
  • Annotations personnalisées
  • Outillage compile-time
  • Outillage runtime
  • Injection d'annotations
  • Conclusion




©Zenika                                4
Présentation
  Historique

  • Java a toujours proposé une forme ou une autre de méta-
    programmation

  • Dès l'origine, l'outil "javadoc" permettait d'exploiter
    automatiquement des méta-données à but documentaire

    /**
     /**
     ** Méthode inutile
          Méthode inutile
     ** @param param Un paramètre (non utilisé)
          @param param Un paramètre (non utilisé)
     ** @return Une valeur fixe :: "foo"
          @return Une valeur fixe   "foo"
     ** @throws Exception N'arrive jamais (promis!)
          @throws Exception N'arrive jamais (promis!)
     */*/
    public String foo(String param) throws Exception {{
     public String foo(String param) throws Exception
        return "foo";
         return "foo";
    }}

©Zenika                                                       5
Présentation
  Historique

  • Ce système était flexible et a rapidement été utilisé / détourné
    pour générer d'autres artefacts : fichiers de configuration, classes
    annexes...
      • Voir le projet XDoclet (xdoclet.sourceforfge.net)
    /**
     /**
     ** @ejb.bean
         @ejb.bean
     **     name="bank/Account"
             name="bank/Account"
     **     type="CMP"
             type="CMP"
     **     jndi-name="ejb/bank/Account"
             jndi-name="ejb/bank/Account"
     **     local-jndi-name="ejb/bank/LocalAccount"
             local-jndi-name="ejb/bank/LocalAccount"
     **     primkey-field="id"
             primkey-field="id"
     ** @ejb.transaction
         @ejb.transaction
     **     type="Required"
             type="Required"
     ** @ejb.interface
         @ejb.interface
     **     remote-class="test.interfaces.Account"
             remote-class="test.interfaces.Account"
     */
      */
©Zenika                                                                    6
Présentation
  Historique

  • Reconnaissant le besoin d'un système de méta-programmation
    plus robuste et plus flexible, Java 5.0 introduit les Annotations
  • Elles remplacent avantageusement les doclets dans tous les
    domaines – sauf bien sûr pour la génération de la Javadoc !
    public class PojoAnnotation extends Superclass {{
     public class PojoAnnotation extends Superclass
        @Override
         @Override
        public void overridenMethod() {{
         public void overridenMethod()
            super.overridenMethod();
             super.overridenMethod();
        }}
          @Deprecated
           @Deprecated
          public void oldMethod(){
           public void oldMethod(){
          }}
    }}
©Zenika                                                                 7
Présentation
  Où trouver des annotations ?

  • Java SE propose assez peu d'annotations en standard
      • @Deprecated, @Override, @SuppressWarnings
      • 4 méta-annotations dans java.lang.annotation
      • Celles définies par JAXB et Commons Annotations      @
                                                             @
  • Java EE en fournit une quantité impressionnante
      • Pour les EJB 3, les Servlets 3, CDI, JSF 2, JPA...   @

  • Les frameworks modernes en tirent également parti
      • Spring, Hibernate, CXF, Stripes...

  • Développez les vôtres !

©Zenika                                                          8
Plan


  • Présentation
  • Annotations, mode d'emploi
      • Elements annotables
      • Annoter une classe, une méthode ou un champ
      • Annoter un package
      • Paramètres d'annotations
      • Restrictions et astuces
  • Annotations personnalisées
  • Outillage compile-time
  • Outillage runtime
  • Injection d'annotations
  • Conclusion

©Zenika                                               9
Annotations, mode d'emploi
  Elements annotables

  • Les annotations peuvent être apposées sur les éléments
    suivants :
      • Les classes, interfaces et enums
      • Les propriétés de classes
      • Les constructeurs et méthodes
      • Les paramètres des constructeurs et méthodes
      • Les variables locales
      • … et d'autres éléments encore grâce à la JSR 308 (Java 7 8)

  • Mais aussi sur...
     • Les packages
     • Les annotations elles-mêmes (méta-annotations) !

©Zenika                                                               10
Annotations, mode d'emploi
  Annoter une classe, méthode ou champ

    @Deprecated
     @Deprecated
    public class Pojo {{
     public class Pojo
        @Deprecated
         @Deprecated
        private int foo;
         private int foo;
        @Deprecated
         @Deprecated
        public Pojo() {{
         public Pojo()
            @Deprecated
             @Deprecated
            int localVar ==0;
             int localVar   0;
        }}
          @Deprecated
           @Deprecated
          public int getFoo() {{
           public intfoo;
              return getFoo()
               return foo;
          }}
          public void setFoo(@Deprecated int foo) {{
           public void setFoo(@Deprecated int foo)
              this.foo ==foo;
               this.foo foo;
          }}
    }}

©Zenika                                                11
Annotations, mode d'emploi
  Annoter un package

  • Comment annoter un package ?

  • La déclaration d'un package est présente dans
    toutes les classes appartenant à ce package. Impossible d'y
    placer une annotation : risque de conflit ou d'information
    incomplète !

    @Foo
     @Foo
    package com.zenika.presentation.annotations;
     package com.zenika.presentation.annotations;
    public class ClassA {}
     public class ClassA {}
    @Bar
     @Bar
    package com.zenika.presentation.annotations;
     package com.zenika.presentation.annotations;
    public class ClassB {}
     public class ClassB {}

©Zenika                                                           12
Annotations, mode d'emploi
  Annoter un package

  • Solution : pour annoter un package, il faut créer
    un fichier spécial nommé package-info.java
  • Il contient uniquement la déclaration du package,
    accompagné de sa javadoc et de ses annotations


    /**
     /**
     ** Ce package contient le code source de
         Ce package contient le code source de
     ** la présentation sur les annotations.
         la présentation sur les annotations.
     */
      */
    @Foo
     @Foo
    @Bar
     @Bar
    package com.zenika.presentation.annotations;
     package com.zenika.presentation.annotations;


©Zenika                                                 13
Annotations, mode d'emploi
  Paramètres d'annotations

  • Les annotations peuvent prendre des paramètres

  • Ils peuvent être obligatoires ou facultatifs (ils prennent alors la
    valeur par défaut spécifiée par le développeur de l'annotation)

  • Les paramètres se précisent entre parenthèses, à la suite de
    l'annotation ; leur ordre n'est pas important
    @MyAnnotation( param1=value1, param2=value2... ))
     @MyAnnotation( param1=value1, param2=value2...
  • Si l'annotation ne prend qu'un paramètre, il est souvent possible
    d'utiliser une notation raccourcie
    @MyAnnotation( value ))
     @MyAnnotation( value

©Zenika                                                                   14
Annotations, mode d'emploi
  Paramètres d'annotations




    @WebInitParam( name="foo", value="bar" ))
     @WebInitParam( name="foo", value="bar"
©Zenika                                         15
Annotations, mode d'emploi
  Restrictions et astuces

  • Il est interdit d'annoter plusieurs fois un élément avec la même
    annotation. Pour contourner le problème, on peut recourir à des
    annotations "wrapper"

    @SecondaryTables({
     @SecondaryTables({
        @SecondaryTable(name="city"),
         @SecondaryTable(name="city"),
        @SecondaryTable(name="country")
         @SecondaryTable(name="country")
    })
     })
    public class Address
     public class Address
    {...}
     {...}
  • Il est possible de séparer l'@ du nom de l'annotation !
    @@
    /** Javadoc */
     /** Javadoc */
    Deprecated
     Deprecated
©Zenika                                                                16
Annotations, mode d'emploi
  Restrictions et astuces

  • Pour les paramètres :

          • Les valeurs des paramètres doivent être des "compile-time
            constants"...

            @MyAnnotation(answer == (true!=false) ?? 42 :: 0)
             @MyAnnotation(answer    (true!=false)    42    0)

          • … mais ne peuvent pas être null
            (Et personne ne sait pourquoi !)

            @MyAnnotation(param == null)
             @MyAnnotation(param    null)



©Zenika                                                                 17
Annotations, mode d'emploi
  Démos




  Démos
  • Mode d'emploi




©Zenika                        18
Plan


  • Présentation
  • Annotations, mode d'emploi
  • Annotations personnalisées
      • Use-cases
      • Méta-annotations
      • Paramètres d'annotations
  • Outillage compile-time
  • Outillage runtime
  • Injection d'annotations
  • Conclusion




©Zenika                            19
Annotations personnalisées
  A quoi ça sert ?

  • Pourquoi développer des annotations personnalisées ?
     • Pour remplacer / compléter des fichiers de configuration XML
     • Pour simplifier ou générifier une portion de code en recourant
       à la méta-programmation
     • Pour appliquer des règles de compilation supplémentaires,
       grâce aux Annotation Processors


          • … parce que c'est fun !




©Zenika                                                                 20
Annotations personnalisées
  Syntaxe

  • Une annotation se déclare comme un type spécial d'interface
  • Elle sera compilée sous la forme d'une interface héritant de
    java.lang.annotation.Annotation

    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}


  • Il est ensuite possible de compléter l'annotation avec :
       • Des paramètres
                    •Pour véhiculer des données supplémentaires
          • Des méta-annotations
                    •Pour spécifier les conditions d'utilisation de l'annotation


©Zenika                                                                            21
Annotation personnalisées
  Paramètres d'annotations

  • Chaque paramètre se déclare sous la forme d'une méthode (non
    générique, sans paramètres et sans exceptions)

  • Il peut posséder une valeur par défaut (compile-time constant),
    déclarée grâce au mot-clé "default" ; il est alors optionnel.

    public @interface MyAnnotation {{
     public @interface MyAnnotation
       String message();
        String message();
       int answer() default 42;
        int answer() default 42;
    }}


    @MyAnnotation( message="Hello World" ))
     @MyAnnotation( message="Hello World"
    @MyAnnotation( message="Hello World", answer == 00 ))
     @MyAnnotation( message="Hello World", answer

©Zenika                                                               22
Annotation personnalisées
  Paramètres d'annotations

  • Si l'annotation ne possède qu'un seul paramètre nommé "value",
    il est possible d'utiliser une syntaxe raccourcie


    public @interface MyAnnotation {{
     public @interface MyAnnotation
       String value();
        String value();
    }}


    @MyAnnotation( "Hello World" ))
     @MyAnnotation( "Hello World"
    @MyAnnotation( value == "Hello World" ))
     @MyAnnotation( value    "Hello World"




©Zenika                                                              23
Annotation personnalisées
  Paramètres d'annotations

  • Comme dans toute interface, il est possible de définir des classes,
    interfaces ou enums internes

    public @interface MyAnnotation {{
     public @interface MyAnnotation
       int defaultAnswer == 42;
        int defaultAnswer    42;
       int answer() default defaultAnswer;
        int answer() default defaultAnswer;
       enum Season {SPRING, SUMMER, FALL, WINTER};
        enum Season {SPRING, SUMMER, FALL, WINTER};
       Season season();
        Season season();
    }}


    @MyAnnotation( season == MyAnnotation.Season.WINTER ))
     @MyAnnotation( season    MyAnnotation.Season.WINTER

©Zenika                                                               24
Annotation personnalisées
  Les Méta-Annotations : @Target

  • La méta-annotation @Target indique sur quels éléments de code
    l'annotation peut être apposée :

    @Target( ElementType[] ))
     @Target( ElementType[]
    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}


  • Exemple :

    @Target( {ElementType.TYPE, ElementType.METHOD} ))
     @Target( {ElementType.TYPE, ElementType.METHOD}
    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}


©Zenika                                                             25
Annotation personnalisées
  Les Méta-Annotations : @Target

  • Valeurs possibles pour l'enum ElementType :
     • TYPE
     • CONSTRUCTOR
     • FIELD
     • METHOD
     • PARAMETER
     • LOCAL_VARIABLE
     • ANNOTATION_TYPE (méta-annotation)
     • PACKAGE
     • TYPE_PARAMETER et TYPE_USE (JSR 308, Java 7 8?)
         Ex: @English String @NonEmpty []

  • Si le paramètre n'est pas spécifié, l'annotation
    peut être utilisée partout (Ex : @Deprecated)
©Zenika                                                  26
Annotation personnalisées
  Les Méta-Annotations : @Retention

  • La méta-annotation @Retention indique la durée de vie de
    l'annotation
    @Retention( RetentionPolicy ))
     @Retention( RetentionPolicy
    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}

  • Exemple
    @Retention( RetentionPolicy.RUNTIME ))
     @Retention( RetentionPolicy.RUNTIME
    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}




©Zenika                                                        27
Annotation personnalisées
  Les Méta-Annotations : @Retention

  • Valeurs possibles pour l'enum RetentionPolicy :
     • SOURCE
     • CLASS (par défaut)
     • RUNTIME
                          compilation     class
                                        loading

           SOURCE

           CLASS

           RUNTIME




©Zenika                                               28
Annotation personnalisées
  Les Méta-Annotations : @Inherited

  • La méta-annotation @Inherited indique que l'annotation est
    héritée par les classes filles de la classe annotée

    @Inherited
     @Inherited
    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}


  • Restrictions
     • Seules les annotations portées sur les classes sont héritées
     • Les annotations apposées sur une interface ne sont pas
       héritées par les classes implémentant cette interface ; idem
       pour les packages.


©Zenika                                                               29
Annotation personnalisées
  Les Méta-Annotations : @Documented

  • La méta-annotation @Documented indique que l'annotation doit
    apparaître dans la javadoc

    @Documented
     @Documented
    public @interface MyAnnotation {{
     public @interface MyAnnotation
    }}




©Zenika                                                            30
Annotation personnalisées
  Démos



  Démos
  • Développer une annotation
  •Décompiler une annotation




©Zenika                         31
Plan


  • Présentation
  • Anatomie
  • Mode d'emploi
  • Annotations personnalisées
  • Outillage compile-time
      • Historique et use-cases
      • Processus de compilation
      • Anatomie d'un processeur
      • Limitations
  • Outillage runtime
  • Injection d'annotations
  • Conclusion

©Zenika                            32
Outillage compile-time
  Historique et use-cases

  Historique

  • Java 5.0 : APT (Annotation Processing Tool)
      • Devait être lancé en plus du compilateur javac

  • Java 6.0 : Pluggable Annotation Processors
      • Intégrés au processus de compilation standard
      • Paramètre -processor ou utilisation du SPI (Service Provider
        Interface)

                Pour plus d'informations sur le SPI, voir :
                • Un article sur The Coder's Breakfast
                • La Javadoc de java.util.ServiceLoader

©Zenika                                                                33
Outillage compile-time
  Historique et use-cases

  Use-cases

  • Génération de ressources : "XDoclet ++"
     • Fichiers de configuration
     • Classes annexes
                   •Ex: Proxies, PropertyEditors...
          • Documentation
                   •Ex: Matrice des rôles JavaEE, cartographie d'IOC...

  • Amélioration du compilateur
     • Vérification de normes de codage
                   •Ex: Les classes "modèle" doivent être Serializable...
          • Messages d'alerte ou d'erreur supplémentaires

©Zenika                                                                     34
Outillage compile-time
  Historique et use-cases

  Mention spéciale : Lombok (projectlombok.org)

          • Améliore "magiquement" les classes
                      •Génère les getters/setters, equals/hashCode, toString
          • Viole la règle de non-modification des ressources existantes
          • Dépend des implémentations internes des compilateurs pour
            manipuler les AST des classes
                      •com.sun.tools.javac.*
                      •org.eclipse.jdt.internal.compiler.*

          • Danger : la compilation de votre projet dépend désormais du
            support de votre compilateur cible par Lombok.
            Peser le rapport gain / risques !
                     •Votre IDE propose également ces fonctionnalités
©Zenika                                                                        35
Outillage compile-time
  Processus de compilation


          1. Le compilateur découvre les processeurs d'annotations
                    •Paramètre -processor sur la ligne de commande
                    •ou via le Service Provider Interface (SPI)

          2. Un round de compilation est lancé
                    •Le compilateur et les processeurs s'exécutent
                    •Si de nouvelles ressources sont créées lors de ce round,
                    un nouveau round est lancé




©Zenika                                                                         36
Outillage compile-time
  Anatomie d'un Processeur

  • Un processeur est une classe implémentant l'interface
    javax.annotation.processing.Processor
      • Généralement, on sous-classe AbstractProcessor

  • L'annotation @SupportedAnnotationTypes permet d'indiquer
    quelles annotations le processeur sait traiter

  • La méthode init() permet d'initialiser le processeur

  • La méthode principale process() reçoit un paramètre de type
    RoundEnvironment représentant l'environnement de compilation.
    Elle renvoie un booléen indiquant si l'annotation est définitivement
    "consommée" par ce processeur

©Zenika                                                                    37
Outillage compile-time
  Anatomie d'un Processeur

  • Des utilitaires sont accessibles via la propriété processingEnv
    fournie par AbstractProcessor :


          • Types et Elements, permettant d'introspecter le code
          • Messager, pour lever des erreurs de compilation et afficher des
            messages dans la console
          • Filer, autorisant la création de nouvelles ressources (classes,
            fichiers de configuration...)

    Types
     Types        types
                   types      == processingEnv.getTypeUtils();
                                  processingEnv.getTypeUtils();
    Elements
     Elements     elts
                   elts       == processingEnv.getElementUtils();
                                  processingEnv.getElementUtils();
    Messager
     Messager     messager
                   messager   == processingEnv.getMessager();
                                  processingEnv.getMessager();
    Filer
     Filer        filer
                   filer      == processingEnv.getFiler();
                                  processingEnv.getFiler();

©Zenika                                                                   38
Outillage compile-time
  Anatomie d'un Processeur
    @SupportedAnnotationTypes("com.zenika.*")
     @SupportedAnnotationTypes("com.zenika.*")
    public class MyProcessor extends AbstractProcessor {{
     public class MyProcessor extends AbstractProcessor
        Types types;
         Types types;
        Elements elements;
         Elements elements;
        Messager messager;
         Messager messager;
        Filer filer;
         Filer filer;
          public void init(ProcessingEnvironment processingEnv) {{
           public void init(ProcessingEnvironment processingEnv)
              super.init(processingEnv);
               super.init(processingEnv);
              types
               types    == processingEnv.getTypeUtils();
                            processingEnv.getTypeUtils();
              elements == processingEnv.getElementUtils();
               elements     processingEnv.getElementUtils();
              messager == processingEnv.getMessager();
               messager = processingEnv.getFiler();
                            processingEnv.getMessager();
              filer
               filer     = processingEnv.getFiler();
          }}
          public boolean process(
           public boolean process(
             Set<? extends TypeElement> annotations,
             RoundEnvironment roundEnv) {annotations,
              Set<? extends TypeElement>
              RoundEnvironment roundEnv) {
                 // TODO
             }} // TODO
    }}
©Zenika                                                              39
Outillage compile-time
  Anatomie d'un Processeur

    public boolean process(
     public boolean process(
       Set<? extends TypeElement> annotations,
        Set<? extends TypeElement> annotations,
       RoundEnvironment roundEnv) {{
        RoundEnvironment roundEnv)
       // Pour chaque annotation traitée...
        // Pour chaque annotation traitée...
       for (TypeElement annotation :: annotations) {{
        for (TypeElement annotation     annotations)
           // Trouver les éléments portant cette annotation
            // Trouver les éléments portant cette annotation
           for (Element ee ::
            for (Element
              roundEnv.getElementsAnnotatedWith(annotation)) {{
               roundEnv.getElementsAnnotatedWith(annotation))
              messager.printMessage(
               messager.printMessage(
                  Diagnostic.Kind.NOTE,
                   Diagnostic.Kind.NOTE,
                  e.getSimpleName());
                   e.getSimpleName());
           }}
       }}
       return false;
        return false;
    }}
©Zenika                                                           40
Outillage compile-time
  Limitations

  • Développer un processeur est complexe !
     • Les Types et les Elements offrent deux vues différentes sur le
       code compilé
                     •Les Elements représentent l'AST brut du code
                     •Les Types offrent une interface davantage typée "java"
                     •Il existe des ponts entre ces deux univers
          • Le pattern Visiteur est beaucoup utilisé

  • Un processeur ne peut pas
    modifier du code existant !

  • Quelques bugs encore, et un
    faible support dans les IDE

©Zenika                                                                        41
Outillage compile-time
  Démos


  Démos
  • ListingProcessor
  •MessageHolderProcessor
  •SerializableClassesProcessor




©Zenika                           42
Plan


  • Présentation
  • Annotations, mode d'emploi
  • Annotations personnalisées
  • Outillage compile-time
  • Outillage runtime
      • Use-cases
      • Récupération des paramètres
      • Une fois les annotations récupérées...
  • Injection d'annotations
  • Conclusion




©Zenika                                          43
Outillage runtime
  Use-cases

  • Au runtime, il est possible d'utiliser la Réflexion pour découvrir les
    annotations présentes sur les classes, champs, méthodes et
    paramètres de méthodes.
  • Uniquement si @Retention(RetentionPolicy.RUNTIME)

  • Use-cases :
     • Mapping Java ↔ ?
     • Programmation orientée POJO
     • Configuration de containers / frameworks

  • Exemples :
     • Hibernate, Apache CXF, XStream...
     • Spring, Guice, Java EE 5/6 (CDI, EJB 3.0, Servlets 3.0...)
©Zenika                                                                      44
Outillage runtime
  Récupération des annotations

  • Les classes Package, Class, Constructor, Field et Method
    implémentent l'interface AnnotatedElement :

    public interface AnnotatedElement {{
     public interface AnnotatedElement
       Annotation[] getAnnotations();
        Annotation[] getAnnotations();
       Annotation[] getDeclaredAnnotations();
        Annotation[] getDeclaredAnnotations();
       boolean isAnnotationPresent(Class annotationClass);
        boolean isAnnotationPresent(Class annotationClass);
       Annotation getAnnotation(Class annotationClass);
        Annotation getAnnotation(Class annotationClass);
    }}

          • getAnnotations() renvoie toutes les annotations applicables à
            l'élément, y compris les annotations héritées
          • getDeclaredAnnotations() ne renvoie que les annotations
            directement apposées sur l'élément


©Zenika                                                                 45
Outillage runtime
  Récupération des annotations

  • Exemple : lecture des annotations d'une classe et de celles de
    son package

    // Annotations sur la classe
     // Annotations sur la classe
    Annotation[] clsAnnots == Pojo.class.getAnnotations();
     Annotation[] clsAnnots    Pojo.class.getAnnotations();
    for (Annotation annot :: clsAnnots) {{
     for (Annotation annot    clsAnnots)
       System.out.println(annot);
        System.out.println(annot);
    }}
    // Annotations sur le package
     // Annotations sur le package
    Package pkg == Pojo.class.getPackage();
     Package pkg    Pojo.class.getPackage();
    Annotation[] pkgAnnots == pkg.getDeclaredAnnotations();
     Annotation[] pkgAnnots    pkg.getDeclaredAnnotations();
    for (Annotation annot :: pkgAnnots) {{
     for (Annotation annot    pkgAnnots)
       System.out.println(annot);
        System.out.println(annot);
    }}


©Zenika                                                              46
Outillage runtime
  Récupération des annotations

  • Les classes Constructor et Method permettent également de
    récupérer les annotations présentes sur leurs paramètres
      • Annotation[][] getParameterAnnotations()
      • Renvoie un tableau d'annotations par paramètre, dans l'ordre
        de leur déclaration dans la signature de la méthode

    public void printParamAnnots(Method method) {{
     public void printParamAnnots(Method method)
       Annotation[][] allAnnots ==
        Annotation[][] allAnnots
          method.getParameterAnnotations();
           method.getParameterAnnotations();
       for (Annotation[] annots :: paramAnnots) {{
        for (Annotation[] annots    paramAnnots)
          System.out.println(Arrays.toString(annots));
           System.out.println(Arrays.toString(annots));
       }}
    }}
©Zenika                                                                47
Outillage runtime
  Une fois les annotations récupérées...

  • Que peut-on faire avec les annotations récupérées par réflexion ?
     • On peut découvrir leur type dynamiquement
       Class<? extends Annotation> annotationType()
     • On peut lire leurs paramètres (cast nécessaire)

    Annotation annot == …… ;;
     Annotation annot
    // Détermination du type réel de l'annotation
     // Détermination du type réel de l'annotation
    Class<? extends Annotation> annotClass ==
     Class<? extends Annotation> annotClass
       myAnnotation.annotationType();
        myAnnotation.annotationType();
    // Affichage du message de MyAnnotation
     // Affichage du message de MyAnnotation
    if (annot instanceof MyAnnotation) {{
     if (annot instanceof MyAnnotation)
       MyAnnotation myAnnot == (MyAnnotation) annot;
        MyAnnotation myAnnot    (MyAnnotation) annot;
       System.out.println(myAnnot.message());
        System.out.println(myAnnot.message());
    }}
©Zenika                                                                 48
Outillage runtime
  Démos



  Démos
  • Démonstration
  • Exemple : CSVReader




©Zenika                   49
Plan


  • Présentation
  • Mode d'emploi
  • Annotations personnalisées
  • Outillage compile-time
  • Outillage runtime
  • Injection d'annotations
      • Au coeur de la classe Class
      • Instancier dynamiquement une annotation
      • Injection dans une classe
      • Injection sur une méthode ou un champ
  • Conclusion


©Zenika                                           50
Injection d'annotations
  Au coeur de la classe Class

  • Dans la classe Class, les annotations sont représentées sous la
    forme de Maps :
    private transient Map<Class, Annotation> annotations;
     private transient Map<Class, Annotation> annotations;
    private transient Map<Class, Annotation> declaredAnnotations;
     private transient Map<Class, Annotation> declaredAnnotations;

  • Ces maps sont initialisées lors du premier appel à
    getAnnotations() ou getDeclaredAnnotations()
  • L'initialisation est réalisée en décodant le byte[] renvoyé par la
    méthode native getRawAnnotations()

  • En modifiant ces maps par Réflexion,
    il est possible d'injecter arbitrairement
    des annotations sur une Classe au runtime !

©Zenika                                                                  51
Injection d'annotations
  Instancier une annotation

  • Pour obtenir une instance de l'annotation à injecter, il suffit
    d'instancier une classe anonyme implémentant son "interface"

    MyAnnotation myAnnotation == new MyAnnotation() {{
     MyAnnotation myAnnotation    new MyAnnotation()
        @Override
         @Override
        public String message() {{
         public String message()
            return MyAnnotation.defaultMessage;
        }} return MyAnnotation.defaultMessage;
        @Override
         @Override
        public int answer() {{
         public intMyAnnotation.defaultAnswer;
                    answer()
            return MyAnnotation.defaultAnswer;
        }} return
          @Override
           @Override
          public Class<? extends Annotation> annotationType() {{
           public Class<? extends Annotation> annotationType()
              return MyAnnotation.class;
          }} return MyAnnotation.class;
    };
     };
©Zenika                                                               52
Injection d'annotations
  Injection sur une Classe

  • Il ne reste plus qu'à utiliser la Réflexion pour injecter notre
    annotation dans la classe cible
    public static void injectClass
     public statictargetClass, Annotation annotation) {
                   void injectClass
        (Class<?> targetClass, Annotation annotation) {
         (Class<?>
        // Initialisation des maps d'annotations
         // Initialisation des maps d'annotations
        targetClass.getAnnotations();
         targetClass.getAnnotations();
        // Récupération de la map interne des annotations
         // Récupération de la map interne des annotations
        Field mapRef == Class.class.getDeclaredField("annotations");
         Field mapRef    Class.class.getDeclaredField("annotations");
        mapRef.setAccessible(true);
         mapRef.setAccessible(true);
        // Modification de la map des annotations
        Map<Class, Annotation> map des=annotations
         // Modification de la annots
         Map<Class, Annotation> annots =
            (Map<Class, Annotation>) mapRef.get(targetClass);
        if (annots==null Annotation>) mapRef.get(targetClass);
             (Map<Class, || annots.isEmpty()) {
         if annots = new HashMap<Class, Annotation>();
            (annots==null || annots.isEmpty()) {
        }} annots = new HashMap<Class, Annotation>();
        pojoAnnotations.put(annotation.annotationType(), annotation);
         pojoAnnotations.put(annotation.annotationType(), annotation);
        mapRef.set(targetClass, pojoAnnotations);
    }} mapRef.set(targetClass, pojoAnnotations);
©Zenika                                                                  53
Injection d'annotations
  Injection sur une Méthode ou un Champ

  • L'injection d'annotations sur les classes Constructor, Field et
    Method est plus problématique

  • Au sein de la classe Class, les méthodes getConstructor(),
    getField(), ou getMethod() renvoient des copies des objets
    correspondants
    Method m1 == Pojo.class.getDeclaredMethod("foo", null);
     Method m1    Pojo.class.getDeclaredMethod("foo", null);
    Method m2 == Pojo.class.getDeclaredMethod("foo", null);
     Method m2    Pojo.class.getDeclaredMethod("foo", null);
    System.out.println(m1==m2); // false
     System.out.println(m1==m2); // false

  • Ces copies sont initialisées directement à partir du bytecode de la
    classe, pas à partir d'une instance prééxistante
  • Les modifications apportées aux maps d'annotations sur une
    instance sont donc strictement locales à cette instance

©Zenika                                                                   54
Injection d'annotations
  Injection sur une Méthode ou un Champ

  • Alors, comment faire ?
      • AOP pour intercepter les méthodes getConstructor(),
        getMethod(), getField() ?
      • Modifier directement la portion de bytecode
        correspondant à ces objets ?
      • Si vous trouvez une solution,
        je suis preneur !




©Zenika                                                       55
Injection d'annotations
  Use-cases

  • Use-cases

          • Les annotations @Inherited posées sur les
            interfaces ne sont pas héritées par les classes
            implémentant ces interfaces.
            Il est possible d'y remédier en réinjectant
            manuellement ces annotations dans les
            classes. Mais attention aux conflits !

          • … d'autres idées ?




©Zenika                                                       56
Injection d'annotations
  Démos


  Démos
  • Injection dans une classe
  • Injection dans un champ




©Zenika                         57
Plan


  •   Présentation
  •   Mode d'emploi
  •   Annotations personnalisées
  •   Outillage compile-time
  •   Outillage runtime
  •   Injection d'annotations
  •   Conclusion




©Zenika                            58
Conclusion


  • Les doclets ont ouvert la voie à la méta-programmation ;
    Java 5.0 a standardisé et démocratisé les annotations

  • Tous les frameworks modernes utilisent les annotations
  • Elles complètent parfaitement les fichiers de configuration XML

  • Il est facile de développer des
    annotations personnalisées
  • Java fournit des outils pour les
    exploiter lors de la compilation
    et au runtime

  • Mais attention à la complexité !

©Zenika                                                               59
?
  Conclusion




               Questions / Réponses
©Zenika                               60
Références


  • Annotation processors
     • La documentation du SDK et la JLS
     • "Enforcing design rules with Pluggable Annotation Processors"
       sur http://thecodersbreakfast.net
     • La newsletter Javaspecialists (http://javaspecialists.eu)

  • JSR 308 et le framework Checkers
      • http://types.cs.washington.edu/jsr308/

  • Lombok
      • http://projectlombok.org/



©Zenika                                                            61

Contenu connexe

Tendances

Présentation de ECMAScript 6
Présentation de ECMAScript 6Présentation de ECMAScript 6
Présentation de ECMAScript 6Julien CROUZET
 
AlterWay SolutionsLinux Outils Industrialisation PHP
AlterWay SolutionsLinux Outils Industrialisation PHPAlterWay SolutionsLinux Outils Industrialisation PHP
AlterWay SolutionsLinux Outils Industrialisation PHPjulien pauli
 
Javascript un langage supérieur
Javascript un langage supérieurJavascript un langage supérieur
Javascript un langage supérieurFredy Fadel
 
Javascript pour le développeur Java
Javascript pour le développeur JavaJavascript pour le développeur Java
Javascript pour le développeur Javajollivetc
 
Solutions Linux 2008 - JavaScript
Solutions Linux 2008 - JavaScriptSolutions Linux 2008 - JavaScript
Solutions Linux 2008 - JavaScriptRaphaël Semeteys
 
Présentation JavaScript
Présentation JavaScriptPrésentation JavaScript
Présentation JavaScripttarkan_
 
Introduction java
Introduction javaIntroduction java
Introduction javaFouad Root
 
Introduction à JavaScript
Introduction à JavaScriptIntroduction à JavaScript
Introduction à JavaScriptMicrosoft
 
#5 Java EE5 Client Lourd et Smart Client
#5 Java EE5  Client Lourd  et Smart Client#5 Java EE5  Client Lourd  et Smart Client
#5 Java EE5 Client Lourd et Smart ClientGuillaume Sauthier
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmiqueAbdoulaye Dieng
 
Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24quicky_osm
 
Du JavaScript dans mon projet
Du JavaScript dans mon projetDu JavaScript dans mon projet
Du JavaScript dans mon projetjollivetc
 
Javascript pour les Développeurs WEB
Javascript pour les Développeurs WEBJavascript pour les Développeurs WEB
Javascript pour les Développeurs WEBAbbes Rharrab
 
Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24quicky_osm
 
Devoxx 2018 Après Java 8, Java 9 et 10
Devoxx 2018 Après Java 8, Java 9 et 10Devoxx 2018 Après Java 8, Java 9 et 10
Devoxx 2018 Après Java 8, Java 9 et 10Jean-Michel Doudoux
 

Tendances (20)

Présentation de ECMAScript 6
Présentation de ECMAScript 6Présentation de ECMAScript 6
Présentation de ECMAScript 6
 
AlterWay SolutionsLinux Outils Industrialisation PHP
AlterWay SolutionsLinux Outils Industrialisation PHPAlterWay SolutionsLinux Outils Industrialisation PHP
AlterWay SolutionsLinux Outils Industrialisation PHP
 
Javascript un langage supérieur
Javascript un langage supérieurJavascript un langage supérieur
Javascript un langage supérieur
 
Ce bon vieux propel
Ce bon vieux propelCe bon vieux propel
Ce bon vieux propel
 
Javascript pour le développeur Java
Javascript pour le développeur JavaJavascript pour le développeur Java
Javascript pour le développeur Java
 
Language java
Language javaLanguage java
Language java
 
Introduction à Python
Introduction à PythonIntroduction à Python
Introduction à Python
 
Cours java
Cours javaCours java
Cours java
 
Solutions Linux 2008 - JavaScript
Solutions Linux 2008 - JavaScriptSolutions Linux 2008 - JavaScript
Solutions Linux 2008 - JavaScript
 
Présentation JavaScript
Présentation JavaScriptPrésentation JavaScript
Présentation JavaScript
 
Introduction java
Introduction javaIntroduction java
Introduction java
 
Change mind about JS
Change mind about JSChange mind about JS
Change mind about JS
 
Introduction à JavaScript
Introduction à JavaScriptIntroduction à JavaScript
Introduction à JavaScript
 
#5 Java EE5 Client Lourd et Smart Client
#5 Java EE5  Client Lourd  et Smart Client#5 Java EE5  Client Lourd  et Smart Client
#5 Java EE5 Client Lourd et Smart Client
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
 
Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24
 
Du JavaScript dans mon projet
Du JavaScript dans mon projetDu JavaScript dans mon projet
Du JavaScript dans mon projet
 
Javascript pour les Développeurs WEB
Javascript pour les Développeurs WEBJavascript pour les Développeurs WEB
Javascript pour les Développeurs WEB
 
Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24Soda sotm fr-2013_02_24
Soda sotm fr-2013_02_24
 
Devoxx 2018 Après Java 8, Java 9 et 10
Devoxx 2018 Après Java 8, Java 9 et 10Devoxx 2018 Après Java 8, Java 9 et 10
Devoxx 2018 Après Java 8, Java 9 et 10
 

Similaire à Annotations Java par Olivier Croisier

0251-formation-java-programmation-objet.pdf
0251-formation-java-programmation-objet.pdf0251-formation-java-programmation-objet.pdf
0251-formation-java-programmation-objet.pdfOmbotimbe Salifou
 
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdfdevoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdfJean-Michel Doudoux
 
Javaday Paris 2022 - Java en 2022 : profiter de Java 17
Javaday Paris 2022 - Java en 2022 : profiter de Java 17Javaday Paris 2022 - Java en 2022 : profiter de Java 17
Javaday Paris 2022 - Java en 2022 : profiter de Java 17Jean-Michel Doudoux
 
.Net pour le développeur Java - une source d'inspiration?
.Net pour le développeur Java - une source d'inspiration?.Net pour le développeur Java - une source d'inspiration?
.Net pour le développeur Java - une source d'inspiration?Rui Carvalho
 
JavaLesBasespourles debutantset pour vous.pdf
JavaLesBasespourles debutantset pour vous.pdfJavaLesBasespourles debutantset pour vous.pdf
JavaLesBasespourles debutantset pour vous.pdfhindguendouz2000
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Loic Yon
 
Langage Java et Programmation Orienté Objet
Langage Java et Programmation Orienté ObjetLangage Java et Programmation Orienté Objet
Langage Java et Programmation Orienté ObjetMohammed Jaafar
 
Apres java 8, java 9 et 10 - BreizhCamp 2018
Apres java 8, java 9 et 10 - BreizhCamp 2018Apres java 8, java 9 et 10 - BreizhCamp 2018
Apres java 8, java 9 et 10 - BreizhCamp 2018Jean-Michel Doudoux
 
Qualité logicielle
Qualité logicielleQualité logicielle
Qualité logiciellecyrilgandon
 
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier KrantzOps@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier KrantzOlivier DASINI
 
Programmation orientee aspect 201401 - Ensim
Programmation orientee aspect 201401 - EnsimProgrammation orientee aspect 201401 - Ensim
Programmation orientee aspect 201401 - EnsimLaurent Broudoux
 
Ez18n Annotation Processing Tool in a nutshell
Ez18n Annotation Processing Tool in a nutshellEz18n Annotation Processing Tool in a nutshell
Ez18n Annotation Processing Tool in a nutshellgdigugli
 
Pluggable annotation processing api
Pluggable annotation processing apiPluggable annotation processing api
Pluggable annotation processing apiArnaud Tournier
 

Similaire à Annotations Java par Olivier Croisier (20)

0251-formation-java-programmation-objet.pdf
0251-formation-java-programmation-objet.pdf0251-formation-java-programmation-objet.pdf
0251-formation-java-programmation-objet.pdf
 
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdfdevoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
 
Javaday Paris 2022 - Java en 2022 : profiter de Java 17
Javaday Paris 2022 - Java en 2022 : profiter de Java 17Javaday Paris 2022 - Java en 2022 : profiter de Java 17
Javaday Paris 2022 - Java en 2022 : profiter de Java 17
 
Nouveautés de java 8
Nouveautés de java 8Nouveautés de java 8
Nouveautés de java 8
 
.Net pour le développeur Java - une source d'inspiration?
.Net pour le développeur Java - une source d'inspiration?.Net pour le développeur Java - une source d'inspiration?
.Net pour le développeur Java - une source d'inspiration?
 
JavaLesBasespourles debutantset pour vous.pdf
JavaLesBasespourles debutantset pour vous.pdfJavaLesBasespourles debutantset pour vous.pdf
JavaLesBasespourles debutantset pour vous.pdf
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
 
tp-spring.pdf
tp-spring.pdftp-spring.pdf
tp-spring.pdf
 
tp-spring.pdf
tp-spring.pdftp-spring.pdf
tp-spring.pdf
 
Langage Java et Programmation Orienté Objet
Langage Java et Programmation Orienté ObjetLangage Java et Programmation Orienté Objet
Langage Java et Programmation Orienté Objet
 
Octo Maven.pdf
Octo Maven.pdfOcto Maven.pdf
Octo Maven.pdf
 
Apres java 8, java 9 et 10 - BreizhCamp 2018
Apres java 8, java 9 et 10 - BreizhCamp 2018Apres java 8, java 9 et 10 - BreizhCamp 2018
Apres java 8, java 9 et 10 - BreizhCamp 2018
 
Javaoop
JavaoopJavaoop
Javaoop
 
Qualité logicielle
Qualité logicielleQualité logicielle
Qualité logicielle
 
GetText / Rails - FR
GetText / Rails - FRGetText / Rails - FR
GetText / Rails - FR
 
GetText / Rails
GetText / RailsGetText / Rails
GetText / Rails
 
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier KrantzOps@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
 
Programmation orientee aspect 201401 - Ensim
Programmation orientee aspect 201401 - EnsimProgrammation orientee aspect 201401 - Ensim
Programmation orientee aspect 201401 - Ensim
 
Ez18n Annotation Processing Tool in a nutshell
Ez18n Annotation Processing Tool in a nutshellEz18n Annotation Processing Tool in a nutshell
Ez18n Annotation Processing Tool in a nutshell
 
Pluggable annotation processing api
Pluggable annotation processing apiPluggable annotation processing api
Pluggable annotation processing api
 

Plus de Normandy JUG

Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...
Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...
Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...Normandy JUG
 
Codeurs En Seine - Lean startup - Matthieu Garde-Lebreton
Codeurs En Seine - Lean startup - Matthieu Garde-LebretonCodeurs En Seine - Lean startup - Matthieu Garde-Lebreton
Codeurs En Seine - Lean startup - Matthieu Garde-LebretonNormandy JUG
 
What makes groovy groovy codeurs en seine - 2013 - light size
What makes groovy groovy   codeurs en seine - 2013 - light sizeWhat makes groovy groovy   codeurs en seine - 2013 - light size
What makes groovy groovy codeurs en seine - 2013 - light sizeNormandy JUG
 
[Codeurs en seine] management & monitoring cloud
[Codeurs en seine] management & monitoring cloud[Codeurs en seine] management & monitoring cloud
[Codeurs en seine] management & monitoring cloudNormandy JUG
 
Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...
Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...
Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...Normandy JUG
 
Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...
Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...
Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...Normandy JUG
 
Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)
Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)
Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)Normandy JUG
 
Soirée Ceylon avec Stéphane Epardaud
Soirée Ceylon avec Stéphane EpardaudSoirée Ceylon avec Stéphane Epardaud
Soirée Ceylon avec Stéphane EpardaudNormandy JUG
 
Soirée Guava et Lombok avec Thierry Leriche
Soirée Guava et Lombok avec Thierry LericheSoirée Guava et Lombok avec Thierry Leriche
Soirée Guava et Lombok avec Thierry LericheNormandy JUG
 
Couche Base par Tugdual Grall
Couche Base par Tugdual GrallCouche Base par Tugdual Grall
Couche Base par Tugdual GrallNormandy JUG
 
Apache, osgi and karaf par Guillaume Nodet
Apache, osgi and karaf par Guillaume NodetApache, osgi and karaf par Guillaume Nodet
Apache, osgi and karaf par Guillaume NodetNormandy JUG
 
Mockito - Design + tests par Brice Duteil
Mockito - Design + tests par Brice DuteilMockito - Design + tests par Brice Duteil
Mockito - Design + tests par Brice DuteilNormandy JUG
 
Spring Batch 17-05-2011
Spring Batch 17-05-2011Spring Batch 17-05-2011
Spring Batch 17-05-2011Normandy JUG
 
ATR2011 - Planning poker
ATR2011 - Planning pokerATR2011 - Planning poker
ATR2011 - Planning pokerNormandy JUG
 
ATR2011 - Scrum dans les tranchées Normandes
ATR2011 - Scrum dans les tranchées NormandesATR2011 - Scrum dans les tranchées Normandes
ATR2011 - Scrum dans les tranchées NormandesNormandy JUG
 
Hibernate vs le_cloud_computing
Hibernate vs le_cloud_computingHibernate vs le_cloud_computing
Hibernate vs le_cloud_computingNormandy JUG
 
Soirée BPM - Introduction Logica
Soirée BPM - Introduction LogicaSoirée BPM - Introduction Logica
Soirée BPM - Introduction LogicaNormandy JUG
 

Plus de Normandy JUG (20)

Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...
Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...
Découvrez les bases de l’ergonomie web : donnez à vos utilisateurs le meilleu...
 
Codeurs En Seine - Lean startup - Matthieu Garde-Lebreton
Codeurs En Seine - Lean startup - Matthieu Garde-LebretonCodeurs En Seine - Lean startup - Matthieu Garde-Lebreton
Codeurs En Seine - Lean startup - Matthieu Garde-Lebreton
 
What makes groovy groovy codeurs en seine - 2013 - light size
What makes groovy groovy   codeurs en seine - 2013 - light sizeWhat makes groovy groovy   codeurs en seine - 2013 - light size
What makes groovy groovy codeurs en seine - 2013 - light size
 
[Codeurs en seine] management & monitoring cloud
[Codeurs en seine] management & monitoring cloud[Codeurs en seine] management & monitoring cloud
[Codeurs en seine] management & monitoring cloud
 
Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...
Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...
Fork / Join, Parallel Arrays, Lambdas : la programmation parallèle (trop ?) f...
 
Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...
Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...
Capacity Planning : Pratiques et outils pour regarder la foudre tomber sans p...
 
Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)
Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)
Gatling : Faites tomber la foudre sur votre serveur ! (Stéphane Landelle)
 
Soirée Ceylon avec Stéphane Epardaud
Soirée Ceylon avec Stéphane EpardaudSoirée Ceylon avec Stéphane Epardaud
Soirée Ceylon avec Stéphane Epardaud
 
Soirée Guava et Lombok avec Thierry Leriche
Soirée Guava et Lombok avec Thierry LericheSoirée Guava et Lombok avec Thierry Leriche
Soirée Guava et Lombok avec Thierry Leriche
 
Couche Base par Tugdual Grall
Couche Base par Tugdual GrallCouche Base par Tugdual Grall
Couche Base par Tugdual Grall
 
Java7 normandyjug
Java7 normandyjugJava7 normandyjug
Java7 normandyjug
 
Apache, osgi and karaf par Guillaume Nodet
Apache, osgi and karaf par Guillaume NodetApache, osgi and karaf par Guillaume Nodet
Apache, osgi and karaf par Guillaume Nodet
 
Mockito - Design + tests par Brice Duteil
Mockito - Design + tests par Brice DuteilMockito - Design + tests par Brice Duteil
Mockito - Design + tests par Brice Duteil
 
Spring Batch 17-05-2011
Spring Batch 17-05-2011Spring Batch 17-05-2011
Spring Batch 17-05-2011
 
ATR2011 - Planning poker
ATR2011 - Planning pokerATR2011 - Planning poker
ATR2011 - Planning poker
 
ATR2011 - Scrum dans les tranchées Normandes
ATR2011 - Scrum dans les tranchées NormandesATR2011 - Scrum dans les tranchées Normandes
ATR2011 - Scrum dans les tranchées Normandes
 
Hibernate vs le_cloud_computing
Hibernate vs le_cloud_computingHibernate vs le_cloud_computing
Hibernate vs le_cloud_computing
 
HTML5 en projet
HTML5 en projetHTML5 en projet
HTML5 en projet
 
Git
GitGit
Git
 
Soirée BPM - Introduction Logica
Soirée BPM - Introduction LogicaSoirée BPM - Introduction Logica
Soirée BPM - Introduction Logica
 

Dernier

Intelligence Artificielle: Vers l'ère de l'imagination
Intelligence Artificielle: Vers l'ère de l'imaginationIntelligence Artificielle: Vers l'ère de l'imagination
Intelligence Artificielle: Vers l'ère de l'imaginationTony Aubé
 
La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...
La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...
La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...OCTO Technology
 
Le Comptoir OCTO - MLOps : Les patterns MLOps dans le cloud
Le Comptoir OCTO - MLOps : Les patterns MLOps dans le cloudLe Comptoir OCTO - MLOps : Les patterns MLOps dans le cloud
Le Comptoir OCTO - MLOps : Les patterns MLOps dans le cloudOCTO Technology
 
Etude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdf
Etude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdfEtude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdf
Etude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdfsnapierala
 
LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...
LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...
LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...Faga1939
 
GUM365 - Rencontre mensuelle Avril 2024 - Montréal
GUM365 - Rencontre mensuelle Avril 2024 - MontréalGUM365 - Rencontre mensuelle Avril 2024 - Montréal
GUM365 - Rencontre mensuelle Avril 2024 - MontréalNicolas Georgeault
 
Milo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IA
Milo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IAMilo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IA
Milo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IAUGAIA
 

Dernier (7)

Intelligence Artificielle: Vers l'ère de l'imagination
Intelligence Artificielle: Vers l'ère de l'imaginationIntelligence Artificielle: Vers l'ère de l'imagination
Intelligence Artificielle: Vers l'ère de l'imagination
 
La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...
La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...
La Grosse Conf 2024 - Philippe Stepniewski -Atelier - Live coding d'une base ...
 
Le Comptoir OCTO - MLOps : Les patterns MLOps dans le cloud
Le Comptoir OCTO - MLOps : Les patterns MLOps dans le cloudLe Comptoir OCTO - MLOps : Les patterns MLOps dans le cloud
Le Comptoir OCTO - MLOps : Les patterns MLOps dans le cloud
 
Etude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdf
Etude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdfEtude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdf
Etude_Bpifrance_-_Les_Greentech_francaises_-_3eme_edition_annuelle_2024.pdf
 
LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...
LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...
LA SUPERINTELLIGENCE ARTIFICIELLE, SES BÉNÉFICES ET NUIRES ET QUE FAIRE POUR ...
 
GUM365 - Rencontre mensuelle Avril 2024 - Montréal
GUM365 - Rencontre mensuelle Avril 2024 - MontréalGUM365 - Rencontre mensuelle Avril 2024 - Montréal
GUM365 - Rencontre mensuelle Avril 2024 - Montréal
 
Milo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IA
Milo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IAMilo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IA
Milo-AI Milo AI Congress est conçu pour transformer votre compréhension de l'IA
 

Annotations Java par Olivier Croisier

  • 1. Les Annotations Java Enfin  expliquées  simplement ! ©Zenika 1
  • 2. Olivier Croisier J'aime  • Consultant Zenika tellement ses  quizz Java ! • Certifié Java 5.0 (100%) • Certifié Spring Framework • Formateur certifié JavaSpecialist (javaspecialists.eu) • Formateur certifié Terracotta • Blog : The Coder's Breakfast ( thecodersbreakfast.net ) • Twitter : @OlivierCroisier (Effet dramatisé en post-production) ©Zenika 2
  • 3. Plan • Présentation • Annotations, mode d'emploi • Annotations personnalisées • Outillage compile-time • Outillage runtime • Injection d'annotations • Conclusion ©Zenika 3
  • 4. Plan • Présentation • Historique • Où trouver des annotations ? • Annotations, mode d'emploi • Annotations personnalisées • Outillage compile-time • Outillage runtime • Injection d'annotations • Conclusion ©Zenika 4
  • 5. Présentation Historique • Java a toujours proposé une forme ou une autre de méta- programmation • Dès l'origine, l'outil "javadoc" permettait d'exploiter automatiquement des méta-données à but documentaire /** /** ** Méthode inutile Méthode inutile ** @param param Un paramètre (non utilisé) @param param Un paramètre (non utilisé) ** @return Une valeur fixe :: "foo" @return Une valeur fixe "foo" ** @throws Exception N'arrive jamais (promis!) @throws Exception N'arrive jamais (promis!) */*/ public String foo(String param) throws Exception {{ public String foo(String param) throws Exception return "foo"; return "foo"; }} ©Zenika 5
  • 6. Présentation Historique • Ce système était flexible et a rapidement été utilisé / détourné pour générer d'autres artefacts : fichiers de configuration, classes annexes... • Voir le projet XDoclet (xdoclet.sourceforfge.net) /** /** ** @ejb.bean @ejb.bean ** name="bank/Account" name="bank/Account" ** type="CMP" type="CMP" ** jndi-name="ejb/bank/Account" jndi-name="ejb/bank/Account" ** local-jndi-name="ejb/bank/LocalAccount" local-jndi-name="ejb/bank/LocalAccount" ** primkey-field="id" primkey-field="id" ** @ejb.transaction @ejb.transaction ** type="Required" type="Required" ** @ejb.interface @ejb.interface ** remote-class="test.interfaces.Account" remote-class="test.interfaces.Account" */ */ ©Zenika 6
  • 7. Présentation Historique • Reconnaissant le besoin d'un système de méta-programmation plus robuste et plus flexible, Java 5.0 introduit les Annotations • Elles remplacent avantageusement les doclets dans tous les domaines – sauf bien sûr pour la génération de la Javadoc ! public class PojoAnnotation extends Superclass {{ public class PojoAnnotation extends Superclass @Override @Override public void overridenMethod() {{ public void overridenMethod() super.overridenMethod(); super.overridenMethod(); }} @Deprecated @Deprecated public void oldMethod(){ public void oldMethod(){ }} }} ©Zenika 7
  • 8. Présentation Où trouver des annotations ? • Java SE propose assez peu d'annotations en standard • @Deprecated, @Override, @SuppressWarnings • 4 méta-annotations dans java.lang.annotation • Celles définies par JAXB et Commons Annotations @ @ • Java EE en fournit une quantité impressionnante • Pour les EJB 3, les Servlets 3, CDI, JSF 2, JPA... @ • Les frameworks modernes en tirent également parti • Spring, Hibernate, CXF, Stripes... • Développez les vôtres ! ©Zenika 8
  • 9. Plan • Présentation • Annotations, mode d'emploi • Elements annotables • Annoter une classe, une méthode ou un champ • Annoter un package • Paramètres d'annotations • Restrictions et astuces • Annotations personnalisées • Outillage compile-time • Outillage runtime • Injection d'annotations • Conclusion ©Zenika 9
  • 10. Annotations, mode d'emploi Elements annotables • Les annotations peuvent être apposées sur les éléments suivants : • Les classes, interfaces et enums • Les propriétés de classes • Les constructeurs et méthodes • Les paramètres des constructeurs et méthodes • Les variables locales • … et d'autres éléments encore grâce à la JSR 308 (Java 7 8) • Mais aussi sur... • Les packages • Les annotations elles-mêmes (méta-annotations) ! ©Zenika 10
  • 11. Annotations, mode d'emploi Annoter une classe, méthode ou champ @Deprecated @Deprecated public class Pojo {{ public class Pojo @Deprecated @Deprecated private int foo; private int foo; @Deprecated @Deprecated public Pojo() {{ public Pojo() @Deprecated @Deprecated int localVar ==0; int localVar 0; }} @Deprecated @Deprecated public int getFoo() {{ public intfoo; return getFoo() return foo; }} public void setFoo(@Deprecated int foo) {{ public void setFoo(@Deprecated int foo) this.foo ==foo; this.foo foo; }} }} ©Zenika 11
  • 12. Annotations, mode d'emploi Annoter un package • Comment annoter un package ? • La déclaration d'un package est présente dans toutes les classes appartenant à ce package. Impossible d'y placer une annotation : risque de conflit ou d'information incomplète ! @Foo @Foo package com.zenika.presentation.annotations; package com.zenika.presentation.annotations; public class ClassA {} public class ClassA {} @Bar @Bar package com.zenika.presentation.annotations; package com.zenika.presentation.annotations; public class ClassB {} public class ClassB {} ©Zenika 12
  • 13. Annotations, mode d'emploi Annoter un package • Solution : pour annoter un package, il faut créer un fichier spécial nommé package-info.java • Il contient uniquement la déclaration du package, accompagné de sa javadoc et de ses annotations /** /** ** Ce package contient le code source de Ce package contient le code source de ** la présentation sur les annotations. la présentation sur les annotations. */ */ @Foo @Foo @Bar @Bar package com.zenika.presentation.annotations; package com.zenika.presentation.annotations; ©Zenika 13
  • 14. Annotations, mode d'emploi Paramètres d'annotations • Les annotations peuvent prendre des paramètres • Ils peuvent être obligatoires ou facultatifs (ils prennent alors la valeur par défaut spécifiée par le développeur de l'annotation) • Les paramètres se précisent entre parenthèses, à la suite de l'annotation ; leur ordre n'est pas important @MyAnnotation( param1=value1, param2=value2... )) @MyAnnotation( param1=value1, param2=value2... • Si l'annotation ne prend qu'un paramètre, il est souvent possible d'utiliser une notation raccourcie @MyAnnotation( value )) @MyAnnotation( value ©Zenika 14
  • 15. Annotations, mode d'emploi Paramètres d'annotations @WebInitParam( name="foo", value="bar" )) @WebInitParam( name="foo", value="bar" ©Zenika 15
  • 16. Annotations, mode d'emploi Restrictions et astuces • Il est interdit d'annoter plusieurs fois un élément avec la même annotation. Pour contourner le problème, on peut recourir à des annotations "wrapper" @SecondaryTables({ @SecondaryTables({ @SecondaryTable(name="city"), @SecondaryTable(name="city"), @SecondaryTable(name="country") @SecondaryTable(name="country") }) }) public class Address public class Address {...} {...} • Il est possible de séparer l'@ du nom de l'annotation ! @@ /** Javadoc */ /** Javadoc */ Deprecated Deprecated ©Zenika 16
  • 17. Annotations, mode d'emploi Restrictions et astuces • Pour les paramètres : • Les valeurs des paramètres doivent être des "compile-time constants"... @MyAnnotation(answer == (true!=false) ?? 42 :: 0) @MyAnnotation(answer (true!=false) 42 0) • … mais ne peuvent pas être null (Et personne ne sait pourquoi !) @MyAnnotation(param == null) @MyAnnotation(param null) ©Zenika 17
  • 18. Annotations, mode d'emploi Démos Démos • Mode d'emploi ©Zenika 18
  • 19. Plan • Présentation • Annotations, mode d'emploi • Annotations personnalisées • Use-cases • Méta-annotations • Paramètres d'annotations • Outillage compile-time • Outillage runtime • Injection d'annotations • Conclusion ©Zenika 19
  • 20. Annotations personnalisées A quoi ça sert ? • Pourquoi développer des annotations personnalisées ? • Pour remplacer / compléter des fichiers de configuration XML • Pour simplifier ou générifier une portion de code en recourant à la méta-programmation • Pour appliquer des règles de compilation supplémentaires, grâce aux Annotation Processors • … parce que c'est fun ! ©Zenika 20
  • 21. Annotations personnalisées Syntaxe • Une annotation se déclare comme un type spécial d'interface • Elle sera compilée sous la forme d'une interface héritant de java.lang.annotation.Annotation public @interface MyAnnotation {{ public @interface MyAnnotation }} • Il est ensuite possible de compléter l'annotation avec : • Des paramètres •Pour véhiculer des données supplémentaires • Des méta-annotations •Pour spécifier les conditions d'utilisation de l'annotation ©Zenika 21
  • 22. Annotation personnalisées Paramètres d'annotations • Chaque paramètre se déclare sous la forme d'une méthode (non générique, sans paramètres et sans exceptions) • Il peut posséder une valeur par défaut (compile-time constant), déclarée grâce au mot-clé "default" ; il est alors optionnel. public @interface MyAnnotation {{ public @interface MyAnnotation String message(); String message(); int answer() default 42; int answer() default 42; }} @MyAnnotation( message="Hello World" )) @MyAnnotation( message="Hello World" @MyAnnotation( message="Hello World", answer == 00 )) @MyAnnotation( message="Hello World", answer ©Zenika 22
  • 23. Annotation personnalisées Paramètres d'annotations • Si l'annotation ne possède qu'un seul paramètre nommé "value", il est possible d'utiliser une syntaxe raccourcie public @interface MyAnnotation {{ public @interface MyAnnotation String value(); String value(); }} @MyAnnotation( "Hello World" )) @MyAnnotation( "Hello World" @MyAnnotation( value == "Hello World" )) @MyAnnotation( value "Hello World" ©Zenika 23
  • 24. Annotation personnalisées Paramètres d'annotations • Comme dans toute interface, il est possible de définir des classes, interfaces ou enums internes public @interface MyAnnotation {{ public @interface MyAnnotation int defaultAnswer == 42; int defaultAnswer 42; int answer() default defaultAnswer; int answer() default defaultAnswer; enum Season {SPRING, SUMMER, FALL, WINTER}; enum Season {SPRING, SUMMER, FALL, WINTER}; Season season(); Season season(); }} @MyAnnotation( season == MyAnnotation.Season.WINTER )) @MyAnnotation( season MyAnnotation.Season.WINTER ©Zenika 24
  • 25. Annotation personnalisées Les Méta-Annotations : @Target • La méta-annotation @Target indique sur quels éléments de code l'annotation peut être apposée : @Target( ElementType[] )) @Target( ElementType[] public @interface MyAnnotation {{ public @interface MyAnnotation }} • Exemple : @Target( {ElementType.TYPE, ElementType.METHOD} )) @Target( {ElementType.TYPE, ElementType.METHOD} public @interface MyAnnotation {{ public @interface MyAnnotation }} ©Zenika 25
  • 26. Annotation personnalisées Les Méta-Annotations : @Target • Valeurs possibles pour l'enum ElementType : • TYPE • CONSTRUCTOR • FIELD • METHOD • PARAMETER • LOCAL_VARIABLE • ANNOTATION_TYPE (méta-annotation) • PACKAGE • TYPE_PARAMETER et TYPE_USE (JSR 308, Java 7 8?) Ex: @English String @NonEmpty [] • Si le paramètre n'est pas spécifié, l'annotation peut être utilisée partout (Ex : @Deprecated) ©Zenika 26
  • 27. Annotation personnalisées Les Méta-Annotations : @Retention • La méta-annotation @Retention indique la durée de vie de l'annotation @Retention( RetentionPolicy )) @Retention( RetentionPolicy public @interface MyAnnotation {{ public @interface MyAnnotation }} • Exemple @Retention( RetentionPolicy.RUNTIME )) @Retention( RetentionPolicy.RUNTIME public @interface MyAnnotation {{ public @interface MyAnnotation }} ©Zenika 27
  • 28. Annotation personnalisées Les Méta-Annotations : @Retention • Valeurs possibles pour l'enum RetentionPolicy : • SOURCE • CLASS (par défaut) • RUNTIME compilation class loading SOURCE CLASS RUNTIME ©Zenika 28
  • 29. Annotation personnalisées Les Méta-Annotations : @Inherited • La méta-annotation @Inherited indique que l'annotation est héritée par les classes filles de la classe annotée @Inherited @Inherited public @interface MyAnnotation {{ public @interface MyAnnotation }} • Restrictions • Seules les annotations portées sur les classes sont héritées • Les annotations apposées sur une interface ne sont pas héritées par les classes implémentant cette interface ; idem pour les packages. ©Zenika 29
  • 30. Annotation personnalisées Les Méta-Annotations : @Documented • La méta-annotation @Documented indique que l'annotation doit apparaître dans la javadoc @Documented @Documented public @interface MyAnnotation {{ public @interface MyAnnotation }} ©Zenika 30
  • 31. Annotation personnalisées Démos Démos • Développer une annotation •Décompiler une annotation ©Zenika 31
  • 32. Plan • Présentation • Anatomie • Mode d'emploi • Annotations personnalisées • Outillage compile-time • Historique et use-cases • Processus de compilation • Anatomie d'un processeur • Limitations • Outillage runtime • Injection d'annotations • Conclusion ©Zenika 32
  • 33. Outillage compile-time Historique et use-cases Historique • Java 5.0 : APT (Annotation Processing Tool) • Devait être lancé en plus du compilateur javac • Java 6.0 : Pluggable Annotation Processors • Intégrés au processus de compilation standard • Paramètre -processor ou utilisation du SPI (Service Provider Interface) Pour plus d'informations sur le SPI, voir : • Un article sur The Coder's Breakfast • La Javadoc de java.util.ServiceLoader ©Zenika 33
  • 34. Outillage compile-time Historique et use-cases Use-cases • Génération de ressources : "XDoclet ++" • Fichiers de configuration • Classes annexes •Ex: Proxies, PropertyEditors... • Documentation •Ex: Matrice des rôles JavaEE, cartographie d'IOC... • Amélioration du compilateur • Vérification de normes de codage •Ex: Les classes "modèle" doivent être Serializable... • Messages d'alerte ou d'erreur supplémentaires ©Zenika 34
  • 35. Outillage compile-time Historique et use-cases Mention spéciale : Lombok (projectlombok.org) • Améliore "magiquement" les classes •Génère les getters/setters, equals/hashCode, toString • Viole la règle de non-modification des ressources existantes • Dépend des implémentations internes des compilateurs pour manipuler les AST des classes •com.sun.tools.javac.* •org.eclipse.jdt.internal.compiler.* • Danger : la compilation de votre projet dépend désormais du support de votre compilateur cible par Lombok. Peser le rapport gain / risques ! •Votre IDE propose également ces fonctionnalités ©Zenika 35
  • 36. Outillage compile-time Processus de compilation 1. Le compilateur découvre les processeurs d'annotations •Paramètre -processor sur la ligne de commande •ou via le Service Provider Interface (SPI) 2. Un round de compilation est lancé •Le compilateur et les processeurs s'exécutent •Si de nouvelles ressources sont créées lors de ce round, un nouveau round est lancé ©Zenika 36
  • 37. Outillage compile-time Anatomie d'un Processeur • Un processeur est une classe implémentant l'interface javax.annotation.processing.Processor • Généralement, on sous-classe AbstractProcessor • L'annotation @SupportedAnnotationTypes permet d'indiquer quelles annotations le processeur sait traiter • La méthode init() permet d'initialiser le processeur • La méthode principale process() reçoit un paramètre de type RoundEnvironment représentant l'environnement de compilation. Elle renvoie un booléen indiquant si l'annotation est définitivement "consommée" par ce processeur ©Zenika 37
  • 38. Outillage compile-time Anatomie d'un Processeur • Des utilitaires sont accessibles via la propriété processingEnv fournie par AbstractProcessor : • Types et Elements, permettant d'introspecter le code • Messager, pour lever des erreurs de compilation et afficher des messages dans la console • Filer, autorisant la création de nouvelles ressources (classes, fichiers de configuration...) Types Types types types == processingEnv.getTypeUtils(); processingEnv.getTypeUtils(); Elements Elements elts elts == processingEnv.getElementUtils(); processingEnv.getElementUtils(); Messager Messager messager messager == processingEnv.getMessager(); processingEnv.getMessager(); Filer Filer filer filer == processingEnv.getFiler(); processingEnv.getFiler(); ©Zenika 38
  • 39. Outillage compile-time Anatomie d'un Processeur @SupportedAnnotationTypes("com.zenika.*") @SupportedAnnotationTypes("com.zenika.*") public class MyProcessor extends AbstractProcessor {{ public class MyProcessor extends AbstractProcessor Types types; Types types; Elements elements; Elements elements; Messager messager; Messager messager; Filer filer; Filer filer; public void init(ProcessingEnvironment processingEnv) {{ public void init(ProcessingEnvironment processingEnv) super.init(processingEnv); super.init(processingEnv); types types == processingEnv.getTypeUtils(); processingEnv.getTypeUtils(); elements == processingEnv.getElementUtils(); elements processingEnv.getElementUtils(); messager == processingEnv.getMessager(); messager = processingEnv.getFiler(); processingEnv.getMessager(); filer filer = processingEnv.getFiler(); }} public boolean process( public boolean process( Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {annotations, Set<? extends TypeElement> RoundEnvironment roundEnv) { // TODO }} // TODO }} ©Zenika 39
  • 40. Outillage compile-time Anatomie d'un Processeur public boolean process( public boolean process( Set<? extends TypeElement> annotations, Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {{ RoundEnvironment roundEnv) // Pour chaque annotation traitée... // Pour chaque annotation traitée... for (TypeElement annotation :: annotations) {{ for (TypeElement annotation annotations) // Trouver les éléments portant cette annotation // Trouver les éléments portant cette annotation for (Element ee :: for (Element roundEnv.getElementsAnnotatedWith(annotation)) {{ roundEnv.getElementsAnnotatedWith(annotation)) messager.printMessage( messager.printMessage( Diagnostic.Kind.NOTE, Diagnostic.Kind.NOTE, e.getSimpleName()); e.getSimpleName()); }} }} return false; return false; }} ©Zenika 40
  • 41. Outillage compile-time Limitations • Développer un processeur est complexe ! • Les Types et les Elements offrent deux vues différentes sur le code compilé •Les Elements représentent l'AST brut du code •Les Types offrent une interface davantage typée "java" •Il existe des ponts entre ces deux univers • Le pattern Visiteur est beaucoup utilisé • Un processeur ne peut pas modifier du code existant ! • Quelques bugs encore, et un faible support dans les IDE ©Zenika 41
  • 42. Outillage compile-time Démos Démos • ListingProcessor •MessageHolderProcessor •SerializableClassesProcessor ©Zenika 42
  • 43. Plan • Présentation • Annotations, mode d'emploi • Annotations personnalisées • Outillage compile-time • Outillage runtime • Use-cases • Récupération des paramètres • Une fois les annotations récupérées... • Injection d'annotations • Conclusion ©Zenika 43
  • 44. Outillage runtime Use-cases • Au runtime, il est possible d'utiliser la Réflexion pour découvrir les annotations présentes sur les classes, champs, méthodes et paramètres de méthodes. • Uniquement si @Retention(RetentionPolicy.RUNTIME) • Use-cases : • Mapping Java ↔ ? • Programmation orientée POJO • Configuration de containers / frameworks • Exemples : • Hibernate, Apache CXF, XStream... • Spring, Guice, Java EE 5/6 (CDI, EJB 3.0, Servlets 3.0...) ©Zenika 44
  • 45. Outillage runtime Récupération des annotations • Les classes Package, Class, Constructor, Field et Method implémentent l'interface AnnotatedElement : public interface AnnotatedElement {{ public interface AnnotatedElement Annotation[] getAnnotations(); Annotation[] getAnnotations(); Annotation[] getDeclaredAnnotations(); Annotation[] getDeclaredAnnotations(); boolean isAnnotationPresent(Class annotationClass); boolean isAnnotationPresent(Class annotationClass); Annotation getAnnotation(Class annotationClass); Annotation getAnnotation(Class annotationClass); }} • getAnnotations() renvoie toutes les annotations applicables à l'élément, y compris les annotations héritées • getDeclaredAnnotations() ne renvoie que les annotations directement apposées sur l'élément ©Zenika 45
  • 46. Outillage runtime Récupération des annotations • Exemple : lecture des annotations d'une classe et de celles de son package // Annotations sur la classe // Annotations sur la classe Annotation[] clsAnnots == Pojo.class.getAnnotations(); Annotation[] clsAnnots Pojo.class.getAnnotations(); for (Annotation annot :: clsAnnots) {{ for (Annotation annot clsAnnots) System.out.println(annot); System.out.println(annot); }} // Annotations sur le package // Annotations sur le package Package pkg == Pojo.class.getPackage(); Package pkg Pojo.class.getPackage(); Annotation[] pkgAnnots == pkg.getDeclaredAnnotations(); Annotation[] pkgAnnots pkg.getDeclaredAnnotations(); for (Annotation annot :: pkgAnnots) {{ for (Annotation annot pkgAnnots) System.out.println(annot); System.out.println(annot); }} ©Zenika 46
  • 47. Outillage runtime Récupération des annotations • Les classes Constructor et Method permettent également de récupérer les annotations présentes sur leurs paramètres • Annotation[][] getParameterAnnotations() • Renvoie un tableau d'annotations par paramètre, dans l'ordre de leur déclaration dans la signature de la méthode public void printParamAnnots(Method method) {{ public void printParamAnnots(Method method) Annotation[][] allAnnots == Annotation[][] allAnnots method.getParameterAnnotations(); method.getParameterAnnotations(); for (Annotation[] annots :: paramAnnots) {{ for (Annotation[] annots paramAnnots) System.out.println(Arrays.toString(annots)); System.out.println(Arrays.toString(annots)); }} }} ©Zenika 47
  • 48. Outillage runtime Une fois les annotations récupérées... • Que peut-on faire avec les annotations récupérées par réflexion ? • On peut découvrir leur type dynamiquement Class<? extends Annotation> annotationType() • On peut lire leurs paramètres (cast nécessaire) Annotation annot == …… ;; Annotation annot // Détermination du type réel de l'annotation // Détermination du type réel de l'annotation Class<? extends Annotation> annotClass == Class<? extends Annotation> annotClass myAnnotation.annotationType(); myAnnotation.annotationType(); // Affichage du message de MyAnnotation // Affichage du message de MyAnnotation if (annot instanceof MyAnnotation) {{ if (annot instanceof MyAnnotation) MyAnnotation myAnnot == (MyAnnotation) annot; MyAnnotation myAnnot (MyAnnotation) annot; System.out.println(myAnnot.message()); System.out.println(myAnnot.message()); }} ©Zenika 48
  • 49. Outillage runtime Démos Démos • Démonstration • Exemple : CSVReader ©Zenika 49
  • 50. Plan • Présentation • Mode d'emploi • Annotations personnalisées • Outillage compile-time • Outillage runtime • Injection d'annotations • Au coeur de la classe Class • Instancier dynamiquement une annotation • Injection dans une classe • Injection sur une méthode ou un champ • Conclusion ©Zenika 50
  • 51. Injection d'annotations Au coeur de la classe Class • Dans la classe Class, les annotations sont représentées sous la forme de Maps : private transient Map<Class, Annotation> annotations; private transient Map<Class, Annotation> annotations; private transient Map<Class, Annotation> declaredAnnotations; private transient Map<Class, Annotation> declaredAnnotations; • Ces maps sont initialisées lors du premier appel à getAnnotations() ou getDeclaredAnnotations() • L'initialisation est réalisée en décodant le byte[] renvoyé par la méthode native getRawAnnotations() • En modifiant ces maps par Réflexion, il est possible d'injecter arbitrairement des annotations sur une Classe au runtime ! ©Zenika 51
  • 52. Injection d'annotations Instancier une annotation • Pour obtenir une instance de l'annotation à injecter, il suffit d'instancier une classe anonyme implémentant son "interface" MyAnnotation myAnnotation == new MyAnnotation() {{ MyAnnotation myAnnotation new MyAnnotation() @Override @Override public String message() {{ public String message() return MyAnnotation.defaultMessage; }} return MyAnnotation.defaultMessage; @Override @Override public int answer() {{ public intMyAnnotation.defaultAnswer; answer() return MyAnnotation.defaultAnswer; }} return @Override @Override public Class<? extends Annotation> annotationType() {{ public Class<? extends Annotation> annotationType() return MyAnnotation.class; }} return MyAnnotation.class; }; }; ©Zenika 52
  • 53. Injection d'annotations Injection sur une Classe • Il ne reste plus qu'à utiliser la Réflexion pour injecter notre annotation dans la classe cible public static void injectClass public statictargetClass, Annotation annotation) { void injectClass (Class<?> targetClass, Annotation annotation) { (Class<?> // Initialisation des maps d'annotations // Initialisation des maps d'annotations targetClass.getAnnotations(); targetClass.getAnnotations(); // Récupération de la map interne des annotations // Récupération de la map interne des annotations Field mapRef == Class.class.getDeclaredField("annotations"); Field mapRef Class.class.getDeclaredField("annotations"); mapRef.setAccessible(true); mapRef.setAccessible(true); // Modification de la map des annotations Map<Class, Annotation> map des=annotations // Modification de la annots Map<Class, Annotation> annots = (Map<Class, Annotation>) mapRef.get(targetClass); if (annots==null Annotation>) mapRef.get(targetClass); (Map<Class, || annots.isEmpty()) { if annots = new HashMap<Class, Annotation>(); (annots==null || annots.isEmpty()) { }} annots = new HashMap<Class, Annotation>(); pojoAnnotations.put(annotation.annotationType(), annotation); pojoAnnotations.put(annotation.annotationType(), annotation); mapRef.set(targetClass, pojoAnnotations); }} mapRef.set(targetClass, pojoAnnotations); ©Zenika 53
  • 54. Injection d'annotations Injection sur une Méthode ou un Champ • L'injection d'annotations sur les classes Constructor, Field et Method est plus problématique • Au sein de la classe Class, les méthodes getConstructor(), getField(), ou getMethod() renvoient des copies des objets correspondants Method m1 == Pojo.class.getDeclaredMethod("foo", null); Method m1 Pojo.class.getDeclaredMethod("foo", null); Method m2 == Pojo.class.getDeclaredMethod("foo", null); Method m2 Pojo.class.getDeclaredMethod("foo", null); System.out.println(m1==m2); // false System.out.println(m1==m2); // false • Ces copies sont initialisées directement à partir du bytecode de la classe, pas à partir d'une instance prééxistante • Les modifications apportées aux maps d'annotations sur une instance sont donc strictement locales à cette instance ©Zenika 54
  • 55. Injection d'annotations Injection sur une Méthode ou un Champ • Alors, comment faire ? • AOP pour intercepter les méthodes getConstructor(), getMethod(), getField() ? • Modifier directement la portion de bytecode correspondant à ces objets ? • Si vous trouvez une solution, je suis preneur ! ©Zenika 55
  • 56. Injection d'annotations Use-cases • Use-cases • Les annotations @Inherited posées sur les interfaces ne sont pas héritées par les classes implémentant ces interfaces. Il est possible d'y remédier en réinjectant manuellement ces annotations dans les classes. Mais attention aux conflits ! • … d'autres idées ? ©Zenika 56
  • 57. Injection d'annotations Démos Démos • Injection dans une classe • Injection dans un champ ©Zenika 57
  • 58. Plan • Présentation • Mode d'emploi • Annotations personnalisées • Outillage compile-time • Outillage runtime • Injection d'annotations • Conclusion ©Zenika 58
  • 59. Conclusion • Les doclets ont ouvert la voie à la méta-programmation ; Java 5.0 a standardisé et démocratisé les annotations • Tous les frameworks modernes utilisent les annotations • Elles complètent parfaitement les fichiers de configuration XML • Il est facile de développer des annotations personnalisées • Java fournit des outils pour les exploiter lors de la compilation et au runtime • Mais attention à la complexité ! ©Zenika 59
  • 60. ? Conclusion Questions / Réponses ©Zenika 60
  • 61. Références • Annotation processors • La documentation du SDK et la JLS • "Enforcing design rules with Pluggable Annotation Processors" sur http://thecodersbreakfast.net • La newsletter Javaspecialists (http://javaspecialists.eu) • JSR 308 et le framework Checkers • http://types.cs.washington.edu/jsr308/ • Lombok • http://projectlombok.org/ ©Zenika 61