java常用日志框架日志门面及实现 SLF4J 、Jboss-logging 、JCL、Log4j、Logback、Log4j2、JUL,springboot集成 log4j、log4j2

赵涵亮
2023-12-01

一、java常用日志框架

1.日志门面(日志接口)

​ 日志门面来解决系统与日志实现框架的耦合性。不是一个真正的日志实现,而是一个抽象层( abstraction layer),它允许你在后台使用任意一个日志实现。

​ 在项目开发中,记录日志时不应该直接调用日志实现层的方法,而应该调用日志门面(日志抽象层)的方法。

  • SLF4J(Simple Logging Facade for Java)

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

    eg: springboot 市 SLF4j+logback

  • Jboss-logging

    使用的场景太少了,普通的业务开发很少用,都是特定的框架在用。

    ​ eg:hibernate框架

  • JCL

    ​ 全称为Jakarta Commons Logging,是Apache提供的一个通用日志API。它是为"所有的Java日志实现",提供一个统一的接口,它自身也提供一个日志的实现,但是功能非常弱(SimpleLog),故而一般不单独使用它(作为统一接口调用,换日志框架,比如换成log4j,切换依赖即可)。它允许开发人员使用不同的具体日志实现工具;Log4j,JDK自带的日志(JUL)。

    最后一次版本更新停在了2014年,后来没有继续维护更新,一般不考虑选用 。

    eg: Spring框架选用的是:commons-logging日至门面

2.日志门面的实现

  1. Log4j

    Log4j是Apache的一个Java的日志库,通过使用Log4j,我们可以控制日志信息输送的目的地(控制台、文件、数据库等);我们也可以控制每一条日志的输出格式;通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。

  2. Logback

    ​ Logback,一个“可靠、通用、快速而又灵活的Java日志框架”。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统,如log4j或JDK14 Logging。logback-access模块与Servlet容器(如Tomcat和Jetty)集成,以提供HTTP访问日志功能。请注意,您可以在logback-core之上轻松构建自己的模块。

    Logback 是 Slf4j 的原生实现框架,它与 Log4j 出自一个人之手,但拥有比 log4j 更多的优点、特性和更做强的性能,现在基本都用来代替 log4j 成为主流。

  3. Log4j2

    Apache Log4j 2是对Log4j的升级,它比其前身Log4j 1.x提供了重大改进,并提供了Logback中可用的许多改进,同时修复了Logback架构中的一些问题。

    现在最优秀的Java日志框架是Log4j2,没有之一。根据官方的测试表明,在多线程环境下,Log4j2的异步日志表现更加优秀。在异步日志中,Log4j2使用独立的线程去执行I/O操作,可以极大地提升应用程序的性能。

  4. JUL(java.util.logging)

    java.util.logging,是jdk自带的日志

二、springboot 集成日志

1.默认实现 logback

​ Spring Boot 默认使用 SLF4J+Logback 记录日志,并提供了默认配置,即使我们不进行任何额外配,也可以使用 SLF4J+Logback 进行日志输出。常见的日志配置包括日志级别、日志的输入出格式等内容。

1.1日志级别

	 日志的输出都是分级别的,当一条日志信息的级别大于或等于配置文件的级别时,就对这条日志进行记录。

常见的日志级别如下(优先级依次升高)。

序号日志级别说明
1trace追踪,指明程序运行轨迹。
2debug调试,实际应用中一般将其作为最低级别,而 trace 则很少使用。
3info输出重要的信息,使用较多。
4warn警告,使用较多。
5error错误信息,使用较多。

1.2输出格式

序号输出格式说明
1%d{yyyy-MM-dd HH:mm:ss, SSS}日志生产时间,输出到毫秒的时间
2%-5level输出日志级别,-5 表示左对齐并且固定输出 5 个字符,如果不足在右边补 0
3%logger 或 %clogger 的名称
4%thread 或 %t输出当前线程名称
5%p日志输出格式
6%message 或 %msg 或 %m日志内容,即 logger.info(“message”)
7%n换行符
8%class 或 %C输出 Java 类名
9%file 或 %F输出文件名
10%L输出错误行号
11%method 或 %M输出方法名
12%l输出语句所在的行数, 包括类名、方法名、文件名、行数
13hostName本地机器名
14hostAddress本地 ip 地址

springboot 默认日志级别 info

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DemoApplicationTests {
    Logger logger = LoggerFactory.getLogger(getClass());
    /**
     * 测试日志输出
     */
    @Test
    void logTest() {
        //日志级别 由低到高
        logger.trace("trace 级别日志");
        logger.debug("debug 级别日志");
        logger.info("info 级别日志");
        logger.warn("warn 级别日志");
        logger.error("error 级别日志");
    }
}

2022-04-01 17:47:00.473  INFO 24772 --- [           main] com.example.demo.DemoApplicationTests:info 级别日志
2022-04-01 17:47:00.473  WARN 24772 --- [           main] com.example.demo.DemoApplicationTests:warn 级别日志
2022-04-01 17:47:00.473 ERROR 24772 --- [           main] com.example.demo.DemoApplicationTests:error级别日志

  • 时间日期
  • 日志级别
  • 进程 ID
  • 分隔符:—
  • 线程名:方括号括起来(可能会截断控制台输出)
  • Logger 名称
  • 日志内容

1.3 logback.xml 常用配置

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒当scan为true时,此属性生效。默认的时间间隔为1分钟。
debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志的根目录 -->
    <property name="LOG_HOME" value="/app/log"/>
    <!-- 定义日志文件名称 -->
    <property name="appName" value="spring-boot-logging"></property>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式:
           %d表示日期时间,
           %thread表示线程名,
           %-5level:级别从左显示5个字符宽度
           %logger{50} 表示logger名字最长50个字符,否则按照句点分割。
           %msg:日志消息,
           %n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread]**************** %-5level %logger{50} - %msg%n</pattern>
        </layout>
    </appender>

    <!-- 滚动记录文件,先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件 
      另外RollingFileAppender下还有:
          <1> class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy":
           最常用的滚动策略,它根据时间来制定滚动策略, 既负责滚动也负责出发滚动。有以下子节点:
      <fileNamePattern>:必要节点,包含文件名及“%d”转换符,“%d”
                          可以包含一个java.text.SimpleDateFormat指定的时间格式, 如:%d{yyyy-MM}。
                          如果直接使用 %d,默认格式是 yyyy-MM-dd。RollingFileAppender的file字节点可有可无,
                          通过设置file,可以为活动文件和归档文件指定不同位置,当前日志总是记录到file指定的文件(活动文件),
                          活动文件的名字不会改变;
                          如果没设置file,活动文件的名字会根据fileNamePattern 的值,
                          每隔一段时间改变一次。“/”或者“\”会被当做目录分隔符。
        <maxHistory>:可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。
                          假设设置每个月滚动,且<maxHistory>是6,则只保存最近6个月的文件,删除之前的旧文件。
                          注意,删除旧文件是,那些为了归档而创建的目录也会被删除。

            <2> class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy": 
                     查看当前活动文件的大小,如果超过指定大小会告知RollingFileAppender 触发当前活动文件滚动。只有一个节点:
                 <maxFileSize>:这是活动文件的大小,默认值是10MB。
                 <prudent>:当为true时,不支持FixedWindowRollingPolicy。支持TimeBasedRollingPolicy,
                                  但是有两个限制,1不支持也不允许文件压缩,2不能设置file属性,必须留空。
                 <triggeringPolicy >: 告知 RollingFileAppender 合适激活滚动。
            
            <3> class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy" 
                    根据固定窗口算法重命名文件的滚动策略。有以下子节点:
                 <minIndex>:窗口索引最小值
                 <maxIndex>:窗口索引最大值,当用户指定的窗口过大时,会自动将窗口设置为12。
                 <fileNamePattern>:必须包含“%i”例如,假设最小值和最大值分别为1和2,命名模式为
                                     mylog%i.log,会产生归档文件mylog1.log和mylog2.log。还可以指定文件压缩选项,
                                      例如,mylog%i.log.gz 或者 没有log%i.log.zip

    
     -->
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${app.name}.log</file>
        <!--
        当发生滚动时,决定 RollingFileAppender 的行为,涉及文件移动和重命名
        TimeBasedRollingPolicy: 最常用的滚动策略,它根据时间来制定滚动策略,既负责滚动也负责出发滚动。
        -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}:按天进行日志滚动
            %i:当文件大小超过maxFileSize时,按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!--
            可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。假设设置每天滚动,
            且maxHistory是365,则只保存最近365天的文件,删除之前的旧文件。注意,删除旧文件是,
            那些为了归档而创建的目录也会被删除。
            -->
            <MaxHistory>365</MaxHistory>
            <!--
            当日志文件超过maxFileSize指定的大小是,根据上面提到的%i进行日志文件滚动 注意此处配置                                     SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的,
           必须配置timeBasedFileNamingAndTriggeringPolicy
            -->
            <timeBasedFileNamingAndTriggeringPolicy 	                               class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志输出格式: -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [ %thread ] ------------------ [ %-5level ] [ %logger{50} : %line ] -
                %msg%n
            </pattern>
        </layout>
    </appender>

    <!--
  logger主要用于存放日志对象,也可以定义日志类型、级别
  name:表示匹配的logger类型前缀,也就是包的前半部分
  level:要记录的日志级别,包括 TRACE < DEBUG < INFO < WARN < ERROR
  additivity:作用在于children-logger是否使用 rootLogger配置的appender进行输出,
  false:表示只用当前logger的appender-ref,true:
  表示当前logger的appender-ref和rootLogger的appender-ref都有效
    -->
    <!-- hibernate logger -->
    <logger name="net.biancheng.www" level="debug"/>
    <!-- Spring framework logger -->
    <logger name="com.example.demo" level="TRACE" additivity="false">
        <appender-ref ref="stdout"/>
    </logger>

    <!--
    root可以理解为一个根节点,而其他的logger都可以看做root的子节点
    root配置的appender属性logger都是使用的,
        logger定义时增加属性additivity="false" 是不使用root标签的 appender属性
        logger标签相当于单独设置 name=xxx 包下的日志输出和日志级别
            如果没有添加 appender-ref 就是没有指定要向那里输出日志

    判断一个类的日志输出情况,首先找到这个类所在的logger(没有特别定义则默认为root),
    然后根据以上规则判断出这个logger的appender和level。然后既可以知道这个类的哪些日志会被输出到哪些地方了。
    注意:任何一个类只会和一个logger对应,要么是定义的logger,要么是root,判断的关键在于找到这个logger,
    然后判断这个logger的appender和level
    -->
    <root level="info">
        <appender-ref ref="stdout"/>
        <appender-ref ref="appLogAppender"/>
    </root>


</configuration>

1.4 logback-spring.xml 配置

​ Spring Boot 推荐用户使用 logback-spring.xml、log4j2-spring.xml 等这种带有 spring 标识的配置文件。这种配置文件被放在项目类路径后,不会直接被日志框架加载,而是由 Spring Boot 对它们进行解析,这样就可以使用 Spring Boot 的高级功能 Profile,实现在不同的环境中使用不同的日志配置。

1.4.1 application.properties/yml配置

spring.profiles.active=pro #指定激活的环境
logging.config=classpath:logback-spring.xml #指定logbak配置文件

1.4.2 logback-spring.xml 常用属性

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL,如果设置为WARN,则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时,配置文档如果发生改变,将会被重新加载,默认值为true -->
<!-- scanPeriod:设置监测配置文档是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。
                 当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
<configuration  scan="true" scanPeriod="10 seconds">
    <contextName>logback</contextName>
    <!--  读取application.properties/yml 属性spring.application.name的值  -->
     <springProperty scope="context" name="app.name" source="spring.application.name"
                    defaultValue="demo1"/>
    <!-- name的值是变量的名称,value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后,可以使“${}”来使用变量。 -->
    <property name="log.path" value="/app/log" />

    <!--0. 日志格式和颜色渲染 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

    <!--1. 输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用,只配置最底级别,控制台输出的日志级别是大于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--2. 输出到文档-->
    <!-- 2.1 level为 DEBUG 日志,时间滚动输出  -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/${app.name}_debug.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/${app.name}-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.2 level为 INFO 日志,时间滚动输出  -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/${app.name}_info.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/${app.name}-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.3 level为 WARN 日志,时间滚动输出  -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/${app.name}_warn.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/web-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.4 level为 ERROR 日志,时间滚动输出  -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/${app.name}_error.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/${app.name}-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
        以及指定<appender>。<logger>仅有一个name属性,
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,
              还有一个特俗值INHERITED或者同义词NULL,代表强制执行上级的级别。
              如果未设置此属性,那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
        <logger name="org.springframework.web" level="info"/>
        <logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>
    -->

    <!--
        使用mybatis的时候,sql语句是debug下才会打印,而这里我们只配置了info,所以想要查看sql语句的话,有以下两种操作:
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql,不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式,代码如下,这样配置sql语句会打印,其他还是正常info级别:
        【logging.level.org.mybatis=debug logging.level.dao=debug】
     -->

    <!--
        root节点是必选节点,用来指定最基础的日志输出级别,只有一个level属性
        level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素,标识这个appender将会添加到这个logger。
    -->

    <!-- 4. 最终的策略 -->
    <!-- 4.1 开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="com.sdcm.pmp" level="debug"/>
    </springProfile>

    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="DEBUG_FILE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="WARN_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>

    <!-- pro环境
    如果这个环境激活 上边的 root 标签会被覆盖 走下边的配置
    -->
    <springProfile name="pro">
        <root level="debug">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile>

</configuration>

2.集成log4j2

2.1.日志级别

序号日志级别说明
1all最低等级的,用于打开所有日志记录.
2trace追踪,指明程序运行轨迹。是追踪,就是程序推进一下
3debug调试,实际应用中一般将其作为最低级别,而 trace 则很少使用。
4info输出重要的信息,使用较多。
5warn警告,使用较多。
6error错误信息,使用较多。
7Fatal输出每个严重的错误事件将会导致应用程序的退出的日志.
8OFF最高等级的,用于关闭所有日志记录

ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF,日志显示大于等于设置的日志级别会显示

2.2 .log4j2.xml

<?xml version="1.0" encoding="utf-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status,这个用于设置log4j2自身内部的信息输出,可以不设置,当设置成trace时,你会看到log4j2内部各种详细输出-->
<!--monitorInterval:Log4j能够自动检测修改配置 文件和重新配置本身,设置间隔秒数-->
<Configuration status="WARN" monitorInterval="600">
    <!-- 参数声明 -->
    <Properties>
        <!-- 日志文件存放根路径 -->
        <property name="DEFAULT_LOG_ROOT_PATH" value="/app/log"/>
        <!-- 日志格式
            %d{HH:mm:ss.SSS} 表示输出到毫秒的时间
                %t 输出当前线程名称
                %-5level 输出日志级别,-5表示左对齐并且固定输出5个字符,如果不足在右边补0
                %logger 输出logger名称,因为Root Logger没有名称,所以没有输出
                %msg 日志文本
                %n 换行
                其他常用的占位符有:
                %F 输出所在的类文件名,如Client.java
                %L 输出行号
                %M 输出所在方法名
                %l 输出语句所在的行数, 包括类名、方法名、文件名、行数
        -->
        <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} -- %style{[%t]}{bright,magenta} %highlight{%-5level}{ERROR=Bright RED, WARN=Bright Yellow, INFO=Bright Green, DEBUG=Bright Cyan, TRACE=Bright White} %logger{36}.%M - %msg%n"/>
        <!-- 日志文件最大文件大小全局配置,单位可以为KB、MB或GB,一天之内最大文件产生数量全局配置 -->
        <property name="MAX_FILE_SIZE" value="100MB"/>
        <property name="MAX_FILE_NUM" value="30"/>

        <!-- debug 日志文件位置及名称,在rollFile的时候老文件的生成规则 -->
        <property name="DEBUG_FILE_PATH_ING" value="${DEFAULT_LOG_ROOT_PATH}/debug.log"/>
        <!--  filePattern="${LOG_HOME}/$${date:yyyy-MM}/${FILE_NAME}-%d{yyyy-MM-dd}-%i.log.gz"> 备份时使用gz格式压缩-->
        <property name="DEBUG_FILE_PATH_ED" value="${DEFAULT_LOG_ROOT_PATH}/history/$${date:yyyy-MM-dd}/debug-%d{yyyy-MM-dd}.%i.log"/>

        <!-- info 日志文件位置及名称,在rollFile的时候老文件的生成规则 -->
        <property name="INFO_FILE_PATH_ING" value="${DEFAULT_LOG_ROOT_PATH}/info.log"/>
        <property name="INFO_FILE_PATH_ED" value="${DEFAULT_LOG_ROOT_PATH}/history/$${date:yyyy-MM-dd}/info-%d{yyyy-MM-dd}.%i.log"/>

        <!-- error 日志文件位置及名称,在rollFile的时候老文件的生成规则 -->
        <property name="ERROR_FILE_PATH_ING" value="${DEFAULT_LOG_ROOT_PATH}/error.log"/>
        <property name="ERROR_FILE_PATH_ED" value="${DEFAULT_LOG_ROOT_PATH}/history/$${date:yyyy-MM-dd}/error-%d{yyyy-MM-dd}.%i.log"/>

        <!-- warn 日志文件位置及名称,在rollFile的时候老文件的生成规则 -->
        <property name="WARN_FILE_PATH_ING" value="${DEFAULT_LOG_ROOT_PATH}/warn_error.log"/>
        <property name="WARN_FILE_PATH_ED" value="${DEFAULT_LOG_ROOT_PATH}/history/$${date:yyyy-MM-dd}/warn_error-%d{yyyy-MM-dd}.%i.log"/>

    </Properties>

    <appenders>
        <!-- 控制台输出日志信息 -->
        <console name="Console_Log" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
             <!--控制台只输出level及其以上级别的信息(onMatch),其他的直接拒绝(onMismatch)
                onMatch="ACCEPT" 表示匹配该级别及以上
                onMatch="DENY" 表示不匹配该级别及以上
                onMatch="NEUTRAL" 表示该级别及以上的,由下一个filter处理,如果当前是最后一个,则表示匹配该级别及以上
                onMismatch="ACCEPT" 表示匹配该级别以下
                onMismatch="NEUTRAL" 表示该级别及以下的,由下一个filter处理,如果当前是最后一个,则不匹配该级别以下的
                onMismatch="DENY" 表示不匹配该级别以下的
             -->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用-->
        <File name="Filelog" fileName="log/test.log" append="false">
            <!--%date表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度 %msg:日志消息,%n是换行符  -->
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size,
            则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档-->
        <RollingFile name="Info_File" fileName="${INFO_FILE_PATH_ING}" filePattern="${INFO_FILE_PATH_ED}">
            <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch)-->
            <ThresholdFilter level="INFO" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <SizeBasedTriggeringPolicy size="${MAX_FILE_SIZE}"/>
                <!--interval属性用来指定多久滚动一次,默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
            </Policies>
            <DefaultRolloverStrategy max="${MAX_FILE_NUM}"/>
        </RollingFile>

        <!-- debug日志文件输出日志信息 -->
        <RollingFile name="Debug_File" fileName="${DEBUG_FILE_PATH_ING}" filePattern="${DEBUG_FILE_PATH_ED}">
            <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <SizeBasedTriggeringPolicy size="${MAX_FILE_SIZE}"/>
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="${MAX_FILE_NUM}"/>
         </RollingFile>

        <!-- warn日志文件输出日志信息 -->
        <RollingFile name="Warn_File" fileName="${ERROR_FILE_PATH_ING}" filePattern="${ERROR_FILE_PATH_ED}">
            <ThresholdFilter level="WARN" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <SizeBasedTriggeringPolicy size="${MAX_FILE_SIZE}"/>
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="${MAX_FILE_NUM}"/>
        </RollingFile>
        <!-- error日志文件输出日志信息 -->
        <RollingFile name="Error_File" fileName="${ERROR_FILE_PATH_ING}" filePattern="${ERROR_FILE_PATH_ED}">
            <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <SizeBasedTriggeringPolicy size="${MAX_FILE_SIZE}"/>
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="${MAX_FILE_NUM}"/>
        </RollingFile>
    </appenders>
    <!--配置总的日志监听级别-->
    <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效-->
    <loggers>
        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.springframework" level="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>
        <root level="info">
            <appender-ref ref="Filelog"/>
            <appender-ref ref="Console_Log"/>
            <appender-ref ref="Debug_File"/>
            <appender-ref ref="Info_File"/>
            <appender-ref ref="Error_File"/>
        </root>
    </loggers>
</Configuration>

2.3.区分不同环境设置

#在application.yml中指定想要的log4j文件
logging:
  config: classpath:log4j2-dev.xml

2.4 pom配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <!-- 20210714去掉logback配置 -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
                <!-- 20210714去掉logback配置 end -->
                <exclusion>
                    <artifactId>logback-classic</artifactId>
                    <groupId>ch.qos.logback</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- log4j2依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.5.java代码用法


1.直接slf4j2门面工厂获取日志
package com.example.demo;

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DemoApplicationTests {
    Logger logger = LoggerFactory.getLogger(getClass());
    /**
     * 测试日志输出
     */
    @Test
    void logTest() {
        //日志级别 由低到高
        logger.trace("trace 级别日志");
        logger.debug("debug 级别日志");
        logger.info("info 级别日志");
        logger.warn("warn 级别日志");
        logger.error("error 级别日志");

    }
}

2.注解方式
package com.example.demo;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@Slf4j
class DemoApplicationTests {
//    Logger logger = LoggerFactory.getLogger(getClass());
    /**
     * 测试日志输出
     */
    @Test
    void logTest() {
        //日志级别 由低到高
        log.trace("trace 级别日志");
        log.debug("debug 级别日志");
        log.info("info 级别日志");
        log.warn("warn 级别日志");
        log.error("error 级别日志");

    }
}
       

3.集成log4j

3.1 pom引入

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <!-- 20210714去掉logback配置 -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
                <!-- 20210714去掉logback配置 end -->
                <exclusion>
                    <artifactId>logback-classic</artifactId>
                    <groupId>ch.qos.logback</groupId>
                </exclusion>
            </exclusions>
        </dependency>
 
        <!-- log4j依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.2.log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<!--
xmlns:log4j [#FIXED attribute] : 定义log4j的名字空间,取定值"http://jakarta.apache.org/log4j/"
-->
<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/' >
     <!-- appender [* child] : 一个appender子元素定义一个日志输出目的地
             name [#REQUIRED attribute] : 定义appender的名字,以便被后文引用
             class [#REQUIRED attribute] : 定义appender对象所属的类的全名
                             org.apache.log4j.RollingFileAppender(滚动文件,自动记录最新日志)
                             org.apache.log4j.ConsoleAppender (控制台)
                             org.apache.log4j.FileAppender (文件)
                             org.apache.log4j.DailyRollingFileAppender (天天产生一个日志文件)
                             org.apache.log4j.WriterAppender (将日志信息以流格式发送到任意指定的地方)
             layout [? child] : 该appender使用的layout对象
             param [* child] : 建立appender对象时传递给类构造方法的参数
     -->
    <appender name="myConsole" class="org.apache.log4j.ConsoleAppender">
        <!--
           class [#REQUIRED attribute] : 定义layout对象所属的类的全名
           param [* child] : 建立layout对象时传递给类构造方法的参数
            -->
        <layout class="org.apache.log4j.PatternLayout">
        <!--
             %c    输出所属类的全名,可在修改成 %d{Num} ,Num类名输出的维(如:"org.apache.elathen.ClassName",%C{2}将输出elathen.ClassName)
             %d    输出日志时间其格式为 %d{yyyy-MM-dd HH:mm:ss,SSS},可指定格式 如 %d{HH:mm:ss}
             %l    输出日志事件发生位置,包括类目名、发生线程,在代码中的行数
             %n    换行符
             %m    输出代码指定信息,如info(“message”),输出message
             %p    输出优先级,即 FATAL ,ERROR 等
             %r    输出从启动到显示该log信息所耗费的毫秒数
             %t    输出产生该日志事件的线程名
        -->
            <param name="ConversionPattern" value="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%p] - %m - %l%n" />
        </layout>

        <!--过滤器设置输出的级别-->
        <filter class="org.apache.log4j.varia.LevelRangeFilter">
            <param name="levelMin" value="debug" />
            <param name="levelMax" value="error" />
            <param name="AcceptOnMatch" value="true" />
        </filter>
    </appender>


    <appender name="myFile" class="org.apache.log4j.RollingFileAppender">
        <param name="File" value="/app/log/output.log" /><!-- 设置日志输出文件名 -->
        <!-- 设置是否在从新启动服务时,在原有日志的基础添加新日志 -->
        <param name="Append" value="true" />
        <param name="MaxBackupIndex" value="10" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%p (%c:%L)- %m%n" />
        </layout>
    </appender>


    <appender name="activexAppender" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="File" value="/app/log/activex.log" />
        <param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%p] - %m - %l%n" />
        </layout>
    </appender>


    <!-- 指定logger的设置,additivity指示是否遵循缺省的继承机制
       logger元素定义一个日志输出器。
            name [#REQUIRED attribute] : 定义logger的名字,以便被后文引用
            additivity [#ENUM attribute] : 取值为"true"(默认)或者"false",是否继承父logger的属性
            level [? child] : 定义该logger的日志级别
            appender-ref [* child] : 定义该logger的输出目的地

    -->
    <logger name="com.example.demo" additivity="false">
        <level value ="error"/>
        <appender-ref ref="myConsole" />
    </logger>

    <!-- 根logger的设置-->
    <root>
   <!--
    记录的优先级priority,优先级由高到低分为
             OFF ,FATAL ,ERROR ,WARN ,INFO ,DEBUG ,ALL。
             Log4j建议只使用FATAL ,ERROR ,WARN ,INFO ,DEBUG这五个级别。
     -->
        <priority value ="info"/>
        <appender-ref ref="myConsole"/>
        <appender-ref ref="myFile"/>
    </root>

</log4j:configuration>

3.3.java代码同上2.5

 类似资料: