Logging 在Log4j2中动态/编程地配置您自己的异步记录器

我的项目中已经实现了一个旧的log4j1.x，我们通过扩展类org.apach.log4j.logger创建了我们自己的日志。但是现在我们想转到Log4j2，因为它有一个asynLogger。下面的代码是否满足了以编程方式创建时支持我的Log4j2的异步日志的所有功能

import java.util.HashMap；
导入org.apache.logging.log4j.Level；
导入org.apache.logging.log4j.core.LoggerContext；
导入org.apache.logging.log4j.core.appender.ConsoleAppender；
导入org.apache.logging.log4j.core.appender.RandomAccessFileAppender；
导入org.apache.logging.log4j.core.async.AsyncLoggerContext；
导入org.apache.logging.log4j.core.layout.PatternLayout；
导入org.apache.logging.log4j.message.FormattedMessageFactory；
导入org.apache.logging.log4j.message.MessageFactory；
公共最终类MyLog4j2Logger扩展
org.apache.logging.log4j.core.async.AsyncLogger{
私有静态HashMap logCache=newhashmap（4）；
私有MyLog4j2Logger（LoggerContext上下文、字符串名称、MessageFactory msgFactory）{
super（上下文、名称、msgFactory）；
System.out.println（“使用异步记录器”）；
//设置为所有级别
此.setLevel（Level.ALL）；
}
/*
*返回记录器实例的工厂方法。如果
*实例已存在于else立即创建的哈希表中
*归还它。
*/
公共最终静态MyLog4j2Logger getCustomLogger（字符串sCategory）{
试一试{
System.setProperty（“Log4jContextSelector”，
“org.apache.logging.log4j.core.async.AsyncLoggerContextSelector”）；
//检查类别的实例是否已存在
if（logCache.containsKey（sCategory））{
MyLog4j2Logger=logCache.get（sCategory）；
info（“正在为“+sCategory”创建记录器）；
返回记录器；
}否则{
//为此类别创建新的自定义记录器
MyLog4j2Logger customLogger=configureCategoryLogger（sCategory）；
//将自定义记录器添加到表中。
logCache.put（sCategory、customLogger）；
info（“为“+sCategory”创建了一个新的记录器）；
return（MyLog4j2Logger）customLogger；
}
}捕获（异常扩展）{
系统输出
.println（“获取记录器实例时引发异常”）；
exp.printStackTrace（）；
}
返回null；
}
专用静态MyLog4j2Logger配置CategoryLogger（字符串散格）{
//创建记录器上下文
LoggerContext上下文=新的AsyncLoggerContext（sCategory）；
//创建格式化消息工厂
MessageFactory msgFactory=新格式化的MessageFactory（）；
MyLog4j2Logger=新的MyLog4j2Logger（上下文、sCategory、，
MSG工厂）；
RandomAccessFileAppender appender=RandomAccessFileAppender
.createAppender(
“C:\\temp\\App.log”，//文件名
“true”，//追加
“file_appender-”+sCategory，//名称
“true”，//立即刷新
“”，//缓冲区大小
“true”，//忽略异常
PatternLayout.createLayout(
“%-5p-[%d]-[%t]-[%l]：%m%n”，空，
null，“UTF-8”，“true”，sCategory），null，//过滤器
“false”，//广告
null，//广告商URI
空//配置
);
ConsoleAppender ConsoleAppender=ConsoleAppender.createAppender(
PatternLayout.createLayout（“%-5p-[%d]-[%t]-[%l]：%m%n”，
空，空，“UTF-8”，空，空），空，空，
“控制台”，空，空）；
appender.start（）；
consoleApender.stop（）；
logger.getContext（）.getConfiguration（）.getLoggerConfig（sCategory）
.addAppender（appender，Level.TRACE，null）；
logger.getContext（）.getConfiguration（）.getLoggerConfig（sCategory）
.addAppender（consoleAppender，Level.OFF，null）；
System.out.println（logger.getContext（）.getConfiguration（））
.getAppenders（））；
返回记录器；
}
公共静态void main（字符串[]args）{
MyLog4j2Logger logger=MyLog4j2Logger.getCustomLogger（“测试”）；
调试（“调试消息”）；
logger.error（“error MSG”）；
logger.info（“info msg”）；
}
}

---

Log4j2中的AsyncLogger完成了代码段所做的一切（以及更多）。我会检查并为您的应用程序配置它，以降低代码的复杂性。

Log4j初始化非常复杂。我确信可以创建只执行log4j的一些初始化并且仍然可以工作的自定义代码，但是我不明白为什么要这样做。基于标准配置的log4j-2.0初始化是否存在问题？（在这种情况下，我想了解p

        import java.util.HashMap;

        import org.apache.logging.log4j.Level;
        import org.apache.logging.log4j.core.LoggerContext;
        import org.apache.logging.log4j.core.appender.ConsoleAppender;
        import org.apache.logging.log4j.core.appender.RandomAccessFileAppender;
        import org.apache.logging.log4j.core.async.AsyncLoggerContext;
        import org.apache.logging.log4j.core.layout.PatternLayout;
        import org.apache.logging.log4j.message.FormattedMessageFactory;
        import org.apache.logging.log4j.message.MessageFactory;

        public final class MyLog4j2Logger extends
                org.apache.logging.log4j.core.async.AsyncLogger {

            private static HashMap<String, MyLog4j2Logger> logCache = new HashMap<String, MyLog4j2Logger>(4);

            private MyLog4j2Logger(LoggerContext context, String name,MessageFactory msgFactory) {
                super(context, name, msgFactory);
                System.out.println("Using AsyncLogger");

                // Set to all levels
                this.setLevel(Level.ALL);
            }

            /*
            * Factory Method that returns an instance of Logger. returns if the
            * instance is already present in the Hash Table else creates now and
            * returns it.
            */
            public final static MyLog4j2Logger getCustomLogger(String sCategory) {
                try {
                    System.setProperty("Log4jContextSelector",
                            "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector");
                    // Check if Instance is already present for the Category
                    if (logCache.containsKey(sCategory)) {
                        MyLog4j2Logger logger = logCache.get(sCategory);
                        logger.info("Getting already created logger for " + sCategory);
                        return logger;
                    } else {

                        // Create a new custom logger for this category
                        MyLog4j2Logger customLogger = configureCategoryLogger(sCategory);

                        // Add the custom logger to Table.
                        logCache.put(sCategory, customLogger);

                        customLogger.info("Created a New Logger for " + sCategory);

                        return (MyLog4j2Logger) customLogger;
                    }
                } catch (Exception exp) {
                    System.out
                            .println("Exception thrown while fetching Logger instance");
                    exp.printStackTrace();
                }

                return null;

            }

            private static MyLog4j2Logger configureCategoryLogger(String sCategory) {

                // Create logger context
                LoggerContext context = new AsyncLoggerContext(sCategory);

                // Create formatted message factory
                MessageFactory msgFactory = new FormattedMessageFactory();

                MyLog4j2Logger logger = new MyLog4j2Logger(context, sCategory,
                        msgFactory);

                RandomAccessFileAppender appender = RandomAccessFileAppender
                        .createAppender(
                                "C:\\temp\\App.log",// filename
                                "true",// append
                                "file_appender-" + sCategory,// name
                                "true",// immediateFlush
                                "",// bufferSize
                                "true",// ignoreExceptions
                                PatternLayout.createLayout(
                                        "%-5p - [%d] - [%t] - [%l]  : %m%n", null,
                                        null, "UTF-8", "true", sCategory), null,// filter
                                "false",// advertise
                                null,// advertiseURI
                                null// config
                        );

                ConsoleAppender consoleAppender = ConsoleAppender.createAppender(
                        PatternLayout.createLayout("%-5p - [%d] - [%t] - [%l]  : %m%n",
                                null, null, "UTF-8", null, null), null, null,
                        "Console", null, null);

                appender.start();
                consoleAppender.stop();
                logger.getContext().getConfiguration().getLoggerConfig(sCategory)
                        .addAppender(appender, Level.TRACE, null);
                logger.getContext().getConfiguration().getLoggerConfig(sCategory)
                        .addAppender(consoleAppender, Level.OFF, null);
                System.out.println(logger.getContext().getConfiguration()
                        .getAppenders());

                return logger;

            }

            public static void main(String[] args) {

                MyLog4j2Logger logger = MyLog4j2Logger.getCustomLogger("TESTING");
                logger.debug("Debug MSG");
                logger.error("Error MSG");
                logger.info("INFO msg");

            }

        }