日志框架

最新推荐文章于 2023-07-10 01:44:41 发布

浅墨扶苏

最新推荐文章于 2023-07-10 01:44:41 发布

阅读量220

点赞数

分类专栏： spring系列

本文链接：https://blog.csdn.net/weixin_43334790/article/details/108705946

版权

spring系列专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在我们的日常开发中,必不可少的会记录一些日志,日志分为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的日志
在这里插入图片描述
问题一:死循环

浅墨扶苏

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
日志框架

在我们的日常开发中,必不可少的会记录一些日志,日志分为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.
复制链接

扫一扫