2021 July 30 Java后端开发

SpringBoot（四）-日志打印1

简介

  1. 引言：之前使用日志打印使用System.out、System.err，该打印格式单一、简单，信息少，通常需要打印的日志附带一些其他信息，比如时间、所属类、错误类型，甚至想把错误日志信息保存到本地磁盘文件，以便于后序排查问题，那么就需要专门封装一下打印，就出现了一些专门打印日志的第三方框架
  2. 日志（Log））的作用
    1. 开发调试：在开发过程中，进行逻辑跟踪、查看运行结果
    2. 问题排查：辅助排查和定位线上问题，优化程序运行性能
    3. 状态监控：用户数据对于公司下一步的战略方向有一定的指导作用
    4. 数据分析：日志中蕴含了大量的用户数据，包括点击行为，兴趣偏好等
  3. Java日志处理的发展史
    1. 最原始：System.out、System.err
    2. JUL(Java Util Logging)：JDK自带的日志框架，在java.util.logging包下，API不完善、对开发者不友好，很少人使用
    3. Log4j(Log For Java)：由Apache组织推出，1.x版本于2015年8月5日宣布停止维护
    4. JCL(Jakarta Commons Logging)：由Apache组织推出的日志门面接口， 提供一套API来实现不同Logger之间的切换
    5. SLF4J(Simple Logging Facade For Java)：由Log4j作者开发的日志门面接口，比JCL更优秀更好用
    6. Logback：由Log4j作者开发，比Log4j 1.x性能高很多，实现了SLF4J接口
    7. Log4j2：由Apache组织推出的，Log4j 1.x的重大升级改进版，改进了Logback的一些问题，既是门面接口，又是日志实现
  4. Java日志框架总结
    1. 门面接口：JCL、SLF4J、Log4j2
    2. 日志实现：JUL、Log4j 1.x 、Logback、Log4j2
  5. Java日志框架讲解内容
    1. Log4j 1.x （实现）
    2. JCL（门面）+ Log4j 1.x （实现）
    3. SLF4J（门面）
      1. Log4j 1.x （实现）
      2. Logback（实现）+ SpringBoot
      3. Log4j 2.x（实现）+ SpringBoot
    4. Log4j 2.x（门面）+ Log4j 2.x（实现）

Log4j 1.x

简单使用

  1. 初始化项目
    1. 新建项目23_Log,然后删除src文件夹，只留pom.xml文件夹
    2. 右击23_Log，新建子项目01_Log4j1x

    3. 在01_Log4j1x的pom.xml中添加依赖

       <dependencies>
     <dependency>
         <groupId>log4j</groupId>
         <artifactId>log4j</artifactId>
         <version>1.2.17</version>
     </dependency>
 </dependencies>
  2. 添加配置文件
    1. classpath:log4j.xml（优先级高）
    2. classpath:log4j.properties
    3. log4j.properties功能比log4j.xml弱一些，比如log4j.properties无法设置Filter

    4. 在resources下新建一个log4j.properties

       # 定义日志的编码
 encoding=UTF-8
 # 定义日志的格式
 pattern=%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5p] [%t]: %m%n
            
 # 1.全局配置：给log4j配置2个参数：TRACE 日志级别，大于等于这个级别的日志都会输出；console 输出目标，将日志输出到哪，即appender；
 log4j.rootLogger=TRACE, console
 #log4j.rootLogger=TRACE, console2
        
 # 下面自定义的目标变量，下面有console、console2、console33个输出目标变量
 # 2.设置输出目标为控制台
 # Appender输出目标（比如控制台、文件）
 # 设置格式：log4j.appender.名称（自己定义）=Appender的类型
 # org.apache.log4j.ConsoleAppender代表控制台
 # 意思是：给log4j配置一个appender，命名为console
 log4j.appender.console=org.apache.log4j.ConsoleAppender
 #1.1.设置日志的编码
 log4j.appender.console.encoding=${encoding}
 #1.2.Layout:设置输出日志的格式
 log4j.appender.console.layout=org.apache.log4j.PatternLayout
 log4j.appender.console.layout.conversionPattern=${pattern}
            
 log4j.appender.console2=org.apache.log4j.ConsoleAppender
 log4j.appender.console2.layout=org.apache.log4j.PatternLayout
 # %c: 打印输出类名 -5：靠左对齐，占用5个字符  5：靠右对齐，占用5个字符
 log4j.appender.console2.layout.conversionPattern=%d{HH:mm:ss.SSS} [%-5p] [%t] %c: %m%n
            
 log4j.appender.console3=org.apache.log4j.ConsoleAppender
 # 日志以HTML的方式展示
 log4j.appender.console3.layout=org.apache.log4j.HTMLLayout
  3. TestLog4j1测试代码

    1. 测试代码

       public class TestLog4j1 {
     public static void main(String[] args) {
         //需要先创建一个logger，然后用这个对象打印日志，getLogger可以是字符串、类，都行
         Logger logger = LogManager.getLogger(TestLog4j1.class);
         logger.info("信息_INFO");
         logger.error("错误_ERROR");
         logger.debug("调试_DEBUG");
         logger.trace("痕迹_TRACE");
         logger.warn("警告_WARN");
         logger.fatal("致命_FATAL");
     }
 }

    2. 输出的日志为：

       //使用console
 22:01:02.451 [INFO ] [main]: 信息_INFO
 22:01:02.453 [ERROR] [main]: 错误_ERROR
 22:01:02.454 [DEBUG] [main]: 调试_DEBUG
 22:01:02.454 [TRACE] [main]: 痕迹_TRACE
 22:01:02.454 [WARN ] [main]: 警告_WARN
 22:01:02.454 [FATAL] [main]: 致命_FATAL
        
 //使用console2
 22:01:02.451 [INFO ] [main] com.zh.main.TestLog4j1: 信息_INFO
 22:01:02.453 [ERROR] [main] com.zh.main.TestLog4j1: 错误_ERROR
 22:01:02.454 [DEBUG] [main] com.zh.main.TestLog4j1: 调试_DEBUG
 22:01:02.454 [TRACE] [main] com.zh.main.TestLog4j1: 痕迹_TRACE
 22:01:02.454 [WARN ] [main] com.zh.main.TestLog4j1: 警告_WARN
 22:01:02.454 [FATAL] [main] com.zh.main.TestLog4j1: 致命_FATAL
  4. 日志级别
    1. 日志的级别由小到大是：TRACE<DEBUG<INFO<WARN<ERROR<FATAL<OFF
    2. 设置了日志级别后，能输出 大于等于 它级别的日志信息，OFF是关闭日志
  5. Pattern
    1. 官方地址
     %c: Logger的全类名
 %d: 时间，%d{yyyy-MM-dd HH:mm:ss.SSS}
 %t: 线程的名称
 %F: 文件名
 %L: 代码行号
 %M: 方法
 %l: 代码的具体位置（哪个类的哪个方法？哪一行？）
 %m: 消息
 %n: 换行
 %p: 日志级别
 %%: 一个%

子Logger

  1. 如果使用log4j.rootLogger配置log，那么这个项目中的所有log都是同样的格式，但是如果想让不同的类、包名有不同的日志格式配置呢？ —-子Logger
  2. 子Logger可以是包级别、类级别：为某些类、包单独定义一些log
  3. 所有子Logger的最终父Logger是rootLogger
  4. 子Logger默认会继承父Logger的Appender
    1. 即子Logger相当于有2个Appender，会把父Logger的Appender也打印出来，这样会打印很多重复的日志
    2. 如果不想继承父类的Appender，可以设置additivity为false
     # 1. 全局配置
 log4j.rootLogger=TRACE, console
        
 # 定义子Logger
 # 2. 设置某个包，这个包下面的所有log都会以该配置打印
 log4j.logger.com.zh.main=WARN, console
 log4j.logger.com.zh.test=ERROR, console2
 # 3. 设置某个类，这个类使用log4j打印的日志都是该配置
 #log4j.logger.com.zh.main.TestLog4j1=WARN, console
 # 子Logger默认会继承父Logger的Appender，当前logger的父logger是log4j.logger.com.zh.main（父logger是rootLogger）
 log4j.logger.com.zh.main.TestLog4j1_02=ERROR, console2
 # 4. 这个logger不继承父Logger的Appender，只打印自己的Appender
 log4j.additivity.com.zh.main.TestLog4j1_02=false

其他Appender

  1. 上面讲的仅仅是ConsoleAppender-将日志打印到控制台；那么如果想要把日志输出到文件中共去呢？或者根据时间、大小自动分割成多个日志文件呢？—-FileAppender

  2. log4j.propertiess全局配置如下

     # 全局配置
 encoding=UTF-8
 pattern=%d{HH:mm:ss.SSS} [%-5p] [%t] %c: %m%n
 log4j.rootLogger=TRACE, file
 # 可以设置多个appender
 #log4j.rootLogger=TRACE, file, rollingFile,dailyRollingFile
  3. 设置appender属性的规律性
    1. 凡是该appender类或者父类实现中有set方法的都可以在这里设置（注意理解！！！）
    2. 比如FileAppender类，进入类实现，继承自WriterAppender
    3. FileAppender中有setFile方法，那么就可以配置file属性值
    4. WriterAppender有setEncoding方法，那么就可以配置encoding属性值

1.FileAppender

  1. 日志只能输出到一个文件中

     # 输出到文件（FileAppender），这里的file仅仅是一个appender名字，跟console一样
 log4j.appender.file=org.apache.log4j.FileAppender
 # 日志输出的具体文件路径，通过FileAppender类、父类发现file、encoding、layout都有对应的set方法，因此都可以设置
 log4j.appender.file.file=F:/logs/log4j.log
 log4j.appender.file.encoding=${encoding}
 log4j.appender.file.layout=org.apache.log4j.PatternLayout
 log4j.appender.file.layout.conversionPattern=${pattern}

2.RollingFileAppender

  1. 点击RollingFileAppender进入类实现，继承自FileAppender

     # 输出到滚动文件（RollingFileAppender）
 log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
 #文件的最大索引是10，最多产生11个文件
 #当文件数量满了，会优先删除时间较早的日志
 log4j.appender.rollingFile.maxBackupIndex=10
 # 每个文件最多占用1MB
 log4j.appender.rollingFile.maxFileSize=1MB
 log4j.appender.rollingFile.file=F:/logs/log4j.log
 log4j.appender.rollingFile.encoding=${encoding}
 log4j.appender.rollingFile.layout=org.apache.log4j.PatternLayout
 log4j.appender.rollingFile.layout.conversionPattern=${pattern}

3.DailyRollingFileAppender

```
log4j.appender.dailyRollingFile=org.apache.log4j.DailyRollingFileAppender
# 设置日志存储的时间单位：秒、分、时、天、。。。
# 设置为每隔一分生成一个日志文件，即同一分钟生成的日志都放到一个文件中
log4j.appender.dailyRollingFile.datePattern='.'yyyy-MM-dd-HH-mm
log4j.appender.dailyRollingFile.file=F:/logs/log4j.log
log4j.appender.dailyRollingFile.encoding=${encoding}
log4j.appender.dailyRollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender.dailyRollingFile.layout.conversionPattern=${pattern}
```

XML的使用

  1. 在resources下新建log4j.xml，同时有log4j.xml、log4j.properties，xml会覆盖掉properties

  2. 举例使用：

     <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE log4j:configuration
         PUBLIC "-//log4j/log4j Configuration//EN" "log4j.dtd">
 <log4j:configuration>
     <!-- appender -->
     <appender name="console" class="org.apache.log4j.ConsoleAppender">
         <param name="encoding" value="UTF-8"/>
         <layout class="org.apache.log4j.PatternLayout">
             <param name="conversionPattern" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
         </layout>
     </appender>
        
     <appender name="file" class="org.apache.log4j.FileAppender">
         <param name="file" value="F:/logs/log4j.log"/>
         <param name="encoding" value="UTF-8"/>
         <layout class="org.apache.log4j.PatternLayout">
             <param name="conversionPattern" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
         </layout>
     </appender>
    
     <appender name="rollingFile" class="org.apache.log4j.RollingFileAppender">
         <param name="maxFileSize" value="1MB"/>
         <param name="maxBackupIndex" value="10"/>
         <param name="file" value="F:/logs/log4j.log"/>
         <param name="encoding" value="UTF-8"/>
         <layout class="org.apache.log4j.PatternLayout">
             <param name="conversionPattern" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
         </layout>
     </appender>
    
     <appender name="dailyRollingFile" class="org.apache.log4j.DailyRollingFileAppender">
         <param name="datePattern" value="'.'yyyy-MM-dd-HH-mm-ss"/>
         <param name="file" value="F:/logs/log4j.log"/>
         <param name="encoding" value="UTF-8"/>
         <layout class="org.apache.log4j.PatternLayout">
             <param name="conversionPattern" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
         </layout>
     </appender>
        
     <!--子logger
     additivity：是否继承父类的appender
     -->
     <logger name="com.zh.main.TestLog4j1" additivity="false">
         <level value="TRACE"/>
         <appender-ref ref="dailyRollingFile"/>
     </logger>
     <!-- 根logger -->
     <root>
         <level value="TRACE"/>
         <appender-ref ref="console"/>
         <appender-ref ref="file"/>
     </root>
 </log4j:configuration>

Filter

  1. Filter可以让Appender在logger的基础上进一步过滤日志信息
  2. 可以针对某个Appender来过滤日志
<appender name="console" class="org.apache.log4j.ConsoleAppender">
    <param name="encoding" value="UTF-8"/>
    <layout class="org.apache.log4j.PatternLayout">
        <param name="conversionPattern" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
    </layout>

    <!--  关闭所有的日志输出-->
    <filter class="org.apache.log4j.varia.DenyAllFilter" />
    
    <!--关闭打印信息中包含字符串"T"的日志-->
    <filter class="org.apache.log4j.varia.StringMatchFilter">
        <param name="stringToMatch" value="T"/>
        <param name="acceptOnMatch" value="false"/>
    </filter>

    <!-- 只输出[INFO, ERROR]之间的日志 -->
    <filter class="org.apache.log4j.varia.LevelRangeFilter">
        <param name="levelMin" value="INFO"/>
        <param name="levelMax" value="ERROR"/>
    </filter>
    
    <!-- 关闭WARN级别 -->
    <filter class="org.apache.log4j.varia.LevelMatchFilter">
        <param name="levelToMatch" value="WARN"/>
        <param name="acceptOnMatch" value="false"/>
    </filter>
    
    <!-- 关闭FATAL级别 -->
    <filter class="org.apache.log4j.varia.LevelMatchFilter">
        <param name="levelToMatch" value="FATAL"/>
        <param name="acceptOnMatch" value="false"/>
    </filter>
</appender>

开启内部日志信息

  1. 3种方法开启log4j的内部日志信息（就是使用功能log4j时，内部运行的一些日志信息）
#方式一：log4j.properties
log4j.debug=true
    
方式二：log4j.xml
<log4j:configuration debug="true">
</log4j:configuration>
    
方式三：TestLog4j1中，使用LogLog直接设置
LogLog.setInternalDebugging(true);

JCL + Log4j 1.x

简单使用

  1. 右击23_Log，新建项目02_JCL_Log4j1.x

  2. 在pom.xml添加依赖

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

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

  3. 在resources中添加配置文件log4j.xml

     <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE log4j:configuration
         PUBLIC "-//log4j/log4j Configuration//EN" "log4j.dtd">
 <log4j:configuration>
     <!-- appender -->
     <appender name="console" class="org.apache.log4j.ConsoleAppender">
         <param name="encoding" value="UTF-8"/>
         <layout class="org.apache.log4j.PatternLayout">
             <param name="conversionPattern" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
         </layout>
     </appender>
    
     <root>
         <level value="TRACE"/>
         <appender-ref ref="console"/>
     </root>
 </log4j:configuration>

  4. TestJCL_Log4j1类测试

     public class TestJCL_Log4j1 {
     public static void main(String[] args) {
         //开启内部日志信息
         // LogLog.setInternalDebugging(true);
         //LogFactory:是JCL的接口类
         Log log = LogFactory.getLog(TestJCL_Log4j1.class);
         log.info("信息_INFO");
         log.error("错误_ERROR");
         log.debug("调试_DEBUG");
         log.trace("痕迹_TRACE");
         log.warn("警告_WARN");
         log.fatal("致命_FATAL");
     }
 }

Lombok自动生成JCL的Log定义

  1. pom.xml中添加lombok依赖（略）

  2. TestJCL_Log4j1添加@CommonsLog注解

     //添加注解，自动生成JCL的Log定义
 @CommonsLog
 public class TestJCL_Log4j1_02 {
     //@CommonsLog注释等价于
     // private static final Log log = LogFactory.getLog(TestJCL_Log4j1_02.class);
     public static void main(String[] args) {    
         //直接使用log
         log.info("信息_INFO");
         log.error("错误_ERROR");
         log.debug("调试_DEBUG");
         log.trace("痕迹_TRACE");
         log.warn("警告_WARN");
         log.fatal("致命_FATAL");
     }
 }

JCL实现原理

图1

  1. JCL的实现原理是
    1. 内部提供了适配器，在适配器中调用JUL、Log4j
    2. 如果上面的项目没有添加log4j依赖，那么TestJCL_Log4j1中的打印任然正常，此时调用的是JUL（JDK自带的日志打印）
  2. 一旦要适配新推出的日志框架，JCL需要修改内部源码，目前已经被apache淘汰

SLF4J+Log4j 1.x

  1. SLF4J对各种日志框架的支持 图1
  2. 分析：可以看到Log4j 1.x并没有适配SLF4J，因此需要添加一个适配器Adaptation即引入Slf4j-log4j12.jar

基本使用

  1. 右击23_Log，新建项目03_SLF4J_Log4j1.x

  2. pom.xml添加依赖

     <dependencies>
<!--        <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.30</version>-->
<!--        </dependency>-->
     <!--log4j与slf之间的依赖包 因此上面2个包不用导入 -->
     <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-log4j12</artifactId>
         <version>1.7.30</version>
     </dependency>
 </dependencies>
  3. 在resources中添加配置文件log4j.xml（略，跟之前一样）

  4. TestSLF4J_Log4j1测试

     public class TestSLF4J_Log4j1 {
     public static void main(String[] args) {
         Logger logger = LoggerFactory.getLogger(TestSLF4J_Log4j1.class);
         log.error("错误_ERROR");
         log.warn("警告_WARN");
         log.info("信息_INFO");
         log.debug("调试_DEBUG");
         log.trace("痕迹_TRACE");
     }
 }
  5. 注意： 在slf4j中，没有FATAL级别（或者可以理解为FATAL等价于ERROR)

Lombok自动生成SLF4J的Logger定义

  1. pom.xml中添加依赖

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

  2. TestSLF4J_Log4j1添加@Slf4j注释

     @Slf4j
 public class TestSLF4J_Log4j1 {
     public static void main(String[] args) {
         // Logger logger = LoggerFactory.getLogger(TestSLF4J_Log4j1.class);
         log.error("错误_ERROR");
         log.warn("警告_WARN");
         log.info("信息_INFO");
         log.debug("调试_DEBUG");
         log.trace("痕迹_TRACE");
     }
 }

SLF4J+Logback

简单使用

  1. 右击23_Log，新建项目04_SLF4J_Logbackx

  2. 在pom.xml添加依赖

     <dependencies>
<!--        <dependency>-->
<!--            <groupId>org.slf4j</groupId>-->
<!--            <artifactId>slf4j-api</artifactId>-->
<!--            <version>1.7.30</version>-->
<!--        </dependency>-->
     <!--logback内部已经实现了slf4j的接口，不需要中间适配器，因此依赖于slf4j，所以上面不用导入-->
     <dependency>
         <groupId>ch.qos.logback</groupId>
         <artifactId>logback-classic</artifactId>
         <version>1.2.3</version>
     </dependency>

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

  3. TestSLF4J_Logback类测试

     @Slf4j
 public class TestSLF4J_Logback {
     public static void main(String[] args) {
         log.error("错误_ERROR");
         log.warn("警告_WARN");
         log.info("信息_INFO");
         log.debug("调试_DEBUG");
         log.trace("痕迹_TRACE");
     }
 }

  4. 此时不需要设置配置文件，因为Logback内部有一套默认配置，可以不用提供配置文件，运行TestSLF4J_Logback，打印如下

     //Logback默认配置文件设置的打印日志格式
 22:19:04.072 [main] ERROR com.zh.TestSLF4J_Logback - 错误_ERROR
 22:19:04.081 [main] WARN com.zh.TestSLF4J_Logback - 警告_WARN
 22:19:04.081 [main] INFO com.zh.TestSLF4J_Logback - 信息_INFO
 22:19:04.081 [main] DEBUG com.zh.TestSLF4J_Logback - 调试_DEBUG

自定义Logback的配置文件

  1. 如果不想使用Logback默认的配置文件打印格式，那么也可以自己设置

  2. 在resources下新建一个logback.xml

     <configuration>
     <!-- 抽取公共内容 -->
     <!--highlight设置打印控制台日志的颜色,不同日志级别输出不同样式颜色，cyan青色-->
     <property name="CONSOLE_PATTERN" value="%d{HH:mm:ss.SSS} [%highlight(%-5p)] %cyan(%c): %m%n"/>
     <property name="CHARSET" value="UTF-8"/>
    
     <!-- appender -->
     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
             <charset>${CHARSET}</charset>
             <pattern>${CONSOLE_PATTERN}</pattern>
         </encoder>
     </appender>
     <!-- logger -->
     <root level="INFO">
         <appender-ref ref="console"/>
     </root>
     <!-- 子logger，additivity：不继承父类的Appender -->
     <logger name="com.zh" level="TRACE" additivity="false">
         <appender-ref ref="console"/>
     </logger>
 </configuration>
    1. 控制台彩色打印

configuration

  1. configuration标签的常用属性
    1. debug=”true”:可以打印Logback内部的日志
    2. Scan=”true” + scanPeriod=”30 seconds”
      1. 每隔30秒扫描配置文件，并且应用配置文件的最新修改
      2. scanPeriod的单位可以是：milliseconds、seconds、minutes、hours
      3. 使用场景：配置文件logback.xml部署到服务器是单独存在的，如果中间替换了，需要在不重新部署项目的情况下，重新加载logback.xml

  2. 举例

     <?xml version="1.0" encoding="UTF-8"?>
 <configuration debug="debug" scan="true" scanPeriod="5 seconds">
 </configuration>

Appender

<!-- 抽取公共内容 -->
<property name="CONSOLE_PATTERN" value="%d{HH:mm:ss.SSS} [%highlight(%-5p)] %cyan(%c): %m%n"/>
<property name="FILE_PATTERN" value="%d{HH:mm:ss.SSS} [%-5p] %c: %m%n"/>
<property name="HTML_PATTERN" value="%d{HH:mm:ss.SSS}%-5p%c%m"/>
<property name="CHARSET" value="UTF-8"/>
<property name="BASE_PATH" value="F:/logs"/>

<!-- FileAppender-->
<appender name="file" class="ch.qos.logback.core.FileAppender">
    <!-- 指定文件路径-->
    <file>${BASE_PATH}/logback_file.log</file>
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        <charset>${CHARSET}</charset>
        <pattern>${FILE_PATTERN}</pattern>
    </encoder>
</appender>

<appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
    <!-- 指定文件路径，输出格式为html-->
    <file>${BASE_PATH}/logback.html</file>
    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        <charset>${CHARSET}</charset>
        <layout class="ch.qos.logback.classic.html.HTMLLayout">
            <pattern>${HTML_PATTERN}</pattern>
        </layout>
    </encoder>
</appender>
<!-- RollingFileAppender 常用-->
<appender name="rollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${BASE_PATH}/logback_rolling.log</file>
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        <charset>${CHARSET}</charset>
        <pattern>${FILE_PATTERN}</pattern>
    </encoder>
    <!-- 基于时间的滚动策略 -->
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <!-- 支持压缩 -->
        <fileNamePattern>${BASE_PATH}/logback_rolling_%d{yyy-MM-dd-HH-mm-ss}.log.gz</fileNamePattern>
        <!-- 删除20秒以前的日志文件（时间单位取决于fileNamePattern） -->
        <maxHistory>20</maxHistory>
        <!-- 总的日志大小限制（超过了，就删除最早的日志） -->
        <totalSizeCap>10KB</totalSizeCap>
    </rollingPolicy>
</appender>

<appender name="rollingFile2" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${BASE_PATH}/logback_rolling2.log</file>
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        <charset>${CHARSET}</charset>
        <pattern>${FILE_PATTERN}</pattern>
    </encoder>
    <!-- 基于文件大小和时间的滚动策略 -->
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <!-- 支持压缩 -->
        <fileNamePattern>${BASE_PATH}/logback_rolling2_%d{HH-mm}_%i.log.gz</fileNamePattern>
        <!-- 当日志文件大小超过1MB，就生成新的日志文件 -->
        <maxFileSize>1MB</maxFileSize>
    </rollingPolicy>
</appender>

Filter

<!-- appender -->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        <charset>${CHARSET}</charset>
        <pattern>${CONSOLE_PATTERN}</pattern>
    </encoder>
    <!-- 只打印WARN级别的信息 -->
    <filter class="ch.qos.logback.classic.filter.LevelFilter">
        <level>WARN</level>
        <!-- 当匹配：接收（开启打印） -->
        <onMatch>ACCEPT</onMatch>
        <!-- 当不匹配：否定（关闭打印） -->
        <onMismatch>DENY</onMismatch>
    </filter>
</appender>

AsyncAppender

  1. 在logback中，可以使用AsyncAppender提高效率

  2. 开一个线程开做日志打印

     <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
     <!-- 阻塞队列的容量 -->
     <param name="queueSize" value="512"/>
     <!-- 当阻塞队列的剩余20%容量时，会默认丢弃TRACE、DEBUG、INFO级别的日志。-->
     <!-- discardingThreshold设置为0，就不会丢弃。 -->
     <param name="discardingThreshold" value="0"/>
     <!-- 将file这个apperder包装成异步的 -->
     <appender-ref ref="file"/>
 </appender>
 <!-- 子logger，additivity：不继承父类的Appender -->
 <logger name="com.zh" level="TRACE" additivity="false">
     <appender-ref ref="async"/>
 </logger>

All content is licensed under CC BY-NC-SA

Buit with Jekyll and 3-Jekyll theme • Hosted on Github

Table of Contents