Abfrage des Namens der aktuell ausgeführten Methode

Question

Gibt es eine Möglichkeit, den Namen der gerade ausgeführten Methode in Java zu erfahren?

Answer 1

Dies ist eine Erweiterung von virgo47's Antwort (oben).

Es bietet einige statische Methoden, um die aktuellen und aufrufenden Klassen-/Methodennamen zu erhalten.

/* Utility class: Getting the name of the current executing method 
 * https://stackoverflow.com/questions/442747/getting-the-name-of-the-current-executing-method
 * 
 * Provides: 
 * 
 *      getCurrentClassName()
 *      getCurrentMethodName()
 *      getCurrentFileName()
 * 
 *      getInvokingClassName()
 *      getInvokingMethodName()
 *      getInvokingFileName()
 *
 * Nb. Using StackTrace's to get this info is expensive. There are more optimised ways to obtain
 * method names. See other stackoverflow posts eg. https://stackoverflow.com/questions/421280/in-java-how-do-i-find-the-caller-of-a-method-using-stacktrace-or-reflection/2924426#2924426
 *
 * 29/09/2012 (lem) - added methods to return (1) fully qualified names and (2) invoking class/method names
 */
package com.stackoverflow.util;

public class StackTraceInfo
{
    /* (Lifted from virgo47's stackoverflow answer) */
    private static final int CLIENT_CODE_STACK_INDEX;

    static {
        // Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
        int i = 0;
        for (StackTraceElement ste: Thread.currentThread().getStackTrace())
        {
            i++;
            if (ste.getClassName().equals(StackTraceInfo.class.getName()))
            {
                break;
            }
        }
        CLIENT_CODE_STACK_INDEX = i;
    }

    public static String getCurrentMethodName()
    {
        return getCurrentMethodName(1);     // making additional overloaded method call requires +1 offset
    }

    private static String getCurrentMethodName(int offset)
    {
        return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getMethodName();
    }

    public static String getCurrentClassName()
    {
        return getCurrentClassName(1);      // making additional overloaded method call requires +1 offset
    }

    private static String getCurrentClassName(int offset)
    {
    return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getClassName();
    }

    public static String getCurrentFileName()
    {
        return getCurrentFileName(1);     // making additional overloaded method call requires +1 offset
    }

    private static String getCurrentFileName(int offset)
    {
        String filename = Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getFileName();
        int lineNumber = Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getLineNumber();

        return filename + ":" + lineNumber;
    }

    public static String getInvokingMethodName()
    {
        return getInvokingMethodName(2); 
    }

    private static String getInvokingMethodName(int offset)
    {
        return getCurrentMethodName(offset + 1);    // re-uses getCurrentMethodName() with desired index
    }

    public static String getInvokingClassName()
    {
        return getInvokingClassName(2); 
    }

    private static String getInvokingClassName(int offset)
    {
        return getCurrentClassName(offset + 1);     // re-uses getCurrentClassName() with desired index
    }

    public static String getInvokingFileName()
    {
        return getInvokingFileName(2); 
    }

    private static String getInvokingFileName(int offset)
    {
        return getCurrentFileName(offset + 1);     // re-uses getCurrentFileName() with desired index
    }

    public static String getCurrentMethodNameFqn()
    {
        return getCurrentMethodNameFqn(1);
    }

    private static String getCurrentMethodNameFqn(int offset)
    {
        String currentClassName = getCurrentClassName(offset + 1);
        String currentMethodName = getCurrentMethodName(offset + 1);

        return currentClassName + "." + currentMethodName ;
    }

    public static String getCurrentFileNameFqn()
    {
        String CurrentMethodNameFqn = getCurrentMethodNameFqn(1);
        String currentFileName = getCurrentFileName(1);

        return CurrentMethodNameFqn + "(" + currentFileName + ")";
    }

    public static String getInvokingMethodNameFqn()
    {
        return getInvokingMethodNameFqn(2);
    }

    private static String getInvokingMethodNameFqn(int offset)
    {
        String invokingClassName = getInvokingClassName(offset + 1);
        String invokingMethodName = getInvokingMethodName(offset + 1);

        return invokingClassName + "." + invokingMethodName;
    }

    public static String getInvokingFileNameFqn()
    {
        String invokingMethodNameFqn = getInvokingMethodNameFqn(2);
        String invokingFileName = getInvokingFileName(2);

        return invokingMethodNameFqn + "(" + invokingFileName + ")";
    }
}

Answer 2

Um den Namen der Methode zu erhalten, die die aktuelle Methode aufgerufen hat, können Sie verwenden:

new Exception("is not thrown").getStackTrace()[1].getMethodName()

Dies funktioniert sowohl auf meinem MacBook als auch auf meinem Android-Handy

Ich habe es auch versucht:

Thread.currentThread().getStackTrace()[1]

aber Android wird "getStackTrace" zurückgeben Ich konnte dies für Android mit

Thread.currentThread().getStackTrace()[2]

aber dann bekomme ich die falsche Antwort auf meinem MacBook

Answer 3

Util.java:

public static String getCurrentClassAndMethodNames() {
    final StackTraceElement e = Thread.currentThread().getStackTrace()[2];
    final String s = e.getClassName();
    return s.substring(s.lastIndexOf('.') + 1, s.length()) + "." + e.getMethodName();
}

SomeClass.java:

public class SomeClass {
    public static void main(String[] args) {
        System.out.println(Util.getCurrentClassAndMethodNames()); // output: SomeClass.main
    }
}

Answer 4

Eine alternative Methode besteht darin, eine Exception zu erzeugen, aber nicht auszulösen, und dieses Objekt zu verwenden, um die Stack-Trace-Daten zu erhalten, da die umschließende Methode typischerweise bei Index 0 sein - solange die JVM diese Information speichert, wie andere oben erwähnt haben. Dies ist jedoch nicht die billigste Methode.

Desde Throwable.getStackTrace() (dies ist mindestens seit Java 5 so):

Das nullte Element des Arrays (unter der Annahme, dass die Länge des Arrays ungleich Null ist) stellt das oberste Element des Stacks dar, das den letzten Methodenaufruf in der Sequenz darstellt. Typischerweise ist dies der Punkt, an dem dieses Throwable erstellt und ausgelöst wurde.

Der folgende Ausschnitt geht davon aus, dass die Klasse nicht statisch ist (aufgrund von getClass()), aber das nur am Rande.

System.out.printf("Class %s.%s\n", getClass().getName(), new Exception("is not thrown").getStackTrace()[0].getMethodName());

Answer 5

Ich weiß nicht, welche Absicht dahinter steckt, den Namen der aktuell ausgeführten Methode zu erhalten, aber wenn das nur zu Debugging-Zwecken ist, dann können Logging-Frameworks wie "logback" hier helfen. In logback müssen Sie zum Beispiel nur Folgendes tun verwenden Sie das Muster "%M" in Ihrer Protokollierungskonfiguration . Dies sollte jedoch mit Vorsicht verwendet werden, da dies die Leistung beeinträchtigen kann.