springboot之日志配置分析

悠悠 2022-10-08 05:45 172阅读 0赞

## 1：日志分析 ##

### 1.1：默认使用的日志框架 ###

logback。一般项目中不需要修改，使用默认即可。

### 1.2：日志的格式 ###

默认的输出日志信息可能如下：

2021-06-20 13:45:17.410  INFO 13724 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8083 (http) with context path ''
    2021-06-20 13:45:17.413  INFO 13724 --- [           main] pringbootIntegrationSpringmvcApplication : Started SpringbootIntegrationSpringmvcApplication in 10894.697 seconds (JVM

格式为`{时间，精确到毫秒} {日志级别} {进程ID} {分割符} {线程名称} {logger名称} : {日志内容}`。  
每项具体说明如下：

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>{时间，精确到毫秒}</td> 
   <td>精确到毫秒的时间，排序的时候可以使用</td> 
  </tr> 
  <tr> 
   <td>{日志级别}</td> 
   <td>如TRACE，DEBUG，ERROR，WARN，INFO等</td> 
  </tr> 
  <tr> 
   <td>{进程ID}</td> 
   <td>程序的进程ID</td> 
  </tr> 
  <tr> 
   <td>{分割符}</td> 
   <td>一般为"—",用于分割具体日志内容</td> 
  </tr> 
  <tr> 
   <td>{线程名称}</td> 
   <td>执行程序的线程名称，如例子中就是主线程</td> 
  </tr> 
  <tr> 
   <td>{logger名称}</td> 
   <td>日志的名称，一般是使用类全限定名称</td> 
  </tr> 
  <tr> 
   <td>{日志内容}</td> 
   <td>日志内容</td> 
  </tr> 
 </tbody> 
</table>

### 1.3：日志的级别 ###

默认springboot为我们输出`>=INFO`的日志级别，想要输出更低级别的日志可以通过如下的几种方式：

1：命令模式 java -jar app.jar --debug=true，优先级最高，会被优先解析
    2：在application.properties中配置--debug=true，但是默认仅仅对嵌入web服务器，Spring生效，对于其他框架，如mybatis，或者是我们自己的应用程序，需要使用3来配置
    3：logging.level.the.package.name={日志级别}，如配置mybatis为trace"logging.level.org.mybatis = trace"

另外还有`logging.pattern.console`用来定义日志输出到控制台的格式，`logging.pattern.file`定义输出到文件的格式。

### 1.4：日志的颜色 ###

如果是控制台输出支持ANSI的话，可以输出带有颜色的日志信息，使用环境变量`spring.output.ansi.enabled`进行配置，可能的值如下：

ALWAYS：启用ANSI日志输出
    DETECT：尝试检测ANSI的着色功能是否可用
    NEVER：禁用ANSI

默认`TRACE,DEBUG,INFO`日志输出颜色为GREEN，`WARN`日志输出颜色为YELLOW，`ERROR`日志输出颜色为RED。

### 1.5：输出到文件 ###

可以使用`logging.file=/path/to/logfile`设置输出的日志文件，也可以使用`logging.path=/the/log/path`设置输出的路径，前者会写到一个文件中，后者会写到名称为`spring.log`的文件中，当达到10M`可通过logging.file.max-size设置`，也可通过`logging.file.max-history`设置日志保留的天数。

### 1.6：自定义日志配置 ###

我们也可以通过自定义配置文件的方式来设置日志输出，其中logback默认的配置文件名称为`logback-spring.xml`和`logback.xml`，注意是在classpath下的，也可以通过`logging.config`在application.properties配置文件中显式设置。

## 2：LoggingApplicationListener ##

springboot的日志功能的初始化是通过`org.springframework.boot.context.logging.LoggingApplicationListener`来完成的。该类签名如下：

public class LoggingApplicationListener implements GenericApplicationListener { }

可以看到其实现了`org.springframework.context.event.GenericApplicationListener`，因此我们从`onApplicationEvent`方法来看起，该方法是调用的入口，详细关于ApplicationListener可以参考[这篇文章][Link 1]。

### 2.1：onApplicationEvent ###

源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationEvent
    public void onApplicationEvent(ApplicationEvent event) { 
    	// <202106201557>
    	// springboot应用启动的时候
    	if (event instanceof ApplicationStartingEvent) { 
    		onApplicationStartingEvent((ApplicationStartingEvent) event);
    	}
    	// <202106201558>
    	// springgboot的environment准备完毕
    	else if (event instanceof ApplicationEnvironmentPreparedEvent) { 
    		onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
    	}
    	// <202106201559>
    	// springboot容器准备完毕
    	else if (event instanceof ApplicationPreparedEvent) { 
    		onApplicationPreparedEvent((ApplicationPreparedEvent) event);
    	}
    	// <202106201560>
    	// springboot容器关闭
    	else if (event instanceof ContextClosedEvent
    			&& ((ContextClosedEvent) event).getApplicationContext().getParent() == null) { 
    		onContextClosedEvent();
    	}
    	// <202106201601>
    	// springboot容器启动失败
    	else if (event instanceof ApplicationFailedEvent) { 
    		onApplicationFailedEvent();
    	}
    }

`<202106201557>`处是处理`ApplicationStartingEvent`事件，调用的方法是`onApplicationStartingEvent`，具体参考`2.3：onApplicationStartingEvent`，`<202106201558>`是处理`ApplicationEnvironmentPreparedEvent`事件，具体参考`2.4：onApplicationEnvironmentPreparedEvent`，`<202106201559>`是处理`ApplicationPreparedEvent`事件，具体参考`2.5：onApplicationPreparedEvent`，`<202106201560>`是处理ContextClosedEvent事件，具体参考`2.6：onContextClosedEvent`,`<202106201601>`是处理ApplicationFailedEvent事件，具体参考`2.7：onApplicationFailedEvent`。

### 2.3：onApplicationStartingEvent ###

源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationStartingEvent
    private void onApplicationStartingEvent(ApplicationStartingEvent event) { 
    	// <202106201618>
    	this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
    	// <202106201619>
    	this.loggingSystem.beforeInitialize();
    }

`<202106201618>`处是获取LoggingSystem抽象类，该类抽象了不同的日志框架，每个日志框架都会定义对应的实现类，类图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70_pic_center]  
其中的`org.springframework.boot.logging.logback.LogbackLoggingSystem`子类可以多关注，因为这是springboot默认使用的日志框架logback对应的类。来看下get方法，源码如下：

org.springframework.boot.logging.LoggingSystem#get(java.lang.ClassLoader)
    // 获取使用的日志系统，支持logback，Java logging
    public static LoggingSystem get(ClassLoader classLoader) { 
    	// 通过系统属性org.springframework.boot.logging.LoggingSystem获取要使用的日志系统的类名
    	// 一般我们不会配置，所以这里正常为null
    	String loggingSystem = System.getProperty(SYSTEM_PROPERTY);
    	if (StringUtils.hasLength(loggingSystem)) { 
    		// 值为none，使用NoOpLoggingSystem，即什么也不输出
    		if (NONE.equals(loggingSystem)) { 
    			return new NoOpLoggingSystem();
    		}
    		// 通过指定的日志系统类名称，创建类实例，源码如下：
    		/* org.springframework.boot.logging.LoggingSystem#get(java.lang.ClassLoader, java.lang.String) 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); } } */
    		return get(classLoader, loggingSystem);
    	}
    	// <202106201740>
    	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"));
    }

`<202106201740>`中的SYSTEMS如下：

org.springframework.boot.logging.LoggingSystem#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);
    }

定义的是不同框架日志类的名称，最终`findFirst()`会获取到logback对应的ch.qos.logback.core.Appender，因此默认就会使用lockback日志框架。  
`<202106201619>`处是日志初始化执行一些操作，在`org.springframework.boot.logging.LoggingSystem`中定义的为模板方法，源码如下：

org.springframework.boot.logging.LoggingSystem#beforeInitialize
    public abstract void beforeInitialize();

具体的实现在对应日志子类中提供，我们在`3：LoggingSystem具体实现类`具体分析每个实现类的具体实现。

### 2.4：onApplicationEnvironmentPreparedEvent ###

环境准备完毕事件执行的方法，源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationEnvironmentPreparedEvent
    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) { 
    	// 如果是logginSystem为null则调用LoggingSystem#get获取
    	// 正常在”2.3：onApplicationStartingEvent“会初始化该值，所以一般不会为null
    	if (this.loggingSystem == null) { 
    		this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
    	}
    	// <202106221131>
    	initialize(event.getEnvironment(), event.getSpringApplication().getClassLoader());
    }

`<202106221131>`是进行相关的初始化，源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initialize
    protected void initialize(ConfigurableEnvironment environment, ClassLoader classLoader) { 
    	// <202106221135>
    	new LoggingSystemProperties(environment).apply();
    	// <202106221335>
    	this.logFile = LogFile.get(environment);
    	// 如果是不为null
    	if (this.logFile != null) { 
    		// 应用属性到环境变量中
    		this.logFile.applyToSystemProperties();
    	}
    	// <202106231639>
    	initializeEarlyLoggingLevel(environment);
    	// <202106231653>
    	initializeSystem(environment, this.loggingSystem, this.logFile);
    	// <202106231734>
    	initializeFinalLoggingLevels(environment, this.loggingSystem);
    	// <202106231819>
    	registerShutdownHookIfNecessary(environment, this.loggingSystem);
    }

`<202106221135>`处LoggingSystemProperties是LoggingSystem的配置类，具体参考`2.4.1：LoggingSystemProperties`。`<202106221335>`处是日志文件对应的对象，具体参考`2.4.2：LogFile`。`<202106231639>`处是设置日志级别，源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initializeEarlyLoggingLevel
    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;
    		}
    	}
    }

以上可以通过在启动时增加`--debug` 或 `--trace`,也可以在配置文件中增加`trace=true`或`debug=true`。其中多的LogLevel是一个用于定义日志级别的枚举类，源码如下：

// LoggingSystem支持的日志级别
    public enum LogLevel { 
    	// 各种支持的枚举类
    	TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF
    }

`<202106231653>`处具体参考`2.4.3：initializeSystem`。`<202106231734>`处是将前面设置的日志级别设置到默认的包路径上，这样这些包路径就不需要单独设置日志级别了，因此对于不支持的包路径需要单独设置，具体参考`2.4.4：initializeFinalLoggingLevels`。`<202106231819>`处源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#registerShutdownHookIfNecessary
    private void registerShutdownHookIfNecessary(Environment environment, LoggingSystem loggingSystem) { 
    	// public static final String REGISTER_SHUTDOWN_HOOK_PROPERTY = "logging.register-shutdown-hook";
    	// 获取是否需要注册虚拟机关闭钩子的标记，关于虚拟机关闭钩子参考:
    	// https://blog.csdn.net/wang0907/article/details/116419006
    	booleanregisterShutdownHook = environment.getProperty(REGISTER_SHUTDOWN_HOOK_PROPERTY, Boolean.class, false);
    	if (registerShutdownHook) { 
    		// 从LoggingSystem中获取注册的关闭钩子处理器
    		Runnable shutdownHandler = loggingSystem.getShutdownHandler();
    		// 有的话，cas方式设置
    		if (shutdownHandler != null && shutdownHookRegistered.compareAndSet(false, true)) { 
    			/* org.springframework.boot.context.logging.LoggingApplicationListener#registerShutdownHook void registerShutdownHook(Thread shutdownHook) { Runtime.getRuntime().addShutdownHook(shutdownHook); } */
    			registerShutdownHook(new Thread(shutdownHandler));
    		}
    	}
    }

#### 2.4.1：LoggingSystemProperties ####

构造函数如下：

org.springframework.boot.logging.LoggingSystemProperties#LoggingSystemProperties
    public LoggingSystemProperties(Environment environment) { 
    	Assert.notNull(environment, "Environment must not be null");
    	this.environment = environment;
    }

`apply`方法源码如下：

org.springframework.boot.logging.LoggingSystemProperties#apply()
    public void apply() { 
    	apply(null);
    }

继续看：

org.springframework.boot.logging.LoggingSystemProperties#apply(org.springframework.boot.logging.LogFile)
    public void apply(LogFile logFile) { 
    	// <202106221145>
    	PropertyResolver resolver = getPropertyResolver();
    	// <202106221323>
    	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");
    	// debug看这里为false，暂时忽略，需要了再看
    	if (logFile != null) { 
    		logFile.applyToSystemProperties();
    	}
    }

`<202106221145>`处是获取用于解析属性的PropertyResolver对象，详细可以参考[这篇文章][Link 2],获取源码如下：

org.springframework.boot.logging.LoggingSystemProperties#getPropertyResolver
    private PropertyResolver getPropertyResolver() { 
    	// 这里为true
    	if (this.environment instanceof ConfigurableEnvironment) { 
    		// 创建属性解析器对象
    		PropertyResolver resolver = new PropertySourcesPropertyResolver(
    				((ConfigurableEnvironment) this.environment).getPropertySources());
    		// 设置忽略无法解析的占位符
    		((PropertySourcesPropertyResolver) resolver).setIgnoreUnresolvableNestedPlaceholders(true);
    		// 返回
    		return resolver;
    	}
    	return this.environment;
    }

`<202106221323>`处是获取环境中配置的`logging.`开头的值通过System.setProperty设置到系统属性中，相关源码如下：

org.springframework.boot.logging.LoggingSystemProperties#setSystemProperty(org.springframework.core.env.PropertyResolver, java.lang.String, java.lang.String)
    private void setSystemProperty(PropertyResolver resolver, String systemPropertyName, String propertyName) { 
    	setSystemProperty(systemPropertyName, resolver.getProperty("logging." + propertyName));
    }
    
    org.springframework.boot.logging.LoggingSystemProperties#setSystemProperty(java.lang.String, java.lang.String)
    private void setSystemProperty(String name, String value) { 
    	if(System.getProperty(name) == null && value != null) { 
    		System.setProperty(name, value);
    	}
    }

#### 2.4.2：LogFile ####

源码如下：

org.springframework.boot.logging.LogFile
    
    // 日志输出文件的引用对象，代表了一个日志输出文件，写文件的路径通过"logging.path"配置，写文件的名称通过"logging.file"配置，
    // (没有配置的话使用名称spring.log),写文件的路径通过"logging.path"配置
    // 相关配置的值可以通过PropertyResolver#get方法获取
    public class LogFile { 
    
    	// 文件名称信息属性，可以是绝对路径，也可以是相对于当前路径的相对目录
    	public static final String FILE_PROPERTY = "logging.file";
    
    	// 日志文件写入路径的配置信息
    	public static final String PATH_PROPERTY = "logging.path";
    
    	private final String file;
    
    	private final String path;
    
    	// 通过文件完整路径创建实例
    	LogFile(String file) { 
    		this(file, null);
    	}
    
    	// file：待写入文件的引用
    	// path：如果是file为空，指定写入文件的路径
    	LogFile(String file, String path) { 
    		Assert.isTrue(StringUtils.hasLength(file) || StringUtils.hasLength(path), "File or Path must not be empty");
    		this.file = file;
    		this.path = path;
    	}
    
    	// 将实例中的file和path信息设置到环境变量中的public static final String LOG_PATH = "LOG_PATH";
    	// 和public static final String LOG_FILE = "LOG_FILE";中
    	public void applyToSystemProperties() { 
    		applyTo(System.getProperties());
    	}
    
    	// 将实例中的file和path信息设置到环境变量中的public static final String LOG_PATH = "LOG_PATH";
    	// 和public static final String LOG_FILE = "LOG_FILE";中
    	public void applyTo(Properties properties) { 
    		put(properties, LoggingSystemProperties.LOG_PATH, this.path);
    		put(properties, LoggingSystemProperties.LOG_FILE, toString());
    	}
    	
    	private void put(Properties properties, String key, String value) { 
    		if (StringUtils.hasLength(value)) { 
    			properties.put(key, value);
    		}
    	}
    
    	@Override
    	public String toString() { 
    		// 如果是指定了文件则直接以file作为结果
    		if (StringUtils.hasLength(this.file)) { 
    			return this.file;
    		}
    		String path = this.path;
    		// 拼接/如果需要的话
    		if (!path.endsWith("/")) { 
    			path = path + "/";
    		}
    		// 获取spring.log文件的路径
    		// 如path为d:\test，则结果就是d\:test\spring.log，spring.log也是默认的日志文件名称
    		return StringUtils.applyRelativePath(path, "spring.log");
    	}
    
    	// 直接通过环境的public static final String FILE_PROPERTY = "logging.file";和
    	// public static final String PATH_PROPERTY = "logging.path";创建LogFile，如果是
    	// 二者都没有设置的话则返回null
    	public static LogFile get(PropertyResolver propertyResolver) { 
    		String file = propertyResolver.getProperty(FILE_PROPERTY);
    		String path = propertyResolver.getProperty(PATH_PROPERTY);
    		
    		if (StringUtils.hasLength(file) || StringUtils.hasLength(path)) { 
    			return new LogFile(file, path);
    		}
    		return null;
    	}
    
    }

#### 2.4.3：initializeSystem ####

源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initializeSystem
    private void initializeSystem(ConfigurableEnvironment environment, LoggingSystem system, LogFile logFile) { 
    	// <202106231706>
    	LoggingInitializationContext initializationContext = new LoggingInitializationContext(environment);
    	// 获得日志配置文件名称，springboot中提供了默认的配置文件名称，如果是没有的话
    	/* 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 */
    	String logConfig = environment.getProperty(CONFIG_PROPERTY);
    	if (ignoreLogConfig(logConfig)) { 
    		// <202106231726>
    		system.initialize(initializationContext, null, logFile);
    	}
    	else { 
    		try { 
    			// 通过尝试加载，确定是否存在
    			ResourceUtils.getURL(logConfig).openStream().close();
    			// <202106231727>
    			system.initialize(initializationContext, logConfig, logFile);
    		}
    		catch (Exception ex) { 
    			System.err.println(
    					"Logging system failed to initialize " + "using configuration from '" + logConfig + "'");
    			ex.printStackTrace(System.err);
    			throw new IllegalStateException(ex);
    		}
    	}
    }

`<202106231706>`处是创建LoggingInitializationContext实例，类源码如下：

// 初始化期间传递给LoggingSystem的上下文对象，目前只有environment信息
    public class LoggingInitializationContext { 
    
    	private final ConfigurableEnvironment environment;
    
    	public LoggingInitializationContext(ConfigurableEnvironment environment) { 
    		this.environment = environment;
    	}
    	public Environment getEnvironment() { 
    		return this.environment;
    	}
    }

`<202106231726>`和`<202106231727>`调用的方法是模板方法，执行初始化操作，在子类中提供具体实现。

#### 2.4.4：initializeFinalLoggingLevels ####

该方法是根据前面设置的级别，分别设置到具体的包路径上，因为打印日志的级别是和包路径有关系的。  
源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initializeFinalLoggingLevels
    private void initializeFinalLoggingLevels(ConfigurableEnvironment environment, LoggingSystem system) { 
    	// springBootLogging，该值是在org.springframework.boot.context.logging.LoggingApplicationListener#initializeEarlyLoggingLevel
    	// 方法中设置的，具体可以参考“<202106231639>”处关于该方法的讲解
    	if (this.springBootLogging != null) { 
    		// <202106231743>
    		initializeLogLevel(system, this.springBootLogging);
    	}
    	// <202106231744>
    	setLogLevels(system, environment);
    }

`<202106231743>`处源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initializeLogLevel(org.springframework.boot.logging.LoggingSystem, org.springframework.boot.logging.LogLevel)
    protected void initializeLogLevel(LoggingSystem system, LogLevel level) { 
    	/* 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); } */
    	// 比如这里的level值是org.springframework.boot.logging.LogLevel#DEBUG,
    	// 则循环处理的就是["sql", "web", "org.springframework.boot"]
    	// <202106231803>
    	LOG_LEVEL_LOGGERS.getOrDefault(level, Collections.emptyList())
    			.forEach((logger) -> initializeLogLevel(system, level, logger));
    }

`<202106231803>`处initializeLogLevel源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initializeLogLevel(org.springframework.boot.logging.LoggingSystem, org.springframework.boot.logging.LogLevel, java.lang.String)
    private void initializeLogLevel(LoggingSystem system, LogLevel level, String logger) { 
    	// 比如这里的level值是org.springframework.boot.logging.LogLevel#DEBUG,
    	// 则循环处理的就是["sql", "web", "org.springframework.boot"]
    	/* // 对应到具体的包名，日志打印的时候是根据包名来确定其打印日志级别的 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); } */
    	// 获取对应的所有的包集合
    	List<String> groupLoggers = DEFAULT_GROUP_LOGGERS.get(logger);
    	// 如果是为null，则默认设置当前logger的日志级别为level
    	if (groupLoggers == null) { 
    		// <202106231813>
    		system.setLogLevel(logger, level);
    		// 注意这里直接就return了
    		return;
    	}
    	// 循环包名，设置每个包名的隔离级别为level
    	// <202106231814>
    	groupLoggers.forEach((groupLogger) -> system.setLogLevel(groupLogger, level));
    }

`<202106231813>`和`<202106231814>`处的`setLogLevel`方法是一个强制子类实现的模板方法，因为不同的日志框架具体操作不同，源码如下：

org.springframework.boot.logging.LoggingSystem#setLogLevel
    // 要设置的logger的名字（一般是包路径）
    public void setLogLevel(String loggerName, LogLevel level) { 
    	// 通过抛出异常强制子类实现
    	throw new UnsupportedOperationException("Unable to set log level");
    }

### 2.5：onApplicationPreparedEvent ###

在spring IOC容器准备完毕后执行的事件，源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationPreparedEvent
    private void onApplicationPreparedEvent(ApplicationPreparedEvent event) { 
    	// 获取应用程序上下文底层的IOC bean工厂容器
    	ConfigurableListableBeanFactory beanFactory = event.getApplicationContext().getBeanFactory();
    	// 如果是IOC容器中不包括org.springframework.boot.context.logging.LoggingApplicationListener#LOGGING_SYSTEM_BEAN_NAME
    	// 则以单例bean的形式注册到bean工厂IOC容器中
    	if (!beanFactory.containsBean(LOGGING_SYSTEM_BEAN_NAME)) { 
    		beanFactory.registerSingleton(LOGGING_SYSTEM_BEAN_NAME, this.loggingSystem);
    	}
    	// 如果是日志文件对象logFile不为null，且在bean工厂IOC容器中不包括
    	// bean org.springframework.boot.context.logging.LoggingApplicationListener#LOGFILE_BEAN_NAME
    	// 则注册到单例bean缓存中
    	if (this.logFile != null && !beanFactory.containsBean(LOGFILE_BEAN_NAME)) { 
    		beanFactory.registerSingleton(LOGFILE_BEAN_NAME, this.logFile);
    	}
    }

### 2.6：onContextClosedEvent ###

容器关闭时执行的事件，源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#onContextClosedEvent
    private void onContextClosedEvent() { 
    	if(this.loggingSystem != null) { 
    		// 执行日志系统的cleanUp清理方法，是个模板方法，提供空实现，具体又子类实现，但不强制实现
    		this.loggingSystem.cleanUp();
    	}
    }

### 2.7：onApplicationFailedEvent ###

springboot的容器启动失败的时候执行的事件，源码如下：

## 3：LoggingSystem具体实现类 ##

### 3.1：NoOpLoggingSystem ###

这是日志系统基础类LoggingSystem的一个静态内部类，用于在禁用日志系统的时候使用`为了保持队代码的通用性，在不使用日志系统的时候也要有一个对应的类，是不是？`，只不过相关对应方法给个空实现就行了，源码如下：

org.springframework.boot.logging.LoggingSystem.NoOpLoggingSystem
    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;
    	}
    
    }

### 3.2：LogbackLoggingSystem ###

该类是logbak日志框架对应的实现类，下面我们来看下该类都执行了哪些内容，程序的入口为`org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationEvent`，再来贴下源码：

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationEvent
    public void onApplicationEvent(ApplicationEvent event) { 
    	if (event instanceof ApplicationStartingEvent) { 
    		onApplicationStartingEvent((ApplicationStartingEvent) event);
    	}
    	else if (event instanceof ApplicationEnvironmentPreparedEvent) { 
    		onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
    	}
    	else if (event instanceof ApplicationPreparedEvent) { 
    		onApplicationPreparedEvent((ApplicationPreparedEvent) event);
    	}
    	else if (event instanceof ContextClosedEvent
    			&& ((ContextClosedEvent) event).getApplicationContext().getParent() == null) { 
    		onContextClosedEvent();
    	}
    	else if (event instanceof ApplicationFailedEvent) { 
    		onApplicationFailedEvent();
    	}
    }

通过具体的事件来分析下重写了哪些方法，执行了哪些逻辑。

#### 3.2.1：ApplicationStartingEvent ####

源码如下：

private void onApplicationStartingEvent(ApplicationStartingEvent event) { 
    	// 获取日志系统对象，这里是org.springframework.boot.logging.logback.LogbackLoggingSystem
    	this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
    	// <202106241656>
    	this.loggingSystem.beforeInitialize();
    }

`<202106241656>`处是初始化前执行的操作，源码如下：

org.springframework.boot.logging.logback.LogbackLoggingSystem#beforeInitialize
    public void beforeInitialize() { 
    	// <202106241707>
    	// 获取LoggerContext对象
    	LoggerContext loggerContext = getLoggerContext();
    	// 判断是否已经初始化，logback内容，不深究
    	if (isAlreadyInitialized(loggerContext)) { 
    		return;
    	}
    	// <202106241710>
    	super.beforeInitialize();
    	// 设置FILTER，定义如下：
    	/* org.springframework.boot.logging.logback.LogbackLoggingSystem#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; } }; */
    	// 可以看到decide方法返回FilterReply.DENY，即先不打印日志，因为还没有初始化完毕
    	loggerContext.getTurboFilterList().add(FILTER);
    }

`<202106241707>`处是获取LoggerContext对象，这是logback中定义的类，具体可以不用深究，方法源码如下：

org.springframework.boot.logging.logback.LogbackLoggingSystem#getLoggerContext
    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;
    }

`<202106241710>`处是执行父类的`beforeInitialize`方法，调用的是`org.springframework.boot.logging.Slf4JLoggingSystem#beforeInitialize`,源码如下：

org.springframework.boot.logging.Slf4JLoggingSystem#beforeInitialize
    public void beforeInitialize() { 
    	super.beforeInitialize();
    	configureJdkLoggingBridgeHandler();
    }

#### 3.2.2：onApplicationEnvironmentPreparedEvent ####

源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationEnvironmentPreparedEvent
    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) { 
    	// 如果是LoggingSystem还没有值，则重新get
    	if (this.loggingSystem == null) { 
    		this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
    	}
    	// <202106251410>
    	initialize(event.getEnvironment(), event.getSpringApplication().getClassLoader());
    }

`<202106251410>`处源码如下：

org.springframework.boot.context.logging.LoggingApplicationListener#initialize
    protected void initialize(ConfigurableEnvironment environment, ClassLoader classLoader) { 
    	...snip...
    	// <202106251412>
    	initializeSystem(environment, this.loggingSystem, this.logFile);
    	// <202106251414>
    	initializeFinalLoggingLevels(environment, this.loggingSystem);
    	// <202106251419>
    	registerShutdownHookIfNecessary(environment, this.loggingSystem);
    }

`<202106251412>`处会调用的`initialize`方法具体实现，具体参考`3.2.2.1：initialize`。`<202106251414>`处会调用到`setLogLevel`方法具体实现，具体参考`3.2.2.2：setLogLevel`。`<202106251419>`处会调用的是`getShutdownHandler`方法的具体实现，具体参考`3.2.2.3：getShutdownHandler`。

##### 3.2.2.1：initialize #####

源码如下：

org.springframework.boot.logging.logback.LogbackLoggingSystem#initialize
    public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) { 
    	// 获取日志上线文对象LoggerContext
    	LoggerContext loggerContext = getLoggerContext();
    	// 如果是已经初始化完毕，则直接return
    	if (isAlreadyInitialized(loggerContext)) { 
    		return;
    	}
    	// <202106251424>
    	super.initialize(initializationContext, configLocation, logFile);
    	// 移除DENY的FILTER，否则不会打印日志
    	loggerContext.getTurboFilterList().remove(FILTER);
    	// 标记为已经初始化
    	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.");
    	}
    }

`<202106251424>`处是调用LoggingSystem抽象实现基类AbstractLoggingSystem的具体实现，源码如下：

org.springframework.boot.logging.AbstractLoggingSystem#initialize
    public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) { 
    	// 有自定义配置文件的情况
    	if (StringUtils.hasLength(configLocation)) { 
    		// <202106251428>
    		initializeWithSpecificConfig(initializationContext, configLocation, logFile);
    		return;
    	}
    	// 无自定义配置文件的情况下执行初始化
    	// <202106251429>
    	initializeWithConventions(initializationContext, logFile);
    }

`<202106251428>`处源码如下：

org.springframework.boot.logging.AbstractLoggingSystem#initializeWithSpecificConfig
    private void initializeWithSpecificConfig(LoggingInitializationContext initializationContext, String configLocation,
    			LogFile logFile) { 
    	// 解析占位符
    	configLocation = SystemPropertyUtils.resolvePlaceholders(configLocation);
    	// 执行配置文件的加载
    	loadConfiguration(initializationContext, configLocation, logFile);
    }

`<202106251429>`处源码如下：

org.springframework.boot.logging.AbstractLoggingSystem#initializeWithConventions
    private void initializeWithConventions(LoggingInitializationContext initializationContext, LogFile logFile) { 
    	// 最终会执行到org.springframework.boot.logging.logback.LogbackLoggingSystem#getStandardConfigLocations
    	// 获取logback默认的配置文件数组，源码如下：
    	/* org.springframework.boot.logging.logback.LogbackLoggingSystem#getStandardConfigLocations @Override protected String[] getStandardConfigLocations() { return new String[] { "logback-test.groovy", "logback-test.xml", "logback.groovy", "logback.xml" }; } */
    	// 这里只返回存在的，比如我们配置了logback-test.groovy，logback.xml则结果是"classpath:logback-test.groovy",因为默认数组
    	// 从前往后优先级依次降低，所以logback.xml不会生效
    	String config = getSelfInitializationConfig();
    	// 如果是配置了默认的配置文件，则使用配置的重新初始化
    	if (config != null && logFile == null) { 
    		// 重新初始化
    		reinitialize(initializationContext);
    		return;
    	}
    	// 如果是没有配置默认的配置文件
    	if (config == null) { 
    		// 和getSelfInitializationConfig不同之处在于，尝试通过对 new String[] { "logback-test.groovy", "logback-test.xml", "logback.groovy", "logback.xml" }
    		// 增加"-spring"名称后缀后进行加载
    		config = getSpringInitializationConfig();
    	}
    	// 如果有配置文件
    	if (config != null) { 
    		// 加载配置文件
    		loadConfiguration(initializationContext, config, logFile);
    		return;
    	}
    	// <202106251523>
    	loadDefaults(initializationContext, logFile);
    }

`<202106251523>`处方法默认是抽象方法，具体实现在子类中，这里我们看的是LogbackLoggingSystem的实现，具体参考`3.2.2.4：loadDefaults`。

##### 3.2.2.2：setLogLevel #####

设置日志级别，源码如下：

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);
    }
    org.springframework.boot.logging.logback.LogbackLoggingSystem#setLogLevel
    public void setLogLevel(String loggerName, LogLevel level) { 
    	ch.qos.logback.classic.Logger logger = getLogger(loggerName);
    	if (logger != null) { 
    		logger.setLevel(LEVELS.convertSystemToNative(level));
    	}
    }

##### 3.2.2.3：getShutdownHandler #####

虚拟机关闭钩子，源码如下：

org.springframework.boot.logging.logback.LogbackLoggingSystem#getShutdownHandler
    public Runnable getShutdownHandler() { 
    	return new ShutdownHandler();
    }
    
    org.springframework.boot.logging.logback.LogbackLoggingSystem.ShutdownHandler
    private final class ShutdownHandler implements Runnable { 
    	@Override
    	public void run() { 
    		getLoggerContext().stop();
    	}
    }

##### 3.2.2.4：loadDefaults #####

该方法是实现`编程方式生成logback.xml`的效果，源码如下：

org.springframework.boot.logging.logback.LogbackLoggingSystem#loadDefaults
    protected void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile) { 
    	// 获取LoggerContext，并重置，重置的原因是因为要重新配置
    	LoggerContext context = getLoggerContext();
    	stopAndReset(context);
    	boolean debug = Boolean.getBoolean("logback.debug");
    	if (debug) { 
    		StatusListenerConfigHelper.addOnConsoleListenerInstance(context, new OnConsoleStatusListener());
    	}
    	// <202106251548>
    	// 创建日志配置类
    	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}}"));
    	new DefaultLogbackConfiguration(initializationContext, logFile).apply(configurator);
    	context.setPackagingDataEnabled(true);
    }

`<202106251548>`处是创建日志配置类，我们来看LogbackConfigurator,源码如下:

// 允许通过程序化的方式来配置logback，这种方式要比xml方式快些，因为省去了解析xml的时间
    class LogbackConfigurator { 
    	
    	private LoggerContext context;
    
    	LogbackConfigurator(LoggerContext context) { 
    		Assert.notNull(context, "Context must not be null");
    		this.context = context;
    	}
    
    	public LoggerContext getContext() { 
    		return this.context;
    	}
    
    	public Object getConfigurationLock() { 
    		return this.context.getConfigurationLock();
    	}
    
    	// 注册转换器，如ANSI彩色输出转换器,异常堆栈打印时打印一些空格
    	@SuppressWarnings({  "rawtypes", "unchecked" })
    	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);
    		}
    		// 可能如配置：
    		// <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    		registry.put(conversionWord, converterClass.getName());
    	}
    	// 设置appender，即日志输出的目标，如控制台通过ConsoleAppender，输出到文件通过FileAppender
    	// 相当于配置文件的如下配置：
    	/* <appender name="console" class="ch.qos.logback.core.ConsoleAppender"> ...snip... </appender> <appender name="timeFileOutput" class="ch.qos.logback.core.rolling.RollingFileAppender"> ...snip... </appender> */
    	// 通过该方法就设置了日志到哪里
    	public void appender(String name, Appender<?> appender) { 
    		appender.setName(name);
    		start(appender);
    	}
    	
    	// 设置name（一般是包名）对应的类打印日志的级别
    	// 配置文件方式可能如下：
    	/* // 设置com.example.service的日志级别为warn <logger name="com.example.service" level="WARN"/> */
    	public void logger(String name, Level level) { 
    		logger(name, level, true);
    	}
    
    	// 设置name（一般是包名）对应的类打印日志的级别
    	// 配置文件方式可能如下：
    	/* // 设置com.example.service打印日志的级别为WARN，并将日志输出到控制台console <logger name="com.example.service" level="WARN" addtivity="false"> <appender-ref ref="console"> </logger> */
    	public void logger(String name, Level level, boolean additive) { 
    		logger(name, level, additive, null);
    	}
    
    	// 配置logger，其中参数additive 为true代表使用root中配置的appender，false代表不使用
    	// 但是我测试好像都会使用root的appender，参数appender代表输出目标，可能配置如下：
    	/* <logger name="com.example.springbootintegarationspringmvc" level="WARN" addtivity="false"> <appender-ref ref="MY_CONSOLE" /> <appender-ref ref="MY_FILE" /> </logger> */
    	public void logger(String name, Level level, boolean additive, Appender<ILoggingEvent> appender) { 
    		Logger logger = this.context.getLogger(name);
    		if (level != null) { 
    			logger.setLevel(level);
    		}
    		logger.setAdditive(additive);
    		if (appender != null) { 
    			logger.addAppender(appender);
    		}
    	}
    
    	// 通过root设置日志name（一般是包名）的默认的输出日志级别(level和输出目标(appender)
    	// 如下配置是设置日志级别为INFO，输出目标为控制台
    	/* <root level="INFO"> // 注意这里的MY_CONSOLE需要通过appender标签进行定义，这里只是示意 <appender-ref ref="MY_CONSOLE" /> </root> */
    	// 如果是某个name（一般是包名）的logger没有配置专门的logger标签，则使用root
    	@SafeVarargs
    	public final void root(Level level, Appender<ILoggingEvent>... appenders) { 
    		Logger logger = this.context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    		if (level != null) { 
    			logger.setLevel(level);
    		}
    		for (Appender<ILoggingEvent> appender : appenders) { 
    			logger.addAppender(appender);
    		}
    	}
    
    	public void start(LifeCycle lifeCycle) { 
    		if (lifeCycle instanceof ContextAware) { 
    			((ContextAware) lifeCycle).setContext(this.context);
    		}
    		lifeCycle.start();
    	}
    
    }

[Link 1]: https://blog.csdn.net/wang0907/article/details/117712056
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/f1eff8c48dbb44a4bd9fefd668398a0a.png
[Link 2]: https://blog.csdn.net/wang0907/article/details/116232260