快速了解常用日志技术(JCL、Slf4j、JUL、Log4j、Logback、Log4j2)

灰太狼 2023-10-05 17:08 11阅读 0赞

[一、快速了解常用日志技术(JCL、Slf4j、JUL、Log4j、Logback、Log4j2)][JCL_Slf4j_JUL_Log4j_Logback_Log4j2]

[二、log4j2配置文件log4j2.xml][log4j2_log4j2.xml]

--------------------

### 文章目录 ###

*   *  一、简介
     *  二、日志门面
     *  三、Spring Boot 使用Log4j2进行日志输出
     *   *  同步日志
         *   *  1、排除logback日志、导入log4j2依赖
             *  2、导入自定义log4j2.xml配置文件
             *  3.基础log4j2.xml配置文件
         *  异步日志
         *   *  1、排除logback日志、导入log4j2依赖
             *  2、导入自定义log4j2.xml配置文件
             *  3.基础log4j2.xml配置文件
     *  四、JCL
     *   *  1、简介
         *  2、入门案例
     *  五、SLF4J
     *   *  1、简介
         *  2、SLF4J的简单使用：
         *  3、绑定日志的实现
         *  4、如何解决旧日志的升级
         *  5、日志适配器列举
     *  六、JUL日志(INFO级别)
     *   *  1、简介
         *  2、日志级别：
         *  3、入门案例
         *  4、设置日志自定义位置输出、以及输出的日志级别
         *  5、解释日志中父子依赖关系
         *  6、自定义JUL配置
         *  7、配置文件详解
         *  8、自定义日之类使用
         *  9、日志原理解析
     *  七、Log4j日志
     *   *  1、简介
         *  2、入门案例
     *  八、logback
     *   *  1、简介
         *  2、 logback入门
         *  3、logback配置
         *  4、过滤器
         *  5、异步日志
     *  九、Log4j2
     *   *  1、简介
         *  2、入门案例
         *  3、log4j2.xml配置信息
         *  4、异步日志
         *   *  4.1异步配置使用：
             *  4.2 异步Appender方式（性能提升少）
             *  4.3 AsyncLogger方式
         *  5、性能
     *  十、Springboot中使用日志
     *   *  1、内部依赖
         *  2、使用Springboot默认日志进行输出（logback）
         *  3、使用自定义日志类型
         *  4、采用生产、测试多种日志配置方式
         *  5、使用Log4j2进行日志输出
     *  十一、相关地址
     *   *  1、B站地址
         *  2、百度网盘地址（包括源码）

--------------------

## 一、简介 ##

**JUL：**

JUL全称Java util Logging是java原生的日志框架，使用时不需要另外引用第三方类库，相对其他日志框架使用方便，学习简单，能够在小型应用中灵活使用。

**log4j：**

Log4j是Apache下的一款开源的日志框架，通过在项目中使用 Log4J，我们可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以更灵活的控制日志的输出过程。方便项目的调试。

**Logback：**

Logback是由log4j创始人设计的另一个开源日志组件，性能比log4j要好。

**log4j2:**

Apache Log4j 2是对Log4j的升级版，参考了logback的一些优秀的设计，并且修复了一些问题，因此带来了一些重大的提升。

**日志门面：**

借鉴JDBC的思想，为日志系统也提供一套门面，那么我们就可以面向这些接口规范来开发，避免了直接依赖具体的日志框架。这样我们的系统在日志中，就存在了日志的门面和日志的实现。

**现有的日志框架体系**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70]

## 二、日志门面 ##

当我们的系统变的更加复杂的时候，我们的日志就容易发生混乱。随着系统开发的进行，可能会更新不同的日志框架，造成当前系统中存在不同的日志依赖，让我们难以统一的管理和控制。就算我们强制要求所有的模块使用相同的日志框架，系统中也难以避免使用其他类似spring,mybatis等其他的第三方框架，它们依赖于我们规定不同的日志框架，而且他们自身的日志系统就有着不一致性，依然会出来日志体系的混乱。

所以我们需要借鉴JDBC的思想，为日志系统也提供一套门面，那么我们就可以面向这些接口规范来开发，避免了直接依赖具体的日志框架。这样我们的系统在日志中，就存在了日志的门面和日志的实现。

**常见的日志门面 ：**

JCL、slf4j

**常见的日志实现：**

JUL、log4j、logback、log4j2

日志框架出现的历史顺序：

log4j —> JUL—> JCL—> slf4j —> logback —> log4j2

**日志门面和日志实现的关系：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 1]

## 三、Spring Boot 使用Log4j2进行日志输出 ##

### 同步日志 ###

#### 1、排除logback日志、导入log4j2依赖 ####

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            
            <exclusion>
                <artifactId>spring-boot-starter-logging</artifactId>
                <groupId>org.springframework.boot</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>

#### 2、导入自定义log4j2.xml配置文件 ####

即可实现采用log4j2的配置方式，进行日志的输出。  
![在这里插入图片描述][20210105102809189.png]

#### 3.基础log4j2.xml配置文件 ####

<?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" packages="com.lydms.common">
        <Appenders>
            <Console name="console" target="SYSTEM_OUT">
                <PatternLayout pattern="[%d %p %t %c] %m%n"/>
            </Console>
    
            <RollingRandomAccessFile name="serverlog"
                                     fileName="logs/sys.log" filePattern="logs/sys/sys-%d{yyyyMMdd}-%i.log">
                <PatternLayout>
                    <Pattern>[%d %p %t %c] %m%n</Pattern>
                </PatternLayout>
                <Policies>
                    <SizeBasedTriggeringPolicy size="500 MB"/>
                </Policies>
            </RollingRandomAccessFile>
    
        </Appenders>
    
        <Loggers>
            <Root level="info">
                <AppenderRef ref="console" />
                <AppenderRef ref="serverlog"/>
            </Root>
        </Loggers>
    </Configuration>

### 异步日志 ###

#### 1、排除logback日志、导入log4j2依赖 ####

#### 2、导入自定义log4j2.xml配置文件 ####

即可实现采用log4j2的配置方式，进行日志的输出。  
![在这里插入图片描述][20210105102809189.png]

#### 3.基础log4j2.xml配置文件 ####

<?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" packages="com.lydms.common">
        <Appenders>
            <Console name="console" target="SYSTEM_OUT">
                <PatternLayout pattern="[%d %p %t %c] %m%n"/>
            </Console>
    
            <RollingRandomAccessFile name="serverlog"
                                     fileName="logs/sys.log" filePattern="logs/sys/sys-%d{yyyyMMdd}-%i.log">
                <PatternLayout>
                    <Pattern>[%d %p %t %c] %m%n</Pattern>
                </PatternLayout>
                <Policies>
                    <SizeBasedTriggeringPolicy size="500 MB"/>
                </Policies>
            </RollingRandomAccessFile>
    
        </Appenders>
    
        <Loggers>
            <AsyncRoot level="info">
                <AppenderRef ref="console" />
                <AppenderRef ref="serverlog"/>
            </AsyncRoot>
        </Loggers>
    </Configuration>

## 四、JCL ##

### 1、简介 ###

*  全称为Jakarta Commons Logging，是Apache提供的一个通用日志API。
 *  它是为 "所有的Java日志实现"提供一个统一的接口，它自身也提供一个日志的实现，但是功能非常常弱（SimpleLog）。所以一般不会单独使用它。他允许开发人员使用不同的具体日志实现工具: Log4j, Jdk 自带的日志（JUL)
 *  JCL 有两个基本的抽象类：Log(基本记录器)和LogFactory(负责创建Log实例)。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 2]

### 2、入门案例 ###

代码：

import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.junit.Test;
    public class JCLTest {
        
    
        @Test
        public void testQuick() throws Exception {
        
            // 获取 log日志记录器对象
            Log log = LogFactory.getLog(JCLTest.class);
            // 日志记录输出
            log.info("hello jcl");
        }
    }

配置文件（使用的是log4j的配置文件）

# 指定 RootLogger 顶级父元素默认配置信息
    # 指定日志级别=trace，使用的 apeender 为=console
    log4j.rootLogger = trace,console
    
    # 指定控制台日志输出的 appender
    log4j.appender.console = org.apache.log4j.ConsoleAppender
    # 指定消息格式 layout
    log4j.appender.console.layout = org.apache.log4j.PatternLayout
    # 指定消息格式的内容
    log4j.appender.console.layout.conversionPattern = [%-10p]%r  %l %d{
        yyyy-MM-dd HH:mm:ss.SSS} %m%n

pom.xml依赖

<dependencies>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <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>
    </dependencies>

## 五、SLF4J ##

### 1、简介 ###

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

SLF4J是目前市面上最流行的日志门面。现在的项目中，基本上都是使用SLF4J作为我们的日志系统。

**SLF4J日志门面主要提供两大功能：**

1.  日志框架的绑定
2.  日志框架的桥接

### 2、SLF4J的简单使用： ###

import org.junit.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class Slf4jTest {
        
    
      public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);
    
        // 快速入门
        @Test
        public void test01() throws Exception {
        
            // 日志输出
            LOGGER.error("error");
            LOGGER.warn("wring");
            LOGGER.info("info"); // 默认级别
            LOGGER.debug("debug");
            LOGGER.trace("trace");
    
            // 使用占位符输出日志信息
            String name = "lydms";
            Integer age = 14;
            LOGGER.info("用户：{},{}", name, age);
    
            // 将系统的异常信息输出
            try {
        
                int i = 1 / 0;
            } catch (Exception e) {
        
                // e.printStackTrace();
                LOGGER.error("出现异常：", e);
            }
        }
    }

### 3、绑定日志的实现 ###

如前所述，SLF4J支持各种日志框架。SLF4J发行版附带了几个称为“SLF4J绑定”的jar文件，每个绑定对应一个受支持的框架。  
使用slf4j的日志绑定流程:

1.  添加slf4j-api的依赖。
2.  使用slf4j的API在项目中进行统一的日志记录。
3.  绑定具体的日志实现框架
    
    1.  绑定已经实现了slf4j的日志框架,直接添加对应依赖。
    2.  绑定没有实现slf4j的日志框架,先添加日志的适配器,再添加实现类的依赖
4.  Slf4j有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 3]

slf4j绑定一个框架就行了，如果配置多个的话，就使用第一个。

简单日志实现

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.21</version>
    </dependency>

logback日志配置

log4j日志配置

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.12</version>
    </dependency>
    
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

不使用任何日志框架

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
        <version>1.7.25</version>
    </dependency>

JUL日志框架

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-jdk14</artifactId>
        <version>1.7.25</version>
    </dependency>

### 4、如何解决旧日志的升级 ###

新版使用 logback日志

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

1.  注释掉过去的log4j，日志依赖，原来代码中的依赖log4j的会报错。
2.  采用log4j桥接器进行桥接log4j
3.  假如新版的logback日志

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

假如内部有log4j和log4j桥接器两个依赖。则会报错栈内存溢出（ Stack Overflow）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 4]

### 5、日志适配器列举 ###

日志门面(slf4j)

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>

日志实现(logback)

<dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

适配器(slf4j—log4j)

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.12</version>
    </dependency>

桥接器(log4j—slf4j)

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>log4j-over-slf4j</artifactId>
        <version>1.7.25</version>
    </dependency>

## 六、JUL日志(INFO级别) ##

### 1、简介 ###

JUL全称Java util Logging是java原生的日志框架，使用时不需要另外引用第三方类库，相对其他日志框架使用方便，学习简单，能够在小型应用中灵活使用。

**架构简介：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 5]

**Loggers：** 被称为记录器，应用程序通过获取Logger对象，调用其API来来发布日志信息。Logger通常时应用程序访问日志系统的入口程序。  
**Appenders：** 也被称为Handlers，每个Logger都会关联一组Handlers，Logger会将日志交给关联Handlers处理，由Handlers负责将日志做记录。Handlers在此是一个抽象，其具体的实现决定了日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等。  
**Layouts：** 也被称为Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts决定了数据在一条日志记录中的最终形式。  
**Level：** 每条日志消息都有一个关联的日志级别。该级别粗略指导了日志消息的重要性和紧迫，我可以将Level和Loggers，Appenders做关联以便于我们过滤消息。  
**Filters：** 过滤器，根据需要定制哪些信息会被记录，哪些信息会被放过。

**总结一下:**

用户使用Logger来进行日志记录，Logger持有若干个Handler，日志的输出操作是由Handler完成的。在Handler在输出日志前，会经过Filter的过滤，判断哪些日志级别过滤放行哪些拦截，Handler会将日志内容输出到指定位置（日志文件、控制台等）。Handler在输出日志时会使用Layout，将输出内容进行排版。

### 2、日志级别： ###

java.util.logging.Level 中定义了日志的级别：

*  SEVERE（最高值）
 *  WARNING
 *  INFO （默认级别）
 *  CONFIG
 *  FINE
 *  FINER
 *  FINEST（最低值）

### 3、入门案例 ###

import org.junit.Test;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    public class JULTest {
        
    
        @Test
        public void testQuick(){
        
    
    //        1、获取日志记录器对象
            Logger logger = Logger.getLogger("com.lydms.local.log.JULTest");
    //        2、日志记录输出
            logger.info("hello jul");
    
    //        通用方法进行日志记录
            logger.log(Level.INFO,"info log");
    
    //        占位符方式，输出日志值
            String name="LiLei";
            Integer age= 34;
            logger.log(Level.INFO,"姓名:{0},年龄:{1}",new Object[]{
        name,age});
        }
    }

输出结果为：

![在这里插入图片描述][20210105101801466.png]

### 4、设置日志自定义位置输出、以及输出的日志级别 ###

import org.junit.Test;
    import java.io.IOException;
    import java.util.logging.*;
    public class JULTest {
        
    
        @Test
        public void testQuick() throws IOException {
        
    
    //        1、获取日志记录器对象
            Logger logger = Logger.getLogger("com.lydms.local.log.JULTest");
    
    //        2、关闭系统默认配置
            logger.setUseParentHandlers(false);
    
    //        自定义配置日志级别
    //       3、创建CondolHandler （控制台输出）
            ConsoleHandler consoleHandler = new ConsoleHandler();
    
    //        创建简单格式转换对象
            SimpleFormatter simpleFormatter = new SimpleFormatter();
    
    //        进行关联
            consoleHandler.setFormatter(simpleFormatter);
            logger.addHandler(consoleHandler);
    
    //        配置日志具体级别
            logger.setLevel(Level.ALL);
            consoleHandler.setLevel(Level.ALL);
    
    //        4、场景FileHandler 文件输出（指定文件输出）
            FileHandler fileHandler = new FileHandler("logs/jul.log");
    
    //        进行关联
            fileHandler.setFormatter(simpleFormatter);
            logger.addHandler(fileHandler);
    
    //        输出的内容
            logger.severe("severe");
    //        警告级别
            logger.warning("warning");
        }
    }

输出结果（控制台和文件都有当前输出的日志）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 6]

### 5、解释日志中父子依赖关系 ###

*  是根据包名进行父子类依赖的。
 *  根类是LogManager，所有log都继承LogManager。

@Test
    public void testLogParent() {
        
        Logger logger1 = Logger.getLogger("com.lydms.local.log.JULTest");
        Logger logger2 = Logger.getLogger("com.lydms.local.log");
    
        //1、两个对象的地址值是相同的，证明有父子关系
        System.out.println(logger1.getParent() == logger2);
        logger2.setUseParentHandlers(false);
    
        //2、设置logger2的日志级别（配置控制台日志输出）
        ConsoleHandler consoleHandler = new ConsoleHandler();
    
        //创建简单格式转换对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
    
        //进行关联
        consoleHandler.setFormatter(simpleFormatter);
        logger2.addHandler(consoleHandler);
    
        //配置日志具体级别
        logger2.setLevel(Level.ALL);
        consoleHandler.setLevel(Level.ALL);
        logger1.severe("severe");
        logger1.info("info");
    }

**结果：**

logger1没有进行配置，照样能够按照logger2的日志设置级别，进行打印日志，表明logger2是logger1的父类。logger1继承logger2的配置。

### 6、自定义JUL配置 ###

@Test
    public void testLogProperties() throws IOException {
        
    
        //通过类加载器，读取配置文件
        InputStream ins = JULTest.class.getClassLoader().getResourceAsStream("logging.properties");
    
        //  创建LogManager
        LogManager logManager = LogManager.getLogManager();
    
        //  通过LogManager加载配置文件
        logManager.readConfiguration(ins);
    
        //  创建日志记录器
        Logger logger = Logger.getLogger("com.lydms.local.log");
    
        //  打印日志
        logger.severe("severe");
        logger.info("info");
    }

配置文件：

# 默认的处理器对象（加载日志配置方式_FileHandler(文件输出)、ConsoleHandler(控制台)）
    handlers= java.util.logging.ConsoleHandler,java.util.logging.FileHandler
    
    # 日志级别
    .level= INFO
    
    # 文件___日志的名称规范（%h当前用户，%u数字）
    java.util.logging.FileHandler.pattern = logs/java%u.log
    # 当前文件，最大存储数量
    java.util.logging.FileHandler.limit = 50000
    # 文件序号（%u）
    java.util.logging.FileHandler.count = 1
    # formatter消息数据格式
    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

### 7、配置文件详解 ###

# 默认的处理器对象(RootLogger 顶级父元素指定的默认处理器为：ConsoleHandler)
    handlers= java.util.logging.ConsoleHandler,java.util.logging.FileHandler
    
    # RootLogger 顶级父元素默认的日志级别为：ALL
    .level= ALL
    
    # 自定义 Logger 使用
    com.lydms.handlers = java.util.logging.ConsoleHandler
    com.lydms.level = CONFIG
    # 关闭默认配置
    com.lydms.useParentHanlders = false
    
    # 日志的名称规范（%h当前用户，%u数字）
    java.util.logging.FileHandler.pattern = logs/java%u.log
    # 当前文件，最大存储数量
    java.util.logging.FileHandler.limit = 50000
    # 文件序号（%u）
    java.util.logging.FileHandler.count = 1
    # formatter消息数据格式
    java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
    
    # 指定以追加方式添加日志内容
    java.util.logging.FileHandler.append = true
    
    # 向控制台输出的 handler 对象
    # 指定 handler 对象的日志级别
    java.util.logging.ConsoleHandler.level = INFO
    # 指定 handler 对象的日志消息格式对象
    java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
    
    #
    com.xyz.foo.level = SEVERE
    
    # 指定 handler 对象的字符集
    java.util.logging.ConsoleHandler.encoding = UTF-8
    
    # 指定日志消息格式
    java.util.logging.SimpleFormatter.format = %4$s: %5$s [%1$tc]%n

### 8、自定义日之类使用 ###

配置文件

# 自定义 Logger 使用
    com.lydms.handlers = java.util.logging.ConsoleHandler
    com.lydms.level = CONFIG
    # 关闭默认配置
    com.lydms.useParentHanlders = false

代码：

@Test
    public void testLogParent() {
        
        Logger logger = Logger.getLogger("com.lydms");
        logger.severe("severe");
        logger.info("info");
    }

### 9、日志原理解析 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 7]

## 七、Log4j日志 ##

### 1、简介 ###

官方网站： [http://logging.apache.org/log4j/1.2/][http_logging.apache.org_log4j_1.2]

### 2、入门案例 ###

pom依赖

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

入门log4j日志信息

import org.apache.log4j.BasicConfigurator;
    import org.apache.log4j.Logger;
    import org.junit.Test;
    public class test {
        
        @Test
        public void testQuick() {
        
    //        初始化配置信息
            BasicConfigurator.configure();
    
    //        获取日志记录器对象
            Logger logger = Logger.getLogger(Log4jTest.class);
    //        日志记录输出
            logger.info("hello world");
    
    //        日志级别
            logger.fatal("fatal");  //严重错误，一般会造成系统崩溃并终止运行
            
            logger.error("error");  //错误信息。不会影响系统运行
            logger.warn("warn");    //警告信息，可能会发生问题
            logger.info("info ");   //运行信息，数据连接、网络连接、IO、操作等等
            logger.debug("debug");  //调制信息，一般在开发过程中使用，记录程序变量参数传递信息等等
            
            logger.trace("trace");  //追踪信息，记录程序所有的流程信息
        }
    }

开启log4j 内置日志记录

// 开启 log4j 内置日志记录
    LogLog.setInternalDebugging(true);

3、log4j 组件

Log4J 主要由 Loggers (日志记录器)、Appenders（输出端）和 Layout（日志格式化器）组成。

*  Loggers 控制日志的输出级别与日志是否输出；
 *  Appenders 指定日志的输出方式（输出到控制台、文件等）；
 *  Layout 控制日志信息的输出格式。

Loggers：

*  日志记录器，负责收集处理日志记录，实例的命名就是类“XX”的full quailied name（类的全限定名），Logger的名字大小写敏感，其命名有继承机制。
 *  Log4J中有一个特殊的logger叫做“root”，他是所有logger的根，也就意味着其他所有的logger都会直接或者间接地继承自root。root logger可以用Logger.getRootLogger()方法获取。

Appenders：

*  Appender 用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。

**Log4j 常用的输出目的地。有以下几种：**

<table> 
 <thead> 
  <tr> 
   <th>输出端类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ConsoleAppender</td> 
   <td>将日志输出到控制台</td> 
  </tr> 
  <tr> 
   <td>FileAppender</td> 
   <td>将日志输出到文件中</td> 
  </tr> 
  <tr> 
   <td>DailyRollingFileAppender</td> 
   <td>将日志输出到一个日志文件，并且每天输出到一个新的文件</td> 
  </tr> 
  <tr> 
   <td>RollingFileAppender</td> 
   <td>将日志信息输出到一个日志文件，并且指定文件的尺寸，当文件大小达到指定尺寸时，会自动把文件改名，同时产生一个新的文件</td> 
  </tr> 
  <tr> 
   <td>JDBCAppender</td> 
   <td>把日志信息保存到数据库中</td> 
  </tr> 
 </tbody> 
</table>

Layouts：

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

**Log4j常用的Layouts:**

<table> 
 <thead> 
  <tr> 
   <th>格式化器类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>HTMLLayout</td> 
   <td>格式化日志输出为HTML表格形式</td> 
  </tr> 
  <tr> 
   <td>SimpleLayout</td> 
   <td>简单的日志输出格式化，打印的日志格式为（info - message）</td> 
  </tr> 
  <tr> 
   <td>PatternLayout</td> 
   <td>最强大的格式化期，可以根据自定义格式输出日志，如果没有指定转换格式，就是用默认的转换格式</td> 
  </tr> 
 </tbody> 
</table>

**Layout的格式**

# %m   输出代码中指定的日志信息
    # %p   输出优先级，及 DEBUG、INFO 等
    # %n   换行符（Windows平台的换行符为 "\n"，Unix 平台为 "\n"）
    # %r   输出自应用启动到输出该 log 信息耗费的毫秒数
    # %c   输出打印语句所属的类的全名
    # %t   输出产生该日志的线程全名
    # %d   输出服务器当前时间，默认为 ISO8601，也可以指定格式，如：%d{
        yyyy年MM月dd日 HH:mm:ss}
    # %l   输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如：Test.main(Test.java:10)
    # %F   输出日志消息产生时所在的文件名称
    # %L   输出代码中的行号
    # %%   输出一个 "%" 字符

**log4j.properties（log4j配置文件）**

# 指定 RootLogger 顶级父元素默认配置信息
    # 0、指定日志级别=trace，使用的 apeender 为=console
    log4j.rootLogger = trace,console
    
    
    # 5、自定义 logger 对象设置
    log4j.logger.com.lydms = info,console
    log4j.logger.org.apache = error
    
    
    # 1、指定控制台日志输出的 appender
    log4j.appender.console = org.apache.log4j.ConsoleAppender
    # 指定消息格式 layout
    log4j.appender.console.layout = org.apache.log4j.PatternLayout
    #log4j.appender.console.layout = org.apache.log4j.HTMLLayout
    #log4j.appender.console.layout = org.apache.log4j.xml.XMLLayout
    
    
    # 指定消息格式的内容
    log4j.appender.console.layout.conversionPattern = [%-10p]%r  %l %d{
        yyyy-MM-dd HH:mm:ss.SSS} %m%n
    
    # %m   输出代码中指定的日志信息
    # %p   输出优先级，及 DEBUG、INFO 等
    # %n   换行符（Windows平台的换行符为 "\n"，Unix 平台为 "\n"）
    # %r   输出自应用启动到输出该 log 信息耗费的毫秒数
    # %c   输出打印语句所属的类的全名
    # %t   输出产生该日志的线程全名
    # %d   输出服务器当前时间，默认为 ISO8601，也可以指定格式，如：%d{yyyy年MM月dd日 HH:mm:ss}
    # %l   输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如：Test.main(Test.java:10)
    # %F   输出日志消息产生时所在的文件名称
    # %L   输出代码中的行号
    # %%   输出一个 "%" 字符
    
    
    # 2、配置日志文件的相关信息（文件路径以及编码格式）
    # 日志文件输出的 appender 对象
    log4j.appender.file = org.apache.log4j.FileAppender
    # 指定消息格式 layout
    log4j.appender.file.layout = org.apache.log4j.PatternLayout
    # 指定消息格式的内容
    log4j.appender.file.layout.conversionPattern = [%-10p]%r  %l %d{
        yyyy-MM-dd HH:mm:ss.SSS} %m%n
    # 指定日志文件保存路径
    log4j.appender.file.file = /logs/log4j.log
    # 指定日志文件的字符集
    log4j.appender.file.encoding = UTF-8
    
    
    
    #  3.1 、按照文件大小拆分的 appender 对象
    # 日志文件输出的 appender 对象
    log4j.appender.rollingFile = org.apache.log4j.RollingFileAppender
    # 指定消息格式 layout
    log4j.appender.rollingFile.layout = org.apache.log4j.PatternLayout
    # 指定消息格式的内容
    log4j.appender.rollingFile.layout.conversionPattern = [%-10p]%r  %l %d{
        yyyy-MM-dd HH:mm:ss.SSS} %m%n
    # 指定日志文件保存路径
    log4j.appender.rollingFile.file = /logs/log4j.log
    # 指定日志文件的字符集
    log4j.appender.rollingFile.encoding = UTF-8
    #总共只会维护10个最大 1 MB 的文件
    # 指定日志文件内容的大小（超过以后重新复制到新的文件）
    log4j.appender.rollingFile.maxFileSize = 1MB
    # 指定日志文件的数量（超过以后进行覆盖）
    log4j.appender.rollingFile.maxBackupIndex = 10
    
    
    
    # 3.2、按照时间规则拆分的 appender 对象
    log4j.appender.dailyFile = org.apache.log4j.DailyRollingFileAppender
    # 指定消息格式 layout
    log4j.appender.dailyFile.layout = org.apache.log4j.PatternLayout
    # 指定消息格式的内容
    log4j.appender.dailyFile.layout.conversionPattern = [%-10p]%r  %l %d{
        yyyy-MM-dd HH:mm:ss.SSS} %m%n
    # 指定日志文件保存路径
    log4j.appender.dailyFile.file = /logs/log4j.log
    # 指定日志文件的字符集
    log4j.appender.dailyFile.encoding = UTF-8
    # 指定日期拆分规则
    log4j.appender.dailyFile.datePattern = '.'yyyy-MM-dd-HH-mm-ss
    
    
    
    # 4、向数据库存入日志 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_category,message) values('itcast','%d{yyyy-MM-dd HH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')

## 八、logback ##

### 1、简介 ###

Logback是由log4j创始人设计的另一个开源日志组件，性能比log4j要好。

官方网站：https://logback.qos.ch/index.htmlLogback

主要分为三个模块：

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

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

### 2、 logback入门 ###

pom依赖

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

代码：

import org.junit.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    public class LogbackTest {
        
    
        public static final Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);
    
        // 快速入门
        @Test
        public void testQuick() throws Exception {
        
    
            for (int i = 0; i < 10000; i++) {
        
    
                // 日志输出
                LOGGER.error("error");
                LOGGER.warn("wring");
                LOGGER.info("info");
                LOGGER.debug("debug");// 默认级别
                LOGGER.trace("trace");
            }
        }
    }

### 3、logback配置 ###

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

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

logback组件之间的关系

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

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 name="console" class="ch.qos.logback.core.ConsoleAppender">
            
            <target>System.err</target>
            
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                <pattern>${pattern}</pattern>
            </encoder>
        </appender>
    
    
    
        <root level="ALL">
            <appender-ref ref="console"/>
        </root>
    </configuration>

日志文件输出格式配置

<property name="log_dir" value="/logs"></property>
    
    
    
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        
        <file>${log_dir}/logback.log</file>
        !--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    
    
    
    <root level="ALL">
        <appender-ref ref="async"/>
    </root>

日志HTML格式文件输出

<property name="log_dir" value="/logs"></property>
    
    
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        
        <file>/logs/logback.html</file>
        
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>%-5level%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
    </appender>
    
    
    <root level="ALL">
        <appender-ref ref="htmlFile"/>
    </root>

日志拆分和归档压缩

*  末尾加上 .gz以后，表格是进行归档压缩
 *  大小拆分：maxFileSize。
 *  时间拆分：

<property name="log_dir" value="/logs"></property>
    
    
    
    <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>
    
        
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
    </appender>
    
    
    
    <root level="ALL">
        <appender-ref ref="rollFile"/>
    </root>

### 4、过滤器 ###

*  `<level>ERROR</level>`：过滤级别(ERROR)
 *  `<onMatch>ACCEPT</onMatch>`：大于当前级别(放行)
 *  `<onMismatch>DENY</onMismatch>`：低于当前级别(拦截)

<appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
    
        
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

### 5、异步日志 ###

源码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 8]

代码：

<appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        
        <appender-ref ref="rollFile"/>
    </appender>
    
    
    
    <root level="ALL">
        <appender-ref ref="console"/>
        <appender-ref ref="async"/>
    </root>

自定义logger

*  自定义日志的优先级高于root日志级别。

<logger name="com.itheima" level="info" additivity="false">
        <appender-ref ref="console"/>
    </logger>

[官方提供的log4j.properties转换成logback.xml][log4j.properties_logback.xml]

https://logback.qos.ch/translator/

## 九、Log4j2 ##

### 1、简介 ###

Apache Log4j 2是对Log4j的升级版，参考了logback的一些优秀的设计，并且修复了一些问题，因此带来了一些重大的提升，主要有：

*  异常处理：在logback中，Appender中的异常不会被应用感知到，但是在log4j2中，提供了一些异常处理机制。
 *  性能提升：log4j2相较于log4j 和logback都具有很明显的性能提升，后面会有官方测试的数据。
 *  自动重载配置：参考了logback的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产上可以动态的修改日志的级别而不需要重启应用。
 *  无垃圾机制：log4j2在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致的jvm gc，（对象的复用）。

官网： [https://logging.apache.org/log4j/2.x/][https_logging.apache.org_log4j_2.x]

目前市面上最主流的日志门面就是SLF4J，虽然Log4j2也是日志门面，因为它的日志实现功能非常强大，性能优越。所以大家一般还是将Log4j2看作是日志的实现，Slf4j + Log4j2应该是未来的大势所趋。

### 2、入门案例 ###

pom.xml依赖

<dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.11.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.11.1</version>
    </dependency>

代码：

import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import org.junit.Test;
    public class Log4j2Test {
        
    
        // 定义日志记录器对象
        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");
        }
    }

slf4j+log4j2实现 pom依赖

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j-impl</artifactId>
        <version>2.9.1</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.11.1</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.11.1</version>
    </dependency>

### 3、log4j2.xml配置信息 ###

*  1、Configuration：根标签。
 *  2、properties：集中配置属性及管理。
 *  3、Appenders；日志处理器（可配置多个Appender）。
 *  4、Loggers：logger定义。

<?xml version="1.0" encoding="UTF-8"?>
    
    <Configuration status="debug" monitorInterval="5">
    
    
        
        <properties>
            <property name="LOG_HOME">/logs</property>
        </properties>
    
    
        
        <Appenders>
    
            
            <Console name="Console" target="SYSTEM_ERR">
                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
            </Console>
    
            
            <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>
    
            
            <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>
    
    
            
            <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 />
                    
                    <SizeBasedTriggeringPolicy size="10 MB" />
                    
                    <TimeBasedTriggeringPolicy />
                </Policies>
                
                <DefaultRolloverStrategy max="30" />
            </RollingFile>
    
        </Appenders>
    
    
        
        <Loggers>
            
            <Root level="trace">
                
                <AppenderRef ref="Console" />
            </Root>
        </Loggers>
    </Configuration>

### 4、异步日志 ###

log4j2最大的特点就是异步日志，其性能的提升主要也是从异步日志中受益.

**同步日志**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 9]

**同步日志**

![在这里插入图片描述][20210105102317762.png]

logEvent调用具体的Appender具体进行实现。Log4j2提供了两种实现日志的方式：

*  一个是通过AsyncAppender（性能提升少）；
 *  一个是通过AsyncLogger，分别对应前面我们说的Appender组件和Logger组件（主要的性能提升）。

#### 4.1异步配置使用： ####

pom.xml

<dependency>
        <groupId>com.lmax</groupId>
        <artifactId>disruptor</artifactId>
        <version>3.3.4</version>
    </dependency>

#### 4.2 异步Appender方式（性能提升少） ####

#### 4.3 AsyncLogger方式 ####

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

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

*  **全局异步方式：**

所有的日志都异步的记录，在配置文件上不用做任何改动，只需要添加一个文件log4j2.component.properties 配置，里面增加如下配置即可；

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

*  **混合异步方式：**

你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活。

<AsyncLogger name="com.lydms" level="trace" includeLocation="false" additivity="false">
        <AppenderRef ref="Console"/>
    </AsyncLogger>

异步日志注意事项：

*  如果使用异步日志，AsyncAppender、AsyncLogger和全局日志，不要同时出现。性能会和AsyncAppender一致，降至最低。
 *  设置includeLocation=false ，打印位置信息会急剧降低异步日志的性能，比同步日志还要慢。

### 5、性能 ###

Log4j2在多线程的环境下吞吐量与Log4j和Logback的比较如下图：

*  1）全局使用异步模式；
 *  2）部分Logger采用异步模式；
 *  3）异步Appender。
    
    **性能提升原因：**
 *  异步日志。
 *  无垃圾记录

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 10]

**简介：**

*  从版本2.6开始，默认情况下Log4j以“无垃圾”模式运行，其中重用对象和缓冲区，并且尽可能不分配临时对象。
 *  还有一个“低垃圾”模式，它不是完全无垃圾，但不使用ThreadLocal字段。Log4j 2.6中的无垃圾日志记录部分通过重用ThreadLocal字段中的对象来实现，部分通过在将文本转换为字节时重用缓冲区来实现。

## 十、Springboot中使用日志 ##

### 1、内部依赖 ###

pom.xml依赖

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

其内部依赖图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 11]

总结：

1.  springboot 底层默认使用logback作为日志实现。
2.  使用了SLF4J作为日志门面。
3.  将JUL也转换成slf4j。
4.  也可以使用log4j2作为日志门面，但是最终也是通过slf4j调用logback。
5.  最终的输出都是采用logback进行日志输出的。

### 2、使用Springboot默认日志进行输出（logback） ###

代码：

import org.apache.logging.log4j.LogManager;
    import org.junit.jupiter.api.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.boot.test.context.SpringBootTest;
    @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");
    
            // 使用 lo4j2 使用桥接器切换为 slf4j 门面和 logback 日志实现
            org.apache.logging.log4j.Logger logger = LogManager.getLogger(SpringbootLogApplicationTests.class);
            logger.info("log4j2 info");
        }
    }

修改默认的日志级别

# 指定自定义 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

### 3、使用自定义日志类型 ###

给类路径下放上每个日志框架自己的配置文件；SpringBoot就不使用默认配置的了

<table> 
 <thead> 
  <tr> 
   <th>日志框架</th> 
   <th>配置文件</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Logback</td> 
   <td>logback-spring.xml , logback.xml</td> 
  </tr> 
  <tr> 
   <td>Log4j2</td> 
   <td>log4j2-spring.xml ， log4j2.xml</td> 
  </tr> 
  <tr> 
   <td>JUL</td> 
   <td>logging.properties</td> 
  </tr> 
 </tbody> 
</table>

**logback.xml：直接就被日志框架识别了**

### 4、采用生产、测试多种日志配置方式 ###

application.properties配置

spring.profiles.active=dev

log4j2.xml配置

*  `<springProfile name="dev">`
 *  `<springProfile name="pro">`

<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        
        <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>

### 5、使用Log4j2进行日志输出 ###

1、排除logback日志、导入log4j依赖

2、导入自定义log4j2.xml配置文件

即可实现采用log4j2的配置方式，进行日志的输出。  
![在这里插入图片描述][20210105102809189.png]

## 十一、相关地址 ##

### [1、B站地址][1_B] ###

https://www.bilibili.com/video/BV1iJ411H74S?p=1

### 2、百度网盘地址（包括源码） ###

[完整视频：][Link 1]

http://yun.itheima.com/course/632.html?2012zzp

[配套资料：][Link 2]

https://pan.baidu.com/s/1FgyZP7vftO5InMLGzOI-yQ 
    提取码：ots5

[JCL_Slf4j_JUL_Log4j_Logback_Log4j2]: https://blog.csdn.net/lydms/article/details/112216734
[log4j2_log4j2.xml]: https://blog.csdn.net/lydms/article/details/108872850
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210105094109827.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210105094136651.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[20210105102809189.png]: https://img-blog.csdnimg.cn/20210105102809189.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210105095024111.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210105095154735.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210105100150647.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210105100222292.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[20210105101801466.png]: https://img-blog.csdnimg.cn/20210105101801466.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2021010510181871.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210105101937239.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[http_logging.apache.org_log4j_1.2]: http://logging.apache.org/log4j/1.2/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210105102143411.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[log4j.properties_logback.xml]: https://logback.qos.ch/translator/
[https_logging.apache.org_log4j_2.x]: https://logging.apache.org/log4j/2.x/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210105102305618.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[20210105102317762.png]: https://img-blog.csdnimg.cn/20210105102317762.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20210105102353403.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20210105102411839.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[1_B]: https://www.bilibili.com/video/BV1iJ411H74S?p=1
[Link 1]: http://yun.itheima.com/course/632.html?2012zzp
[Link 2]: https://pan.baidu.com/s/1FgyZP7vftO5InMLGzOI-yQ