Salut les gens !
 
Voilà, j'ai un projet pour lequel je dois programmer un logger pour enregistrer tout le déroulement d'un algo, au niveau de ses variables par exemple.
En gros, je veux enregistrer la variable et sa valeur dès qu'elle est créée et dès qu'elle est modifiée. Avec ça, je pourrais ensuite mieux voir ce qu'il se passe dans mon algo au fur et à mesure de ses appels successifs.
 
Pour le logger, je vais sûrement utiliser la lib log4j qui est quand même super pratique !  Je reste néanmoins ouvert à toute autre suggestion !
 
Après, pour ne pas avoir à réécrire 35x la même chose à tous les endroits où mon algo va changer la moindre variable (j'ai quand même pas mal de calcul dedans... ), j'avais dans l'idée d'utiliser d'une part des annotations pour faciliter l'intégration du logger dans le code et d'autres part des observateurs (?) pour qu'une fois appelé pour une variable, le logger enregistre toute modification de cette variable.
Grâce à ça, je n'aurai plus qu'à écrire un truc genre @log(variable1) ou @logs(variable1, variable2, ...) pour que les variables citées soient suivies et enregistrées !  Et tout le système serait géré dans un projet à part et importé via une archive jar !
 
Jusque là, ça me paraît une idée plutôt correcte et qui pourrait bien fonctionner ! Venons-en maintenant à mes problèmes...  
Déjà, j'ai du mal à créer des annotations : ça date du jdk 1.5 (avec apt), ça a été amélioré dans le 1.6 (où c'est intégré dans javac) mais c'est pas encore le top, genre c'est pas compatible avec Éclipse (et j'ai pas le choix, je dois travailler avec) ou en tout cas la structure est pas la même dans les deux cas, ...  En plus, il n'y a presque aucun tuto sur le web qui traite de la création d'annotation avec le jdk 1.6...
Mon autre souci concerne les observateurs : j'ai trouvé un tuto qui m'a l'air pas mal sur le web (de mémoire, sur Developpez) mais je me pose un question à propos de l'initialisation du truc : l'annotation doit être appelée avant la méthode mais ne faut-il pas initialiser la variable avant d'initialiser l'observateur ? et comment je fais dans ce cas ?  
 
 
Voilà en gros mes problèmes !  Donc maintenant : est-ce que vous auriez des solutions , des conseils à me donner ? Est-ce que vous pensez que c'est infaisable  ou alors que c'est trivial et que c'est fournit dans une lib quelconque ? (on sait jamais )
Je suis tout ouï et j'attends vos messages !    
 
Merci d'avance !
 
Bobby qui galère depuis 2 semaines dessus...

 
Et pourquoi ne pas tout simplement utiliser java.util.logging ?
 

 
J'avoue ne pas avoir trifouillé les annotations depuis un beau paquet de temps, mais pourquoi n'utilises-tu tout simplement pas un schéma OO du type "Observateur" justement ? C'est tout simple à faire et ça mange pas de pain .
 
Plus d'infos ici, T. 207.
 

 
Bon, y a certainement des gens plus connaisseurs que moi de librairies extérieures, je suis objectivement parlant plutôt un intégriste du "pas besoin de sortir de l'API standard quand c'est pas nécessaire" à tout prix.
 
Ma conclusion en très peu de mot: tu te compliques trop la vie . En utilisant quelques outils bien choisis dans le JDK et un bon schéma OO, je ne vois pas ce qu'il te faudrait de plus .

Si tu veux voir un bout d'implémentation du schéma observateur (C++), tu peux aussi consulter ceci.

je plussoie la réponse de Geddeon, java.util.logging epicetout

Ca a l'air bien les annotations pourquoi j'utilise 1.4 au boulot

Mon souci est que le code du logger doit être super modulable : il ne restera dans le code que pendant certains tests, on doit pouvoir le modifier facilement et rapidement, ajouter des observateurs pour certaines autre variables (si on modifie le code), etc.
 
J'ai pas encore trop regardé le java.util.logging mais je pense que ça ne va pas être autant modulable que les annotations peuvent l'être, si ?

 
Si c'est pour en arriver à ce genre d’extrémité, alors pourquoi tu ne cherches directement du côté du profiling de tes applications ?
Grosso modo j'ai l'impression que c'est comme si tu cherchais un interpréteur de ton code java qui, à tout instant, peut te donner la valeur exacte de toutes les composantes de ton espace d'état .
 

 
Baah ça dépend comment tu fais le bousin aussi .

Pas tout compris  
Mais sinon, oui, il faut que j'arrive à récupérer ça (enfin, en partie parce qu'il y a un bon nombre de trucs dont je me balance   )

http://en.wikipedia.org/wiki/Profi [...] ogramming)

Exemple typique en C/C++: les incontournables "valgrind" & gdb (si code compilé en mode debug) . Ca existe aussi en java, y compris dans des outils standards Sun . Mais je te laisse googler pour ça .

Ben regarde aussi de ce côté là alors . Mais ça peut être chiant à mettre en place la première fois . C'est à toi d'évaluer tes besoins et voir si l'investissement en vaut la peine.

Après avoir regardé un peu toutes les pages indiquées + google sur ce que je connaissais pas du tout, j'en reviens un peu au problème du départ :
dans mon cas, je DOIS insérer le minimum de code dans mon algo donc c'est pour ça que passer par une annotation me parait le plus logique...
Après, c'est évident que je vais utiliser un observateur et java.util.logging (log4j fait la même chose mais on configure le truc dans un fichier de préférence ) mais ça me dérange d'avoir à insérer tant de code directement dans l'algo...
Moi ce que je vois, c'est un truc comme ça :
 

• on place une annotation prenant en argument une variable à observer
• l'annotation va créer un observateur relatif à la variable en fonction de la configuration qu'on a fait
• dès qu'il détecte une modification de la variable, l'observateur va enregistrer la nouvelle valeur dans le fichier de log

Je comprend bien que c'est lourd pour ce que c'est mais j'ai pas trop le choix, j'ai un certain cahier des charges à respecter    
Il faudrait donc que j'arrive à trouver comment faire un truc qui marche comme ça !
 
Any idea ?

 
Nan mais tu te rends compte que tu demandes ce qu'un interpréteur fait, sur du code compilé (bon ok du byte-code ) ?
 

 
Si tu trouves un jour comment faire ça, en gardant la compilation normale, dis-le moi, parce que là ça défie toutes mes notions de structure des langages .
 
Tu devrais faire ça en Python, ça serait plus simple pour tout le monde .
 

Sauf que j'arrive pas à comprendre le truc de l’interpréteur, ou en tout cas comment il marche
J'ai compris que c'était par exemple dans le JVM Tools Interface (en C++) ou dans le JMX (en Java) mais pas moyen de comprendre comment ça fonctionne  
 
Si tu as un tuto quelque part là-dessus, ça m'arrangerai  

Nan mais ma "question" n'avait aucun sens. Que quelqu'un me corrige si je me trompe mais ce que tu demandes, tel que tu le demandes, est théoriquement infaisable (théorie des langages).

Je ne sais pas t'en dire plus parce que je n'ai plus trifouillé dans ces machins-là depuis un certain temps mais un machin avec JVM dedans ne peut pas être C++ ou alors le nom est très mal choisi .
Pour le JMX, ça me parle plus c'est un peu ça que j'avais en tête, ouais. Mais ça reste assez lourd à mettre en place la première fois.

Tutos officiels Sun/Oracle . Le reste: lire les bouts intéressants de l'API, faut mettre les mains dans le cambouis dans ce genre de trucs. Ca paye rarement en première lecture, mais une fois que t'as pigé tu peux revaloriser ton expérience plus tard.

Mais honnêtement, vu les contraintes que tu mets sur tes désirs, j'ai de très gros doutes sur la faisabilité de ton projet. Mais je n'ai certainement pas la parole absolue .

edit: Pour le logging de java.util.logging, si tu t'en sors pas, je peux te donner des bouts de code. Je travaille actuellement sur un projet où j'ai intégré ce genre de trucs, en version assez large (logging HDD, console et réseau simultanés, avec des niveaux différents etc.).

ok bah je vais voir avec qui-de-droit pour discuter de comment je fais  
 
 

En regardant ça, j'ai quand même l'impression de pas faire du java : http://download.oracle.com/javase/ [...] tml#whatIs
 
 

Les tutos officiels sont peut-etre précis et tout mais ils sont souvent moins clairs que d'autres tutos  
 

le logging, ça va, c'est le truc le plus facile dans le tas    
Mais je veux bien quand même des bouts de codes histoire de comparer à ce que j'ai déjà !

Nouvelle idée qu'on a eu : utiliser AspectJ !
Apparemment ça a l'air de faire à peu près ce que je voulais... Mais faut que j'examine ça plus à fond !

Intéressant mais si tu regardes bien, c'est la mise en place simplifiée de techniques dont je te parlais précédemment . Et ça s'insère bien dans le code *avant* compilation .
 
Maintenant, que ça facilite la vie du programmeur, ça c'est autre chose .

On s'est mal compris sur le coup de "avant la compilation" parce que c'est évident que ça va pas rajouter du code après  
 
 
par contre, j'ai maintenant un souci quand j'essaie de coder un aspect pour récupérer une variable utilisée dans une méthode... genre :
 
Main.java

 
 
CompteBancaire.java
 

 
1er Aspect qui fonctionne (il écrit un truc avant et après l'exécution de la méthode CompteBancaire.retrait:

 
2e aspect qui marche (et fait presque pareil que le précédent sauf qu'en sortie on a la valeur de l'argument donné à retrait() et le nom du compte) :

 
Et maintenant celui qui ne fonctionne pas :

En fait mon problème est que j'ai du mal à identifier le type de pattern que je dois utiliser pour les différents types de pointcut... J'ai essayé de remplacer le this() par target() (ça change rien) et par args() (j'ai alors une magnifique boucle infinie   )
 
Any idea ?
 
 
nb : et pourtant, je m'aide des pages officielles   :
choix de pointcut : http://www.eclipse.org/aspectj/doc [...] tcuts.html (haut de la page)
pattern summary : la même page tout en bas

Trouvé ! Enfin j'ai trouvé un truc qui me donne ce qu'il faut ^^
 

Et il faut définir les variables solde et variable1 en public static et non private
 
Maintenant, il ne reste plus qu'à tester ça avec du log et puis sur l'algo !