Discussion :

[Chen norris]

Bonjour à tous,

En Java 7, je me pose la question de comment écrire une annotation custom pour exécuter du code avant et après une méthode (l'idée est de chronométrer le temps d'exécution de certaines de mes méthodes).
La méthode classique mais que je trouve redondante est de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public void maMethode() {
    long debut = new Date().getTime();
    // ici le contenu de la méthode
    System.out.println("Durée : " + new Date().getTime() - debut);
}

(l'exemple ici reste volontairement simple, l'usage de new Date(), getTime() ou même System.out.println n'est pas du tout la question)

En réalité, mon cas est un tout petit peu plus compliqué puisqu'il stocke les durées d'exécution des méthodes qui sont appelées plusieurs fois pour n'afficher que leur temps moyen d'exécution à la toute fin de mon programme.
Dans les faits, ça donne quelque chose dans ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public void maMethode() {
    startBench("un identifiant quelconque");
    // ici le contenu de la méthode
    stopBench("un identifiant quelconque");
}

Dans l'idée, je pensais créer une annotation du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Bench {
    String value();
}

et l'utiliser comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
@Bench("un identifiant quelconque")
public void maMethode() {
    // ici le contenu de la méthode
}

Mais voilà : comment faire en sorte d'exécuter startBench("un identifiant quelconque"); avant d'exécuter ma méthode et stopBench("un identifiant quelconque"); à la fin de ma méthode ?

Après moults recherches sur le net, impossible de trouver une solution pour ce problème qui me semble pourtant élémentaire...
Je précise que la solution que je recherche concerne une vraie application, pas une "application" web.
J'aimerais idéalement définir une méthode onStart et une méthode onFinish dans mon annotation mais comment faire en sorte qu'elles soient appelées automatiquement ?

Merci d'avance pour votre aide et vos pistes

[gervais.b]

Bonjour,

Je pense qu'il y à deux solutions:

La première serait d'utiliser un framework d'AOP (Aspect Oriented Programming) dans votre application. Certains fonctionnent avec des déclarations de point de coupe, d'autres avec des annotations à vous de voir ce qui vous convient le mieux.

L'autre solution est de créer un processeur d'annotations que vous renseignez à votre compilateur. Mais il faudra faire de la manipulation de code pour injecter vos appels startBench et stopBench au début et à la fin de votre méthode plus gèrer les try { .. } catch { .. } finally { .. }.


Une troisième approche, qui n'est pas vraiment une réponse à votre question, serait d'utiliser une librairie existante pour faire ce travail. C'est à mon sens (sans connaître vos besoins) la solution la plus efficace.

[Chen norris]

Bonjour

Pour éclaircir un peu le domaine auquel cela doit s'appliquer, il s'agit d'une application client lourd qui grosso modo pourrait s'apparenter à un moteur 3D basé sur OpenGL. Pour reprendre les solutions proposées :

1. Les librairies existantes sont malheureusement souvent basées sur des annotations Spring ou autre, et répondent du coup plutôt à des besoins lié au web (configuration des annotations via des beans définis dans des configurations Tomcat, par exemple). La plupart des solutions sur lesquelles je tombe sont basées là-dessus, malheureusement pour moi… J'ai donc écarté cette option pour le moment.

2. Le processeur d'annotation est une piste que j'ai commencé à explorer, mais je me suis rendu compte qu'au final, je devais explicitement lancer ce processeur d'annotations pour qu'il s'exécute. Mon application étant lancée comme un programme, lancer un processeur d'annotation en pré-requis me paraît un peu lourd et coûteux en terme de vitesse d'exécution (mes contraintes sont de garder une application qui s'ouvre rapidement et qui maintienne une vitesse d'exécution élevée pour garantir les 60 FPS).

3. En troisième solution, l'approche AOP m'intéressait beaucoup car semblant la plus adaptée à mes besoins. Mais mes connaissances sont un peu trop limitées dans ce domaine, et je n'arrive pas à savoir comment m'y prendre techniquement.
Je n'arrive pas à savoir si :

• une annotation sur une méthode permet de déclencher un traitement au moment où la méthode en question se lance,
• un listener doit être mis en place quelque part, en scannant toutes les méthodes annotées au préalable

Si c'est la première option, l'idée serait d'encapsuler l'appel à la méthode, en l'encadrant par mes startBench / stopBench.
Si par contre c'est la seconde option, pas sûr encore une fois que ça respecte mes contraintes concernant la vitesse d'exécution…

Je ne sais pas si tout cela est très clair, n'hésitez pas en cas d'interrogation ^^

[professeur shadoko]

il existe une solution particulièrement facile et crade (quick and dirty) : mettre aux points critiques un assert qui lance une méthode qui rend toujours true
après tu exécutes avec ou sans assertion activée!
assert n'est pas du tout fait pour ça mais hein c'est "facile et crade"

[Chen norris]

Effectivement, un usage détourné assez particulier, j'y aurais pas pensé...

Mais vu ce qu'il implique, au final, appeler manuellement mes méthodes startBench et stopBench respectivement en début et en fin des methodes à mesurer est à peine plus coûteux, et surtout un peu plus propre.

[professeur shadoko]

l'avantage du "assert" détourné c'est que tu peux activer tes méthodes à la demande (l'exécution n'en est pas systématique) et ça c'est important!

[thelvin]

Après moults recherches sur le net, impossible de trouver une solution pour ce problème qui me semble pourtant élémentaire...

Oui enfin, c'est quand même assez clairement une problématique de programmation orientée aspect. Si Java était orienté aspect, ça se saurait.

1. Les librairies existantes sont malheureusement souvent basées sur des annotations Spring ou autre, et répondent du coup plutôt à des besoins lié au web (configuration des annotations via des beans définis dans des configurations Tomcat, par exemple).

Absolument pas. Spring fonctionne avec tout, et si les gens s'en servent surtout pour le web, ce n'est pas son problème. Rien de Spring n'est lié à Tomcat. Il aide juste des fois que ça t'intéresserait d'utiliser Tomcat, mais si ce n'est pas le cas, ne le fais pas.

Tu peux toujours refaire la même chose : Organiser ton code en beans interconnectés les uns aux autres par annotation ou implication, avec un moteur qui se charge de les interconnecter au lieu de le faire toi-même. Pour plus de simplicité, programme-les tous par interface. Puis fais en sorte que ce moteur, quand il tombe sur une annotation @Bench sur une méthode, crée un proxy de l'interface qui mesure le temps passé à exécuter la méthode, et à l'intérieur appelle la classe concrète qui aurait normalement été liée directement.

Bien sûr c'est exactement ce que fait Spring AOP, et il y a 0% de web là-dedans, donc ça a pas l'air bien malin de le refaire. Mais c'est tout à fait possible.

[Chen norris]

Si Java était orienté aspect, ça se saurait.

Je comprends un peu mieux pourquoi je n'arrive pas à trouver de solution facilement, ça me rassure

Pour plus de simplicité, programme-les tous par interface. Puis fais en sorte que ce moteur, quand il tombe sur une annotation @Bench sur une méthode, crée un proxy de l'interface

Je pense que c'est effectivement ce qui se rapproche le plus de ce que je cherche à faire. Si je comprends bien, ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ClasseA {
    public void methodeA1() {
        ...
    }
    public void methodeA2() {
        ...
    }
}
 
public class ClasseB {
    public void methodeB1() {
        ...
    }
    public void methodeB2() {
        ...
    }
}

qui sont lancées via un moteur global dans lequel mes classes sont injectées en tant que beans comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class Engine {
    @Bean
    ClasseA classeA;
 
    @Bean
    ClasseB classeB;
 
    ...
}

Et au moment de lancer les méthodes de mes beans, je vérifie si elles sont annotées @Bench ou pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
if (classeA.traitementA.hasAnnotation(Bench.class))
    classeA.startBench("classeA.traitementA");
classeA.traitementA();
if (classeA.traitementA.hasAnnotation(Bench.class))
    classeA.stopBench("classeA.traitementA");

J'ai bon ?

Et question corollaire : la vérification de la présence d'annotation sur une méthode nécessite systématiquement de la réflexivité ?

[thelvin]

C'est une manière de faire moins générale, donc plus dirigée vers ton besoin, oui.

Et question corollaire : la vérification de la présence d'annotation sur une méthode nécessite systématiquement de la réflexivité ?

Ouaip.

[Chen norris]

OK, c'est un peu ce que je craignais. La réflexion n'étant pas synonyme de performance, je pense que je vais m'arrêter là dans mes recherches et m'en tenir à mes appels explicites startBench / stopBench.
Je note le sujet comme résolu, merci pour toutes vos pistes

[thelvin]

Euh oui non mais, il y a moyen de chercher au démarrage du programme où sont les annotations, et de faire en sorte que tous les passages par là soient mesurés, sans avoir à refaire de la réflectivité.

[gervais.b]

thelvin à raison. C'est une étape à faire une fois au lancement du programme. Ensuite vous pouvez travailler avec les Proxy ou le faire à la main avec de la composition.

https://docs.oracle.com/javase/8/doc...ect/Proxy.html

[Chen norris]

Le vocabulaire officiel et moi faisant parfois un peu deux, je suis allé cherché un tuto sur la mise en place de proxy… et je me rends compte que c'est quelque chose que j'ai en réalité déjà mis en place pour gérer mes associations touches du clavier / actions. Grosso modo, j'ai un fichier de properties qui est parsé au lancement de mon appli pour générer une Map<Touche de clavier, Méthode à lancer> et il se trouve que les valeurs de cette map, ce sont justement des objets qui invoquent des méthodes. Pour mon bench, il suffit que je fasse la même chose au démarrage de mon appli. La seule différence, c'est qu'au lieu de parcourir un fichier de properties, je dois juste détecter les méthodes annotées avec un intercepteur (c'est sans doute sur cette dernière partie que je manque de connaissance).
Au final, j'avais écarté cette hypothèse car je pensais que c'était coûteux à chaque itération mais si je comprends bien, c'est plutôt l'initialisation qui est coûteuse, pas l'exécution