Log4j2日志框架

log4j2

Apache log4j 2 是对log4j的升级版，参考了logback的一些优秀的设计，并且修复了一些问题

​ 异常处理：logback中，appender中的异常不会被应用感知到，但是在log4j中，提供了一些异常处理机制

​ 性能提升：log4j2相较于log4j和logback 都具有明显的性能提升

​ 自动重载配置，参考了logback的设计，当然会提供自动刷新参数配置，可以动态修改配置而不需要重启应用

​ 无垃圾机制，log4j2 在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致jvm的 gc

pom.xml

<!-- log4j2的门面 -->
   <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-api</artifactId>
       <version>2.13.3</version>
   </dependency>
   <!-- log4j2的实现 -->
   <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-core</artifactId>
       <version>2.13.3</version>
   </dependency>

名词

Logger

 org.apache.logging.log4j
     log4j2他也是一个日志门面，所以也抽象出一个logger接口
/*

这是log4j包中的中心接口。除了配置之外，大多数日志记录操作都是通过这个接口完成的。
获取类的记录器的规范方法是通过{@link LogManager\#getLogger（）}。通常，每个类都以其完全限定的类名（通过{@link LogManager#getLogger（）}方法获得时的默认记录器名称）获得自己的记录器。因此，最简单的使用方法如下：
* <pre><code>
 * public class MyClass {
 //这里其实做了 栈操作，更具运行时的压栈信息找到 当前调用.getLogger()的类
 *     private static final Logger LOGGER = LogManager.getLogger();
 *     // ...
 * }
 * </code></pre>

为了便于过滤、搜索、排序等，通常最好为每个类创建记录器，而不是共享记录器。相反，{@link Marker}应该用于共享的、可过滤的标识。

对于服务提供者实现，建议扩展AbstractLogger类，而不是直接实现这个接口。

从2.4开始，方法被添加到{@code Logger}接口以支持lambda表达式。新方法允许客户端代码延迟地记录消息，而无需显式检查请求的日志级别是否已启用。例如，以前有人会写：
 * <pre><code>
 * // pre-Java 8 style optimization: explicitly check the log level
 * // to make sure the expensiveOperation() method is only called if necessary
 * if (logger.isTraceEnabled()) {
 *     logger.trace(&quot;Some long-running operation returned {}&quot;, expensiveOperation());
 * }
 * </code></pre>
 使用lambda表达式可以获得相同的效果：
 
  * <pre>
 * // Java-8 style optimization: no need to explicitly check the log level:
 * // the lambda expression is not evaluated if the TRACE level is not enabled
 * logger.trace(&quot;Some long-running operation returned {}&quot;, () -&gt; expensiveOperation());
 * </pre>
 
 注意，虽然提供了{@link messagesupplier}，但是使用{@link supplier{@code Supplier<Message>}}的工作原理是一样的。MessageSupplier在2.6中已被弃用，而在2.8.1中未弃用。这些api的匿名类用法应该更倾向于使用Supplier。

 
*/
     
ExtendedLogger:使用有助于实现或扩展{@code Logger}的方法扩展{@code Logger}接口。用户不必使用此接口。

AbstractLogger

implements ExtendedLogger, LocationAwareLogger, Serializable
LocationAwareLogger:接受调用方的位置的 一个 logger

//记录器的基本实现。强烈建议任何记录器实现都扩展这个类。

    
// 实现注意：这个类中的许多方法都针对性能进行了调整。小心修改！
    // 具体来说，保持热字节码的方法是：
    //这在java7和java8 Hotspot虚拟机 的MaxInlineSize阈值范围内，使这些方法成为立即内联的候选方法，而不是等到它们被指定为“足够热”时才使用。
  

    /**
     * Marker for flow tracing.
     */
    public static final Marker FLOW_MARKER = MarkerManager.getMarker("FLOW");

    /**
     * Marker for method entry tracing.
     */
    public static final Marker ENTRY_MARKER = MarkerManager.getMarker("ENTER").setParents(FLOW_MARKER);

    /**
     * Marker for method exit tracing.
     */
    public static final Marker EXIT_MARKER = MarkerManager.getMarker("EXIT").setParents(FLOW_MARKER);

    /**
     * Marker for exception tracing.
     */
    public static final Marker EXCEPTION_MARKER = MarkerManager.getMarker("EXCEPTION");

    /**
     * Marker for throwing exceptions.
     */
    public static final Marker THROWING_MARKER = MarkerManager.getMarker("THROWING").setParents(EXCEPTION_MARKER);

    /**
     * Marker for catching exceptions.
     */
    public static final Marker CATCHING_MARKER = MarkerManager.getMarker("CATCHING").setParents(EXCEPTION_MARKER);

    /**
     * The default MessageFactory class.
     */
    public static final Class<? extends MessageFactory> DEFAULT_MESSAGE_FACTORY_CLASS =
            createClassForProperty("log4j2.messageFactory", ReusableMessageFactory.class,
                    ParameterizedMessageFactory.class);

    /**
     * The default FlowMessageFactory class.
     */
    public static final Class<? extends FlowMessageFactory> DEFAULT_FLOW_MESSAGE_FACTORY_CLASS =
            createFlowClassForProperty("log4j2.flowMessageFactory", DefaultFlowMessageFactory.class);

    private static final long serialVersionUID = 2L;

    private static final String FQCN = AbstractLogger.class.getName();
    private static final String THROWING = "Throwing";
    private static final String CATCHING = "Catching";

    protected final String name;
    private final MessageFactory2 messageFactory;
    private final FlowMessageFactory flowMessageFactory;
    private static ThreadLocal<int[]> recursionDepthHolder = new ThreadLocal<>(); // LOG4J2-1518, LOG4J2-2031
    protected final transient ThreadLocal<DefaultLogBuilder> logBuilder;

StatusLogger

/*
记录日志系统 内部 中发生的事件。默认情况下，只有错误消息被记录到{@link System#err}。通常，Log4j状态记录器是通过Log4j配置文件中的根 {@code<Configuration status=“LEVEL”/>}节点配置的。但是，这可以通过一个名为"{@value SimpleLoggerContext#SYSTEM_PREFIX}StatusLogger.level"的系统属性重写，并且可以与任何Log4j提供程序一起使用。

*/

Logger

 org.apache.logging.log4j.core;
/*

{@link org.apache.logging.log4j.Logger}接口的核心实现。除了提供所有记录器方法的实现之外，这个类还为log4j1.x兼容性以及对与此记录器相关联的{@link org.apache.logging.log4j.core.Filter Filters}和{@link org.apache.logging.log4j.core.Appender Appenders}的访问提供了一些方便的方法。注意，对这些底层对象的访问主要用于单元测试或桥接遗留log4j1.x代码。这个类的未来版本可能包括，也可能不包括被认为不是公共API一部分的各种方法。

TODO:可以将所有isEnabled方法推送到筛选器接口中。不确定是否可以检查消息模式和参数。显著地影响了伐木机的性能。消息模式和参数是必需的，以便可以在全局筛选器中使用。
TODO All the isEnabled methods could be pushed into a filter interface. Not sure of the utility of having isEnabled be able to examine the message pattern and parameters. (RG) Moving the isEnabled methods out of Logger noticeably impacts performance. The message pattern and parameters are required so that they can be used in global filters.

*/

private static final long serialVersionUID = 1L;

    /**
     * Config should be consistent across threads.
     */
    protected volatile PrivateConfig privateConfig;

    // FIXME: ditto to the above
    private final LoggerContext context;

PrivateConfig

每一个logger都内置一个私有配置的对象

protected class PrivateConfig {
        // config fields are public to make them visible to Logger subclasses
        /** LoggerConfig to delegate the actual logging to. */
        public final LoggerConfig loggerConfig; // SUPPRESS CHECKSTYLE
        /** The current Configuration associated with the LoggerConfig. */
        public final Configuration config; // SUPPRESS CHECKSTYLE
        private final Level loggerConfigLevel;
        private final int intLevel;
        private final Logger logger;
        private final boolean requiresLocation;

        public PrivateConfig(final Configuration config, final Logger logger) {
            this.config = config;
            this.loggerConfig = config.getLoggerConfig(getName());
            this.loggerConfigLevel = this.loggerConfig.getLevel();
            this.intLevel = this.loggerConfigLevel.intLevel();
            this.logger = logger;
            this.requiresLocation = this.loggerConfig.requiresLocation();
        }

        public PrivateConfig(final PrivateConfig pc, final Level level) {
            this.config = pc.config;
            this.loggerConfig = pc.loggerConfig;
            this.loggerConfigLevel = level;
            this.intLevel = this.loggerConfigLevel.intLevel();
            this.logger = pc.logger;
            this.requiresLocation = this.loggerConfig.requiresLocation();
        }

        public PrivateConfig(final PrivateConfig pc, final LoggerConfig lc) {
            this.config = pc.config;
            this.loggerConfig = lc;
            this.loggerConfigLevel = lc.getLevel();
            this.intLevel = this.loggerConfigLevel.intLevel();
            this.logger = pc.logger;
            this.requiresLocation = this.loggerConfig.requiresLocation();
        }

        // LOG4J2-151: changed visibility to public
        public void logEvent(final LogEvent event) {
            loggerConfig.log(event);
        }

        boolean filter(final Level level, final Marker marker, final String msg) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Throwable t) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, (Object) msg, t);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object... p1) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p1);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3,
                final Object p4) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3, p4);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3,
                final Object p4, final Object p5) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3, p4, p5);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3,
                final Object p4, final Object p5, final Object p6) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3, p4, p5, p6);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3,
                final Object p4, final Object p5, final Object p6,
                final Object p7) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3, p4, p5, p6, p7);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3,
                final Object p4, final Object p5, final Object p6,
                final Object p7, final Object p8) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3, p4, p5, p6, p7, p8);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final String msg, final Object p0,
                final Object p1, final Object p2, final Object p3,
                final Object p4, final Object p5, final Object p6,
                final Object p7, final Object p8, final Object p9) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, p0, p1, p2, p3, p4, p5, p6, p7, p8,
                        p9);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final CharSequence msg, final Throwable t) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, t);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final Object msg, final Throwable t) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, t);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        boolean filter(final Level level, final Marker marker, final Message msg, final Throwable t) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, msg, t);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

        @Override
        public String toString() {
            final StringBuilder builder = new StringBuilder();
            builder.append("PrivateConfig [loggerConfig=");
            builder.append(loggerConfig);
            builder.append(", config=");
            builder.append(config);
            builder.append(", loggerConfigLevel=");
            builder.append(loggerConfigLevel);
            builder.append(", intLevel=");
            builder.append(intLevel);
            builder.append(", logger=");
            builder.append(logger);
            builder.append("]");
            return builder.toString();
        }
    }

LoggerConfig

/*

过配置创建的Logger对象。
*/

  public static final String ROOT = "root";
    private static LogEventFactory LOG_EVENT_FACTORY = null;

    private List<AppenderRef> appenderRefs = new ArrayList<>();
    private final AppenderControlArraySet appenders = new AppenderControlArraySet();
    private final String name;
    private LogEventFactory logEventFactory;
    private Level level;
    private boolean additive = true;
    private boolean includeLocation = true;
    private LoggerConfig parent;
    private Map<Property, Boolean> propertiesMap;
    private final List<Property> properties;
    private final boolean propertiesRequireLookup;
    private final Configuration config;
    private final ReliabilityStrategy reliabilityStrategy;

‘ReliabilityStrategy

/*

这个接口的实例对象知道如何确保将日志事件传递到适当的附加器，即使在系统处于活动状态时修改配置期间或之后也是如此。
*/

LoggerContext

/*
日志实现的定位点。用于定位日志实现
*/

SimpleLoggerContext：他就是用来获取一个简单logger的 上下文

LoggerContext

org.apache.logging.log4j.core;
extends AbstractLifeCycle
        implements org.apache.logging.log4j.spi.LoggerContext, AutoCloseable, Terminable, ConfigurationListener,
        LoggerContextShutdownEnabled 
            

            
 Terminable: 由提供关闭方法的LoggerContext实现的接口。  
   ConfigurationListener:  用于在配置更改时通知组件的接口。
       LoggerContextShutdownEnabled: 实现此功能的loggerContext是能够注册LoggerContextShutdownAware类。  
/*
LoggerContext是日志记录系统的锚（支持，用于获取logger的）。它维护应用程序请求的所有记录器的列表以及对配置的引用。configration{将包含已配置的记录器、附加器、过滤器等}，并将在重新配置发生时自动更新。




*/

 public static final String PROPERTY_CONFIG = "config";

    private static final Configuration NULL_CONFIGURATION = new NullConfiguration();

    private final LoggerRegistry<Logger> loggerRegistry = new LoggerRegistry<>();
    private final CopyOnWriteArrayList<PropertyChangeListener> propertyChangeListeners = new CopyOnWriteArrayList<>();
    private volatile List<LoggerContextShutdownAware> listeners = null;

    /**
     * The Configuration is volatile to guarantee that initialization of the Configuration has completed before the
     * reference is updated.
     */
    private volatile Configuration configuration = new DefaultConfiguration();
    private static final String EXTERNAL_CONTEXT_KEY = "__EXTERNAL_CONTEXT_KEY__";
    private ConcurrentMap<String, Object> externalMap = new ConcurrentHashMap<>();
    private String contextName;
    private volatile URI configLocation;
    private Cancellable shutdownCallback;

    private final Lock configLock = new ReentrantLock();

AsyncLoggerContext

/*
{@code LoggerContext}，用于创建{@code AsyncLogger}对象。


*/

private final AsyncLoggerDisruptor loggerDisruptor;

LoggerRegistry

//{@code LoggerContext}实现使用的便利类。

   private static final String DEFAULT_FACTORY_KEY = AbstractLogger.DEFAULT_MESSAGE_FACTORY_CLASS.getName();
    private final MapFactory<T> factory;
    private final Map<String, Map<String, T>> map;
就是容器用于存储 logger对象和 真正获取logger对象

MarkerManager

//应用程序使用标记管理器创建标记。此管理器创建的所有标记都是不可变的。


   public static Marker getMarker(final String name) {
        Marker result = MARKERS.get(name);
        if (result == null) {
            MARKERS.putIfAbsent(name, new Log4jMarker(name));
            result = MARKERS.get(name);
        }
        return result;
    }


Log4jMarker：考虑到这个类是私有的，它是公共的，以满足Jackson对XML和JSON IO的要求。实际的Marker实现。
内部注意：如果{@code org.apache.logging.log4j.core.jackson.MarkerMixIn}类被移到这个包中，我们可以将这个类包设为私有的，而不是公共的，当然会保留在它当前的模块中。

Marker

 org.apache.logging.log4j;


/*
Marker是用于向日志消息添加易于筛选的信息的对象。


Markers可以是分层的-每个标记都可以有一个父级。这样就可以将大的类别细分为更具体的类别。例如，一个名为“Error”的标记和名为“SystemError”和“ApplicationError”的子级。

*/

Interface for constructing log events before logging them. Instances of LogBuilders should only be created by calling one of the Logger methods that return a LogBuilder.

MessageFactory

/*

创建消息。实现可以提供不同的消息格式语法。

*/

MessageFactory2：创建消息。实现可以提供不同的消息格式语法。
    
    
AbstractMessageFactory：为带有默认实现的{@link MessageFactory2}实现提供抽象超类（扩展名为{@link MessageFactory}）。这个类是不变的。实施者注意事项：当子类能够最有效地构建{@link MessageFactory2}实例时，它们可以实现{@linkmessagefactory2}方法。如果子类不实现{@link MessageFactory2}方法，则这些调用将通过该类中的{@link#newMessage（String，Object…）}进行路由。

Message

/*

一个接口，用于各种可以记录的消息实现。消息可以充当对象的包装器，这样用户就可以在必要时控制将对象转换为字符串，而不需要复杂的格式化程序，并且可以根据运行时可用的信息（如系统的区域设置）来操作消息。

自定义消息实现应考虑实现{@link StringBuilderFormattable}接口，以实现更高效的处理。如果消息实现StringBuildPerformAttable，则无垃圾 Layouts 将调用{@link StringBuildPerformAttable#formatTo（StringBuilder）formatTo（StringBuilder）}，而不是{@link Message#getFormattedMessage（）}。

注意：不应将消息对象视为线程安全的，也不应假定它们即使在同一线程上也可以安全地重用。日志记录系统可以向消息对象提供信息，消息可能会排队等待异步传递。因此，在消息作为记录器方法的参数传递之后，应用程序应该避免对消息对象的任何修改。


*/

LifeCycle

/*
所有合适的Java框架都实现某种对象生命周期。在Log4j中，处理对象生命周期上下文的主接口是这个。默认情况下，对象首先以{@link State#INITIALIZED}状态启动，以指示类已加载。从这里开始，调用{@link#start（）}方法会将此状态更改为{@link state#STARTING}。成功启动后，此状态将更改为{@link state#started}。当调用{@link#stop（）}时，它将进入{@link State#STOPPING}状态。成功停止后，它将进入{@link State#stopped}状态。在大多数情况下，实现类应该将它们的{@link state}存储在{@code volatile}字段中，或者存储在{@link java.util.concurrent.atomic.AtomicReference}中，这取决于同步和并发需求。

*/

LifeCycle2: 扩展生命周期界面。此接口应与3.0中的超级接口合并。

Filterable

extends LifeCycle 
/*
接口由允许进行筛选的类实现。
扩展{@link LifeCycle}，因为过滤器有生命周期。
*/

Configuration

extends Filterable
//必须实现以创建配置的接口。
//建议自定义实现来扩展{@linkabstractconfiguration}。

AbstractConfiguration  extends AbstractFilterable implements Configuration:基本配置。许多配置实现都会扩展这个类。
    AbstractFilterable   extends AbstractLifeCycle implements Filterable:通过允许类包含筛选器来增强类。 
    	AbstractLifeCycle implements LifeCycle2

AbstractConfiguration

/*

基本配置。许多配置实现都会扩展这个类。
*/
包含已配置的记录器、附加器、过滤器
 private static final int BUF_SIZE = 16384;

    /**
     * The root node of the configuration.
     */
    protected Node rootNode;

    /**
     * Listeners for configuration changes.
     */
    protected final List<ConfigurationListener> listeners = new CopyOnWriteArrayList<>();

    /**
     * Packages found in configuration "packages" attribute.
     */
    protected final List<String> pluginPackages = new ArrayList<>();

    /**
     * The plugin manager.
     */
    protected PluginManager pluginManager;

    /**
     * Shutdown hook is enabled by default.
     */
    protected boolean isShutdownHookEnabled = true;

    /**
     * Shutdown timeout in milliseconds.
     */
    protected long shutdownTimeoutMillis = 0;

    /**
     * The Script manager.
     */
    protected ScriptManager scriptManager;

    /**
     * The Advertiser which exposes appender configurations to external systems.
     */
    private Advertiser advertiser = new DefaultAdvertiser();
    private Node advertiserNode = null;
    private Object advertisement;
    private String name;
    private ConcurrentMap<String, Appender> appenders = new ConcurrentHashMap<>();
    private ConcurrentMap<String, LoggerConfig> loggerConfigs = new ConcurrentHashMap<>();
    private List<CustomLevelConfig> customLevels = Collections.emptyList();
    private final ConcurrentMap<String, String> propertyMap = new ConcurrentHashMap<>();
    private final StrLookup tempLookup = new Interpolator(propertyMap);
    private final StrSubstitutor subst = new StrSubstitutor(tempLookup);
    private LoggerConfig root = new LoggerConfig();
    private final ConcurrentMap<String, Object> componentMap = new ConcurrentHashMap<>();
    private final ConfigurationSource configurationSource;
    private final ConfigurationScheduler configurationScheduler = new ConfigurationScheduler();
    private final WatchManager watchManager = new WatchManager(configurationScheduler);
    private AsyncLoggerConfigDisruptor asyncLoggerConfigDisruptor;
    private NanoClock nanoClock = new DummyNanoClock();
    private final WeakReference<LoggerContext> loggerContext;

PluginManager

/*
加载并管理所有插件。

 private static final CopyOnWriteArrayList<String> PACKAGES = new CopyOnWriteArrayList<>();
    private static final String LOG4J_PACKAGES = "org.apache.logging.log4j.core";

    private static final Logger LOGGER = StatusLogger.getLogger();

    private Map<String, PluginType<?>> plugins = new HashMap<>();
    private final String category;


*/

PluginType

/*
插件描述符。这是一个memento对象，用于插件注释与其注释类配对。


*/

private final PluginEntry pluginEntry;
    private final Class<T> pluginClass;
    private final String elementName;

PluginEntry

//用于将插件项存储到缓存文件的Memento对象。
 private String key;
    private String className;
    private String name;
    private boolean printable;
    private boolean defer;
    private transient String category;

AutoCloseable

java.lang
/*
一个在关闭之前可以保存资源（如文件或套接字句柄）的对象。当退出{@code try}-with-resources块时，{@code AutoCloseable}对象的{@link\#close（）}方法将自动调用，该资源块已在资源规范头中声明了该对象。否则会导致资源耗尽。


基类实现AutoCloseable是可能的，事实上也是常见的，即使它的所有子类或实例都包含可发布的资源。 
对于必须完全通用地操作的代码，或者当已知{@code AutoCloseable}实例需要资源释放时，建议使用{@code try}-with-resource 构造。但是，当使用{@link之类的工具时java.util.stream.Stream}同时支持基于I/O和非I/O的表单，{@code try}-with resources块在使用非基于I/O的表单时通常是不必要的。

然而，当使用同时支持基于I/O和非I/O形式的{@link java.util.stream.Stream}之类的工具时，{@code try}-with-resources块在使用非基于I/O的形式时通常是不必要的。


*/
    
  关闭此资源，释放底层资源。  
  Closes this resource, relinquishing any underlying resources. 此方法在{@codetry}-with-resources语句管理的对象上自动调用。虽然此接口方法声明为抛出{@code Exception}，但强烈建议实现者声明{@code close}方法的具体实现来引发更具体的异常，或者在close操作不能失败时根本不抛出异常。
   关闭操作可能失败的情况需要实施者仔细关注。强烈建议在抛出异常之前，放弃底层资源并在内部将资源标记为关闭。 
   {@code close}方法不太可能被多次调用，因此这可以确保及时释放资源。此外，它还减少了当资源包装或被其他资源包装时可能出现的问题。
  强烈建议此接口的实现者不要使用{@code close}方法抛出{@link InterruptedException}。此异常与线程的中断状态交互，如果{@code InterruptedException}是{@linkplain Throwable#addSuppressed suppressed}，则很可能发生运行时错误行为。
    更一般地说，如果抑制异常会导致问题，则AutoCloseable.close方法不应抛出它。
    
注意，与{@link java.io.Closeable}的{@link java.io.Closeable#close close}  方法不同，这个{@code close}方法不是的幂等的。换句话说，多次调用这个{@codeclose}方法可能会产生一些可见的副作用，这与{@code Closeable.close}不同，{@code Closeable.close}被要求多次调用时没有任何效果。
但是，强烈建议此接口的实现者使其{@code close}方法幂等。
        void close() throws Exception;s

Provider

/*
log4j2提供程序的模型类。此类中的属性对应于{@code META-INF/log4j-provider.properties}文件中使用的属性。注意，这个类是由Log4j自动创建的，不应该由提供者使用。



*/
其实就是使用了服务自动发现
    
    ServiceLoader.load 这个东西 你指定一个类对象，他就会去 META-INFO/service/ 下面 找 类对象名字的文件，这个文件指定类对象的实现类

    
    这里这个Provider的具体实现就是这么来的，这个对象指定了 log4j2工厂的类型，所以工厂的获取在这里

LoggerContextFactory

/*
由此子类实例创建{@link LoggerContext}对象的工厂实现。

*/

Log4jContextFactory

implements LoggerContextFactory, ShutdownCallbackRegistry

ShutdownCallbackRegistry：用于可运行关闭时回调实例的注册表。由于对JVM生命周期中Log4j的关闭时间有不同的要求，提供这个接口是为了定制如何注册关闭的一个钩子回调。实现可以选择性地实现{@link org.apache.logging.log4j.core.LifeCycle}。
    
  /*
  
  工厂定位ContextSelector，然后加载LoggerContext。
  */

ContextSelector

用于定位LoggerContext的接口。
    
    private static ContextSelector createContextSelector() {
        try {
           //    public static final String LOG4J_CONTEXT_SELECTOR = "Log4jContextSelector";指定了就是用这个指定的loggerContext选择器
            final ContextSelector selector = Loader.newCheckedInstanceOfProperty(Constants.LOG4J_CONTEXT_SELECTOR,
                ContextSelector.class);
            if (selector != null) {
                return selector;
            }
        } catch (final Exception e) {
            LOGGER.error("Unable to create custom ContextSelector. Falling back to default.", e);
        }
    //没有指定就是默认的ClassLoaderContextSelector
        return new ClassLoaderContextSelector();
    }



 private static ShutdownCallbackRegistry createShutdownCallbackRegistry() {
        try {
            
            // String SHUTDOWN_CALLBACK_REGISTRY = "log4j.shutdownCallbackRegistry";
指定了就创建指定的
            final ShutdownCallbackRegistry registry = Loader.newCheckedInstanceOfProperty(
                ShutdownCallbackRegistry.SHUTDOWN_CALLBACK_REGISTRY, ShutdownCallbackRegistry.class
            );
            if (registry != null) {
                return registry;
            }
        } catch (final Exception e) {
            LOGGER.error("Unable to create custom ShutdownCallbackRegistry. Falling back to default.", e);
        }
     
     //创建默认的DefaultShutdownCallbackRegistry
        return new DefaultShutdownCallbackRegistry();
    }

StrSubstitutor

/*
用值替换字符串中的变量。

这个类接受一段文本并替换其中的所有变量。
 * 变量的默认定义是<code>${variableName}</code>。
 *前缀和后缀可以通过构造函数和set方法更改。

变量值通常从映射中解析，但也可以从系统属性或通过提供自定义变量解析程序来解析。
最简单的例子是使用这个类来替换Java系统属性。例如：
* <pre>
 * StrSubstitutor.replaceSystemProperties(
 *      "You are running with java.version = ${java.version} and os.name = ${os.name}.");
 * </pre>
 这个类的典型用法遵循以下模式：首先创建一个实例并用包含可用变量值的映射初始化。如果变量的前缀和/或后缀不是默认的，则可以执行适当的设置。之后，可以调用<code>replace（）</code>方法，传入源文本进行插值。在返回的文本中，所有变量引用（只要它们的值已知）都将被解析。
 * 下面的示例演示了这一点：
 
 * <pre>
 * Map valuesMap = HashMap();
 * valuesMap.put(&quot;animal&quot;, &quot;quick brown fox&quot;);
 * valuesMap.put(&quot;target&quot;, &quot;lazy dog&quot;);
 * String templateString = &quot;The ${animal} jumped over the ${target}.&quot;;
 * StrSubstitutor sub = new StrSubstitutor(valuesMap);
 * String resolvedString = sub.replace(templateString);
 * </pre>



此外，此类还允许为未解析变量设置默认值。
变量的默认值可以追加到变量名后的变量默认值分隔符之后。
变量default value delimiter的默认值是“：-”，就像bash和其他*nix shell中一样，因为可以说，这些shell是默认${}分隔符集的起源地。可以通过调用{@link#setValueDelimiterMatcher（StrMatcher）}、{@link#setValueDelimiter（char）}或{@link\#setValueDelimiter（String）}手动设置变量default value delimiter。
 * 下面显示了一个具有变量默认值设置的示例：

* <pre>
 * Map valuesMap = HashMap();
 * valuesMap.put(&quot;animal&quot;, &quot;quick brown fox&quot;);
 * valuesMap.put(&quot;target&quot;, &quot;lazy dog&quot;);
 * String templateString = &quot;The ${animal} jumped over the ${target}. ${undefined.number:-1234567890}.&quot;;
 * StrSubstitutor sub = new StrSubstitutor(valuesMap);
 * String resolvedString = sub.replace(templateString);
 * </pre>
 
 除了这种使用模式，还有一些静态的方便方法，它们涵盖了最常见的用例。这些方法无需手动创建实例即可使用。但是，如果要执行多个替换操作，则创建和重用此类的实例将更加高效。
 变量替换以递归方式工作。因此，如果变量值包含变量，则该变量也将被替换。检测到循环替换，并将导致引发异常。
 
有时插值的结果必须包含可变前缀。以以下源文本为例：
The variable ${${name}} must be used.

在这里，只有文本中引用的变量名才应该被替换为文本（假设<code>name</code>变量的值是<code>x</code>）：
 * <pre>
 *   The variable ${x} must be used.
 * </pre>
 
 要达到这种效果，有两种可能：为不与要生成的结果文本冲突的变量设置不同的前缀和后缀。另一种可能是使用转义符，默认为“$”。如果此字符放在变量引用之前，此引用将被忽略且不会被替换。例如：
 
 * <pre>
 *   The variable $${${name}} must be used.
 * </pre>
 例如，在一些复杂的场景中，您甚至可能希望在变量名称中执行替换
  * <pre>
 * ${jre-${java.specification.version}}
 * </pre>
 <code>StrSubstitutor</code>在变量名中支持这种递归替换，但必须通过将{@link#setEnableSubstitutionConstances（boolean）enableSubstitutionConstances}属性设置为<b>true</b>来显式启用它。

*/

StrLookup

//查找字符串值的字符串键。


/*
此类表示字符串到字符串映射的最简单形式。它比map有一个优点，它可以根据需要根据密钥创建结果。

这个类带有各种工厂方法。如果这些还不够，您可以子类化并实现自己的匹配器。

例如，可以实现一个使用该键作为主键的查找，并根据需要从数据库中查找值

*/



/*
查找字符串值的字符串键。
内部实现可以使用任何机制来返回值。最简单的实现是使用映射。然而，实际上任何实施都是可能的。
例如，可以实现一个将键用作主键的查找，并根据需要从数据库中查找值；或者，可以创建一个基于数字的实现，将键视为整数，增加值并将结果作为字符串返回-将1转换为2，15到16等。

不管基础数据是什么，此方法总是通过必要的转换来返回字符串。例如：
 * <pre>
     * Map<String, Object> map = new HashMap<String, Object>();
     * map.put("number", new Integer(2));
     * assertEquals("2", StrLookup.mapLookup(map).lookup("number"));
     * </pre>

*/
//key要查找的键，可以为null
  String lookup(String key);


/*
查找可能使用当前LogEvent的字符串值的字符串键。

*/
  String lookup(LogEvent event, String key);

MBeanServer

继承 MBeanServerConnection:此接口表示与MBean服务器（无论是本地服务器还是远程服务器）的通信方式。{@link MBeanServer}接口（表示本地MBean服务器）扩展了此接口。


/*
这是代理端MBean操作的接口。它包含创建、注册和删除mbean所需的方法，以及已注册mbean的访问方法。这是JMX基础设施的核心组件。

用户代码通常不实现此接口。相反，实现这个接口的对象是通过{@link中的一个方法获得的javax.management.MBeanServerFactory}class。

添加到MBean服务器的每个MBean都变得可管理：其属性和操作可以通过连接到该MBean服务器的连接器/适配器远程访问。Java对象不能在MBean服务器中注册，除非它是符合JMX的MBean。


When an MBean is registered or unregistered in the MBean server a {@link javax.management.MBeanServerNotification MBeanServerNotification} Notification is emitted. To register an object as listener to MBeanServerNotifications you should call the MBean server method {@link #addNotificationListener addNotificationListener} with <CODE>ObjectName</CODE> the <CODE>ObjectName</CODE> of the {@link javax.management.MBeanServerDelegate MBeanServerDelegate}.  This <CODE>ObjectName</CODE> is: <BR> <CODE>JMImplementation:type=MBeanServerDelegate</CODE>
*/

源码流程

工厂获取

LogManager静态代码块执行

/**
扫描classpath以找到所有日志实现。目前，只有一个将被使用，但这可以扩展到允许使用多个实现。
     */
    static {
        //强制指定日志实现的快捷绑定。
    //log4j2.component.properties（使用容器存起来），log4j2.system.properties（往系统属性里面存），classpath下面找这个文件并把他们读取变成 两个Properties存起来，但是后者不会覆盖系统资源的默认值 
    
    //除此之外 ServiceLoader.load(PropertySource.class, classLoader)) 干了活
    // private static final String PREFIX = "META-INF/services/";
    // 例子：意思就是去META-INF/services/路径下找org.apache.logging.log4j.util.PropertySource
    //这个文件，然后实例化
        final PropertiesUtil managerProps = PropertiesUtil.getProperties();
    
    //,从已经加载好配置文件的缓存中获取key为log4j2.loggerContextFactory的value值
        final String factoryClassName = managerProps.getStringProperty(FACTORY_PROPERTY_NAME);
    
        if (factoryClassName != null) {
            try {
                factory = LoaderUtil.newCheckedInstanceOf(factoryClassName, LoggerContextFactory.class);
            } catch (final ClassNotFoundException cnfe) {
                LOGGER.error("Unable to locate configured LoggerContextFactory {}", factoryClassName);
            } catch (final Exception ex) {
                LOGGER.error("Unable to create configured LoggerContextFactory {}", factoryClassName, ex);
            }
        }

        if (factory == null) {
            final SortedMap<Integer, LoggerContextFactory> factories = new TreeMap<>();
            // note that the following initial call to ProviderUtil may block until a Provider has been installed when
            // running in an OSGi environment
            
            //去META-INF/services/路径下找org.apache.logging.log4j.spi.Provider
    //这个文件，然后根据里面的具体子类实现路径进行实例化
            //实例化好了之后META-INF/log4j-provider.properties文件找提供provider的实例
            //
            if (ProviderUtil.hasProviders()) {
                
                for (final Provider provider : ProviderUtil.getProviders()) {
                    final Class<? extends LoggerContextFactory> factoryClass = provider.loadLoggerContextFactory();
                    if (factoryClass != null) {
                        try {
                            factories.put(provider.getPriority(), factoryClass.newInstance());
                        } catch (final Exception e) {
                            LOGGER.error("Unable to create class {} specified in provider URL {}", factoryClass.getName(), provider
                                    .getUrl(), e);
                        }
                    }
                }

                if (factories.isEmpty()) {
                    LOGGER.error("Log4j2 could not find a logging implementation. "
                            + "Please add log4j-core to the classpath. Using SimpleLogger to log to the console...");
                    factory = new SimpleLoggerContextFactory();
                } else if (factories.size() == 1) {
                    factory = factories.get(factories.lastKey());
                } else {
                    final StringBuilder sb = new StringBuilder("Multiple logging implementations found: \n");
                    for (final Map.Entry<Integer, LoggerContextFactory> entry : factories.entrySet()) {
                        sb.append("Factory: ").append(entry.getValue().getClass().getName());
                        sb.append(", Weighting: ").append(entry.getKey()).append('\n');
                    }
                    factory = factories.get(factories.lastKey());
                    sb.append("Using factory: ").append(factory.getClass().getName());
                    LOGGER.warn(sb.toString());

                }
            } else {
                LOGGER.error("Log4j2 could not find a logging implementation. "
                        + "Please add log4j-core to the classpath. Using SimpleLogger to log to the console...");
                factory = new SimpleLoggerContextFactory();
            }
        }
    }

工厂的初始化

  selector= new ClassLoaderContextSelector();
    shutdownCallbackRegistry= new DefaultShutdownCallbackRegistry();
public Log4jContextFactory(final ContextSelector selector,
                               final ShutdownCallbackRegistry shutdownCallbackRegistry) {
        this.selector = Objects.requireNonNull(selector, "No ContextSelector provided");
        this.shutdownCallbackRegistry = Objects.requireNonNull(shutdownCallbackRegistry, "No ShutdownCallbackRegistry provided");
        LOGGER.debug("Using ShutdownCallbackRegistry {}", shutdownCallbackRegistry.getClass());
    
    //这里其实就是创建了一个Thread对象，然后去管理这个thread对象
        initializeShutdownCallbackRegistry();
    }

工厂的获取是利用Provider的服务自动发现 来找到 工厂具体类型

LoggerContext的获取

log4j2的工厂是Log4jContextFactory

public static LoggerContext getContext(final boolean currentContext) {
        // TODO: would it be a terrible idea to try and find the caller ClassLoader here?
        try {
            return factory.getContext(FQCN, null, null, currentContext, null, null);
        } catch (final IllegalStateException ex) {
            LOGGER.warn(ex.getMessage() + " Using SimpleLogger");
            return new SimpleLoggerContextFactory().getContext(FQCN, null, null, currentContext, null, null);
        }
    }



public LoggerContext getContext(final String fqcn, final ClassLoader loader, final Object externalContext,
                                    final boolean currentContext, final URI configLocation, final String name) {
    
    //通过选择器获取LoggerContext
        final LoggerContext ctx = selector.getContext(fqcn, loader, currentContext, configLocation);
        if (externalContext != null && ctx.getExternalContext() == null) {
            ctx.setExternalContext(externalContext);
        }
        if (name != null) {
        	ctx.setName(name);
        }
        if (ctx.getState() == LifeCycle.State.INITIALIZED) {
            if (configLocation != null || name != null) {
                ContextAnchor.THREAD_CONTEXT.set(ctx);
                final Configuration config = ConfigurationFactory.getInstance().getConfiguration(ctx, name, configLocation);
                LOGGER.debug("Starting LoggerContext[name={}] from configuration at {}", ctx.getName(), configLocation);
                ctx.start(config);
                ContextAnchor.THREAD_CONTEXT.remove();
            } else {
                ctx.start();
            }
        }
        return ctx;
    }



 public LoggerContext getContext(final String fqcn, final ClassLoader loader, final boolean currentContext,
            final URI configLocation) {
        if (currentContext) {
            //一般为fasle
            //当前线程的LoggerContext的锚点。，从线程本地获取LoggerContext，如果没有
            final LoggerContext ctx = ContextAnchor.THREAD_CONTEXT.get();
            if (ctx != null) {
                return ctx;
            }
            return getDefault();
        } else if (loader != null) {
            return locateContext(loader, configLocation);
        } else {
            final Class<?> clazz = StackLocatorUtil.getCallerClass(fqcn);
            if (clazz != null) {
                //clazz不为空，根据位置获取LoggerContext
                return locateContext(clazz.getClassLoader(), configLocation);
            }
        
            final LoggerContext lc = ContextAnchor.THREAD_CONTEXT.get();
            if (lc != null) {
                return lc;
            }
            return getDefault();
        }
    }



 private LoggerContext locateContext(final ClassLoader loaderOrNull, final URI configLocation) {
        // LOG4J2-477: class loader may be null
        final ClassLoader loader = loaderOrNull != null ? loaderOrNull : ClassLoader.getSystemClassLoader();
     //获取LoggerContext的名字，以后好做映射
        final String name = toContextMapKey(loader);
     
        AtomicReference<WeakReference<LoggerContext>> ref = CONTEXT_MAP.get(name);
        if (ref == null) {
            if (configLocation == null) {
                //获取父的 类加载器
                ClassLoader parent = loader.getParent();
                while (parent != null) {
					//名字重新获取
                    ref = CONTEXT_MAP.get(toContextMapKey(parent));
                    if (ref != null) {
                        final WeakReference<LoggerContext> r = ref.get();
                        final LoggerContext ctx = r.get();
                        if (ctx != null) {
                            return ctx;
                        }
                    }
                    //迭代到根加载器
                    parent = parent.getParent();
                    /*  In Tomcat 6 the parent of the JSP classloader is the webapp classloader which would be configured by the WebAppContextListener. The WebAppClassLoader is also the ThreadContextClassLoader.
                    在tomcat6中，JSP类加载器的父类是webapp类加载器，它将由WebAppContextListener配置。WebAppClassLoader也是ThreadContextClassLoader。
                    
                    In JBoss 5 the parent of the JSP ClassLoader is the WebAppClassLoader which is also the ThreadContextClassLoader. However, the parent of the WebAppClassLoader is the ClassLoader that is configured by the WebAppContextListener.
					在jboss5中，JSP类加载器的父类是WebAppClassLoader，它也是ThreadContextClassLoader。但是，WebAppClassLoader的父级是WebAppContextListener配置的类加载器。
					
                    ClassLoader threadLoader = null;
                    try {
                        threadLoader = Thread.currentThread().getContextClassLoader();
                    } catch (Exception ex) {
                        // Ignore SecurityException
                    }
                    if (threadLoader != null && threadLoader == parent) {
                        break;
                    } else {
                        parent = parent.getParent();
                    } */
                }
            }
            //如果父ClassLoader命名的加载器拿不到，那么使用此ClassLoader命名创建一个 LoggerContext
            LoggerContext ctx = createContext(name, configLocation);
            //存入缓存
            LoggerContext newContext = CONTEXT_MAP.computeIfAbsent(name,
                    k -> new AtomicReference<>(new WeakReference<>(ctx))).get().get();
            if (newContext == ctx) {
                //添加关闭监听
                ctx.addShutdownListener(this);
            }
            return newContext;
        }
        final WeakReference<LoggerContext> weakRef = ref.get();
        LoggerContext ctx = weakRef.get();
        if (ctx != null) {
            if (ctx.getConfigLocation() == null && configLocation != null) {
                LOGGER.debug("Setting configuration to {}", configLocation);
                ctx.setConfigLocation(configLocation);
            } else if (ctx.getConfigLocation() != null && configLocation != null
                    && !ctx.getConfigLocation().equals(configLocation)) {
                LOGGER.warn("locateContext called with URI {}. Existing LoggerContext has URI {}", configLocation,
                        ctx.getConfigLocation());
            }
            return ctx;
        }
        ctx = createContext(name, configLocation);
        ref.compareAndSet(weakRef, new WeakReference<>(ctx));
        return ctx;
    }


    public LoggerContext(final String name, final Object externalContext, final URI configLocn) {
        this.contextName = name;
        if (externalContext == null) {
            externalMap.remove(EXTERNAL_CONTEXT_KEY);
        } else {
            externalMap.put(EXTERNAL_CONTEXT_KEY, externalContext);
        }
        this.configLocation = configLocn;
    }


最后启动
    
    @Override
    public void start() {
        LOGGER.debug("Starting LoggerContext[name={}, {}]...", getName(), this);
        if (PropertiesUtil.getProperties().getBooleanProperty("log4j.LoggerContext.stacktrace.on.start", false)) {
            LOGGER.debug("Stack trace to locate invoker",
                    new Exception("Not a real error, showing stack trace to locate invoker"));
        }
        if (configLock.tryLock()) {
            try {
                if (this.isInitialized() || this.isStopped()) {
                    this.setStarting();
                    //重新配置上下文。Log4j在重新配置期间不会删除记录器。Log4j将创建新的LoggerConfig对象，Log4j将把记录器指向新的LoggerConfigs。Log4j将释放旧的LoggerConfig，以及旧的appender和过滤器。
                    reconfigure();
                    if (this.configuration.isShutdownHookEnabled()) {
                        setUpShutdownHook();
                    }
                    this.setStarted();
                }
            } finally {
                configLock.unlock();
            }
        }
        LOGGER.debug("LoggerContext[name={}, {}] started OK.", getName(), this);
    }

Logger获取

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);
    //这里可以更具消息工厂名字的不同来选择一个具体的logger
        return loggerRegistry.getLogger(name, messageFactory);
    }

注意咯，这里子类可以覆盖 如果需要更换那就需要更换 选择器contextSelector
   protected Logger newInstance(final LoggerContext ctx, final String name, final MessageFactory messageFactory) {
        return new Logger(ctx, name, messageFactory);
    }

执行：

调用到 AbstractLogger 的
   public void error(final String message) {
        logIfEnabled(FQCN, Level.ERROR, null, message, (Throwable) null);
    }


 @Override
    public void logIfEnabled(final String fqcn, final Level level, final Marker marker, final String message,
            final Throwable t) {
        if (isEnabled(level, marker, message, t)) {
            logMessage(fqcn, level, marker, message, t);
        }
    }
protected void logMessage(final String fqcn, final Level level, final Marker marker, final String message,
            final Throwable t) {
        logMessageSafely(fqcn, level, marker, messageFactory.newMessage(message), t);
    }

@PerformanceSensitive
    // NOTE: This is a hot method. Current implementation compiles to 30 bytes of byte code.
    // This is within the 35 byte MaxInlineSize threshold. Modify with care!
    private void logMessageSafely(final String fqcn, final Level level, final Marker marker, final Message msg,
            final Throwable throwable) {
        try {
            logMessageTrackRecursion(fqcn, level, marker, msg, throwable);
        } finally {
            // LOG4J2-1583 prevent scrambled logs when logging calls are nested (logging in toString())
            //如果消息是 可以可回收重用的，那么就回收
            ReusableMessageFactory.release(msg);
            
            //消息重用机制就是 当前线程中保存一个 threadlocal对象做为key，消息作为value
            //因为一个线程每次只能处理一条消息
        }
    }

@PerformanceSensitive
    // NOTE: This is a hot method. Current implementation compiles to 33 bytes of byte code.
    // This is within the 35 byte MaxInlineSize threshold. Modify with care!
    private void logMessageTrackRecursion(final String fqcn,
                                          final Level level,
                                          final Marker marker,
                                          final Message msg,
                                          final Throwable throwable) {
        try {
            增加一次栈深度
            incrementRecursionDepth(); // LOG4J2-1518, LOG4J2-2031
            tryLogMessage(fqcn, getLocation(fqcn), level, marker, msg, throwable);
        } finally {
            减少一次栈深度
            decrementRecursionDepth();
        }
    }
private void tryLogMessage(final String fqcn,
                               final StackTraceElement location,
                               final Level level,
                               final Marker marker,
                               final Message msg,
                               final Throwable throwable) {
        try {
            记录日志
            log(level, marker, fqcn, location, msg, throwable);
        } catch (final Exception e) {
            // LOG4J2-1990 Log4j2 suppresses all exceptions that occur once application called the logger
            //处理异常
            handleLogMessageException(e, fqcn, msg);
        }
    }




  //具体logger的isEnabled调用，当然也可以使用包一层的方式 在内部调用具体的isenabled，为了适配
//所以一个logger对应一个filter
 @Override
    public boolean isEnabled(final Level level, final Marker marker, final String message, final Throwable t) {
        return privateConfig.filter(level, marker, message, t);
    }

  boolean filter(final Level level, final Marker marker, final String msg, final Throwable t) {
            final Filter filter = config.getFilter();
            if (filter != null) {
                final Filter.Result r = filter.filter(logger, level, marker, (Object) msg, t);
                if (r != Filter.Result.NEUTRAL) {
                    return r == Filter.Result.ACCEPT;
                }
            }
            return level != null && intLevel >= level.intLevel();
        }

真正log4j2的日志处理

  
同步的
@Override
    protected void log(final Level level, final Marker marker, final String fqcn, final StackTraceElement location,
        final Message message, final Throwable throwable) {
        final ReliabilityStrategy strategy = privateConfig.loggerConfig.getReliabilityStrategy();
        if (strategy instanceof LocationAwareReliabilityStrategy) {
           // strategy一般默认为DefaultReliabilityStrategy（继承LocationAwareReliabilityStrategy）
            ((LocationAwareReliabilityStrategy) strategy).log(this, getName(), fqcn, location, marker, level,
                message, throwable);
        } else {
            strategy.log(this, getName(), fqcn, marker, level, message, throwable);
        }
    }


   public void log(final Supplier<LoggerConfig> reconfigured, final String loggerName, final String fqcn,
        final StackTraceElement location, final Marker marker, final Level level, final Message data,
        final Throwable t) {
        loggerConfig.log(loggerName, fqcn, location, marker, level, data, t);
    }



@PerformanceSensitive("allocation")
    public void log(final String loggerName, final String fqcn, final StackTraceElement location, final Marker marker,
        final Level level, final Message data, final Throwable t) {
        List<Property> props = null;
        if (!propertiesRequireLookup) {
            props = properties;
        } else {
            if (properties != null) {
                props = new ArrayList<>(properties.size());
                final LogEvent event = Log4jLogEvent.newBuilder()
                    .setMessage(data)
                    .setMarker(marker)
                    .setLevel(level)
                    .setLoggerName(loggerName)
                    .setLoggerFqcn(fqcn)
                    .setThrown(t)
                    .build();
                for (int i = 0; i < properties.size(); i++) {
                    final Property prop = properties.get(i);
                    final String value = prop.isValueNeedsLookup() // since LOG4J2-1575
                        ? config.getStrSubstitutor().replace(event, prop.getValue()) //
                        : prop.getValue();
                    props.add(Property.createProperty(prop.getName(), value));
                }
            }
        }
        //使用事件工厂创建一个日志事件，默认使用可重用事件工厂，原理与消息工厂一样
        final LogEvent logEvent = logEventFactory instanceof LocationAwareLogEventFactory ?
            ((LocationAwareLogEventFactory) logEventFactory).createEvent(loggerName, marker, fqcn, location, level,
                data, props, t) : logEventFactory.createEvent(loggerName, marker, fqcn, level, data, props, t);
        try {
            log(logEvent, LoggerConfigPredicate.ALL);
        } finally {
            // LOG4J2-1583 prevent scrambled logs when logging calls are nested (logging in toString())
            ReusableLogEventFactory.release(logEvent);
        }
    }
    protected void log(final LogEvent event, final LoggerConfigPredicate predicate) {
        if (!isFiltered(event)) {
            processLogEvent(event, predicate);
        }
    }
   public boolean isFiltered(final LogEvent event) {
        return filter != null && filter.filter(event) == Filter.Result.DENY;
    }


    private void processLogEvent(final LogEvent event, final LoggerConfigPredicate predicate) {
        event.setIncludeLocation(isIncludeLocation());
        if (predicate.allow(this)) {
            callAppenders(event);
        }
        logParent(event, predicate);
    }


 @PerformanceSensitive("allocation")
    protected void callAppenders(final LogEvent event) {
        final AppenderControl[] controls = appenders.get();
        //noinspection ForLoopReplaceableByForEach
        for (int i = 0; i < controls.length; i++) {
            controls[i].callAppender(event);
        }
    }

--------------------------AppenderControl------------------
 public void callAppender(final LogEvent event) {
        if (shouldSkip(event)) {
            return;
        }
        callAppenderPreventRecursion(event);
    }
 private boolean shouldSkip(final LogEvent event) {
        return isFilteredByAppenderControl(event) || isFilteredByLevel(event) || isRecursiveCall();
    }


 private void callAppenderPreventRecursion(final LogEvent event) {
        try {
            recursive.set(this);
            callAppender0(event);
        } finally {
            recursive.set(null);
        }
    }

    private void callAppender0(final LogEvent event) {
        ensureAppenderStarted();
        if (!isFilteredByAppender(event)) {
            tryCallAppender(event);
        }
    }

    private boolean isFilteredByAppender(final LogEvent event) {
        return appender instanceof Filterable && ((Filterable) appender).isFiltered(event);
    }

    private void tryCallAppender(final LogEvent event) {
        try {
            appender.append(event);
        } catch (final RuntimeException ex) {
            handleAppenderError(event, ex);
        } catch (final Exception ex) {
            handleAppenderError(event, new AppenderLoggingException(ex));
        }
    }

-----具体的appender-----
所以实现一个appender就必须实现  append方法
    @Override
    public void append(final LogEvent event) {
        try {
            tryAppend(event);
        } catch (final AppenderLoggingException ex) {
            error("Unable to write to stream " + manager.getName() + " for appender " + getName(), event, ex);
            throw ex;
        }
    }

配置文件

ConfigurationFactory

继承ConfigurationBuilderFactory：提供创建ConfigurationBuilders的方法。
/*
用于从配置文件解析的{@link Configuration}对象的工厂类。
ConfigurationFactory允许通过以下三种方式中的一种动态选择配置实现：
	1名为“log4j.configurationFactory”的系统属性可以设置为要使用的configurationFactory的名称。
    2{@linkplain#setConfigurationFactory（ConfigurationFactory）}可以与要使用的ConfigurationFactory实例一起调用。必须在调用Log4j之前调用它。
    3.ConfigurationFactory实现可以添加到类路径中，并配置为{@link#CATEGORY ConfigurationFactory}类别中的插件。 {@link Order}注释应该用于将工厂配置为第一个被检查的工厂。 参见{@linkplain org.apache.logging.log4j.core.config.xml.XmlConfigurationFactory}获取示例。
 
如果添加的ConfigurationFactory在调用getConfiguration时返回null，那么作为插件找到的任何其他ConfigurationFactory都将按各自的顺序调用。如果未返回任何配置，则始终最后调用DefaultConfiguration。 


 
*/
    
     reconfigure(); //获取loggerContext时候会调用



private void reconfigure(final URI configURI) {
        Object externalContext = externalMap.get(EXTERNAL_CONTEXT_KEY);
        final ClassLoader cl = ClassLoader.class.isInstance(externalContext) ? (ClassLoader) externalContext : null;
        LOGGER.debug("Reconfiguration started for context[name={}] at URI {} ({}) with optional ClassLoader: {}",
                contextName, configURI, this, cl);
        final Configuration instance = ConfigurationFactory.getInstance().getConfiguration(this, contextName, configURI, cl);
        if (instance == null) {
            LOGGER.error("Reconfiguration failed: No configuration found for '{}' at '{}' in '{}'", contextName, configURI, cl);
        } else {
            setConfiguration(instance);
            /*
             * instance.start(); Configuration old = setConfiguration(instance); updateLoggers(); if (old != null) {
             * old.stop(); }
             */
            final String location = configuration == null ? "?" : String.valueOf(configuration.getConfigurationSource());
            LOGGER.debug("Reconfiguration complete for context[name={}] at URI {} ({}) with optional ClassLoader: {}",
                    contextName, location, this, cl);
        }
    }



ConfigurationFactory.getInstance()：
    
    public static ConfigurationFactory getInstance() {
        // volatile works in Java 1.6+, so double-checked locking also works properly
        //noinspection DoubleCheckedLocking
        if (factories == null) {
            LOCK.lock();
            try {
                if (factories == null) {
                    final List<ConfigurationFactory> list = new ArrayList<>();
                    PropertiesUtil props = PropertiesUtil.getProperties();
                    //首先获取  public static final String CONFIGURATION_FACTORY_PROPERTY = "log4j.configurationFactory";指定的
                    final String factoryClass = props.getStringProperty(CONFIGURATION_FACTORY_PROPERTY);
                    if (factoryClass != null) {
                        //处理化并加入list
                        addFactory(list, factoryClass);
                    }
                    final PluginManager manager = new PluginManager(CATEGORY);
                    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) {
                            LOGGER.warn("Unable to add class {}", type.getPluginClass(), ex);
                        }
                    }
                    Collections.sort(ordered, OrderComparator.getInstance());
                    for (final Class<? extends ConfigurationFactory> clazz : ordered) {
                        addFactory(list, clazz);
                    }
                    // see above comments about double-checked locking
                    //noinspection NonThreadSafeLazyInitialization
                    factories = Collections.unmodifiableList(list);
                    authorizationProvider = authorizationProvider(props);
                }
            } finally {
                LOCK.unlock();
            }
        }

        LOGGER.debug("Using configurationFactory {}", configFactory);
        return configFactory;
    }

插件机制

 PluginManager

public void collectPlugins() {
        collectPlugins(null);
    }

public void collectPlugins(final List<String> packages) {
        final String categoryLowerCase = category.toLowerCase();
        final Map<String, PluginType<?>> newPlugins = new LinkedHashMap<>();

        // 首先，迭代Log4j2插件.dat在主ClassPath中找到的文件
        Map<String, List<PluginType<?>>> builtInPlugins = PluginRegistry.getInstance().loadFromMainClassLoader();
    
    
        if (builtInPlugins.isEmpty()) {
            // 如果我们没有在上面找到任何插件，一定是有人弄乱了log4j-core.jar. 搜索标准包，希望能找到我们的核心插件。
            builtInPlugins = PluginRegistry.getInstance().loadFromPackage(LOG4J_PACKAGES);
        }
        mergeByName(newPlugins, builtInPlugins.get(categoryLowerCase));

        // 接下来，迭代任何Log4j2插件.datOSGi捆绑包中的文件
        for (final Map<String, List<PluginType<?>>> pluginsByCategory : PluginRegistry.getInstance().getPluginsByCategoryByBundleId().values()) {
            mergeByName(newPlugins, pluginsByCategory.get(categoryLowerCase));
        }

        // 接下来迭代传递给静态addPackage方法的所有包。
        for (final String pkg : PACKAGES) {
            mergeByName(newPlugins, PluginRegistry.getInstance().loadFromPackage(pkg).get(categoryLowerCase));
        }
        // Finally iterate any packages provided in the configuration (note these can be changed at runtime).
        if (packages != null) {
            for (final String pkg : packages) {
                mergeByName(newPlugins, PluginRegistry.getInstance().loadFromPackage(pkg).get(categoryLowerCase));
            }
        }

        LOGGER.debug("PluginManager '{}' found {} plugins", category, newPlugins.size());

        plugins = newPlugins;
    }



 private Map<String, List<PluginType<?>>> decodeCacheFiles(final ClassLoader loader) {
        final long startTime = System.nanoTime();
        final PluginCache cache = new PluginCache();
        try {
            // public static final String PLUGIN_CACHE_FILE =
 // "META-INF/org/apache/logging/log4j/core/config/plugins/Log4j2Plugins.dat";就是获取这个资源
            final Enumeration<URL> resources = loader.getResources(PluginProcessor.PLUGIN_CACHE_FILE);
            if (resources == null) {
                LOGGER.info("Plugin preloads not available from class loader {}", loader);
            } else {
                cache.loadCacheFiles(resources);
            }
        } catch (final IOException ioe) {
            LOGGER.warn("Unable to preload plugins", ioe);
        }
        final Map<String, List<PluginType<?>>> newPluginsByCategory = new HashMap<>();
        int pluginCount = 0;
        for (final Map.Entry<String, Map<String, PluginEntry>> outer : cache.getAllCategories().entrySet()) {
            final String categoryLowerCase = outer.getKey();
            final List<PluginType<?>> types = new ArrayList<>(outer.getValue().size());
            newPluginsByCategory.put(categoryLowerCase, types);
            for (final Map.Entry<String, PluginEntry> inner : outer.getValue().entrySet()) {
                final PluginEntry entry = inner.getValue();
                final String className = entry.getClassName();
                try {
                    final Class<?> clazz = loader.loadClass(className);
                    final PluginType<?> type = new PluginType<>(entry, clazz, entry.getName());
                    types.add(type);
                    ++pluginCount;
                } catch (final ClassNotFoundException e) {
                    LOGGER.info("Plugin [{}] could not be loaded due to missing classes.", className, e);
                } catch (final LinkageError e) {
                    LOGGER.info("Plugin [{}] could not be loaded due to linkage error.", className, e);
                }
            }
        }
        final int numPlugins = pluginCount;
        LOGGER.debug(() -> {
            final long endTime = System.nanoTime();
            StringBuilder sb = new StringBuilder("Took ");
            final DecimalFormat numFormat = new DecimalFormat("#0.000000");
            sb.append(numFormat.format((endTime - startTime) * 1e-9));
            sb.append(" seconds to load ").append(numPlugins);
            sb.append(" plugins from ").append(loader);
            return sb.toString();
        });
        return newPluginsByCategory;
    }




public Configuration getConfiguration(final LoggerContext loggerContext, final String name, final URI configLocation, final ClassLoader loader) {
        if (!isActive()) {
            return null;
        }
        if (loader == null) {
            return getConfiguration(loggerContext, name, configLocation);
        }
        if (isClassLoaderUri(configLocation)) {
            final String path = extractClassLoaderUriPath(configLocation);
            final ConfigurationSource source = ConfigurationSource.fromResource(path, loader);
            if (source != null) {
                final Configuration configuration = getConfiguration(loggerContext, source);
                if (configuration != null) {
                    return configuration;
                }
            }
        }
        return getConfiguration(loggerContext, name, configLocation);
    }


 public Configuration getConfiguration(final LoggerContext loggerContext, final String name, final URI configLocation) {

            if (configLocation == null) {
                final String configLocationStr = this.substitutor.replace(PropertiesUtil.getProperties()
                        .getStringProperty(CONFIGURATION_FILE_PROPERTY));
                if (configLocationStr != null) {
                    String[] sources = parseConfigLocations(configLocationStr);
                    if (sources.length > 1) {
                        final List<AbstractConfiguration> configs = new ArrayList<>();
                        for (final String sourceLocation : sources) {
                            final Configuration config = getConfiguration(loggerContext, sourceLocation.trim());
                            if (config != null && config instanceof AbstractConfiguration) {
                                configs.add((AbstractConfiguration) config);
                            } else {
                                LOGGER.error("Failed to created configuration at {}", sourceLocation);
                                return null;
                            }
                        }
                        return new CompositeConfiguration(configs);
                    }
                    return getConfiguration(loggerContext, configLocationStr);
                } else {
                    final String log4j1ConfigStr = this.substitutor.replace(PropertiesUtil.getProperties()
                            .getStringProperty(LOG4J1_CONFIGURATION_FILE_PROPERTY));
                    if (log4j1ConfigStr != null) {
                        System.setProperty(LOG4J1_EXPERIMENTAL, "true");
                        return getConfiguration(LOG4J1_VERSION, loggerContext, log4j1ConfigStr);
                    }
                }
                for (final ConfigurationFactory factory : getFactories()) {
                    final String[] types = factory.getSupportedTypes();
                    if (types != null) {
                        for (final String type : types) {
                            //private static final String ALL_TYPES = "*";
                            //XmlConfigurationFactory的 public static final String[] SUFFIXES = new String[] {".xml", "*"};
  
                            if (type.equals(ALL_TYPES)) {
                                final Configuration config = factory.getConfiguration(loggerContext, name, configLocation);
                                if (config != null) {
                                    return config;
                                }
                            }
                        }
                    }
                }
            } else {
                String[] sources = parseConfigLocations(configLocation);
                if (sources.length > 1) {
                    final List<AbstractConfiguration> configs = new ArrayList<>();
                    for (final String sourceLocation : sources) {
                        final Configuration config = getConfiguration(loggerContext, sourceLocation.trim());
                        if (config instanceof AbstractConfiguration) {
                            configs.add((AbstractConfiguration) config);
                        } else {
                            LOGGER.error("Failed to created configuration at {}", sourceLocation);
                            return null;
                        }
                    }
                    return new CompositeConfiguration(configs);
                }
                // configLocation != null
                final String configLocationStr = configLocation.toString();
                for (final ConfigurationFactory factory : getFactories()) {
                    final String[] types = factory.getSupportedTypes();
                    if (types != null) {
                        for (final String type : types) {
                            if (type.equals(ALL_TYPES) || configLocationStr.endsWith(type)) {
                                final Configuration config = factory.getConfiguration(loggerContext, name, configLocation);
                                if (config != null) {
                                    return config;
                                }
                            }
                        }
                    }
                }
            }

            Configuration config = getConfiguration(loggerContext, true, name);
            if (config == null) {
                config = getConfiguration(loggerContext, true, null);
                if (config == null) {
                    config = getConfiguration(loggerContext, false, name);
                    if (config == null) {
                        config = getConfiguration(loggerContext, false, null);
                    }
                }
            }
            if (config != null) {
                return config;
            }
            LOGGER.warn("No Log4j 2 configuration file found. " +
                    "Using default configuration (logging only errors to the console), " +
                    "or user programmatically provided configurations. " +
                    "Set system property 'log4j2.debug' " +
                    "to show Log4j 2 internal initialization logging. " +
                    "See https://logging.apache.org/log4j/2.x/manual/configuration.html for instructions on how to configure Log4j 2");
            return new DefaultConfiguration();
        }




 public Configuration getConfiguration(final LoggerContext loggerContext, final String name, final URI configLocation) {
        if (!isActive()) {
            return null;
        }
        if (configLocation != null) {
            final ConfigurationSource source = ConfigurationSource.fromUri(configLocation);
            if (source != null) {
                return getConfiguration(loggerContext, source);
            }
        }
        return null;
    }




先按获取log4j2-test，带name
    log4j2-test 不带name
    log4j2 带name
    log4j2 不带name
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;
                //获取本工厂的前缀 首先后去test前缀 ，然后获取
                // protected static final String DEFAULT_PREFIX = "log4j2";默认的
                final String prefix = isTest ? factory.getTestPrefix() : factory.getDefaultPrefix();
                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;

                    final ConfigurationSource source = ConfigurationSource.fromResource(configName, loader);
                    if (source != null) {
                        if (!factory.isActive()) {
                            LOGGER.warn("Found configuration file {} for inactive ConfigurationFactory {}", configName, factory.getClass().getName());
                        }
                        return factory.getConfiguration(loggerContext, source);
                    }
                }
            }
            return null;
        }


能够找到就返回指定的
 return new XmlConfiguration(loggerContext, source);
  不能够就返回默认的
       return new DefaultConfiguration();

Configuration.start()

public void start() {
       // Preserve the prior behavior of initializing during start if not initialized.
       if (getState().equals(State.INITIALIZING)) {
           initialize();
       }
       LOGGER.debug("Starting configuration {}", this);
       this.setStarting();
       if (watchManager.getIntervalSeconds() >= 0) {
           watchManager.start();
       }
       if (hasAsyncLoggers()) {
           asyncLoggerConfigDisruptor.start();
       }
       final Set<LoggerConfig> alreadyStarted = new HashSet<>();
       for (final LoggerConfig logger : loggerConfigs.values()) {
           logger.start();
           alreadyStarted.add(logger);
       }
       for (final Appender appender : appenders.values()) {
           appender.start();
       }
       if (!alreadyStarted.contains(root)) { // LOG4J2-392
           root.start(); // LOG4J2-336
       }
       super.start();
       LOGGER.debug("Started configuration {} OK.", this);
   }


   public void initialize() {
       LOGGER.debug(Version.getProductString() + " initializing configuration {}", this);
       subst.setConfiguration(this);
       try {
           scriptManager = new ScriptManager(this, watchManager);
       } catch (final LinkageError | Exception e) {
           // LOG4J2-1920 ScriptEngineManager is not available in Android
           LOGGER.info("Cannot initialize scripting support because this JRE does not support it.", e);
       }
       pluginManager.collectPlugins(pluginPackages);
       final PluginManager levelPlugins = new PluginManager(Level.CATEGORY);
       levelPlugins.collectPlugins(pluginPackages);
       final Map<String, PluginType<?>> plugins = levelPlugins.getPlugins();
       if (plugins != null) {
           for (final PluginType<?> type : plugins.values()) {
               try {
                   // Cause the class to be initialized if it isn't already.
                   Loader.initializeClass(type.getPluginClass().getName(), type.getPluginClass().getClassLoader());
               } catch (final Exception e) {
                   LOGGER.error("Unable to initialize {} due to {}", type.getPluginClass().getName(), e.getClass()
                           .getSimpleName(), e);
               }
           }
       }
       setup();
       setupAdvertisement();
       //做配置
       doConfigure();
       setState(State.INITIALIZED);
       LOGGER.debug("Configuration {} initialized", this);
   }

xml配置文件解析

xml的new就是xml配置的初始化，此时 所有的节点都会被解析出来
    /*
        private final List<Status> status = new ArrayList<>();
    private Element rootElement;
    private boolean strict;
    private String schemaResource;

    */
 public XmlConfiguration(final LoggerContext loggerContext, final ConfigurationSource configSource) {
        super(loggerContext, configSource);
        final File configFile = configSource.getFile();
        byte[] buffer = null;

        try {
            final InputStream configStream = configSource.getInputStream();
            try {
                buffer = toByteArray(configStream);
            } finally {
                Closer.closeSilently(configStream);
            }
            final InputSource source = new InputSource(new ByteArrayInputStream(buffer));
            source.setSystemId(configSource.getLocation());
            final DocumentBuilder documentBuilder = newDocumentBuilder(true);
            Document document;
            try {
                //这行做事情
                document = documentBuilder.parse(source);
            } catch (final Exception e) {
                // LOG4J2-1127
                final Throwable throwable = Throwables.getRootCause(e);
                if (throwable instanceof UnsupportedOperationException) {
                    LOGGER.warn(
                            "The DocumentBuilder {} does not support an operation: {}."
                            + "Trying again without XInclude...",
                            documentBuilder, e);
                    document = newDocumentBuilder(false).parse(source);
                } else {
                    throw e;
                }
            }
            rootElement = document.getDocumentElement();
            final Map<String, String> attrs = processAttributes(rootNode, rootElement);
            final StatusConfiguration statusConfig = new StatusConfiguration().withVerboseClasses(VERBOSE_CLASSES)
                    .withStatus(getDefaultStatus());
            int monitorIntervalSeconds = 0;
            for (final Map.Entry<String, String> entry : attrs.entrySet()) {
                final String key = entry.getKey();
                final String value = getStrSubstitutor().replace(entry.getValue());
                if ("status".equalsIgnoreCase(key)) {
                    statusConfig.withStatus(value);
                } else if ("dest".equalsIgnoreCase(key)) {
                    statusConfig.withDestination(value);
                } else if ("shutdownHook".equalsIgnoreCase(key)) {
                    isShutdownHookEnabled = !"disable".equalsIgnoreCase(value);
                } else if ("shutdownTimeout".equalsIgnoreCase(key)) {
                    shutdownTimeoutMillis = Long.parseLong(value);
                } else if ("verbose".equalsIgnoreCase(key)) {
                    statusConfig.withVerbosity(value);
                } else if ("packages".equalsIgnoreCase(key)) {
                    pluginPackages.addAll(Arrays.asList(value.split(Patterns.COMMA_SEPARATOR)));
                } else if ("name".equalsIgnoreCase(key)) {
                    setName(value);
                } else if ("strict".equalsIgnoreCase(key)) {
                    strict = Boolean.parseBoolean(value);
                } else if ("schema".equalsIgnoreCase(key)) {
                    schemaResource = value;
                } else if ("monitorInterval".equalsIgnoreCase(key)) {
                    monitorIntervalSeconds = Integer.parseInt(value);
                } else if ("advertiser".equalsIgnoreCase(key)) {
                    createAdvertiser(value, configSource, buffer, "text/xml");
                }
            }
            initializeWatchers(this, configSource, monitorIntervalSeconds);
            statusConfig.initialize();
        } catch (final SAXException | IOException | ParserConfigurationException e) {
            LOGGER.error("Error parsing " + configSource.getLocation(), e);
        }
        if (strict && schemaResource != null && buffer != null) {
            try (InputStream is = Loader.getResourceAsStream(schemaResource, XmlConfiguration.class.getClassLoader())) {
                if (is != null) {
                    final javax.xml.transform.Source src = new StreamSource(is, LOG4J_XSD);
                    final SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
                    Schema schema = null;
                    try {
                        schema = factory.newSchema(src);
                    } catch (final SAXException ex) {
                        LOGGER.error("Error parsing Log4j schema", ex);
                    }
                    if (schema != null) {
                        final Validator validator = schema.newValidator();
                        try {
                            validator.validate(new StreamSource(new ByteArrayInputStream(buffer)));
                        } catch (final IOException ioe) {
                            LOGGER.error("Error reading configuration for validation", ioe);
                        } catch (final SAXException ex) {
                            LOGGER.error("Error validating configuration", ex);
                        }
                    }
                }
            } catch (final Exception ex) {
                LOGGER.error("Unable to access schema {}", this.schemaResource, ex);
            }
        }

        if (getName() == null) {
            setName(configSource.getLocation());
        }
    }



然后会进行初始化
    
    public void initialize() {
        LOGGER.debug(Version.getProductString() + " initializing configuration {}", this);
        subst.setConfiguration(this);
        try {
            scriptManager = new ScriptManager(this, watchManager);
        } catch (final LinkageError | Exception e) {
            // LOG4J2-1920 ScriptEngineManager is not available in Android
            LOGGER.info("Cannot initialize scripting support because this JRE does not support it.", e);
        }
        pluginManager.collectPlugins(pluginPackages);
        final PluginManager levelPlugins = new PluginManager(Level.CATEGORY);
        levelPlugins.collectPlugins(pluginPackages);
        final Map<String, PluginType<?>> plugins = levelPlugins.getPlugins();
        if (plugins != null) {
            for (final PluginType<?> type : plugins.values()) {
                try {
                    // Cause the class to be initialized if it isn't already.
                    Loader.initializeClass(type.getPluginClass().getName(), type.getPluginClass().getClassLoader());
                } catch (final Exception e) {
                    LOGGER.error("Unable to initialize {} due to {}", type.getPluginClass().getName(), e.getClass()
                            .getSimpleName(), e);
                }
            }
        }
    /*
    
    */
    
        setup();
    /*
    advertiser = clazz.newInstance();
                    advertisement = advertiser.advertise(advertiserNode.getAttributes());
    */
        setupAdvertisement();
        doConfigure();
        setState(State.INITIALIZED);
        LOGGER.debug("Configuration {} initialized", this);
    }
    
      public void setup() {
        if (rootElement == null) {
            LOGGER.error("No logging configuration");
            return;
        }
          //层次结构化 节点
        constructHierarchy(rootNode, rootElement);
        if (status.size() > 0) {
            for (final Status s : status) {
                LOGGER.error("Error processing element {} ({}): {}", s.name, s.element, s.errorType);
            }
            return;
        }
        rootElement = null;
    }
    
    
    
     public void start() {
        // Preserve the prior behavior of initializing during start if not initialized.
        if (getState().equals(State.INITIALIZING)) {
            initialize();
        }
        LOGGER.debug("Starting configuration {}", this);
        this.setStarting();
        if (watchManager.getIntervalSeconds() >= 0) {
            watchManager.start();
        }
        if (hasAsyncLoggers()) {
            asyncLoggerConfigDisruptor.start();
        }
        final Set<LoggerConfig> alreadyStarted = new HashSet<>();
        for (final LoggerConfig logger : loggerConfigs.values()) {
            logger.start();
            alreadyStarted.add(logger);
        }
        for (final Appender appender : appenders.values()) {
            appender.start();
        }
        if (!alreadyStarted.contains(root)) { // LOG4J2-392
            root.start(); // LOG4J2-336
        }
        super.start();
        LOGGER.debug("Started configuration {} OK.", this);
    }

如何解析dom

   static DocumentBuilder newDocumentBuilder(final boolean xIncludeAware) throws ParserConfigurationException {
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);

        disableDtdProcessing(factory);

        if (xIncludeAware) {
            enableXInclude(factory);
        }
        return factory.newDocumentBuilder();
    }



 DocumentBuilderImpl(DocumentBuilderFactoryImpl dbf, Map<String, Object> dbfAttrs,
            Map<String, Boolean> features, boolean secureProcessing)
        throws SAXNotRecognizedException, SAXNotSupportedException
    {
        domParser = new DOMParser();

        // If validating, provide a default ErrorHandler that prints
        // validation errors with a warning telling the user to set an
        // ErrorHandler
        if (dbf.isValidating()) {
            fInitErrorHandler = new DefaultValidationErrorHandler(domParser.getXMLParserConfiguration().getLocale());
            setErrorHandler(fInitErrorHandler);
        }
        else {
            fInitErrorHandler = domParser.getErrorHandler();
        }

        domParser.setFeature(VALIDATION_FEATURE, dbf.isValidating());

        // "namespaceAware" == SAX Namespaces feature
        domParser.setFeature(NAMESPACES_FEATURE, dbf.isNamespaceAware());

        // Set various parameters obtained from DocumentBuilderFactory
        domParser.setFeature(INCLUDE_IGNORABLE_WHITESPACE,
                !dbf.isIgnoringElementContentWhitespace());
        domParser.setFeature(CREATE_ENTITY_REF_NODES_FEATURE,
                !dbf.isExpandEntityReferences());
        domParser.setFeature(INCLUDE_COMMENTS_FEATURE,
                !dbf.isIgnoringComments());
        domParser.setFeature(CREATE_CDATA_NODES_FEATURE,
                !dbf.isCoalescing());

        // Avoid setting the XInclude processing feature if the value is false.
        // This will keep the configuration from throwing an exception if it
        // does not support XInclude.
        if (dbf.isXIncludeAware()) {
            domParser.setFeature(XINCLUDE_FEATURE, true);
        }

        fSecurityPropertyMgr = new XMLSecurityPropertyManager();
        domParser.setProperty(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);

        fSecurityManager = new XMLSecurityManager(secureProcessing);
        domParser.setProperty(SECURITY_MANAGER, fSecurityManager);

        if (secureProcessing) {
            /**
             * If secure processing is explicitly set on the factory, the
             * access properties will be set unless the corresponding
             * System Properties or jaxp.properties are set
             */
            if (features != null) {
                Boolean temp = features.get(XMLConstants.FEATURE_SECURE_PROCESSING);
                if (temp != null) {
                    if (temp && Constants.IS_JDK8_OR_ABOVE) {
                        fSecurityPropertyMgr.setValue(Property.ACCESS_EXTERNAL_DTD,
                                State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
                        fSecurityPropertyMgr.setValue(Property.ACCESS_EXTERNAL_SCHEMA,
                                State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
                    }
                }
            }
        }

        this.grammar = dbf.getSchema();
        if (grammar != null) {
            XMLParserConfiguration config = domParser.getXMLParserConfiguration();
            XMLComponent validatorComponent = null;
            /** For Xerces grammars, use built-in schema validator. **/
            if (grammar instanceof XSGrammarPoolContainer) {
                validatorComponent = new XMLSchemaValidator();
                fSchemaValidationManager = new ValidationManager();
                fUnparsedEntityHandler = new UnparsedEntityHandler(fSchemaValidationManager);
                config.setDTDHandler(fUnparsedEntityHandler);
                fUnparsedEntityHandler.setDTDHandler(domParser);
                domParser.setDTDSource(fUnparsedEntityHandler);
                fSchemaValidatorComponentManager = new SchemaValidatorConfiguration(config,
                        (XSGrammarPoolContainer) grammar, fSchemaValidationManager);
            }
            /** For third party grammars, use the JAXP validator component. **/
            else {
                validatorComponent = new JAXPValidatorComponent(grammar.newValidatorHandler());
                fSchemaValidationManager = null;
                fUnparsedEntityHandler = null;
                fSchemaValidatorComponentManager = config;
            }
            config.addRecognizedFeatures(validatorComponent.getRecognizedFeatures());
            config.addRecognizedProperties(validatorComponent.getRecognizedProperties());
            setFeatures(features);      // Must set before calling setDocumentHandler()
            config.setDocumentHandler((XMLDocumentHandler) validatorComponent);
            ((XMLDocumentSource)validatorComponent).setDocumentHandler(domParser);
            domParser.setDocumentSource((XMLDocumentSource) validatorComponent);
            fSchemaValidator = validatorComponent;
        }
        else {
            fSchemaValidationManager = null;
            fUnparsedEntityHandler = null;
            fSchemaValidatorComponentManager = null;
            fSchemaValidator = null;
            setFeatures(features);
        }

        //setAttribute override those that may be set by other means
        setDocumentBuilderFactoryAttributes(dbfAttrs);

        // Initial EntityResolver
        fInitEntityResolver = domParser.getEntityResolver();
    }




最后找此类的一个实现
/**
 * The entity handler interface defines methods to report information
 * about the start and end of entities.
 *
 * @xerces.internal
 *
 * @see com.sun.org.apache.xerces.internal.impl.XMLEntityScanner
 *
 * @author Andy Clark, IBM
 *
 */
public interface XMLEntityHandler {

    //
    // XMLEntityHandler methods
    //

    /**
     * This method notifies of the start of an entity. The DTD has the
     * pseudo-name of "[dtd]" parameter entity names start with '%'; and
     * general entities are just specified by their name.
     *
     * @param name     The name of the entity.
     * @param identifier The resource identifier.
     * @param encoding The auto-detected IANA encoding name of the entity
     *                 stream. This value will be null in those situations
     *                 where the entity encoding is not auto-detected (e.g.
     *                 internal entities or a document entity that is
     *                 parsed from a java.io.Reader).
     * @param augs     Additional information that may include infoset augmentations
     *
     * @throws XNIException Thrown by handler to signal an error.
     */
    public void startEntity(String name,
                            XMLResourceIdentifier identifier,
                            String encoding, Augmentations augs) throws XNIException;

    /**
     * This method notifies the end of an entity. The DTD has the pseudo-name
     * of "[dtd]" parameter entity names start with '%'; and general entities
     * are just specified by their name.
     *
     * @param name The name of the entity.
     * @param augs Additional information that may include infoset augmentations
     *
     * @throws IOException This exception might be thrown when there is premature end of entity
     * @throws XNIException Thrown by handler to signal an error.
     */
    public void endEntity(String name, Augmentations augs) throws IOException, XNIException;

} // interface XMLEntityHandler

真正做配置

protected void doConfigure() {
        preConfigure(rootNode);
        configurationScheduler.start();
        if (rootNode.hasChildren() && rootNode.getChildren().get(0).getName().equalsIgnoreCase("Properties")) {
            //处理Properties节点
            final Node first = rootNode.getChildren().get(0);
            createConfiguration(first, null);
            if (first.getObject() != null) {
                subst.setVariableResolver((StrLookup) first.getObject());
            }
        } else {
            final Map<String, String> map = this.getComponent(CONTEXT_PROPERTIES);
            final StrLookup lookup = map == null ? null : new MapLookup(map);
            subst.setVariableResolver(new Interpolator(lookup, pluginPackages));
        }

        boolean setLoggers = false;
        boolean setRoot = false;
        for (final Node child : rootNode.getChildren()) {
            if (child.getName().equalsIgnoreCase("Properties")) {
                if (tempLookup == subst.getVariableResolver()) {
                    LOGGER.error("Properties declaration must be the first element in the configuration");
                }
                continue;
            }
            createConfiguration(child, null);
            if (child.getObject() == null) {
                continue;
            }
            if (child.getName().equalsIgnoreCase("Scripts")) {
                //处理script节点
                for (final AbstractScript script : child.getObject(AbstractScript[].class)) {
                    if (script instanceof ScriptRef) {
                        LOGGER.error("Script reference to {} not added. Scripts definition cannot contain script references",
                                script.getName());
                    } else {
                        if (scriptManager != null) {
                            scriptManager.addScript(script);
                        }}
                }
            } else if (child.getName().equalsIgnoreCase("Appenders")) {
                 //处理Appenders节点
                appenders = child.getObject();
            } else if (child.isInstanceOf(Filter.class)) {
                 //处理Filter节点
                addFilter(child.getObject(Filter.class));
            } else if (child.getName().equalsIgnoreCase("Loggers")) {
                 //处理Loggers节点
                final Loggers l = child.getObject();
                loggerConfigs = l.getMap();
                setLoggers = true;
                if (l.getRoot() != null) {
                    root = l.getRoot();
                    setRoot = true;
                }
            } else if (child.getName().equalsIgnoreCase("CustomLevels")) {
                //处理CustomLevels
                customLevels = child.getObject(CustomLevels.class).getCustomLevels();
            } else if (child.isInstanceOf(CustomLevelConfig.class)) {
                
                final List<CustomLevelConfig> copy = new ArrayList<>(customLevels);
                copy.add(child.getObject(CustomLevelConfig.class));
                customLevels = copy;
            } else {
                final List<String> expected = Arrays.asList("\"Appenders\"", "\"Loggers\"", "\"Properties\"",
                        "\"Scripts\"", "\"CustomLevels\"");
                LOGGER.error("Unknown object \"{}\" of type {} is ignored: try nesting it inside one of: {}.",
                        child.getName(), child.getObject().getClass().getName(), expected);
            }
        }

        if (!setLoggers) {
           // Logger是否已经设置过，没有就设置一个默认的
            LOGGER.warn("No Loggers were configured, using default. Is the Loggers element missing?");
            setToDefault();
            return;
        } else if (!setRoot) {
            //Root是否已经设置过，没有就设置一个默认的
            LOGGER.warn("No Root logger was configured, creating default ERROR-level Root logger with Console appender");
            setToDefault();
            // return; // LOG4J2-219: creating default root=ok, but don't exclude configured Loggers
        }

        for (final Map.Entry<String, LoggerConfig> entry : loggerConfigs.entrySet()) {
            final LoggerConfig loggerConfig = entry.getValue();
            for (final AppenderRef ref : loggerConfig.getAppenderRefs()) {
                final Appender app = appenders.get(ref.getRef());
                if (app != null) {
                    loggerConfig.addAppender(app, ref.getLevel(), ref.getFilter());
                } else {
                    LOGGER.error("Unable to locate appender \"{}\" for logger config \"{}\"", ref.getRef(),
                            loggerConfig);
                }
            }

        }

        setParents();
    }



 private void setParents() {
        for (final Map.Entry<String, LoggerConfig> entry : loggerConfigs.entrySet()) {
            final LoggerConfig logger = entry.getValue();
            String key = entry.getKey();
            if (!key.isEmpty()) {
                final int i = key.lastIndexOf('.');
                if (i > 0) {
                    key = key.substring(0, i);
                    LoggerConfig parent = getLoggerConfig(key);
                    if (parent == null) {
                        parent = root;
                    }
                    logger.setParent(parent);
                } else {
                    logger.setParent(root);
                }
            }
        }
    }



主要是这个方法
public void createConfiguration(final Node node, final LogEvent event) {
    //每一个节点都被当成一个PluginType对象，这里面的有该节点的类型，名字，还有其他信息
        final PluginType<?> type = node.getType();
        if (type != null && type.isDeferChildren()) {
            node.setObject(createPluginObject(type, node, event));
        } else {
            for (final Node child : node.getChildren()) {
                如果还有内部子节点，继续递归
                createConfiguration(child, event);
            }

            if (type == null) {
                if (node.getParent() != null) {
                    LOGGER.error("Unable to locate plugin for {}", node.getName());
                }
            } else {
                node.setObject(createPluginObject(type, node, event));
            }
        }
    }



  private Object createPluginObject(final PluginType<?> type, final Node node, final LogEvent event) {
        final Class<?> clazz = type.getPluginClass();

        if (Map.class.isAssignableFrom(clazz)) {
            try {
                return createPluginMap(node);
            } catch (final Exception e) {
                LOGGER.warn("Unable to create Map for {} of class {}", type.getElementName(), clazz, e);
            }
        }

        if (Collection.class.isAssignableFrom(clazz)) {
            try {
                return createPluginCollection(node);
            } catch (final Exception e) {
                LOGGER.warn("Unable to create List for {} of class {}", type.getElementName(), clazz, e);
            }
        }

      最后通过PluginBuilder(type)来实现
        return new PluginBuilder(type).withConfiguration(this).withConfigurationNode(node).forLogEvent(event).build();
    }


 private static Method findFactoryMethod(final Class<?> clazz) {
        for (final Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(PluginFactory.class) &&
                Modifier.isStatic(method.getModifiers())) {
                ReflectionUtil.makeAccessible(method);
                return method;
            }
        }
        throw new IllegalStateException("No factory method found for class " + clazz.getName());
    }


如果你想要加一个 appender或者layout，但是不知道怎么加，点开对应的layout实现，在此类下一定有一个带 @PluginFactory注解的 方法，这个方法里面就告诉你应该怎么填写，这里面内置了一个 静态内部类Builder，这个builder就是创建该外部类对象的，里面的属性都是 反射获取属性进行注入，所以写标签是，属性名与builder的属性名一样就行
    
      @PluginFactory
    @Deprecated
    public static PatternLayout createLayout(
            @PluginAttribute(value = "pattern", defaultString = DEFAULT_CONVERSION_PATTERN) final String pattern,
            @PluginElement("PatternSelector") final PatternSelector patternSelector,
            @PluginConfiguration final Configuration config,
            @PluginElement("Replace") final RegexReplacement replace,
            // LOG4J2-783 use platform default by default, so do not specify defaultString for charset
            @PluginAttribute(value = "charset") final Charset charset,
            @PluginAttribute(value = "alwaysWriteExceptions", defaultBoolean = true) final boolean alwaysWriteExceptions,
            @PluginAttribute(value = "noConsoleNoAnsi") final boolean noConsoleNoAnsi,
            @PluginAttribute("header") final String headerPattern,
            @PluginAttribute("footer") final String footerPattern) {

    // public static final String PLUGIN_NAME = "Console";
    @Plugin(name = ConsoleAppender.PLUGIN_NAME, category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE, printObject = true)// 里面的name就是标签的命名
     @PluginBuilderAttribute 表示从标签 内部属性获取
     @PluginElement("Layout") 表示 从子标签获取，Layout一般是接口类型，子类实现提供的@Plugin里面的name就是标签名

使用

    public void test(){

        Logger logger= LogManager.getLogger("aa");
//日志级别与logback一致
        logger.fatal("fatal");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
    }

在类路径下创建一个log4j2.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<!--
status 是 log4j2 内部日志系统的记录日志级别
monitorInterval 自动加载配置文件的间隔时间，不低于5s
  -->
<configuration status="warn" monitorInterval="5">

    <!-- 集中配置属性进行管理
           使用时通过 ${name}
      -->
    <properties>
        <property name="logDir">F:/test</property>
        <property name="console_pattern">%d{yyyy-MM-dd HH:mm:ss} [%-5p] [%t] %l - %m%n </property>

    </properties>

    <!-- 定义appender 集合 -->
    <Appenders>
        <!-- 控制台appender -->
        <Console name="console" target="SYSTEM_ERR">
            <PatternLayout pattern="${console_pattern}"></PatternLayout>
        </Console>
        <!-- file的appender -->
        <File name="file" fileName="${logDir}/log4j2.log">
            <PatternLayout pattern="${console_pattern}"></PatternLayout>
        </File>

        <!-- RandomAccessFile这个appender 使用了 随机读写流，就是那个可以skip和seek的流，提高文件读写效率  -->
        <RandomAccessFile name="accessFile" fileName="${logDir}/randomLog4j2.log" >
            <PatternLayout pattern="${console_pattern}"></PatternLayout>
        </RandomAccessFile>


        <!-- 日志拆分 ，
        filePattern是定义拆分规则的
        首先日志没找过指定文件大小前 被放在${logDir}/rollingFile.log文件里
            没超过大小，但是超过指定的%d{yyyy-MM-dd-HH}时间级别 后 会生成一个 rollingFile-%d{yyyy-MM-dd-HH}-%i.log的文件
            超过大小，没超过指定时间，那么也会按照生成rollingFile-%d{yyyy-MM-dd-HH}-%i.log文件，后续还会生成一个时间相同，但是尾部序号不同的文件
          -->
        <RollingFile name="rollingFile" fileName="${logDir}/rollingFile.log"
                        filePattern="${logDir}/$${yyyy-MM-dd}/rollingFile-%d{yyyy-MM-dd-HH}-%i.log" >
            <!-- appender的日志级别过滤器 -->
            <ThresholdFilter level="debug" OnMatch="ACCEPT" OnMismatch="DENY"></ThresholdFilter>
            <PatternLayout pattern="${console_pattern}"></PatternLayout>
            <Policies>
                <!-- 系统启动时就触发 日志拆分规则，生成一个日志文件 -->
                <OnStartupTriggeringPolicy></OnStartupTriggeringPolicy>
                <!-- 每个日志文件的最大大小为10 mb -->
                <SizeBasedTriggeringPolicy size="10 MB"></SizeBasedTriggeringPolicy>
                <!-- 按给定的时间节点进行拆分  -->
                <TimeBasedTriggeringPolicy></TimeBasedTriggeringPolicy>
            </Policies>

            <!-- 同一个目录下，文件个数不超过30个，超过会按照时间老的进行覆盖 -->

            <DefaultRolloverStrategy max="30"></DefaultRolloverStrategy>
        </RollingFile>

    </Appenders>


    <!--  定义Logger -->
    <Loggers>
        <Root level="info">
            <AppenderRef ref="console"></AppenderRef>
        </Root>
        
    </Loggers>

</configuration>

与slf4j日志门面整合

pom.xml

<!-- log4j2的实现 -->
  <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.13.3</version>
  </dependency>

  <!-- log4j2 的适配 -->
  <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-slf4j-impl</artifactId>
      <version>2.13.3</version>
  </dependency>

  <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.26</version>
  </dependency>

原理：

通过 包名加类名完全一样的一个不同的StaticLoggerBinder来获取一个日志工厂
    
    private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();

 private StaticLoggerBinder() {
        loggerFactory = new Log4jLoggerFactory();
    }


使用适配器
    
      @Override
    public L getLogger(final String name) {
        final LoggerContext context = getContext();
        final ConcurrentMap<String, L> loggers = getLoggersInContext(context);
        final L logger = loggers.get(name);
        if (logger != null) {
            return logger;
        }
        loggers.putIfAbsent(name, newLogger(name, context));
        return loggers.get(name);
    }


    protected LoggerContext getContext() {
        final Class<?> anchor = StackLocatorUtil.getCallerClass(FQCN, PACKAGE);
        //LogManager就是log4j2的操作了
        return anchor == null ? LogManager.getContext() : getContext(StackLocatorUtil.getCallerClass(anchor));
    }

 public ConcurrentMap<String, L> getLoggersInContext(final LoggerContext context) {
        ConcurrentMap<String, L> loggers;
        lock.readLock ().lock ();
        try {
            loggers = registry.get (context);
        } finally {
            lock.readLock ().unlock ();
        }

        if (loggers != null) {
            return loggers;
        }
        lock.writeLock ().lock ();
        try {
            loggers = registry.get (context);
            if (loggers == null) {
                loggers = new ConcurrentHashMap<> ();
                registry.put (context, loggers);
                if (context instanceof LoggerContextShutdownEnabled) {
                    ((LoggerContextShutdownEnabled) context).addShutdownListener(this);
                }
            }
            return loggers;
        } finally {
            lock.writeLock ().unlock ();
        }
    }


    @Override
    protected Logger newLogger(final String name, final LoggerContext context) {
        final String key = Logger.ROOT_LOGGER_NAME.equals(name) ? LogManager.ROOT_LOGGER_NAME : name;
        return new Log4jLogger(validateContext(context).getLogger(key), name);
    }



Log4jLogger是一个内置log4j的logger实现的包装
     public Log4jLogger(final ExtendedLogger logger, final String name) {
        this.logger = logger;
        this.eventLogger = "EventLogger".equals(name);
        this.name = name;
    }


调用
    
      @Override
    public void error(final String format) {
        logger.logIfEnabled(FQCN, Level.ERROR, null, format);
    }

同步和异步

同步流程

应用调用logger.info()---> 全局过滤filter--->Logger自身级别过滤---->生成日志输出内容---》生成logevent--->Logger配置的Filter进行level过滤-----》Appender的filter和level过滤---》是否Rollover---》layout处理----》输出

异步：

Logger.info —–>Logger —logevent—> 放入 ArrayBlokingQueue（能放入立即返回）

处理日志事件的线程 不断从队列获取 日志事件，然后调用对应的appender进行处理

异步处理主要提供两种 AsyncLogger和AsyncAppender

官网对异步logger和异步appender做了一些性能比较，发现最好的是 该日志系统全部使用异步logger，其次 有一部分是同步logger，而另一部分是异步logger，异步appender没什么性能提升

pom.xml

<!-- 导入单机版最快的消息队列，因为log4j2依赖他 -->

 <dependency>
        <groupId>com.lmax</groupId>
        <artifactId>disruptor</artifactId>
        <version>3.4.2</version>
    </dependency>

虽然异步的appender没什么提升，但还是看一下

异步appender是引入logback思想，无需disruptor

<?xml version="1.0" encoding="UTF-8"?>

<!--
status 是 log4j2 内部日志系统的记录日志级别
monitorInterval 自动加载配置文件的间隔时间，不低于5s
  -->
<configuration status="warn" monitorInterval="5">

    <!-- 集中配置属性进行管理
           使用时通过 ${name}
      -->
    <properties>
        <property name="logDir">F:/test</property>
        <property name="console_pattern">%d{yyyy-MM-dd HH:mm:ss} [%-5p] [%t] %l - %m%n </property>

    </properties>

    <!-- 定义appender 集合 -->
    <Appenders>
        <!-- 控制台appender -->
        <Console name="console" target="SYSTEM_ERR">
            <PatternLayout pattern="${console_pattern}"></PatternLayout>
        </Console>

        <!-- 异步的appender本身不会处理，但是要直到 谁去处理，所以肯定要用用有具体的实现 -->
        <Async name="asyncConsole">
            <AppenderRef ref="console"></AppenderRef>
        </Async>
    </Appenders>


    <!--  定义Logger -->
    <Loggers>
        <Root level="info">
            
            <!-- 这里就使用异步的appender -->
            <AppenderRef ref="asyncConsole"></AppenderRef>
        </Root>

    </Loggers>

</configuration>

<!--

  @Override
    public void append(final LogEvent logEvent) {
        if (!isStarted()) {
            throw new IllegalStateException("AsyncAppender " + getName() + " is not active");
        }
        final Log4jLogEvent memento = Log4jLogEvent.createMemento(logEvent, includeLocation);
        InternalAsyncUtil.makeMessageImmutable(logEvent.getMessage());
        if (!transfer(memento)) {
            //如果不能放入处理队列，进行其他当前线程直接调用处理
            if (blocking) {
                if (AbstractLogger.getRecursionDepth() > 1) { // LOG4J2-1518, LOG4J2-2031
                    // If queue is full AND we are in a recursive call, call appender directly to prevent deadlock
                    AsyncQueueFullMessageUtil.logWarningToStatusLogger();
                    logMessageInCurrentThread(logEvent);
                } else {
                    // delegate to the event router (which may discard, enqueue and block, or log in current thread)
                    final EventRoute route = asyncQueueFullPolicy.getRoute(thread.getId(), memento.getLevel());
                    route.logMessage(this, memento);
                }
            } else {
                error("Appender " + getName() + " is unable to write primary appenders. queue is full");
                logToErrorAppenderIfNecessary(false, memento);
            }
        }
    }


就是开一个线程不断run
  @Override
        public void run() {
            while (!shutdown) {
                LogEvent event;
                try {
                    event = queue.take();
                    if (event == SHUTDOWN_LOG_EVENT) {
                        shutdown = true;
                        continue;
                    }
                } catch (final InterruptedException ex) {
                    break; // LOG4J2-830
                }
                event.setEndOfBatch(queue.isEmpty());
                final boolean success = callAppenders(event);
                if (!success && errorAppender != null) {
                    try {
                        errorAppender.callAppender(event);
                    } catch (final Exception ex) {
                        // Silently accept the error.
                    }
                }
            }
            // Process any remaining items in the queue.
            LOGGER.trace("AsyncAppender.AsyncThread shutting down. Processing remaining {} queue events.",
                queue.size());
            int count = 0;
            int ignored = 0;
            while (!queue.isEmpty()) {
                try {
                    final LogEvent event = queue.take();
                    if (event instanceof Log4jLogEvent) {
                        final Log4jLogEvent logEvent = (Log4jLogEvent) event;
                        logEvent.setEndOfBatch(queue.isEmpty());
                        callAppenders(logEvent);
                        count++;
                    } else {
                        ignored++;
                        LOGGER.trace("Ignoring event of class {}", event.getClass().getName());
                    }
                } catch (final InterruptedException ex) {
                    // May have been interrupted to shut down.
                    // Here we ignore interrupts and try to process all remaining events.
                }
            }
            LOGGER.trace("AsyncAppender.AsyncThread stopped. Queue has {} events remaining. "
                + "Processed {} and ignored {} events since shutdown started.", queue.size(), count, ignored);
        }


-->

异步logger

第一种，就是通过指定asyncLoggerContextSeletor来获取AsyncLoggerContext进一步获取AsyncLogger

类路径下 创建

log4j2.component.properties

log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
#就不需要动了xml，xml所有的logger都是异步的

混合异步

使用混合，必须把全局的先关闭

<?xml version="1.0" encoding="UTF-8"?>

<!--
status 是 log4j2 内部日志系统的记录日志级别
monitorInterval 自动加载配置文件的间隔时间，不低于5s
  -->
<configuration status="debug" monitorInterval="5">

    <!-- 集中配置属性进行管理
           使用时通过 ${name}
      -->
    <properties>
        <property name="logDir">F:/test</property>
        <property name="console_pattern">%d{yyyy-MM-dd HH:mm:ss} [%-5p] [%t] %l - %m%n </property>

    </properties>

    <!-- 定义appender 集合 -->
    <Appenders>
        <!-- 控制台appender -->
        <Console name="console" target="SYSTEM_ERR">
            <PatternLayout pattern="${console_pattern}"></PatternLayout>
        </Console>
        
    </Appenders>


    <!--  定义Logger -->
    <Loggers>

        <!-- 
 				使用异步logger
               includeLocation:false 是关闭日志记录的行号信息（开启行号有可能使性能比同步还要慢）
                additivity：false 是不继承

如果使用异步日志，AsyncAppender,AsyncLogger,和全局异步，不要同时出现，否则性能会和AsyncAppender一样，降至最低
         -->
        <AsyncLogger name="aa" level="debug" includeLocation="false" additivity="false">
            <AppenderRef ref="console"></AppenderRef>
        </AsyncLogger>

        <Root level="info">
            <AppenderRef ref="console"></AppenderRef>
        </Root>

    </Loggers>

</configuration>

源码

AsyncLoggerDisruptor

/*
异步记录器的助手类：AsyncLoggerDisruptor处理使用LMAX Disruptor的机制，并与其关联的AsyncLoggerContext一起工作，以使中断程序及其线程的生命周期与上下文的生命周期同步。上下文的AsyncLoggerDisruptor由该AsyncLoggerContext创建的所有AsyncLogger对象共享。

*/


private static final int SLEEP_MILLIS_BETWEEN_DRAIN_ATTEMPTS = 50;
    private static final int MAX_DRAIN_ATTEMPTS_BEFORE_SHUTDOWN = 200;

    private final Object queueFullEnqueueLock = new Object();

//下面这个是老大哥
    private volatile Disruptor<RingBufferLogEvent> disruptor;
    private String contextName;

    private boolean useThreadLocalTranslator = true;
    private long backgroundThreadId;
    private AsyncQueueFullPolicy asyncQueueFullPolicy;
    private int ringBufferSize;

队列初始化

public synchronized void start() {
        if (disruptor != null) {
            LOGGER.trace(
                    "[{}] AsyncLoggerDisruptor not starting new disruptor for this context, using existing object.",
                    contextName);
            return;
        }
        LOGGER.trace("[{}] AsyncLoggerDisruptor creating new disruptor for this context.", contextName);
    
    //获取循环数组的大小ringBufferSize，没有使用默认
    //   private static final int RINGBUFFER_NO_GC_DEFAULT_SIZE = 4 * 1024;
        ringBufferSize = DisruptorUtil.calculateRingBufferSize("AsyncLogger.RingBufferSize");
    
    //初始化一个等待策略，没有使用默认
        final WaitStrategy waitStrategy = DisruptorUtil.createWaitStrategy("AsyncLogger.WaitStrategy");

    
    //创建一个线程工厂
        final ThreadFactory threadFactory = new Log4jThreadFactory("AsyncLogger[" + contextName + "]", true, Thread.NORM_PRIORITY) {
            @Override
            public Thread newThread(final Runnable r) {
                final Thread result = super.newThread(r);
                backgroundThreadId = result.getId();
                return result;
            }
        };
    //异步队列满是的政策（策略）
        asyncQueueFullPolicy = AsyncQueueFullPolicyFactory.create();

    //初始化disruptor
        disruptor = new Disruptor<>(RingBufferLogEvent.FACTORY, ringBufferSize, threadFactory, ProducerType.MULTI,
                waitStrategy);

        final ExceptionHandler<RingBufferLogEvent> errorHandler = DisruptorUtil.getAsyncLoggerExceptionHandler();
        disruptor.setDefaultExceptionHandler(errorHandler);

        final RingBufferLogEventHandler[] handlers = {new RingBufferLogEventHandler()};
        disruptor.handleEventsWith(handlers);

        LOGGER.debug("[{}] Starting AsyncLogger disruptor for this context with ringbufferSize={}, waitStrategy={}, "
                + "exceptionHandler={}...", contextName, disruptor.getRingBuffer().getBufferSize(), waitStrategy
                .getClass().getSimpleName(), errorHandler);
        disruptor.start();

        LOGGER.trace("[{}] AsyncLoggers use a {} translator", contextName, useThreadLocalTranslator ? "threadlocal"
                : "vararg");
        super.start();
    }




    protected Logger newInstance(final LoggerContext ctx, final String name, final MessageFactory messageFactory) {
        return new AsyncLogger(ctx, name, messageFactory, loggerDisruptor);
    }




    public AsyncLogger(final LoggerContext context, final String name, final MessageFactory messageFactory,
            final AsyncLoggerDisruptor loggerDisruptor) {
        super(context, name, messageFactory);
        this.loggerDisruptor = loggerDisruptor;
        includeLocation = privateConfig.loggerConfig.isIncludeLocation();
        nanoClock = context.getConfiguration().getNanoClock();
    }



logger.info  
    
    
       private void logWithThreadLocalTranslator(final String fqcn, final StackTraceElement location, final Level level,
        final Marker marker, final Message message, final Throwable thrown) {
        // Implementation note: this method is tuned for performance. MODIFY WITH CARE!

        final RingBufferLogEventTranslator translator = getCachedTranslator();
        initTranslator(translator, fqcn, location, level, marker, message, thrown);
        initTranslatorThreadValues(translator);
        publish(translator);
    }


   private void publish(final RingBufferLogEventTranslator translator) {
        if (!loggerDisruptor.tryPublish(translator)) {
            //生产过快，就使用当前线程消费
            handleRingBufferFull(translator);
        }
    }

无垃圾模式

其实就是在创建消息时，使用threadlocal来保存，下次只需修改就好
但是log4j2也是在2.6才提供的，所以不要使用2.6以前版本

RollingRandomAccessFileAppender

RollingRandomAccessFileAppender与标准RollingFileAppender相似， 除了它总是被缓冲（无法关闭）并且在内部它使用ByteBuffer + RandomAccessFile而不是BufferedOutputStream。与RollingFileAppender相比，在我们的测量中，与RollingFileAppender相比，性能提高了20-200％。RollingRandomAccessFileAppender写入fileName参数中命名的File，然后根据TriggeringPolicy和RolloverPolicy将文件翻转。与RollingFileAppender相似，RollingRandomAccessFileAppender使用RollingRandomAccessFileManager实际执行文件I / O并执行翻转。虽然无法共享来自不同配置的RollingRandomAccessFileAppender，但如果可以访问Manager，则可以使用RollingRandomAccessFileManagers。例如，servlet容器中的两个Web应用程序可以具有自己的配置，并且如果Log4j位于这两个应用程序共同的ClassLoader中，则可以安全地写入同一文件。

RollingRandomAccessFileAppender需要 TriggeringPolicy和 RolloverStrategy。触发策略确定是否应执行过渡，而RolloverStrategy定义应如何进行过渡。如果未配置RolloverStrategy，则RollingRandomAccessFileAppender将使用 DefaultRolloverStrategy。从log4j-2.5开始，可以在DefaultRolloverStrategy中配置自定义删除操作以在翻转时运行。


只有在使用同步记录器,immediateFlush=true才会每次刷新。
 
    如果immediateFlush设置为false，异步日志记录器和追加器也会在一批事件结束时自动刷新。但这也保证了数据写入磁盘的效率。

自己弄的一个配置

<?xml version="1.0" encoding="UTF-8"?>

<configuration status="warn" monitorInterval="1800">
    <!-- 全局属性配置  -->
    <Properties>

        <!-- info debug trace 日志级别共用属性配置 ↓ -->
        <property name="simple_pattern">%d{yyyy-MM-dd HH:mm:ss} [%-5p] [%t] %c -- %m%n</property>
        <property name="simple_log_dir">F:/test/logs/simple</property>
        <!-- info debug trace 日志级别共用属性配置 ↑ -->


        <!-- error 日志级别共用属性配置 ↓ -->
        <property name="error_pattern">%d{yyyy-MM-dd HH:mm:ss} [%-5p] [%t] %l -- %m%n</property>
        <property name="error_log_dir">F:/test/logs/error</property>
        <!-- error 日志级别共用属性配置 ↑ -->

        <!-- warn 日志级别共用属性配置 ↓ -->
        <property name="warn_pattern">%d{yyyy-MM-dd HH:mm:ss} [%-5p] [%t] %l -- %m%n</property>
        <property name="warn_log_dir">F:/test/logs/warn</property>
        <!-- warn 日志级别共用属性配置 ↑ -->

    </Properties>

    <Appenders>

        <!-- ===================info debug trace 级别  ↓===================  -->
        <Console name="simple_console" target="SYSTEM_OUT">
            <PatternLayout pattern="${simple_pattern}"></PatternLayout>
            <Filters>
                <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
                <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
        </Console>

        <Routing name="simple_Routing">
            <Routes pattern="$${thread:threadName}">
                <Route>
                    <RollingFile name="rollingFile-${thread:threadName}"
                                 fileName="${simple_log_dir}/${thread:threadName}.log"
                                 filePattern="${simple_log_dir}/$${date:yyyy-MM-dd}/${thread:threadName}=%d{yyyy-MM-dd-HH}=%i.log" >
                        <!-- appender的日志级别过滤器 -->
                        <Filters>
                            <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
                            <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY"/>
                        </Filters>

                        <PatternLayout pattern="${simple_pattern}"></PatternLayout>
                        <Policies>
                            <!-- 系统启动时就触发 日志拆分规则，生成一个日志文件 -->
<!--                            <OnStartupTriggeringPolicy></OnStartupTriggeringPolicy>-->
                            <!-- 每个日志文件的最大大小为50 mb -->
                            <SizeBasedTriggeringPolicy size="50 MB"></SizeBasedTriggeringPolicy>
                            <!-- 按给定的时间节点进行拆分  -->
                            <TimeBasedTriggeringPolicy  interval="12"></TimeBasedTriggeringPolicy>
                        </Policies>
                        <!-- 同一个目录下，文件个数不超过100个，超过会按照时间老的进行覆盖 -->
                        <DefaultRolloverStrategy max="100"></DefaultRolloverStrategy>
                    </RollingFile>
                </Route>
            </Routes>
        </Routing>


        <!-- ===================info debug trace 级别  ↑===================  -->

        <!-- ===================== error 级别 ↓============================== -->
        <Console name="error_console" target="SYSTEM_ERR">
            <PatternLayout pattern="${error_pattern}"></PatternLayout>
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
        </Console>

        <Routing name="error_Routing">
            <Routes pattern="$${thread:threadName}">
                <Route>
                    <RollingFile name="rollingFile-${thread:threadName}"
                                 fileName="${error_log_dir}/${thread:threadName}.log"
                                 filePattern="${error_log_dir}/$${date:yyyy-MM-dd}/${thread:threadName}=%d{yyyy-MM-dd-HH}=%i.log" >
                        <!-- appender的日志级别过滤器 -->
                        <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
                        <PatternLayout pattern="${error_pattern}"></PatternLayout>
                        <Policies>
                            <!-- 系统启动时就触发 日志拆分规则，生成一个日志文件,这个看需求 -->
<!--                            <OnStartupTriggeringPolicy></OnStartupTriggeringPolicy>-->
                            <!-- 每个日志文件的最大大小为50 mb -->
                            <SizeBasedTriggeringPolicy size="50 MB"></SizeBasedTriggeringPolicy>
                            <!--
                            按给定的时间节点进行拆分 这里的12是根据上面的filePattern的级别来定
                            例如：%d{yyyy-MM-dd-HH} 那么这里的12就表示12个小时生成一个新文件
                             -->
                            <TimeBasedTriggeringPolicy interval="12"></TimeBasedTriggeringPolicy>
                        </Policies>

                        <!-- 同一个目录下，文件个数不超过100个，超过会按照时间老的进行覆盖 -->
                        <DefaultRolloverStrategy max="100"></DefaultRolloverStrategy>
                    </RollingFile>
                </Route>
            </Routes>
        </Routing>



        <!-- ===================== error 级别 ↑============================== -->


        <!-- ===================== warn 级别 ↓============================== -->


        <Console name="warn_console" target="SYSTEM_ERR">
            <PatternLayout pattern="${warn_pattern}"></PatternLayout>
            <Filters>
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
                <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
        </Console>

        <Routing name="warn_Routing">
            <Routes pattern="$${thread:threadName}">
                <Route>
                    <RollingFile name="rollingFile-${thread:threadName}"
                                 fileName="${warn_log_dir}/${thread:threadName}.log"
                                 filePattern="${warn_log_dir}/$${date:yyyy-MM-dd}/${thread:threadName}=%d{yyyy-MM-dd-HH}=%i.log" >
                        <!-- appender的日志级别过滤器 -->
                        <Filters>
                            <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
                            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
                        </Filters>
                        <PatternLayout pattern="${warn_pattern}"></PatternLayout>
                        <Policies>
                            <!-- 系统启动时就触发 日志拆分规则，生成一个日志文件 -->
<!--                            <OnStartupTriggeringPolicy></OnStartupTriggeringPolicy>-->
                            <!-- 每个日志文件的最大大小为50 mb -->
                            <SizeBasedTriggeringPolicy size="50 MB"></SizeBasedTriggeringPolicy>
                            <!-- 按给定的时间节点进行拆分  -->
                            <TimeBasedTriggeringPolicy interval="12"></TimeBasedTriggeringPolicy>
                        </Policies>
                        <!-- 同一个目录下，文件个数不超过100个，超过会按照时间老的进行覆盖 -->
                        <DefaultRolloverStrategy max="100"></DefaultRolloverStrategy>
                    </RollingFile>
                </Route>
            </Routes>
        </Routing>


        <!-- ===================== warn 级别 ↑============================== -->



    </Appenders>

    <Loggers>

        <Logger name="error" level="error" additivity="false">
            <appenderRef ref="error_console"></appenderRef>
            <appenderRef ref="error_Routing"></appenderRef>
        </Logger>

        <Logger name="warn" level="warn" additivity="false">
            <appenderRef ref="warn_console"></appenderRef>
            <appenderRef ref="warn_Routing"></appenderRef>
        </Logger>

        <AsyncRoot level="trace" includeLocation="false">
            <appenderRef ref="simple_console"></appenderRef>
            <appenderRef ref="simple_Routing"></appenderRef>
        </AsyncRoot>

    </Loggers>

</configuration>

/*
TimeBasedTriggeringPolicy
基于时间的触发策略。该策略主要是完成周期性的log文件封存工作。有两个参数：

interval，integer型，指定两次封存动作之间的时间间隔。这个配置需要和filePattern结合使用，filePattern日期格式精确到哪一位，interval也精确到哪一个单位。注意filePattern中配置的文件重命名规则是%d{yyyy-MM-dd HH-mm-ss}-%i，最小的时间粒度是ss，即秒钟。

TimeBasedTriggeringPolicy默认的size是1，结合起来就是每1秒钟生成一个新文件。如果改成%d{yyyy-MM-dd HH}，最小粒度为小时，则每一个小时生成一个文件

modulate，boolean型，说明是否对封存时间进行调制。若modulate=true， 则封存时间将以0点为边界进行偏移计算。比如，modulate=true，interval=4hours， 那么假设上次封存日志的时间为03:00，则下次封存日志的时间为04:00， 之后的封存时间依次为08:00，12:00，16:00

简单示例：

*/
@Plugin(name = "thread",category = StrLookup.CATEGORY)
    private static class ThreadLookup implements StrLookup{

        @Override
        public String lookup(String key) {
            return Thread.currentThread().getName();
        }

        @Override
        public String lookup(LogEvent event, String key) {
            return event.getThreadName()==null?Thread.currentThread().getName():event.getThreadName();
        }

        @Override
        public String toString() {
            return "是一个Log4j2的获取当前线程名称的插件";
        }
    }

赏

谢谢你请我吃糖果

支付宝

微信

• 本文作者： 忘忧症
• 本文链接： https://NepenthesZGW.github.io/2020/02/20/framework/log/log4j2/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！