Discussion :

[Nymethny]

Bonjour,

J'aimerai savoir si quelqu'un connait un moyen en java d'automatiser différentes actions (l'appel d'une méthode statique, par exemple) au début et à la fin d'un grand nombre de méthodes.

En gros, j'ai une méthode statique (appelons-la Perso.log() ) qui génère des logs personnalisés et que je dois appeler en début et fin d'un tres grand nombre de méthodes dans mon application.
Au lieu de copier/coller les appels à Perso.log() dans toutes les méthodes de quasi toutes les classes de mon appli, je me demandais s'il était pas possible d'automatiser le processus, un peu sur le même principe que les OnLoad() et autres pour les composants graphiques (je comprend qu'il y a une enorme difference, mais c'est pour expliquer le concept).

Peut-être en utilisant des @annotations, ou en passant par une interface ou classe abstraite qui serait implémentée/héritée par toutes les classes dont je veux "logger" les méthodes ?

Si quelqu'un l'a déjà fait, ou a une idée qui pourrait marcher, je suis preneur!

Merci d'avance,

Nymethny.

[william44290]

http://ewawszczyk.developpez.com/tut...va/spring/aop/

[Nymethny]

Merci beaucoup pour cette réponse, je sais maintenant que ce que je veux faire est possible .
Je vais donc orienter mes recherches du coté de l'AOP.

J'ai tout de même une petite question (probablement stupide, mais... ) :
N'utilisant pas Spring, et n'étant pas particulièrement familier avec les différents framework, je ne suis pas sur d'avoir compris comment cela fonctionne réellement.
Vu que l' "ajout" de code se fait visiblement à la compilation, faut il obligatoirement utiliser un framework ?
Ou cela peut-il être géré uniquement par une/des librairie(s) à inclure dans le projet ?

Merci d'avance,

Nymethny.

[therwald]

Si tu utilises l'AOP Spring, alors il faut intégrer Spring (une lib). L'ajout des aspects se fait au runtime. D'ailleurs que dans le contexte Spring, c'est à dire pour les instances qui ont été créées par Spring.
Par contre il existe une autre manière de faire de l'AOP avec aspectJ pour laquelle le tissage (weaving), c'est à dire l'ajout des aspects, se fait à la compilation. Avantage: dans ce cas il n'y a pas la limitation sur les instances qui ont les aspects ou pas comme pour Spring. Inconvénient: c'est une phase de compilation particulière donc ton process de build doit être adapté.
Dans les deux cas tu introduis une dépendance runtime (aspectjrt.jar pour aspectJ, Spring+ses dépendances dans le cas AOP Spring).

[billynirvana]

Regarde plutôt du côté d'AspectJ:

http://www.eclipse.org/aspectj

[Jimmy_]

Utiliser Spring et faire de l'AOP juste pour faire du logging, c'est gaché quand même. A la place d'avoir les appels dans le code il aura 4 km de fichier xml.
Tu seras content avec ton gros fichier xml.

Quel est le soucis de faire un appel a un logger partout dans ton code ?
C'est très classique et très utilisé.