在我们的日常开发中,必不可少的会记录一些日志,日志分为8个级别,优先级从高到低依次为:OFF、FATAL、ERROR、WARN、INFO、DEBUG、TRACE、 ALL。那么传统的日志框架有哪些呢?
主要有以下这些:
-
Java Util Logging(简称JUL)
(1)、使用package com.fanlx.log; import java.util.logging.Logger; /** 1. @version v1.0 2. @ProjectName: spring-log 3. @ClassName: JulLog 4. @Description: TODO 5. @Author: fanlx 6. @Date: 2020-09-21 10:12 */ public class JulLog { public static void main(String[] args) { Logger logger = Logger.getLogger("JulLog"); logger.info("JulLog"); } }
(2)、日志图
-
Log4J
(1)、maven依赖<dependencies> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> </dependencies>
(2)、使用
package com.fanlx.log; import org.apache.log4j.Logger; /** * @version v1.0 * @ProjectName: spring-log * @ClassName: Log4J * @Description: TODO * @Author: fanlx * @Date: 2020-09-21 15:58 */ public class Log4J { public static void main(String[] args) { Logger logger = Logger.getLogger("Log4J"); logger.info("Log4J"); } }
(3)、日志图
-
Jakarta Commons Logging(简称JCL)
(1) 、maven依赖<dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.2</version> </dependency>
(2)、使用
package com.fanlx.log; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * @version v1.0 * @ProjectName: spring-log * @ClassName: JclLog * @Description: TODO * @Author: fanlx * @Date: 2020-09-21 10:13 */ public class JclLog { public static void main(String[] args) { Log log = LogFactory.getLog("JclLog"); log.info("JclLog"); } }
(3)、日志图
(4)、原理
JCL这个日志框架跟Log4J,Java Logging API等日志框架不同。JCL采用了设计模式中的“适配器模式”,它对外提供统一的接口,然后在适配类中将对日志的操作委托给具体的日志框架,比如Log4J,Java Logging API等。(1)、在JCL中对外有两个统一的接口,分别是Log和LogFactory。如下图所示:
(2)、具体执行步骤LogFactory抽象类 方法一:获取一个log的实例对象,入口 public static Log getLog(String name) throws LogConfigurationException { return getFactory().getInstance(name); } 方法二:获取一个LogFactory public static LogFactory getFactory() throws LogConfigurationException { ---------------此处省略代码--------------- } 方法三:获取log的市实例对象,并返回给入口调用方法 public abstract Log getInstance(String var1) throws LogConfigurationException; 方法四:从上面的getInstance方法进入到LogFactory子类LogFactoryImpl的getInstance方法 public Log getInstance(String name) throws LogConfigurationException { Log instance = (Log)this.instances.get(name); if (instance == null) { instance = this.newInstance(name); this.instances.put(name, instance); } return instance; } 注意这个instances:它是在LogFactoryImpl类中定义的,protected Hashtable instances = new Hashtable();所以刚开始肯定获取不到,所以我们就主要看this.newInstance(name) 方法五: protected Log newInstance(String name) throws LogConfigurationException { try { Log instance; Object[] params; if (this.logConstructor == null) { instance = this.discoverLogImplementation(name); } else { params = new Object[]{name}; instance = (Log)this.logConstructor.newInstance(params); } if (this.logMethod != null) { params = new Object[]{this}; this.logMethod.invoke(instance, params); } return instance; } catch (LogConfigurationException var5) { throw var5; } catch (InvocationTargetException var6) { Throwable c = var6.getTargetException(); throw new LogConfigurationException((Throwable)(c == null ? var6 : c)); } catch (Throwable var7) { handleThrowable(var7); throw new LogConfigurationException(var7); } } 从上面可以看到最终返回了一个newInstance,而这个newInstance要不就是走if获取到的要不就是走else获取到的,看源码得知logConstructor为null,所以接下来分析discoverLogImplementation这个方法 方法六: private Log discoverLogImplementation(String logCategory) throws LogConfigurationException { if (isDiagnosticsEnabled()) { this.logDiagnostic("Discovering a Log implementation..."); } this.initConfiguration(); Log result = null; String specifiedLogClassName = this.findUserSpecifiedLogClassName(); if (specifiedLogClassName != null) { if (isDiagnosticsEnabled()) { this.logDiagnostic("Attempting to load user-specified log class '" + specifiedLogClassName + "'..."); } result = this.createLogFromClass(specifiedLogClassName, logCategory, true); if (result == null) { StringBuffer messageBuffer = new StringBuffer("User-specified log class '"); messageBuffer.append(specifiedLogClassName); messageBuffer.append("' cannot be found or is not useable."); this.informUponSimilarName(messageBuffer, specifiedLogClassName, "org.apache.commons.logging.impl.Log4JLogger"); this.informUponSimilarName(messageBuffer, specifiedLogClassName, "org.apache.commons.logging.impl.Jdk14Logger"); this.informUponSimilarName(messageBuffer, specifiedLogClassName, "org.apache.commons.logging.impl.Jdk13LumberjackLogger"); this.informUponSimilarName(messageBuffer, specifiedLogClassName, "org.apache.commons.logging.impl.SimpleLog"); throw new LogConfigurationException(messageBuffer.toString()); } else { return result; } } else { if (isDiagnosticsEnabled()) { this.logDiagnostic("No user-specified Log implementation; performing discovery using the standard supported logging implementations..."); } for(int i = 0; i < classesToDiscover.length && result == null; ++i) { result = this.createLogFromClass(classesToDiscover[i], logCategory, true); } if (result == null) { throw new LogConfigurationException("No suitable Log implementation"); } else { return result; } } } 上面的代码最终返回result,所以看result获取的地方,也就是进入else里面的for循环的地方,如果看过源码的话,应该可以看到classesToDiscover是一个String数组,它里面存放了四个日志框架的类名,如下面所示: String[] classesToDiscover = new String[]{"org.apache.commons.logging.impl.Log4JLogger", "org.apache.commons.logging.impl.Jdk14Logger", "org.apache.commons.logging.impl.Jdk13LumberjackLogger", "org.apache.commons.logging.impl.SimpleLog"}; 依次为Log4JLogger、Jdk14Logger、Jdk13LumberjackLogger、SimpleLog 到这里其实已经很清晰了,如果不信你可以点进去看,你会发现最终就是调用三行代码(其他可以忽略不计) Class c= Class.forName(logAdapterClassName, true, currentCL); constructor = c.getConstructor(this.logConstructorSignature); Object o = constructor.newInstance(params); newInstance熟悉吗?归根结底这个jul就是集成了其它日志框架,通过在数组里写日志框架的类名,然后依次循环,看哪一个能获取到就返回
(3)、需要注意的地方
循环的条件result == null
数组第一个为Log4JLogger
(4)、总结
JCL采用了设计模式中的“适配器模式”,它对外提供统一的接口,然后在适配类中将对日志的操作委托给具体的日志框架,如果在你的项目里加入了log4j的maven依赖,它会优先采用Log4JLogger,如果没有log4j,它会采用Jdk14Logger,后面两个可以不用考虑,这样做有什么好处呢?
example:如果哪天项目经理给你一个需求,让你在项目里使用jdk日志,然后你在项目里所有该用的地方都加了,好了,万事俱备了,只欠什么风来着,某某天,你的项目经理狂性大发,让你改成log4j,你想想,你得改多少地方,简直要骂娘,可如果你使用jul,你想用哪个就用哪个,就是删一个maven依赖的事,至于坏处,暂时还不知道
4.slf4j
首先我们进slf4j的官网slf4j官网
上面也说了在你使用slf4j之前,强烈建议你看看用户使用手册,那我们就点进去看看slf4j用户手册
这里面也写了如何使用slf4j,看上面红框框所示:
1.添加maven依赖
<dependencies>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.28</version>
</dependency>
</dependencies>
2.启动你的应用程序,会发现有个警告,注意不是错误
看See,翻译过来就是看,肯定不是让你看美女,让你进这个地址看解决上面这个问题
注意看上面这个图,跟我们之前那个错误是不是很像,意思就是说在我们的classPath下没有找到和slf4j绑定的日志框架,让我们把slf4j-nop.jar,slf4j-simple.jar,slf4j-log4j12.jar等等jar包添加一个(只能是一个,多了会报错)到我们的classPath下,由于我使用的是maven环境,所以我就试其中的一个
<dependencies>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.28</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.28</version>
</dependency>
</dependencies>
发现能够正常打印日志了,但是我反复测试了几个,看到第二个依赖里已经包含了第一个依赖,所以可以把第一个依赖去掉,这是将log4j和slf4j进行绑定,至于其它的小伙伴们就自己去玩了
接下来我们看看slf4j另外一个使用场景,桥接器
假如有一天我们做了个大型项目,项目经理说使用jul打印日志,这个对很多程序员来说简单,但是由于我们项目中引入了其它框架,而恰恰这个框架内部使用的是log4j框架,项目经理就说小伙子,你去让这个谁谁谁也打印jul日志,突然头疼了,改别人框架肯定不可能,那有什么办法在不修改那个谁谁谁的前提下又可以让打印jul日志呢?让我们来看看slf4j是怎么完成的
1.我们自己打印的jul日志
2.xxx框架打印log4j日志
3.添加slf4j桥接器以后,让log4j摇身一变
这里主要添加两个依赖
<dependencies>
<!--slf4j绑定jdk日志-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-jdk14</artifactId>
<version>1.7.28</version>
</dependency>
<!--log4j桥接到slf4j-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j</artifactId>
<version>1.7.28</version>
</dependency>
</dependencies>
详情链接桥接详情
需要注意的地方,就是如果想把jul日志变成log4j等其它日志的时候,
1.添加以下依赖
<dependencies>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.28</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jul-to-slf4j</artifactId>
<version>1.7.28</version>
</dependency>
</dependencies>
2,在你记录日志的地方需要添加以下两行代码,红框框,这样打印的才是log4j的日志
问题一:死循环