SpringBoot 日志深度解析：轻松上手，快速精通！

最新推荐文章于 2025-05-26 19:53:23 发布

Yaml墨韵

最新推荐文章于 2025-05-26 19:53:23 发布

阅读量1.1k

点赞数 11

CC 4.0 BY-SA版权

分类专栏： # springboot 文章标签： spring boot 后端 java

本文链接：https://blog.youkuaiyun.com/Yaml4/article/details/143289391

springboot 专栏收录该内容

48 篇文章

订阅专栏

前言

日志，是开发中熟悉又陌生的伙伴，熟悉是因为我们经常会在各种场合打印日志，陌生是因为大部分时候我们都不太关心日志是怎么打印出来的，因为打印一条日志，在我们看来是一件太平常不过的事情了，特别是在宇宙第一框架Springboot的加持下，日志打印是怎么工作的就更没人关注了。

但是了解日志框架怎么工作，以及学会Springboot怎么和Log4j2或Logback等日志框架集成，对我们扩展日志功能以及优雅打印日志大有好处，甚至在有些场景，还能通过调整日志的打印策略来提升我们的系统吞吐量。

所以本文将以Springboot集成Log4j2为例，详细说明Springboot框架下Log4j2是如何工作的，你可能会担心，如果是使用Logback日志框架该怎么办呢，其实Log4j2和Logback极其相似，Springboot在启动时处理Log4j2和处理Logback也几乎是一样的套路，所以学会Springboot框架下Log4j2如何工作，切换成Logback也是轻轻松松的。

本文遵循一个该深则深，该浅则浅的整体指导方针，全方位的阐述Springboot中日志怎么工作，思维导图如下所示。

一. Log4j2简单工作原理分析

Log4j2 是一个功能强大的 Java 日志框架，它提供了灵活的配置和高效的日志记录功能。以下是对 Log4j2 工作原理的详细分析，并结合代码进行说明。

1、核心组件

Logger（日志记录器）：Logger 是 Log4j2 中用于记录日志的核心组件。每个 Logger 都有一个名称，用于标识不同的日志来源。Logger 可以根据日志级别来决定是否记录日志。常见的日志级别从低到高依次为：TRACE、DEBUG、INFO、WARN、ERROR 和 FATAL。
Appender（输出目的地）：Appender 定义了日志的输出目的地，可以是控制台、文件、数据库等。Log4j2 支持多种类型的 Appender，开发人员可以根据实际需求进行配置。
Layout（日志格式器）：Layout 用于定义日志的输出格式。它可以将日志事件转换为特定的字符串格式，以便于阅读和分析。Log4j2 提供了多种 Layout 实现，如 PatternLayout、JSONLayout 等。

2、工作原理

配置加载：在应用程序启动时，Log4j2 会加载配置文件。配置文件可以是 XML、JSON 或 properties 格式，其中包含了 Logger、Appender 和 Layout 的配置信息。Log4j2 根据配置文件创建相应的 Logger、Appender 和 Layout 对象。
日志记录：当应用程序需要记录日志时，会通过 Logger 对象的相应方法（如 debug、info、error 等）来记录日志。Logger 会根据当前的日志级别和配置来决定是否记录该日志。如果日志级别满足要求，Logger 会将日志事件传递给关联的 Appender。
Appender 处理：Appender 接收到日志事件后，会根据其配置的 Layout 对日志事件进行格式化。然后，Appender 将格式化后的日志输出到指定的目的地，如控制台、文件或数据库。
异步日志记录：Log4j2 支持异步日志记录，这可以提高应用程序的性能。异步日志记录将日志的产生和输出分离，日志事件首先被放入一个队列中，然后由单独的线程从队列中取出并输出。这样可以避免在日志输出时阻塞应用程序的主线程。

3、代码示例

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Log4j2Example {
    private static final Logger logger = LogManager.getLogger(Log4j2Example.class);

    public static void main(String[] args) {
        logger.trace("This is a trace message.");
        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
        logger.fatal("This is a fatal message.");
    }
}

在这个例子中：

首先，引入了 Log4j2 的相关库：

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

创建一个静态的 Logger 对象：

private static final Logger logger = LogManager.getLogger(Log4j2Example.class);

这里通过 LogManager.getLogger 方法获取与当前类对应的 Logger 对象。每个 Logger 都有一个名称，这里使用当前类的全限定名作为 Logger 的名称，以便更好地区分不同模块的日志。

在 main 方法中，使用不同的日志级别记录日志：

logger.trace("This is a trace message.");
logger.debug("This is a debug message.");
logger.info("This is an info message.");
logger.warn("This is a warning message.");
logger.error("This is an error message.");
logger.fatal("This is a fatal message.");

这些方法分别对应不同的日志级别。根据 Log4j2 的配置，只有级别高于或等于配置中指定的日志级别才会被输出。

例如，如果配置文件中设置的日志级别为 INFO，那么只有 info、warn、error 和 fatal 级别的日志会被输出，而 trace 和 debug 级别的日志将被忽略。

以下是一个简单的 Log4j2 XML 配置文件示例：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

在这个配置文件中：

<Appenders> 部分定义了输出目的地。这里定义了一个名为 Console 的输出目的地，将日志输出到控制台。<PatternLayout> 定义了日志的格式，包括时间戳、线程名称、日志级别、日志记录器名称和日志消息等。
<Loggers> 部分定义了日志记录器。<Root> 表示根日志记录器，这里设置其级别为 info，并将 Console 输出目的地关联到根日志记录器，意味着所有级别为 info 及以上的日志都会被输出到控制台。

四、总结

Log4j2 通过灵活的配置和强大的功能，为 Java 应用程序提供了高效的日志记录解决方案。开发人员可以根据实际需求配置不同的 Logger、Appender 和 Layout，以满足不同的日志记录需求。同时，Log4j2 的异步日志记录功能可以提高应用程序的性能，避免在日志输出时阻塞主线程。

二、Springboot日志简单配置说明

在 Spring Boot 中，日志配置相对简单，它默认使用 Logback 作为日志实现框架。以下是关于 Spring Boot 日志的详细介绍及结合代码的说明：

1、Spring Boot 日志的默认配置

Spring Boot 为开发者提供了一套默认的日志配置，无需额外的配置就可以在控制台输出日志信息。默认情况下，日志级别为 INFO，会输出 INFO、WARN、ERROR 级别的日志。

2、日志级别

Spring Boot 支持的日志级别从低到高依次为：TRACE、DEBUG、INFO、WARN、ERROR、FATAL。可以通过配置文件调整日志级别，以控制输出的日志详细程度。

例如，将日志级别调整为 DEBUG，可以看到更多的调试信息：

logging.level.root=DEBUG

3、配置文件

application.properties 文件：

可以在 application.properties 文件中进行简单的日志配置。

logging.level.com.example.demo=DEBUG
# 设置包 com.example.demo 的日志级别为 DEBUG

logging.file=myapp.log
# 指定日志输出到文件 myapp.log

logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
# 定义控制台输出的日志格式

application.yml 文件：

也可以使用 YAML 格式的配置文件进行日志配置。

例如：

logging:
  level:
    com.example.demo: DEBUG
  file: myapp.log
  pattern:
    console: '%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n'

4、代码中使用日志

在 Spring Boot 应用中，可以直接使用 SLF4J（Simple Logging Facade for Java）的接口来记录日志，而具体的日志实现由底层的日志框架（如 Logback）负责。

例如，在一个服务类中：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    public void doSomething() {
        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
    }
}

五、总结

Spring Boot 的日志配置简单而强大，可以通过配置文件轻松调整日志级别、输出目的地和日志格式等。在开发过程中，合理地配置日志可以帮助开发者更好地了解应用程序的运行状态，便于调试和故障排除。

三. Springboot日志启动机制分析

1、依赖引入与自动配置

Spring Boot 在启动时会自动引入相关的日志依赖。默认情况下，它使用 Logback 作为日志实现框架。如果在项目中引入了其他日志框架，如 Log4j2 或 Java Util Logging，Spring Boot 会根据依赖的优先级进行自动配置。

在项目的 pom.xml 文件中，通常会有以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

这个启动器会自动引入一系列的基础依赖，其中包括日志相关的依赖。

2、日志配置文件加载

默认情况下，Spring Boot 会查找 classpath 下的 logback-spring.xml、logback-spring.groovy、logback.xml 或 logback.groovy 文件作为 Logback 的配置文件。如果使用其他日志框架，也会查找相应的配置文件。
配置文件可以设置日志级别、输出目的地、日志格式等。例如，一个简单的 Logback 配置文件 logback-spring.xml 如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

这个配置文件定义了一个输出到控制台的 Appender，并设置了日志格式和根日志级别为 INFO。

3、日志记录器的创建与使用

在 Spring Boot 应用中，可以使用 SLF4J（Simple Logging Facade for Java）的接口来记录日志。SLF4J 提供了统一的日志接口，而具体的日志实现由底层的日志框架负责。

例如，在一个服务类中：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    public void doSomething() {
        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
    }
}

当应用程序启动时，SLF4J 会根据配置的日志框架创建相应的日志记录器（Logger）。在上面的代码中，通过 LoggerFactory.getLogger 方法获取与 MyService 类对应的日志记录器。

4、日志级别控制

可以通过配置文件或在运行时动态调整日志级别。例如，在配置文件中设置特定包或类的日志级别：

<configuration>
   ...
    <logger name="com.example.demo" level="DEBUG"/>
   ...
</configuration>

这将设置包 com.example.demo 的日志级别为 DEBUG。

也可以在运行时通过 JMX（Java Management Extensions）或使用特定的日志管理工具来动态调整日志级别。

5、总结

Spring Boot 的日志启动机制通过自动配置和依赖引入，使得日志配置变得简单而高效。开发者可以通过配置文件轻松地定制日志的输出格式、级别和目的地，并且可以在代码中使用统一的 SLF4J 接口来记录日志。这种机制有助于提高开发效率，便于调试和故障排除。

四、Springboot集成Log4j2原理

1、依赖引入与自动配置

在 Spring Boot 项目中，要集成 Log4j2，首先需要在项目的依赖管理文件（如 Maven 的 pom.xml）中添加相应的依赖：

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-log4j2</artifactId>
   </dependency>

这个依赖会引入 Log4j2 相关的库以及与 Spring Boot 的集成组件。

Spring Boot 的自动配置机制会检测到这个依赖，并尝试进行 Log4j2 的自动配置。

2、配置文件加载

Spring Boot 会在项目的 classpath 下查找 Log4j2 的配置文件。默认情况下，会查找 log4j2.xml、log4j2.properties 或 log4j2.yml 文件。

例如，一个简单的 log4j2.xml 配置文件如下：

   <?xml version="1.0" encoding="UTF-8"?>
   <Configuration status="WARN">
       <Appenders>
           <Console name="Console" target="SYSTEM_OUT">
               <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
           </Console>
       </Appenders>
       <Loggers>
           <Root level="info">
               <AppenderRef ref="Console"/>
           </Root>
       </Loggers>
   </Configuration>

这个配置文件定义了一个输出到控制台的 Appender，并设置了根日志记录器的级别为 info。

3、日志记录器的创建与使用

在应用程序中，可以使用 SLF4J（Simple Logging Facade for Java）的接口来记录日志。SLF4J 提供了统一的日志接口，而具体的日志实现由底层的日志框架（这里是 Log4j2）负责。

例如，在一个服务类中：

   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;

   public class MyService {
       private static final Logger logger = LoggerFactory.getLogger(MyService.class);

       public void doSomething() {
           logger.debug("This is a debug message.");
           logger.info("This is an info message.");
           logger.warn("This is a warning message.");
           logger.error("This is an error message.");
       }
   }

通过 LoggerFactory.getLogger 方法获取与 MyService 类对应的日志记录器。当调用日志记录方法时，SLF4J 会将日志请求转发给 Log4j2，Log4j2 根据配置文件中的设置来决定如何处理日志事件。

4、工作流程总结

当 Spring Boot 应用启动时：

首先，自动配置机制检测到 spring-boot-starter-log4j2 依赖，并尝试加载 Log4j2 的配置文件。
如果找到配置文件，Log4j2 根据配置文件创建相应的日志记录器、Appender 和 Layout。
在应用程序运行过程中，当使用 SLF4J 的接口记录日志时，SLF4J 将日志请求转发给 Log4j2。
Log4j2 根据当前的日志级别和配置，决定是否记录日志以及将日志输出到何处。

五. Springboot日志打印器级别热更新

在 Spring Boot 中，可以实现日志打印器级别的热更新，这意味着可以在应用程序运行时动态地调整日志级别，而无需重新启动应用程序。以下是详细介绍并结合代码说明：

1、实现原理

Spring Boot 默认使用的日志框架是 Logback，但也可以集成其他日志框架如 Log4j2。无论是哪种框架，通常都支持通过特定的方式在运行时动态调整日志级别。一般来说，这是通过读取配置文件或者使用特定的管理工具来实现的。

2、使用配置文件实现热更新（以 Logback 为例）

在 application.properties 或 application.yml 文件中，可以配置特定包或类的日志级别。例如：
- 在 application.properties 文件中：

     logging.level.com.example.demo=DEBUG

在 application.yml 文件中：

     logging:
       level:
         com.example.demo: DEBUG

这里将包 com.example.demo 的日志级别设置为 DEBUG。

如果要在运行时动态更新这个级别，可以修改配置文件并让应用程序重新读取配置文件。有些应用服务器或工具可以实现配置文件的热加载，从而实现日志级别的热更新。

3、使用 JMX（Java Management Extensions）实现热更新

可以通过 JMX 来动态调整日志级别。对于 Logback，可以使用 ch.qos.logback.classic.jmx.JMXConfigurator 来启用 JMX 支持。

在 Logback 的配置文件（如 logback.xml）中添加以下配置：

   <configuration>
       <!-- 其他配置 -->
       <jmxConfigurator/>
   </configuration>

然后，可以使用 JMX 工具（如 JConsole）连接到应用程序，并找到对应的 MBean（Managed Bean）来调整日志级别。

4、代码示例

以下是一个简单的 Spring Boot 应用程序，展示了如何在代码中获取日志记录器并输出不同级别的日志：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LoggingExampleApplication {

    private static final Logger logger = LoggerFactory.getLogger(LoggingExampleApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(LoggingExampleApplication.class, args);

        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
    }
}

在运行这个应用程序后，可以通过上述提到的方法（如修改配置文件或使用 JMX 工具）来动态调整日志级别，观察不同级别日志的输出变化。

5、总结

Spring Boot 日志打印器级别的热更新可以提高开发和调试的效率，无需重新启动应用程序即可根据需要调整日志级别，以便更好地跟踪和排查问题。

六. 自定义Springboot下日志打印器级别热更新

在 Spring Boot 中可以自定义实现日志打印器级别的热更新。以下是详细介绍并结合代码说明：

1、实现思路

创建一个自定义的配置类，用于监听外部的配置变化事件，比如通过 HTTP 请求或者特定的配置文件变化来触发日志级别更新。
在配置类中，使用 Spring 的 @ConfigurationProperties 注解来绑定外部配置源的属性到 Java 对象中，以便获取新的日志级别设置。
利用 Spring 的 ApplicationEventPublisher 发布一个自定义的事件，通知应用程序中的其他组件日志级别发生了变化。
创建一个事件监听器，在接收到自定义事件时，更新日志打印器的级别。

2、代码实现

创建自定义配置类：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "logging")
public class LoggingConfig {

    private String level;

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }
}

这个类用于绑定外部配置源中以 logging 为前缀的属性，比如 logging.level。

创建自定义事件：

import org.springframework.context.ApplicationEvent;

public class LoggingLevelChangeEvent extends ApplicationEvent {

    public LoggingLevelChangeEvent(Object source) {
        super(source);
    }
}

创建事件发布者：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

@Component
public class LoggingLevelChangePublisher {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publishLoggingLevelChange() {
        applicationEventPublisher.publishEvent(new LoggingLevelChangeEvent(this));
    }
}

这个组件用于发布日志级别变化事件。

创建事件监听器：

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class LoggingLevelChangeListener {

    @EventListener
    public void onLoggingLevelChange(LoggingLevelChangeEvent event) {
        // 假设这里从自定义配置类中获取新的日志级别
        LoggingConfig loggingConfig = new LoggingConfig();
        String newLevel = loggingConfig.getLevel();
        Logger logger = LogManager.getLogger(LoggingLevelChangeListener.class);
        logger.setLevel(Level.toLevel(newLevel));
    }
}

这个监听器在接收到日志级别变化事件时，更新指定日志记录器的级别。

触发日志级别更新：

可以通过创建一个 HTTP 控制器或者其他方式来触发日志级别更新。例如，创建一个 HTTP 控制器方法，接收请求并调用事件发布者发布事件：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoggingController {

    @Autowired
    private LoggingLevelChangePublisher loggingLevelChangePublisher;

    @PostMapping("/updateLoggingLevel")
    public void updateLoggingLevel(@RequestParam String level) {
        // 设置新的日志级别到自定义配置类中
        LoggingConfig loggingConfig = new LoggingConfig();
        loggingConfig.setLevel(level);
        // 发布日志级别变化事件
        loggingLevelChangePublisher.publishLoggingLevelChange();
    }
}