commons-logging + log4j源码分析

分析之前先理清楚几个概念

log4j = log for java

slf4j = simple logging facade for java

看到facade首先想到的就是设计模式中的门面（facade）模式，实际上slf4j 就是一个装"门面"的java日志框架，它只提供一层抽象且通用的日志api供调用方写日志使用，而真正实现写日志功能的则是log4j、logback等框架和从jdk1.4之后开始提供的java.util.logging包，而具体要使用谁就要看slf4j中设置的策略，整体来看的话也确实是使用了门面模式

关于这几个日志框架的诞生和关系推荐看下这篇博客：

 

apache的commons-logging和slf4j 一样，也是一个抽象的日志框架，使用得更广泛，下面通过几段源码分析下其内部的门面模式是怎样实现的

一般写日志之前都要先用下面的方法获取到log对象

log log = logfactory.getlog(clz.getname());

进入getlog方法

    public static log getlog(string name) throws logconfigurationexception {
        return getfactory().getinstance(name);
    }

看来是先获取到log工厂对象再获取到log对象，进入getfactory方法

//获取到上下文中的类加载器
classloader contextclassloader = getcontextclassloaderinternal();

//先尝试从缓存中获取logfactory
logfactory factory = getcachedfactory(contextclassloader);
if (factory != null) {
　　return factory;
}

  //如果存在commons-logging.properties配置文件且其中的use_tccl配置项为false，则使用thisclassloader作为后续的类加载器，thisclassloader就是当前类的加载器
  properties props = getconfigurationfile(contextclassloader, factory_properties);
  classloader baseclassloader = contextclassloader;
  if (props != null) {
　　  string usetcclstr = props.getproperty(tccl_key);
　　  if (usetcclstr != null) {
　　　　  if (boolean.valueof(usetcclstr).booleanvalue() == false) {
　　　　　　  baseclassloader = thisclassloader;
　　　　  }
　　  }
  }

//获取org.apache.commons.logging.logfactory系统配置项，若存在则使用配置的类新建一个工厂对象

string factoryclass = getsystemproperty(factory_property, null);
if (factoryclass != null) {
    factory = newfactory(factoryclass, baseclassloader, contextclassloader);
}

//利用java中的spi机制根据meta-inf/services/org.apache.commons.logging.logfactory中的配置类新建工厂对象

if (factory == null) {
    try {
        final inputstream is = getresourceasstream(contextclassloader, service_id);
　　　　  ...

　　　　 factory = newfactory(factoryclassname, baseclassloader, contextclassloader );
　　　　  ...

//根据commons-logging.properties中的配置属性org.apache.commons.logging.logfactory新建工厂对象

  if (factory == null) {
  　　string factoryclass = props.getproperty(factory_property);
  　　factory = newfactory(factoryclass, baseclassloader, contextclassloader);

  //如果以上都没成功创建工厂对象则直接使用默认的org.apache.commons.logging.impl.logfactoryimpl类创建

factory = newfactory(factory_default, thisclassloader, contextclassloader);

//最后放入缓存

cachefactory(contextclassloader, factory);

一般上述过程中属性配置都不加的话默认的logfactory实现类就是logfactoryimpl，然后进入到它的getinstance方法看下

 

public log getinstance(string name) throws logconfigurationexception {
        log instance = (log) instances.get(name);
        if (instance == null) {
            instance = newinstance(name);
            instances.put(name, instance);
        }
        return instance;
    }

进入newinstance

    protected log newinstance(string name) throws logconfigurationexception {
        log instance;
        try {
            if (logconstructor == null) {
                instance = discoverlogimplementation(name);
            }
            else {
                object params[] = { name };
                instance = (log) logconstructor.newinstance(params);
            }

            if (logmethod != null) {
                object params[] = { this };
                logmethod.invoke(instance, params);
            }

            return instance;

进入discoverlogimplementation

    private log discoverlogimplementation(string logcategory)
        throws logconfigurationexception {
        initconfiguration();
        log result = null;

　　　　//finduserspecifiedlogclassname方法内部也是读取一些系统配置项，如果读取到了就根据配置的类名来创建日志对象

        string specifiedlogclassname = finduserspecifiedlogclassname();
        if (specifiedlogclassname != null) {
            result = 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.");
                informuponsimilarname(messagebuffer, specifiedlogclassname, logging_impl_log4j_logger);
                informuponsimilarname(messagebuffer, specifiedlogclassname, logging_impl_jdk14_logger);
                informuponsimilarname(messagebuffer, specifiedlogclassname, logging_impl_lumberjack_logger);
                informuponsimilarname(messagebuffer, specifiedlogclassname, logging_impl_simple_logger);
                throw new logconfigurationexception(messagebuffer.tostring());
            }
            return result;
        }
　　　　 //如果上面没有创建成功则根据classestodiscover数组的值作为类名依次创建日志对象，直到创建成功（不为空）就返回
　　　　 for(int i=0; i<classestodiscover.length && result == null; ++i) {
            result = createlogfromclass(classestodiscover[i], logcategory, true);
        }

        if (result == null) {
            throw new logconfigurationexception
                        ("no suitable log implementation");
        }
        return result;
    }

其中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"
}

所以当我们的项目中引入的commons-logging和log4j的jar包，其实不需要做任何配置，就会优先使用log4jlogger做为实际的写日志实现类

整个过程中有两点需要注意的：

1.日志工厂对象和日志实现类对象都是先使用当前类或者thread context的classload将类加载进来再通过反射创建对象，这样的话如果有的插件使用自定义的classload加载，当插件内部打印日志时可能会出现无法创建日志对象或者使用了和预期不一致的日志对象

2.动态查找：对日志工厂实现类和日志实现类的动态查找基本上都是通过读取系统配置或者代码里写死的方式来查找，其实可以通过java spi机制来实现

slf4j的实现方式与上述是完全不同的，它采用的是静态绑定，可以避免classload的问题，但在使用时要引入各种桥接包，如果引入了两个相反的桥接包就会导致循环依赖的*