有没有办法在 Java 中获取当前正在执行的方法的名称？
Omar Kooheji
问问题
428229 次
23 回答
343
从技术上讲，这将起作用...
String name = new Object(){}.getClass().getEnclosingMethod().getName();
但是，在编译期间将创建一个新的匿名内部类（例如YourClass$1.class）。因此，这将为.class部署此技巧的每个方法创建一个文件。此外，在运行时每次调用时都会创建一个未使用的对象实例。所以这可能是一个可以接受的调试技巧，但它确实带来了巨大的开销。
此技巧的一个优点是getEnclosingMethod()返回java.lang.reflect.Method可用于检索方法的所有其他信息，包括注释和参数名称。这使得区分具有相同名称的特定方法成为可能（方法重载）。
请注意，根据getEnclosingMethod()此技巧的 JavaDoc 不应抛出 a SecurityException，因为应使用相同的类加载器加载内部类。因此，即使有安全管理员，也无需检查访问条件。
请注意：它需要getEnclosingConstructor()用于构造函数。在（命名的）方法之外的块期间，getEnclosingMethod()返回null.
于 2011-05-05T00:20:50.927 回答
191
Thread.currentThread().getStackTrace()通常将包含您从中调用它的方法，但存在缺陷（请参阅Javadoc）：
在某些情况下，某些虚拟机可能会从堆栈跟踪中省略一个或多个堆栈帧。在极端情况下，允许没有关于该线程的堆栈跟踪信息的虚拟机从该方法返回一个长度为零的数组。
于 2009-01-14T12:29:03.863 回答
139
2009 年 1 月：
完整的代码将是（使用@Bombe 的警告）：
/**
* Get the method name for a depth in call stack. <br />
* Utility function
* @param depth depth in the call stack (0 means current method, 1 means call method, ...)
* @return method name
*/
public static String getMethodName(final int depth)
{
final StackTraceElement[] ste = Thread.currentThread().getStackTrace();
//System. out.println(ste[ste.length-depth].getClassName()+"#"+ste[ste.length-depth].getMethodName());
// return ste[ste.length - depth].getMethodName(); //Wrong, fails for depth = 0
return ste[ste.length - 1 - depth].getMethodName(); //Thank you Tom Tresansky
}
更多在这个问题。
2011 年 12 月更新：
蓝色评论：
我使用 JRE 6 并给了我不正确的方法名称。
如果我写它会起作用ste[2 + depth].getMethodName().
0是getStackTrace()，1是getMethodName(int depth)和2正在调用方法。
于 2009-01-14T12:33:28.550 回答
90
我们使用此代码来减轻堆栈跟踪索引的潜在可变性 - 现在只需调用 methodName util：
public class MethodNameTest {
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(MethodNameTest.class.getName())) {
break;
}
}
CLIENT_CODE_STACK_INDEX = i;
}
public static void main(String[] args) {
System.out.println("methodName() = " + methodName());
System.out.println("CLIENT_CODE_STACK_INDEX = " + CLIENT_CODE_STACK_INDEX);
}
public static String methodName() {
return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX].getMethodName();
}
}
看起来设计过度了，但我们有一些 JDK 1.5 的固定数字，当我们迁移到 JDK 1.6 时它发生了变化，有点惊讶。现在它在 Java 6/7 中是一样的，但你永远不知道。这并不能证明该索引在运行时发生了变化——但希望 HotSpot 不会做得那么糟糕。:-)
于 2011-12-21T16:13:03.287 回答
47
public class SomeClass {
public void foo(){
class Local {};
String name = Local.class.getEnclosingMethod().getName();
}
}
名称将具有值 foo。
于 2013-03-13T05:21:06.773 回答
44
这两个选项都适用于 Java：
new Object(){}.getClass().getEnclosingMethod().getName()
或者：
Thread.currentThread().getStackTrace()[1].getMethodName()
于 2015-09-01T10:21:59.757 回答
34
我发现最快的方法是：
import java.lang.reflect.Method;
public class TraceHelper {
// save it static to have it available on every call
private static Method m;
static {
try {
m = Throwable.class.getDeclaredMethod("getStackTraceElement",
int.class);
m.setAccessible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
public static String getMethodName(final int depth) {
try {
StackTraceElement element = (StackTraceElement) m.invoke(
new Throwable(), depth + 1);
return element.getMethodName();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
它直接访问本机方法 getStackTraceElement(int depth)。并将可访问的方法存储在静态变量中。
于 2012-07-30T17:40:37.900 回答
26
使用以下代码：
StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
StackTraceElement e = stacktrace[1];//coz 0th will be getStackTrace so 1st
String methodName = e.getMethodName();
System.out.println(methodName);
于 2012-06-12T07:44:19.940 回答
25
这可以StackWalker从 Java 9 开始使用。
public static String getCurrentMethodName() {
return StackWalker.getInstance()
.walk(s -> s.skip(1).findFirst())
.get()
.getMethodName();
}
public static String getCallerMethodName() {
return StackWalker.getInstance()
.walk(s -> s.skip(2).findFirst())
.get()
.getMethodName();
}
StackWalker被设计成惰性的，所以它可能比Thread.getStackTrace急切地为整个调用堆栈创建一个数组更有效。另请参阅 JEP 了解更多信息。
于 2018-09-14T15:45:13.150 回答
20
public static String getCurrentMethodName() {
return Thread.currentThread().getStackTrace()[2].getClassName() + "." + Thread.currentThread().getStackTrace()[2].getMethodName();
}
于 2014-02-19T07:13:45.557 回答
14
这是对virgo47 答案的扩展（上图）。
它提供了一些静态方法来获取当前和调用的类/方法名称。
/* 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 + ")";
}
}
于 2012-09-29T14:55:45.697 回答
12
要获取调用当前方法的方法的名称，您可以使用：
new Exception("is not thrown").getStackTrace()[1].getMethodName()
这适用于我的 MacBook 以及我的 Android 手机
我也试过：
Thread.currentThread().getStackTrace()[1]
但 Android 将返回“getStackTrace”我可以为 Android 修复此问题
Thread.currentThread().getStackTrace()[2]
但后来我在我的 MacBook 上得到了错误的答案
于 2015-09-22T10:39:30.280 回答
11
实用程序.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
}
}
于 2015-11-02T08:21:09.290 回答
5
另一种方法是创建但不抛出异常，并使用该对象从中获取堆栈跟踪数据，因为封闭方法通常位于索引 0 - 只要 JVM 存储该信息，就像其他人一样上文提到的。然而，这不是最便宜的方法。
从Throwable.getStackTrace()（至少从 Java 5 开始就是这样）：
数组的第零个元素（假设数组的长度不为零）表示堆栈的顶部，这是序列中的最后一个方法调用。通常，这是这个 throwable 被创建和抛出的点。
下面的代码片段假定该类是非静态的（因为 getClass()），但这是一个旁白。
System.out.printf("Class %s.%s\n", getClass().getName(), new Exception("is not thrown").getStackTrace()[0].getMethodName());
于 2014-12-15T11:48:42.207 回答
4
String methodName =Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println("methodName = " + methodName);
于 2013-06-03T11:46:39.170 回答
3
我有使用这个的解决方案（在 Android 中）
/**
* @param className fully qualified className
* <br/>
* <code>YourClassName.class.getName();</code>
* <br/><br/>
* @param classSimpleName simpleClassName
* <br/>
* <code>YourClassName.class.getSimpleName();</code>
* <br/><br/>
*/
public static void getStackTrace(final String className, final String classSimpleName) {
final StackTraceElement[] steArray = Thread.currentThread().getStackTrace();
int index = 0;
for (StackTraceElement ste : steArray) {
if (ste.getClassName().equals(className)) {
break;
}
index++;
}
if (index >= steArray.length) {
// Little Hacky
Log.w(classSimpleName, Arrays.toString(new String[]{steArray[3].getMethodName(), String.valueOf(steArray[3].getLineNumber())}));
} else {
// Legitimate
Log.w(classSimpleName, Arrays.toString(new String[]{steArray[index].getMethodName(), String.valueOf(steArray[index].getLineNumber())}));
}
}
于 2016-03-03T06:53:00.543 回答
3
我不知道获取当前执行的方法名称的意图是什么，但如果这只是为了调试目的，那么像“logback”这样的日志框架可以在这里提供帮助。例如，在 logback 中，您需要做的就是在日志配置中使用模式“%M”。但是，应谨慎使用，因为这可能会降低性能。
于 2016-11-08T02:04:26.123 回答
3
万一您想知道名称的方法是junit测试方法，则可以使用junit TestName规则：https ://stackoverflow.com/a/1426730/3076107
于 2018-02-20T14:08:44.237 回答
0
我改写了一点马克莱门茨的回答：
private static Method m;
static {
try {
m = Throwable.class.getDeclaredMethod(
"getStackTraceElement",
int.class
);
}
catch (final NoSuchMethodException e) {
throw new NoSuchMethodUncheckedException(e);
}
catch (final SecurityException e) {
throw new SecurityUncheckedException(e);
}
}
public static String getMethodName(int depth) {
StackTraceElement element;
final boolean accessible = m.isAccessible();
m.setAccessible(true);
try {
element = (StackTraceElement) m.invoke(new Throwable(), 1 + depth);
}
catch (final IllegalAccessException e) {
throw new IllegalAccessUncheckedException(e);
}
catch (final InvocationTargetException e) {
throw new InvocationTargetUncheckedException(e);
}
finally {
m.setAccessible(accessible);
}
return element.getMethodName();
}
public static String getMethodName() {
return getMethodName(1);
}
于 2019-09-20T18:30:19.430 回答
0
这里的大多数答案似乎都是错误的。
public static String getCurrentMethod() {
return getCurrentMethod(1);
}
public static String getCurrentMethod(int skip) {
return Thread.currentThread().getStackTrace()[1 + 1 + skip].getMethodName();
}
例子：
public static void main(String[] args) {
aaa();
}
public static void aaa() {
System.out.println("aaa -> " + getCurrentMethod( ) );
System.out.println("aaa -> " + getCurrentMethod(0) );
System.out.println("main -> " + getCurrentMethod(1) );
}
输出：
aaa -> aaa
aaa -> aaa
main -> main
于 2020-03-29T15:50:23.230 回答
0
我将此代码片段与带有最新 Java 更新的最新 Android Studio 一起使用。它可以从任何 Activity、Fragment 等中调用。
public static void logPoint() {
String[] splitPath = Thread.currentThread().getStackTrace()[3]
.toString().split("\\.");
Log.d("my-log", MessageFormat.format("{0} {1}.{2}",
splitPath[splitPath.length - 3],
splitPath[splitPath.length - 2],
splitPath[splitPath.length - 1]
));
}
像这样称呼它
logPoint();
输出
... D/my-log: MainActivity onCreate[(MainActivity.java:44)]
于 2021-06-14T13:42:46.270 回答
-3
MethodHandles.lookup().lookupClass().getEnclosingMethod().getName();
于 2016-09-27T10:20:09.557 回答
-6
这种方法有什么问题：
class Example {
FileOutputStream fileOutputStream;
public Example() {
//System.out.println("Example.Example()");
debug("Example.Example()",false); // toggle
try {
fileOutputStream = new FileOutputStream("debug.txt");
} catch (Exception exception) {
debug(exception + Calendar.getInstance().getTime());
}
}
private boolean was911AnInsideJob() {
System.out.println("Example.was911AnInsideJob()");
return true;
}
public boolean shouldGWBushBeImpeached(){
System.out.println("Example.shouldGWBushBeImpeached()");
return true;
}
public void setPunishment(int yearsInJail){
debug("Server.setPunishment(int yearsInJail=" + yearsInJail + ")",true);
}
}
在人们疯狂使用System.out.println(...)你之前，你总是可以而且应该创建一些方法来重定向输出，例如：
private void debug (Object object) {
debug(object,true);
}
private void dedub(Object object, boolean debug) {
if (debug) {
System.out.println(object);
// you can also write to a file but make sure the output stream
// ISN'T opened every time debug(Object object) is called
fileOutputStream.write(object.toString().getBytes());
}
}
于 2014-08-25T05:03:24.217 回答