java日志框架JUL、JCL、Slf4j、Log4j、Log4j2、Logback 一网打尽

x33g5p2x  于2021-12-20 转载在 Java  
字(27.8k)|赞(0)|评价(0)|浏览(405)

为什么程序需要记录日志

我们不可能实时的24小时对系统进行人工监控,那么如果程序出现异常错误时要如何排查呢?并且系统在运行时做了哪些事情我们又从何得知呢?这个时候日志这个概念就出现了,日志的出现对系统监控和异常分析起着至关重要的作用;

就拿java来说,在早期的日志都是通过System.out.println()进行记录的,但是这种方式不便于管理,所以apache最先开发了首个日志框架:log4j; 为日志框架奠定了基础;

日志框架出现的历史顺序为 : log4j → JUL → JCL → SLF4J → logback → log4j2

java日志框架分类

日志实现

  1. JUL(java.util.logging):java自带的日志框架,适合小型项目
  2. logback:目前比较火的框架,spring2.0默认使用logback日志
  3. log4j:老牌日志框架,apache 旗下
  4. log4j2:log4j升级版,目前最好的日志实现技术

日志门面接口

  1. JCL(jakarta commons Logging):apache旗下
  2. slf4j (simple logging facade for java):目前比较火的

JUL java.util.logging)-- java自带的日志框架

JUL日志级别

JUL一共有7个日志级别,用法如下:

logger.(Level.INFO,"info");
  1. Level.SEVERE:最高级别的日志,主要记录错误信息
  2. Level.WARNING:级别排行第二,记录警告信息
  3. Level.INFO:级别排行第三,最常用的日志级别,记录普通消息,比如请求信息、连接信息、参数信息等等
  4. Level.CONFIG:级别排行第四,记录配置信息,加载配置文件、读取配置参数都可以使用CONFIG记录
  5. Level.FINE :debug 时记录的 日志消息,记录运行时的状态、传递的参数等等
  6. Level.FINER:debug 时记录的 日志消息,记录运行时的状态、传递的参数等等
  7. Level.FINEST:debug 时记录的 日志消息,记录运行时的状态、传递的参数等等
  8. Level.ALL:所有记录都开启
  9. Level.OFF: 关闭日志记录

其中,FINEFINERFINEST都是记录debug信息的,三者取其一即可;

JUL原理

  1. Logger是用来记录日志的,
  2. LogRecord是用来传递日志的,
  3. Handler是用来导出(处理)日志的,
  4. Level是用来定义日志级别的(控制日志输出),
  5. Filter提供了日志级别之外更细粒度的控制,
  6. Formatter是用来格式化LogRecord的,
  7. 此外还有一个单一的全局的LogManager维护Logger和管理日志。JUL主要由这七个核心类或接口组成,再有就是一些子类或者实现类。API中关于这几个类或接口的类和方法的详细介绍这里不再复述。现在我们已经对JUL有了一个整体的了解,并且对核心类或接口的功能职责也有了初步了解,接下就该结合代码看看JUL的真面目。

JUL配置文件详解

新建一个文件名为:logging.properties,内容如下,以下配置可以同时输出到控制台和文件中

#为顶级父元素RootLogger指定默认的处理器:ConsoleHandler,即若是你没有自定义Logger,就用这个Logger
handlers=java.util.logging.ConsoleHandler
#顶级父元素默认的日志级别为INFO,即此Logger的日志级别是INFO
.level=INFO 
#自定义Logger,即该Logger的name为com.yexindong,调用时这样即可 Logger logger = Logger.getLogger("com.yexindong");
#指定了自定义Logger的handlers,ConsoleHandler是输出到控制台,FileHandler是输出到文件中,两个都指定就可以同时输出;
com.yexindong.handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler
#指定了自定义Logger的日志级别
com.yexindong.level=INFO
#关闭默认配置
com.yexindong.useParentHandlers=false

#*******************向文件输出的handler对象 start*******************
#指定日志文件输出的路径
java.util.logging.FileHandler.pattern=D:\\ying.log
#指定文件内容的大小(单位:字节(b))
java.util.logging.FileHandler.limit=50000
#指定日志文件的个数
java.util.logging.FileHandler.count=10
#指定日志文件的格式,
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
#指定以追加的方式添加日志内容
java.util.logging.FileHandler.append=true
#*******************向文件输出的handler对象 end*******************

#*******************向控制台输出的handler对象 start*****************
#指定日志级别 ,尽量和自定义的级别相同,否则会有些日志无法打印处理
java.util.logging.ConsoleHandler.level=INFO
#指定日志的格式
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
#指定日志的编码
java.util.logging.ConsoleHandler.encoding=UTF-8
#*******************向控制台输出的handler对象 end*****************
#指定日志消息的格式
java.util.logging.SimpleFormatter.format=%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n

log4j

log4j 很重要的一个缺陷是不支持占位符,但是用户可自己定义实现占位符的功能,

log4j日志级别

log4j的默认日志级别 是debug;

  1. logger.fatal(info):记录严重的错误信息,一般会造成系统崩溃并终止运行
  2. logger.error(info):记录错误信息,不会影响系统运行
  3. logger.warn(info):记录警告信息
  4. logger.info(info):记录运行信息,
  5. logger.debug(info):(默认)记录调式信息,一般在开发中使用
  6. logger.trace(info):记录追踪信息,记录程序的流程信息;

Appenders

Appenders ·是用来指定将日志输出到哪个地方,可以同时指定日志的输出目的地,log4j常用的Appenders有以下几种

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

layouts

布局器,用于控制日志输出的格式,让我么可以自定义日志格式,log4j常用的layouts有以下几种

格式化器作用
HTMLLayout格式化日志为html表格形式
XMLLayout格式化日志为xml文档形式
SimpleLayout(默认)简单的日志输出格式化,打印的日志格式为(info - message)
PatternLayout最强大的格式化器,可以根据自定义格式输出日志,如果没有指定转换格式,默认的格式只显示消息内容;
PatternLayout 格式语法
参数说明举例
%m输出代码中指定的日志信息logger.info(日志信息)
%p输出日志级别INFO、DEBUG、ERROR %-8p 表示占用8个字符,若字符不够用空格代替
%n换行符必须在结尾加上换行符,否则日志将杂乱不堪
%r输出从应用启动到输出该log信息耗费的毫秒数(log打印时间 - 应用启动时间)
%c输出打印语句所属的类全名%c :com.xd.App %c{1}:App
%C列出调用logger的类的全名(包含包路径)%C :com.xd.App %C{1}:App
%t输出产生该日志所在的线程名名称main 、thread-0、thread-1
%d输出服务器当前时间,精确到豪秒,自定义格式 1、%d :2021-12-16 16:05:07,201 2、 %d{yyyy-MM-dd HH:mm:ss} :2021-12-16 16:05:07
%l输出日志发生的位置,包含包名、类名、方法名、所在的代码行树com.log.App.haveConfigFile(App.java:25)
%L输出代码中的行号12
%F显示调用logger的类的文件名App.class
%%输出一个百分号 %%

log4j2

apache log4j2是对log4j的升级班,参考了logback的一些优秀设计,并且修复了logback体系中的一些问题,因此带来了一些重大的提升,主要有以下几点

  1. 异常处理,在logback中,appender中的异常不会被应用感知到,但是log4j2中,提供了一些异常处理机制
  2. 性能提升,log2j 比log4j和logback都具有明显的性能提升,官方数据是提升了18倍
  3. 自动重载配置,参考了logback的设计,提供了自动刷新参数的配置,在生产上可以动态修改日志级别,而不需要重启应用;
  4. 无垃圾机制,(默认开启)log4j2在大部分情况下, 都可以使用无垃圾机制,避免频繁的日志收集导致触发jvm的垃圾回收机制;

log4j2 异步日志原理

  1. 应用程序的主线程调用打印记录日志的方法后,传递到logEvent对象
  2. event将对象加入到一个阻塞队列(ArrayBlockingQueue)中
  3. 此时,主线程的工作就已经完成了,其余工作交给log异步线程就可以了
  4. 阻塞队列(ArrayBlockingQueue)收到日志消息后,立马将消息发给appender对象
  5. appender收到消息后开始打输出消息;

搭建 log4j2门面 + log4j2实现

添加依赖

<!-- log4j门面-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.15.0</version>
</dependency>
<!-- log4j2依赖-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.15.0</version>
</dependency>

java代码

package com;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
//使用log4j作为门面
public class Log4j2App {
    public static void main(String[] args) {
        Logger logger = LogManager.getLogger(Log4j2App.class);
        logger.fatal("max error");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
        
    }
}

配置文件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="30">

    <properties>
        <!-- 配置全局变量,使用时通过:${name} 获取-->
        <property name="LOG_PATH">D:\\log\\</property>
        <property name="pattern_format">[%d{HH:mm:ss:SSS}] [%-5p] - %l -- %m%n</property>
    </properties>
    <!--先定义所有的appender-->
    <appenders>
        <!--控制台的输出配置-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${pattern_format}"/>
        </console>

        <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用-->
        <File name="log" fileName="${LOG_PATH}/log4j2_all.log" append="false">
            <PatternLayout pattern="${pattern_format}"/>
        </File>
        <!-- RandomAccessFile 使用随机读写流输出日志到文件,性能较高 -->
        <RandomAccessFile name="file" fileName="${LOG_PATH}/randomAccessFile.log">
            <PatternLayout pattern="${pattern_format}"/>
        </RandomAccessFile>
        <!-- RollingFile 按照一定的规则进行拆分文件-->
        <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size,则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${LOG_PATH}/info_low.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch)-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <!-- 系统启动或重启时就触发拆分规则,生成一个新的日志文件-->
                <OnStartupTriggeringPolicy/>
                <!-- 按照时间的节点进行拆分 ,根据filePattern定义的规则拆分-->
                <TimeBasedTriggeringPolicy/>
                <!-- 按文件大小进行拆分-->
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
            <!-- 在同一目录下,日志文件的个数限定为30个,超过30个则会覆盖,这个配置可以有效防止日志文件过大导致磁盘空间不足; -->
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
        <!-- 只打印 info级别的信息-->
        <RollingFile name="RollingFileInfo" fileName="${LOG_PATH}/info.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出 info 级别的信息-->
            <filters>
                <!-- onMismatch="NEUTRAL" 表示该级别及以下的,由下一个filter处理,如果当前是最后一个,则不匹配该级别以下的 onMatch="DENY" 表示不匹配该级别及以上 -->
                <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
                <!-- onMatch="ACCEPT" 表示匹配该级别及以上 onMismatch="DENY" 表示不匹配该级别以下的 -->
                <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            </filters>

            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
        </RollingFile>
        <!-- 只打印warn级别的信息,并自动存档-->
        <RollingFile name="RollingFileWarn" fileName="${LOG_PATH}/warn.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <!-- 只打印warn级别的日志-->
            <filters>
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
                <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            </filters>
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件,这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>
        <!-- 打印error级别以上的信息-->
        <RollingFile name="RollingFileError" fileName="${LOG_PATH}/error.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <!-- 只打印error级别的日志-->
            <filters>
                <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            </filters>
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
        </RollingFile>

<!-- 每天进行归档,自动压缩日志文件 -->
        <RollingRandomAccessFile name="applicationAppender" fileName="${LOG_PATH}/rollingRandomAccessFile.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/common-%d{yyyy-MM-dd}.log.gz" append="true">
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
            </Policies>
        </RollingRandomAccessFile>
    </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="all">
            <!-- appender引用-->
            <appender-ref ref="Console"/>
            <appender-ref ref="log"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

运行上面的java代码,打印的日志如下

[21:10:17:717] [FATAL] - com.Log4j2App.main(Log4j2App.java:15) -- max error
[21:10:17:717] [ERROR] - com.Log4j2App.main(Log4j2App.java:16) -- error
[21:10:17:717] [WARN ] - com.Log4j2App.main(Log4j2App.java:17) -- warn
[21:10:17:717] [INFO ] - com.Log4j2App.main(Log4j2App.java:18) -- info
[21:10:17:717] [DEBUG] - com.Log4j2App.main(Log4j2App.java:19) -- debug
[21:10:17:717] [TRACE] - com.Log4j2App.main(Log4j2App.java:20) -- trace

搭建slf4j门面 + log4j2 实现

加入pom依赖

<!-- slf4j门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
<!-- slf4j与log4j2的桥接包:log4j-slf4j-impl-2.9.0.jar,这个包的作用就是使用slf4j的api,但是底层实现是基于log4j2.-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.9.0</version>
        </dependency>

        <!-- log4j门面 ,这个也是需要的-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.15.0</version>
        </dependency>
        <!-- log4j2依赖-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.15.0</version>
        </dependency>
        <!-- log4j2异步日志依赖 ,不用异步功能的话,这个包可以不要-->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.4</version>
        </dependency>

java代码

package com;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/** * 使用Slf4j作为门面 */
public class Log4j2_Slf4j_App {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(Log4j2_Slf4j_App.class);
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
    }
}

配置文件还是使用原来 log4j2.xml 即可,

执行代码后打印结果如下

[11:20:56:866] [ERROR] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:15) -- error
[11:20:56:866] [WARN ] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:16) -- warn
[11:20:56:866] [INFO ] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:17) -- info
[11:20:56:867] [DEBUG] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:18) -- debug
[11:20:56:867] [TRACE] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:19) -- trace

异步日志

异步分为全局异步和混合异步2种方式

  • 全局异步:所有日志都异步记录
  • 混合异步:在应用种同时使用同步日志和异步日志,这样的日志配置更加灵活

添加maven依赖

<!-- log4j2异步日志依赖-->
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.3.4</version>
</dependency>
全局异步
  1. 全局启用异步Logger方案一 :JVM启动参数加上-DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
  2. 全局启用异步Logger方案二:classpath中添加文件log4j2.component.properties,文件增加以下内容:
Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
混合异步

log4j2提供2种异步日志的实现方式

  • AsyncAppender :性能提升较小
  • AsyncLogger:性能提升较大,推荐使用

AsyncAppender配置方式

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
  <appender name="xindong_file" class="ch.qos.logback.core.FileAppender">
    <file>myapp.log</file>
    <encoder>
      <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%level] [%thread] [%logger{50}] >>> %msg%n</pattern>
    </encoder>
  </appender>
 
  <appender name="xindong_async" class="ch.qos.logback.classic.AsyncAppender">
    <appender-ref ref="xindong_file" />
  </appender>
 
  <root level="DEBUG">
    <appender-ref ref="xindong_async" />
  </root>
</configuration>

AsyncLogger配置方式

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" monitorInterval="30">
    <Appenders>
        <RollingRandomAccessFile name="applicationAppender" fileName="./log/application.log" filePattern="./log/$${date:yyyy-MM}/common-%d{yyyy-MM-dd}.log.gz" append="false">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
            </Policies>
        </RollingRandomAccessFile>

        <Console name="CONSOLE" target="SYSTEM_OUT">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%p] %t - %l - %m%n"/>
        </Console>

    </Appenders>

    <Loggers>
        <!-- AsyncLogger配置 -->
        <AsyncLogger name="log4j2" >
            <AppenderRef ref="applicationAppender"/>
        </AsyncLogger>

        <Root level="info">
            <!--<AppenderRef ref="CONSOLE"/>-->
            <AppenderRef ref="applicationAppender"/>
        </Root>

        <!--<Logger name="log4j2" level="debug" additivity="false" >-->
            <!--<AppenderRef ref="CONSOLE"/>-->
            <!--<AppenderRef ref="applicationAppender"/>-->
        <!--</Logger>-->

    </Loggers>
</Configuration>

logback

logback是由log4j的创始人设计的另一个开源日志组件,性能比log4j更好;
logback主要分为三个模块

  1. logback-core:其他2个模块的基础模块,也是最核心的模块
  2. logback-classic:它是log4j的一个改良版本,同时它完整实现了slf4j API
  3. logback-access:访问模块与servlet容器集成通过http来访问日志的功能;
logback默认日志级别

logback的默认日志级别是debug;

logback配置文件

logback 支持以下几种方式的配置文件,如果以下文件都不存在的话则会采用默认的配置文件;

  • logback.groovy
  • logback-test.xml
  • logback.xml

logback使用

先导入maven依赖,这里使用slf4j来管理logback

<!-- 使用日志门面管理logback-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

java代码

package com.log;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LogbackApp {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(LogbackApp.class);
        logger.error("error");
        logger.info("123445");
        logger.debug("debug");
        logger.trace("trace");
        
    }
}

logback的配置文件,这里的配置比较全,童鞋们按需配置即可

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>

    <!-- 配置变量,和 maven 的 properties标签的功能医院-->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss} [%t] [%-5level] %c %M %L %m %n"></property>
    <property name="html_pattern" value="%d{yyyy-MM-dd HH:mm:ss}%t%-5level%c%M%L%m%n"></property>

    <!-- 输出到控制台-->
    <appender name="yexindong_console_appender" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 控制输出流对象,默认为System.out(黑色字体) ,System.err 是红色字体 -->
        <!-- <target>System.err</target>-->
        <!-- 输出的日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!-- 日志输出格式 %-5level : 日志级别,占用5个字符的位置 %d{yyyy-MM-dd HH:mm:ss,SSS} :日期并指定格式 %c :类的完整名称 %M : 方法名称 %L : 代码所在行号 %t : 调用logger打印方法的thread线程名称 %m : 打印的日志内容 %n : 换行 -->
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!-- 输出到文件-->
    <!-- <appender name="yexindong_file_appender" class="ch.qos.logback.core.FileAppender">-->
            <!-- 日志文件保存路径-->
    <!-- <file>D:\\log\\logback.log</file>-->
            <!-- 输出的日志消息格式配置-->
    <!-- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
    <!-- <pattern>${pattern}</pattern>-->
    <!-- </encoder>-->
    <!-- </appender>-->

    <!-- 输出到html格式的日志文件-->
    <!-- <appender name="yexindong_html_appender" class="ch.qos.logback.core.FileAppender">-->
            <!-- 日志文件保存路径-->
    <!-- <file>D:\\log\\logback_html.html</file>-->
            <!-- html 消息格式配置-->
    <!-- <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">-->
    <!-- <layout class="ch.qos.logback.classic.html.HTMLLayout">-->
    <!-- <pattern>${html_pattern}</pattern>-->
    <!-- </layout>-->
    <!-- </encoder>-->
    <!-- </appender>-->

    <!-- 日志拆分、自动归档压缩-->
    <appender name="yexindong_roll_file_appender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件保存路径-->
        <file>D:\\log\\logback_rolling.log</file>
        <!-- 输出的日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!-- 指定文件拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 按照时间为节点进行拆分,自动压缩的文件名称-->
            <fileNamePattern>D:\\log\\logback_rolling.%d{yyyy-MM-dd HH_mm_ss}.log%i.gz</fileNamePattern>
            <!-- 按照文件大小进行拆分,当文件大小达到1MB时就会将日志进行压缩 -->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!-- 日志级别过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置日志级别,-->
            <level>ERROR</level>
            <!-- 超过这个级别的日志才会打印-->
            <onMatch>ACCEPT</onMatch>
            <!-- 小于这个级别的日志不会打印-->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 异步日志,因为之前每次打印日志都是在主线程进行输出的,这样对响应速度会有所影响,配置成异步日志会提升响应速度-->
    <appender name="yexindong_async_appender" class="ch.qos.logback.classic.AsyncAppender">
        <!-- 这里将自动归档的appender设为异步的-->
        <appender-ref ref="yexindong_roll_file_appender"></appender-ref>
    </appender>

    <!--根logger配置-->
    <root level="All">
        <!-- appender引用-->
        <appender-ref ref="yexindong_console_appender"></appender-ref>
        <!-- <appender-ref ref="yexindong_file_appender"></appender-ref>-->
        <!-- <appender-ref ref="yexindong_html_appender"></appender-ref>-->
        <appender-ref ref="yexindong_async_appender"></appender-ref>
    </root>
    <!-- 自定义logger对象 name="com" : 这里是com是包名,表示com包下所有子包的类都使用自定义logger level="info" :自定义logger的日志级别 additivity="false" :表示自定义的logger对象是否继承 rootLogger(根logger) -->
    <logger name="com" level="all" additivity="false">
        <appender-ref ref="yexindong_console_appender"></appender-ref>
    </logger>

</configuration>

运行后即可看到打印的日志内容

2021-12-17 19:55:38 [main] [ERROR] com.log.LogbackApp main 13 error 
2021-12-17 19:55:38 [main] [INFO ] com.log.LogbackApp main 14 123445 
2021-12-17 19:55:38 [main] [DEBUG] com.log.LogbackApp main 15 debug 
2021-12-17 19:55:38 [main] [TRACE] com.log.LogbackApp main 16 trace

日志门面技术

什么是日志门面技术

日志门面技术借鉴了 JDBC 的思想,为日志系统也提供了一套门面,开发者就可以面向这些接口规范来开发,避免了直接依赖具体日志框架,因为不同的日志框架有不同的用法,所以导致在更换日志框架时就需要改动大量的代码,所以为了减少开发量,就有了日志门面技术,门面技术简单地理解就是说你的日志框架变了,但是不需要改代码,只修改依赖和配置文件即可,提高了开发效率;

目前主流的日志门面技术有2种

  • JCL
  • SLF4J

因为JCL支持的日志技术比较少,只支持目前比较主流的日志框架,且不支持扩展,需要扩展其他的日志实现技术的话需要用户自己修改源代码,但是随着技术的发展,以后肯定会发展出更多更好的日志框架,但是jcl却不支持这些新出的框架,因此jcl在在2014年就已经被 apache 给淘汰了,目前使用最广泛的是slf4j;

为什么要用门面技术?
  1. 面向接口开发,不在依赖具体的实现类,减少代码的耦合
  2. 项目通过导入不同的日志实现类,可以灵活的切换日志框架
  3. 统一API,方便开发者学习和使用
  4. 统一配置便于项目日志的管理

日志门面技术 - JCL

日志实现优先级排列

jcl门面技术在获取log实现时会按照以下顺序依次获取logger的实现,我们可以看到它是优先使用log4j的,如果找到了log4j的实现,就不会在往下找其他实现了

  1. log4j : 优先使用log4j
  2. jdk14Logger:jdk自带logger
  3. jdk13LumberjackLogger :也是jdk自带logger
  4. SimpleLog : jcl自带的日志框架,功能比较简单
JCL使用
  1. 先添加apache门面的pom依赖
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>
  1. 打印日志
package com.log;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class App {
    public static void main(String[] args) {
        Log log = LogFactory.getLog(App.class);
        // jcl优先使用 log4j 日志,如果未添加log4j依赖,默认会使用java自带的日志框架:java.util.logging
        log.info("hello world");
    }
}
  1. 打印结果如下,发现默认情况下使用的是jdk自带的日志框架
十二月 17, 2021 11:34:22 上午 com.log.App main
信息: hello world
  1. 接下来我们加上 log4j的依赖
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
  1. 再加上log4j的配置文件 log4j.properties,放在resources目录下
# 配置log4j的顶级父元素,指定日志级别为 trace,使用appender为yexindong, 这个yexindong  是用户自定义的
log4j.rootLogger=trace,yexindong
# ***********************输出到控制台 start****************
# 指定控制台日志输出的 appender
log4j.appender.yexindong=org.apache.log4j.ConsoleAppender
# 指定消息layout布局器
log4j.appender.yexindong.layout=org.apache.log4j.PatternLayout
# 指定消息输出格式
log4j.appender.yexindong.layout.conversionPattern=%t %d [%t] %-5p %l -- %m %n
  1. 其他代码不变,再次运行main方法后打印结果如下 ,会发现自动使用了log4j进行输出日志;
main 2021-12-17 11:36:06,642 [main] INFO  com.log.App.main(App.java:17) -- hello world

日志门面技术 - SLF4J

SLF4J的由来

在log4j开发出来出来之后,log4j就受到了广大开发者的爱好,纷纷开始使用log4j,但是后来 log4j的创始人跟apache因为一些矛盾从apache辞职自己去创业了,创始人为了给自己的公司打出一点名声,所以就基于log4j又开发出了一个新的日志框架 logback,logback不管是性能还是功能都比log4j强,但是却很少人使用, 因为jcl门面不支持logback,所以这个创世人又设计出了slf4j,slf4j支持市面上所有主流的日志框架;所以目前为止,使用最多的就是slf4j了; 后来 apache又基于 logback 的源码 设计出了 log4j2 日志,性能上log4j2比logback更胜一筹,并且log4j2既是日志框架,也是门面技术,但是log4j2的门面技术很少人使用,大多还是使用slf4j;

注意事项

=maven依赖中,尽量保证只有一个日志实现,如果由多个日志实现的话默认使用第一个(maven依赖靠前的那个),并且在控制台会显示以下警告信息

# 提示有多个日志实现
SLF4J: Class path contains multiple SLF4J bindings.
# 第一个日志实现
SLF4J: Found binding in [jar:file:/D:/repository/org/slf4j/slf4j-simple/1.7.25/ slf4j-simple-1.7.25.jar!/org/slf4j/impl/StaticLoggerBin
# 第二个日志实现
SLF4J: Found binding in [jar:file:/D:/repository/org/slf4j/slf4j-log4j12/1.7.12/slf4j-log4j12-1.7.12.jar!/org/slf4j/impl/StaticLoggerBinder.class]
# 默认绑定第一个
SLF4J: Actual binding is of type [org.slf4j.impl.SimpleLoggerFactory]
准备java打印日志代码

首先加入slf4j的依赖

<!-- 日志门面依赖-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

log打印代码如下

package com.log;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class App {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(App.class);
        logger.error("12322");
        logger.warn("warn");
        logger.info("info {}", "yexindong");
        logger.debug("debug");
        logger.trace("trace");
    }
}

此时还不会打印内容,因为目前只有接口,还没有具体的实现

1、slf4j绑定默认日志

slf4j-simple是slf4j内置的简单日志实现框架,功能比较简单;

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

运行上述java代码后,控制台打印的结果如下

[main] ERROR com.log.App - 12322
[main] WARN com.log.App - warn
[main] INFO com.log.App - info yexindong
2、绑定 java自带日志框架 jul
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>1.7.25</version>
</dependency>

运行上述java代码后,控制台打印的结果如下

十二月 17, 2021 5:03:58 下午 com.log.App main
严重: 12322
十二月 17, 2021 5:03:58 下午 com.log.App main
警告: warn
十二月 17, 2021 5:03:58 下午 com.log.App main
信息: info yexindong
3、绑定log4j日志框架

其中 slf4j-log4j12 是适配器,必须要一个适配器,否则log4j不生效

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

除此之外,还需要加上log4j的配置文件:log4j.properties

# 配置log4j的顶级父元素,指定日志级别为 trace,使用appender为yexindong, 这个yexindong  是用户自定义的
log4j.rootLogger=trace,yexindong
# ***********************输出到控制台 start****************
# 指定控制台日志输出的 appender
log4j.appender.yexindong=org.apache.log4j.ConsoleAppender
# 指定消息layout布局器
log4j.appender.yexindong.layout=org.apache.log4j.PatternLayout
# 指定消息输出格式
log4j.appender.yexindong.layout.conversionPattern=%t %d [%t] %-5p %l -- %m %n
# ***********************输出到控制台 end****************

运行上述java代码后,控制台打印的结果如下

main 2021-12-17 17:22:03,345 [main] ERROR com.log.App.main(App.java:11) -- 12322 
main 2021-12-17 17:22:03,350 [main] WARN  com.log.App.main(App.java:12) -- warn 
main 2021-12-17 17:22:03,351 [main] INFO  com.log.App.main(App.java:13) -- info yexindong 
main 2021-12-17 17:22:03,351 [main] DEBUG com.log.App.main(App.java:14) -- debug 
main 2021-12-17 17:22:03,351 [main] TRACE com.log.App.main(App.java:15) -- trace
4、绑定logback日志框架
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.2.3</version>
</dependency>

运行上述java代码后,控制台打印的结果如下

17:14:23.500 [main] ERROR com.log.App - 12322
17:14:23.508 [main] WARN com.log.App - warn
17:14:23.508 [main] INFO com.log.App - info yexindong
17:14:23.510 [main] DEBUG com.log.App - debug

slf4j 日志桥接器

使用场景

老项目使用的日志框架是log4j,现在想要使用logback, 但是一大堆的java文件中都有log4j的导入

import org.apache.log4j.Logger;

因为使用了logback,就一定要将log4j相关的maven依赖删除,依赖删除后,这个import导入就一定会报错,一个个去改把,太麻烦了,搞不好改错了,更麻烦,于是就有了 日志桥接器,只需要加上桥接器的maven依赖即可,代码一行都不需要改,依赖如下

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

加上这个依赖后,虽然import上是log4j,但是底层调用的其实是logback的日志实现;

注意问题
  1. log4j-over-slf4j 和 slf4j-jcl.jar 不能同时部署,否则会导致无限循环
  2. log4j-over-slf4j桥接器 和 slf4j-log4j 适配器不能同时出现
  3. jul-to-slf4j.jar 和 slf4j-jdk14.jar 不能同时出现
  4. 所有的桥接器都只对Logger日志记录器对象有效,如果程序中调用了内部的配置类或者是Appender、Filter等对象,将无法产生效果;

相关文章