Discussion :

[Alain Defrance]

Bonjour,

Je me suis posé une question à laquelle je ne suis pas arrivé à répondre malgrès de multiples recherches infructueuses.

Est-il possible, à partir d'une classe, de récupérer une interface correspondante à sa signature publique ?

Prenons l'exemple de JFrame qui possède une signature publique assez importante. Est-il possible de récupérer cette signature sous forme d'interface, dans le but plus tard d'appliquer une implémentation dynamique ?

[gifffftane]

Je ne connais pas la notion de signature pour une classe. En java cela existe pour une méthode, mais à ma connaissance pas pour une classe.

Peut être entends-tu par là l'ensemble des méthodes ou choses publiques d'une classe, et chercherais-tu à les extraire pour former une interface, interface que tu mettrais en oeuvre dynamiquement.

Je m'interroge sur la pratiquabilité d'une telle démarche, mais si tu confirmes, et si jamais elle est possible, ce serait par le biais d'outils de manipulation du bytecode, tels asm.

Une autre voie sera peut être de passer par les notions d'aspects, capables de coller un comportement nouveaux à n'importe quel entité d'une classe, et qui utilisent beaucoup les outils de manipulation du bytecode pour y parvenir.

[Alain Defrance]

La signature publique d'une classe est en effet la partie visible d'une classe de l'exterieur.

A partir d'une interface il est tout à fait possible d'implémenter dynamiquement ces méthodes sans pour autant manipuler le bytecode (merci la reflexion de Java).

Il peut être possible d'ajouter dynamiquement des responsabilitées à des classes suivant certains modèles de conceptions (Decorator), ou d'initialiser leurs état (Builder), mais je cherchais ici bel et bien, à reimplémenter une partie d'un type, et pour celà il faut récupérer sa signature sous forme d'interface, chose que je ne suis pas parvenu a faire .

Je ne cherche pas à rendre cette implémentation permanante, ni à générer du code véritablement (sinon en effet, ASM semblerait être parfait pour cela).

Merci en tous cas pour cette idée .

[gifffftane]

Je ne vois pas comment, par la reflexion, tu peux implémenter du code à partir d'une classe telle que JFrame.

Certes à partir d'une interface tu le peux avec le Proxy.

J'ai l'impression que la notion d'aspect est ce qui se rapproche le plus de ce que tu cherches à faire. Regarde Spring et ses aspects(ici et là), ou directement AspectJ, par exemple ?

[Alain Defrance]

Ce que je cherche à faire c'est récupérer une interface correspondante à une classe (par exemple JFrame), pour pouvoir l'implémenter par la suite avec le Proxy.

[benwit]

Je n'arrive pas trop à comprendre ce que tu veux faire et surtout à quel moment (en développement ou dynamiquement à l'execution) ?

A l'execution, tu peux connaître par reflexion l'ensemble des méthodes publiques.
Mais après, pour quoi faire ?

Si c'est pour modifier une implémentation existante, l'AOP est une technique.

Sinon, si tu veux créer une interface à partir des infos précédemment extraites par réflexion, que vas tu en faire ensuite ?

Si j'ai bien compris, tu ne veux pas modifier ta classe d'origine (JFrame) pour lui faire implémenter ton interface mais créer un autre objet (un proxy ?) qui implémenterai cette interface ?
Le problème dans cette démarche, c'est le client de JFrame ? Comment tu vas lui faire appeler les méthodes de ton interface ? Il ne connait que JFrame et ce n'est pas parce que tu lui passe un objet avec les mêmes méthodes que ça va lui plaire !

Si tu veux une indépendance sans bidouiller le bytecode, c'est à la conception qu'il faut le prévoir :
Créer l'interface qui sera utilisée par la classe cliente (Cette interface reprend les méthodes de ta classe (JFrame dans l'exemple) Il y a des outils de dev pour le faire si tu trouves ça long à saisir)
Créer un adapter de ta JFrame qui implémente l'interface.
Quand, tu veux une autre implémentation, tu implémentes l'interface.
Si tu veux que partiellement, une autre implémentation, tu fais un proxy qui implémente ton interface (et tu redéfinie juste où tu as besoin)

[Alain Defrance]

Si tu veux une indépendance sans bidouiller le bytecode, c'est à la conception qu'il faut le prévoir :
Créer l'interface qui sera utilisée par la classe cliente (Cette interface reprend les méthodes de ta classe (JFrame dans l'exemple) Il y a des outils de dev pour le faire si tu trouves ça long à saisir)
Créer un adapter de ta JFrame qui implémente l'interface.
Quand, tu veux une autre implémentation, tu implémentes l'interface.
Si tu veux que partiellement, une autre implémentation, tu fais un proxy qui implémente ton interface (et tu redéfinie juste où tu as besoin)

Je n'avais pas pensé à l'adaptateur, ca pourrait être une réponse à mon problème .
Je vais faire des tests en ce sens.

[djo.mos]

Salut,
Mais sinon, la manipulation de bytecode n'st pas si effrayante que ça, pas avec des libs comme cglib ou javassist. Tu es déjà au courant je coris, mais avec ce libs, tu peux hériter et redéfinir les méthodes d'une classe, et non plus seulement une interface comme de dyamic proxy du jdk.