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

发布时间:2022-01-16 09:26:29 作者:路人甲 阅读(408)

为什么程序需要记录日志

我们不可能实时的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个日志级别,用法如下:

  1. 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,内容如下,以下配置可以同时输出到控制台和文件中

  1. #为顶级父元素RootLogger指定默认的处理器:ConsoleHandler,即若是你没有自定义Logger,就用这个Logger
  2. handlers=java.util.logging.ConsoleHandler
  3. #顶级父元素默认的日志级别为INFO,即此Logger的日志级别是INFO
  4. .level=INFO
  5. #自定义Logger,即该Logger的name为com.yexindong,调用时这样即可 Logger logger = Logger.getLogger("com.yexindong");
  6. #指定了自定义Logger的handlers,ConsoleHandler是输出到控制台,FileHandler是输出到文件中,两个都指定就可以同时输出;
  7. com.yexindong.handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler
  8. #指定了自定义Logger的日志级别
  9. com.yexindong.level=INFO
  10. #关闭默认配置
  11. com.yexindong.useParentHandlers=false
  12. #*******************向文件输出的handler对象 start*******************
  13. #指定日志文件输出的路径
  14. java.util.logging.FileHandler.pattern=D:\\ying.log
  15. #指定文件内容的大小(单位:字节(b))
  16. java.util.logging.FileHandler.limit=50000
  17. #指定日志文件的个数
  18. java.util.logging.FileHandler.count=10
  19. #指定日志文件的格式,
  20. java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
  21. #指定以追加的方式添加日志内容
  22. java.util.logging.FileHandler.append=true
  23. #*******************向文件输出的handler对象 end*******************
  24. #*******************向控制台输出的handler对象 start*****************
  25. #指定日志级别 ,尽量和自定义的级别相同,否则会有些日志无法打印处理
  26. java.util.logging.ConsoleHandler.level=INFO
  27. #指定日志的格式
  28. java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
  29. #指定日志的编码
  30. java.util.logging.ConsoleHandler.encoding=UTF-8
  31. #*******************向控制台输出的handler对象 end*****************
  32. #指定日志消息的格式
  33. 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 <br> %-8p 表示占用8个字符,若字符不够用空格代替
%n 换行符 必须在结尾加上换行符,否则日志将杂乱不堪
%r 输出从应用启动到输出该log信息耗费的毫秒数 (log打印时间 - 应用启动时间)
%c 输出打印语句所属的类全名 %c :com.xd.App <br> %c{1}:App
%C 列出调用logger的类的全名(包含包路径) %C :com.xd.App <br>%C{1}:App
%t 输出产生该日志所在的线程名名称 main 、thread-0、thread-1
%d 输出服务器当前时间,精确到豪秒, 自定义格式 <br> 1、%d :2021-12-16 16:05:07,201 <br>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实现

添加依赖

  1. <!-- log4j门面-->
  2. <dependency>
  3. <groupId>org.apache.logging.log4j</groupId>
  4. <artifactId>log4j-api</artifactId>
  5. <version>2.15.0</version>
  6. </dependency>
  7. <!-- log4j2依赖-->
  8. <dependency>
  9. <groupId>org.apache.logging.log4j</groupId>
  10. <artifactId>log4j-core</artifactId>
  11. <version>2.15.0</version>
  12. </dependency>

java代码

  1. package com;
  2. import org.apache.logging.log4j.LogManager;
  3. import org.apache.logging.log4j.Logger;
  4. //使用log4j作为门面
  5. public class Log4j2App {
  6. public static void main(String[] args) {
  7. Logger logger = LogManager.getLogger(Log4j2App.class);
  8. logger.fatal("max error");
  9. logger.error("error");
  10. logger.warn("warn");
  11. logger.info("info");
  12. logger.debug("debug");
  13. logger.trace("trace");
  14. }
  15. }

配置文件log4j2.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
  3. <!--Configuration后面的status,这个用于设置log4j2自身内部的信息输出,可以不设置,当设置成trace时,你会看到log4j2内部各种详细输出-->
  4. <!--monitorInterval:Log4j能够自动检测修改配置 文件和重新配置本身,设置间隔秒数-->
  5. <configuration status="WARN" monitorInterval="30">
  6. <properties>
  7. <!-- 配置全局变量,使用时通过:${name} 获取-->
  8. <property name="LOG_PATH">D:\\log\\</property>
  9. <property name="pattern_format">[%d{HH:mm:ss:SSS}] [%-5p] - %l -- %m%n</property>
  10. </properties>
  11. <!--先定义所有的appender-->
  12. <appenders>
  13. <!--控制台的输出配置-->
  14. <console name="Console" target="SYSTEM_OUT">
  15. <!--输出日志的格式-->
  16. <PatternLayout pattern="${pattern_format}"/>
  17. </console>
  18. <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用-->
  19. <File name="log" fileName="${LOG_PATH}/log4j2_all.log" append="false">
  20. <PatternLayout pattern="${pattern_format}"/>
  21. </File>
  22. <!-- RandomAccessFile 使用随机读写流输出日志到文件,性能较高 -->
  23. <RandomAccessFile name="file" fileName="${LOG_PATH}/randomAccessFile.log">
  24. <PatternLayout pattern="${pattern_format}"/>
  25. </RandomAccessFile>
  26. <!-- RollingFile 按照一定的规则进行拆分文件-->
  27. <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size,则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档-->
  28. <RollingFile name="RollingFileInfo" fileName="${LOG_PATH}/info_low.log"
  29. filePattern="${LOG_PATH}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
  30. <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch)-->
  31. <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
  32. <PatternLayout pattern="${pattern_format}"/>
  33. <Policies>
  34. <!-- 系统启动或重启时就触发拆分规则,生成一个新的日志文件-->
  35. <OnStartupTriggeringPolicy/>
  36. <!-- 按照时间的节点进行拆分 ,根据filePattern定义的规则拆分-->
  37. <TimeBasedTriggeringPolicy/>
  38. <!-- 按文件大小进行拆分-->
  39. <SizeBasedTriggeringPolicy size="100 KB"/>
  40. </Policies>
  41. <!-- 在同一目录下,日志文件的个数限定为30个,超过30个则会覆盖,这个配置可以有效防止日志文件过大导致磁盘空间不足; -->
  42. <DefaultRolloverStrategy max="30"/>
  43. </RollingFile>
  44. <!-- 只打印 info级别的信息-->
  45. <RollingFile name="RollingFileInfo" fileName="${LOG_PATH}/info.log"
  46. filePattern="${LOG_PATH}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
  47. <!--控制台只输出 info 级别的信息-->
  48. <filters>
  49. <!--
  50. onMismatch="NEUTRAL" 表示该级别及以下的,由下一个filter处理,如果当前是最后一个,则不匹配该级别以下的
  51. onMatch="DENY" 表示不匹配该级别及以上
  52. -->
  53. <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
  54. <!--
  55. onMatch="ACCEPT" 表示匹配该级别及以上
  56. onMismatch="DENY" 表示不匹配该级别以下的
  57. -->
  58. <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
  59. </filters>
  60. <PatternLayout pattern="${pattern_format}"/>
  61. <Policies>
  62. <TimeBasedTriggeringPolicy/>
  63. <SizeBasedTriggeringPolicy size="100 KB"/>
  64. </Policies>
  65. </RollingFile>
  66. <!-- 只打印warn级别的信息,并自动存档-->
  67. <RollingFile name="RollingFileWarn" fileName="${LOG_PATH}/warn.log"
  68. filePattern="${LOG_PATH}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
  69. <!-- 只打印warn级别的日志-->
  70. <filters>
  71. <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
  72. <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
  73. </filters>
  74. <PatternLayout pattern="${pattern_format}"/>
  75. <Policies>
  76. <TimeBasedTriggeringPolicy/>
  77. <SizeBasedTriggeringPolicy size="100 KB"/>
  78. </Policies>
  79. <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件,这里设置了20 -->
  80. <DefaultRolloverStrategy max="20"/>
  81. </RollingFile>
  82. <!-- 打印error级别以上的信息-->
  83. <RollingFile name="RollingFileError" fileName="${LOG_PATH}/error.log"
  84. filePattern="${LOG_PATH}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
  85. <!-- 只打印error级别的日志-->
  86. <filters>
  87. <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
  88. </filters>
  89. <PatternLayout pattern="${pattern_format}"/>
  90. <Policies>
  91. <TimeBasedTriggeringPolicy/>
  92. <SizeBasedTriggeringPolicy size="100 KB"/>
  93. </Policies>
  94. </RollingFile>
  95. <!-- 每天进行归档,自动压缩日志文件 -->
  96. <RollingRandomAccessFile name="applicationAppender" fileName="${LOG_PATH}/rollingRandomAccessFile.log"
  97. filePattern="${LOG_PATH}/$${date:yyyy-MM}/common-%d{yyyy-MM-dd}.log.gz"
  98. append="true">
  99. <PatternLayout pattern="${pattern_format}"/>
  100. <Policies>
  101. <TimeBasedTriggeringPolicy/>
  102. </Policies>
  103. </RollingRandomAccessFile>
  104. </appenders>
  105. <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效-->
  106. <loggers>
  107. <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
  108. <logger name="org.springframework" level="INFO"></logger>
  109. <logger name="org.mybatis" level="INFO"></logger>
  110. <root level="all">
  111. <!-- appender引用-->
  112. <appender-ref ref="Console"/>
  113. <appender-ref ref="log"/>
  114. <appender-ref ref="RollingFileInfo"/>
  115. <appender-ref ref="RollingFileWarn"/>
  116. <appender-ref ref="RollingFileError"/>
  117. </root>
  118. </loggers>
  119. </configuration>

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

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

搭建slf4j门面 + log4j2 实现

加入pom依赖

  1. <!-- slf4j门面-->
  2. <dependency>
  3. <groupId>org.slf4j</groupId>
  4. <artifactId>slf4j-api</artifactId>
  5. <version>1.7.30</version>
  6. </dependency>
  7. <!-- slf4j与log4j2的桥接包:log4j-slf4j-impl-2.9.0.jar,这个包的作用就是使用slf4j的api,但是底层实现是基于log4j2.-->
  8. <dependency>
  9. <groupId>org.apache.logging.log4j</groupId>
  10. <artifactId>log4j-slf4j-impl</artifactId>
  11. <version>2.9.0</version>
  12. </dependency>
  13. <!-- log4j门面 ,这个也是需要的-->
  14. <dependency>
  15. <groupId>org.apache.logging.log4j</groupId>
  16. <artifactId>log4j-api</artifactId>
  17. <version>2.15.0</version>
  18. </dependency>
  19. <!-- log4j2依赖-->
  20. <dependency>
  21. <groupId>org.apache.logging.log4j</groupId>
  22. <artifactId>log4j-core</artifactId>
  23. <version>2.15.0</version>
  24. </dependency>
  25. <!-- log4j2异步日志依赖 ,不用异步功能的话,这个包可以不要-->
  26. <dependency>
  27. <groupId>com.lmax</groupId>
  28. <artifactId>disruptor</artifactId>
  29. <version>3.3.4</version>
  30. </dependency>

java代码

  1. package com;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. /**
  5. * 使用Slf4j作为门面
  6. */
  7. public class Log4j2_Slf4j_App {
  8. public static void main(String[] args) {
  9. Logger logger = LoggerFactory.getLogger(Log4j2_Slf4j_App.class);
  10. logger.error("error");
  11. logger.warn("warn");
  12. logger.info("info");
  13. logger.debug("debug");
  14. logger.trace("trace");
  15. }
  16. }

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

执行代码后打印结果如下

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

异步日志

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

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

添加maven依赖

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

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

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

AsyncAppender配置方式

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

AsyncLogger配置方式

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="WARN" monitorInterval="30">
  3. <Appenders>
  4. <RollingRandomAccessFile name="applicationAppender" fileName="./log/application.log"
  5. filePattern="./log/$${date:yyyy-MM}/common-%d{yyyy-MM-dd}.log.gz"
  6. append="false">
  7. <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%p] - %l - %m%n"/>
  8. <Policies>
  9. <TimeBasedTriggeringPolicy/>
  10. </Policies>
  11. </RollingRandomAccessFile>
  12. <Console name="CONSOLE" target="SYSTEM_OUT">
  13. <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%p] %t - %l - %m%n"/>
  14. </Console>
  15. </Appenders>
  16. <Loggers>
  17. <!-- AsyncLogger配置 -->
  18. <AsyncLogger name="log4j2" >
  19. <AppenderRef ref="applicationAppender"/>
  20. </AsyncLogger>
  21. <Root level="info">
  22. <!--<AppenderRef ref="CONSOLE"/>-->
  23. <AppenderRef ref="applicationAppender"/>
  24. </Root>
  25. <!--<Logger name="log4j2" level="debug" additivity="false" >-->
  26. <!--<AppenderRef ref="CONSOLE"/>-->
  27. <!--<AppenderRef ref="applicationAppender"/>-->
  28. <!--</Logger>-->
  29. </Loggers>
  30. </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

  1. <!-- 使用日志门面管理logback-->
  2. <dependency>
  3. <groupId>org.slf4j</groupId>
  4. <artifactId>slf4j-api</artifactId>
  5. <version>1.7.30</version>
  6. </dependency>
  7. <dependency>
  8. <groupId>ch.qos.logback</groupId>
  9. <artifactId>logback-core</artifactId>
  10. <version>1.2.3</version>
  11. </dependency>
  12. <dependency>
  13. <groupId>ch.qos.logback</groupId>
  14. <artifactId>logback-classic</artifactId>
  15. <version>1.2.3</version>
  16. </dependency>

java代码

  1. package com.log;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. public class LogbackApp {
  5. public static void main(String[] args) {
  6. Logger logger = LoggerFactory.getLogger(LogbackApp.class);
  7. logger.error("error");
  8. logger.info("123445");
  9. logger.debug("debug");
  10. logger.trace("trace");
  11. }
  12. }

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

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3. <!-- 配置变量,和 maven 的 properties标签的功能医院-->
  4. <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss} [%t] [%-5level] %c %M %L %m %n"></property>
  5. <property name="html_pattern" value="%d{yyyy-MM-dd HH:mm:ss}%t%-5level%c%M%L%m%n"></property>
  6. <!-- 输出到控制台-->
  7. <appender name="yexindong_console_appender" class="ch.qos.logback.core.ConsoleAppender">
  8. <!-- 控制输出流对象,默认为System.out(黑色字体) ,System.err 是红色字体 -->
  9. <!-- <target>System.err</target>-->
  10. <!-- 输出的日志消息格式配置-->
  11. <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  12. <!--
  13. 日志输出格式
  14. %-5level : 日志级别,占用5个字符的位置
  15. %d{yyyy-MM-dd HH:mm:ss,SSS} :日期并指定格式
  16. %c :类的完整名称
  17. %M : 方法名称
  18. %L : 代码所在行号
  19. %t : 调用logger打印方法的thread线程名称
  20. %m : 打印的日志内容
  21. %n : 换行
  22. -->
  23. <pattern>${pattern}</pattern>
  24. </encoder>
  25. </appender>
  26. <!-- 输出到文件-->
  27. <!-- <appender name="yexindong_file_appender" class="ch.qos.logback.core.FileAppender">-->
  28. <!-- 日志文件保存路径-->
  29. <!-- <file>D:\\log\\logback.log</file>-->
  30. <!-- 输出的日志消息格式配置-->
  31. <!-- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
  32. <!-- <pattern>${pattern}</pattern>-->
  33. <!-- </encoder>-->
  34. <!-- </appender>-->
  35. <!-- 输出到html格式的日志文件-->
  36. <!-- <appender name="yexindong_html_appender" class="ch.qos.logback.core.FileAppender">-->
  37. <!-- 日志文件保存路径-->
  38. <!-- <file>D:\\log\\logback_html.html</file>-->
  39. <!-- html 消息格式配置-->
  40. <!-- <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">-->
  41. <!-- <layout class="ch.qos.logback.classic.html.HTMLLayout">-->
  42. <!-- <pattern>${html_pattern}</pattern>-->
  43. <!-- </layout>-->
  44. <!-- </encoder>-->
  45. <!-- </appender>-->
  46. <!-- 日志拆分、自动归档压缩-->
  47. <appender name="yexindong_roll_file_appender" class="ch.qos.logback.core.rolling.RollingFileAppender">
  48. <!-- 日志文件保存路径-->
  49. <file>D:\\log\\logback_rolling.log</file>
  50. <!-- 输出的日志消息格式配置-->
  51. <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  52. <pattern>${pattern}</pattern>
  53. </encoder>
  54. <!-- 指定文件拆分规则-->
  55. <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  56. <!-- 按照时间为节点进行拆分,自动压缩的文件名称-->
  57. <fileNamePattern>D:\\log\\logback_rolling.%d{yyyy-MM-dd HH_mm_ss}.log%i.gz</fileNamePattern>
  58. <!-- 按照文件大小进行拆分,当文件大小达到1MB时就会将日志进行压缩 -->
  59. <maxFileSize>1MB</maxFileSize>
  60. </rollingPolicy>
  61. <!-- 日志级别过滤器-->
  62. <filter class="ch.qos.logback.classic.filter.LevelFilter">
  63. <!-- 设置日志级别,-->
  64. <level>ERROR</level>
  65. <!-- 超过这个级别的日志才会打印-->
  66. <onMatch>ACCEPT</onMatch>
  67. <!-- 小于这个级别的日志不会打印-->
  68. <onMismatch>DENY</onMismatch>
  69. </filter>
  70. </appender>
  71. <!-- 异步日志,因为之前每次打印日志都是在主线程进行输出的,这样对响应速度会有所影响,配置成异步日志会提升响应速度-->
  72. <appender name="yexindong_async_appender" class="ch.qos.logback.classic.AsyncAppender">
  73. <!-- 这里将自动归档的appender设为异步的-->
  74. <appender-ref ref="yexindong_roll_file_appender"></appender-ref>
  75. </appender>
  76. <!--根logger配置-->
  77. <root level="All">
  78. <!-- appender引用-->
  79. <appender-ref ref="yexindong_console_appender"></appender-ref>
  80. <!-- <appender-ref ref="yexindong_file_appender"></appender-ref>-->
  81. <!-- <appender-ref ref="yexindong_html_appender"></appender-ref>-->
  82. <appender-ref ref="yexindong_async_appender"></appender-ref>
  83. </root>
  84. <!--
  85. 自定义logger对象
  86. name="com" : 这里是com是包名,表示com包下所有子包的类都使用自定义logger
  87. level="info" :自定义logger的日志级别
  88. additivity="false" :表示自定义的logger对象是否继承 rootLogger(根logger)
  89. -->
  90. <logger name="com" level="all" additivity="false">
  91. <appender-ref ref="yexindong_console_appender"></appender-ref>
  92. </logger>
  93. </configuration>

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

  1. 2021-12-17 19:55:38 [main] [ERROR] com.log.LogbackApp main 13 error
  2. 2021-12-17 19:55:38 [main] [INFO ] com.log.LogbackApp main 14 123445
  3. 2021-12-17 19:55:38 [main] [DEBUG] com.log.LogbackApp main 15 debug
  4. 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依赖

  1. <dependency>
  2. <groupId>commons-logging</groupId>
  3. <artifactId>commons-logging</artifactId>
  4. <version>1.2</version>
  5. </dependency>

2、打印日志

  1. package com.log;
  2. import org.apache.commons.logging.Log;
  3. import org.apache.commons.logging.LogFactory;
  4. public class App {
  5. public static void main(String[] args) {
  6. Log log = LogFactory.getLog(App.class);
  7. // jcl优先使用 log4j 日志,如果未添加log4j依赖,默认会使用java自带的日志框架:java.util.logging
  8. log.info("hello world");
  9. }
  10. }

3、 打印结果如下,发现默认情况下使用的是jdk自带的日志框架

  1. 十二月 17, 2021 11:34:22 上午 com.log.App main
  2. 信息: hello world

4、 接下来我们加上 log4j的依赖

  1. <dependency>
  2. <groupId>log4j</groupId>
  3. <artifactId>log4j</artifactId>
  4. <version>1.2.17</version>
  5. </dependency>

5、 再加上log4j的配置文件 log4j.properties,放在resources目录下

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

6、 其他代码不变,再次运行main方法后打印结果如下 ,会发现自动使用了log4j进行输出日志;

  1. 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依赖靠前的那个)==,并且在控制台会显示以下警告信息

  1. # 提示有多个日志实现
  2. SLF4J: Class path contains multiple SLF4J bindings.
  3. # 第一个日志实现
  4. 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
  5. # 第二个日志实现
  6. 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]
  7. # 默认绑定第一个
  8. SLF4J: Actual binding is of type [org.slf4j.impl.SimpleLoggerFactory]
准备java打印日志代码

首先加入slf4j的依赖

  1. <!-- 日志门面依赖-->
  2. <dependency>
  3. <groupId>org.slf4j</groupId>
  4. <artifactId>slf4j-api</artifactId>
  5. <version>1.7.26</version>
  6. </dependency>

log打印代码如下

  1. package com.log;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. public class App {
  5. public static void main(String[] args) {
  6. Logger logger = LoggerFactory.getLogger(App.class);
  7. logger.error("12322");
  8. logger.warn("warn");
  9. logger.info("info {}", "yexindong");
  10. logger.debug("debug");
  11. logger.trace("trace");
  12. }
  13. }

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

1、slf4j绑定默认日志

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

  1. <dependency>
  2. <groupId>org.slf4j</groupId>
  3. <artifactId>slf4j-simple</artifactId>
  4. <version>1.7.25</version>
  5. </dependency>

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

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

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

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

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

  1. <dependency>
  2. <groupId>org.slf4j</groupId>
  3. <artifactId>slf4j-log4j12</artifactId>
  4. <version>1.7.12</version>
  5. </dependency>
  6. <dependency>
  7. <groupId>log4j</groupId>
  8. <artifactId>log4j</artifactId>
  9. <version>1.2.17</version>
  10. </dependency>

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

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

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

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

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

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

slf4j 日志桥接器

使用场景

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

  1. import org.apache.log4j.Logger;

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

  1. <dependency>
  2. <groupId>org.slf4j</groupId>
  3. <artifactId>log4j-over-slf4j</artifactId>
  4. <version>1.7.25</version>
  5. </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等对象,将无法产生效果;

关键字Java