Conférence: Les annotations enfin expliquées simplement

5

Mardi dernier, Olivier Croisier, a présenté une présentation dédiée aux annotations dans les locaux de Zenika.

Olivier a commencé la présentation en revenant sur les principes des annotations et leur mise en oeuvre au quotidien, puis a démontré l’étendue des possibilités qu’elles offrent à la compilation et au runtime, grace aux annotations Processors et la Reflexion en s’appuyant sur des exemples concrets.

La présentation a remporté un franc succès :

  • « Très intéressant. Niveau technique avancé » A. F.
  • « Vivement le prochain projet pour qu’on mette cela en place » JP. L.
  • « Excellente présentation avec démo hardcore à la fin 😉 » C. M.
  • « Présentation bien organisée avec des exemples à la fin » B. A.
  • « Très bon intervenant » S. F.
  • « Très éclairant sur le sujet » O. P.
  • « J’ai appris beaucoup de choses concernant les annotations. Merci! » A. O.
Les slides et les sources de la démo sont disponibles en annexe de ce billet. 

Allez plus loin !

Si vous aussi vous voulez maîtriser les fonctionnalités les plus avancées du langage Java, inscrivez vous dès maintenant à la formation Java Spécialiste de septembre animée par Olivier Croisier.

Pour vous donner un avant goût : the JavaSpecialist’s Newsletter
Partagez cet article.

A propos de l'auteur

5 commentaires

  1. salut

    slides bien réalisés, reprenant un graphisme proche des Head First, bonne idée :)

    Quelques remarques toutefois.

    Perso j’aurai également évoqué les utilitaires de scan de jar/sources afin de trouver toutes les annotations une fois pour toutes et constituer un « annuaire » des annotations présentes.

    Cela évite d’itérer à travers tous les class loaders à chaque fois que l’on cherche les utilisateurs de telle ou telle annotation (le scan est alors fait une fois pour toute).

    Dès qu’on utilise beaucoup les annotations, de tels outils rendent les choses vraiment plus rapides.

    Voir par exemple Scannotations (http://scannotation.sourceforge.net…) ou Reflections(http://code.google.com/p/reflection…). JBoss avait aussi un projet similaire, mais à l’époque cela ne semblait pas avoir dépassé le cadre de l’annonce (ça a pu changer depuis).

    Par ailleurs, un exemple « avancé » d’utilisation des annotations pour l’APT, j’aurai, personnellement, mentionné le projet Lombok (http://projectlombok.org/), ne serait ce qu’en guise d’ouverture.

    Enfin, je ne vois pas l’intérêt d’injecter des annotations dans la classe Class. Des cas d’utilisations auraient été bienvenus, là cela semble très théorique (et non fonctionnel à ce que j’en ai compris).

    encore merci !
    ++
    joseph

  2. Bonjour et merci pour ce partage,

    AMHA, il manque une slide « pour aller plus loin », une autre « références ».

    Disclaimer: A cette heure, je n’ai pu que survoler le contenu des slides.

    Pour moi, cela sera un excellent point de départ, je cherche à créer des annotations qui permettront de générer dynamiquement des méthodes à partir de templates (texte) sous G App Engine.

    Merci

    Jérôme

  3. Un très bon support, ça manque toujours. Merci beaucoup.

    La partie sur compile-time est très instructive.

    Je vais l’ajouter dans mes liens de la semaine pour archivage, ça pourra toujours servir 😉

    Mickael

  4. Merci pour les liens Joseph, je ne connaissais pas les outils de scan d’annotations. Ca a l’air intéressant !

    Concernant Lombok, ça semblait un peu trop magique à mon goût : normalement, les processeurs d’annotations ne sont pas autorisés à modifier le code des sources existantes. Je suis donc allé regarder le code source, et là, horreur : Lombok utilise les classes de javac (com.sun.javac.*) et du compilateur d’Eclipse pour modifier l’AST des classes. Les utilisateurs sont donc fortement liés à un compilateur particulier, sans garantie de portabilité ni d’évolutivité (c’est d’ailleurs indiqué dans la javadoc de Lombok). Au final, je déconseille donc fortement l’utilisation de cet outil, qui si l’on regarde bien, ne procure absolument aucune « killer-feature ».

    Enfin, dans ma conférence, je n’injecte pas des annotations dans la classe Class, mais dans ses instances : String.class, Pojo.class, Foo.class. Simplement, au lieu de placer les annotations sur ces classes lors de leur développement, je les injecte au runtime.
    Je n’ai pas encore réellement trouvé de use-case pour le moment (mais je n’ai pas trop eu le temps de chercher non plus). J’imagine qu’on pourrait transformer n’importe quelle classe en EJB en injectant @Stateless avant de la charger dans un container embarqué, par exemple. Ou en composant Spring en injectant @Component.
    Si vous trouvez des cas d’utilisation utiles (ou non), je suis preneur !

  5. Bonjour Olivier Croisier. Ma réaction si tardive vous étonnera certainement, mais je viens à peine de tomber sur le présent. Votre conférence intitulée « Les annotations enfin expliquées simplement », qualifiée de « très bon support » par Mickael Baron (dont je lis les publications depuis longtemps et avec un grand intérêt) ne peut qu’attiser mon intérêt, les annotations étant, en plus, un sujet que je cherche à approfondir. Il se fait malheureusement que ni la vidéo ni ses documents annexes (les slides et les sources de la démo) ne sont accessibles à partir de la présente page. Pouvez-nous m’aider à me les procurer ? Merci d’avance. (Luc, Rabat, Maroc).

Ajouter un commentaire