Discussion :

[ZeKiD]

Bonjour,

Je cherche un livre qui traiterait des annotations en détails.
Je suis plutôt expérimentés en Java, et les bouquins Java 5 sont un peu trop pour moi ( j'en ai déjà en 1.2, et 1.4 ... ), car j'aimerai simplement savoir ce que sont ces fameuses annotations, mais surtout à terme pouvoir en développer moi même.
Celle qui m'intéresse essentiellement étant celle en RUNTIME !!!
Donc s'il y en a parmi vous, qui ont développé des annotations, et bien je suis preneur de tout livre ou tutoriel que vous auriez trouvé.
De préférence en français, mais au pire pourquoi pas en français.
D'avance merci à tous.

[adiGuba]

Salut,

De préférence en français, mais au pire pourquoi pas en français.

Ou sinon en français ce te conviendrais ???



Tu peux jeter un coup d'oeil à mon tutoriel : Les Annotations de Java 5.0

Mais attention la troisième section sur APT (Annotation Processing Tool) est spécifique à Java 5.0 et pas du tout standard. Par contre Java 6 possède un mécanisme similaire mais standardisé par la JSR 269 (mais que je ne traite pas dans ce tutoriel).


Pour la partie runtime c'est tout bête : tu utilises l'API de réflection pour récupérer les annotations et leurs valeurs...

a++

[ZeKiD]

Super !!
Euh !! Oui je m'a gourré pour le français
Merci beaucoup, je dois y aller à cause des grêves, mais je regarderai ce we.
Merci à toi et bon we.
S'il y en a qui ont traité le cas de Java 6, je suis aussi preneur.
Encore merci.

[ZeKiD]

Bon alors je viens de regarder ton lien.
Effectivement, j'avais déjà lu ce tuto. Très bien fait d'ailleurs.
A mon grand regret effectivement, tu ne parles pas des annotations en Runtime.
J'ai bien compris la logique avec la réflexion, mais je me demande simplement comment faire pour intercepter la création de mes objets.
Dois-je créer un ClassLoader pour pouvoir contrôler ces créations, et / ou appels au méthodes, et / ou propriété ?
En gros comment faire pour intercepter ces différents appels ?

[adiGuba]

A mon grand regret effectivement, tu ne parles pas des annotations en Runtime.
J'ai bien compris la logique avec la réflexion,

Euh... les annotations en runtime pour moi cela consiste à utiliser la réflection pour récupérer les informations contenu dans les annotations et effectuer des traitements selon leurs valeurs...

mais je me demande simplement comment faire pour intercepter la création de mes objets.
Dois-je créer un ClassLoader pour pouvoir contrôler ces créations, et / ou appels au méthodes, et / ou propriété ?
En gros comment faire pour intercepter ces différents appels ?

Que veux-tu faire exactement ?
Je ne pense pas que les annotations soient adapté pour ce que tu souhaites faire...

a++

[ZeKiD]

En fait l'idée est relativement simple, et mets venue de la lecture d'un livre Java EE5.
Apparemment , en EJB3, il te suffit d'annoter tes classes pour pouvoir faire tous le traitement d'appels de EJB.
Je cherche donc d'abord à faire une simple annotation qui permettent par exemple, de compter le nombre d'objets générés depuis une classe.
Pour çà, je me suis dit, il suffit que j'annote une classe, et que hop, j'ai mon résultat.
Comme les EJB3 avec le container d'EJB, mais mon problème réside d'en l'interception de la création d'objets ou d'appels de méthodes.
Alors c'est faisable, mais comment ???

[adiGuba]

En fait l'idée est relativement simple, et mets venue de la lecture d'un livre Java EE5.
Apparemment , en EJB3, il te suffit d'annoter tes classes pour pouvoir faire tous le traitement d'appels de EJB.

Je ne sais pas exactement ce que permettent les annotations des EJB 3, mais une chose est certaines ils ne permettent pas de modifier les classes sur lesquelles elles se trouvent.


Les annotations sont :

• Soit utilisées à l'exécution via l'API de réflection.
• Soit utilisées à la compilation (via APT ou les Processor de Java 6) pour générer des fichiers ou de nouvelles classes.

a++

[ZeKiD]

En effet, elles ne permettent pas de modifier une classe à l'exécution, mais d'effectuer un traitement avant ou après la création d'un objet, d'appel de méthode ou autre.
C'est dommage, que tu ne connaisses pas les EJB3, tu aurais certainement compris où je voulais en venir.
En tout cas merci déjà pour tes réponses, et si tu as l'occasion, tu vois ce que je veux faire !!!
Merci d'avance.

[adiGuba]

En effet, elles ne permettent pas de modifier une classe à l'exécution, mais d'effectuer un traitement avant ou après la création d'un objet, d'appel de méthode ou autre.

Non non non : les annotations ne permettent pas cela ! Les annotations ne sont vraiment que des données informatives qui peuvent être manipulé à la compilation ou à l'exécution.

Ce que tu décris ressemble plutôt à de la programmation orientée aspect (qui éventuellement utiliserait des annotations).

Comme AspectJ par exemple (par contre je ne connais que de nom)

a++

[ZeKiD]

Effectivement, je connais aussi comme toi, la programmation Aspect, et il y a effectivement fort à parier que ce soit ce genre de chose.
Je pensais que c'était automatique avec les annotations.
Mais bon certainement que tu as raison !!

[manblaizo]

En effet, elles ne permettent pas de modifier une classe à l'exécution, mais d'effectuer un traitement avant ou après la création d'un objet, d'appel de méthode ou autre.
C'est dommage, que tu ne connaisses pas les EJB3, tu aurais certainement compris où je voulais en venir.
En tout cas merci déjà pour tes réponses, et si tu as l'occasion, tu vois ce que je veux faire !!!
Merci d'avance.

Non non non : les annotations ne permettent pas cela ! Les annotations ne sont vraiment que des données informatives qui peuvent être manipulé à la compilation ou à l'exécution.

Ce que tu décris ressemble plutôt à de la programmation orientée aspect (qui éventuellement utiliserait des annotations).

Salut,
Connaissant assez bien les EJB, et les EJB3 en particulier, je pense que adiGuba a raison. Ce que tu as dû lire, ZeKiD, c'est certainement le concept d'Interceptor qui a été ajouté dans EJB 3.0. Un Interceptor dans EJB3 te permet de pouvoir, euh..., intercepter un appel de méthode sur ton ejb et effectuer un traitement avant et/ou après l'exécution effective de la méthode. Ce qui permet donc d'externaliser par exemple du code de logging, d'audit, de sécurité, etc, dans une autre classe pour maintenir le code principal plus clair et plus lisible. Et pour ce faire, tu informes le container EJB à propos de ton Interceptor en annotant la classe ou la méthode (annotation @Interceptor ou @Interceptors, @AroundInvoke). Mais tu n'es pas obligé d'utiliser les annotations pour ça, tu peux très bien ajouter cette configuration dans le descripteur de déploiement (ejb-jar.xml). Il s'agit bien du concept d'AOP (Aspect-Oriented Programming) comme l'a dit adiGuba (même si ça reste rudimentaire par rapport à ce qu'on peut faire dans Spring par exemple en utilisant AspectJ).
J'espère que cela contribue à éclaircir les choses.

[ZeKiD]

Assurément cela éclaircit les choses.
En fait, les annotations que j'ai vu, proviennent du livre Cahier du programmeur Java EE5. Il y a entre autre chose les annotations du type @Stateless, ou @Statefull etc ....
Effectivement, cela doit être un coup d'Aspect derrière tout çà.
En tout cas c'est bien pratique tout çà, et j'espère qu'il intégrerons çà dans un futur JDK.
Je trouve en effet, que c'est un super complément aux annotations de type Runtime. Cela nous évite la réflexion, et comme cela on peut intervenir au cours d'un projet avec des petites annotations par ci par là pour améliorer les dev.
En tout cas merci beaucoup pour ces éclairssissements.
Je ne me suis pas encore intéressé de prêt à Aspect, pas le temps ni l'obligation, mais je crois que je vais m'y intéresser de très prêt.
En tout cas encore merci à vous deux.
Et j'espère que cela aura aidé d'autre personne.