Java日志

package me.likeyao.jdk.logger;

import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class JDKLoggerTest {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("logger");
        logger.info("hello world");

        Handler handler = new Handler() {
            @Override
            public void publish(LogRecord record) {
            }
            @Override
            public void flush() {
            }
            @Override
            public void close() throws SecurityException {
            }
        };

        handler.setFormatter(new Formatter() {
            @Override
            public String format(LogRecord record) {
                return null;
            }
        });

        logger.setLevel(Level.INFO);
        logger.log(Level.FINEST, "hello world");
    }
}

private final Hashtable<String,LoggerWeakRef> namedLoggers = new Hashtable<>();

package me.likeyao.java.logger;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class JCLTest {
    private static Log logger = LogFactory.getLog(JCLTest.class);
    public static void main(String[] args) throws Exception {
        logger.info("hello world");
    }
}

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

private Log discoverLogImplementation(String logCategory)
    ...
    Log result = null;
    //查看commons-logging.properties和System.getProperty是否配置了org.apache.commons.logging.log
    String specifiedLogClassName = findUserSpecifiedLogClassName();
    if (specifiedLogClassName != null) {
        ...
        //如果有配置，直接使用配置的类创建Log
        result = createLogFromClass(specifiedLogClassName,
                                    logCategory,
                                    true);
        ...
        return result;
    }
    ...
    //如果没有，遍历classesToDiscover数组，如果使用指定的ClassLoader Class.forName能加载到类，就创建Log对象
    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;
}

package me.likeyao.java.logger;

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class JCLTest3 {

    public static void main(String[] args) throws Exception {
        //自定义classloader，模仿web容器classloader，自己加载优先
        ChildClassLoader childClassLoader = new ChildClassLoader(
                new URL[] { new File("c:/tmpclass/commons-logging-1.2.jar").toURL(),
                            new File("C:/respository3/log4j/log4j/1.2.17/log4j-1.2.17.jar").toURL()});
        Thread.currentThread().setContextClassLoader(childClassLoader);
        Log log = LogFactory.getLog(JCLTest3.class);
        log.error("hello world");
    }

}

class ChildClassLoader extends URLClassLoader {

    public ChildClassLoader(URL[] urls) {
        super(urls, ClassLoader.getSystemClassLoader());
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            Class c = findLoadedClass(name);
            try{
                c = findClass(name);
                if (resolve) {
                    resolveClass(c);
                }
            }catch(Exception e){
                
            }
            if (c == null) {
                c = super.loadClass(name, resolve);
            }
            return c;
        }
    }
}

private Log createLogFromClass(String logAdapterClassName, //org.apache.commons.logging.impl.Log4JLogger
                               String logCategory,
                               boolean affectState)
    throws LogConfigurationException {
    ...
    //通过logAdapterClassName所制定的类创建的对象，方法返回的结果
    Log logAdapter = null;
    ...
    //获取classloader，这里会返回ChildClassLoader，即main方法中设置的线程上下文加载器
    ClassLoader currentCL = getBaseClassLoader();
    for(;;) {
        try {
            ...
            Class c;
            try {
                //因为ChildClassLoader加载器可以获取到org.apache.commons.logging.impl.Log4JLogger类，正常得到c
                c = Class.forName(logAdapterClassName, true, currentCL);
            } catch (ClassNotFoundException originalClassNotFoundException) {
                ...
            }
            //创建org.apache.commons.logging.impl.Log4JLogger对象，这里o的classloader是ChildClassLoader
            constructor = c.getConstructor(logConstructorSignature);
            Object o = constructor.newInstance(params);

            // 注意下面的注释，因为Log和o的类加载器不一致，所以不进入if分支
            // Note that we do this test after trying to create an instance
            // [rather than testing Log.class.isAssignableFrom(c)] so that
            // we don‘t complain about Log hierarchy problems when the
            // adapter couldn‘t be instantiated anyway.
            if (o instanceof Log) {
                logAdapterClass = c;
                logAdapter = (Log) o;
                break;
            }

            // Oops, we have a potential problem here. An adapter class
            // has been found and its underlying lib is present too, but
            // there are multiple Log interface classes available making it
            // impossible to cast to the type the caller wanted. We
            // certainly can‘t use this logger, but we need to know whether
            // to keep on discovering or terminate now.
            //
            // The handleFlawedHierarchy method will throw
            // LogConfigurationException if it regards this problem as
            // fatal, and just return if not.
            // 根据allowFlawedHierarchy参数判断是否抛出LogConfigurationException，如果不抛异常，只是简单return，进入下一个循环
            handleFlawedHierarchy(currentCL, c);
        } catch (NoClassDefFoundError e) {
            ...
            break;
        } catch (ExceptionInInitializerError e) {
            ...
            break;
        } catch (LogConfigurationException e) {
            // call to handleFlawedHierarchy above must have thrown
            // a LogConfigurationException, so just throw it on
            throw e;
        } catch (Throwable t) {
            ...
        }

        if (currentCL == null) {
            break;
        }

        // try the parent classloader
        // currentCL = currentCL.getParent();
        currentCL = getParentClassLoader(currentCL);
    }
    ...
    return logAdapter;
}

package me.likeyao.slf4j.logger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SLF4JTest {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(SLF4JTest.class);
        logger.error("hello world");
    }
}

    if (tagName.equals(CATEGORY) || tagName.equals(LOGGER)) {
      parseCategory(currentElement);
    } else if (tagName.equals(ROOT_TAG)) {
      parseRoot(currentElement);
    } else if(tagName.equals(RENDERER_TAG)) {
      parseRenderer(currentElement);
    } else if(tagName.equals(THROWABLE_RENDERER_TAG)) {
        if (repository instanceof ThrowableRendererSupport) {
            ThrowableRenderer tr = parseThrowableRenderer(currentElement);
            if (tr != null) {
                ((ThrowableRendererSupport) repository).setThrowableRenderer(tr);
            }
        }
    } else if (!(tagName.equals(APPENDER_TAG)
            || tagName.equals(CATEGORY_FACTORY_TAG)
            || tagName.equals(LOGGER_FACTORY_TAG))) {
        quietParseUnrecognizedElement(repository, currentElement, props);
    }

<logger name="me.likeyao" additivity="false">     
    <level value="WARN" />     
    <appender-ref ref="CONSOLE" />     
</logger>

synchronized(ht) {
      Object o = ht.get(key);
      if(o == null) {
        logger = factory.makeNewLoggerInstance(name);
        logger.setHierarchy(this);
        ht.put(key, logger);
        updateParents(logger);
        return logger;
      } else if(o instanceof Logger) {
        return (Logger) o;
      } else if (o instanceof ProvisionNode) {
        //System.out.println("("+name+") ht.get(this) returned ProvisionNode");
        logger = factory.makeNewLoggerInstance(name);
        logger.setHierarchy(this);
        ht.put(key, logger);
        updateChildren((ProvisionNode) o, logger);
        updateParents(logger);
        return logger;
      }
      else {
        // It should be impossible to arrive here
        return null;  // but let‘s keep the compiler happy.
      }
}

    // if the desired logger does not exist, them create all the loggers
    // in between as well (if they don‘t already exist)
    String childName;
    while (true) {
      int h = LoggerNameUtil.getSeparatorIndexOf(name, i);
      if (h == -1) {
        childName = name;
      } else {
        childName = name.substring(0, h);
      }
      // move i left of the last point
      i = h + 1;
      synchronized (logger) {
        childLogger = logger.getChildByName(childName);
        if (childLogger == null) {
          childLogger = logger.createChildByName(childName);
          loggerCache.put(childName, childLogger);
          incSize();
        }
      }
      logger = childLogger;
      if (h == -1) {
        return childLogger;
      }
    }