Java日志-Log4j源码分析

static public void configure() {
    Logger root = Logger.getRootLogger();
    
    // 设置RootLogger的Appender为ConsoleAppender
    // 设置Layout为PatternLayout
    root.addAppender(new ConsoleAppender(
        new PatternLayout(PatternLayout.TTCC_CONVERSION_PATTERN)));
}

static final String DEFAULT_CONFIGURATION_FILE = "log4j.properties";
static final String DEFAULT_XML_CONFIGURATION_FILE = "log4j.xml";

static {
    // 实例化Hierarchy，设置RootLogger，并关联到LogManager上    
    // 这里新建RootLogger设置的日志级别为DEBUG，也就是说如果你在日志中没有配置RootLogger，则他的日志级别为DEBUG
    Hierarchy h = new Hierarchy(new RootLogger((Level) Level.DEBUG));
    repositorySelector = new DefaultRepositorySelector(h);
   
    // 从classpath中获取log4j.xml文件
    // 如果不存在，则尝试获取log4j.properties文件
    URL url = null;
    url = Loader.getResource(DEFAULT_XML_CONFIGURATION_FILE);
    if (url == null) {
        url = Loader.getResource(DEFAULT_CONFIGURATION_FILE);
    }
    if (url != null) {
        try {
            // 配置文件存在，进入配置文件解析流程
            OptionConverter.selectAndConfigure(url, configuratorClassName,
                                               LogManager.getLoggerRepository());
        } catch (NoClassDefFoundError e) {
            LogLog.warn("Error during default initialization", e);
        }
    } else {
        LogLog.debug("Could not find resource: [" + configurationOptionStr + "].");
    }
}

static public void selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy) {
    Configurator configurator = null;
    String filename = url.getFile();

    // 如果是xml文件，使用DOMConfigurator类
    if (clazz == null && filename != null && filename.endsWith(".xml")) {
        clazz = "org.apache.log4j.xml.DOMConfigurator";
    }

    if (clazz != null) {
        LogLog.debug("Preferred configurator class: " + clazz);
        configurator = (Configurator) instantiateByClassName(clazz,
                                                             Configurator.class,
                                                             null);
        if (configurator == null) {
            LogLog.error("Could not instantiate configurator [" + clazz + "].");
            return;
        }
    } else {
        // 其他情况使用PropertyConfigurator类
        configurator = new PropertyConfigurator();
    }

    configurator.doConfigure(url, hierarchy);
}

public void doConfigure(Properties properties, LoggerRepository hierarchy) {
    // ...

    // 设置RootLogger
    configureRootCategory(properties, hierarchy);
    // 设置LoggerFactory，基本用不上
    configureLoggerFactory(properties);
    // 设置其他Logger
    parseCatsAndRenderers(properties, hierarchy);
}

// org.apache.log4j.LogManager#getLogger(java.lang.Class)
public static Logger getLogger(final Class clazz) {
    // 获取日志仓库，通过日志仓库获取Logger
    return getLoggerRepository().getLogger(clazz.getName());
}

// org.apache.log4j.Hierarchy#getLogger(java.lang.String, org.apache.log4j.spi.LoggerFactory)
public Logger getLogger(String name, LoggerFactory factory) {
    // 保存在Hashtable中的Key对象
    CategoryKey key = new CategoryKey(name);
    Logger logger;

    // 获取ht的锁，串行化getLogger流程
    synchronized (ht) {
        Object o = ht.get(key);
        
        if (o == null) {
            // 1. Hashtable中没有该Logger，新建Logger
            // 新建后的Logger需要关联好其父Logger，
            // 如果没有发现父Logger配置，则其父Logger为RootLogger
            logger = factory.makeNewLoggerInstance(name);
            logger.setHierarchy(this);
            ht.put(key, logger);
            updateParents(logger);
            return logger;
        } else if (o instanceof Logger) {
            // 2. Hashtable中已经有缓存该Logger，直接返回
            return (Logger) o;
        } else if (o instanceof ProvisionNode) {
            // 3. Hashtable中存在该name的ProvisionNode对象
            // ProvisionNode对象是一个占位对象，比如配置了x.y Logger，
            // 在初始化这个Logger时，会去寻找x Logger，但是x Logger不存在，
            // 这个时候就会新建一个ProvisionNode对象，保存x对应的所有子Logger，
            // 如果后续配置上x Logger，则可以通过ProvisionNode中的信息，建立x Logger
            // 与所有其子Logger的父子关系
            logger = factory.makeNewLoggerInstance(name);
            logger.setHierarchy(this);
            ht.put(key, logger);
            updateChildren((ProvisionNode) o, logger);
            updateParents(logger);
            return logger;
        } else {
            // 不会进入的分支
            return null;
        }
    }
}

public void debug(Object message) {
    // 判断全局日志级别，全局日志级别由配置项log4j.threshold设置
    if (repository.isDisabled(Level.DEBUG_INT))
        return;
    // 判断该Logger的日志级别，如果该Logger没有设置level，则查询父Logger的level，直到RootLogger
    if (Level.DEBUG.isGreaterOrEqual(this.getEffectiveLevel())) {
        forcedLog(FQCN, Level.DEBUG, message, null);
    }
}

protected void forcedLog(String fqcn, Priority level, Object message, Throwable t) {
    callAppenders(new LoggingEvent(fqcn, this, level, message, t));
}

public void callAppenders(LoggingEvent event) {
    int writes = 0;

    // 遍历处理该Logger，与其父Logger
    for (Category c = this; c != null; c = c.parent) {
        synchronized (c) {
            if (c.aai != null) {
                // 调用Logger关联的所有Appender进行输出
                writes += c.aai.appendLoopOnAppenders(event);
            }
            
            // 如果设置additivity=false，则不会调用父Logger！
            if (!c.additive) {
                break;
            }
        }
    }

    if (writes == 0) {
        repository.emitNoAppenderWarning(this);
    }
}

public class WriterAppender extends AppenderSkeleton {
    protected QuietWriter qw;
    
    // 每次输出日志，是否调用Writer的flush方法。默认是每次都会调用
    protected boolean immediateFlush = true;

    protected void subAppend(LoggingEvent event) {
        // 使用layout格式化消息，然后调用Writer的write方法输出日志
        this.qw.write(this.layout.format(event));
        
        // 判断是否设置了每次都调用flush方法，如果设置了，则调用flush方法
        if (shouldFlush(event)) {
            this.qw.flush();
        }
    }
}

public class FileAppender extends WriterAppender {

    // 是否使用缓冲IO，默认为false
    protected boolean bufferedIO = false;

    public synchronized void setFile(String fileName, boolean append, boolean bufferedIO, int bufferSize)
        throws IOException {

        // 如果使用缓冲IO，就不需要每次flush
        if (bufferedIO) {
            setImmediateFlush(false);
        }

        reset();
        FileOutputStream ostream = null;
        try {
            ostream = new FileOutputStream(fileName, append);
        } catch (FileNotFoundException ex) {
            // ...
        }
        
        // 用FileOutputStream新建Writer，核心逻辑是new OutputStreamWriter()
        Writer fw = createWriter(ostream);
        
        // 如果配置指定要使用缓冲IO，则使用BufferedWriter进行内存缓冲
        if (bufferedIO) {
            fw = new BufferedWriter(fw, bufferSize);
        }
        this.setQWForFiles(fw);
        this.fileName = fileName;
        this.fileAppend = append;
        this.bufferedIO = bufferedIO;
        this.bufferSize = bufferSize;
        writeHeader();
    }
}