前言：常见的日志

• nginx日志：

127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /plugins/normalize-css/normalize.css HTTP/1.1" 200 8053 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET / HTTP/1.1" 200 57621 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /static/css/page-learing-article.css HTTP/1.1" 404 582 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /static/plugins/bootstrap/dist/css/bootstrap.css HTTP/1.1" 404 582 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /css/page-learing-index.css HTTP/1.1" 200 25403 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /css/main.css HTTP/1.1" 200 39 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"

• Tomcat日志：

01-Aug-2019 08:42:19.365 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Server version:        Apache Tomcat/8.5.31
01-Aug-2019 08:42:19.422 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Server built:          Apr 27 2018 20:24:25 UTC
01-Aug-2019 08:42:19.425 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Server number:         8.5.31.0
01-Aug-2019 08:42:19.427 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log OS Name:               Windows 7
01-Aug-2019 08:42:19.428 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log OS Version:            6.1
01-Aug-2019 08:42:19.429 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Architecture:          amd64
01-Aug-2019 08:42:19.430 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Java Home:             C:\Program Files\Java\jdk1.8.0_131\jre
01-Aug-2019 08:42:19.432 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log JVM Version:           1.8.0_131-b11
01-Aug-2019 08:42:19.433 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log JVM Vendor:            Oracle Corporation
01-Aug-2019 08:42:19.434 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log CATALINA_BASE:         D:\Program Files\cas\apache-tomcat-8.5.31
01-Aug-2019 08:42:19.436 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log CATALINA_HOME:         D:\Program Files\cas\apache-tomcat-8.5.31
01-Aug-2019 08:42:19.437 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Command line argument: -Djava.util.logging.config.file=D:\Program Files\cas\apache-tomcat-8.5.31\conf\logging.properties
01-Aug-2019 08:42:19.438 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Command line argument: -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager
01-Aug-2019 08:42:19.440 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Command line argument: -Djdk.tls.ephemeralDHKeySize=2048

一、 从Tomcat的日志说起

Tomcat中的日志其实是对jul的一层封装

二、乱乱的日志体系

2.1 日志发展史

问题：

1. 控制日志输出的内容和格式
2. 控制日志输出的位置
3. 日志优化：异步日志，日志文件的归档和压缩
4. 日志系统的维护
5. 面向接口开发 -- 日志的门面

日志门面 JCL、slf4j

日志实现 JUL、logback、log4j、log4j2

jul

入门使用

Loggers：被称为记录器，调用其API来来发布日志信息。指定日志级别，日志内容 Handler：指定日志位置，格式化信息

package com.zs.blog;

import org.junit.jupiter.api.Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class JULTest {
    @Test
    public void testQuick() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.itheima.log.JULTest");
        // 2.日志记录输出
        logger.info("hello jul");
        // 3. 通用方法进行记录
        logger.log(Level.INFO, "info msg");
        // 4. 日志内容占位符的使用
        String name = "jack"; Integer age = 18; logger.log(Level.INFO, "用户信息：{0},{1}", new Object[]{name, age});
    }
}

日志级别

/**
     * 洋红色日志：System.err
     * 只输出info后面的日志信息：默认配置的日志级别是info
     */
    @Test
    public void test01(){
        Logger logger = Logger.getLogger("abc");
        // 2.日志记录输出 all < finest < finer < fine < config < info < warning < severe < off
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

父子关系

/**
 * LogManager$RootLogger 是 logger1 的父级
 * logger1 是 logger2 的父级
 * logger2 是 logger3 的父级
 */
@Test
public void test02(){
    //所有的logger默认的父级是java.util.loggering.LogManager$RootLogger
    Logger logger1 = Logger.getLogger("a");
    Logger logger2 = Logger.getLogger("a.b");
    Logger logger3 = Logger.getLogger("a.b.c");
}
将logger对象的日志级别，以及将父级的Handler的输出级别改为all 即可输出所有级别的日志了
@Test
public void test01(){
    Logger logger = Logger.getLogger("abc");
    //设置 logger的级别
    logger.setLevel(Level.ALL);

    //获取到父级并设置Handler（appender）的级别
    Handler[] handlers = logger.getParent().getHandlers();
    for (Handler handler : handlers) {
        handler.setLevel(Level.ALL);
    }

    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

使用自己的Handler

@Test
public void test03(){
    Logger logger = Logger.getLogger("a");

    ConsoleHandler selfHandler = new ConsoleHandler();
    //设置自己的Handler
    logger.addHandler(selfHandler);
    //不在使用父级的Handler，解决日志重复输出
    logger.setUseParentHandlers(false);

    logger.info("info");
}

自定义日志级别配置

  @Test
    public void testLogConfig() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.itheima.log.JULTest");


        // 一、自定义日志级别
        // a.关闭系统默认配置
        logger.setUseParentHandlers(false);
        // b.创建handler对象
        ConsoleHandler consoleHandler = new ConsoleHandler();
        // c.创建formatter对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        // d.进行关联
        consoleHandler.setFormatter(simpleFormatter);
        logger.addHandler(consoleHandler);
        // e.设置日志级别
        logger.setLevel(Level.ALL);
        consoleHandler.setLevel(Level.ALL);


        // 二、输出到日志文件
        FileHandler fileHandler = new FileHandler("d:/logs/jul.log");
        fileHandler.setFormatter(simpleFormatter);
        logger.addHandler(fileHandler);


        // 2.日志记录输出
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("cofnig");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

配置文件

jre文件夹中

默认配置文件路径$JAVAHOME\jre\lib\logging.properties

handlers= java.util.logging.ConsoleHandler
# 配置全局的Logger的级别
.level= INFO

# 文件输出的规则
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# 控制台输出规则
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# 指定包的日志级别
com.xyz.foo.level = SEVERE

读取配置文件

static LogManager logManager = LogManager.getLogManager();
static {
    try {
        logManager.readConfiguration(JulService.class.getClassLoader()
        .getResourceAsStream("logging.properties"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

测试代码如下

@Test
    public void testProperties() throws Exception {
        // 读取自定义配置文件 
        InputStream in = JULTest.class.getClassLoader().getResourceAsStream("logging.properties");
        // 获取日志管理器对象 
        LogManager logManager = LogManager.getLogManager();
        // 通过日志管理器加载配置文件 
        logManager.readConfiguration(in); 


        Logger logger = Logger.getLogger("com.itheima.log.JULTest");
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

## RootLogger使用的处理器（获取时设置）
handlers= java.util.logging.ConsoleHandler
# RootLogger日志等级
.level= INFO


## 自定义Logger
com.jf3q.part8_log.test.handlers= java.util.logging.FileHandler
# 自定义Logger日志等级
com.jf3q.part8_log.test.level= INFO
# 忽略父日志设置
com.jf3q.part8_log.test.useParentHandlers=false



## 控制台处理器
# 输出日志级别
java.util.logging.ConsoleHandler.level = INFO
# 输出日志格式
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# 指定handler对象的日志消息格式对象
java.util.logging.ConsoleHandler.encoding = UTF-8
# 指定日志输出的格式
java.util.logging.SimpleFormatter.format="%4$s: %5$s [%1$tc]%n"


## 文件处理器
# 输出日志级别
java.util.logging.FileHandler.level=INFO
# 输出日志格式
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
# 输出日志文件路径
java.util.logging.FileHandler.pattern = /java%u.log
# 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.limit = 50000
# 输出日志文件限制个数
java.util.logging.FileHandler.count = 10
# 输出日志文件 是否是追加
java.util.logging.FileHandler.append=true

日志原理解析

1. 初始化LogManager

1. LogManager加载logging.properties配置
2. 添加Logger到LogManager

1. 从单例LogManager获取Logger
2. 设置级别Level，并指定日志记录LogRecord
3. Filter提供了日志级别之外更细粒度的控制
4. Handler是用来处理日志输出位置
5. Formatter是用来格式化LogRecord的

log4j （最后更新2012年）

可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以更灵活的控制日志的输出过程。 官方网站： http://logging.apache.org/log4j/1.2/

Log4j 只维护到 2012年的1.2.17版本

开创了日志的分级别输出思想

log4j入门

添加依赖

<dependency> 
	<groupId>log4j</groupId> 
	<artifactId>log4j</artifactId> 
	<version>1.2.17</version> 
</dependency> 
<dependency> 
	<groupId>junit</groupId> 
	<artifactId>junit</artifactId> 
	<version>4.12</version>
</dependency> 

java代码

package com.zs.blog;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;
import org.junit.jupiter.api.Test;

public class Log4jTest {
    @Test
    public void testQuick() throws Exception {
        // 初始化系统配置，不需要配置文件
        BasicConfigurator.configure();


        // 创建日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");


        // 日志级别
        logger.fatal("fatal"); 	// 严重错误，一般会造成系统崩溃和终止运行
        logger.error("error"); 	//** 错误信息，但不会影响系统运行
        logger.warn("warn"); 	//** 警告信息，可能会发生问题
        logger.info("info"); 	//** 程序运行信息，数据库的连接、网络、IO操作等
        logger.debug("debug"); 	//** 调试信息，一般在开发阶段使用，记录程序的变量、参 数等
        logger.trace("trace"); 	// 追踪信息，记录程序的所有流程信息
    }
}

日志的级别

* 每个Logger都被了一个日志级别（log level），用来控制日志信息的输出。日志级别从高到低分 为：

fatal 指出每个严重的错误事件将会导致应用程序的退出。

error 指出虽然发生错误事件，但仍然不影响系统的继续运行。

warn 表明会出现潜在的错误情形。

info 一般和在粗粒度级别上，强调应用程序的运行全程。

debug 一般用于细粒度级别上，对调试应用程序非常有帮助。

trace 是程序追踪，可以用于输出程序运行中的变量，显示执行的流程。

* 还有两个特殊的级别：

OFF，可用来关闭日志记录。

ALL，启用所有消息的日志记录。

注：一般只使用4个级别，优先级从高到低为 ERROR > WARN > INFO > DEBUG

Log4j组件

Log4J 主要由 Loggers (日志记录器)、Appenders（输出端）和 Layout（日志格式化器）组成。 其中 Loggers 控制日志的输出级别与日志是否输出； Appenders 指定日志的输出方式（输出到控制台、文件等）； Layout 控制日志信息的输出格式。

Loggers（同样的父子关系）

日志记录器，负责收集处理日志记录,实例的命名就是类“XX”的full quailied name（类的全限定名）， Logger的名字大小写敏感，其命名有继承机制：例如：name为org.apache.commons的logger会继承 name为org.apache的logger。

Log4J中有一个特殊的logger叫做“root”，他是所有logger的根，也就意味着其他所有的logger都会直接 或者间接地继承自root。root logger可以用Logger.getRootLogger()方法获取。

但是，自log4j 1.2版以来， Logger 类已经取代了 Category 类。对于熟悉早期版本的log4j的人来说， Logger 类可以被视为 Category 类的别名。

Appenders（输出位置）

Appender 用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。Log4j 常用的输出目的地 有以下几种：

Layouts（输出格式）

布局器 Layouts用于控制日志输出内容的格式，让我们可以使用各种需要的格式输出日志。Log4j常用的Layouts:

配置文件

日志配置文件

配置文件名称(源码位置)

log4j.properties或log4j.xml

.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/LogManager.class:25

配置文件位置（源码位置）

类路径下

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/LogManager.class:115

读取配置文件内部信息（源码位置）

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/LogManager.class:132

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/helpers/OptionConverter.class:303

具体如何配置

rootLogger 顶层父级（源码位置）

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:44

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:232

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:295

appender 输出器配置、layout 格式化器（源码位置）

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:337

入门案例，使用配置文件

package com.zs.logger;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;
import org.junit.Test;

public class Log4jTest {
    @Test
    public void testQuick() throws Exception {
        // 初始化系统配置，不需要配置文件
        //BasicConfigurator.configure();


        // 创建日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");


        // 日志级别
        logger.fatal("fatal"); 	// 严重错误，一般会造成系统崩溃和终止运行
        logger.error("error"); 	//** 错误信息，但不会影响系统运行
        logger.warn("warn"); 	//** 警告信息，可能会发生问题
        logger.info("info"); 	//** 程序运行信息，数据库的连接、网络、IO操作等
        logger.debug("debug"); 	//** 调试信息，一般在开发阶段使用，记录程序的变量、参 数等
        logger.trace("trace"); 	// 追踪信息，记录程序的所有流程信息
    }
}

配置示例1

log4j.properties

# rootLooger的日志级别，以及appenders
log4j.rootLogger = trace,stdout

# 配置简单控制台appender对象
# 使用控制台appender
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
# 日志格式：简单格式
log4j.appender.stdout.layout = org.apache.log4j.SimpleLayout

配置示例2

# rootLooger的日志级别，以及appenders
log4j.rootLogger = trace,stdout

# 使用控制台appender，其中stdout是自定义的
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
# 输出目的地
log4j.appender.stdout.Target = System.out
# appender的日志级别
log4j.appender.stdout.Threshold = info
# 日志格式：简单格式
#log4j.appender.stdout.layout = org.apache.log4j.SimpleLayout
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
# %d{yyyy-MM-dd HH:mm:ss}：指定日期格式
# %-5p：日志级别     %20c：全类名    %L：第几行      %m：自己打印的message     %n：换行
log4j.appender.stdout.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %20c %L:%m %n


# 配置文件appender，输出到文件，而且每天一个文件
log4j.appender.a1 = org.apache.log4j.DailyRollingFileAppender
# 这里的目录不需要提前创建
log4j.appender.a1.file = ${user.home}/log-demo/log4j/a1.log
log4j.appender.a1.threshold = info
log4j.appender.a1.layout = org.apache.log4j.PatternLayout
log4j.appender.a1.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %20c %L:%m %n



log4j.appender.a2 = org.apache.log4j.RollingFileAppender
log4j.appender.a2.file = ${user.home}/log-demo/log4j/a2.log
# 单个文件最大100MB
log4j.appender.a2.maxFileSize = 100MB
# 最多保留7个日志文件
log4j.appender.a2.maxBackupIndex = 7
log4j.appender.a2.threshold = info
log4j.appender.a2.layout = org.apache.log4j.PatternLayout
log4j.appender.a2.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %20c %L:%m %n

# 还可以保存7天的日志文件 crontab
# find /home/zhao/logs/ -type f -mtime +7 -exec rm -f {} \;

#mysql 将日志保存到数据库
log4j.appender.logDB=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.logDB.layout=org.apache.log4j.PatternLayout
log4j.appender.logDB.Driver=com.mysql.jdbc.Driver
log4j.appender.logDB.URL=jdbc:mysql://localhost:3306/test
log4j.appender.logDB.User=root
log4j.appender.logDB.Password=root
log4j.appender.logDB.Sql=INSERT INTO
log(project_name,create_date,level,category,file_name,thread_name,line,all_categ
ory,message) values('itcast','%d{yyyy-MM-dd
HH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')

# 注意：父子类都指定同一个appender时会出现日志重复问题
# 自定义logger对象设置
log4j.logger.com.zs.log.log4j = ERROR,a1

CREATE TABLE `log` (
`log_id` int(11) NOT NULL AUTO_INCREMENT,
`project_name` varchar(255) DEFAULT NULL COMMENT '目项名',
`create_date` varchar(255) DEFAULT NULL COMMENT '创建时间',
`level` varchar(255) DEFAULT NULL COMMENT '优先级',
`category` varchar(255) DEFAULT NULL COMMENT '所在类的全名',
`file_name` varchar(255) DEFAULT NULL COMMENT '输出日志消息产生时所在的文件名称 ',
`thread_name` varchar(255) DEFAULT NULL COMMENT '日志事件的线程名',
`line` varchar(255) DEFAULT NULL COMMENT '号行',
`all_category` varchar(255) DEFAULT NULL COMMENT '日志事件的发生位置',
`message` varchar(4000) DEFAULT NULL COMMENT '输出代码中指定的消息',
PRIMARY KEY (`log_id`)
);

日志门面

我们为什么要使用日志门面：

1. 面向接口开发，不再依赖具体的实现类。减少代码的耦合
2. 项目通过导入不同的日志实现类，可以灵活的切换日志框架
3. 统一API，方便开发者学习和使用
4. 统一配置便于项目日志的管理

常见的日志门面 ： JCL、slf4j 常见的日志实现： JUL、log4j、logback、log4j2

日志框架出现的历史顺序： log4j -->JUL-->JCL--> slf4j --> logback --> log4j2

jcl（了解，最后更新2014年）

Jakarta Commons Logging.commons-logging.jar 2014年 1.2

• jakarta
• 运行时获取具体日志：org.apache.commons.logging.LogFactoryImpl#discoverLogImplementation

默认使用的是jul的日志

<dependency> 
	<groupId>commons-logging</groupId> 
	<artifactId>commons-logging</artifactId> 
	<version>1.2</version> 
</dependency>

public class JULTest { 
	@Test 
	public void testQuick() throws Exception { 
		// 创建日志对象 
		Log log = LogFactory.getLog(JULTest.class); 
		// 日志记录输出 
		log.fatal("fatal"); 
		log.error("error"); 
		log.warn("warn"); 
		log.info("info"); 
		log.debug("debug"); 
	} 
}

如何切换成log4j

1、引入log4j

2、配置log4j.properties

原理

1. 通过LogFactory动态加载Log实现类
2. 日志门面支持的日志实现数组

private static final String[] classesToDiscover = 
new String[]{"org.apache.commons.logging.impl.Log4JLogger", 
"org.apache.commons.logging.impl.Jdk14Logger", 
"org.apache.commons.logging.impl.Jdk13LumberjackLogger", 
"org.apache.commons.logging.impl.SimpleLog"};

1. 获取具体的日志实现

for(int i = 0; i < classesToDiscover.length && result == null; ++i) { 
	result = this.createLogFromClass(classesToDiscover[i], logCategory, true); 
}

SLF4j的使用

简单日志门面(Simple Logging Facade For Java) SLF4J主要是为了给Java日志访问提供一套标准、规范 的API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如log4j和logback等。 当然slf4j自己也提供了功能较为简单的实现，但是一般很少用到。对于一般的Java项目而言，日志框架 会选择slf4j-api作为门面，配上具体的实现框架（log4j、logback等），中间使用桥接器完成桥接。

官方网站： https://www.slf4j.org/

SLF4J入门

• 添加依赖

   <!--slf4j 门面:只要用slf4j做日志门面，这个就必须写！！！！-->
        <dependency>
            <groupId>org.slf4j</groupId>
              <artifactId>slf4j-api</artifactId>
          </dependency>
        <!--slf4j简单实现-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </dependency>

• java代码

package com.zs.blog;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Slf4jTest {

    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);


    @Test
    public void testQuick() throws Exception {
        // 日志级别
        LOGGER.error("error 中文"); // 错误信息，但不会影响系统运行
        LOGGER.warn("warn 中文"); // 警告信息，可能会发生问题
        LOGGER.info("info 中文"); // 程序运行信息，数据库的连接、网络、IO操作等
        LOGGER.debug("debug 中文"); // 调试信息，一般在开发阶段使用，记录程序的变量、参 数等
        LOGGER.trace("trace 中文"); // 追踪信息，记录程序的所有流程信息

        LOGGER.info("用户：{},年龄 {}","zs",18);

        //将系统异常信息输出
        try {
            int i =1/0;
        } catch (Exception e) {
            LOGGER.error("出现异常",e);
        }
    }
}

日志的实现（Binding）

使用slf4j的日志绑定流程:

1. 添加slf4j-api的依赖

2. 使用slf4j的API在项目中进行统一的日志记录

3. 绑定具体的日志实现框架

3.1. 绑定已经实现了slf4j的日志框架,直接添加对应依赖

3.2. 绑定没有实现slf4j的日志框架,先添加日志的适配器,再添加实现类的依赖

4. slf4j有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

• 绑定slf4j-simple 、logback 、nop这些遵循slf4j技术的（在slf4j火起来之后的技术）

<!--slf4j 门面-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.26</version>
</dependency> 
<!--以下三个日志实现任选一个-->
<!--以下三个日志实现任选一个-->
<!--以下三个日志实现任选一个-->


<!--slf4j简单实现-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.21</version>
</dependency>
<!-- logback-->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
<!-- nop 日志开关，加上这个就日志无效了-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.27</version>
</dependency>

• 绑定老牌的日志实现,需要导入适配器

log4j

<!-- log4j-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.27</version>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

jul

<!-- jul 导入适配器即可，因为这个是基于jdk的 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-jdk14</artifactId>
  <version>1.7.27</version>
</dependency>

SLF4J桥接旧的日志框架

比如之前是用的log4j这种老的日志框架写的，现在想升级slf4j结合logback的形式.但又不想改代码，那就可以用slf4j的桥接功能（把旧的log4j的依赖去掉，logback依赖加入 ，slf4-api的依赖加入，再加一个log4j和slf4j之间的桥接器依赖即可）

迁移的方式： 如果我们要使用SLF4J的桥接器，替换原有的日志框架，那么我们需要做的第一件事情，就是删除掉原 有项目中的日志框架的依赖。然后替换成SLF4J提供的桥接器。

<!-- log4j-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>
<!-- jul -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jul-to-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>
<!--jcl -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>

注意问题：

1. jcl-over-slf4j.jar和 slf4j-jcl.jar不能同时部署。前一个jar文件将导致JCL将日志系统的选择委托给 SLF4J，后一个jar文件将导致SLF4J将日志系统的选择委托给JCL，从而导致无限循环
2. log4j-over-slf4j.jar和slf4j-log4j12.jar不能同时出现
3. jul-to-slf4j.jar和slf4j-jdk14.jar不能同时出现
4. 所有的桥接都只对Logger日志记录器对象有效，如果程序中调用了内部的配置类或者是 Appender,Filter等对象，将无法产生效果。

Logback的使用

Logback是由log4j创始人设计的另一个开源日志组件，性能比log4j要好。 官方网站：https://logback.qos.ch/index.html

Logback主要分为三个模块：

• logback-core：其它两个模块的基础模块
• logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API
• logback-access：访问模块与Servlet容器集成提供通过Http来访问日志的功能

后续的日志代码都是通过SLF4J日志门面搭建日志系统，所以在代码是没有区别，主要是通过修改配置 文件和pom.xml依赖

logback入门

1. 添加依赖

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

1. java代码

package com.zs.blog;


import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogbackTest {


    //定义日志对象
    public final static Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);


    @Test
    public void testQuick() throws Exception {
        // 日志级别
        LOGGER.error("error 中文"); // 错误信息，但不会影响系统运行
        LOGGER.warn("warn 中文"); // 警告信息，可能会发生问题
        LOGGER.info("info 中文"); // 程序运行信息，数据库的连接、网络、IO操作等
        LOGGER.debug("debug 中文"); // 调试信息，一般在开发阶段使用，记录程序的变量、参 数等
        LOGGER.trace("trace 中文"); // 追踪信息，记录程序的所有流程信息

        LOGGER.info("用户：{},年龄 {}","zs",18);

        //将系统异常信息输出
        try {
            int i =1/0;
        } catch (Exception e) {
            LOGGER.error("出现异常",e);
        }
    }
}

logback配置

logback会依次读取以下类型配置文件：

• logback.groovy
• logback-test.xml
• logback.xml 如果均不存在会采用默认配置

1. logback组件之间的关系

1. Logger:日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也 可以定义日志类型、级别。
2. Appender:用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等。
3. Layout:负责把事件转换成字符串，格式化的日志信息的输出。在logback中Layout对象被封 装在encoder中。

1. 配置

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!--##################################################配置集中管理属性##################################################-->
    <!--
        日志输出格式：
            %-5level
            %d  {yyyy-MM-dd HH:mm:ss.SSS}日期
            %c  类的完整名称
            %M  为method
            %L  为行号
            %thread 线程名称
            %m  或者 %msg 为信息
            %n  换行
     -->
    <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %c [%thread] %-5level %msg%n"/>
    <property name="pattern2" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %line: %msg%n"/>

    <!-- 日志文件存放目录
            value="/logs" : 绝对路径
            value="logs" : 项目根路径
    -->
    <property name="log_dir" value="logs"></property>
    <!--###############################################################################################################-->


    <!--##############################################控制台日志输出appender##############################################-->
    <!--
        Appender: 设置日志信息的去向,常用的有以下几个
            ch.qos.logback.core.ConsoleAppender (控制台)
            ch.qos.logback.core.rolling.RollingFileAppender (文件大小到达指定尺 寸的时候产生一个新文件)
            ch.qos.logback.core.FileAppender (文件)
    -->
    <!--控制台appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!--输出流对象 默认 System.out 改为 System.err-->
        <target>System.err</target>
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>


    <!--fileappender-->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        <!--日志输出路径-->
        <file>${log_dir}/logback.log</file>
    </appender>

    <!-- 生成html格式appender对象 -->
    <appender name="htmlfile" class="ch.qos.logback.core.FileAppender">
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>%level%d{yyyy-MM-dd HH:mm:ss}%c%M%L%thread%m</pattern>
                <!--                <pattern>${pattern}</pattern>-->
            </layout>
            <!--日志输出路径-->
            <file>${log_dir}/logback.html</file>
        </encoder>
    </appender>

    <!-- 日志文件拆分和归档的appender对象-->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--日志输出路径-->
        <file>${log_dir}/roll_logback.log</file>

        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
<!--        <encoder>-->
<!--            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %line: %msg%n</pattern>-->
<!--            <charset>UTF-8</charset>-->
<!--        </encoder>-->

        <!--指定日志文件拆分和压缩策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--通过指定压缩文件名称，来确定分割文件方式-->
<!--            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz</fileNamePattern>-->
<!--            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i</fileNamePattern>-->
            <fileNamePattern>${log_dir}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!--单个日志文件最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!--归档日志将保留过去30天-->
            <maxHistory>30</maxHistory>
            <!--归档日志总大小-->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>


        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--设置拦截日志级别-->
            <level>info</level> <!--error级别输出-->
            <onMatch>ACCEPT</onMatch><!--超过这个级别的就放行 -->
            <onMismatch>DENY</onMismatch><!--小于这个级别的就拦截 -->
        </filter>
    </appender>

    <!--异步日志-->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="rollFile"/>
    </appender>
    <!--###############################################################################################################-->

    <!--################################################logger日志记录器################################################-->
    <!--日志记录器对象-->
    <!--
        用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。
        <loger>仅有一个name属性，一个可选的level和一个可选的addtivity属性
        name:
            用来指定受此logger约束的某一个包或者具体的某一个类。
        level:
            用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，如果未设置此属性，那么当前logger将会继承上级的级别。
        additivity:
            是否向上级loger传递打印信息。默认是true。 false:表示不重复输出
        <logger>可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个 logger
    -->
    <!--自定义logger
        additivity表示是否从 rootLogger继承配置
    -->
    <logger name="com.zs.blog" level="warn" additivity="false">
        <appender-ref ref="console"/>
    </logger>

    <!--
        也是<logger>元素，但是它是根logger。默认debug
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        <root>可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个 logger。
    -->
    <root level="ALL">
        <appender-ref ref="console"/>
        <!--        <appender-ref ref="file"/>-->
        <!--        <appender-ref ref="htmlfile"/>-->
        <!--        <appender-ref ref="rollFile"/>-->
        <appender-ref ref="async"/>
    </root>
    <!--###############################################################################################################-->

</configuration>

1. 官方提供的log4j.properties转换成logback.xml

https://logback.qos.ch/translator/services/propertiesTranslator.html 生成后的logback的内容中 的格式信息需要修改即可

logback-access的使用

logback-access模块与Servlet容器（如Tomcat和Jetty）集成，以提供HTTP访问日志功能。我们可以使 用logback-access模块来替换tomcat的访问日志。

1. 将logback-access.jar与logback-core.jar复制到$TOMCAT_HOME/lib/目录下
2. 修改$TOMCAT_HOME/conf/server.xml中的Host元素中添加：

<Valve className="ch.qos.logback.access.tomcat.LogbackValve" />

1. logback默认会在$TOMCAT_HOME/conf下查找文件 logback-access.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- always a good activate OnConsoleStatusListener -->
    <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>
    <property name="LOG_DIR" value="${catalina.base}/logs"/>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_DIR}/access.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>access.%d{yyyy-MM-dd}.log.zip</fileNamePattern>
        </rollingPolicy>

        <encoder> 
        	<!-- 访问日志的格式 -->
            <pattern>combined</pattern>
        </encoder>
    </appender>
    <appender-ref ref="FILE"/>
</configuration>

1. 官方配置： https://logback.qos.ch/access.html#configuration

log4j2

前面提到，log4j由apache宣布，2015年后，不再维护。推荐大家升级到log4j2，虽然log4j2沿袭了log4j的思想，然而log4j2和log4j完全是两码事，并不兼容。

log4j2以性能著称，它⽐其前身Log4j 1.x提供了重大改进，同时类⽐logback，它提供了Logback中可⽤的许多改进，同时修复了Logback架构中的一些固有问题。功能上，它有着和Logback相同的基本操作，同时又有自己独特的部分，⽐如：插件式结构、配置文件优化、异步日志等。

pom：

<!-- Log4j2 门面API-->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-api</artifactId>
  <version>2.11.1</version>
</dependency>
<!-- Log4j2 日志实现 -->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.11.1</version>
</dependency>

代码：

// 定义日志记录器对象
    public static final Logger LOGGER = LogManager.getLogger(Log4j2Test.class);

    // 快速入门
    @Test
    public void testQuick()throws Exception{
        // 日志消息输出
        LOGGER.fatal("fatal");
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("inf");
        LOGGER.debug("debug");
        LOGGER.trace("trace");


    }

配置：log4j2默认加载classpath下的 log4j2.xml 文件中的配置。

<?xml version="1.0" encoding="UTF-8"?>
<!--
    status="warn" 日志框架本身的输出日志级别
    monitorInterval="5" 自动加载配置文件的间隔时间，不低于 5 秒
-->
<Configuration status="debug" monitorInterval="5">

    <!--
        集中配置属性进行管理
        使用时通过:${name}
    -->
    <properties>
        <property name="LOG_HOME">/logs</property>
    </properties>

    <!--日志处理-->
    <Appenders>
        <!--控制台输出 appender-->
        <Console name="Console" target="SYSTEM_ERR">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
        </Console>

        <!--日志文件输出 appender-->
        <File name="file" fileName="${LOG_HOME}/myfile.log">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </File>

        <!--<Async name="Async">-->
            <!--<AppenderRef ref="file"/>-->
        <!--</Async>-->

        <!--使用随机读写刘的日志文件输出 appender，性能提高-->
        <RandomAccessFile name="accessFile" fileName="${LOG_HOME}/myAcclog.log">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </RandomAccessFile>

        <!--按照一定规则拆分的日志文件的 appender-->
        <RollingFile name="rollingFile" fileName="${LOG_HOME}/myrollog.log"
                     filePattern="/logs/$${date:yyyy-MM-dd}/myrollog-%d{yyyy-MM-dd-HH-mm}-%i.log">
            <!--日志级别过滤器-->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" />
            <!--日志消息格式-->
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %msg%n" />
            <Policies>
                <!--在系统启动时，出发拆分规则，生产一个新的日志文件-->
                <OnStartupTriggeringPolicy />
                <!--按照文件大小拆分，10MB -->
                <SizeBasedTriggeringPolicy size="10 MB" />
                <!--按照时间节点拆分，规则根据filePattern定义的-->
                <TimeBasedTriggeringPolicy />
            </Policies>
            <!--在同一个目录下，文件的个数限定为 30 个，超过进行覆盖-->
            <DefaultRolloverStrategy max="30" />
        </RollingFile>

    </Appenders>

    <!--logger 定义-->
    <Loggers>


        <!--自定义异步 logger 对象
            includeLocation="false" 关闭日志记录的行号信息
            additivity="false" 不在继承 rootlogger 对象
        -->
        <AsyncLogger name="com.itheima" level="trace" includeLocation="false" additivity="false">
            <AppenderRef ref="Console"/>
        </AsyncLogger>


        <!--使用 rootLogger 配置 日志级别 level="trace"-->
        <Root level="trace">
            <!--指定日志使用的处理器-->
            <AppenderRef ref="Console" />

            <!--使用异步 appender-->
            <!--<AppenderRef ref="Async" />-->
        </Root>
    </Loggers>
</Configuration>

现在主流的是是用slf4j作为日志门面，而不是用log4j2自带的日志门面,所以要在前面的依赖基础上外加下面两个依赖

<!--使用slf4j作为日志的门面,使用log4j2来记录日志 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.25</version>
</dependency>
<!--为slf4j绑定日志实现 log4j2的适配器 -->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j-impl</artifactId>
  <version>2.10.0</version>
</dependency>

最大亮点异步日志

Log4j2提供了两种实现日志的方式，一个是通过AsyncAppender，一个是通过AsyncLogger，分别对应

前面我们说的Appender组件和Logger组件。

注意：配置异步日志需要添加依赖

<!--异步日志依赖-->
<dependency>
  <groupId>com.lmax</groupId>
  <artifactId>disruptor</artifactId>
  <version>3.3.4</version>
</dependency>

1.AsyncAppender方式 (不推荐)

以下两处注释的地方放开即可

2. AsyncLogger方式 （推荐）

AsyncLogger才是log4j2 的重头戏，也是官方推荐的异步方式。它可以使得调用Logger.log返回的

更快。你可以有两种选择：全局异步和混合异步。

全局异步就是，所有的日志都异步的记录，在配置文件上不用做任何改动，只需要添加一个

log4j2.component.properties 配置；

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

混合异步就是，你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加

灵活。

如上配置： com.itheima 日志是异步的，root日志是同步的。

使用异步日志需要注意的问题：

1. 如果使用异步日志，AsyncAppender、AsyncLogger和全局日志，不要同时出现。性能会和

AsyncAppender一致，降至最低。

2. 设置includeLocation=false ，打印位置信息会急剧降低异步日志的性能，比同步日志还要

慢。

另一个亮点无垃圾记录

垃圾收集暂停是延迟峰值的常见原因，并且对于许多系统而言，花费大量精力来控制这些暂停。

许多日志库（包括以前版本的Log4j）在稳态日志记录期间分配临时对象，如日志事件对象，字符串，

字符数组，字节数组等。这会对垃圾收集器造成压力并增加GC暂停发生的频率。

从版本2.6开始，默认情况下Log4j以“无垃圾”模式运行，其中重用对象和缓冲区，并且尽可能不分配临

时对象。还有一个“低垃圾”模式，它不是完全无垃圾，但不使用ThreadLocal字段。

Log4j 2.6中的无垃圾日志记录部分通过重用ThreadLocal字段中的对象来实现，部分通过在将文本转换

为字节时重用缓冲区来实现。

使用Log4j 2.5：内存分配速率809 MB /秒，141个无效集合。

springboot项目

1.springboot 底层默认使用logback作为日志实现。
2.使用了SLF4]作为日志门面
3.将JUL也转换成sIf4j
4.也可以使用log4i2作为日志门面，但是最终也是通过sIf4i调用logback

使用默认的logback

测试类

@SpringBootTest
class SpringbootLogApplicationTests {

    // 声明日志记录器对象
    public static final Logger LOGGER = LoggerFactory.getLogger(SpringbootLogApplicationTests.class);

    @Test
    public void contextLoads() {
        // 打印日志信息
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); // 默认日志级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");

        // 使用 log4j2 使用桥接器切换为 slf4j 门面和 logback 日志实现
        org.apache.logging.log4j.Logger logger = LogManager.getLogger(SpringbootLogApplicationTests.class);
        logger.info("log4j2 info");
    }

}

application.properties配置文件（后面切换成log4j2也照样用这个）

# 指定自定义 logger 对象日志级别
logging.level.com.itheima=trace

# 指定控制台输出消息格式
logging.pattern.console=[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c [%thread]===== %msg %n

# 指定存放日志文件的具体路径
# logging.file=/logs/springboot.log
# 指定日志文件存放的目录，默认的文件名 spring.log
logging.file.path=/logs/springboot/
# 指定日志文件消息格式
logging.pattern.file=[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c [%thread]===== %msg %n

# 指定项目使用的具体环境
spring.profiles.active=pro

logback-spring.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration>


    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] -------- %m %n"></property>



    <!--控制台日志输出的 appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!--控制输出流对象 默认 System.out 改为 System.err-->
        <target>System.err</target>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <springProfile name="dev">
                <pattern>${pattern}</pattern>
            </springProfile>
            <springProfile name="pro">
                <pattern>[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] xxxxxxxx %m %n</pattern>
            </springProfile>
        </encoder>
    </appender>



    <!--自定义 looger 对象
        additivity="false" 自定义 logger 对象是否继承 rootLogger
     -->
    <logger name="com.itheima" level="info" additivity="false">
        <appender-ref ref="console"/>
    </logger>
</configuration>

切换成log4j2

依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <!--排除 logback 日志实现-->
                <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--使用 log4j2 的日志启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>

日志配置文件：log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
    status="warn" 日志框架本身的输出日志级别
    monitorInterval="5" 自动加载配置文件的间隔时间，不低于 5 秒
-->
<Configuration status="debug" monitorInterval="5">


    <!--日志处理-->
    <Appenders>
        <!--控制台输出 appender-->
        <Console name="Console" target="SYSTEM_ERR">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
        </Console>

    </Appenders>

    <!--logger 定义-->
    <Loggers>


        <!--使用 rootLogger 配置 日志级别 level="trace"-->
        <Root level="trace">
            <!--指定日志使用的处理器-->
            <AppenderRef ref="Console" />

        </Root>
    </Loggers>
</Configuration>