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

多云666

已于 2022-04-02 16:31:44 修改

阅读量815

点赞数 1

文章标签： java spring maven spring boot

于 2022-04-02 15:29:41 首次发布

本文链接：https://blog.csdn.net/weixin_44518592/article/details/123921193

版权

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

一、java常用日志框架
- 1.日志门面（日志接口）
- 2.日志门面的实现
二、springboot 集成日志

一、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.日志门面的实现

Log4j

Log4j是Apache的一个Java的日志库，通过使用Log4j，我们可以控制日志信息输送的目的地（控制台、文件、数据库等）；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
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 成为主流。
Log4j2

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

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

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

二、springboot 集成日志

1.默认实现 logback

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

1.1日志级别

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

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

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

1.2输出格式

序号	输出格式	说明
1	%d{yyyy-MM-dd HH:mm:ss, SSS}	日志生产时间,输出到毫秒的时间
2	%-5level	输出日志级别，-5 表示左对齐并且固定输出 5 个字符，如果不足在右边补 0
3	%logger 或 %c	logger 的名称
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	输出语句所在的行数, 包括类名、方法名、文件名、行数
13	hostName	本地机器名
14	hostAddress	本地 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.日志级别

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

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

多云666

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java常用日志框架日志门面及实现 SLF4J 、Jboss-logging 、JCL、Log4j、Logback、Log4j2、JUL，springboot集成 log4j、log4j2

一、java常用日志框架1.日志门面（日志接口）日志门面来解决系统与日志实现框架的耦合性。不是一个真正的日志实现，而是一个抽象层（ abstraction layer），它允许你在后台使用任意一个日志实现。在项目开发中，记录日志时不应该直接调用日志实现层的方法，而应该调用日志门面（日志抽象层）的方法。SLF4J（Simple Logging Facade for Java）简单日志门面(Simple Logging Facade For Java)
复制链接

扫一扫