Java⽇志框架学习笔记

向右看齐 2024-03-27 11:38 51阅读 0赞

**目录**

1.⽇志概述

1.1 ⽇志是⽤来做什么的？

1.2 为什么要⽤到⽇志框架？

1.3 现有的⽇志框架有哪些？

1.4 ⽇志⻔⾯技术

2.logback

2.1 logback介绍

2.1.1 logback 模块

2.1.2 logback 组件

2.1.3 logback 配置

2.1.4 logback.xml 配置⽂件解析

2.2 SLF4j+logback进⾏⽇志管理

2.2.2 配置⽂件

2.2.3 代码实现

2.2.6 异步⽇志

2.2.7 ⾃定义Logger

2.2.8 配置⽂件转换器

2.2.9 logback-access模块

3.Log4j2

3.1.1Log4j2介绍

3.2.1 XML配置⽂件解析

3.2.2 Log4j2的使⽤

3.2.3 Log4j的Bug及解决⽅案

4.SpringBoot⽇志管理

4.1 SpringBoot⾃定义⽇志

4.1.1 SpringBoot默认的⽇志配置

4.1.2 使⽤logback-spring.xml⾃定义配置

4.1.3 多环境输出⽇志⽂件

4.2 SpringBoot整合Log4j2

5.demo源码：Java日志模板: Java日志信息，包括slf42,logback,springboot整合slf42

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

## 1.**⽇志概述**  ##

### 1.1 **⽇志是⽤来做什么的？**  ###

**⽇志⽂件是⽤于记录系统操作事件的⽂件集合**，可分为 **事件⽇志**和 **消息⽇志**。具

有处理历史数据、诊断问题的追踪以及理解系统的活动等重要作⽤。

### 1.2 **为什么要⽤到⽇志框架？**  ###

因为软件系统发展到今天已经很复杂了，特别是服务器端软件，涉及到的知识，内

容，问题太多。在某些⽅⾯使⽤别⼈成熟的框架，就相当于让别⼈帮你完成⼀些基

础⼯作，你只需要集中精⼒完成系统的业务逻辑设计。⽽且框架⼀般是成熟，稳健

的，它可以处理系统很多细节问题，⽐如，事务处理，安全性，数据流控制等问

题。还有框架⼀般都经过很多⼈使⽤，所以结构很好，所以扩展性也很好，⽽且它

是不断升级的，你可以直接享受别⼈升级代码带来的好处。

### 1.3 **现有的⽇志框架有哪些？**  ###

*  JUL（java util logging）
 *  logback
 *  log4j
 *  log4j2
 *  JCL（Jakarta Commons Logging）
 *  slf4j（ Simple Logging Facade for Java）

**⽇志框架出现的历史顺序：**

log4j -->JUL-->JCL--> slf4j --> logback --> log4j2

### 1.4 **⽇志⻔⾯技术**  ###

当我们的系统变的更加复杂的时候，我们的⽇志就容易发⽣混乱。随着系统开发的 进⾏，可能会更新不同的⽇志框架，造成当前系统中存在不同的⽇志依赖，让我们 难以统⼀的管理和控制。就算我们强制要求所有的模块使⽤相同的⽇志框架，系统 中也难以避免使⽤其它类似spring mybatis等其它的第三⽅框架，它们依赖于我们规定不同的⽇志框架，⽽且它们⾃身的⽇志系统就有着不⼀致性，依然会出现⽇志体系的混乱。 所以我们需要借鉴JDBC的思想，为⽇志系统也提供⼀套⾯，那么我们就可以⾯ 向这些接⼝规范来开发，避免了直接依赖具体的⽇志框架。这样我们的系统在⽇志中，就存在了⽇志的⻔⾯和⽇志的实现。

1.4.1 **⽇志⻔⾯技术的优点**

1. ⾯向接⼝开发，不再依赖具体的实现类。减少代码的耦合

2. 项⽬通过导⼊不同的⽇志实现类，可以灵活的切换⽇志框架

3. 统⼀API，⽅便开发者学习和使⽤

4. 统⼀配置便于项⽬⽇志的管理

1.4.2 **⽇志⻔⾯和⽇志实现的关系**

![43e670e81d884334af5ae6a3d3ff7df9.png][]

⽤户可以使⽤⽇志⻔⾯，然后根据需求，动态的选择具体的⽇志实现框架。这样就

可以使所有⽇志实现框架拥有统⼀的规范。

## 2.logback ##

### 2.1 logback**介绍**  ###

官⽹：http://logback.qos.ch

Logback是由log4j创始⼈设计的另⼀个开源⽇志组件，性能⽐log4j要好。log4j,

logback, slf4j 都出⾃于他之⼿。

SLF4j 绑定 Logback⽆缝衔接，只需要⼀个logback-classic-1.0.13.jar，这个绑定包不

是slf4j项⽬提供的，⽽是是logback项⽬提供的，它本身就是基于slf4j API实现的。

![bfee8cdc01da4a749002d9d13b17a503.png][]

logback拥有以下优点：

*  内核重写、测试充分、初始化内存加载更⼩，这⼀切让logback性能和log4j相⽐有诸多倍的提升
 *  logback⾮常⾃然地直接实现了slf4j，这个严格来说算不上优点，只是这样，再理解slf4j的前提下会很容易理解logback，也同时很容易⽤其他⽇志框架替换 logback
 *  logback有⽐较⻬全的200多⻚的⽂档
 *  logback当配置⽂件修改了，⽀持⾃动重新加载配置⽂件，扫描过程快且安全， 它并不需要另外创建⼀个扫描线程
 *  ⽀持⾃动去除旧的⽇志⽂件，可以控制已经产⽣⽇志⽂件的最⼤数量

#### 2.1.1 logback **模块**  ####

logback-core: 其他两个模块的基础模块

logback-class：它是log4j的改良版本，完整实现了Slf4j API

logback-access: 访问模块与servlet容器继承提供通过Http来访问⽇志的功能

#### 2.1.2 logback **组件**  ####

1） **Logger**:⽇志的记录器，把它关联到应⽤的对应的context上后，主要⽤于存放⽇志对象，也可以定义⽇志类型、级别。

2） **Appender**:⽤于指定⽇志输出的⽬的地，可以是控制台、⽂件、数据库等等。

3） **Layout**:负责把事件转换成字符串，格式化的⽇志信息的输出。在logback中Layout对象被封装在encoder中。

#### 2.1.3 logback **配置**  ####

logback会依次读取以下类型配置⽂件:

1）logback.grovy

2）logback-test.xml

3）logback.xml

#### 2.1.4 logback.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 name="log_dir" value="G://logs"/>
        
        <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
            <target>System.out</target> 
            
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                <pattern>${pattern}</pattern>
            </encoder>
        </appender>
    
    
        
        <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>
    
    
        
        <appender name="html" class="ch.qos.logback.core.FileAppender">
            <file>${log_dir}/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>
    
        
        <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-HH-ss}.log%i.gz</fileNamePattern>
                <maxFileSize>1MB</maxFileSize>
            </rollingPolicy>
        </appender>
    
    
        
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <omMismatch>DENY</omMismatch>
        </filter>
    
    
        
        <appender name="asyncInfo" class="ch.qos.logback.classic.AsyncAppender">
            
            <discardingThreshold>0</discardingThreshold>
            
            <queueSize>256</queueSize>
            
            <appender-ref ref="rollFile"/>
        </appender>
    
    
        <root level="ALL">
            <appender-ref ref="console"/>
            <appender-ref ref="rollFile"/>
            <appender-ref ref="file"/>
            <appender-ref ref="html"/>
        </root>
    </configuration>

⽇志输出格式:

%-5level

%d\{yyyy-MM-dd HH:mm:ss.SSS\}⽇期

%c类的完整名称

%M为method

%L为⾏号

%thread线程名称

%m或者%msg为信息

%n换⾏

格式化输出:

%d表示⽇期，

%thread表示线程名，

%-5level:级别从左显示5个字符宽度

%msg:⽇志消息

%n是换⾏符

### 2.2 SLF4j+logback**进⾏⽇志管理** ###

SLF4j 绑定 Logback，只需要⼀个logback-classic-1.0.13.jar

2.2.1 **导包**

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

#### 2.2.2 **配置⽂件** ####

log4j2.xml

#### 2.2.3 **代码实现** ####

package com.wang;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.stream.IntStream;
    
    /**
     * @author 飞
     */
    public class Test {
        public static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
        public static void main(String[] args) {
            IntStream.range(0, 10000).forEach(i -> {
                LOGGER.trace("trace");
                LOGGER.debug("debug"); // 默认输出级别
                LOGGER.info("info");
                LOGGER.warn("warn");
                LOGGER.error("error");
            });
        }
    
    }

2.2.4 **⽇志拆分**

所有信息都输出到同⼀个⽇志⽂件，⽇志的产⽣速度很快，⽂件⼀⼤，就很难分析，因此需要进⾏拆分。

<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-HH-ss}.log%i.gz</fileNamePattern>
                <maxFileSize>1MB</maxFileSize>
            </rollingPolicy>
        </appender>

2.2.5 **过滤器**

<filter class="ch.qos.logback.classic.filter.LevelFilter">
        <level>ERROR</level>
        <onMatch>ACCEPT</onMatch>
        <omMismatch>DENY</omMismatch>
    </filter>

该过滤器表示：⼤于等于 error 级别的⽇志才会被输出到⽂件中

#### 2.2.6 **异步⽇志**  ####

为了提升性能，应该将⽇志设置为异步，同步⽇志意味着⽇志必须完成才能执⾏后续代码，但是⽇志毕竟是 io 操作，会影响程序速度配置异步⽇志很简单，新增⼀个 appender，指定其为 async, 并调⽤现有的 appender 即可。

<appender name="asyncInfo" class="ch.qos.logback.classic.AsyncAppender">
            
            <discardingThreshold>0</discardingThreshold>
            
            <queueSize>256</queueSize>
            
            <appender-ref ref="rollFile"/>
        </appender>

#### 2.2.7 **⾃定义**Logger ####

我们可以针对⾃⼰的业务代码⾃定义 logger 对象，可以不必继承 rootLogger。

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

#### 2.2.8 **配置⽂件转换器**  ####

http://logback.qos.ch/translator/ 可以将 log4j 的配置转成 logback 的配置格式

#### 2.2.9 logback-access**模块**  ####

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

具体参考官⽹⽂档 https://logback.qos.ch/access.h

## 3.Log4j2 ##

#### 3.1.1Log4j2介绍 ####

Log4j2 是对Log4j 的升级版本，015年5⽉，Apache宣布log4j1.x 停⽌更新。

Log4j与Log4j2下载地址：https://logging.apache.org/

log4j2参考了logback的⼀些优秀的设计，并且修复了⼀些问题，因此带来了⼀些重⼤的提升，主要有：

1、异常处理：在logback中，Appender中的异常不会被应⽤感知到，但是在log4j2中，提供了⼀些异常处理机制。

2、性能提升：log4j2相较于log4j 1和logback都具有很明显的性能提升。

3、⾃动重载配置：参考了logback的设计，提供⾃动刷新参数配置，可以动态的修改⽇志的级别⽽不需要重启应⽤。

4、⽆垃圾机制，log4j2在⼤部分情况下，都可以使⽤其设计的⼀套⽆垃圾机制，避免频繁的⽇志收集导致的jvm gc。

log4j 2.x版本不再⽀持像1.x中的.properties后缀的⽂件配置⽅式，2.x版本配置⽂件

后缀名只能为".xml",".json"或者".jsn"。

log4j2虽然采⽤xml⻛格进⾏配置，依然包含三个组件分别是Loggers（记录器）、

Appender（输出⽬的地）、Layout（⽇志布局）。

配置⽂件的位置：log4j2默认会在classpath⽬录下寻找log4j2.xml、log4j.json、log4j.jsn等名称的⽂件。

#### 3.2.1 XML**配置⽂件解析** ####

1、根节点Configuration有两个属性:status和monitorinterval,有两个⼦节点:Appenders和Loggers(表明可以定义多个Appender和Logger

> status⽤来指定log4j本身的打印⽇志的级别
> 
> monitorinterval为log4j 2.x新特点⾃动重载配置。指定⾃动重新配置的监测间隔时
> 
> 间，单位是s,最⼩是5s

2、Appenders节点，常⻅的有三种⼦节点:Console、File、RollingFile

> Console节点⽤来定义输出到控制台的Appender
> 
> File节点⽤来定义输出到指定位置的⽂件的Appender
> 
> RollingFile节点⽤来定义超过指定⼤⼩⾃动删除旧的创建新的的Appender

> 通过在⼦节点中加⼊进⾏⽇志布局：
> 
> %p: 输出⽇志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
> 
> %d: 输出⽇志时间点的⽇期或时间，默认格式为ISO8601，也可以在其后指定格式，⽐如：%d\{yyy MMM dd HH:mm:ss,SSS\}，输出类似：2002年10⽉18⽇ 22：10：28，921
> 
> %r: 输出⾃应⽤启动到输出该log信息耗费的毫秒数
> 
> %c: 输出⽇志信息所属的类⽬，通常就是所在类的全名
> 
> %t: 输出产⽣该⽇志事件的线程名
> 
> %l: 输出⽇志事件的发⽣位置，相当于%C.%M(%F:%L)的组合,包括类⽬名、发⽣的线
> 
> 程，以及在代码中的⾏数。举例：Testlog4.main(TestLog4.Java:10)
> 
> %x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其⽤到像Java servlets这样的多客户多线程的应⽤中。
> 
> %%: 输出⼀个”%”字符
> 
> %F: 输出⽇志消息产⽣时所在的⽂件名称
> 
> %L: 输出代码中的⾏号
> 
> %m: 输出代码中指定的消息,产⽣的⽇志具体信息
> 
> %n: 输出⼀个回⻋换⾏符，Windows平台为”\\r\\n”，Unix平台为”\\n”输出⽇志信息换⾏

3、Loggers节点，常⻅的有两种：Root和Logger

> Root节点⽤来指定项⽬的根⽇志，如果没有单独指定Logger，那么就会默认使⽤该Root⽇志输出
> 
> Logger节点⽤来单独指定⽇志的形式，⽐如要为指定包下的class指定不同的⽇志级别等。

#### 3.2.2 Log4j2**的使⽤** ####

1 **导包**

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

2 **创建配置⽂件**

<?xml version="1.0" encoding="UTF-8" ?>
    <configuration status="error">
        
        <appenders>
            <Console name="console" target="SYSTEM_OUT">
                
                <ThresholdFilter level = "trace" onMatch="ACCEPT" onMismatch="DENY"/>
                <PatternLayout pattern = "%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %m%n"/>
            </Console>
    
            <File name="log" fileName="G:/logs/log4j2.log" append = "true">
                <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %m%n"/>
            </File>
    
            <File name="error" fileName="G:/logs/log4j2_error.log">
                <ThresholdFilter level = "error" onMatch="ACCEPT" onMismatch="DENY"/>
                <PatternLayout pattern = "%d{yyyy.MM.dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %m%n"/>
            </File>
    
            
            <RollingFile name="rollingFile" fileName="G:/logs/web.log"
                         filePattern="logs/$${date:yyyy-MM}/web-%d{MM-dd-yyyy}-%i.log.gz">
                <PatternLayout pattern = "%d{yyyy.MM.dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %m%n"/>
                <SizeBasedTriggeringPolicy size="2MB"/>
            </RollingFile>
    
        </appenders>
    
        <loggers>
            <root level = "trace">
                <appender-ref ref="rollingFile"/>
                <appender-ref ref="console"/>
                <appender-ref ref="error"/>
                <appender-ref ref="log"/>
            </root>
        </loggers>
    
    </configuration>

3 **应⽤**

package com.wang;
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    
    public class Test {
    
        private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    
        public static void main(String[] args) {
    
            for (int i= 0;i<3;i++){
                // 记录trace级别的日志信息
                logger.trace("log4j日志输出：This is trace message.");
                // 记录debug级别的日志信息
                logger.debug("log4j日志输出：This is debug message.");
                // 记录info级别的日志信息
                logger.info("log4j日志输出：This is info message.");
                // 记录error级别的日志信息
                logger.error("log4j日志输出：This is error message.");
            }
    
    
        }
    
    }

#### 3.2.3 Log4j**的**Bug**及解决⽅案** ####

**解决⽅式**

*  禁⽤lookup或JNDI服务

罪魁祸⾸就是lookup和JNDI，那么直接修改配置⽂件 log4j2.formatMsgNoLookups=True或禁⽤JNDI服务，不过⼀般产⽣问题的服务都是线上已经在跑的服务，禁⽤的时候要注意评估⼀下是否允许。

*  升级Apache Log4j

这次产⽣的影响范围主要是在Apache Log4j 2.x <= 2.14.1，所以直接把Log4j升级即可解决。

## 4.SpringBoot**⽇志管理** ##

### 4.1 SpringBoot**⾃定义⽇志**  ###

SpringBoot内部使⽤logback作为系统⽇志实现的框架，将⽇志输出到控制台，不会写到⽇志⽂件。如果在application.properties或application.yml配置，这样只能配置简单的场景，保存路径、⽇志格式等。复杂的场景（区分 info 和 error 的⽇志、每天产⽣⼀个⽇志⽂件等）满⾜不了，只能⾃定义配置⽂件logback-spring.xml。

#### 4.1.1 SpringBoot**默认的⽇志配置** ####

![f314f725eced45cb94158f07ef6f3a8d.png][]

> **格式说明** 
> 
> 时间戳,精确到毫秒: 2022-10-27 12:38:39.195
> 
> logback⽇志级别.⽇志级别分为：TRACE、DEBUG、INFO、WARN、ERROR、
> 
> FATAL: INFO
> 
> 进程ID: 16816
> 
> 分割符:默认是: ---
> 
> 线程名称: \[main\]

SpringBoot从控制台打印出来的⽇志级别默认只有INFO及以上级别，可以在application.properties中修改⽇志级别logging.level.root=WARN。

在application.properties配置⽂件中添加：

> logging.level.root= WARN

<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <version>1.18.12</version>
    </dependency>

package com.wang.controller;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.stream.IntStream;
    
    /**
     * @author 飞
     */
    @Slf4j //lombok 提供的注解
    @RestController
    @RequestMapping("log")
    public class LogController {
        //如果不使⽤lombok就需要⽤以下代码获取⽇志操作对象
        //Logger log = LoggerFactory.getLogger(LogController.class);
        @GetMapping("/test")
        public String test(){
            IntStream.range(0, 1000).forEach(i -> {
                log.trace("hello trace");
                log.debug("hello debug");
                log.info("hello info");
                log.warn("hello warn");
            });
            return "SpringBoot日志管理";
        }
    
    }

root是项⽬所有的⽇志级别。启动成功了，但是没有⽇志输出。我们把默认的⽇志级别设置成WARN,按照层级关系INFO,DEBUG,TRACE的⽇志都不输出。我们在 application.properties 将root的⽇志级别改成INFO，⾃⼰的写的业务包⽇志级别改成DEBUG。

logging.level.root=INFO //root⽇志以INFO级别输出信息
    logging.level.com.wang.controller.config=WARN //指定config包下的类以WARN级别输出

运⾏之后，log.info("这是info级别⽇志")没有输出。

> **⽇志的其它配置项** 
> 
> logging.config ⽇志配置；
> 
> logging.logback.rollingpolicy.max-file-size (低版本⽤ logging.file.max-size )最⼤⽇志⽂件⼤⼩；
> 
> logging.logback.rollingpolicy.max-history (低版本 logging.file.max-history )最⼤归档⽂件数量；
> 
> logging.pattern.console 控制台输出的⽇志模式；
> 
> logging.pattern.dateformat ⽇志的⽇期格式；
> 
> logging.pattern.file 默认使⽤⽇志模式
> 
> logging.pattern.level ⽇志级别
> 
> logging.config ⽇志配置；
> 
> logging.logback.rollingpolicy.max-file-size (低版本⽤logging.file.max-size )最⼤⽇志⽂件⼤⼩；
> 
> logging.logback.rollingpolicy.max-history (低版本 logging.file.max-history )最⼤归档⽂件数量；
> 
> logging.pattern.console 控制台输出的⽇志模式；
> 
> logging.pattern.dateformat ⽇志的⽇期格式；
> 
> logging.pattern.file 默认使⽤⽇志模式
> 
> logging.pattern.level ⽇志级别

#### 4.1.2 **使⽤**logback-spring.xml**⾃定义配置** ####

⽇志服务⼀般都在ApplicationContext创建前就初始化了，它并不是必须通过Spring的配置⽂件控制。因此通过系统属性和传统的Spring Boot外部配置⽂件依然可以很好的⽀持⽇志控制和管理。在类路径下放置⾃定义⽇志配置xml⽂件，SpringBoot就不会使⽤它本身的默认⽇志配置了。下图是SpringBoot官⽅⽂档的提示内容，意思是：根据您的⽇志记录系统，将加载相应的⽂件使⽤。即如果我们使⽤logback⽇志框架，那么可以使⽤logback-spring.xml、logback-spring.groovy、logback.xml、logback.groovy之⼀作为配置⽂件来加载。根据不同的⽇志系统，你可以按如下规则组织配置⽂件名，并且放在src/main/resources下⾯就能被正确加载：

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

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 name="log_dir" value="C://logs"/>
     
     <appender name="console"
    class="ch.qos.logback.core.ConsoleAppender">
     <target>System.out</target> 
     
     <encoder
    class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
     <pattern>${pattern}</pattern>
     </encoder>
     </appender>
     
     <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>
    
     <appender name="html"
    class="ch.qos.logback.core.FileAppender">
     <file>${log_dir}/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>
     
     <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-HHss}.log%i.gz</fileNamePattern>
     <maxFileSize>1MB</maxFileSize>
     </rollingPolicy>
     </appender>
     
     <filter class="ch.qos.logback.classic.filter.LevelFilter">
     <level>ERROR</level>
     <onMatch>ACCEPT</onMatch>
    <omMismatch>DENY</omMismatch>
     </filter>
     
     <appender name="asyncInfo"
    class="ch.qos.logback.classic.AsyncAppender">
     
     <discardingThreshold>0</discardingThreshold>
     
     <queueSize>256</queueSize>
     
     <appender-ref ref="rollFile"/>
     </appender>
     <root level="ALL">
     <appender-ref ref="console"/>
     <appender-ref ref="rollFile"/>
     <appender-ref ref="asyncInfo"/>
    
    
     </root>
    </configuration>

#### 4.1.3 **多环境输出⽇志⽂件** ####

SpringBoot官⽅建议使⽤logback-spring.xml作为logback框架的⾃定义⽇志配置⽂件，使⽤logback-spring.xml⽽不是logback.xml，因为带-spring后缀的配置⽂件可以使⽤使⽤Spring扩展profile⽀持，提供profile多环境⽇志输出得功能。

Logback 配置⽂件中的 节点指令允许您根据配置⽂件激活参数(active) 选择性的包含和排查部分配置信息。根据不同环境来定义不同的⽇志输出，在 logback-spring.xml中使⽤ 节点来定义，⽅法如下:

<springProfile name="dev">
     
     <logger name="com.laoxue.contoller.test" level="debug"
    addtivity="false"/>
     
     <root level="INFO">
     <appender-ref ref="console" />
     </root>
    
     </springProfile>
     
     <springProfile name="pro">
     <root level="INFO">
     <appender-ref ref="rollFile"/>
     <appender-ref ref="asyncInfo"/>
     </root>
    
    
     </springProfile>

以启动服务的时候指定 profile （如不指定使⽤默认），如指定prod 的⽅式为：

> java -jar xxx.jar –spring.profiles.active=prod

### 4.2 SpringBoot**整合**Log4j2 ###

Apache Log4j 2是 Log4j1. x 的升级版，⽐它的祖先 Log4j 有了很⼤的改进，和 logback对⽐有很⼤的改进。除了内部设计的调整外，主要有以下⼏点的⼤升级：

*  更简化的配置
 *  更强⼤的参数格式化
 *  强⼤的异步性能

Log4j 2中，分为API(log4j-api **）和实现**(log4j-core)两个模块。API 和slf4j 是⼀个类

型，属于⽇志抽象/⻔⾯，⽽实现部分，才是Log4j 2的核⼼。

*  org.apache.logging.log4j » log4j-api
 *  org.apache.logging.log4j » log4j-core

相⽐与其他的⽇志系统，log4j2丢数据这种情况少；disruptor技术，在多线程环境下，性能⾼于logback等10倍以上；利⽤jdk1.5并发的特性，减少了死锁的发⽣；同步⽇志模式下, Logback的性能是最糟糕的，log4j2的性能⽆论在同步⽇志模式还是异步⽇志模式下都是最佳的。

![e416780aa5a341c08ab460218fa8ddd1.png][]

1.pom配置

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <exclusions>
                    
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-logging</artifactId>
                    </exclusion>
                </exclusions>
                <version>2.7.5</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-log4j2</artifactId>
                <version>1.4.7.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.20</version>
            </dependency>
    
        </dependencies>

2. **配置⽂件**

默认名log4j2-spring.xml. 如果是其它的名字需要在配置⽂件中指定

> logging.config=xxx.xml

配置⽂件模板：

<?xml version="1.0" encoding="UTF-8"?>
    
    
    <configuration monitorInterval="5">
        
    
        
        <Properties>
            
            
            <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
            
            <property name="FILE_PATH" value="G://logs" />
            <property name="FILE_NAME" value="springboot-log" />
        </Properties>
    
        <appenders>
    
            <console name="Console" target="SYSTEM_OUT">
                
                <PatternLayout pattern="${LOG_PATTERN}"/>
                
                <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            </console>
    
            
            <File name="File-log" fileName="${FILE_PATH}/test.log" append="false">
                <PatternLayout pattern="${LOG_PATTERN}"/>
            </File>
    
            
            <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
                
                <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
                <PatternLayout pattern="${LOG_PATTERN}"/>
                <Policies>
                    
                    <TimeBasedTriggeringPolicy interval="1"/>
                    <SizeBasedTriggeringPolicy size="1MB"/>
                </Policies>
                
                <DefaultRolloverStrategy max="15"/>
            </RollingFile>
    
            
            <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
                
                <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
                <PatternLayout pattern="${LOG_PATTERN}"/>
                <Policies>
                    
                    <TimeBasedTriggeringPolicy interval="1"/>
                    <SizeBasedTriggeringPolicy size="1MB"/>
                </Policies>
                
                <DefaultRolloverStrategy max="15"/>
            </RollingFile>
    
            
            <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
                
                <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
                <PatternLayout pattern="${LOG_PATTERN}"/>
                <Policies>
                    
                    <TimeBasedTriggeringPolicy interval="1"/>
                    <SizeBasedTriggeringPolicy size="1MB"/>
                </Policies>
                
                <DefaultRolloverStrategy max="15"/>
            </RollingFile>
    
        </appenders>
    
        
        
        <loggers>
            
            <logger name="org.mybatis" level="info" additivity="false">
                <AppenderRef ref="Console"/>
            </logger>
            
            
            <Logger name="org.springframework" level="info" additivity="false">
                <AppenderRef ref="Console"/>
            </Logger>
            <root level="info"> 
                <appender-ref ref="Console"/>
                <appender-ref ref="File-log"/>
                <appender-ref ref="RollingFileInfo"/>
                <appender-ref ref="RollingFileWarn"/>
                <appender-ref ref="RollingFileError"/>
            </root>
    
        </loggers>
    
    </configuration>

## 5.demo源码：[Java日志模板: Java日志信息，包括slf42,logback,springboot整合slf42][Java_ Java_slf42_logback_springboot_slf42] ##

[43e670e81d884334af5ae6a3d3ff7df9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/85545a47ef344cd18590f3d45fd4d5e7.png
[bfee8cdc01da4a749002d9d13b17a503.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7bfb9f5d352e4c01bf73ca43988e411f.png
[f314f725eced45cb94158f07ef6f3a8d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/add1928d44264004b995aa22e20c07f1.png
[e416780aa5a341c08ab460218fa8ddd1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e940b7cbd4474b9db3f5ee87bdcbeb6d.png
[Java_ Java_slf42_logback_springboot_slf42]: https://gitee.com/here-comes-brother-fei/java-learning---framework.git