176 [main] INFO  org.foo.Bar - Located nearest gas station.

private static final Logger log = LogManager.getLogger();

// LoggerManager 的静态初始化代码块
static {
	// *********************** 步骤一 *****************************
	// FACTORY_PROPERTY_NAME = "log4j2.loggerContextFactory";
        final String factoryClassName = managerProps.getStringProperty(FACTORY_PROPERTY_NAME);
        factory = LoaderUtil.newCheckedInstanceOf(factoryClassName, LoggerContextFactory.class);
	
	// *********************** 步骤二 *****************************
	if (factory == null) {
	    final SortedMap<Integer, LoggerContextFactory> factories = new TreeMap<>();
	
	    if (ProviderUtil.hasProviders()) {
	        for (final Provider provider : ProviderUtil.getProviders()) {
	            final Class<? extends LoggerContextFactory> factoryClass = provider.loadLoggerContextFactory();
	            if (factoryClass != null) {
	                factories.put(provider.getPriority(), factoryClass.newInstance());
	            }
	        }
	
	        if (factories.isEmpty()) {
	            // *********************** 步骤三 *****************************
	            factory = new SimpleLoggerContextFactory();
	        } else if (factories.size() == 1) {
	            factory = factories.get(factories.lastKey());
	        } else {
	            factory = factories.get(factories.lastKey());
	        }
	    } else {
	    	// *********************** 步骤三 *****************************
	        factory = new SimpleLoggerContextFactory();
	    }
	}
}

// org.apache.logging.log4j.LogManager.getLogger(Class<?>)
public static Logger getLogger(final Class<?> clazz) {
        final Class<?> cls = callerClass(clazz);
        return getContext(cls.getClassLoader(), false).getLogger(toLoggerName(cls));
}

// Log4jContextFactory.getContext(String, ClassLoader, Object, boolean)

public LoggerContext getContext(final String fqcn, final ClassLoader loader, final Object externalContext,
                                    final boolean currentContext) {
    // selector 为 ClassLoaderContextSelector，下文有介绍
    final LoggerContext ctx = selector.getContext(fqcn, loader, currentContext);
    if (externalContext != null && ctx.getExternalContext() == null) {
        ctx.setExternalContext(externalContext);
    }
    // 刚初始化后的 LoggerContext 需调用 start 方法进配置的加载
    if (ctx.getState() == LifeCycle.State.INITIALIZED) {
        ctx.start();
    }
    return ctx;
}

//org.apache.logging.log4j.core.selector.BasicContextSelector
// 通用的 LoggerContext
private static final LoggerContext CONTEXT = new LoggerContext("Default");
    
public LoggerContext getContext(final String fqcn, final ClassLoader loader, final boolean currentContext) {
	// ThreadLocal 中的 LoggerContext
	final LoggerContext ctx = ContextAnchor.THREAD_CONTEXT.get();
	return ctx != null ? ctx : CONTEXT;
}

//org.apache.logging.log4j.core.selector.ClassLoaderContextSelector
protected static final ConcurrentMap<String, AtomicReference<WeakReference<LoggerContext>>> CONTEXT_MAP =
            new ConcurrentHashMap<>();
// 代码有删减
private LoggerContext locateContext(final ClassLoader loaderOrNull, final URI configLocation) {
    final ClassLoader loader = loaderOrNull != null ? loaderOrNull : ClassLoader.getSystemClassLoader();
    // 将 loader 对象转化为 Map 的键值字符串，即对象存储地址的十六进制字符串
    final String name = toContextMapKey(loader);
    // 根据转化的键值在 Map 中查找是否存在，存在就返回，不存在就创建后添加入 MAP
    AtomicReference<WeakReference<LoggerContext>> ref = CONTEXT_MAP.get(name);
    if (ref == null) {
        // ★★★ 没找到创建后，添加到 Map ★★★
        LoggerContext ctx = createContext(name, configLocation);
        final AtomicReference<WeakReference<LoggerContext>> r = new AtomicReference<>();
        r.set(new WeakReference<>(ctx));
        CONTEXT_MAP.putIfAbsent(name, r);
        ctx = CONTEXT_MAP.get(name).get().get();
        return ctx;
    }
    final WeakReference<LoggerContext> weakRef = ref.get();
    LoggerContext ctx = weakRef.get();
    // 找到就返回
    if (ctx != null) {
        return ctx;
    }
    ctx = createContext(name, configLocation);
    ref.compareAndSet(weakRef, new WeakReference<>(ctx));
    return ctx;
}

/**
 * LoggerContext 实现 LifeCycle2 生命周期接口
 * 而 LifeCycle2 继承 LifeCycle，它定义了如下声明周期状态
 */
// org.apache.logging.log4j.core.LifeCycle.State
enum State {
    /** 对象正在初始化. */
    INITIALIZING,
    /** 初始化完成，还没启动. */
    INITIALIZED,
    /** 正在调用 start 方法，启动中. */
    STARTING,
    /** start 方法执行完毕，已启动. */
    STARTED,
    /** stop 方法执行中，停止中. */
    STOPPING,
    /** stop 方法执行完毕，已停止 */
    STOPPED
}

// org.apache.logging.log4j.core.LoggerContext.start()
// 代码有删减
public void start() {
    if (configLock.tryLock()) {
        try {
            if (this.isInitialized() || this.isStopped()) {
            	// 生命周期调整为 启动中 状态
                this.setStarting();
                // 加载配置
                reconfigure();
                if (this.configuration.isShutdownHookEnabled()) {
                    setUpShutdownHook();
                }
                // 启动完毕，生命周期调整为 已启动 状态
                this.setStarted();
            }
        } finally {
            configLock.unlock();
        }
    }
}
// org.apache.logging.log4j.core.LoggerContext.reconfigure(URI)
// 上面的 reconfigure() 方法最终调用到此方法
// 代码有删减
private void reconfigure(final URI configURI) {
    // configURI 此时为 null，故 cl 也为 null
    final ClassLoader cl = ClassLoader.class.isInstance(externalContext) ? (ClassLoader) externalContext : null;
    // ★★★ 委托给 ConfigurationFactory ★★★
    final Configuration instance = ConfigurationFactory.getInstance().getConfiguration(this, contextName, configURI, cl);
    if (instance == null) {
        // 记录异常
    } else {
    	 // 将配置实例赋值给成员变量
        setConfiguration(instance);
    }
}

// org.apache.logging.log4j.core.config.ConfigurationFactory.getInstance()
// 代码有删减
public static ConfigurationFactory getInstance() {
    if (factories == null) {
        LOCK.lock();
        try {
            if (factories == null) {
                final List<ConfigurationFactory> list = new ArrayList<>();
                // ① 系统属性方式收集配置工厂实例
                // CONFIGURATION_FACTORY_PROPERTY = "log4j.configurationFactory"
                final String factoryClass = PropertiesUtil.getProperties().getStringProperty(CONFIGURATION_FACTORY_PROPERTY);
                if (factoryClass != null) {
                    addFactory(list, factoryClass);
                }

                // ② 利用插件管理器搜集注解方式的配置工厂实例
                // CATEGORY = "ConfigurationFactory"
                final PluginManager manager = new PluginManager(CATEGORY);
                /*
                 * 按照下面顺序进行追加合并收集：
                 * 1. 搜寻 CLASSPATH 中的 Log4j2Plugin.dat 插件缓存文件，里面都是 Log4j 内建的插件
                 *  2. 在 OSGi bundles 中搜寻 Log4j2Plugin.dat
                 *  3. 搜寻通过静态的 `addPackage` 方法添加的包中搜寻插件
                 *  4. 搜寻方法参数给定的包列表中的插件
                 */
                manager.collectPlugins();
                final Map<String, PluginType<?>> plugins = manager.getPlugins();
                final List<Class<? extends ConfigurationFactory>> ordered = new ArrayList<>(plugins.size());
                for (final PluginType<?> type : plugins.values()) {
                    try {
                        ordered.add(type.getPluginClass().asSubclass(ConfigurationFactory.class));
                    } catch (final Exception ex) {
                      // 记录异常日志
                    }
                }
                // 插件找到的工厂，按照注解 @Order 的顺序排序，数值越大优先级越高
                Collections.sort(ordered, OrderComparator.getInstance());
                for (final Class<? extends ConfigurationFactory> clazz : ordered) {
                    // 系统属性参数配置的工厂高于插件找到的，由此可知
                    addFactory(list, clazz);
                }
                factories = Collections.unmodifiableList(list);
            }
        } finally {
            LOCK.unlock();
        }
    }
    /* ★★★
     * 返回私有静态内部类 ConfigurationFactory.Factory
     * 由它的 getConfiguration 方法获取 Configuration
     */
    return configFactory;
}

// org.apache.logging.log4j.core.config.ConfigurationFactory.Factory.getConfiguration(LoggerContext, boolean, String)
private Configuration getConfiguration(final LoggerContext loggerContext, final boolean isTest, final String name) {
    final boolean named = Strings.isNotEmpty(name);
    final ClassLoader loader = LoaderUtil.getThreadContextClassLoader();
    // 按照优先级顺序，依次遍历插件工厂寻找与之相对应的配置文件类型，找到立即返回
    for (final ConfigurationFactory factory : getFactories()) {
        String configName;
        final String prefix = isTest ? TEST_PREFIX : DEFAULT_PREFIX;
        final String [] types = factory.getSupportedTypes();
        if (types == null) {
            continue;
        }

        for (final String suffix : types) {
            if (suffix.equals(ALL_TYPES)) {
                continue;
            }
            configName = named ? prefix + name + suffix : prefix + suffix;

            // 根据配置文件名 log4j2.properties 使用 ClassLoader.getResource 的到实际的资源
            final ConfigurationSource source = ConfigurationSource.fromResource(configName, loader);
            if (source != null) {
                if (!factory.isActive()) {
                    // 记录警告信息
                }
                // ★★★ 加载配置的操作交给真正的配置工厂实例 ★★★
                return factory.getConfiguration(loggerContext, source);
            }
        }
    }
    return null;
}

// PropertiesConfigurationFactory.getConfiguration(LoggerContext, ConfigurationSource)
public PropertiesConfiguration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) {
    final Properties properties = new Properties();
    try (final InputStream configStream = source.getInputStream()) {
        // 读取 log4j2.properties
        properties.load(configStream);
    } catch (final IOException ioe) {
        // 记录异常
    }
    // 采用 Builder 模式构建 PropertiesConfiguration
    return new PropertiesConfigurationBuilder()
            .setConfigurationSource(source)
            .setRootProperties(properties)
            .setLoggerContext(loggerContext)
            .build();
}

// org.apache.logging.log4j.core.LoggerContext.reconfigure(URI)
// 代码有删减
private void reconfigure(final URI configURI) {
    final Configuration instance = ConfigurationFactory.getInstance().getConfiguration(this, contextName, configURI, cl);
    if (instance == null) {
        // 记录异常
    } else {
    	 // ★★★ 可不光仅仅是给成员变量赋值 ★★★
        setConfiguration(instance);
    }
}

// LoggerContext.setConfiguration(Configuration)
// 代码有删减
private Configuration setConfiguration(final Configuration config) {
    configLock.lock();
    try {
        // 存档一份当前配置的引用
        final Configuration prev = this.configuration;
        // 给新传入的配置注册一个监听器
        config.addListener(this);
        //★★★ 新配置启动，【已初始化】->【已启动】
        config.start();
        // 将新传入的配置更新为当前的配置
        this.configuration = config;
        // 根据新配置更新所有 Logger 的配置信息
        updateLoggers();
        // 完成后清理旧的配置
        if (prev != null) {
            prev.removeListener(this);
            prev.stop();
        }

        // 触发属性变更事件
        firePropertyChangeEvent(new PropertyChangeEvent(this, PROPERTY_CONFIG, prev, config));

        // AsyncLoggers update their nanoClock when the configuration changes
        Log4jLogEvent.setNanoClock(configuration.getNanoClock());

        return prev;
    } finally {
        configLock.unlock();
    }
}

org.apache.logging.log4j.core.LoggerContext.setConfiguration(Configuration)
  org.apache.logging.log4j.core.config.AbstractConfiguration.start()
    org.apache.logging.log4j.core.config.AbstractConfiguration.initialize()  
      org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration.setup()
        // ① 把 Component组件树 转变为 Node节点树
        org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration.convertToNode(Node, Component)
      org.apache.logging.log4j.core.config.AbstractConfiguration.doConfigure()
        org.apache.logging.log4j.core.config.AbstractConfiguration.createConfiguration(Node, LogEvent)
          // ② Node 节点关联的插件类的具体实例设置到 Node.object 成员变量上
          org.apache.logging.log4j.core.config.Node.setObject(Object)
            org.apache.logging.log4j.core.config.AbstractConfiguration.createPluginObject(PluginType<?>, Node, LogEvent)
              // ③ 解析插件注解，反射调用被 `@PluginFactory` 或 `@PluginBuilderFactory` 注解的方法，得到插件类实例
              org.apache.logging.log4j.core.config.plugins.util.PluginBuilder.build()

// org.apache.logging.log4j.core.LoggerContext.getLogger(String, MessageFactory)
public Logger getLogger(final String name, final MessageFactory messageFactory) {
    // Note: This is the only method where we add entries to the 'loggerRegistry' ivar.
    Logger logger = loggerRegistry.getLogger(name, messageFactory);
    if (logger != null) {
        AbstractLogger.checkMessageFactory(logger, messageFactory);
        return logger;
    }

    logger = newInstance(this, name, messageFactory);
    loggerRegistry.putIfAbsent(name, messageFactory, logger);
    return loggerRegistry.getLogger(name, messageFactory);
}