源码赏析之深入了解log4j的LogManager类

    在上一篇博文中对log4j的结构有了一定的了解，这一篇就深入地了解一下其中的LogManager类。首先，先了解一下与LogManager相关的类结构；然后，再仔细地说明每个类的作用及其之间的关系。

1       类图

 

       图中的方框代表类，圆圈代表接口，实线箭头代表关联关系（箭头的一方为非箭头一方的属性），虚线箭头代表依赖关系（箭头的一方为非箭头一方的方法参数或局部变量），实线三角箭头表示继承关系。

从图中可知，LogManager类有RepositorySelector属性和LoggerRepository属性，并且依赖于Configurator接口。LoggerRepository类有LoggerFactory属性。DefaultLoggerFactory类有Logger属性。接下来简要介绍一下这些类和接口的作用。

LogManager类将Configurator和LoggerRepository整合在一起，它在初始化的时候（static）找到Log4J配置文件，并且将其解析到LoggerRepository中。

Configurator用来处理相关的配置文件。Log4J支持两种配置文件：properties文件和xml文件。

RepositorySelector负责缓存和管理LoggerRepository对象。

LoggerRepository是一个Logger的容器，它会调用LoggerFactory创建Logger并缓存Logger实例，从而具有相同名字的Logger实例不会多次创建，以提高性能。调用Configurator对配置文件进行解析，并将解析后的信息添加到LoggerRepository中。同时它也维护了Logger之间的关系，因为在Log4J中，所有Logger都组装成以RootLogger为根的一棵树，树的层次由Logger的Name来决定，其中以”.”分隔。

Hierarchy是Log4J中默认对LoggerRepository的实现类，它用于表达其内部的Logger是以层次结构存储的。在对LoggerRepository接口的实现中，getLogger()方法是其最核心的实现。

2       RootLogger类

       在Log4J中，所有Logger都组装成以RootLogger为根的一棵树。

public final class RootLogger extends Logger { 

  /**

   * 使用日志级别来构造一个日志记录器，记录器名称默认为root。

   */

  public RootLogger(Level level) {

    super("root");

    setLevel(level);

  }

}

3       LoggerFactory类

        这里使用了创建型设计模式的工厂(Factory)模式。所有需要创建新Logger的方法都可以调用该接口的makeNewLoggerInstance方法。

/**

 *实现该接口可以创建新的日志记录器实例。

 */

public interface LoggerFactory {

  public Logger makeNewLoggerInstance(String name);

}

4      LoggerFactory的实现类

       该实现类为DefaultLoggerFactory。

public final class DefaultLoggerFactory implements LoggerFactory {

  public DefaultLoggerFactory() {}

  public Logger makeNewLoggerInstance(String name) {

    return new Logger(name);

  }

}

5       Configurator类

        Configurator用来处理相关的配置文件。Log4J支持两种配置文件：properties文件和xml文件。如下是配置器接口：

public interface Configurator {

}

6       Configurator的抽象实现类

        该抽象实现类是ConfiguratorBase类。

/**

 * 该类包含了一个大部分配置类都需要的功能。

 */

abstract public class ConfiguratorBase implements Configurator {

}

7       ConfiguratorBase的property实现类

       该实现类是PropertyConfigurator类，负责对property属性文件进行解析。

public class PropertyConfigurator extends ConfiguratorBase

    implements ConfiguratorEx {

}

8       ConfiguratorBase的XML实现类

    该实现类是JoranConfigurator类。负责对XML配置文件进行解析。

public class JoranConfigurator extends ConfiguratorBase

    implements ConfiguratorEx {

}

9       LoggerRepository接口

        LoggerRepository它是一个Logger的容器，它会调用LoggerFactory创建Logger并缓存Logger实例，从而具有相同名字的Logger实例不会多次创建，以提高性能。调用Configurator对配置文件进行解析，并将解析后的信息添加到LoggerRepository中。

        同时它也维护了Logger之间的关系，因为在Log4J中，所有Logger都组装成以RootLogger为根的一棵树，树的层次由Logger的Name来决定，其中以”.”分隔。

        除此之外，它还有一个Threshold属性，用于过滤所有在Threshold级别以下的日志。以及其他和Logger操作相关的方法和属性。

public interface LoggerRepository {

  // 添加一个事件到repository.

  public void addHierarchyEventListener(HierarchyEventListener listener);

  public void setThreshold(Level level);

  public void setThreshold(String val);

  public Level getThreshold();

  public Logger getLogger(String name);

  public Logger getLogger(String name, LoggerFactory factory);

  public Logger getRootLogger();

  public abstract Logger exists(String name);

  public abstract void shutdown();

  public Enumeration getCurrentLoggers();

  public abstract void fireAddAppenderEvent(Category logger, Appender appender);

  public abstract void resetConfiguration();

}

10             LoggerRepository的子接口

public interface LoggerRepositoryEx extends LoggerRepository {

  void addLoggerRepositoryEventListener(LoggerRepositoryEventListener listener);

  void removeLoggerRepositoryEventListener(LoggerRepositoryEventListener listener);

  void addLoggerEventListener(LoggerEventListener listener);

  void removeLoggerEventListener(LoggerEventListener listener);

  String getName();

  void setName(String repoName);

  void fireRemoveAppenderEvent(Category logger, Appender appender);

  void fireLevelChangedEvent(Logger logger);

  void fireConfigurationChangedEvent();

  PluginRegistry getPluginRegistry();

  Map getProperties();

  String getProperty(String key);

  void setProperty(String key, String value);

  void setLoggerFactory(LoggerFactory loggerFactory);

  LoggerFactory getLoggerFactory();

}

11            LoggerRepositoryEx的实现类

        该实现类是Hierarchy类。

        Hierarchy是Log4J中默认对LoggerRepository的实现类，它用于表达其内部的Logger是以层次结构存储的。在对LoggerRepository接口的实现中，getLogger()方法是其最核心的实现。

Hierarchy中用一个Hashtable来存储所有Logger实例，它以CategoryKey作为key，Logger作为value，其中CategoryKey是对Logger中Name字符串的封装，之所以要引入这个类是出于性能考虑，因为它会缓存Name字符串的hash code，这样在查找过程中计算hash code时就可以直接取得而不用每次都计算。

class CategoryKey {

  String name;

  int hashCache;

  CategoryKey(String name) {

    this.name = name;

    hashCache = name.hashCode();

  }

}

        getLogger()方法首先根据传入name创建CategoryKey实例，而后从缓存ht字段中查找：

1.       如果找到对应的Logger实例，则直接返回该实例。

2.       如果没有找到任何实例，则使用LoggerFactory创建新的Logger实例，并将该实例缓存到ht集合中，同时更新新创建Logger实例的parent属性。更新parent属性最简单的做法是从后往前以’.’为分隔符截取字符串，使用截取后的字符串从ht集合中查找是否存在Logger实例，如果存在，则新创建的Logger实例的parent即为找到的实例，若在整个遍历过程中都没有找到相应的parent实例，则其parent实例为root。然而如果一个“x.y.z.w”Logger起初的parent设置为root，而后出现“x.y.z”Logger实例，那么就需要更新“x.y.z.w”Logger的parent为“x.y.z”Logger实例，此时就会遇到一个如何找到在集合中已经存在的“x.y.z”Logger实例子节点的问题。当然一种简单的做法是遍历ht集合中所有实例，判断那个实例是不是“x.y.z”Logger实例的子节点，是则更新其parent节点。由于每次的遍历会引起一些性能问题，因而Log4J使用ProvisionNode事先将所有的可能相关的子节点保存起来，并将ProvisionNode实例添加到ht集合中，这样只要找到对应的ProvisionNode实例，就可以找到所有相关的子节点了。比如对“x.y.z.w”Logger实例，它会产生三个ProvisionNode实例（当然如果相应的实例已经存在，则直接添加而无需创建，另外，如果相应节点已经是Logger实例，那么将“x.y.z.w”Logger实例的parent直接指向它即可）：ProvisionNode(“x”), ProvisionNode(“x.y”), ProvisionNode(“x.y.z”)，他们都存储了“x.y.z.w”Logger实例作为其子节点。

public class Hierarchy implements LoggerRepositoryEx, RendererSupport {

  private LoggerFactory loggerFactory;

  private final ArrayList repositoryEventListeners;

  private final ArrayList loggerEventListeners;

  String name;

  Hashtable ht;  // Loggers所在的Hashtable.

  Logger root;  // Root logger.

  /**

   * 构造一个logger hierarchy.

   */

  public Hierarchy(final Logger rootLogger) {

    ht = new Hashtable();

    repositoryEventListeners = new ArrayList(1);

    loggerEventListeners = new ArrayList(1);

    this.root = rootLogger;

    this.objectMap = new HashMap();

    // Enable all level levels by default.

    setThreshold(Level.ALL);

    this.root.setHierarchy(this);

    rendererMap = new RendererMap();

    rendererMap.setLoggerRepository(this);

    properties = new Hashtable();

    loggerFactory = new DefaultLoggerFactory();

  }

  public Logger getLogger(final String loggerName) {

    return getLogger(loggerName, loggerFactory);

  }

  public Logger getLogger(final String loggerName, final LoggerFactory factory) {

    CategoryKey key = new CategoryKey(loggerName);

    Logger logger;

    synchronized (ht) {

      Object o = ht.get(key);

      if (o == null) {

        LogLog.debug("Creating new logger [" + loggerName + "] in repository [" + getName() + "].");

        logger = factory.makeNewLoggerInstance(loggerName);

        logger.setHierarchy(this);

        ht.put(key, logger);

        updateParents(logger);

        return logger;

      } else if (o instanceof Logger) {

          LogLog.debug("Returning existing logger [" + loggerName + "] in repository [" + getName() + "].");

          return (Logger) o;

      } else if (o instanceof ProvisionNode) {

        logger = factory.makeNewLoggerInstance(loggerName);

        logger.setHierarchy(this);

        ht.put(key, logger);

        updateChildren((ProvisionNode) o, logger);

        updateParents(logger);

        return logger;

      } else {

        // 代码运行时不会到达这里。

        return null; // 但是这样可以避免编译器告警。

      }

    }

  }

}

12             RepositorySelector接口

    RepositorySelector负责缓存和管理LoggerRepository对象。

public interface RepositorySelector {

  public LoggerRepository getLoggerRepository();

}

13             RepositorySelector的子接口

        该子接口为RepositorySelectorEx 接口。

public interface RepositorySelectorEx extends RepositorySelector {

  LoggerRepository detachRepository(String name);

}

14             RepositorySelectorEx的实现类

        该实现类为DefaultRepositorySelector类。

public class DefaultRepositorySelector implements RepositorySelectorEx {

  private LoggerRepository defaultRepository;

  public DefaultRepositorySelector(final LoggerRepository repository) {

    if (repository == null)

      throw new NullPointerException();

    this.defaultRepository = repository;

  }

  public LoggerRepository getLoggerRepository() {

    return defaultRepository;

  }

}

15             LogManager类

        LogManager将Configurator和LoggerRepository整合在一起，它在初始化的时候（static）找到Log4J配置文件，并且将其解析到LoggerRepository中。

public class LogManager {

    private static RepositorySelector repositorySelector;

    private static boolean debug = false;

    /**

     * 默认的LoggerRepository实例。

     */

public static final LoggerRepository defaultLoggerRepository;

// 初始化部分。

    static {

       String debugProp = System.getProperty("log4j.debug");

       if(Boolean.valueOf(debugProp).booleanValue()) {

          debug = true;

       }

       if(debug) {

          System.out.println("**Start of LogManager static initializer");

       }

       Hierarchy hierarchy =  new Hierarchy(new RootLogger(Level.DEBUG));

       defaultLoggerRepository = hierarchy;

       hierarchy.setName(Constants.DEFAULT_REPOSITORY_NAME);

       repositorySelector = new DefaultRepositorySelector (defaultLoggerRepository);

       String configuratorClassName = OptionConverter.getSystemProperty(Constants.CONFIGURATOR_CLASS_KEY, null);

       String configurationOptionStr = OptionConverter.getSystemProperty(Constants.DEFAULT_CONFIGURATION_KEY, null);

       if (configurationOptionStr == null) {

          if (Loader.getResource(Constants.DEFAULT_XML_CONFIGURATION_FILE) != null) {

               configurationOptionStr = Constants.DEFAULT_XML_CONFIGURATION_FILE;

            } else if (Loader.getResource(Constants.DEFAULT_CONFIGURATION_FILE) != null) {

               configurationOptionStr = Constants.DEFAULT_CONFIGURATION_FILE;

                }

            }

        if(debug) {

            System.out.println("*** configurationOptionStr=" + configurationOptionStr);

        }

        // 整合Configurator和LoggerRepository部分。

        IntializationUtil.initialConfiguration(defaultLoggerRepository, configurationOptionStr, configuratorClassName);

        String repositorySelectorStr = OptionConverter.getSystemProperty("log4j.repositorySelector", null);

        if (repositorySelectorStr == null) {

            // 不做任何事情, 默认的repository已经在前面配置好了。

        } else if (repositorySelectorStr.equalsIgnoreCase("JNDI")) {

            if(debug) {

                System.out.println("*** Will use ContextJNDISelector **");

            }

            repositorySelector = new ContextJNDISelector();

            guard = new Object();

        } else {

            Object r = OptionConverter.instantiateByClassName(repositorySelectorStr, RepositorySelector.class, null);

            if (r instanceof RepositorySelector) {

                if(debug) {System.out.println("*** Using [" + repositorySelectorStr+ "] instance as repository selector.");

                }

                repositorySelector = (RepositorySelector) r;

                guard = new Object();

            } else {

                if(debug) {System.out.println("*** Could not insantiate [" + repositorySelectorStr+ "] as repository selector.");

                    System.out.println("*** Using default repository selector");

                }

                repositorySelector = new DefaultRepositorySelector(defaultLoggerRepository);

            }

        }

        if(debug) {

            System.out.println("** End of LogManager static initializer");

        }

    }

public static Logger getLogger(String name) {

    return repositorySelector.getLoggerRepository().getLogger(name);

    }

 

}