Java的日志系统

lgllinktheworld

已于 2023-04-26 18:06:06 修改

阅读量733

点赞数 14

文章标签： java log4j apache

于 2023-04-26 18:04:55 首次发布

本文链接：https://blog.csdn.net/lgllinktheworld/article/details/130390431

版权

文章目录

前言

日志重要吗？大家排查问题，数据统计分析、故障定位都依赖日志，甚至有的公司直接用日志的输出，经过统计做业务系统的输入。所以日志实在太重要了，大家几乎每天都在用日志，那都知道用的是什么日志框架，以及实现的原理吗？

大家平时用的日志框架是什么？log4j 和logback吗？和slf4j什么区别？

门面模式和slf4j

说Log4j 和 Logback 之前，不得不提SLF4J。

简单说，SLF4J相当于定义了接口，Log4j 和 Logback是具体实现。

SLF4J就是典型的门面模式。

门面模式（Facade Pattern）又叫外观模式，提供了一个统一的接口，提供了一个统一的接口，用来访问子系统中的一群接口。其主要特征是定义了一个高层接口，让子系统更容易使用，属于结构性模式。

假设有一个系统 A，提供了 a、b、c、d 四个接口。系统 B 完成某个业务功能，需要调用 A 系统的 a、b、d接口。利用门面模式，我们提供一个包裹 a、b、d 接口调用的门面接口 x，给系统 B 直接使用。
假设我们刚刚提到的系统 A是一个后端服务器，系统 B 是 App 客户端。App 客户端通过后端服务器提供的接口来获取数据。我们知道，App和服务器之间是通过移动网络通信的，网络通信耗时比较多，为了提高 App 的响应速度，我们要尽量减少 App 与服务器之间的网络通信次数。
假设，完成某个业务功能（比如显示某个页面信息）需要“依次”调用 a、b、d 三个接口，因自身业务的特点，不支持并发调用这三个接口。如果我们现在发现 App客户端的响应速度比较慢，排查之后发现，是因为过多的接口调用过多的网络通信。针对这种情况，我们就可以利用门面模式，让后端服务器提供一个包裹a、b、d 三个接口调用的接口 x。App 客户端调用一次接口 x，来获取到所有想要的数据，将网络通信的次数从 3 次减少到 1次，也就提高了 App 的响应速度。

这里举的例子只是应用门面模式的其中一个意图，也就是解决性能问题。实际上，不同的应用场景下，使用门面模式的意图也不同。

具体的有关门面模式的使用可以自行查找。

说完门面模式，那么SLF4J和门面模式有什么关系吗？简单说系统访问入口SLF4J只提供一个门面，具体实现对调用方不可见，SLF4J门面模式画了个简图，如下：
在这里插入图片描述

SLF4J门面是怎么绑定具体的日志系统的

要打印日志，就会引入上面提到的日志框架，就拿我们平时工程中常用的maven来讲，会同时引入Log4j、sfl4j-jdk / Logback等作为日志记录系统，那SLF4J门面是怎么绑定具体的日志系统的呢？

我们先写一个简单例子：新建一个maven工程，在pom中只加入SLF4J的依赖包，

<!--只引入slf4j-->
<dependencies>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.24</version>
  </dependency>
</dependencies>

写段打印日志的测试代码, 如下：

public class LogTest {

    static final Logger logger = LoggerFactory.getLogger(LogTest.class);

    public static void main(String[] args) {
        logger.info("验证slf4j");
    }
}

运行结果如下：
在这里插入图片描述

因为我们现在只引入了门面SLF4J, 没有具体实现, 所有会报找不到StaticLoggerBinder的异常日志。

这个是运行期的报错，编译没问题，因为这个门面的具体实现是运行期绑定的。

我们添加多个实现

<dependencies>
        <!--引入slf4j 门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.24</version>
        </dependency>

        <!--logback-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.11</version>
        </dependency>

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

        <!--slf4j-log4j12-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>
    </dependencies>

SLF4J会提示Classpath 包含多个SLF4J的实现，已经最终从这些中选择的是logback实现。
在这里插入图片描述
那问题来了：LoggerFactory如果绑定具体的日志系统的呢？

源码查看

先说结论

所有实现SLF4J标准的日志系统都需要提供StaticLoggerBinder类，如下图所示：

我们在代码中写下这行代码的时候，SLF4J是如何绑定具体日志系统的呢？

static final Logger logger = LoggerFactory.getLogger(LogTest.class);

我们点击查看getLogger()方法，如下：

    public static Logger getLogger(String name) {
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

    public static Logger getLogger(Class<?> clazz) {
        Logger logger = getLogger(clazz.getName());
        // 省略
        return logger;
    }

会发现核心就是getILoggerFactory()方法，实现如下：

public static ILoggerFactory getILoggerFactory() {
        if (INITIALIZATION_STATE == 0) {
            Class var0 = LoggerFactory.class;
            synchronized(LoggerFactory.class) {
                if (INITIALIZATION_STATE == 0) {
                    INITIALIZATION_STATE = 1;
                    performInitialization();
                }
            }
        }

        switch(INITIALIZATION_STATE) {
        case 1:
            return SUBST_FACTORY;
        case 2:
            throw new IllegalStateException("org.slf4j.LoggerFactory in failed state. Original exception was thrown EARLIER. See also http://www.slf4j.org/codes.html#unsuccessfulInit");
        case 3:
            return StaticLoggerBinder.getSingleton().getLoggerFactory();
        case 4:
            return NOP_FALLBACK_FACTORY;
        default:
            throw new IllegalStateException("Unreachable code");
        }
    }

这段逻辑就是判断日志系统是否初始化，如果还没初始化，先进行初始化，performInitialization() 只会执行一次。

初始化过程中，INITIALIZATION_STATE是初始化过程中状态。下面是定义的状态和变量

static final int UNINITIALIZED = 0;
static final int ONGOING_INITIALIZATION = 1;
static final int FAILED_INITIALIZATION = 2;
static final int SUCCESSFUL_INITIALIZATION = 3;
static final int NOP_FALLBACK_INITIALIZATION = 4;
//日志系统初始化状态
static volatile int INITIALIZATION_STATE = 0;

可以看到INITIALIZATION_STATE是volatile 修饰的，保证多线程初始化日志框架的时候状态的可见性，不会出现多次初始化。

我们再看下 performInitialization() 函数，重点就在bind函数, 这里实际上就是绑定具体的日志框架，如下：

private static final void performInitialization() {
		// 核心是bind()方法
        bind();
        if (INITIALIZATION_STATE == 3) {
            versionSanityCheck();
        }
    }
	private static final void bind() {
        String msg;
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            // 第一步: 如果是Android 则跳过, 否则查找类路径下所有的StaticLoggerBinder实现类
            if (!isAndroid()) {
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
			// 第二步: 可能会有多个StaticLoggerBinder实现类，随机绑定其中一个
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = 3;
            //打印实际绑定的
            reportActualBinding(staticLoggerBinderPathSet);
            fixSubstituteLoggers();
            replayEvents();
            SUBST_FACTORY.clear();
        }catch(){
        // 省略
        }
    }

	static Set<URL> findPossibleStaticLoggerBinderPathSet() {
        LinkedHashSet staticLoggerBinderPathSet = new LinkedHashSet();

        try {
            ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
            Enumeration paths;
            //STATIC_LOGGER_BINDER_PATH = org/slf4j/impl/StaticLoggerBinder.class
    		//就是查找classpath下所有 StaticLoggerBinder，限制一定是org.slf4j.impl这个包路径
            if (loggerFactoryClassLoader == null) {
                paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
            } else {
                paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
            }

            while(paths.hasMoreElements()) {
                URL path = (URL)paths.nextElement();
                staticLoggerBinderPathSet.add(path);
            }
        } catch (IOException var4) {
            Util.report("Error getting resources from path", var4);
        }

        return staticLoggerBinderPathSet;
    }

如果系统中有多个SLF4J实现时，ClassLoader.getResources() 方法会从ClassPath查找到多个StaticLoggerBinder的实现类，通过类加载器加载所有StaticLoggerBinder类

org/slf4j/impl/StaticLoggerBinder.class

lombok注解中@Slf4j的原理是什么？

我去看了看我们项目里的日志，几乎都是使用@Slf4j注解
它的原理是什么呢？

@Log4j：注解在类上；为类提供一个 属性名为log 的 log4j 日志对像
@Slf4j: 同上

实现原理：

Lombok不是通过字节码改写来实现的。
它主要是用编译器内支持的annotation processing，直接操纵抽象语法树（AST），根据需要添加新节点

例如：

@Slf4j
public class LogExample {
}

以上将编译成

public class LogExample {
	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
}

甜点-延伸

如果我们自己要实现一套日志框架，只需要在我们工程中创建一个StaticLoggerBinder类，当然包名一定要是 org/slf4j/impl/。

参考

面试官突然的关心-日志篇

lgllinktheworld

关注

14
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java的日志系统

日志重要吗？大家排查问题，数据统计分析、故障定位都依赖日志，甚至有的公司直接用日志的输出，经过统计做业务系统的输入。所以日志实在太重要了，大家几乎每天都在用日志，那都知道用的是什么日志框架，以及实现的原理吗？大家平时用的日志框架是什么？log4j 和logback吗？和slf4j什么区别？
复制链接

扫一扫