顿悟！新手都能学懂的SpringBoot源码分析！

傷城~ 2023-01-23 06:55 35阅读 0赞

# 概述 #

日志是一个系统必不可缺少的东西，记录了系统运行时的点点滴滴，便于我们了解自己系统的运行状态，在我们使用 Spring Boot时，默认就已经提供了日志功能，使用Logback作为默认的日志框架。那么，接下来我们依赖来看看 Spring Boot是如何初始化好日志系统的。[关于Spring的知识点总结了一个图谱][Spring]，分享给大家：

![Spring 知识总结.jpg][Spring _.jpg]

为什么Spring Boot默认的日志框架是Logbasck呢？

因为在spring-boot-starter模块中引入spring-boot-starter-logging模块，该Starter引入了logback-classic依赖。

## Log日志体系 ##

在我们的日常工作中，可能看到项目中依赖的跟日志相关的jar包有很多，例如commons-logging、log4j、log4j2、sl4j和logback等等，眼花缭乱。经常会碰到各种依赖冲入的问题，非常烦恼，例如这几个问题：

1.Failed to load class org.slf4j.impl.StaticLoggerBinder，没找到日志实现，如果你觉得你已经添加了对应的日志实现依赖了，那应该检查一下版本是否兼容

2.Multiple bindings，找到了多个日志实现，也可能是版本问题，slf4j会找其中一个作为日志实现  
如果想要正确地使用它们，有必要先理清它们之间的关系，我们可以来看看Log的发展史，首先从 Java Log 的发展历程开始说起：

1.1.log4j（作者Ceki Gülcü）出来后，被开发者们广泛的应用（注意，这里是直接使用），当初是 Java 日志事实上的标准，并成为了 Apache 的项目

2.2.Apache 要求把 log4j 并入到 jdk，SUN 表示拒绝，并在 jdk1.4 版本后增加了 JUL（java.util.logging）；

3.3.毕竟是 JDK 自带的，JUL 也被很多人使用。同时还有其他的日志组件，如 SimpleLog 等。这个时候如果有人想换成其他日志组件，如 log4j 换成 JUL，因为 API 完全不同，就需要改动代码，当然很多人不愿意呀；

4.4.Apache 见此，开发了 JCL（Jakarta Commons Logging），即 commons-logging-xx.jar。它只提供一套通用的日志接口 API，并不提供日志的实现。很好的设计原则嘛，依赖抽象而非实现。这样一来，我们的应用程序可以在运行时选择自己想要的日志实现组件；

5.5.这样看上去也挺美好的，但是log4j的作者觉得JCL不好用，自己开发出一套slf4j，它跟JCL类似，本身不替供日志的具体实现，只对外提供接口或门面。目的就是为了替代JCL。同时，还开发出logback，一个比log4j 拥有更高性能的组件，目的是为了替代log4j；

6.6.Apache 参考了 logback，并做了一系列优化，推出了一套 log4j2 日志框架。  
对于性能没什么特别高要求的使用 Spring Boot 中默认的 logback 就可以了，如果想要使用 log4j2 可以参考我的 《MyBatis 使用手册》 这篇文章，有提到过。

**回顾**

回到前面的 《SpringApplication 启动类的启动过程》 这篇文章，Spring Boot 启动应用的入口和主流程都是在 SpringApplication\#run(String… args) 方法中。

在启动 Spring 应用的整个过程中，到了不同的阶段会发布不同类型的事件，例如最开始会发布一个 应用正在启动 的事件，对于不同类型的事件都是通过 EventPublishingRunListener 事件发布器来发布，里面有一个事件广播器，封装了几个 ApplicationListener 事件监听器，如下：

#Application Listeners
    org.springframework.context.ApplicationListener=\
    org.springframework.boot.ClearCachesApplicationListener,\
    org.springframework.boot.builder.ParentContextCloserApplicationListener,\
    org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
    org.springframework.boot.context.FileEncodingApplicationListener,\
    org.springframework.boot.context.config.AnsiOutputApplicationListener,\
    org.springframework.boot.context.config.ConfigFileApplicationListener,\
    org.springframework.boot.context.config.DelegatingApplicationListener,\
    org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
    org.springframework.boot.context.logging.LoggingApplicationListener,\
    org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

其中有一个 LoggingApplicationListener 对象，监听到不同事件后，会对日志系统进行一些相关的初始化工作

> 提示：Spring Boot 的 LoggingSystem 日志系统的初始化过程有点绕，嵌套的方法有点多，可参考序号耐心查看

**LoggingApplicationListener**

org.springframework.boot.context.logging.LoggingApplicationListener，Spring Boot 事件监听器，用于初始化日志系统

**onApplicationEvent方法**

onApplicationEvent(ApplicationEvent 方法，处理监听到的事件

@Override
    public void onApplicationEvent(ApplicationEvent event) {
        // 应用正在启动的事件
        if (event instanceof ApplicationStartingEvent) {
            onApplicationStartingEvent((ApplicationStartingEvent) event);
        }
        // Environment 环境已准备事件
        else if (event instanceof ApplicationEnvironmentPreparedEvent) {
            onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
        }
        // 应用已准备事件
        else if (event instanceof ApplicationPreparedEvent) {
            onApplicationPreparedEvent((ApplicationPreparedEvent) event);
        }
        // Spring 上下文关闭事件
        else if (event instanceof ContextClosedEvent
                && ((ContextClosedEvent) event).getApplicationContext().getParent() == null) {
            onContextClosedEvent();
        }
        // 应用启动失败事件
        else if (event instanceof ApplicationFailedEvent) {
            onApplicationFailedEvent();
        }
    }

对于不同的事件调用不同的方法，事件的发布顺序也就是上面从上往下的顺序

### 1. onApplicationStartingEvent方法 ###

处理应用正在启动的事件

private void onApplicationStartingEvent(ApplicationStartingEvent event) {
        // <1> 创建 LoggingSystem 对象
        // 指定了类型则使用指定的，没有则尝试创建对应的对象，ClassLoader 中有对应的 Class 对象则创建（logback > log4j2 > java logging）
        this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
        // <2> LoggingSystem 的初始化前置处理
        this.loggingSystem.beforeInitialize();
    }

**过程如下：**

1.1.创建LoggingSystem对象，指定了类型则使用指定的，没有则尝试创建对应的对象，ClassLoader中有对应的Class对象则创建（logback > log4j2 > java logging）

2.2.调用LoggingSystem 的 beforeInitialize()方法，初始化前置处理

### 2. onApplicationEnvironmentPreparedEvent方法 ###

**处理环境已准备事件**

private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        // <1> 如果还未明确 LoggingSystem 类型，那么这里继续创建 LoggingSystem 对象
        if (this.loggingSystem == null) {
            this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
        }
        // <2> 初始化 LoggingSystem 对象，创建日志文件，设置日志级别
        initialize(event.getEnvironment(), event.getSpringApplication().getClassLoader());
    }

**过程如下：**

1.1.如果还未明确LoggingSystem类型，那么这里继续创建LoggingSystem对象

2.2.调用initialize(…) 方法，初始化LoggingSystem对象，创建日志文件，设置日志级别

### 3. initialize 方法 ###

protected void initialize(ConfigurableEnvironment environment, ClassLoader classLoader) {
        // <1> 根据 Environment 环境通过 LoggingSystemProperties 往 System 进行一些日志配置
        new LoggingSystemProperties(environment).apply();
        // <2> 根据 Environment 环境配置的日志名称和路径创建一个日志文件
        // 默认情况没有配置，这个对象也为 null，而是在打印第一个日志的时候会创建（如果不存在的话）
        this.logFile = LogFile.get(environment);
        if (this.logFile != null) {
            // <3> 往 System 添加日志文件的名称和路径
            this.logFile.applyToSystemProperties();
        }
        // <4> 创建一个日志分组对象
        this.loggerGroups = new LoggerGroups(DEFAULT_GROUP_LOGGERS);
        // <5> 初始化早期的 Spring Boot 日志级别（Debug 或者 Trace）
        initializeEarlyLoggingLevel(environment);
        // <6> 初始化 LoggingSystem 对象
        initializeSystem(environment, this.loggingSystem, this.logFile);
        // <7> 初始化最终的 Spring Boot 日志级别，逐个设置 Environment 配置的日志级别
        initializeFinalLoggingLevels(environment, this.loggingSystem);
        // <8> 向 JVM 注册一个钩子，用于在 JVM 关闭时关闭日志系统
        registerShutdownHookIfNecessary(environment, this.loggingSystem);
    }

**初始过程如下：**

1.1.根据Environment环境通过LoggingSystemProperties往System进行一些日志配置

2.2.根据Environment环境配置的日志名称和路径创建一个日志文件，默认情况没有配置，这个对象也为null，而是在打印第一个日志的时候会创建（如果不存在的话）

// LogFile.java
    public static LogFile get(PropertyResolver propertyResolver) {
        // 获取 `logging.file.name` 指定的日志文件名称，也可以通过 `logging.file` 指定
        String file = getLogFileProperty(propertyResolver, FILE_NAME_PROPERTY, FILE_PROPERTY);
        // 获取 `logging.file.path` 指定的日志文件保存路径，也可以通过 `logging.path` 指定
        String path = getLogFileProperty(propertyResolver, FILE_PATH_PROPERTY, PATH_PROPERTY);
        // 创建一个日志文件
        if (StringUtils.hasLength(file) || StringUtils.hasLength(path)) {
            return new LogFile(file, path);
        }
        return null;
    }

3.3.往System添加日志文件的名称和路径

4.4.创建一个日志分组对象

5.5.初始化早期的 Spring Boot 日志级别（Debug 或者 Trace）

private void initializeEarlyLoggingLevel(ConfigurableEnvironment environment) {
        if (this.parseArgs && this.springBootLogging == null) {
            if (isSet(environment, "debug")) {
                this.springBootLogging = LogLevel.DEBUG;
            }
            if (isSet(environment, "trace")) {
                this.springBootLogging = LogLevel.TRACE;
            }
        }
    }

**初始化LoggingSystem对象**

private void initializeSystem(ConfigurableEnvironment environment, LoggingSystem system, LogFile logFile) {
        LoggingInitializationContext initializationContext = new LoggingInitializationContext(environment);
        // <1> 找到 `logging.config` 指定的配置文件路径
        String logConfig = environment.getProperty(CONFIG_PROPERTY);
        // <2> 如果没配置文件，则不指定配置文件初始化 LoggingSystem 对象
        // 使用约定好的配置文件，或者使用默认配置
        if (ignoreLogConfig(logConfig)) {
            system.initialize(initializationContext, null, logFile);
        }
        // <3> 否则，指定配置文件初始化 LoggingSystem 对象
        else {
            try {
                system.initialize(initializationContext, logConfig, logFile);
            }
            catch (Exception ex) {
                // 抛出异常
            }
        }
    }

初始化最终的Spring Boot日志级别，逐个设置Environment配置的日志级别

向JVM注册一个钩子，用于在JVM关闭时关闭日志系统

可以看到需要通过LoggingSystem日志系统对象来初始化，后面会讲到

### 4. onApplicationPreparedEvent方法 ###

**处理应用已准备事件**

private void onApplicationPreparedEvent(ApplicationPreparedEvent event) {
        // 往底层 IoC 容器注册几个 Bean：LoggingSystem、LogFile 和 LoggerGroups
        ConfigurableListableBeanFactory beanFactory = event.getApplicationContext().getBeanFactory();
        if (!beanFactory.containsBean(LOGGING_SYSTEM_BEAN_NAME)) {
            beanFactory.registerSingleton(LOGGING_SYSTEM_BEAN_NAME, this.loggingSystem);
        }
        if (this.logFile != null && !beanFactory.containsBean(LOG_FILE_BEAN_NAME)) {
            beanFactory.registerSingleton(LOG_FILE_BEAN_NAME, this.logFile);
        }
        if (this.loggerGroups != null && !beanFactory.containsBean(LOGGER_GROUPS_BEAN_NAME)) {
            beanFactory.registerSingleton(LOGGER_GROUPS_BEAN_NAME, this.loggerGroups);
        }
    }

**LoggingSystem**

org.springframework.boot.logging.LoggingSystem 抽象类，Spring Boot 的日志系统对象，每个日志框架，都会对应一个实现类。如下图所示：

![image.png][]

public abstract class LoggingSystem {
    
    	private static final Map<String, String> SYSTEMS;
    
    	static {
    		Map<String, String> systems = new LinkedHashMap<>();
    		systems.put("ch.qos.logback.core.Appender", "org.springframework.boot.logging.logback.LogbackLoggingSystem");
    		systems.put("org.apache.logging.log4j.core.impl.Log4jContextFactory",
    				"org.springframework.boot.logging.log4j2.Log4J2LoggingSystem");
    		systems.put("java.util.logging.LogManager", "org.springframework.boot.logging.java.JavaLoggingSystem");
    		SYSTEMS = Collections.unmodifiableMap(systems);
    	}
    }

1.1 get 方法

创建一个 LoggingSystem 日志系统对象，如下：

public static LoggingSystem get(ClassLoader classLoader) {
        // <1> 从系统参数 `org.springframework.boot.logging.LoggingSystem` 获得 LoggingSystem 类型
        String loggingSystem = System.getProperty(SYSTEM_PROPERTY);
        // <2> 如果非空，说明配置了，那么创建一个该类型的 LoggingSystem 实例对象
        if (StringUtils.hasLength(loggingSystem)) {
            if (NONE.equals(loggingSystem)) {
                return new NoOpLoggingSystem();
            }
            return get(classLoader, loggingSystem);
        }
        // <3> 否则，没有配置，则通过顺序依次尝试创建对应类型的 LoggingSystem 实例对象
        // logback > log4j2 > java logging
        return SYSTEMS.entrySet().stream().filter((entry) -> ClassUtils.isPresent(entry.getKey(), classLoader))
                .map((entry) -> get(classLoader, entry.getValue())).findFirst()
                .orElseThrow(() -> new IllegalStateException("No suitable logging system located"));
    }

**过程如下：**

1.1.从系统参数org.springframework.boot.logging.LoggingSystem获得LoggingSystem类型

2.2.如果非空，说明配置了，那么创建一个该类型的LoggingSystem实例对象

3.3.否则，没有配置，则通过顺序依次尝试创建对应类型的LoggingSystem实例对象，也就是在static代码块中初始化好的集合，logback > log4j2 > java logging

#### 1.2 beforeInitialize方法 ####

初始化的前置操作，抽象方法，交由子类实现

/**
     * Reset the logging system to be limit output. This method may be called before
     * {@link #initialize(LoggingInitializationContext, String, LogFile)} to reduce
     * logging noise until the system has been fully initialized.
     */
    public abstract void beforeInitialize();

### 2. initialize方法 ###

**初始化操作，空方法，由子类来重写**

/**
     * Fully initialize the logging system.
     * @param initializationContext the logging initialization context
     * @param configLocation a log configuration location or {@code null} if default
     * initialization is required
     * @param logFile the log output file that should be written or {@code null} for
     * console only output
     */
    public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) {
    }

**AbstractLoggingSystem**

org.springframework.boot.logging.AbstractLoggingSystem 抽象类，继承 LoggingSystem 抽象类，作为一个基类

#### 2.1 initialize方法 ####

**重写父类的 initialize(…) 方法，提供模板化的初始化逻辑，如下：**

@Override
    public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) {
        // <1> 有自定义的配置文件，则使用指定配置文件进行初始化
        if (StringUtils.hasLength(configLocation)) {
            initializeWithSpecificConfig(initializationContext, configLocation, logFile);
            return;
        }
        // <2> 无自定义的配置文件，则使用约定配置文件进行初始化
        initializeWithConventions(initializationContext, logFile);
    }

有指定的配置文件，则调用 initializeWithSpecificConfig(…) 方法， 使用指定配置文件进行初始化

没有自定义的配置文件，则调用 initializeWithConventions(…) 方法，使用约定配置文件进行初始化

##### 2.1.1 initializeWithSpecificConfig方法 #####

initializeWithSpecificConfig(LoggingInitializationContext, String, LogFile) 方法，使用指定配置文件进行初始化

private void initializeWithSpecificConfig(LoggingInitializationContext initializationContext, String configLocation,
            LogFile logFile) {
        // <1> 获得配置文件的路径（可能有占位符）
        configLocation = SystemPropertyUtils.resolvePlaceholders(configLocation);
        // <2> 加载配置文件到日志系统中，抽象方法，子类实现
        loadConfiguration(initializationContext, configLocation, logFile);
    }

**先获取配置文件的路径（可能有占位符），然后调用 loadConfiguration(…) 抽象方法，加载配置文件到日志系统中**

/**
     * Load a specific configuration.
     * @param initializationContext the logging initialization context
     * @param location the location of the configuration to load (never {@code null})
     * @param logFile the file to load or {@code null} if no log file is to be written
     */
    protected abstract void loadConfiguration(LoggingInitializationContext initializationContext, String location,
            LogFile logFile);

##### 2.1.2 initializeWithConventions方法 #####

initializeWithConventions(LoggingInitializationContext, LogFile) 方法，使用约定配置文件进行初始化

private void initializeWithConventions(LoggingInitializationContext initializationContext, LogFile logFile) {
        // <1> 尝试获得约定配置文件，例如 log4j2 约定的是 log4j2.xml
        String config = getSelfInitializationConfig();
        // <2> 如果找到了约定的配置文件
        if (config != null && logFile == null) {
            // self initialization has occurred, reinitialize in case of property changes
            // <2.1> 自定义初始化，子类实现
            reinitialize(initializationContext);
            return;
        }
        // <3> 尝试获取约定的配置文件（带有 `-spring` ），例如 log4j2 对应是 log4j2-spring.xml
        if (config == null) {
            config = getSpringInitializationConfig();
        }
        // <4> 获取到了 `-spring` 配置文件，则加载到日志系统中，抽象方法，子类实现
        if (config != null) {
            loadConfiguration(initializationContext, config, logFile);
            return;
        }
        // <5> 加载默认配置，抽象方法，子类实现
        loadDefaults(initializationContext, logFile);
    }

**过程如下**

调用 getSelfInitializationConfig() 方法，尝试获得约定配置文件，例如 log4j2 约定的是 log4j2.xml

protected String getSelfInitializationConfig() {
        return findConfig(getStandardConfigLocations());
    }
    
    protected abstract String[] getStandardConfigLocations();
    
    private String findConfig(String[] locations) {
        for (String location : locations) {
            ClassPathResource resource = new ClassPathResource(location, this.classLoader);
            if (resource.exists()) {
                return "classpath:" + location;
            }
        }
        return null;
    }

如果找到了约定的配置文件，则调用 reinitialize(…) 抽象方法，自定义初始化，子类实现

> protected void reinitialize(LoggingInitializationContext initializationContext) \{ \}

调用 getSpringInitializationConfig(…) 方法，尝试获取约定的配置文件（带有 -spring ），例如 log4j2 对应是 log4j2-spring.xml

protected String getSpringInitializationConfig() {    return findConfig(getSpringConfigLocations());}protected String[] getSpringConfigLocations() {    String[] locations = getStandardConfigLocations();    for (int i = 0; i < locations.length; i++) {        String extension = StringUtils.getFilenameExtension(locations[i]);        locations[i] = locations[i].substring(0, locations[i].length() - extension.length() - 1) + "-spring."                + extension;    }    return locations;}private String findConfig(String[] locations) {    for (String location : locations) {        ClassPathResource resource = new ClassPathResource(location, this.classLoader);        if (resource.exists()) {            return "classpath:" + location;        }    }    return null;}

获取到了 -spring 配置文件，则调用 loadConfiguration(…) 抽象方法，加载到日志系统中，子类实现

protected abstract void loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile);  
还没有找到到指定的配置文件，那么调用 loadDefaults(…) 抽象方法，加载默认配置，子类实现

protected abstract void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile);  
整个过程就是尝试获取到各个日志框架约定好的配置文件名称，如果存在这个配置文件，则加载到日志系统中，否则使用默认的配置

Slf4JLoggingSystem  
org.springframework.boot.logging.Slf4JLoggingSystem，继承 AbstractLoggingSystem 抽象类，基于 Slf4J 的 LoggingSystem 的抽象基类

##### 1.2.1 beforeInitialize方法 #####

**初始化的前置操作**

`@Overridepublic void beforeInitialize() { super.beforeInitialize(); // <1> 配置 JUL 的桥接处理器，桥接到 slf4j configureJdkLoggingBridgeHandler();}`

先调用父类的 beforeInitialize() 方法，然后调用 configureJdkLoggingBridgeHandler() 方法，配置 JUL 的桥接处理器，桥接到 slf4j

`private void configureJdkLoggingBridgeHandler() { try { // <1> 判断 JUL 是否桥接到 SLF4J 了 if (isBridgeJulIntoSlf4j()) { // <2> 移除 JUL 桥接处理器 removeJdkLoggingBridgeHandler(); // <3> 重新安装 SLF4JBridgeHandler SLF4JBridgeHandler.install(); } } catch (Throwable ex) { // Ignore. No java.util.logging bridge is installed. }}`

**过程如下：**

1.判断JUL是否桥接到slf4j了

`protected final boolean isBridgeJulIntoSlf4j() { // 存在 SLF4JBridgeHandler 类，且 JUL 只有 ConsoleHandler 处理器被创建 return isBridgeHandlerAvailable() && isJulUsingASingleConsoleHandlerAtMost();}`

3.移除JUL桥接处理器

`private void removeJdkLoggingBridgeHandler() { try { // 移除 JUL 的 ConsoleHandler removeDefaultRootHandler(); // 卸载 SLF4JBridgeHandler SLF4JBridgeHandler.uninstall(); } catch (Throwable ex) { // Ignore and continue }}private void removeDefaultRootHandler() { try { Logger rootLogger = LogManager.getLogManager().getLogger(""); Handler[] handlers = rootLogger.getHandlers(); if (handlers.length == 1 && handlers[0] instanceof ConsoleHandler) { rootLogger.removeHandler(handlers[0]); } } catch (Throwable ex) { // Ignore and continue }}`

3.重新安装 SLF4JBridgeHandler

#### 2.3 loadConfiguration方法 ####

重写AbstractLoggingSystem父类的方法，加载指定的日志配置文件到日志系统中

`@Overrideprotected void loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile) { Assert.notNull(location, "Location must not be null"); if (initializationContext != null) { // 将 Environment 中的日志配置往 System 中配置 applySystemProperties(initializationContext.getEnvironment(), logFile); }}`

实际上就是将Environment中的日志配置往System中配置

**LogbackLoggingSystem**

> org.springframework.boot.logging.logback.LogbackLoggingSystem，继承Slf4JLoggingSystem抽象类，基于 logback的LoggingSystem实现类

##### 1.2.2 beforeInitialize方法 #####

重写LoggingSystem的方法，初始化前置操作

`@Overridepublic void beforeInitialize() { // <1> 获得 LoggerContext 日志上下文 LoggerContext loggerContext = getLoggerContext(); // <2> 如果 LoggerContext 已有 LoggingSystem，表示已经初始化，则直接返回 if (isAlreadyInitialized(loggerContext)) { return; } // <3> 调用父方法 super.beforeInitialize(); // <4> 添加 FILTER 到其中，因为还未初始化，不打印日志 loggerContext.getTurboFilterList().add(FILTER);}`

**过程如下：**

1.调用getLoggerContext() 方法，获得LoggerContext日志上下文

`private LoggerContext getLoggerContext() { ILoggerFactory factory = StaticLoggerBinder.getSingleton().getLoggerFactory(); // 这里会校验`factory`是否为 LoggerContext 类型 return (LoggerContext) factory;}`

2.如果LoggerContext已有LoggingSystem，表示已经初始化，则直接返回

`private boolean isAlreadyInitialized(LoggerContext loggerContext) { return loggerContext.getObject(LoggingSystem.class.getName()) != null;}`

3.调用父方法

4.添加FILTER到其中，因为还未初始化，不打印日志

`private static final TurboFilter FILTER = new TurboFilter() { @Override public FilterReply decide(Marker marker, ch.qos.logback.classic.Logger logger, Level level, String format, Object[] params, Throwable t) { // 一律拒绝 return FilterReply.DENY; }};`

**getStandardConfigLocations方法**

重写AbstractLoggingSystem的方法，获取logback标准的配置文件名称

`@Overrideprotected String[] getStandardConfigLocations() { return new String[] { "logback-test.groovy", "logback-test.xml", "logback.groovy", "logback.xml" };}`

#### 2.2 initialize 方法 ####

**重写LoggingSystem的方法，初始化操作**

`@Overridepublic void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) { // <1> 获得 LoggerContext 日志上下文 LoggerContext loggerContext = getLoggerContext(); // <2> 如果 LoggerContext 已有 LoggingSystem，表示已经初始化，则直接返回 if (isAlreadyInitialized(loggerContext)) { return; } // <3> 调用父方法 super.initialize(initializationContext, configLocation, logFile); // <4> 移除之前添加的 FILTER，可以开始打印日志了 loggerContext.getTurboFilterList().remove(FILTER); // <5> 标记为已初始化，往 LoggerContext 中添加一个 LoggingSystem 对象 markAsInitialized(loggerContext); if (StringUtils.hasText(System.getProperty(CONFIGURATION_FILE_PROPERTY))) { getLogger(LogbackLoggingSystem.class.getName()).warn("Ignoring '" + CONFIGURATION_FILE_PROPERTY + "' system property. Please use 'logging.config' instead."); }}`

**过程如下：**

1.调用getLoggerContext() 方法，获得LoggerContext日志上下文

2.如果LoggerContext已有LoggingSystem，表示已经初始化，则直接返回

`private boolean isAlreadyInitialized(LoggerContext loggerContext) { return loggerContext.getObject(LoggingSystem.class.getName()) != null;}`

3.调用父方法

4.移除之前添加的FILTER，可以开始打印日志了

5.调用markAsInitialized(…) 方法，标记为已初始化，往LoggerContext中添加一个LoggingSystem对象

#### 2.4 loadConfiguration方法 ####

**重写AbstractLoggingSystem的方法，加载指定的日志配置文件到日志系统中**

`@Overrideprotected void loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile) { // <1> 调用父方法 super.loadConfiguration(initializationContext, location, logFile); LoggerContext loggerContext = getLoggerContext(); // <2> 重置 LoggerContext 对象 // 这里会添加一个 LevelChangePropagator 监听器，当日志级别被修改时会立即生效，而不用重启应用 stopAndReset(loggerContext); try { // <3> 读取配置文件并解析，配置到 LoggerContext 中 configureByResourceUrl(initializationContext, loggerContext, ResourceUtils.getURL(location)); } catch (Exception ex) { throw new IllegalStateException("Could not initialize Logback logging from " + location, ex); } // <4> 判断是否发生错误，有的话抛出 IllegalStateException 异常 List<Status> statuses = loggerContext.getStatusManager().getCopyOfStatusList(); StringBuilder errors = new StringBuilder(); for (Status status : statuses) { if (status.getLevel() == Status.ERROR) { errors.append((errors.length() > 0) ? String.format("%n") : ""); errors.append(status.toString()); } } if (errors.length() > 0) { throw new IllegalStateException(String.format("Logback configuration error detected: %n%s", errors)); }}`

**过程如下：**

1.调用父方法

2.重置LoggerContext对象，这里会添加一个LevelChangePropagator监听器，当日志级别被修改时会立即生效，而不用重启应用  
`private void stopAndReset(LoggerContext loggerContext) { // 停止 loggerContext.stop(); // 重置 loggerContext.reset(); // 如果有桥接器 if (isBridgeHandlerInstalled()) { // 添加一个日志级别的监听器，能够及时更新日志级别 addLevelChangePropagator(loggerContext); }}private void addLevelChangePropagator(LoggerContext loggerContext) { LevelChangePropagator levelChangePropagator = new LevelChangePropagator(); levelChangePropagator.setResetJUL(true); levelChangePropagator.setContext(loggerContext); loggerContext.addListener(levelChangePropagator);}`

3.读取配置文件并解析，配置到LoggerContext中

`private void configureByResourceUrl(LoggingInitializationContext initializationContext, LoggerContext loggerContext, URL url) throws JoranException { if (url.toString().endsWith("xml")) { JoranConfigurator configurator = new SpringBootJoranConfigurator(initializationContext); configurator.setContext(loggerContext); configurator.doConfigure(url); } else { new ContextInitializer(loggerContext).configureByResource(url); }}`

4.判断是否发生错误，有的话抛出IllegalStateException异常

**reinitialize方法**

实现类AbstractLoggingSystem的方法，重新初始化

`@Overrideprotected void reinitialize(LoggingInitializationContext initializationContext) { // 重置 getLoggerContext().reset(); // 清空资源 getLoggerContext().getStatusManager().clear(); // 加载指定的配置文件，此时使用约定的配置文件 loadConfiguration(initializationContext, getSelfInitializationConfig(), null);}`

**loadDefaults方法**

实现类AbstractLoggingSystem的方法，没有指定的配置文件，也没有约定的配置文件，那么加载默认的配置到日志系统

`@Overrideprotected void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile) { LoggerContext context = getLoggerContext(); // <1> 重置 LoggerContext 对象 // 这里会添加一个 LevelChangePropagator 监听器，当日志级别被修改时会立即生效，而不用重启应用 stopAndReset(context); // <2> 如果开启 debug 模式则添加一个 OnConsoleStatusListener 监听器 boolean debug = Boolean.getBoolean("logback.debug"); if (debug) { StatusListenerConfigHelper.addOnConsoleListenerInstance(context, new OnConsoleStatusListener()); } // <3> 往 LoggerContext 中添加默认的日志配置 LogbackConfigurator configurator = debug ? new DebugLogbackConfigurator(context) : new LogbackConfigurator(context); Environment environment = initializationContext.getEnvironment(); context.putProperty(LoggingSystemProperties.LOG_LEVEL_PATTERN, environment.resolvePlaceholders("${logging.pattern.level:${LOG_LEVEL_PATTERN:%5p}}")); context.putProperty(LoggingSystemProperties.LOG_DATEFORMAT_PATTERN, environment.resolvePlaceholders( "${logging.pattern.dateformat:${LOG_DATEFORMAT_PATTERN:yyyy-MM-dd HH:mm:ss.SSS}}")); context.putProperty(LoggingSystemProperties.ROLLING_FILE_NAME_PATTERN, environment .resolvePlaceholders("${logging.pattern.rolling-file-name:${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz}")); // <4> 创建 DefaultLogbackConfiguration 对象，设置到`configurator`中 // 设置转换规则，例如颜色转换，空格转换 new DefaultLogbackConfiguration(initializationContext, logFile).apply(configurator); // <5> 设置日志文件，按天切割 context.setPackagingDataEnabled(true);}`

**过程如下：**

1.重置LoggerContext对象，这里会添加一个LevelChangePropagator监听器，当日志级别被修改时会立即生效，而不用重启应用

`private void stopAndReset(LoggerContext loggerContext) { // 停止 loggerContext.stop(); // 重置 loggerContext.reset(); // 如果有桥接器 if (isBridgeHandlerInstalled()) { // 添加一个日志级别的监听器，能够及时更新日志级别 addLevelChangePropagator(loggerContext); }}private void addLevelChangePropagator(LoggerContext loggerContext) { LevelChangePropagator levelChangePropagator = new LevelChangePropagator(); levelChangePropagator.setResetJUL(true); levelChangePropagator.setContext(loggerContext); loggerContext.addListener(levelChangePropagator);}`

2.如果开启debug模式则添加一个OnConsoleStatusListener监听器

3.往LoggerContext中添加默认的日志配置

4.创建DefaultLogbackConfiguration对象，设置到configurator中，设置转换规则，例如颜色转换，空格转换

5.设置日志文件，按天切割

**Log4J2LoggingSystem**

org.springframework.boot.logging.log4j2.Log4J2LoggingSystem，继承Slf4JLoggingSystem抽象类，基于 log4j2的LoggingSystem实现类

和LogbackLoggingSystem基本类似，感兴趣的小伙伴可以自己去瞧一瞧

**JavaLoggingSystem**

org.springframework.boot.logging.java.JavaLoggingSystem，继承AbstractLoggingSystem抽象类，基于 jul的LoggingSystem 实现类

逻辑比较简单，感兴趣的小伙伴可以自己去瞧一瞧

## 总结 ##

本文分析了Sping Boot初始化不同LoggingSystem日志系统的一个过程，同样是借助于Spring的ApplicationListener事件监听器机制，在启动Spring应用的过程中，例如会广播应用正在启动的事件和应用环境已准备好，然后LoggingApplicationListener监听到不同的事件会进行不同的初始化操作。

LoggingSystem日志系统主要分为logback、log4j2和JUL三种，本文主要对logback的初始化过程进行了分析，因为它是Spring Boot的默认日志框架嘛。整个的初始化过程稍微有点绕，嵌套的方法有点多，主要的小节都标注了序号。

大致流程就是先配置JUL到slf4j的桥接器，然后尝试找到指定的配置文件对日志系统进行配置，可通过 logging.config设置；没有指定则获取约定好的配置文件，例如logback.xml、log4j2.xml；还没有获取到则 Spring约定好的配置文件，例如logback-spring.xml、log4j2-spring.xml；要是还没有找到配置文件，那只能尝试加载默认的配置了。

## 最后 ##

[我这边整理了一份SpringBoot相关资料文档][Spring]、Spring系列全家桶、Java的系统化资料：（包括Java核心知识点、面试专题和21年最新的互联网真题、电子书等）有需要的朋友可以关注公众号【程序媛小琬】即可获取。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70_pic_center][]

[Spring]: https://mp.weixin.qq.com/s?__biz=Mzg2ODUzMDg1OQ==&mid=2247484196&idx=1&sn=a49343247b50371531c0969261cbc9d8&chksm=ceabace0f9dc25f66c7886e3077f1d581ebbe6a37bddda06515b6963f455212fa6883cad9fdc&token=1495605139&lang=zh_CN#rd
[Spring _.jpg]: /images/20221004/6e906dd9b6a348b7a376a3647ebeb416.png
[image.png]: /images/20221004/a9c03df829504e44ac48d22c2cb7e926.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221004/db34c7e316814491a90377ae19fa0950.png