Java面试题之Logback打印日志是如何获取当前方法名称的？

在 Java 中，有四种方法可以获取当前正在执行方法体的方法名称，分别是：

1. 使用 Thread.currentThread().getStackTrace() 方法
2. 使用异常对象的 getStackTrace() 方法
3. 使用匿名内部类的 getClass().getEnclosingMethod() 方法
4. Java 9 的 Stack-Walking API

本文将根据以上四种方法来给大家进行具体讲解，不过不知道大家有没有想过，获取当前执行方法体的方法名称有什么用嘞？

它可以用于日志记录、异常处理、测试框架等方面。例如我们可以在方法的开始和结束时打印出当前方法名和参数，以便追踪程序的执行流程和性能。

1.使用 Thread.currentThread().getStackTrace()方法

这种方法是通过获取当前线程的堆栈跟踪信息，然后从中提取出当前方法名的。

具体的代码如下：

// 获取当前方法名
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
// 打印当前方法名
System.out.println("当前方法名：" + methodName);

这种方法的优点是简单易用，不需要创建额外的对象。缺点是性能较低，因为 Thread.currentThread().getStackTrace() 方法获取堆栈跟踪信息需要遍历整个调用栈，而且需要保证线程安全性。

2.使用异常对象的 getStackTrace()方法

这种方法是通过创建一个新的异常对象，然后从其堆栈跟踪信息中提取出当前方法名和参数的。

具体的代码如下：

// 获取当前方法名
String methodName = new Exception().getStackTrace()[0].getMethodName();
// 打印当前方法名
System.out.println("当前方法名：" + methodName);

这种方法的优点是不需要获取堆栈跟踪信息，而且不会创建异常对象，因此性能和可读性都较好。缺点是需要创建额外的对象，而且代码较为复杂，不太直观。

3.匿名内部类的 getClass().getEnclosingMethod()方法

这种方法是通过创建一个匿名内部类的对象，然后从其类对象中获取当前方法的方法对象，再从方法对象中获取当前方法名和参数的。具体的代码如下：

// 获取当前方法名
String methodName = new Object(){}.getClass().getEnclosingMethod().getName();
// 打印当前方法名
System.out.println("当前方法名：" + methodName);

这种方法的优点是不需要获取堆栈跟踪信息，而且不会创建异常对象，因此性能和可读性都较好。缺点是需要创建额外的对象，而且代码较为复杂，不太直观。

4.Java 9 的 Stack-Walking API

Java 9 引入了 Stack-Walking API，以惰性且高效的方式遍历 JVM 堆栈帧。可以使用这个 API 找到当前正在执行的方法，具体的代码如下：

StackWalker walker = StackWalker.getInstance();
Optional<String> optional = walker.walk(frames -> frames
        .findFirst()
        .map(StackWalker.StackFrame::getMethodName));
System.out.println("当前方法名：" + optional.get());

首先，我们使用 StackWalker.getInstance() 工厂方法获取 StackWalker 实例。然后我们使用 walk() 方法从上到下遍历栈帧：

• walk() 方法可以将堆栈帧转化为 Stream流
• findFirst() 方法从 Stream 流中的获取第一个元素，也就是堆栈的顶部帧，顶部帧就代表当前正在执行的方法
• map() 方法用于获取顶部帧 StackFrame 的当前方法名称

Stack-Walking API 的优点

与以上方法相比，Stack-Walking API 有很多优点：

• 线程安全
• 无需创建匿名内部类实例 – new Object().getClass(){}
• 无需创建异常 – new Throwable()
• 无需急切地捕获整个堆栈跟踪，这可能成本很高 – Thread.currentThread()

StackWalker 是以一种懒惰的方式逐一遍历堆栈。在需要获取当前方法名称时，我们可以只获取顶部帧，而不需要捕获整个堆栈跟踪。

面试题：Logback

Logback 是一个流行的 Java 日志框架，它是 Log4j 的继承者，由 Log4j 的创始人设计。Logback 有以下特点：

• 高性能：Logback 比其他日志框架更快，更节省空间，有时甚至大得多。
• 灵活配置：Logback 支持 XML 和 Groovy 两种配置方式，可以实现动态修改配置，无需重启应用。
• 丰富功能：Logback 提供了多种输出目标，如控制台、文件、数据库、邮件等，还支持滚动策略、过滤器、异步日志等高级功能。
• 与 SLF4J 集成：Logback 是 SLF4J 的原生实现，可以与其他基于 SLF4J 的日志框架无缝切换。

不知道大家有没有想过，我们在使用 Logback 日志框架中打印日志时，是如何获取当前执行方法体的方法名称的嘞？在 Spring 项目中，我们一般是通过 Logback 的 xml 文件 parttern 属性来配置日志格式的。xml 配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <springProperty scope="context" name="appName" source="spring.application.name" defaultValue="dev"/>
    <property name="logPath" value="/home/logs/${appName}"/>
    <property name="pattern"
              value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{request_id}] [%thread] [%-5level] %logger{36}:%L %M - %msg%n"/>

    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoder 默认配置为PatternLayoutEncoder -->
        <encoder>
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    <!-- 记录日志到文件 -->
    <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${logPath}/info.log</file>
        <encoder>
            <pattern>${pattern}</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logPath}/run.%d{yyyy-MM-dd}.log</fileNamePattern>
        </rollingPolicy>
    </appender>
    ...
</configuration>

可以看到我们配置的日志输出格式是 %d{yyyy-MM-dd HH:mm:ss.SSS} [%X{request_id}] [%thread] [%-5level] %logger{36}:%L %M - %msg%n，Logback 在打印日志时，会解析这个日志输出格式，最后将 %M 占位符替换为当前方法名称。

解析日志格式的源码就在 FormattingConverter 类的 write() 方法中，write() 方法中会执行 convert() 方法，这个方法就是执行占位符替换的。

源码截图如下

如上图根据类名我们可以看到红线框起来的 MethodOfCallerConverter 类就是用来执行 %M 占位符替换逻辑的，源码如下，

public class MethodOfCallerConverter extends ClassicConverter {
    public String convert(ILoggingEvent le) {
        StackTraceElement[] cda = le.getCallerData();
        if (cda != null && cda.length > 0) {
            // 返回当前方法名称
            return cda[0].getMethodName();
        } else {
            return CoreConstants.NA;
        }
    }
}

方法逻辑如下，

1. StackTraceElement[] cda = le.getCallerData() 获取当前堆栈顶部帧
2. cda[0].getMethodName() 根据顶部帧获取当前方法名称。

如上我们只需要看下 le.getCallerData() 方法的堆栈是从哪里获取来的，就能知道答案了。

进入 LoggingEvent 源码类中，我们可以发现堆栈获取逻辑。

源码如下

public class LoggingEvent implements ILoggingEvent {
    public StackTraceElement[] getCallerData() {
        if (callerDataArray == null) {
            // 堆栈初始化
            callerDataArray = CallerData.extract(new Throwable(), fqnOfLoggerClass,
                    loggerContext.getMaxCallerDataDepth(), loggerContext.getFrameworkPackages());
        }
        return callerDataArray;
    }
    ...
}

1. 如果当前堆栈为空，进行堆栈信息初始化。这里就可以看到堆栈信息初始化来自 CallerData.extract(new Throwable(), fqnOfLoggerClass,loggerContext.getMaxCallerDataDepth(), loggerContext.getFrameworkPackages()) 方法。
2. 如果堆栈信息不为空，直接返回当前堆栈。这里是为了避免浪费，针对在一个方法中重复获取堆栈信息的情况。

Ok，到这里离胜利就只差一步了。进一步查看 CallerData.extract(new Throwable(), fqnOfLoggerClass,loggerContext.getMaxCallerDataDepth(), loggerContext.getFrameworkPackages()) 方法，源码如下，

public class CallerData {
    public static StackTraceElement[] extract(Throwable t, String fqnOfInvokingClass, final int maxDepth,
            List<String> frameworkPackageList) {
        if (t == null) {
            return null;
        }

        StackTraceElement[] steArray = t.getStackTrace();
        StackTraceElement[] callerDataArray;
        ...
        callerDataArray = new StackTraceElement[desiredDepth];
        for (int i = 0; i < desiredDepth; i++) {
            callerDataArray[i] = steArray[found + i];
        }
        return callerDataArray;
    }
    ...
}

为了突出源码逻辑的重点，这里我删去了一部分代码，是为了让大家更好的看清楚 Logback 中堆栈信息的初始化，其实用的就是异常对象的 getStackTrace() 方法。也就是上面源码中 StackTraceElement[] steArray = t.getStackTrace() 方法所体现的。

那么到这里我就可以下一个结论了， Logback 日志框架中打印日志时，就是使用异常对象的 getStackTrace() 方法来获取当前执行方法的方法名称的。

总结

本文有介绍四种方法获取当前执行方法名称，一般情况下大家使用异常对象的 getStackTrace() 方法以及匿名内部类的 getClass().getEnclosingMethod() 方法都是可以的，它们的性能都 OK，代码书写复杂程度都大差不差。

在 Java 9 以后推荐使用 Stack-Walking API，它的功能更为强大，与程序里的堆栈语意也跟为契合，性能OK，并且还是线程安全的。