# 精尽 Spring Boot 源码分析 —— 日志系统

# 1. 概述

在使用 Spring Boot 时，默认就已经提供了日志功能，使用 Logback 作为默认的日志框架。本文，我们就来一起研究下，Spring Boot 是如何自动初始化好日志系统的。

不了解 Spring Boot 日志功能的胖友，可以先看看 [《一起来学 SpringBoot 2.x | 第三篇：SpringBoot 日志配置》](http://www.iocoder.cn/Spring-Boot/battcn/v2-config-logs/?vip) 文章。

# 2. LoggingApplicationListener

Spring Boot 提供日志功能，关键在于 LoggingApplicationListener 类。在 [《精尽 Spring Boot 源码分析 —— ApplicationListener》](http://svip.iocoder.cn/Spring-Boot/ApplicationListener/) 中，我们已经简单介绍过它：

> `org.springframework.boot.context.logging.LoggingApplicationListener` ，实现 GenericApplicationListener 接口，实现根据配置初始化日志系统 Logger 。

## 2.1 supportsEventType

实现 `#supportsEventType(ResolvableType resolvableType)` 方法，判断是否是支持的事件类型。代码如下：

```
// LoggingApplicationListener.java

private static final Class<?>[] EVENT_TYPES = { ApplicationStartingEvent.class,
		ApplicationEnvironmentPreparedEvent.class, ApplicationPreparedEvent.class,
		ContextClosedEvent.class, ApplicationFailedEvent.class };
		
@Override
public boolean supportsEventType(ResolvableType resolvableType) {
	return isAssignableFrom(resolvableType.getRawClass(), EVENT_TYPES);
}

private boolean isAssignableFrom(Class<?> type, Class<?>... supportedTypes) {
	if (type != null) {
		for (Class<?> supportedType : supportedTypes) {
			if (supportedType.isAssignableFrom(type)) {
				return true;
			}
		}
	}
	return false;
}
```

## 2.2 supportsSourceType

实现 `#supportsSourceType(Class<?> sourceType)` 方法，判断是否是支持的事件来源。代码如下：

```
// LoggingApplicationListener.java

private static final Class<?>[] SOURCE_TYPES = { SpringApplication.class,
		ApplicationContext.class };
		
@Override
public boolean supportsSourceType(Class<?> sourceType) {
	return isAssignableFrom(sourceType, SOURCE_TYPES);
}
```

## 2.3 onApplicationEvent

实现 `#onApplicationEvent(ApplicationEvent event)` 方法，处理事件。代码如下：

```
// LoggingApplicationListener.java

@Override
public void onApplicationEvent(ApplicationEvent event) {
    // 在 Spring Boot 应用启动的时候
	if (event instanceof ApplicationStartingEvent) {
		onApplicationStartingEvent((ApplicationStartingEvent) event);
    // 在 Spring Boot 的 Environment 环境准备完成的时候
	} else if (event instanceof ApplicationEnvironmentPreparedEvent) {
		onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
    // 在 Spring Boot 容器的准备工作已经完成（并未启动）的时候
	} else if (event instanceof ApplicationPreparedEvent) {
		onApplicationPreparedEvent((ApplicationPreparedEvent) event);
    // 在 Spring Boot 容器关闭的时候
	} else if (event instanceof ContextClosedEvent
            && ((ContextClosedEvent) event).getApplicationContext().getParent() == null) {
		onContextClosedEvent();
	// 在 Spring Boot 容器启动失败的时候
	} else if (event instanceof ApplicationFailedEvent) {
		onApplicationFailedEvent();
	}
}
```

- 不同的事件，对应不同的处理方法。下文，我们一一来看。

## 2.4 onApplicationStartingEvent

`#onApplicationStartingEvent(ApplicationStartingEvent event)` 方法，代码如下：

```
// LoggingApplicationListener.java

private LoggingSystem loggingSystem;

private void onApplicationStartingEvent(ApplicationStartingEvent event) {
    // <1> 创建 LoggingSystem 对象
	this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
	// <2> LoggingSystem 的初始化的前置处理
	this.loggingSystem.beforeInitialize();
}
```

- ```
  <1>
  ```

   

  处，调用

   

  ```
  LoggingSystem#get(ClassLoader classLoader)
  ```

   

  方法，创建（获得） LoggingSystem 对象。关于这个，可以先看看

   

  「3.1 get」

   

  小节。

  - 通过 LoggingSystem 的抽象，对应不同日志框架对应的 LoggingSystem 实现，达到方便透明的接入不同的日志框架~

- `<2>` 处，调用 `LoggingSystem#beforeInitialize()` 方法，执行 LoggingSystem 的初始化的前置处理。关于这个，可以先看看 [「3.2 beforeInitialize」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 小节。

## 2.5 onApplicationEnvironmentPreparedEvent

`#onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event)` 方法，代码如下：

```
// LoggingApplicationListener.java

private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
	if (this.loggingSystem == null) {
		this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
	}
	// 初始化
	initialize(event.getEnvironment(), event.getSpringApplication().getClassLoader());
}

protected void initialize(ConfigurableEnvironment environment, ClassLoader classLoader) {
    // <1> 初始化 LoggingSystemProperties 配置
    new LoggingSystemProperties(environment).apply();
    // <2> 初始化 LogFile
    LogFile logFile = LogFile.get(environment);
    if (logFile != null) {
        logFile.applyToSystemProperties(); // <2.1>
    }
    // <3> 初始化早期的 Spring Boot Logging 级别
    initializeEarlyLoggingLevel(environment);
    // <4> 初始化 LoggingSystem 日志系统
    initializeSystem(environment, this.loggingSystem, logFile);
    // <5> 初始化最终的 Spring Boot Logging 级别
    initializeFinalLoggingLevels(environment, this.loggingSystem);
    // <6>  
    registerShutdownHookIfNecessary(environment, this.loggingSystem);
}
```

- `<1>` 处，调用 `LoggingSystemProperties#apply()` 方法，初始化 LoggingSystemProperties 配置。关于这个，可以先看看 [「4. LoggingSystemProperties」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 小节。

- ```
  <2>
  ```

   

  处，调用

   

  ```
  LogFile#get(environment)
  ```

   

  方法，创建（获得）LogFile 。关于这个，可以先看看

   

  「5. LogFile」

   

  小节。

  - `<2.1>` 处，调用 `LogFile#applyToSystemProperties()` 方法，应用 `LogFile.path` 和 `LogFile.file` 到系统属性中。

- `<3>` 处，调用 `#initializeEarlyLoggingLevel(ConfigurableEnvironment environment)` 方法，初始化早期的 Spring Boot Logging 级别。详细解析，见 [「2.5.1 initializeEarlyLoggingLevel」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

- `<4>` 处，调用 `#initializeSystem(ConfigurableEnvironment environment, LoggingSystem system, LogFile logFile)` 方法，初始化 LoggingSystem 日志系统。详细解析，见 [「2.5.2 initializeSystem」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

- `<5>` 处，调用 `#initializeFinalLoggingLevels(ConfigurableEnvironment environment, LoggingSystem system)` 方法，初始化最终的 Spring Boot Logging 级别。详细解析，见 [「2.5.3 initializeFinalLoggingLevels」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

- `<6>` 处，调用 `#registerShutdownHookIfNecessary(Environment environment, LoggingSystem loggingSystem)` 方法，注册 ShutdownHook 。详细解析，见 [「2.5.4」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

### 2.5.1 initializeEarlyLoggingLevel

`#initializeEarlyLoggingLevel(ConfigurableEnvironment environment)` 方法，初始化早期的 Spring Boot Logging 级别。代码如下：

```
// LoggingApplicationListener.java
    
private boolean parseArgs = true;
    
private LogLevel springBootLogging = null;
    
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;
		}
	}
}
    
private boolean isSet(ConfigurableEnvironment environment, String property) {
	String value = environment.getProperty(property);
	return (value != null && !value.equals("false"));
}
```

- 可以通过在启动 jar 的时候，跟上 `--debug` 或 `--trace` 。
- 也可以在配置文件中，添加 `debug=true` 或 `trace=true` 。
- 关于日志级别，可以先看看 [「6. LogLevel」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

### 2.5.2 initializeSystem

`#initializeSystem(ConfigurableEnvironment environment, LoggingSystem system, LogFile logFile)` 方法，初始化 LoggingSystem 日志系统。代码如下：

```
// LoggingApplicationListener.java
    
public static final String CONFIG_PROPERTY = "logging.config";

private void initializeSystem(ConfigurableEnvironment environment, LoggingSystem system, LogFile logFile) {
    // <1> 创建 LoggingInitializationContext 对象
    LoggingInitializationContext initializationContext = new LoggingInitializationContext(environment);
    // <2> 获得日志组件的配置文件
    String logConfig = environment.getProperty(CONFIG_PROPERTY);
    // <3> 如果没配置，则直接初始化 LoggingSystem
    if (ignoreLogConfig(logConfig)) {
        system.initialize(initializationContext, null, logFile);
    // <3> 如果有配置，先尝试加载指定配置文件，然后在初始化 LoggingSystem
    } else {
        try {
            ResourceUtils.getURL(logConfig).openStream().close();
            system.initialize(initializationContext, logConfig, logFile); // <X>
        } catch (Exception ex) {
            // NOTE: We can't use the logger here to report the problem
            System.err.println("Logging system failed to initialize " + "using configuration from '" + logConfig + "'");
            ex.printStackTrace(System.err);
            throw new IllegalStateException(ex);
        }
    }
}
```

- `<1>` 处，创建 LoggingInitializationContext 对象。其中，`org.springframework.boot.logging.LoggingInitializationContext` ，LoggingSystem 初始化时的 Context 。代码如下：

  ```
  // LoggingInitializationContext.java
  
  public class LoggingInitializationContext {
  
  	private final ConfigurableEnvironment environment;
  
  	public LoggingInitializationContext(ConfigurableEnvironment environment) {
  		this.environment = environment;
  	}
  
  	public Environment getEnvironment() {
  		return this.environment;
  	}
  
  }
  ```

  - 虽然目前只有 `environment` 属性。但是未来可以在后面增加新的参数，而无需改动 `LoggingSystem#initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)` 方法。

- `<2>` 处，从 `environment` 中获得 `"logging.config"` ，即获得日志组件的配置文件。一般情况下，我们无需配置。因为根据不同的日志系统，Spring Boot 按如下“约定规则”组织配置文件名加载日志配置文件：

| 日志框架                | 配置文件                                                     |
| :---------------------- | :----------------------------------------------------------- |
| Logback                 | logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy |
| Log4j                   | log4j-spring.properties, log4j-spring.xml, log4j.properties, log4j.xml |
| Log4j2                  | log4j2-spring.xml, log4j2.xml                                |
| JDK (Java Util Logging) | logging.properties                                           |

- `<3>` 和 `<4>` 处，调用 `LoggingSystem#initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)` 方法，初始化 LoggingSystem 日志系统。详细解析，可以先看看 [「3.3 initialize」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。
- `<3>` 和 `<4>` 处，差异点在于后者多了 `ResourceUtils.getURL(logConfig).openStream().close()` 代码块，看着有点奇怪哟？它的作用是，尝试去加载 `logConfig` 对应的配置文件，看看是否真的存在~

### 2.5.3 initializeFinalLoggingLevels

`#initializeFinalLoggingLevels(ConfigurableEnvironment environment, LoggingSystem system)` 方法，初始化最终的 Spring Boot Logging 级别。代码如下：

```
// LoggingApplicationListener.java

private void initializeFinalLoggingLevels(ConfigurableEnvironment environment, LoggingSystem system) {
    // <1> 如果 springBootLogging 非空，则设置到日志级别
    if (this.springBootLogging != null) {
        initializeLogLevel(system, this.springBootLogging);
    }
    // <2> 设置 environment 中配置的日志级别
    setLogLevels(system, environment);
}
```

- `<1>` 处，如果 `springBootLogging` 非空，则调用 `#initializeLogLevel(LoggingSystem system, LogLevel level)` 方法，设置日志级别。代码如下：

  ```
  // LoggingApplicationListener.java
  
  private static final Map<LogLevel, List<String>> LOG_LEVEL_LOGGERS;
  
  static {
  	MultiValueMap<LogLevel, String> loggers = new LinkedMultiValueMap<>();
  	loggers.add(LogLevel.DEBUG, "sql");
  	loggers.add(LogLevel.DEBUG, "web");
  	loggers.add(LogLevel.DEBUG, "org.springframework.boot");
  	loggers.add(LogLevel.TRACE, "org.springframework");
  	loggers.add(LogLevel.TRACE, "org.apache.tomcat");
  	loggers.add(LogLevel.TRACE, "org.apache.catalina");
  	loggers.add(LogLevel.TRACE, "org.eclipse.jetty");
  	loggers.add(LogLevel.TRACE, "org.hibernate.tool.hbm2ddl");
  	LOG_LEVEL_LOGGERS = Collections.unmodifiableMap(loggers);
  }
  
  protected void initializeLogLevel(LoggingSystem system, LogLevel level) {
  	List<String> loggers = LOG_LEVEL_LOGGERS.get(level);
  	if (loggers != null) {
  		for (String logger : loggers) {
  			system.setLogLevel(logger, level);
  		}
  	}
  }
  ```

  - 遍历的 `loggers` ，是 `LOG_LEVEL_LOGGERS` 中对应的 `level` 的值。
  - 调用 `LoggingSystem#setLogLevel(String loggerName, LogLevel level)` 方法，设置指定 `loggerName` 的日志级别。详细解析，见 [「3.4 setLogLevel」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

- `<2>` 处，调用 `#setLogLevels(LoggingSystem system, Environment environment)` 方法，设置 environment 中配置的日志级别。代码如下：

  ```
  // LoggingApplicationListener.java
  
  private static final ConfigurationPropertyName LOGGING_LEVEL = ConfigurationPropertyName.of("logging.level");
  private static final ConfigurationPropertyName LOGGING_GROUP = ConfigurationPropertyName.of("logging.group");
  
  private static final Bindable<Map<String, String>> STRING_STRING_MAP = Bindable.mapOf(String.class, String.class);
  private static final Bindable<Map<String, String[]>> STRING_STRINGS_MAP = Bindable.mapOf(String.class, String[].class);
  
  protected void setLogLevels(LoggingSystem system, Environment environment) {
      if (!(environment instanceof ConfigurableEnvironment)) {
          return;
      }
      // 创建 Binder 对象
      Binder binder = Binder.get(environment);
      // <1> 获得日志分组的集合
      Map<String, String[]> groups = getGroups(); // <1.1>
      binder.bind(LOGGING_GROUP, STRING_STRINGS_MAP.withExistingValue(groups)); // <1.2>
      // <2> 获得日志级别的集合
      Map<String, String> levels = binder.bind(LOGGING_LEVEL, STRING_STRING_MAP).orElseGet(Collections::emptyMap);
      // <3> 遍历 levels 集合，逐个设置日志级别
      levels.forEach((name, level) -> {
          String[] groupedNames = groups.get(name);
          if (ObjectUtils.isEmpty(groupedNames)) {
              setLogLevel(system, name, level);
          } else {
              setLogLevel(system, groupedNames, level);
          }
      });
  }
  ```

  - `<1>` 处，获得日志分组的集合。

    - `<1.1>` 处，调用 `#getGroups()` 方法，获得默认的日志分组集合。代码如下：

      ```
      // LoggingApplicationListener.java
      
      private static final Map<String, List<String>> DEFAULT_GROUP_LOGGERS;
      static {
      	MultiValueMap<String, String> loggers = new LinkedMultiValueMap<>();
      	loggers.add("web", "org.springframework.core.codec");
      	loggers.add("web", "org.springframework.http");
      	loggers.add("web", "org.springframework.web");
      	loggers.add("web", "org.springframework.boot.actuate.endpoint.web");
      	loggers.add("web", "org.springframework.boot.web.servlet.ServletContextInitializerBeans");
      	loggers.add("sql", "org.springframework.jdbc.core");
      	loggers.add("sql", "org.hibernate.SQL");
      	DEFAULT_GROUP_LOGGERS = Collections.unmodifiableMap(loggers);
      }
      
      private Map<String, String[]> getGroups() {
      	Map<String, String[]> groups = new LinkedHashMap<>();
      	DEFAULT_GROUP_LOGGERS.forEach(
      			(name, loggers) -> groups.put(name, StringUtils.toStringArray(loggers)));
      	return groups;
      }
      ```

      - 实际上，就是把我们日常配置的 `loggerName` 进行了分组。默认情况下，内置了 `sql`、`web` 分组。

    - `<1.2>` 处，从 `environment` 中读取 `logging.group` 配置的日志分组。举个例子，在配置文件里增加 `logging.group.demo=xxx.Dog,yyy.Cat` 。

  - `<2>` 处，从 `environment` 中读取 `logging.level` 配置的日志分组。举两个例子，在配置文件里添加：

    - `logging.level.web=INFO`
    - `logging.level.xxx.Dog=INFO`

  - `<3>` 处，遍历 `levels` 集合，逐个设置日志级别。涉及的方法，代码如下：

    ```
    // LoggingApplicationListener.java
    
    private void setLogLevel(LoggingSystem system, String[] names, String level) {
        // 遍历 names 数组
        for (String name : names) {
            setLogLevel(system, name, level);
        }
    }
    
    private void setLogLevel(LoggingSystem system, String name, String level) {
        try {
            // 获得 loggerName
            name = name.equalsIgnoreCase(LoggingSystem.ROOT_LOGGER_NAME) ? null : name;
            // 设置日志级别
            system.setLogLevel(name, coerceLogLevel(level));
        } catch (RuntimeException ex) {
            this.logger.error("Cannot set level '" + level + "' for '" + name + "'");
        }
    }
    
    /**
     * @param level 日志级别字符串
     * @return 将字符串转换成 {@link LogLevel}
     */
    private LogLevel coerceLogLevel(String level) {
        String trimmedLevel = level.trim();
        if ("false".equalsIgnoreCase(trimmedLevel)) { // false => OFF
            return LogLevel.OFF;
        }
        return LogLevel.valueOf(trimmedLevel.toUpperCase(Locale.ENGLISH));
    }
    ```

    - 比较简单，胖友瞅瞅~

### 2.5.4 registerShutdownHookIfNecessary

`#registerShutdownHookIfNecessary(Environment environment, LoggingSystem loggingSystem)` 方法，注册 ShutdownHook 。代码如下：

```
// LoggingApplicationListener.java

/**
 * The name of the Spring property that controls the registration of a shutdown hook
 * to shut down the logging system when the JVM exits.
 * @see LoggingSystem#getShutdownHandler
 */
public static final String REGISTER_SHUTDOWN_HOOK_PROPERTY = "logging.register-shutdown-hook";

private void registerShutdownHookIfNecessary(Environment environment, LoggingSystem loggingSystem) {
    // 获得 logging.register-shutdown-hook 对应的配置值
    boolean registerShutdownHook = environment.getProperty(REGISTER_SHUTDOWN_HOOK_PROPERTY, Boolean.class, false);
    // 如果开启
    if (registerShutdownHook) {
        // <x> 获得 shutdownHandler 钩子
        Runnable shutdownHandler = loggingSystem.getShutdownHandler();
        // 注册 ShutdownHook(
        if (shutdownHandler != null
                && shutdownHookRegistered.compareAndSet(false, true)) {
            registerShutdownHook(new Thread(shutdownHandler));
        }
    }
}

void registerShutdownHook(Thread shutdownHook) {
    Runtime.getRuntime().addShutdownHook(shutdownHook);
}
```

- `<X>` 处，所注册的 ShutdownHook ，通过调用 `LoggingSystem#getShutdownHandler()` 方法，进行获得。详细解析，见 [「3.5 getShutdownHandler」](https://svip.iocoder.cn/Spring-Boot/logger-system/#)。

## 2.6 onApplicationPreparedEvent

`#onApplicationPreparedEvent(ApplicationPreparedEvent event)` 方法，代码如下：

```
// LoggingApplicationListener.java

/**
 * The name of the {@link LoggingSystem} bean.
 */
public static final String LOGGING_SYSTEM_BEAN_NAME = "springBootLoggingSystem";

private void onApplicationPreparedEvent(ApplicationPreparedEvent event) {
	ConfigurableListableBeanFactory beanFactory = event.getApplicationContext().getBeanFactory();
	if (!beanFactory.containsBean(LOGGING_SYSTEM_BEAN_NAME)) {
		beanFactory.registerSingleton(LOGGING_SYSTEM_BEAN_NAME, this.loggingSystem);
	}
}
```

- 将创建的 LoggingSystem 对象，注册到 Spring 容器中。

## 2.7 onContextClosedEvent

`#onContextClosedEvent()` 方法，代码如下：

```
// LoggingApplicationListener.java

private void onContextClosedEvent() {
	if (this.loggingSystem != null) {
		this.loggingSystem.cleanUp();
	}
}
```

- 调用 `LoggingSystem#cleanUp()` 方法，执行清理。详细解析，见 [「3.6 cleanUp」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

## 2.8 onApplicationFailedEvent

`#onApplicationFailedEvent()` 方法，代码如下：

```
// LoggingApplicationListener.java

private void onApplicationFailedEvent() {
	if (this.loggingSystem != null) {
		this.loggingSystem.cleanUp();
	}
}
```

> 至此，我们需要来看看 LoggingSystem 的实现类。具体的，可以跳到 [「7. LoggingSystem 的实现类」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

# 3. LoggingSystem

`org.springframework.boot.logging.LoggingSystem` ，日志系统抽象类。每个日志框架，都会对应一个实现类。如下图所示：[![LoggingSystem 实现类](15-Spring Boot 源码分析-日志系统.assets/01.jpg)](http://static.iocoder.cn/images/Spring-Boot/2021-02-01-new/01.jpg)LoggingSystem 实现类

## 3.1 get

`#get(ClassLoader classLoader)` 方法，创建（获得） LoggingSystem 对象。代码如下：

```
// LoggingApplicationListener.java

/**
 * A System property that can be used to indicate the {@link LoggingSystem} to use.
 */
public static final String SYSTEM_PROPERTY = LoggingSystem.class.getName();

/**
 * The value of the {@link #SYSTEM_PROPERTY} that can be used to indicate that no
 * {@link LoggingSystem} should be used.
 */
public static final String NONE = "none";

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);
}

public static LoggingSystem get(ClassLoader classLoader) {
    // <1> 从系统参数 org.springframework.boot.logging.LoggingSystem 获得 loggingSystem 类型
    String loggingSystem = System.getProperty(SYSTEM_PROPERTY);
    // <2> 如果非空，说明配置了
    if (StringUtils.hasLength(loggingSystem)) {
        // <2.1> 如果是 none ，则创建 NoOpLoggingSystem 对象
        if (NONE.equals(loggingSystem)) {
            return new NoOpLoggingSystem();
        }
        // <2.2> 获得 loggingSystem 对应的 LoggingSystem 类，进行创建对象
        return get(classLoader, loggingSystem);
    }
    // <3> 如果为空，说明未配置，则顺序查找 SYSTEMS 中的类。如果存在指定类，则创建该类。
    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>` 处，从系统参数 `org.springframework.boot.logging.LoggingSystem` 获得 loggingSystem 类型。

- `<2>` 处，如果非空，说明配置了。

  - `<2.1>` 处，如果是 `none` ，则创建 NoOpLoggingSystem 对象。

  - `<2.2>` 处，调用 `#get(ClassLoader classLoader, String loggingSystemClass)` 方法，获得 `loggingSystem` 对应的 LoggingSystem 类，进行创建对象。代码如下：

    ```
    // LoggingSystem.java
    
    private static LoggingSystem get(ClassLoader classLoader, String loggingSystemClass) {
    	try {
    		Class<?> systemClass = ClassUtils.forName(loggingSystemClass, classLoader);
    		return (LoggingSystem) systemClass.getConstructor(ClassLoader.class).newInstance(classLoader);
    	} catch (Exception ex) {
    		throw new IllegalStateException(ex);
    	}
    }
    ```

    - `systemClass` 中的 VALUES ，就是 `loggingSystem` 对应的类。

- `<3>` 处，如果为空，说明未配置，则顺序查找 `SYSTEMS` 中的类。如果存在指定类，则创建该类。

## 3.2 beforeInitialize

`#beforeInitialize()` **抽象**方法，初始化的前置方法。代码如下：

```
// LoggingSystem.java

/**
 * 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();
```

## 3.3 initialize

`#initialize()` 方法，初始化。代码如下：

```
// LoggingSystem.java

/**
 * 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) {
}
```

- 目前是个空方法，需要子类来实现。
- 我们先不着急看子类的实现，等后面继续看。

## 3.4 setLogLevel

`#setLogLevel(String loggerName, LogLevel level)` 方法，设置指定 `loggerName` 的日志级别。代码如下：

```
// LoggingSystem.java

/**
 * Sets the logging level for a given logger.
 * @param loggerName the name of the logger to set ({@code null} can be used for the
 * root logger).
 * @param level the log level ({@code null} can be used to remove any custom level for
 * the logger and use the default configuration instead)
 */
public void setLogLevel(String loggerName, LogLevel level) {
	throw new UnsupportedOperationException("Unable to set log level");
}
```

- 目前是个空方法，需要子类来实现。
- 我们先不着急看子类的实现，等后面继续看。

## 3.5 getShutdownHandler

`#getShutdownHandler()` 方法，获得 ShutdownHook 的 Runnable 对象。代码如下：

```
// LoggingSystem.java

/**
 * Returns a {@link Runnable} that can handle shutdown of this logging system when the
 * JVM exits. The default implementation returns {@code null}, indicating that no
 * shutdown is required.
 * @return the shutdown handler, or {@code null}
 */
public Runnable getShutdownHandler() {
	return null;
}
```

- 目前是个空方法，需要子类来实现。
- 我们先不着急看子类的实现，等后面继续看。

## 3.6 cleanUp

`#cleanUp()` 方法，清理。代码如下：

```
// LoggingSystem.java

/**
 * Clean up the logging system. The default implementation does nothing. Subclasses
 * should override this method to perform any logging system-specific cleanup.
 */
public void cleanUp() {
}
```

- 目前是个空方法，需要子类来实现。
- 我们先不着急看子类的实现，等后面继续看。

# 4. LoggingSystemProperties

`org.springframework.boot.logging.LoggingSystemProperties` ，LoggingSystem 的配置类。

## 4.1 构造方法

```
// LoggingSystemProperties.java

private final Environment environment;

public LoggingSystemProperties(Environment environment) {
	Assert.notNull(environment, "Environment must not be null");
	this.environment = environment;
}
```

## 4.2 apply

`#apply()` 方法，解析 `environment` 的配置变量到系统属性中。代码如下：

```
// LoggingSystemProperties.java

public void apply() {
    apply(null);
}

public void apply(LogFile logFile) {
    // <1> 获得 PropertyResolver 对象
    PropertyResolver resolver = getPropertyResolver();
    // <2> 解析配置文件到系统属性中
    setSystemProperty(resolver, EXCEPTION_CONVERSION_WORD, "exception-conversion-word");
    setSystemProperty(PID_KEY, new ApplicationPid().toString()); // 应用进程编号
    setSystemProperty(resolver, CONSOLE_LOG_PATTERN, "pattern.console");
    setSystemProperty(resolver, FILE_LOG_PATTERN, "pattern.file");
    setSystemProperty(resolver, FILE_MAX_HISTORY, "file.max-history");
    setSystemProperty(resolver, FILE_MAX_SIZE, "file.max-size");
    setSystemProperty(resolver, LOG_LEVEL_PATTERN, "pattern.level");
    setSystemProperty(resolver, LOG_DATEFORMAT_PATTERN, "pattern.dateformat");
    // <3> 如果 logFile 非空，则应用配置
    if (logFile != null) {
        logFile.applyToSystemProperties();
    }
}
```

- ```
  <1>
  ```

   

  处，调用

   

  ```
  #getPropertyResolver()
  ```

   

  方法，获得 PropertyResolver 对象。代码如下：

  ```
  // LoggingSystemProperties.java
  
  private PropertyResolver getPropertyResolver() {
  	if (this.environment instanceof ConfigurableEnvironment) {
  		PropertySourcesPropertyResolver resolver = new PropertySourcesPropertyResolver(((ConfigurableEnvironment) this.environment).getPropertySources());
  		resolver.setIgnoreUnresolvableNestedPlaceholders(true);
  		return resolver;
  	}
  	return this.environment;
  }
  ```

- `<2>` 处，调用 `#setSystemProperty(PropertyResolver resolver, String systemPropertyName, String propertyName)` 方法，解析配置文件到系统属性中。代码如下：

  ```
  // LoggingSystemProperties.java
  
  public static final String PID_KEY = "PID";
  public static final String EXCEPTION_CONVERSION_WORD = "LOG_EXCEPTION_CONVERSION_WORD";
  public static final String LOG_FILE = "LOG_FILE";
  public static final String LOG_PATH = "LOG_PATH";
  public static final String FILE_LOG_PATTERN = "FILE_LOG_PATTERN";
  public static final String FILE_MAX_HISTORY = "LOG_FILE_MAX_HISTORY";
  public static final String FILE_MAX_SIZE = "LOG_FILE_MAX_SIZE";
  public static final String LOG_LEVEL_PATTERN = "LOG_LEVEL_PATTERN";
  public static final String LOG_DATEFORMAT_PATTERN = "LOG_DATEFORMAT_PATTERN";
  
  private void setSystemProperty(PropertyResolver resolver, String systemPropertyName, String propertyName) {
  	setSystemProperty(systemPropertyName, resolver.getProperty("logging." + propertyName)); // <X>
  }
  
  private void setSystemProperty(String name, String value) {
  	if (System.getProperty(name) == null && value != null) {
  		System.setProperty(name, value);
  	}
  }
  ```

  - `<X>` 处，读取的是 `environment` 中的 `logging.` 开头的配置属性。

# 5. LogFile

`org.springframework.boot.logging.LogFile` ，日志文件。

## 5.1 构造方法

```
// LogFile.java

/**
 * 文件名
 */
private final String file;
/**
 * 文件路径
 */
private final String path;
```

## 5.2 applyToSystemProperties

`#applyToSystemProperties()` 方法，应用 `file`、`path` 到系统属性。代码如下：

```
// LogFile.java

public static final String FILE_NAME_PROPERTY = "logging.file.name";
public static final String FILE_PATH_PROPERTY = "logging.file.path";

public void applyToSystemProperties() {
	applyTo(System.getProperties());
}

public void applyTo(Properties properties) {
	put(properties, LoggingSystemProperties.LOG_PATH, this.path);
	put(properties, LoggingSystemProperties.LOG_FILE, toString());
}
```

- ```
  #toString()
  ```

   

  方法，返回文件名。代码如下：

  ```
  // LogFile.java
  
  @Override
  public String toString() {
  	if (StringUtils.hasLength(this.file)) {
  		return this.file;
  	}
  	return new File(this.path, "spring.log").getPath();
  }
  ```

- ```
  #put(Properties properties, String key, String value)
  ```

   

  方法，添加属性值到系统属性。代码如下：

  ```
  // LogFile.java
  
  private void put(Properties properties, String key, String value) {
  	if (StringUtils.hasLength(value)) {
  		properties.put(key, value);
  	}
  }
  ```

## 5.3 get

`#get(PropertyResolver propertyResolver)` 方法，获得（创建）LogFile 对象。代码如下：

```
// LogFile.java

public static LogFile get(PropertyResolver propertyResolver) {
    // <1> 获得 file 和 path 属性
	String file = getLogFileProperty(propertyResolver, FILE_NAME_PROPERTY, FILE_PROPERTY);
	String path = getLogFileProperty(propertyResolver, FILE_PATH_PROPERTY, PATH_PROPERTY);
	// <2> 创建 LogFile 对象
	if (StringUtils.hasLength(file) || StringUtils.hasLength(path)) {
		return new LogFile(file, path);
	}
	return null;
}
```

- ```
  <1>
  ```

   

  处，调用

   

  ```
  #getLogFileProperty(PropertyResolver propertyResolver, String propertyName, String deprecatedPropertyName)
  ```

   

  方法，获得

   

  ```
  file
  ```

   

  和

   

  ```
  path
  ```

   

  属性。代码如下：

  ```
  // LogFile.java
  
  private static String getLogFileProperty(PropertyResolver propertyResolver, String propertyName, String deprecatedPropertyName) {
  	String property = propertyResolver.getProperty(propertyName);
  	if (property != null) {
  		return property;
  	}
  	return propertyResolver.getProperty(deprecatedPropertyName);
  }
  ```

- `<2>` 处，创建 LogFile 对象。

# 6. LogLevel

`org.springframework.boot.logging.LogLevel` ，Spring Boot 日志枚举类。代码如下：

```
// LogLevel.java

public enum LogLevel {

	TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF

}
```

每个日志框架，都有其日志级别。通过 LogLevel 枚举类，和它们映射。

# 7. LoggingSystem 的实现类

## 7.1 NoOpLoggingSystem

NoOpLoggingSystem ，是 LoggingSystem 的内部静态类，继承 LoggingSystem 类，空操作的 LoggingSystem 实现类，用于禁用日志系统的时候。代码如下：

```
// LoggingSystem#NoOpLoggingSystem.java

static class NoOpLoggingSystem extends LoggingSystem {

	@Override
	public void beforeInitialize() {

	}

	@Override
	public void setLogLevel(String loggerName, LogLevel level) {

	}

	@Override
	public List<LoggerConfiguration> getLoggerConfigurations() {
		return Collections.emptyList();
	}

	@Override
	public LoggerConfiguration getLoggerConfiguration(String loggerName) {
		return null;
	}

}
```

## 7.2 AbstractLoggingSystem

`org.springframework.boot.logging.AbstractLoggingSystem` ，继承 LoggingSystem 抽象类，是 LoggingSystem 的抽象基类。

### 7.2.1 构造方法

```
// AbstractLoggingSystem.java

private final ClassLoader classLoader;

public AbstractLoggingSystem(ClassLoader classLoader) {
	this.classLoader = classLoader;
}
```

### 7.2.2 initialize

实现 `#initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)` 方法，提供模板化的初始化逻辑。代码如下：

```
// AbstractLoggingSystem.java

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

- `<1>` 处，有自定义的配置文件，则调用 `#initializeWithSpecificConfig(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)` 方法，使用指定配置文件进行初始化。详细解析，见 [「7.2.2.1 initializeWithSpecificConfig」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。
- `<2>` 处，无自定义的配置文件，则调用 `#initializeWithConventions(LoggingInitializationContext initializationContext, LogFile logFile)` 方法，使用约定配置文件进行初始化。详细解析，见 [7.2.2.2 initializeWithConventions](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

#### 7.2.2.1 initializeWithSpecificConfig

`#initializeWithSpecificConfig(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)` 方法，使用指定配置文件进行初始化。代码如下：

```
// AbstractLoggingSystem.java

private void initializeWithSpecificConfig(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) {
    // <1> 获得配置文件（可能有占位符）
    configLocation = SystemPropertyUtils.resolvePlaceholders(configLocation);
    // <2> 加载配置文件
    loadConfiguration(initializationContext, configLocation, logFile);
}
```

- `<1>` 处，获得配置文件（可能有占位符）。

- ```
  <2>
  ```

   

  处，调用

   

  ```
  #loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile))
  ```

   

  抽象

  方法，加载配置文件。代码如下：

  ```
  // AbstractLoggingSystem.java
  
  /**
   * 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);
  ```

#### 7.2.2.2 initializeWithConventions

`#initializeWithConventions(LoggingInitializationContext initializationContext, LogFile logFile)` 方法，使用约定配置文件进行初始化。代码如下：

```
// AbstractLoggingSystem.java

private void initializeWithConventions(LoggingInitializationContext initializationContext, LogFile logFile) {
    // <1> 获得约定配置文件
    String config = getSelfInitializationConfig();
    // <2> 如果获取到，结果 logFile 为空，则重新初始化
    if (config != null && logFile == null) {
        // self initialization has occurred, reinitialize in case of property changes
        reinitialize(initializationContext);
        return;
    }
    // <3> 如果获取不到，则尝试获得约定配置文件（带 spring 后缀）
    if (config == null) {
        config = getSpringInitializationConfig();
    }
    // <4> 如果获取到，则加载配置文件
    if (config != null) {
        loadConfiguration(initializationContext, config, logFile);
        return;
    }
    // <5> 如果获取不到，则加载默认配置
    loadDefaults(initializationContext, logFile);
}
```

- `<1>` 处，调用 `#getSelfInitializationConfig()` 方法，获得约定配置文件。代码如下：

  ```
  // AbstractLoggingSystem.java
  
  protected String getSelfInitializationConfig() {
  	return findConfig(getStandardConfigLocations());
  }
  
  protected abstract String[] getStandardConfigLocations();
  
  private String findConfig(String[] locations) {
      // 遍历 locations 数组，逐个判断是否存在。若存在，则返回
      for (String location : locations) {
          ClassPathResource resource = new ClassPathResource(location, this.classLoader);
          if (resource.exists()) {
              return "classpath:" + location;
          }
      }
      return null;
  }
  ```

  - `#getStandardConfigLocations()` **抽象**方法，获得约定的配置文件。例如说：LogbackLoggingSystem 返回的是 `"logback-test.groovy"`、`"logback-test.xml"`、 `"logback.groovy"`、`"logback.xml"` 。

- `<2>` 处，如果获取到，结果 `logFile` 为空，则调用 `#reinitialize(LoggingInitializationContext initializationContext)` 方法，重新初始化。代码如下：

  ```
  // AbstractLoggingSystem.java
  
  /**
   * Reinitialize the logging system if required. Called when
   * {@link #getSelfInitializationConfig()} is used and the log file hasn't changed. May
   * be used to reload configuration (for example to pick up additional System
   * properties).
   * @param initializationContext the logging initialization context
   */
  protected void reinitialize(LoggingInitializationContext initializationContext) {
  }
  ```

  - 一般情况下，`logFile` 非空~

- `<3>` 处，如果获取不到，则调用 `#getSpringInitializationConfig()` 方法，尝试获得约定配置文件（带 `-spring` 后缀）。代码如下：

  ```
  // AbstractLoggingSystem.java
  
  /**
   * Return any spring specific initialization config that should be applied. By default
   * this method checks {@link #getSpringConfigLocations()}.
   * @return the spring initialization config or {@code null}
   */
  protected String getSpringInitializationConfig() {
  	return findConfig(getSpringConfigLocations());
  }
  
  /**
   * Return the spring config locations for this system. By default this method returns
   * a set of locations based on {@link #getStandardConfigLocations()}.
   * @return the spring config locations
   * @see #getSpringInitializationConfig()
   */
  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;
  }
  ```

  - 例如说：LogbackLoggingSystem 返回的是 `"logback-test-spring.groovy"`、`"logback-test-spring.xml"`、 `"logback-spring.groovy"`、`"logback-spring.xml"` 。

- `<4>` 处，如果获取到，则调用 `#loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile))` **抽象**方法，加载配置文件。

- ```
  <5>
  ```

   

  处，如果获取不到，则调用

   

  ```
  #loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile)
  ```

   

  抽象

  方法，加载默认配置。代码如下：

  ```
  // AbstractLoggingSystem.java
  
  /**
   * Load sensible defaults for the logging system.
   * @param initializationContext the logging initialization context
   * @param logFile the file to load or {@code null} if no log file is to be written
   */
  protected abstract void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile);
  ```

### 7.2.3 LogLevels

LogLevels ，是 AbstractLoggingSystem 的内部静态类，用于 Spring Boot LogLevel 和日志框架的 LogLevel 做映射。代码如下：

```
// AbstractLoggingSystem#LogLevels.java

/**
 * Maintains a mapping between native levels and {@link LogLevel}.
 *
 * @param <T> the native level type
 */
protected static class LogLevels<T> {

	private final Map<LogLevel, T> systemToNative;

	private final Map<T, LogLevel> nativeToSystem;

	public LogLevels() {
		this.systemToNative = new EnumMap<>(LogLevel.class);
		this.nativeToSystem = new HashMap<>();
	}

	public void map(LogLevel system, T nativeLevel) {
		if (!this.systemToNative.containsKey(system)) {
			this.systemToNative.put(system, nativeLevel);
		}
		if (!this.nativeToSystem.containsKey(nativeLevel)) {
			this.nativeToSystem.put(nativeLevel, system);
		}
	}

	public LogLevel convertNativeToSystem(T level) {
		return this.nativeToSystem.get(level);
	}

	public T convertSystemToNative(LogLevel level) {
		return this.systemToNative.get(level);
	}

	public Set<LogLevel> getSupported() {
		return new LinkedHashSet<>(this.nativeToSystem.values());
	}

}
```

## 7.3 Slf4JLoggingSystem

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

### 7.3.1 beforeInitialize

重写 `#beforeInitialize()` 方法，代码如下：

```
// Slf4JLoggingSystem.java

@Override
public void beforeInitialize() {
    // 父方法
    super.beforeInitialize();
    // <1> 配置 JUL 的桥接处理器
    configureJdkLoggingBridgeHandler();
}
```

- 因为艿艿没有特别完整的了解过日志框架，所以下面的解释，更多凭的是“直觉”！如果有错误的地方，给艿艿星球留言哈~
- `<1>` 处，调用 `#configureJdkLoggingBridgeHandler()` 方法，配置 JUL 的桥接处理器。详细解析，见 [「7.3.1.1 configureJdkLoggingBridgeHandler」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

#### 7.3.1.1 configureJdkLoggingBridgeHandler

`#configureJdkLoggingBridgeHandler()` 方法，配置 JUL 的桥接处理器。代码如下：

```
// Slf4JLoggingSystem.java
    
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>` 处，调用 `#isBridgeJulIntoSlf4j()` 方法，判断 JUL 是否桥接到 SLF4J 了。代码如下：

  ```
  // Slf4JLoggingSystem.java
  
  private static final String BRIDGE_HANDLER = "org.slf4j.bridge.SLF4JBridgeHandler";
  
  /**
   * Return whether bridging JUL into SLF4J or not.
   * @return whether bridging JUL into SLF4J or not
   * @since 2.0.4
   */
  protected final boolean isBridgeJulIntoSlf4j() {
  	return isBridgeHandlerAvailable() // 判断是否存在 SLF4JBridgeHandler 类
              && isJulUsingASingleConsoleHandlerAtMost(); // 判断是否 JUL 只有 ConsoleHandler 处理器被创建了
  }
  
  protected final boolean isBridgeHandlerAvailable() {
  	return ClassUtils.isPresent(BRIDGE_HANDLER, getClassLoader());
  }
  
  private boolean isJulUsingASingleConsoleHandlerAtMost() {
  	Logger rootLogger = LogManager.getLogManager().getLogger("");
  	Handler[] handlers = rootLogger.getHandlers();
  	return handlers.length == 0
  			|| (handlers.length == 1 && handlers[0] instanceof ConsoleHandler);
  }
  ```

  - 第一个方法，调用后面的两个方法判断~

- `<2>` 处，调用 `#removeJdkLoggingBridgeHandler()` 方法，移除 JUL 桥接处理器。代码如下：

  ```
  // Slf4JLoggingSystem.java
  
  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
  	}
  }
  ```

  - 移除 JUL 的 ConsoleHandler ，卸载 SLF4JBridgeHandler 。

- `<3>` 处，会重新安装 SLF4JBridgeHandler。

### 7.3.2 cleanUp

重写 `#cleanUp()` 方法，代码如下：

```
// Slf4JLoggingSystem.java

@Override
public void cleanUp() {
    // 判断 JUL 是否桥接到 SLF4J 了
    if (isBridgeHandlerAvailable()) {
        // 移除 JUL 桥接处理器
        removeJdkLoggingBridgeHandler();
    }
}
```

### 7.3.3 loadConfiguration

重写 `#loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile)` 方法，代码如下：

```
// Slf4JLoggingSystem.java

@Override
protected void loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile) {
	Assert.notNull(location, "Location must not be null");
	if (initializationContext != null) {
		applySystemProperties(initializationContext.getEnvironment(), logFile);
	}
}
```

- 调用 `#applySystemProperties(Environment environment, LogFile logFile)` 方法，应用 `environment` 和 `logFile` 的属性，到系统属性种。在 [「4.2 apply」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中，已经详细解析。
- 不过有一点，搞不懂，为什么这么实现。

## 7.4 LogbackLoggingSystem

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

### 7.4.1 beforeInitialize

重写 `#beforeInitialize()` 方法，代码如下：

```
// LogbackLoggingSystem.java

@Override
public void beforeInitialize() {
    // <1.1> 获得 LoggerContext 对象
    LoggerContext loggerContext = getLoggerContext();
    // <1.2> 如果已经初始化过，则直接返回
    if (isAlreadyInitialized(loggerContext)) {
        return;
    }
    // <2> 调用父方法
    super.beforeInitialize();
    // <3> 添加 FILTER 到其中
    loggerContext.getTurboFilterList().add(FILTER);
}
```

- ```
  <1.1>
  ```

   

  处，调用

   

  ```
  #getLoggerContext()
  ```

   

  方法，获得 LoggerContext 对象。代码如下：

  ```
  // LogbackLoggingSystem.java
  
  private LoggerContext getLoggerContext() {
  	ILoggerFactory factory = StaticLoggerBinder.getSingleton().getLoggerFactory();
  	Assert.isInstanceOf(LoggerContext.class, factory,
  			String.format(
  					"LoggerFactory is not a Logback LoggerContext but Logback is on "
  							+ "the classpath. Either remove Logback or the competing "
  							+ "implementation (%s loaded from %s). If you are using "
  							+ "WebLogic you will need to add 'org.slf4j' to "
  							+ "prefer-application-packages in WEB-INF/weblogic.xml",
  					factory.getClass(), getLocation(factory)));
  	return (LoggerContext) factory;
  }
  ```

- ```
  <1.2>
  ```

   

  处，调用

   

  ```
  #isAlreadyInitialized(LoggerContext loggerContext)
  ```

   

  方法，判断如果已经初始化过，则直接返回。代码如下：

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

- `<2>` 处，调用父方法。

- `<3>` 处，添加 `FILTER` 到 `loggerContext` 其中。代码如下：

  ```
  // LogbackLoggingSystem.java
  
  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;
  	}
  
  };
  ```

  - 因为此时，Logback 并未初始化好，所以全部返回 `FilterReply.DENY` 。即，先不打印日志。

### 7.4.2 getStandardConfigLocations

实现 `#getStandardConfigLocations()` 方法，获得约定的配置文件的数组。代码如下：

```
// LogbackLoggingSystem.java

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

### 7.4.3 initialize

重写 `#initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)` 方法，代码如下：

```
// LogbackLoggingSystem.java

private static final String CONFIGURATION_FILE_PROPERTY = "logback.configurationFile";

@Override
public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) {
    // <1> 如果已经初始化，则返回
    LoggerContext loggerContext = getLoggerContext();
    if (isAlreadyInitialized(loggerContext)) {
        return;
    }
    // <2> 调用父方法
    super.initialize(initializationContext, configLocation, logFile);
    // <3> 移除 FILTER
    loggerContext.getTurboFilterList().remove(FILTER);
    // <4> 标记已经初始化
    markAsInitialized(loggerContext);
    // <5> 如果配置了 logback.configurationFile ，则打印日志
    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>` 处，如果已经初始化，则返回。

- `<2>` 处，调用父方法，进行初始化。

- `<3>` 处，从 `loggerContext` 中，移除 `FILTER` 。😈 如果不移除，就一直打印不出日志列。

- `<4>` 处，调用 `#markAsInitialized(LoggerContext loggerContext)` 方法，标记已经初始化。代码如下：

  ```
  // LogbackLoggingSystem.java
  
  private void markAsInitialized(LoggerContext loggerContext) {
  	loggerContext.putObject(LoggingSystem.class.getName(), new Object());
  }
  ```

- `<5>` 处，如果配置了 `"logback.configurationFile"` ，则打印日志。

#### 7.4.3.1 loadConfiguration

实现 `#loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile)` 方法，代码如下：

```
// LogbackLoggingSystem.java

@Override
protected void loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile) {
    // <1> 调用父方法
    super.loadConfiguration(initializationContext, location, logFile);
    // <2> 重置
    LoggerContext loggerContext = getLoggerContext();
    stopAndReset(loggerContext);
    // <3> 读取配置文件，并进行配置
    try {
        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>` 处，调用 `#stopAndReset(LoggerContext loggerContext)` 方法，重置。代码如下：

  ```
  // LogbackLoggingSystem.java
  
  private void stopAndReset(LoggerContext loggerContext) {
      // 停止
      loggerContext.stop();
      // 重置
      loggerContext.reset();
      // 如果是 SLF4J 桥接
      if (isBridgeHandlerInstalled()) {
          // 添加 LevelChangePropagator
          addLevelChangePropagator(loggerContext);
      }
  }
  
  private boolean isBridgeHandlerInstalled() {
      if (!isBridgeHandlerAvailable()) {
          return false;
      }
      java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger("");
      Handler[] handlers = rootLogger.getHandlers();
      // 判断有 SLF4JBridgeHandler 唯一元素
      return handlers.length == 1 && handlers[0] instanceof SLF4JBridgeHandler;
  }
  
  private void addLevelChangePropagator(LoggerContext loggerContext) {
      // 创建 LevelChangePropagator 对象（见 https://cloud.tencent.com/developer/ask/174323 说明）
      LevelChangePropagator levelChangePropagator = new LevelChangePropagator();
      // 设置属性
      levelChangePropagator.setResetJUL(true);
      levelChangePropagator.setContext(loggerContext);
      // 添加 LevelChangePropagator 到 loggerContext 中
      loggerContext.addListener(levelChangePropagator);
  }
  ```

  - 通过阅读 https://cloud.tencent.com/developer/ask/174323 文章，我们能弄懂这里为什么要使用 LevelChangePropagator ，以及 [「7.3.1.1 configureJdkLoggingBridgeHandler」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 处的原因。

- `<3>` 处，调用 `#configureByResourceUrl(LoggingInitializationContext initializationContext, LoggerContext loggerContext, URL url)` 方法，读取配置文件，并进行配置。代码如下：

  ```
  // LogbackLoggingSystem.java
  
  private void configureByResourceUrl(LoggingInitializationContext initializationContext, LoggerContext loggerContext, URL url) throws JoranException {
      // <X> 如果是 xml 配置格式，则使用 SpringBootJoranConfigurator
      if (url.toString().endsWith("xml")) {
          JoranConfigurator configurator = new SpringBootJoranConfigurator(initializationContext);
          configurator.setContext(loggerContext);
          configurator.doConfigure(url);
      // 如果是其它格式，则使用 ContextInitializer
      } else {
          new ContextInitializer(loggerContext).configureByResource(url);
      }
  }
  ```

  - `<X>` 处，如果是 Logback xml 配置格式，则使用 SpringBootJoranConfigurator 类。
  - 至此，Logback 配置文件，就已经被读完落。

- `<4>` 处，判断是否发生错误。如果有，则抛出 IllegalStateException 异常。

##### 7.4.3.1.1 SpringBootJoranConfigurator

`org.springframework.boot.logging.logback.SpringBootJoranConfigurator` ，继承 JoranConfigurator 类，增加 Spring Boot 自定义的标签。代码如下：

```
// SpringBootJoranConfigurator.java

class SpringBootJoranConfigurator extends JoranConfigurator {

	private LoggingInitializationContext initializationContext;

	SpringBootJoranConfigurator(LoggingInitializationContext initializationContext) {
		this.initializationContext = initializationContext;
	}

	@Override
	public void addInstanceRules(RuleStore rs) {
	    // 调用父方法
		super.addInstanceRules(rs);
		Environment environment = this.initializationContext.getEnvironment();
		rs.addRule(new ElementSelector("configuration/springProperty"), new SpringPropertyAction(environment));
		rs.addRule(new ElementSelector("*/springProfile"), new SpringProfileAction(environment));
		rs.addRule(new ElementSelector("*/springProfile/*"), new NOPAction());
	}

}
```

- 不了解的胖友，可以先看看 [《SpringBoot 中 logback.xml 使用 application.yml 中属性》](https://www.cnblogs.com/jianliang-Wu/p/8945343.html) 文章。
- [`org.springframework.boot.logging.logback.SpringProfileAction`](https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/SpringProfileAction.java) ，处理 `<springProfile />` 标签。
- [`org.springframework.boot.logging.logback.SpringPropertyAction`](https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/SpringPropertyAction.java) ，处理 `<springProperty />` 标签。

#### 7.4.3.2 reinitialize

实现 `#reinitialize(LoggingInitializationContext initializationContext)` 方法，代码如下：

```
// LogbackLoggingSystem.java

@Override
protected void reinitialize(LoggingInitializationContext initializationContext) {
	// <1> 重置
	getLoggerContext().reset();
	// <2> 清空 StatusManager
	getLoggerContext().getStatusManager().clear();
	// <3> 加载配置
	loadConfiguration(initializationContext, getSelfInitializationConfig(), null);
}
```

- `<1>` 处，重置。
- `<2>` 处，清空 StatusManager 。
- `<3>` 处，调用 `#loadConfiguration(LoggingInitializationContext initializationContext, String location, LogFile logFile)` 方法，加载配置。此时，使用的是约定的 Logback 配置文件。

#### 7.4.3.3 loadDefaults

实现 `#loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile)` 方法，代码如下：

```
// LogbackLoggingSystem.java

@Override
protected void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile) {
    // <1> 重置
    LoggerContext context = getLoggerContext();
    stopAndReset(context);
    // <2> 创建 LogbackConfigurator 对象
    LogbackConfigurator configurator = new LogbackConfigurator(context);
    // <3> 从 environment 读取变量，设置到 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}}"));
    // <4> 创建 DefaultLogbackConfiguration 对象，设置到 configurator 中
    new DefaultLogbackConfiguration(initializationContext, logFile).apply(configurator);
    // <5> 设置日志文件，按天滚动
    context.setPackagingDataEnabled(true);
}
```

- `<1>` 处，调用 `#stopAndReset(LoggerContext loggerContext)` 方法，重置。
- `<2>` 处，创建 LogbackConfigurator 对象。详细解析，见 [「7.4.3.3.1 LogbackConfigurator」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。
- `<3>` 处，从 `environment` 读取变量，设置到 `context` 中。
- `<4>` 处，创建 DefaultLogbackConfiguration 对象，后调用 `DefaultLogbackConfiguration#apply(LogbackConfigurator)` 方法，设置到 `configurator` 中。详细解析，见 [「7.4.3.3.2 DefaultLogbackConfiguration」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。
- `<5>` 处，调用 `LoggerContext#setPackagingDataEnabled(boolean packagingDataEnabled)` 方法，设置日志文件，按天滚动。

##### 7.4.3.3.1 LogbackConfigurator

`org.springframework.boot.logging.logback.LogbackConfigurator` ，Logback 配置器，提供一些工具方法，方便配置 Logback 。

因为 LogbackConfigurator 提供的方法，都是被 DefaultLogbackConfiguration 所调用。所以我们先跳到 [「7.4.3.3.2 DefaultLogbackConfiguration」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 中。

###### 7.4.3.3.1.1 conversionRule

`#conversionRule(String conversionWord, Class<? extends Converter> converterClass)` 方法，添加转换规则。代码如下：

```
// LogbackConfigurator.java

public void conversionRule(String conversionWord, Class<? extends Converter> converterClass) {
    Assert.hasLength(conversionWord, "Conversion word must not be empty");
    Assert.notNull(converterClass, "Converter class must not be null");
    // 获得注册表
    Map<String, String> registry = (Map<String, String>) this.context.getObject(CoreConstants.PATTERN_RULE_REGISTRY);
    // 如果注册表为空，则进行注册
    if (registry == null) {
        registry = new HashMap<>();
        this.context.putObject(CoreConstants.PATTERN_RULE_REGISTRY, registry);
    }
    // 添加转换规则，到注册表中
    registry.put(conversionWord, converterClass.getName());
}
```

- 比较简单，胖友自己瞅瞅。
- 目前有三个转换规则，分别是：
  - [org.springframework.boot.logging.logback.ColorConverter](https://github.com/YunaiV/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/ColorConverter.java) ，实现 ANSI 颜色转换器。
  - [org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter](https://github.com/YunaiV/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/ExtendedWhitespaceThrowableProxyConverter.java) ，在异常堆栈的打印过程中添加一些空格。
  - [org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter](https://github.com/YunaiV/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/ExtendedWhitespaceThrowableProxyConverter.java) ，在异常堆栈的打印过程中添加一些空格。
  - [org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter](https://github.com/YunaiV/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/WhitespaceThrowableProxyConverter.java) ，在异常堆栈的打印过程中添加一些空格。【同上】
  - 就不详细解析啦，胖友自己瞅瞅就明白列。

###### 7.4.3.3.1.2 logger

`#logger(String name, Level level)` 方法，添加 Logger 。代码如下：

```
// LogbackConfigurator.java

public void logger(String name, Level level) {
    logger(name, level, true);
}

public void logger(String name, Level level, boolean additive) {
    logger(name, level, additive, null);
}

public void logger(String name, Level level, boolean additive, Appender<ILoggingEvent> appender) {
    // 获得 Logger 对象
    Logger logger = this.context.getLogger(name);
    // 设置 level
    if (level != null) {
        logger.setLevel(level);
    }
    // 设置 additive
    logger.setAdditive(additive);
    // 设置 appender
    if (appender != null) {
        logger.addAppender(appender);
    }
}
```

###### 7.4.3.3.1.3 appender

`#appender(String name, Appender<?> appender)` 方法，启动 Appender 。代码如下：

```
// LogbackConfigurator.java

public void appender(String name, Appender<?> appender) {
	// 设置 name
	appender.setName(name);
	// 启动 Appender
	start(appender);
}

public void start(LifeCycle lifeCycle) {
    // 设置 context
    if (lifeCycle instanceof ContextAware) {
        ((ContextAware) lifeCycle).setContext(this.context);
    }
    // 启动
    lifeCycle.start();
}
```

###### 7.4.3.3.1.4 root

`#root(Level level, Appender<ILoggingEvent>... appenders)` 方法，设置 appender 到 ROOT Logger 。代码如下：

```
// LogbackConfigurator.java

public final void root(Level level, Appender<ILoggingEvent>... appenders) {
    // 获得 Root Logger 对象
    Logger logger = this.context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    // 设置 level
    if (level != null) {
        logger.setLevel(level);
    }
    // 添加 appender 到 logger 中
    for (Appender<ILoggingEvent> appender : appenders) {
        logger.addAppender(appender);
    }
}
```

##### 7.4.3.3.2 DefaultLogbackConfiguration

`org.springframework.boot.logging.logback.DefaultLogbackConfiguration` ，默认的 Logback 配置类。代码如下：

> 相当于代码生成 `logback.xml` 的效果。

##### 7.4.3.3.2.1 构造方法

```
// DefaultLogbackConfiguration.java

/**
 * PropertyResolver 对象。提供从 environment 解析配置
 */
private final PropertyResolver patterns;

private final LogFile logFile;

DefaultLogbackConfiguration(LoggingInitializationContext initializationContext, LogFile logFile) {
    this.patterns = getPatternsResolver(initializationContext.getEnvironment());
    this.logFile = logFile;
}

private PropertyResolver getPatternsResolver(Environment environment) {
    // 创建 PropertySourcesPropertyResolver 对象，无 environment
    if (environment == null) {
        return new PropertySourcesPropertyResolver(null);
    }
    // 创建 PropertySourcesPropertyResolver 对象，有 environment
    if (environment instanceof ConfigurableEnvironment) {
        PropertySourcesPropertyResolver resolver = new PropertySourcesPropertyResolver(((ConfigurableEnvironment) environment).getPropertySources());
        resolver.setIgnoreUnresolvableNestedPlaceholders(true);
        return resolver;
    }
    // 直接返回 environment
    return environment;
}
```

##### 7.4.3.3.2.2 apply

`#apply(LogbackConfigurator config)` 方法，应用配置。代码如下：

```
// DefaultLogbackConfiguration.java

public void apply(LogbackConfigurator config) {
    // <1> 锁
    synchronized (config.getConfigurationLock()) {
        // <2> 设置基础属性
        base(config);
        // <3> 创建 console Appender
        Appender<ILoggingEvent> consoleAppender = consoleAppender(config);
        // <4> 如果 logFile 非空，则创建 file Appender
        if (this.logFile != null) {
            Appender<ILoggingEvent> fileAppender = fileAppender(config, this.logFile.toString());
            // <5> 设置 appender 到 ROOT Logger
            config.root(Level.INFO, consoleAppender, fileAppender);
        } else {
            // <5> 设置 appender 到 ROOT Logger
            config.root(Level.INFO, consoleAppender);
        }
    }
}
```

- `<1>` 处，锁。代码如下：

  ```
  // LogbackConfigurator.java
  
  private LoggerContext context;
  
  public Object getConfigurationLock() {
  	return this.context.getConfigurationLock();
  }
  ```

- `<2>` 处，调用 `#base(LogbackConfigurator config)` 方法，设置基础属性。代码如下：

  ```
  // LogbackConfigurator.java
  
  private void base(LogbackConfigurator config) {
  	// <2.1> Converter
  	config.conversionRule("clr", ColorConverter.class);
  	config.conversionRule("wex", WhitespaceThrowableProxyConverter.class);
  	config.conversionRule("wEx", ExtendedWhitespaceThrowableProxyConverter.class);
  	// <2.2> 默认的 logger
  	config.logger("org.apache.catalina.startup.DigesterFactory", Level.ERROR);
  	config.logger("org.apache.catalina.util.LifecycleBase", Level.ERROR);
  	config.logger("org.apache.coyote.http11.Http11NioProtocol", Level.WARN);
  	config.logger("org.apache.sshd.common.util.SecurityUtils", Level.WARN);
  	config.logger("org.apache.tomcat.util.net.NioSelectorPool", Level.WARN);
  	config.logger("org.eclipse.jetty.util.component.AbstractLifeCycle", Level.ERROR);
  	config.logger("org.hibernate.validator.internal.util.Version", Level.WARN);
  }
  ```

  - `<2.1>` 处，调用 `LogbackConfigurator#conversionRule(String conversionWord, Class<? extends Converter> converterClass)` 方法，添加转换规则。详细解析，见 [「 7.4.3.3.1.1 conversionRule」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。
  - `<2.2>` 处，调用 `LogbackConfigurator#logger(String name, Level level)` 方法，默认的 logger 。详细解析，见 [「7.4.3.3.1.2 logger」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

- `<3>` 处，调用 `#consoleAppender(LogbackConfigurator config)` 方法，创建 console Appender 对象。代码如下：

  ```
  // LogbackConfigurator.java
  
  private static final String CONSOLE_LOG_PATTERN = "%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint} "
  		+ "%clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} "
  		+ "%clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} "
  		+ "%clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}";
  
  private Appender<ILoggingEvent> consoleAppender(LogbackConfigurator config) {
  	ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<>();
  	PatternLayoutEncoder encoder = new PatternLayoutEncoder();
  	String logPattern = this.patterns.getProperty("logging.pattern.console", CONSOLE_LOG_PATTERN); // <X>
  	encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
  	config.start(encoder);
  	appender.setEncoder(encoder);
  	config.appender("CONSOLE", appender); // <Y>
  	return appender;
  }
  ```

  - `<X>` 处，从 `environment` 中，读取 `"logging.pattern.console"` 作为格式。如果找不到，使用 `CONSOLE_LOG_PATTERN` 。
  - `<Y>` 处，调用 `LogbackConfigurator#appender(String name, Appender<?> appender)` 方法，启动 Appender 。详细解析，见 [「7.4.3.3.1.3 appender」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

- `<4>` 处，如果 `logFile` 非空，则调用 `#fileAppender(LogbackConfigurator config, String logFile)` 方法，创建 file Appender。代码如下：

  ```
   // LogbackConfigurator.java
   
   private static final String FILE_LOG_PATTERN = "%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}} "
  + "${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}";
  
   private static final String MAX_FILE_SIZE = "10MB";
   
   private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config, String logFile) {
   	RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>();
   	PatternLayoutEncoder encoder = new PatternLayoutEncoder();
   	String logPattern = this.patterns.getProperty("logging.pattern.file", FILE_LOG_PATTERN);
   	encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
   	appender.setEncoder(encoder);
   	config.start(encoder);
   	appender.setFile(logFile);
   	// 滚动策略
   	setRollingPolicy(appender, config, logFile);
   	config.appender("FILE", appender);
   	return appender;
   }
   
   private void setRollingPolicy(RollingFileAppender<ILoggingEvent> appender, LogbackConfigurator config, String logFile) {
   	SizeAndTimeBasedRollingPolicy<ILoggingEvent> rollingPolicy = new SizeAndTimeBasedRollingPolicy<>();
   	rollingPolicy.setFileNamePattern(logFile + ".%d{yyyy-MM-dd}.%i.gz");
   	// 单文件最大值
   	setMaxFileSize(rollingPolicy, this.patterns.getProperty("logging.file.max-size", MAX_FILE_SIZE));
   	rollingPolicy.setMaxHistory(this.patterns.getProperty("logging.file.max-history", Integer.class, CoreConstants.UNBOUND_HISTORY));
   	appender.setRollingPolicy(rollingPolicy);
   	rollingPolicy.setParent(appender);
   	config.start(rollingPolicy);
   }
   
   private void setMaxFileSize(SizeAndTimeBasedRollingPolicy<ILoggingEvent> rollingPolicy, String maxFileSize) {
   	try {
   		rollingPolicy.setMaxFileSize(FileSize.valueOf(maxFileSize));
   	} catch (NoSuchMethodError ex) {
   		// Logback < 1.1.8 used String configuration
   		Method method = ReflectionUtils.findMethod(SizeAndTimeBasedRollingPolicy.class, "setMaxFileSize", String.class);
   		ReflectionUtils.invokeMethod(method, rollingPolicy, maxFileSize);
   	}
   }
  ```

- `<5>` 处，调用 `LogbackConfigurator#root(Level level, Appender<ILoggingEvent>... appenders)` 方法，设置 appender 到 ROOT Logger 。详细解析，见 [「7.4.3.3.1.4 root」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 。

### 7.4.4 setLogLevel

实现 `#setLogLevel(String loggerName, LogLevel level)` 方法，代码如下：

```
// LogbackLoggingSystem.java

private static final LogLevels<Level> LEVELS = new LogLevels<>();

static {
	LEVELS.map(LogLevel.TRACE, Level.TRACE);
	LEVELS.map(LogLevel.TRACE, Level.ALL);
	LEVELS.map(LogLevel.DEBUG, Level.DEBUG);
	LEVELS.map(LogLevel.INFO, Level.INFO);
	LEVELS.map(LogLevel.WARN, Level.WARN);
	LEVELS.map(LogLevel.ERROR, Level.ERROR);
	LEVELS.map(LogLevel.FATAL, Level.ERROR);
	LEVELS.map(LogLevel.OFF, Level.OFF);
}

@Override
public void setLogLevel(String loggerName, LogLevel level) {
	// <1> 获得 Logger 对象
	ch.qos.logback.classic.Logger logger = getLogger(loggerName);
	// <2> 设置日志级别
	if (logger != null) {
		logger.setLevel(LEVELS.convertSystemToNative(level));
	}
}
```

- ```
  <1>
  ```

   

  处，调用

   

  ```
  #getLogger(String name)
  ```

   

  方法，获得 Logger 对象。代码如下：

  ```
  // LogbackLoggingSystem.java
  
  private ch.qos.logback.classic.Logger getLogger(String name) {
  	LoggerContext factory = getLoggerContext();
  	if (StringUtils.isEmpty(name) || ROOT_LOGGER_NAME.equals(name)) {
  		name = Logger.ROOT_LOGGER_NAME;
  	}
  	return factory.getLogger(name);
  
  }
  ```

- `<2>` 处，设置日志级别。

### 7.4.4 cleanUp

重写 `#cleanUp()` 方法，代码如下：

```
// LogbackLoggingSystem.java

@Override
public void cleanUp() {
	// 标记为未初始化
	LoggerContext context = getLoggerContext();
	markAsUninitialized(context);
	// 调用父方法
	super.cleanUp();
	// 清空 StatusManager
	context.getStatusManager().clear();
	// 移除 FILTER
	context.getTurboFilterList().remove(FILTER);
}

private void markAsUninitialized(LoggerContext loggerContext) {
	loggerContext.removeObject(LoggingSystem.class.getName());
}
```

### 7.4.5 getShutdownHandler

实现 `#getShutdownHandler()` 方法，代码如下：

```
// LogbackLoggingSystem.java

@Override
public Runnable getShutdownHandler() {
	return new ShutdownHandler();
}

private final class ShutdownHandler implements Runnable {

	@Override
	public void run() {
		getLoggerContext().stop(); // 停止
	}

}
```

## 7.5 Log4J2LoggingSystem

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

就暂时不解析了，基本类似。感兴趣的胖友，可以看看 [《spring boot 源码解析28-Log4J2LoggingSystem》](https://blog.csdn.net/qq_26000415/article/details/79109517) 。

## 7.6 JavaLoggingSystem

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

就暂时不解析了，基本类似。感兴趣的胖友，可以看看 [《spring boot 源码解析27-JavaLoggingSystem及LoggingSystem生命周期详解》](https://blog.csdn.net/qq_26000415/article/details/79103989) 的 [「LoggingSystem」](https://svip.iocoder.cn/Spring-Boot/logger-system/#) 部分。

# 666. 彩蛋

Spring Boot 的文章，基本都短不了~咋说呢？虽然长了一些吧，总体还是比较简单和顺畅的。

参考和推荐如下文章：

- 一个努力的码农 [《spring boot 源码解析29-LogbackLoggingSystem》](https://blog.csdn.net/qq_26000415/article/details/79130943)
- oldflame-Jm [《Spring boot源码分析-log日志系统（6）》](https://blog.csdn.net/jamet/article/details/78060817)