Apache Commons Logging 是如何决定使用哪个日志实现类的

  1public static LogFactory getFactory() throws LogConfigurationException {
  2
  3    // Identify the class loader we will be using
  4    // 找到应用自身所用的加载器
  5    //在 WAS 5.1 下是 com.ibm.ws.classloader.CompoundClassLoader
  6    ClassLoader contextClassLoader =
  7        (ClassLoader)AccessController.doPrivileged(
  8            new PrivilegedAction() {
  9                public Object run() {
 10                    return getContextClassLoader();
 11                }
 12            });
 13
 14    // Return any previously registered factory for this class loader
 15    // 看看是否有缓存的与此类加载器关联的 LogFactory 实例,有则返回
 16    LogFactory factory = getCachedFactory(contextClassLoader);
 17    if (factory != null)
 18        return factory;
 19
 20    // Load properties file..
 21    // will be used one way or another in the end.
 22    // 加载应用的 Classpath 下的属性文件 commons-logging.properties
 23    // FACTORY_PROPERTIES 常量值是 commons-logging.properties
 24    // commons-logging 一般在这个文件里指定 LogFactory 的实现类
 25    // 注意，它只是去加载这个属性文件，并不马上用里面配置的 LogFactory 类
 26    Properties props=null;
 27    try {
 28        InputStream stream = getResourceAsStream(contextClassLoader,
 29                                                 FACTORY_PROPERTIES);
 30
 31        if (stream != null) {
 32            props = new Properties();
 33            props.load(stream);
 34            stream.close();
 35        }
 36    } catch (IOException e) {
 37    } catch (SecurityException e) {
 38    }
 39
 40    /**** 从下面开始就是 commons-logging 按什么顺找到 LogFactory 实现类 ****/
 41
 42    // First, try the system property
 43    // 1. 查找系统属性 FACTORY_PROPERTY(org.apache.commons.logging.LogFactory)
 44    // 的值所对应的 LogFactory 实现类
 45
 46    try {
 47        String factoryClass = System.getProperty(FACTORY_PROPERTY);
 48        if (factoryClass != null) {
 49            factory = newFactory(factoryClass, contextClassLoader);
 50        }
 51    } catch (SecurityException e) {
 52        ;  // ignore
 53    }
 54
 55    // Second, try to find a service by using the JDK1.3 jar
 56    // discovery mechanism. This will allow users to plug a logger
 57    // by just placing it in the lib/ directory of the webapp ( or in
 58    // CLASSPATH or equivalent ). This is similar with the second
 59    // step, except that it uses the (standard?) jdk1.3 location in the jar.
 60    // 2. 使用 JDK1.3 jar 的 Service Provider Interface(SPI) 类发现机制
 61    // 从配置文件 SERVICE_ID(META-INF/services/org.apache.commons.logging.LogFactory)
 62    // 的第一行读取 LogFactory 的实现类名
 63    // 这个 META-INF 目录可以是 WebRoot 的 META-INF，也可以是 classpath 下的 META-INF 目录
 64
 65    if (factory == null) {
 66        try {
 67            InputStream is = getResourceAsStream(contextClassLoader,
 68                                                 SERVICE_ID);
 69
 70            if( is != null ) {
 71                // This code is needed by EBCDIC and other strange systems.
 72                // It's a fix for bugs reported in xerces
 73                BufferedReader rd;
 74                try {
 75                    rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
 76                } catch (java.io.UnsupportedEncodingException e) {
 77                    rd = new BufferedReader(new InputStreamReader(is));
 78                }
 79
 80                String factoryClassName = rd.readLine();
 81                rd.close();
 82
 83                if (factoryClassName != null &&
 84                    ! "".equals(factoryClassName)) {
 85
 86                    factory= newFactory( factoryClassName, contextClassLoader );
 87                }
 88            }
 89        } catch( Exception ex ) {
 90            ;
 91        }
 92    }
 93
 94    // Third try a properties file.
 95    // If the properties file exists, it'll be read and the properties
 96    // used. IMHO ( costin ) System property and JDK1.3 jar service
 97    // should be enough for detecting the class name. The properties
 98    // should be used to set the attributes ( which may be specific to
 99    // the webapp, even if a default logger is set at JVM level by a
100    // system property )
101    // 3. 现在才轮到用前面加载的 commons-logging.properties 文件中的
102    // FACTORY_PROPERTY(org.apache.commons.logging.LogFactory) 属性指定的 LogFactory 实现类
103
104    if (factory == null  &&  props != null) {
105        String factoryClass = props.getProperty(FACTORY_PROPERTY);
106        if (factoryClass != null) {
107            factory = newFactory(factoryClass, contextClassLoader);
108        }
109    }
110
111    // Fourth, try the fallback implementation class
112    // 4. 前面几步没有找到 LogFactory 的实现类或有异常的话就用默认的实现类
113    // 即 LogFactory 为我们准备的 FACTORY_DEFAULT(org.apache.commons.logging.impl.LogFactoryImpl)
114
115    if (factory == null) {
116        factory = newFactory(FACTORY_DEFAULT, LogFactory.class.getClassLoader());
117    }
118
119    if (factory != null) {
120        /**
121         * Always cache using context class loader..
122         * 缓存所用的实现类，以后直接使用缓冲中的 LogFactory 实现类
123         */
124        cacheFactory(contextClassLoader, factory);
125
126        if( props!=null ) {
127            Enumeration names = props.propertyNames();
128            while (names.hasMoreElements()) {
129                String name = (String) names.nextElement();
130                String value = props.getProperty(name);
131                factory.setAttribute(name, value);
132            }
133        }
134    }
135
136    return factory;
137}