Avoir les noms des parametres d'une methode par reflection, c'est possible ?
13 réponses
Vincent Cantin
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee.
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les
noms des arguments. Est-ce que cette information est stockee dans le fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une
option speciale ? et comment y acceder ?
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Amha, et je ne suis pas spécialiste, le langage se fout des noms des arguments, donc, il ne va pas les conserver (souci d'optimisation) a part pour les différencier, mais là, à mon avis, ils les renomment de facon incompréhensible à nos yeux...
Merci, Vincent
De rien, vraiment de rien
Isammoc
Je suis en train d'ecrire un outil qui utilise la reflection pour
presenter a l'utilisateur le profil des methodes et champs d'une
classe specifiee. Dans la classe java.lang.reflect.Method il y a bien
moyen d'obtenir la liste des type des arguments d'une methode, mais je
ne vois rien pour avoir les noms des arguments. Est-ce que cette
information est stockee dans le fichier .class apres compilation ? Si
non, y-at'il moyen de l'y inclure par une option speciale ? et comment
y acceder ?
Amha, et je ne suis pas spécialiste,
le langage se fout des noms des arguments, donc, il ne va pas les conserver
(souci d'optimisation) a part pour les différencier, mais là, à mon avis,
ils les renomment de facon incompréhensible à nos yeux...
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Amha, et je ne suis pas spécialiste, le langage se fout des noms des arguments, donc, il ne va pas les conserver (souci d'optimisation) a part pour les différencier, mais là, à mon avis, ils les renomment de facon incompréhensible à nos yeux...
Merci, Vincent
De rien, vraiment de rien
Isammoc
JScoobyCed
Isammoc wrote:
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Amha, et je ne suis pas spécialiste, le langage se fout des noms des arguments, donc, il ne va pas les conserver (souci d'optimisation) a part pour les différencier, mais là, à mon avis, ils les renomment de facon incompréhensible à nos yeux...
Je dirais que quelquepart les noms des champs sont conserves, selon le mode de compilation. Par defaut d'ailleurs, cela doit etre le cas. En effet, si je prend un simple decompiler (sur sourceforge, il y en a quelques-uns) il me decompile mes classes et donne les bons noms pour les parametres. Par contre, je ne suis pas sur que par Reflection ca se fasse. Les decompilers (decompilateur, en FR, qui decompilatent :)) lisent le bytecode pour re-generer les sources, et rarement la reflection. Maintenant, je ne sais pas exactement comment c'est fait, mais il y a des sites qui doivent expliquer comment interpreter (traduire) le bytecode en code source. J'ai cru comprendre qu'un set de valeurs hexadecimales dans le bytecode a une signification unique (selon comment c'est lu) et donc par mapping on peut traduire.
-- JScoobyCed What about a JScooby snack Shaggy ? ... Shaggy ?!
Isammoc wrote:
Dans la classe java.lang.reflect.Method il y a bien
moyen d'obtenir la liste des type des arguments d'une methode, mais je
ne vois rien pour avoir les noms des arguments. Est-ce que cette
information est stockee dans le fichier .class apres compilation ? Si
non, y-at'il moyen de l'y inclure par une option speciale ? et comment
y acceder ?
Amha, et je ne suis pas spécialiste,
le langage se fout des noms des arguments, donc, il ne va pas les conserver
(souci d'optimisation) a part pour les différencier, mais là, à mon avis,
ils les renomment de facon incompréhensible à nos yeux...
Je dirais que quelquepart les noms des champs sont conserves, selon le
mode de compilation. Par defaut d'ailleurs, cela doit etre le cas. En
effet, si je prend un simple decompiler (sur sourceforge, il y en a
quelques-uns) il me decompile mes classes et donne les bons noms pour
les parametres. Par contre, je ne suis pas sur que par Reflection ca se
fasse. Les decompilers (decompilateur, en FR, qui decompilatent :))
lisent le bytecode pour re-generer les sources, et rarement la reflection.
Maintenant, je ne sais pas exactement comment c'est fait, mais il y a
des sites qui doivent expliquer comment interpreter (traduire) le
bytecode en code source. J'ai cru comprendre qu'un set de valeurs
hexadecimales dans le bytecode a une signification unique (selon comment
c'est lu) et donc par mapping on peut traduire.
--
JScoobyCed
What about a JScooby snack Shaggy ? ... Shaggy ?!
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Amha, et je ne suis pas spécialiste, le langage se fout des noms des arguments, donc, il ne va pas les conserver (souci d'optimisation) a part pour les différencier, mais là, à mon avis, ils les renomment de facon incompréhensible à nos yeux...
Je dirais que quelquepart les noms des champs sont conserves, selon le mode de compilation. Par defaut d'ailleurs, cela doit etre le cas. En effet, si je prend un simple decompiler (sur sourceforge, il y en a quelques-uns) il me decompile mes classes et donne les bons noms pour les parametres. Par contre, je ne suis pas sur que par Reflection ca se fasse. Les decompilers (decompilateur, en FR, qui decompilatent :)) lisent le bytecode pour re-generer les sources, et rarement la reflection. Maintenant, je ne sais pas exactement comment c'est fait, mais il y a des sites qui doivent expliquer comment interpreter (traduire) le bytecode en code source. J'ai cru comprendre qu'un set de valeurs hexadecimales dans le bytecode a une signification unique (selon comment c'est lu) et donc par mapping on peut traduire.
-- JScoobyCed What about a JScooby snack Shaggy ? ... Shaggy ?!
Isammoc
Amha, et je ne suis pas spécialiste, le langage se fout des noms des arguments, donc, il ne va pas les conserver (souci d'optimisation) a part pour les différencier, mais là, à mon avis, ils les renomment de facon incompréhensible à nos yeux...
Je dirais que quelquepart les noms des champs sont conserves, selon le mode de compilation. Par defaut d'ailleurs, cela doit etre le cas. En effet, si je prend un simple decompiler (sur sourceforge, il y en a quelques-uns) il me decompile mes classes et donne les bons noms pour les parametres. Par contre, je ne suis pas sur que par Reflection ca se fasse. Les decompilers (decompilateur, en FR, qui decompilatent :)) lisent le bytecode pour re-generer les sources, et rarement la reflection. Maintenant, je ne sais pas exactement comment c'est fait, mais il y a des sites qui doivent expliquer comment interpreter (traduire) le bytecode en code source. J'ai cru comprendre qu'un set de valeurs hexadecimales dans le bytecode a une signification unique (selon comment c'est lu) et donc par mapping on peut traduire.
Je m'incline!
-- Isammoc
Amha, et je ne suis pas spécialiste,
le langage se fout des noms des arguments, donc, il ne va pas les
conserver (souci d'optimisation) a part pour les différencier, mais
là, à mon avis, ils les renomment de facon incompréhensible à nos
yeux...
Je dirais que quelquepart les noms des champs sont conserves, selon le
mode de compilation. Par defaut d'ailleurs, cela doit etre le cas. En
effet, si je prend un simple decompiler (sur sourceforge, il y en a
quelques-uns) il me decompile mes classes et donne les bons noms pour
les parametres. Par contre, je ne suis pas sur que par Reflection ca
se fasse. Les decompilers (decompilateur, en FR, qui decompilatent :))
lisent le bytecode pour re-generer les sources, et rarement la
reflection. Maintenant, je ne sais pas exactement comment c'est fait,
mais il y a des sites qui doivent expliquer comment interpreter
(traduire) le bytecode en code source. J'ai cru comprendre qu'un set
de valeurs hexadecimales dans le bytecode a une signification unique
(selon comment c'est lu) et donc par mapping on peut traduire.
Amha, et je ne suis pas spécialiste, le langage se fout des noms des arguments, donc, il ne va pas les conserver (souci d'optimisation) a part pour les différencier, mais là, à mon avis, ils les renomment de facon incompréhensible à nos yeux...
Je dirais que quelquepart les noms des champs sont conserves, selon le mode de compilation. Par defaut d'ailleurs, cela doit etre le cas. En effet, si je prend un simple decompiler (sur sourceforge, il y en a quelques-uns) il me decompile mes classes et donne les bons noms pour les parametres. Par contre, je ne suis pas sur que par Reflection ca se fasse. Les decompilers (decompilateur, en FR, qui decompilatent :)) lisent le bytecode pour re-generer les sources, et rarement la reflection. Maintenant, je ne sais pas exactement comment c'est fait, mais il y a des sites qui doivent expliquer comment interpreter (traduire) le bytecode en code source. J'ai cru comprendre qu'un set de valeurs hexadecimales dans le bytecode a une signification unique (selon comment c'est lu) et donc par mapping on peut traduire.
Je m'incline!
-- Isammoc
Black Myst
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? Dans le .class, non
L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le format des fichiers class pour savoir si l'information ajoutable.
et comment y acceder ?
Demande le source
Merci, Vincent
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee.
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les
noms des arguments. Est-ce que cette information est stockee dans le fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une
option speciale ?
Dans le .class, non
L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le
format des fichiers class pour savoir si l'information ajoutable.
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? Dans le .class, non
L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le format des fichiers class pour savoir si l'information ajoutable.
et comment y acceder ?
Demande le source
Merci, Vincent
Cédric Chabanois
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir http://cvs.apache.org/viewcvs.cgi/ws-axis/java/src/org/apache/axis/utils/bytecode/
Cédric
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ?
Dans le .class, non L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le format des fichiers class pour savoir si l'information ajoutable.
et comment y acceder ?
Demande le source
Merci, Vincent
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g).
Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou
DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour
récupérer les noms des paramètres (à condition de compiler la classe en
mode debug)
Voir
http://cvs.apache.org/viewcvs.cgi/ws-axis/java/src/org/apache/axis/utils/bytecode/
Cédric
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour
presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee.
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la
liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les
noms des arguments. Est-ce que cette information est stockee dans le
fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une
option speciale ?
Dans le .class, non
L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le
format des fichiers class pour savoir si l'information ajoutable.
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir http://cvs.apache.org/viewcvs.cgi/ws-axis/java/src/org/apache/axis/utils/bytecode/
Cédric
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ?
Dans le .class, non L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le format des fichiers class pour savoir si l'information ajoutable.
et comment y acceder ?
Demande le source
Merci, Vincent
Black Myst
Cédric Chabanois wrote:
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir http://cvs.apache.org/viewcvs.cgi/ws-axis/java/src/org/apache/axis/utils/bytecode/
J'avais testé de tel outils, mais probablement en ayant compilé sans l'option debug, donc jugé à tord de l'impossibilité de retrouvé les noms des parametres.
Merci pour ce lien, j'ai regardé le source, c'est quand même relativment imbuvable :-)
Cédric
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ?
Dans le .class, non L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le format des fichiers class pour savoir si l'information ajoutable.
et comment y acceder ?
Demande le source
Merci, Vincent
Cédric Chabanois wrote:
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g).
Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou
DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour
récupérer les noms des paramètres (à condition de compiler la classe en
mode debug)
Voir
http://cvs.apache.org/viewcvs.cgi/ws-axis/java/src/org/apache/axis/utils/bytecode/
J'avais testé de tel outils, mais probablement en ayant compilé sans
l'option debug, donc jugé à tord de l'impossibilité de retrouvé les noms
des parametres.
Merci pour ce lien, j'ai regardé le source, c'est quand même relativment
imbuvable :-)
Cédric
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour
presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee.
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir
la liste
des type des arguments d'une methode, mais je ne vois rien pour avoir
les
noms des arguments. Est-ce que cette information est stockee dans le
fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une
option speciale ?
Dans le .class, non
L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le
format des fichiers class pour savoir si l'information ajoutable.
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir http://cvs.apache.org/viewcvs.cgi/ws-axis/java/src/org/apache/axis/utils/bytecode/
J'avais testé de tel outils, mais probablement en ayant compilé sans l'option debug, donc jugé à tord de l'impossibilité de retrouvé les noms des parametres.
Merci pour ce lien, j'ai regardé le source, c'est quand même relativment imbuvable :-)
Cédric
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ?
Dans le .class, non L'inclure avec une option de javac, non
Peu etre en ecrivant ton propre compiler, mais je connais assez le format des fichiers class pour savoir si l'information ajoutable.
et comment y acceder ?
Demande le source
Merci, Vincent
Vincent Cantin
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir
Merci beaucoup pour l'info, apparemment la classe qui m'interesse serait "ParamNameExtractor". Je vais y jeter un coup d'oeil plus approfondi plus tard, quand recuperer le nom des parametres sera en haut de ma liste de priorite (peut-etre dans un mois le temps de finir le reste >_<).
C'est quand meme dommage que la Java Team n'ait rien prevu pour ca dans leur API : il permettent de laisser cette info dans les .class mais on ne peut pas y acceder :-(
Vincent
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g).
Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou
DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour
récupérer les noms des paramètres (à condition de compiler la classe en
mode debug)
Voir
Merci beaucoup pour l'info, apparemment la classe qui m'interesse serait
"ParamNameExtractor". Je vais y jeter un coup d'oeil plus approfondi plus
tard, quand recuperer le nom des parametres sera en haut de ma liste de
priorite (peut-etre dans un mois le temps de finir le reste >_<).
C'est quand meme dommage que la Java Team n'ait rien prevu pour ca dans leur
API : il permettent de laisser cette info dans les .class mais on ne peut
pas y acceder :-(
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir
Merci beaucoup pour l'info, apparemment la classe qui m'interesse serait "ParamNameExtractor". Je vais y jeter un coup d'oeil plus approfondi plus tard, quand recuperer le nom des parametres sera en haut de ma liste de priorite (peut-etre dans un mois le temps de finir le reste >_<).
C'est quand meme dommage que la Java Team n'ait rien prevu pour ca dans leur API : il permettent de laisser cette info dans les .class mais on ne peut pas y acceder :-(
Vincent
JScoobyCed
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Merci, Vincent
En suivant ce fil, j'ai donc regarde sur AXIS. C'est assez bien fait, et effectivement c'est de la lecture de bytecode. Leur classe ParamNameExtractor passe le contenu du fichier.class a la classe ParamReader (qui extends leur ClassReader). Ensuite ca fait une serie de lecture d'index et de code hexa qui transforme par UTF8 vers ASCII retrouve le nom du parametre. (Ok, c'est tres bref, mais c'est juste pour donner une idee, par un cours de lecture de bytecode :) ) Si tu es interesse par leur travail tu seras comble.
-- JScoobyCed What about a JScooby snack Shaggy ? ... Shaggy ?!
Vincent Cantin wrote:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee.
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les
noms des arguments. Est-ce que cette information est stockee dans le fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une
option speciale ? et comment y acceder ?
Merci,
Vincent
En suivant ce fil, j'ai donc regarde sur AXIS.
C'est assez bien fait, et effectivement c'est de la lecture de bytecode.
Leur classe ParamNameExtractor passe le contenu du fichier.class a la
classe ParamReader (qui extends leur ClassReader). Ensuite ca fait une
serie de lecture d'index et de code hexa qui transforme par UTF8 vers
ASCII retrouve le nom du parametre.
(Ok, c'est tres bref, mais c'est juste pour donner une idee, par un
cours de lecture de bytecode :) )
Si tu es interesse par leur travail tu seras comble.
--
JScoobyCed
What about a JScooby snack Shaggy ? ... Shaggy ?!
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier .class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Merci, Vincent
En suivant ce fil, j'ai donc regarde sur AXIS. C'est assez bien fait, et effectivement c'est de la lecture de bytecode. Leur classe ParamNameExtractor passe le contenu du fichier.class a la classe ParamReader (qui extends leur ClassReader). Ensuite ca fait une serie de lecture d'index et de code hexa qui transforme par UTF8 vers ASCII retrouve le nom du parametre. (Ok, c'est tres bref, mais c'est juste pour donner une idee, par un cours de lecture de bytecode :) ) Si tu es interesse par leur travail tu seras comble.
-- JScoobyCed What about a JScooby snack Shaggy ? ... Shaggy ?!
Jérôme Serré
Et dans la classe Class ?
Signature ------------------------------------------------------------------ -------------- Jérôme Serré http://m.heid.free.fr/expander "Vincent Cantin" a écrit dans le message de news:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Merci, Vincent
Et dans la classe Class ?
Signature ------------------------------------------------------------------
-------------- Jérôme Serré http://m.heid.free.fr/expander
"Vincent Cantin" <MY_EMAIL_IS_karma@astrocorp.com.tw> a écrit dans le
message de news:2mrapdFq9omuU1@uni-berlin.de...
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour
presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee.
Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la
liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les
noms des arguments. Est-ce que cette information est stockee dans le
fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une
option speciale ? et comment y acceder ?
Signature ------------------------------------------------------------------ -------------- Jérôme Serré http://m.heid.free.fr/expander "Vincent Cantin" a écrit dans le message de news:
Bonjour,
Je suis en train d'ecrire un outil qui utilise la reflection pour presenter
a l'utilisateur le profil des methodes et champs d'une classe specifiee. Dans la classe java.lang.reflect.Method il y a bien moyen d'obtenir la liste
des type des arguments d'une methode, mais je ne vois rien pour avoir les noms des arguments. Est-ce que cette information est stockee dans le fichier
.class apres compilation ? Si non, y-at'il moyen de l'y inclure par une option speciale ? et comment y acceder ?
Merci, Vincent
Cédric Chabanois
Oui mais çà se comprend car l'information n'est présente qu'en mode debug.
En fait je te conseille de laisser la possibilité à l'utilisateur de spécifier autrement le nom des paramètres (via un fichier de config par exemple)
Cédric
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir
Merci beaucoup pour l'info, apparemment la classe qui m'interesse serait "ParamNameExtractor". Je vais y jeter un coup d'oeil plus approfondi plus tard, quand recuperer le nom des parametres sera en haut de ma liste de priorite (peut-etre dans un mois le temps de finir le reste >_<).
C'est quand meme dommage que la Java Team n'ait rien prevu pour ca dans leur API : il permettent de laisser cette info dans les .class mais on ne peut pas y acceder :-(
Vincent
Oui mais çà se comprend car l'information n'est présente qu'en mode debug.
En fait je te conseille de laisser la possibilité à l'utilisateur de
spécifier autrement le nom des paramètres (via un fichier de config par
exemple)
Cédric
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g).
Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou
DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour
récupérer les noms des paramètres (à condition de compiler la classe en
mode debug)
Voir
Merci beaucoup pour l'info, apparemment la classe qui m'interesse serait
"ParamNameExtractor". Je vais y jeter un coup d'oeil plus approfondi plus
tard, quand recuperer le nom des parametres sera en haut de ma liste de
priorite (peut-etre dans un mois le temps de finir le reste >_<).
C'est quand meme dommage que la Java Team n'ait rien prevu pour ca dans leur
API : il permettent de laisser cette info dans les .class mais on ne peut
pas y acceder :-(
Oui mais çà se comprend car l'information n'est présente qu'en mode debug.
En fait je te conseille de laisser la possibilité à l'utilisateur de spécifier autrement le nom des paramètres (via un fichier de config par exemple)
Cédric
Le nom des paramètres est conservé lorsqu'on compile en mode debug (-g). Par contre ce n'est pas accessible par réflexion "simple".
Pour s'en persuader il suffit d'essayer un décompilateur tel que Jad ou DJ Java Decompiler, on a bien les méthodes avec le nom des arguments.
Axis (client et serveur SOAP) se sert de cette possibilité pour récupérer les noms des paramètres (à condition de compiler la classe en mode debug) Voir
Merci beaucoup pour l'info, apparemment la classe qui m'interesse serait "ParamNameExtractor". Je vais y jeter un coup d'oeil plus approfondi plus tard, quand recuperer le nom des parametres sera en haut de ma liste de priorite (peut-etre dans un mois le temps de finir le reste >_<).
C'est quand meme dommage que la Java Team n'ait rien prevu pour ca dans leur API : il permettent de laisser cette info dans les .class mais on ne peut pas y acceder :-(
