SlideShare une entreprise Scribd logo

Annotations Java par Olivier Croisier

Normandy JUG, profile picture
Normandy JUG

Ce document explique les annotations Java, leur utilisation, et comment créer des annotations personnalisées. Il aborde aussi l'historique des annotations, leur intégration dans le développement Java, et les outils associés pour leur traitement au moment de la compilation. Enfin, il détaille des concepts comme les méta-annotations, les paramètres d'annotations et les restrictions à respecter.

Technologie
1  sur  61
Téléchargé 30 fois
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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

PDF
Conférence sur les annotations Java par Olivier Croisier (Zenika) au Paris JUG
Zenika
 
PDF
Cours JavaScript
Olivier Le Goaër
 
PDF
Voxxdays luxembourg 2016 retours java 8
Jean-Michel Doudoux
 
ODP
Patterns and OOP in PHP
julien pauli
 
PDF
"Input/Ouput, 16 ans après" à Devoxx France 2012
Jean-Michel Doudoux
 
PDF
Voxxeddays lux 2018 apres java 8, java 9 et 10
Jean-Michel Doudoux
 
PPTX
Nouveautés JavaScript dans le monde Microsoft
davrous
 
PDF
Traits : de la théorie à la pratique
Frederic Hardy
 
Conférence sur les annotations Java par Olivier Croisier (Zenika) au Paris JUG
Zenika
 
Cours JavaScript
Olivier Le Goaër
 
Voxxdays luxembourg 2016 retours java 8
Jean-Michel Doudoux
 
Patterns and OOP in PHP
julien pauli
 
"Input/Ouput, 16 ans après" à Devoxx France 2012
Jean-Michel Doudoux
 
Voxxeddays lux 2018 apres java 8, java 9 et 10
Jean-Michel Doudoux
 
Nouveautés JavaScript dans le monde Microsoft
davrous
 
Traits : de la théorie à la pratique
Frederic Hardy
 

Tendances (20)

PPTX
Présentation de ECMAScript 6
Julien CROUZET
 
PDF
AlterWay SolutionsLinux Outils Industrialisation PHP
julien pauli
 
PPTX
Javascript un langage supérieur
Fredy Fadel
 
PDF
Ce bon vieux propel
Francois Zaninotto
 
PDF
Javascript pour le développeur Java
jollivetc
 
PPTX
Language java
LAMINE KACIMI
 
PPTX
Introduction à Python
Abdoulaye Dieng
 
PDF
Cours java
Zakaria Mouammin
 
ODP
Solutions Linux 2008 - JavaScript
Raphaël Semeteys
 
PPTX
Présentation JavaScript
tarkan_
 
PDF
Introduction java
Fouad Root
 
PPTX
Change mind about JS
Damien Simonin Feugas
 
ODP
Introduction à JavaScript
Microsoft
 
ODP
#5 Java EE5 Client Lourd et Smart Client
Guillaume Sauthier
 
PPTX
Initiation à l'algorithmique
Abdoulaye Dieng
 
PDF
Soda sotm fr-2013_02_24
quicky_osm
 
PDF
Du JavaScript dans mon projet
jollivetc
 
PDF
Javascript pour les Développeurs WEB
Abbes Rharrab
 
ODT
Soda sotm fr-2013_02_24
quicky_osm
 
PDF
Devoxx 2018 Après Java 8, Java 9 et 10
Jean-Michel Doudoux
 
Présentation de ECMAScript 6
Julien CROUZET
 
AlterWay SolutionsLinux Outils Industrialisation PHP
julien pauli
 
Javascript un langage supérieur
Fredy Fadel
 
Ce bon vieux propel
Francois Zaninotto
 
Javascript pour le développeur Java
jollivetc
 
Language java
LAMINE KACIMI
 
Introduction à Python
Abdoulaye Dieng
 
Cours java
Zakaria Mouammin
 
Solutions Linux 2008 - JavaScript
Raphaël Semeteys
 
Présentation JavaScript
tarkan_
 
Introduction java
Fouad Root
 
Change mind about JS
Damien Simonin Feugas
 
Introduction à JavaScript
Microsoft
 
#5 Java EE5 Client Lourd et Smart Client
Guillaume Sauthier
 
Initiation à l'algorithmique
Abdoulaye Dieng
 
Soda sotm fr-2013_02_24
quicky_osm
 
Du JavaScript dans mon projet
jollivetc
 
Javascript pour les Développeurs WEB
Abbes Rharrab
 
Soda sotm fr-2013_02_24
quicky_osm
 
Devoxx 2018 Après Java 8, Java 9 et 10
Jean-Michel Doudoux
 
Publicité

Similaire à Annotations Java par Olivier Croisier (20)

PDF
0251-formation-java-programmation-objet.pdf
Ombotimbe Salifou
 
PDF
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
Jean-Michel Doudoux
 
PDF
Javaday Paris 2022 - Java en 2022 : profiter de Java 17
Jean-Michel Doudoux
 
PPTX
Nouveautés de java 8
Florian Beaufumé
 
PPT
.Net pour le développeur Java - une source d'inspiration?
Rui Carvalho
 
PDF
JavaLesBasespourles debutantset pour vous.pdf
hindguendouz2000
 
PPTX
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Loic Yon
 
PDF
tp-spring.pdf
badrfathallah2
 
PDF
tp-spring.pdf
seydou4devops
 
PPT
Langage Java et Programmation Orienté Objet
Mohammed Jaafar
 
PDF
Octo Maven.pdf
badrfathallah2
 
PDF
Apres java 8, java 9 et 10 - BreizhCamp 2018
Jean-Michel Doudoux
 
PPTX
Javaoop
javaexpert
 
PDF
Qualité logicielle
cyrilgandon
 
PDF
GetText / Rails - FR
Sylvain Abélard
 
PDF
GetText / Rails
Sylvain Abélard
 
PDF
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Olivier DASINI
 
PDF
Programmation orientee aspect 201401 - Ensim
Laurent Broudoux
 
PPTX
Ez18n Annotation Processing Tool in a nutshell
gdigugli
 
PDF
Pluggable annotation processing api
Arnaud Tournier
 
0251-formation-java-programmation-objet.pdf
Ombotimbe Salifou
 
devoxx 2022 - 10 ans de Devoxx FR et de Java.pdf
Jean-Michel Doudoux
 
Javaday Paris 2022 - Java en 2022 : profiter de Java 17
Jean-Michel Doudoux
 
Nouveautés de java 8
Florian Beaufumé
 
.Net pour le développeur Java - une source d'inspiration?
Rui Carvalho
 
JavaLesBasespourles debutantset pour vous.pdf
hindguendouz2000
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Loic Yon
 
tp-spring.pdf
badrfathallah2
 
tp-spring.pdf
seydou4devops
 
Langage Java et Programmation Orienté Objet
Mohammed Jaafar
 
Octo Maven.pdf
badrfathallah2
 
Apres java 8, java 9 et 10 - BreizhCamp 2018
Jean-Michel Doudoux
 
Javaoop
javaexpert
 
Qualité logicielle
cyrilgandon
 
GetText / Rails - FR
Sylvain Abélard
 
GetText / Rails
Sylvain Abélard
 
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Olivier DASINI
 
Programmation orientee aspect 201401 - Ensim
Laurent Broudoux
 
Ez18n Annotation Processing Tool in a nutshell
gdigugli
 
Pluggable annotation processing api
Arnaud Tournier
 
Publicité

Plus de Normandy JUG (20)

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

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