Bonjour à tous,

je bloque sur un problème qui pourtant me parait simple : dans un bout de code je cherche à avoir la méthode qui a appelé ce bout de code.

Pour ce faire on peut utiliser un code du style
Throwable t = new Throwable();
StackTraceElement[] elems = t.getStackTrace();

Problème : sur un StackTraceElement, je peux avoir le nom de la méthode, sa ligne et d'autres trucs. Mais pas la signature de la méthode.

Question :  comment on fait pour retrouver la signature ?

Pour info je ne veux pas introspecter, ce serait trop lourd et vu que j'ai plusieurs méthodes qui portent le même nom, le getMethodName() ne rend pas un "identifiant" unique et vu aussi que le code à vocation à bouger le getLineNumber() ne me servira pas à grand chose

Merci à tous.

++ Toinou

Salut,

voici une solution mais avec l'introspection


import java.lang.reflect.*;

public class Test {

    public String getMethodSignature(Method method) {       
        StringBuilder str = new StringBuilder ();
        str.append(Modifier.toString(method.getModifiers()) + " " + method.getReturnType().getCanonicalName() +  " " + method.getName());
        // Les paramètres
        str.append(" (");
        for (Class parameter : method.getParameterTypes()) {
            str.append(parameter.getCanonicalName() + ", ");
        }
        str.deleteCharAt(str.length() - 2);
        str.append(") ");
        // Les exception levées
        if (method.getExceptionTypes().length != 0) {
            str.append(" throws ");
            for (Class exception : method.getExceptionTypes()) {
                str.append(exception.getName() + ", ");
            }
            str.deleteCharAt(str.length() - 2);
        }
       
        return str.toString();
    }
   
    public static void main( String [] args) throws Exception {
        Class c = Class .forName("java.io.FileReader");
        Method method = c.getMethod("close");
       
        String signature = new Test().getMethodSignature(method);
        System.out.println(signature);
    }
}


Cordialement..

_____________________
Vos avis et critiques sur le livre "Objets réactifs en java" de Frédéric Boussinot : contactez moi par MP..

Salut,

pour la signature, tu parles de la signature équivalente à JNI ? si oui tu peux t'inspirer du code ci-dessous :


   /**
     * Récupération de la signature JNI de la méthode
     * @param m Méthode à tester
     * @return récupération de la signature.
     */
    public static String getJNISignature(Method m) {
        String retType = m.getReturnType().getName();
        StringBuilder params = new StringBuilder();
        for(Class<?> param :  m.getParameterTypes())
            params.append(getJNIType(param.getName()));
        return "(" + params.toString() + ")" + getJNIType(retType);
    }
   
    /**
     * Ajustement du type conformément à JNI
     * @param in Type d'entrée
     * @return type ajusté
     */
    public static String getJNIType(String in) {
        String ret = in;
        if(in.equals("void")) ret = "V";
        else if(in.equals("int")) ret = "I";
        else if(in.equals("long")) ret = "J";
        else if(in.equals("double")) ret = "D";
        else if(in.equals("float")) ret = "F";
        else if(in.equals("short")) ret = "S";
        else if(in.equals("byte")) ret = "B";
        else if(in.equals("boolean")) ret = "Z";
        else if(in.equals("char")) ret = "C";
        else if(in.indexOf(".") != -1) { // cas des objets
            ret = ret.replaceAll("\\.", "/"); // conforme JNI
            //idem si l'objet ne se termine pas par ';'
            if(!ret.endsWith(";")) ret += ";";
            if(ret.startsWith("[") && ret.charAt(1) != 'L') {
                ret = "[L" + ret.substring(1, ret.length());
            } else if(!ret.startsWith("[") && ret.charAt(0) != 'L') {
                ret = "L" + ret;
            }
        }
        return ret;
    }

utilisation :

public class Test {

    public static void main(String[] args) throws Throwable {
        Method main = Test.class.getMethod("main", String[].class);
        System.out.println(getJNISignature(main)); // retourne '([Ljava/lang/String;)V'

        // ou simplement
        System.out.println(getJNIType(int.class.getName())); // retourne 'I'
        System.out.println(getJNIType(int[].class.getName())); // retourne '[I'
        System.out.println(getJNIType(String.class.getName()));// retourne 'Ljava/lang/String;'
        System.out.println(getJNIType(String[].class.getName()));// retourne '[Ljava/lang/String;'
    }
}


------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

OoWORAoO

Merci à tous les deux pour vos réponses.

Le truc c'est que dès que j'ai une object Method c'est que j'ai fait de l'introspection.
Or je cherche absolument à éviter ça, c'est beaucoup trop couteux car j suis dans un serveur J2EE qui a pas loin d'1 million d'appel ejb en 1 jour ouvré.
Vu que je veux récup la méthode pour chaque appel ejb, si j'introspecte ca va me flinguer la machine (enfin je pense).

 C'est juste que je pige pas pourquoi java ne peut pas me sortir la signature d'une méthode via la stacktrace alors qu'il peut me dire son nom, sa ligne etc...

J pense qu'une autre voie doit être de faire de la programmation par aspect mais j'préfèrerai aussi éviter

Merci en tt cas, j suis preneur pour toute suggestion !!