JUL、JCL、Log4j、Slf4j各种日志框架的使用

小鱼儿 2022-11-15 11:22 174阅读 0赞

java中存在各种各样的与日志有关的框架，如：

*  JUL：Java Util Logging。
 *  JCL：Jakarta Commons Logging，也可称为"Apache Commons Logging"。
 *  Log4j
 *  Log4j2
 *  Logback
 *  Slf4j

## JUL的使用 ##

JUL是jdk自带的无需引入第三方的jar。

package com.morris.spring.log;
    
    import java.util.logging.Logger;
    
    public class JULTest { 
    
        public static void main(String[] args) { 
            Logger logger = Logger.getLogger(JULTest.class.getName());
            logger.info("jul log");
        }
    }

运行结果如下：  
![在这里插入图片描述][20210331154014401.png]

## Log4j的使用 ##

使用Log4j需引用Log4j的JAR。

还需要在`resources`目录下添加`log4j.properties`，内容如下：

# Root logger option
    log4j.rootLogger=INFO, stdout
    
    # Direct log messages to stdout
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.out
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d{ yyyy-MM-dd HH:mm:ss} %-5p %c{ 1}:%L - %m%n

log4j的使用如下：

package com.morris.spring.log;
    
    import org.apache.log4j.Logger;
    
    public class Log4jTest { 
    
        public static void main(String[] args) { 
    
            Logger logger = Logger.getLogger(Log4jTest.class);
            logger.info("log4j log");
    
        }
    }

运行结果如下：  
![在这里插入图片描述][20210331154036985.png]

## JCL的使用 ##

使用JCL需要引入JCL的JAR。

<dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>

JCL的使用如下：

package com.morris.spring.log;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    public class JCLTest { 
    
        public static void main(String[] args) { 
            Log log = LogFactory.getLog(JCLTest.class);
            log.info("jcl log");
        }
    }

运行结果如下：

![在这里插入图片描述][20210331154050432.png]

从运行结果可以发现，JCL的运行结果与Log4j的运行结果一致，可以大胆猜测JCL的底层是使用了Log4j。然后我们将Log4j的依赖去除，运行结果如下：

![在这里插入图片描述][20210331154058792.png]

从运行结果可以发现，去除Log4j依赖后，JCL的运行结果与JUL的运行结果一致，可以大胆猜测JCL的底层是使用了JUL。

那么JCL到底何时使用Log4j，何时使用JUL，还会不会使用其他日志框架呢？答案从源码中可以分析出。

## JCL的源码分析 ##

通过查看源代码可以发现，执行`LogFactory.getLog(JCLTest.class);`语句的时候，最终是执行LogFactoryImp类中的discoverLogImplementation方法，在该方法中有如下代码语句：

> org.apache.commons.logging.impl.LogFactoryImpl\#discoverLogImplementation而其中的classesToDiscover是一个静态常量，值为：

private static final String[] classesToDiscover = { 
            "org.apache.commons.logging.impl.Log4JLogger",
            "org.apache.commons.logging.impl.Jdk14Logger",
            "org.apache.commons.logging.impl.Jdk13LumberjackLogger",
            "org.apache.commons.logging.impl.SimpleLog"
    };

JCL会根据静态常量定义的顺序循环查找这些常量所表示的类是否存在，直到找到存在的为止，JCL首先会查找Log4j是否存在，找到就会使用Log4j打印日志，没找到就会查找JUL是否存在，JUL为jdk自带的，一般都会存在，所以最后会使用JUL打印日志，后面的常量所表示的类不会执行。

在Log4JLogger类中，包含有`org.apache.log4j.Logger`类，即Log4J中的Logger类，因而对Log4JLogger类中的日志操作方法的调用会被委托给`org.apache.log4j.Logger`类运行。

在Jdk14Logger类中，包含有`java.util.logging.Logger`类，即Java Logging API中的Logger类，因而对Jdk14Logger类中的日志操作方法的调用会被委托给`java.util.logging.Logger`类运行。

## Slf4j的简单使用 ##

要想使用slf4j，需引入slf4j的api。

slf4j的测试类如下：

package com.morris.spring.log;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class Slf4jTest { 
    
        public static void main(String[] args) { 
            Logger logger = LoggerFactory.getLogger(Slf4jTest.class);
            logger.info("slf4j log");
        }
    }

运行结果如下：

![在这里插入图片描述][20210331154114247.png]

从运行结果发现并没有打印日志，而是打印出一个警告`Failed to load class "org.slf4j.impl.StaticLoggerBinder`

slf4j只是一个日志标准，并不是日志系统的具体实现。要打印日志，还得引入一个具体实现。

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

注意`slf4j-simple`的版本与`slf4j-api`的版本保持一致。

运行结果如下：

![在这里插入图片描述][20210331154123830.png]

## Slf4j绑定Log4j ##

我们的代码中是面向抽象（slf4j）编程，而打印日志需要一个具体的实现（如log4j）,那么slf4j和log4j之间怎么关联起来呢，这就需要一个绑定器（slf4j-log4j12）。

每一种具体的日志框架都有与之对应的绑定器。一般来说绑定器（slf4j-log4j12）中依赖了具体的实现（log4j），所有项目中不需要显性的引入具体的实现。

将上面例子中`slf4j-simple`的依赖去除，加入log4j对应的绑定器(slf4j-log4j12)。

注意绑定器的版本与slf4j-api的版本需保持一致。

运行结果如下：

![在这里插入图片描述][20210331154202358.png]

从运行结果可看出，确实使用了log4j打印了日志（如果还不确定可以设置log4g.properties中的日志级别为error，看是不是会生效）。

如果此时我想将日志框架换成JUL，那么只需将绑定器换成slf4j-jdk14即可。

同样JCL有与之对应的绑定器，如果想将项目的日志框架换了，只需将项目中的绑定换成与之对应的绑定器即可。

Logback直接实现了slf4j，只需将依赖引入即可，无需绑定器：

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

## slf4j的源码分析 ##

从`Logger logger = LoggerFactory.getLogger(Slf4jTest.class)`开始进入找，最终会调到：

org.slf4j.LoggerFactory\#findPossibleStaticLoggerBinderPathSet

private static Set findPossibleStaticLoggerBinderPathSet() { 
        LinkedHashSet staticLoggerBinderPathSet = new LinkedHashSet();
    
        try { 
            ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
            Enumeration paths;
            if (loggerFactoryClassLoader == null) { 
                paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
            } else { 
    			// STATIC_LOGGER_BINDER_PATH 为org/slf4j/impl/StaticLoggerBinder.class
                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会去查找类路径下所有的StaticLoggerBinder类，而我们添加的绑定器slf4j-log4j12中就有这个类：

![在这里插入图片描述][20210331154220844.png]

log4j对应的绑定器（slf4j-log4j12）中包含了一个StaticLoggerBinder类，

// org.slf4j.impl.StaticLoggerBinder
    private final ILoggerFactory loggerFactory = new Log4jLoggerFactory();

Log4jLoggerFactory中使用了Log4j：

package org.slf4j.impl;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    import org.apache.log4j.LogManager;
    import org.slf4j.ILoggerFactory;
    import org.slf4j.Logger;
    
    public class Log4jLoggerFactory implements ILoggerFactory { 
        ConcurrentMap<String, Logger> loggerMap = new ConcurrentHashMap();
    
        public Log4jLoggerFactory() { 
        }
    
        public Logger getLogger(String name) { 
            Logger slf4jLogger = (Logger)this.loggerMap.get(name);
            if (slf4jLogger != null) { 
                return slf4jLogger;
            } else { 
                org.apache.log4j.Logger log4jLogger;
                if (name.equalsIgnoreCase("ROOT")) { 
                    log4jLogger = LogManager.getRootLogger();
                } else { 
                    log4jLogger = LogManager.getLogger(name);
                }
    
                Logger newInstance = new Log4jLoggerAdapter(log4jLogger);
                Logger oldInstance = (Logger)this.loggerMap.putIfAbsent(name, newInstance);
                return (Logger)(oldInstance == null ? newInstance : oldInstance);
            }
        }
    }

## 总结 ##

*  在项目中使用JCL的好处是降低与具体日志框架的耦合，可以灵活改变使用的具体日志框架。
 *  经典的日志框架组合为：JCL+Log4J。
 *  Spring项目中就选用了JCL框架。

[20210331154014401.png]: /images/20221022/bbc4f7c856764257b26cbe2ae9af1f93.png
[20210331154036985.png]: https://img-blog.csdnimg.cn/20210331154036985.png
[20210331154050432.png]: https://img-blog.csdnimg.cn/20210331154050432.png
[20210331154058792.png]: https://img-blog.csdnimg.cn/20210331154058792.png
[20210331154114247.png]: https://img-blog.csdnimg.cn/20210331154114247.png
[20210331154123830.png]: https://img-blog.csdnimg.cn/20210331154123830.png
[20210331154202358.png]: https://img-blog.csdnimg.cn/20210331154202358.png
[20210331154220844.png]: https://img-blog.csdnimg.cn/20210331154220844.png