devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot slf4j log4j2 动态创建日志的方法_log4j2 routingappender

作者：天景科技苑 | 2024-07-29 07:14:39

赞

踩

log4j2 routingappender

 

Java日志框架

作为一个Java程序员，肯定离不开日志框架，现在最优秀的Java日志框架是Log4j2，没有之一。根据官方的测试表明，在多线程环境下，Log4j2的异步日志表现更加优秀。在异步日志中，Log4j2使用独立的线程去执行I/O操作，可以极大地提升应用程序的性能。

在官方的测试中，下图比较了Sync、Async Appenders和Loggers all async三者的性能。其中Loggers all async表现最为出色，而且线程数越多，Loggers all async性能越好。

b9a258ea5b0d1248a36de147459e0861.png

除了对Log4j2自身的不同模式做对比以外，官方还做了Log4j2/Log4j1/Logback的对比，如下图所示

a8efcc5ca91280253430ffa69aa1505a.png

其中，Loggers all async是基于LMAX Disruptor实现的。

使用Log4j2

需要哪些JAR

使用Log4j2最少需要两个JAR，分别是log4j-api-2.x和log4j-core-2.x，其它JAR包根据应用程序需要添加。

配置文件位置

默认的，Log4j2在classpath下寻找名为log4j2.xml的配置文件。也可以使用system property指定配置文件的全路径。-Dlog4j.configurationFile=path/to/log4j2.xml，在Java代码中指定路径如下所示

  1.  
  2. import org.apache.logging.log4j.LogManager;
  3.  
  4. import org.apache.logging.log4j.core.LoggerContext;
  5.  
  6. import java.io.File;
  7.  
  8. public class Demo {
  9.  
  10. public static void main(String[] args) {
  11.  
  12.      LoggerContext loggerContext = (LoggerContext) LogManager.getContext(false);
  13.  
  14.      File file = new File("path/to/a/different/log4j2.xml");
  15.  
  16.      loggerContext.setConfigLocation(file.toURI());
  17.  
  18.    }
  19.  
  20. }
  21.  
 
 

 

一般的，不需要手动关闭Log4j2，如果想手动在代码中关闭Log4j2如下所示

  1. package com;
  2.  
  3. import org.apache.logging.log4j.LogManager;
  4. import org.apache.logging.log4j.core.LoggerContext;
  5. import org.apache.logging.log4j.core.config.Configurator;
  6.  
  7. public class Demo {
  8. 	public static void main(String[] args) {
  9. 		Configurator.shutdown((LoggerContext) LogManager.getContext());
  10. 	}
  11. }
 
 

有关Log4j2的内容很多，不能一一列出，如果在开发中遇到任何问题，推荐去官方文档中寻找解决方案。

不同的线程输出日志到不同的文件中

方法一使用ThreadContext

在多线程编程中，如果不做特殊的设置，那么多个线程的日志会输出到同一个日志文件中，这样在查阅日志的时候，会带来诸多不便。很自然地，我们想到了让不同的线程输出日志到不同的文件中，这样不是更好吗？在翻阅官方文档过程中，找到了FAQ（Frequently Asked Questions），其中有个问题How do I dynamically write to separate log files?正是我们所需要的。根据提示步步推进可以顺利解决该问题。其中log4j2.xml配置如下：

 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="OFF">
  3. 	<Appenders>
  4. 		<Routing name="Routing">
  5. 			<Routes pattern="$${ctx:ROUTINGKEY}">
  6. 				<!-- This route is chosen if ThreadContext has value 'special' for key 
  7. 					ROUTINGKEY. -->
  8. 				<Route key="special">
  9. 					<RollingFile name="Rolling-${ctx:ROUTINGKEY}"
  10. 						fileName="logs/special-${ctx:ROUTINGKEY}.log"
  11. 						filePattern="./logs/${date:yyyy-MM}/${ctx:ROUTINGKEY}-special-%d{yyyy-MM-dd}-%i.log.gz">
  12. 						<PatternLayout>
  13. 							<Pattern>%d{ISO8601} [%t] %p %c{3} - %m%n</Pattern>
  14. 						</PatternLayout>
  15. 						<Policies>
  16. 							<TimeBasedTriggeringPolicy interval="6"
  17. 								modulate="true" />
  18. 							<SizeBasedTriggeringPolicy size="10 MB" />
  19. 						</Policies>
  20. 					</RollingFile>
  21. 				</Route>
  22. 				<!-- This route is chosen if ThreadContext has no value for key ROUTINGKEY. -->
  23. 				<Route key="$${ctx:ROUTINGKEY}">
  24. 					<RollingFile name="Rolling-default"
  25. 						fileName="logs/default.log"
  26. 						filePattern="./logs/${date:yyyy-MM}/default-%d{yyyy-MM-dd}-%i.log.gz">
  27. 						<PatternLayout>
  28. 							<pattern>%d{ISO8601} [%t] %p %c{3} - %m%n</pattern>
  29. 						</PatternLayout>
  30. 						<Policies>
  31. 							<TimeBasedTriggeringPolicy interval="6"
  32. 								modulate="true" />
  33. 							<SizeBasedTriggeringPolicy size="10 MB" />
  34. 						</Policies>
  35. 					</RollingFile>
  36. 				</Route>
  37. 				<!-- This route is chosen if ThreadContext has a value for ROUTINGKEY 
  38. 					(other than the value 'special' which had its own route above). The value 
  39. 					dynamically determines the name of the log file. -->
  40. 				<Route>
  41. 					<RollingFile name="Rolling-${ctx:ROUTINGKEY}"
  42. 						fileName="logs/other-${ctx:ROUTINGKEY}.log"
  43. 						filePattern="./logs/${date:yyyy-MM}/${ctx:ROUTINGKEY}-other-%d{yyyy-MM-dd}-%i.log.gz">
  44. 						<PatternLayout>
  45. 							<pattern>%d{ISO8601} [%t] %p %c{3} - %m%n</pattern>
  46. 						</PatternLayout>
  47. 						<Policies>
  48. 							<TimeBasedTriggeringPolicy interval="6"
  49. 								modulate="true" />
  50. 							<SizeBasedTriggeringPolicy size="10 MB" />
  51. 						</Policies>
  52. 					</RollingFile>
  53. 				</Route>
  54. 			</Routes>
  55. 		</Routing>
  56. 		<!--很直白，Console指定了结果输出到控制台 -->
  57. 		<Console name="ConsolePrint" target="SYSTEM_OUT">
  58. 			<PatternLayout
  59. 				pattern="%d{yyyy.MM.dd HH:mm:ss z} %t %-5level %class{36} %L %M - %msg%xEx%n" />
  60. 		</Console>
  61. 	</Appenders>
  62. 	<Loggers>
  63. 		<!-- 级别顺序（低到高）：TRACE < DEBUG < INFO < WARN < ERROR < FATAL -->
  64. 		<Root level="DEBUG" includeLocation="true">
  65. 			<!--AppenderRef中的ref值必须是在前面定义的appenders -->
  66. 			<AppenderRef ref="Routing" />
  67. 			<AppenderRef ref="ConsolePrint" />
  68. 		</Root>
  69. 	</Loggers>
  70. </Configuration>

 

测试类如下所示

  1. package com;
  2.  
  3. import lombok.extern.log4j.Log4j2;
  4. import org.apache.logging.log4j.ThreadContext;
  5.  
  6. @Log4j2
  7. public class TestLog {
  8. 	public static void main(String[] args) {
  9. 		new Thread(() -> {
  10. 			ThreadContext.put("ROUTINGKEY", Thread.currentThread().getName());
  11. 			log.info("info");
  12. 			log.debug("debug");
  13. 			log.error("error");
  14. 			ThreadContext.remove("ROUTINGKEY");
  15. 		}).start();
  16. 		new Thread(() -> {
  17. 			ThreadContext.put("ROUTINGKEY", Thread.currentThread().getName());
  18. 			log.info("info");
  19. 			log.debug("debug");
  20. 			log.error("error");
  21. 			ThreadContext.remove("ROUTINGKEY");
  22. 		}).start();
  23. 	}
  24. }

 

 

 

运行测试类，会得到如下两个日志文件，other-Thread-1.log和other-Thread-2.log，每个日志文件对应着一个线程。该程序使用Gradle构建，依赖的JAR包如下：

 

1

2

3

4

5

 
 

dependencies {

compile 'org.projectlombok:lombok:1.16.10'

compile 'org.apache.logging.log4j:log4j-core:2.6'

compile 'org.apache.logging.log4j:log4j-api:2.6'

}

 

需要注意的一点是，每次在使用log对象之前，需要先设置ThreadContext.put("ROUTINGKEY", Thread.currentThread().getName());，设置的key和log4j2.xml配置文件中的key要一致，而value可以是任意值，参考配置文件即可理解。

有没有发现，每次使用log对象，还需要添加额外的代码，这不是恶心他妈给恶心开门——恶心到家了吗？有没有更加优雅地解决办法呢？且看下节。

方法二实现StrLookup

修改log4j2.xml配置文件如下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="OFF">
  3.     <Appenders>
  4.         <Routing name="Routing">
  5.             <Routes pattern="$${thread:threadName}">
  6.                 <Route>
  7.                     <RollingFile name="logFile-${thread:threadName}"
  8.                                  fileName="logs/concurrent-${thread:threadName}.log"
  9.                                  filePattern="logs/concurrent-${thread:threadName}-%d{MM-dd-yyyy}-%i.log">
  10.                         <PatternLayout pattern="%d %-5p [%t] %C{2} - %m%n"/>
  11.                         <Policies>
  12.                             <SizeBasedTriggeringPolicy size="50 MB"/>
  13.                         </Policies>
  14.                         <DefaultRolloverStrategy max="100"/>
  15.                     </RollingFile>
  16.                 </Route>
  17.             </Routes>
  18.         </Routing>
  19.         <Async name="async" bufferSize="1000" includeLocation="true">
  20.             <AppenderRef ref="Routing"/>
  21.         </Async>
  22.         <!--很直白，Console指定了结果输出到控制台-->
  23.         <Console name="ConsolePrint" target="SYSTEM_OUT">
  24.             <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %t %-5level %class{36} %L %M - %msg%xEx%n"/>
  25.         </Console>
  26.     </Appenders>
  27.     <Loggers>
  28.         <Root level="info" includeLocation="true">
  29.             <AppenderRef ref="async"/>
  30.             <AppenderRef ref="ConsolePrint"/>
  31.         </Root>
  32.     </Loggers>
  33. </Configuration>

 

 
 

实现StrLookup中的lookup方法，代码如下：

  1. package com;
  2.  
  3. import org.apache.logging.log4j.core.LogEvent;
  4. import org.apache.logging.log4j.core.config.plugins.Plugin;
  5. import org.apache.logging.log4j.core.lookup.StrLookup;
  6.  
  7. @Plugin(name = "thread", category = StrLookup.CATEGORY)
  8. public class ThreadLookup implements StrLookup {
  9.  
  10.  
  11.  
  12. 	@Override
  13. 	public String lookup(String key) {
  14. 		return Thread.currentThread().getName();
  15. 	}
  16.  
  17.  
  18. 	@Override
  19. 	public String lookup(LogEvent event, String key) {
  20. 		return event.getThreadName() == null ? Thread.currentThread().getName() : 
  21.           event.getThreadName();
  22. 	}
  23.  
  24.  
  25. }

 

 

 

编写测试类，代码如下：

  1. package com;
  2.  
  3. import lombok.extern.log4j.Log4j2;
  4. import org.apache.logging.log4j.ThreadContext;
  5.  
  6. @Log4j2
  7. public class TestLog {
  8. 	public static void main(String[] args) {
  9. 		new Thread(() -> {
  10. 		
  11. 			log.info("info");
  12. 			log.debug("debug");
  13. 			log.error("error");
  14. 			
  15. 		}).start();
  16. 		new Thread(() -> {
  17. 			log.info("info");
  18. 			log.debug("debug");
  19. 			log.error("error");
  20. 			
  21. 		}).start();
  22. 	}
  23. }

 

该测试类同样会得到两个日志文件，每个线程分别对应一个，但是在使用log对象之前不再需要设置ThreadContext.put("ROUTINGKEY", Thread.currentThread().getName());，是不是清爽多了。

根据官方的性能测试我们知道，Loggers all async的性能最高，但是方法一使用的是Sync模式（因为Appender默认是synchronous的），方法二使用的是Async Appender模式，那么如何更进一步让所有的Loggers都是Asynchronous的，让我们的配置更完美呢？想要使用Loggers all async还需要做一步设置，如果是Maven或Gradle项目，需要在src/main/resources目录下添加log4j2.component.properties配置文件，根据官网说明，其中内容为

 

1

 
 

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

同时还需要在classpath下添加依赖的disruptor JAR包com.lmax:disruptor:3.3.6。当配置使用了AsyncLoggerContextSelector之后，所有的Loggers就都是异步的了。有方法证明使用了Loggers all async吗，答案是有，默认的location不会传递给Loggers all async的I/O线程，所以如果不设置includeLocation=true的话，打印出来的日志中location信息是“?”，例如“2016-12-16 16:38:47,285 INFO [Thread-3] ? - info”，如果设置includeLocation=”true”之后，打印出“2016-12-16 16:39:14,899 INFO [Thread-3] TestLog - info”，Gradle构建依赖如下：

 

1

2

3

4

5

6

 
 

dependencies {

compile 'org.projectlombok:lombok:1.16.10'

compile 'org.apache.logging.log4j:log4j-core:2.6'

compile 'org.apache.logging.log4j:log4j-api:2.6'

compile 'com.lmax:disruptor:3.3.6'

}

 

不同级别的日志输出到不同的文件中

通常情况下，用到的日志级别主要是info/debug/error三个，而如果不做特殊配置，这三者信息是写到一个日志文件中的，当我们需要不同级别的日志输出到不同的文件中时，需要如何做呢？log4j2.xml配置信息如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="OFF">
  3.     <Properties>
  4.         <Property name="logFilePath">logs</Property>
  5.         <Property name="logFileName">testLog</Property>
  6.     </Properties>
  7.     <Appenders>
  8.         <!--很直白，Console指定了结果输出到控制台-->
  9.         <Console name="ConsolePrint" target="SYSTEM_OUT">
  10.             <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %t %-5level %class{36} %L %M - %msg%xEx%n"/>
  11.         </Console>
  12.         <!--<File>输出结果到指定文件</File>-->
  13.         <!--<RollingFile>同样输出结果到指定文件，但是使用buffer，速度会快点</RollingFile>-->
  14.         <!--filePattern：表示当日志到达指定的大小或者时间，产生新日志时，旧日志的命名路径。-->
  15.         <!--PatternLayout：和log4j一样，指定输出日志的格式，append表示是否追加内容，值默认为true-->
  16.         <RollingFile name="RollingFileDebug" fileName="${logFilePath}/${logFileName}-debug.log"
  17.                      filePattern="${logFilePath}/$${date:yyyy-MM}/${logFileName}-%d{yyyy-MM-dd}_%i.log.gz">
  18.             <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  19.             <!--注意，如果有多个ThresholdFilter，那么Filters标签是必须的-->
  20.             <Filters>
  21.                 <!--首先需要过滤不符合的日志级别，把不需要的首先DENY掉，然后在ACCEPT需要的日志级别，次序不能颠倒-->
  22.                 <!--INFO及以上级别拒绝输出-->
  23.                 <ThresholdFilter level="INFO" onMatch="DENY" onMismatch="NEUTRAL"/>
  24.                 <!--只输出DEBUG级别信息-->
  25.                 <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/>
  26.             </Filters>
  27.             <Policies>
  28.                 <!--时间策略，每隔24小时产生新的日志文件-->
  29.                 <TimeBasedTriggeringPolicy/>
  30.                 <!--大小策略，每到30M时产生新的日志文件-->
  31.                 <SizeBasedTriggeringPolicy size="30MB"/>
  32.             </Policies>
  33.         </RollingFile>
  34.         <RollingFile name="RollingFileInfo" fileName="${logFilePath}/${logFileName}-info.log"
  35.                      filePattern="${logFilePath}/$${date:yyyy-MM}/${logFileName}-%d{yyyy-MM-dd}_%i.log.gz">
  36.             <Filters>
  37.                 <!--onMatch:Action to take when the filter matches. The default value is NEUTRAL-->
  38.                 <!--onMismatch:    Action to take when the filter does not match. The default value is DENY-->
  39.                 <!--级别在ERROR之上的都拒绝输出-->
  40.                 <!--在组合过滤器中，接受使用NEUTRAL（中立），被第一个过滤器接受的日志信息，会继续用后面的过滤器进行过滤，只有符合所有过滤器条件的日志信息，才会被最终写入日志文件-->
  41.                 <ThresholdFilter level="ERROR" onMatch="DENY" onMismatch="NEUTRAL"/>
  42.                 <ThresholdFilter level="INFO" onMatch="ACCEPT" onMismatch="DENY"/>
  43.             </Filters>
  44.             <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  45.             <Policies>
  46.                 <TimeBasedTriggeringPolicy/>
  47.                 <SizeBasedTriggeringPolicy size="30MB"/>
  48.             </Policies>
  49.         </RollingFile>
  50.         <RollingFile name="RollingFileError" fileName="${logFilePath}/${logFileName}-error.log"
  51.                      filePattern="${logFilePath}/$${date:yyyy-MM}/${logFileName}-%d{yyyy-MM-dd}_%i.log.gz">
  52.             <Filters>
  53.                 <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY"/>
  54.             </Filters>
  55.             <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  56.             <Policies>
  57.                 <TimeBasedTriggeringPolicy/>
  58.                 <SizeBasedTriggeringPolicy size="30MB"/>
  59.             </Policies>
  60.         </RollingFile>
  61.     </Appenders>
  62.     <Loggers>
  63.         <!--logger用于定义log的level以及所采用的appender，如果无需自定义，可以使用root解决，root标签是log的默认输出形式-->
  64.         <!-- 级别顺序（低到高）：TRACE < DEBUG < INFO < WARN < ERROR < FATAL -->
  65.         <Root level="DEBUG" includeLocation="true">
  66.             <!-- 只要是级别比ERROR高的，包括ERROR就输出到控制台 -->
  67.             <!--appender-ref中的值必须是在前面定义的appenders-->
  68.             <Appender-ref level="ERROR" ref="ConsolePrint"/>
  69.             <Appender-ref ref="RollingFileDebug"/>
  70.             <Appender-ref ref="RollingFileInfo"/>
  71.             <Appender-ref ref="RollingFileError"/>
  72.         </Root>
  73.     </Loggers>
  74. </Configuration>

 

src\main\resources\log4j2.component.properties内容不变，如下

 

1

 
 

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

 

测试代码如下

  1. package com;
  2.  
  3. import lombok.extern.log4j.Log4j2;
  4.  
  5.  
  6. @Log4j2
  7. public class TestLog {
  8.  
  9.     public static void main(String[] args) {
  10.  
  11.         new Thread(() -> {
  12.             log.info("info");
  13.             log.debug("debug");
  14.             log.error("error");
  15.         }).start();
  16.  
  17.         new Thread(() -> {
  18.             log.info("info");
  19.             log.debug("debug");
  20.             log.error("error");
  21.         }).start();
  22.  
  23.  
  24.     }
  25. }

 

 

该程序会生成三份日志文件【testLog-debug.log，testLog-error.log，testLog-info.log】，如果你足够细心的话，就会发现线程1和线程2的info|debug|error信息都输出到一个info|debug|error日志文件中了。如何解决这个问题呢？换句话说，我想得到

Thread 1

Thread 1的info日志
Thread 1的debug日志
Thread 1的error日志

Thread 2

Thread 2的info日志
Thread 2的debug日志
Thread 2的error日志

六个日志文件，要如何实现呢？这正是下一节要讲述的内容。

不同线程不同级别的日志输出到不同的文件中

要实现该功能，还要从RoutingAppender身上做文章。RoutingAppender主要用来评估LogEvents，然后将它们路由到下级Appender。目标Appender可以是先前配置的并且可以由其名称引用的Appender，或者可以根据需要动态地创建Appender。RoutingAppender应该在其引用的任何Appenders之后配置，以确保它可以正确关闭。

RoutingAppender中的name属性用来指定该Appender的名字，它可以包含多个Routes子节点，用来标识选择Appender的条件，而Routes只有一个属性“pattern”，该pattern用来评估所有注册的Lookups，并且其结果用于选择路由。在Routes下可以有多个Route，每个Route都必须配置一个key，如果这个key匹配“pattern”的评估结果，那么这个Route就被选中。同时每个Route都必须引用一个Appender，如果这个Route包含一个ref属性，那么这个Route将引用一个在配置中定义的Appender，如果这个Route包含一个Appender的定义，那么这个Appender将会根据RoutingAppender的上下文创建并被重用。

废话说多了，直接上配置才简洁明了。log4j2.xml配置如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--status的含义为是否记录log4j2本身的event信息，默认是OFF-->
  3. <Configuration status="OFF">
  4.     <Properties>
  5.         <!--自定义一些常量，之后使用${变量名}引用-->
  6.         <Property name="logFilePath">logs</Property>
  7.         <Property name="logFileName">testLog</Property>
  8.     </Properties>
  9.     <Appenders>
  10.         <!--很直白，Console指定了结果输出到控制台-->
  11.         <Console name="ConsolePrint" target="SYSTEM_OUT">
  12.             <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %t %-5level %class{36} %L %M - %msg%xEx%n"/>
  13.         </Console>
  14.         <!--<File>输出结果到指定文件</File>-->
  15.         <!--<RollingFile>同样输出结果到指定文件，但是使用buffer，速度会快点</RollingFile>-->
  16.         <!--filePattern：表示当日志到达指定的大小或者时间，产生新日志时，旧日志的命名路径。-->
  17.         <!--PatternLayout：和log4j一样，指定输出日志的格式，append表示是否追加内容，值默认为true-->
  18.         <Routing name="RollingFileDebug_${thread:threadName}">
  19.             <Routes pattern="$${thread:threadName}">
  20.                 <Route>
  21.                     <RollingFile name="RollingFileDebug_${thread:threadName}"
  22.                                  fileName="${logFilePath}/${logFileName}_${thread:threadName}_debug.log"
  23.                                  filePattern="${logFilePath}/$${date:yyyy-MM}/${logFileName}-%d{yyyy-MM-dd}-${thread:threadName}-debug_%i.log.gz">
  24.                         <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  25.                         <!--注意，如果有多个ThresholdFilter，那么Filters标签是必须的-->
  26.                         <Filters>
  27.                             <!--首先需要过滤不符合的日志级别，把不需要的首先DENY掉，然后在ACCEPT需要的日志级别，次序不能颠倒-->
  28.                             <!--INFO及以上级别拒绝输出-->
  29.                             <ThresholdFilter level="INFO" onMatch="DENY" onMismatch="NEUTRAL"/>
  30.                             <!--只输出DEBUG级别信息-->
  31.                             <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/>
  32.                         </Filters>
  33.                         <Policies>
  34.                             <!--时间策略，每隔24小时产生新的日志文件-->
  35.                             <TimeBasedTriggeringPolicy/>
  36.                             <!--大小策略，每到30M时产生新的日志文件-->
  37.                             <SizeBasedTriggeringPolicy size="30MB"/>
  38.                         </Policies>
  39.                     </RollingFile>
  40.                 </Route>
  41.             </Routes>
  42.         </Routing>
  43.         <Routing name="RollingFileInfo_${thread:threadName}">
  44.             <Routes pattern="$${thread:threadName}">
  45.                 <Route>
  46.                     <RollingFile name="RollingFileInfo_${thread:threadName}"
  47.                                  fileName="${logFilePath}/${logFileName}_${thread:threadName}_info.log"
  48.                                  filePattern="${logFilePath}/$${date:yyyy-MM}/${logFileName}-%d{yyyy-MM-dd}-${thread:threadName}-info_%i.log.gz">
  49.                         <Filters>
  50.                             <!--onMatch: Action to take when the filter matches. The default value is NEUTRAL-->
  51.                             <!--onMismatch:    Action to take when the filter does not match. The default value is DENY-->
  52.                             <!--级别在ERROR之上的都拒绝输出-->
  53.                             <!--在组合过滤器中，接受使用NEUTRAL（中立），被第一个过滤器接受的日志信息，会继续用后面的过滤器进行过滤，只有符合所有过滤器条件的日志信息，才会被最终写入日志文件-->
  54.                             <ThresholdFilter level="ERROR" onMatch="DENY" onMismatch="NEUTRAL"/>
  55.                             <ThresholdFilter level="INFO" onMatch="ACCEPT" onMismatch="DENY"/>
  56.                         </Filters>
  57.                         <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  58.                         <Policies>
  59.                             <TimeBasedTriggeringPolicy/>
  60.                             <SizeBasedTriggeringPolicy size="30MB"/>
  61.                         </Policies>
  62.                     </RollingFile>
  63.                 </Route>
  64.             </Routes>
  65.         </Routing>
  66.         <Routing name="RollingFileError_${thread:threadName}">
  67.             <Routes pattern="$${thread:threadName}">
  68.                 <Route>
  69.                     <RollingFile name="RollingFileError_${thread:threadName}"
  70.                                  fileName="${logFilePath}/${logFileName}_${thread:threadName}_error.log"
  71.                                  filePattern="${logFilePath}/$${date:yyyy-MM}/${logFileName}-%d{yyyy-MM-dd}-${thread:threadName}-error_%i.log.gz">
  72.                         <Filters>
  73.                             <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY"/>
  74.                         </Filters>
  75.                         <PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  76.                         <Policies>
  77.                             <TimeBasedTriggeringPolicy/>
  78.                             <SizeBasedTriggeringPolicy size="30MB"/>
  79.                         </Policies>
  80.                     </RollingFile>
  81.                 </Route>
  82.             </Routes>
  83.         </Routing>
  84.         <!--bufferSize整数，指定可以排队的events最大数量，如果使用BlockingQueue，这个数字必须是2的幂次-->
  85.         <!--includeLocation默认值是FALSE，如果指定为TRUE，会降低性能，但是推荐设置为TRUE，否则不打印位置行信息-->
  86.         <Async name="async" bufferSize="262144" includeLocation="true">
  87.             <AppenderRef ref="RollingFileDebug_${thread:threadName}"/>
  88.             <AppenderRef ref="RollingFileInfo_${thread:threadName}"/>
  89.             <AppenderRef ref="RollingFileError_${thread:threadName}"/>
  90.             <!-- 只要是级别比ERROR高的，包括ERROR就输出到控制台 -->
  91.             <AppenderRef ref="ConsolePrint" level="ERROR"/>
  92.         </Async>
  93.     </Appenders>
  94.     <Loggers>
  95.         <!--Logger用于定义log的level以及所采用的appender，如果无需自定义，可以使用root解决，root标签是log的默认输出形式-->
  96.         <!-- 级别顺序（低到高）：TRACE < DEBUG < INFO < WARN < ERROR < FATAL -->
  97.         <Root level="DEBUG" includeLocation="true">
  98.             <!--AppenderRef中的ref值必须是在前面定义的appenders-->
  99.             <AppenderRef ref="async"/>
  100.         </Root>
  101.     </Loggers>
  102. </Configuration>

 

log4j2.component.properties和ThreadLookup类不变，依赖的JAR包和上一节一样。测试类如下

  1. package com;
  2.  
  3. import lombok.extern.log4j.Log4j2;
  4. import org.apache.logging.log4j.ThreadContext;
  5.  
  6. @Log4j2
  7. public class TestLog {
  8. 	
  9.  
  10.       public static void main(String[] args) {
  11.  
  12.         new Thread(() -> {
  13.             log.info("info");
  14.             log.debug("debug");
  15.             log.error("error");
  16.         }).start();
  17.  
  18.         new Thread(() -> {
  19.             log.info("info");
  20.             log.debug("debug");
  21.             log.error("error");
  22.         }).start();
  23.  
  24.     }
  25. }

该程序会输出六个日志文件，分别是

testLog_Thread-2_debug.log
testLog_Thread-2_error.log
testLog_Thread-2_info.log
testLog_Thread-3_debug.log
testLog_Thread-3_error.log
testLog_Thread-3_info.log

至此，就实现了不同线程不同级别的日志输出到不同文件中的功能。

如何启用All Loggers Asynchronous

为了使得所有的Loggers都是异步的，除了添加一个新的配置文件，就是log4j2.component.properties外，还有其它方式吗？有的，仅列举如下

  • 例如【IntelliJ IDEA】中使用Gradle构建项目，那么可以在Settings | Build, Execution, Deployment | Build Tools | Gradle | Gradle VM options中填入

     

    1

    		 
     

    -DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

  • 另一种就是在前面提到的ThreadLookup类中，添加静态代码块

     

    1

    2

    3

    		 
     

    static {

    System.setProperty("Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector");

    }

根据参考手册，有一点需要注意的就是，要使用<Root>或<Logger>标签，而不是<asyncRoot>和<asyncLogger>，原文如下：

When AsyncLoggerContextSelector is used to make all loggers asynchronous, make sure to use normal <root> and <logger> elements in the configuration. The AsyncLoggerContextSelector will ensure that all loggers are asynchronous, using a mechanism that is different from what happens when you configure <asyncRoot> or <asyncLogger>. The latter elements are intended for mixing async with sync loggers.

混合使用Synchronous和Asynchronous Loggers

需要disruptor-3.0.0.jar或更高版本的jar包，不需要设置系统属性Log4jContextSelector，在配置中可以混合使用Synchronous和asynchronous loggers，使用<AsyncRoot>或者<AsyncLogger>去指定需要异步的Loggers，<AsyncLogger>元素还可以包含<Root>和<Logger>用于同步的Loggers。注意如果使用的是<AsyncRoot>或者<AsyncLogger>，那么就无需设置系统属性Log4jContextSelector了。

一个混合了同步和异步的Loggers配置如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!-- No need to set system property "Log4jContextSelector" to any value
  3.      when using <asyncLogger> or <asyncRoot>. -->
  4. <Configuration status="WARN">
  5.   <Appenders>
  6.     <!-- Async Loggers will auto-flush in batches, so switch off immediateFlush. -->
  7.     <RandomAccessFile name="RandomAccessFile" fileName="asyncWithLocation.log"
  8.               immediateFlush="false" append="false">
  9.       <PatternLayout>
  10.         <Pattern>%d %p %class{1.} [%t] %location %m %ex%n</Pattern>
  11.       </PatternLayout>
  12.     </RandomAccessFile>
  13.   </Appenders>
  14.   <Loggers>
  15.     <!-- pattern layout actually uses location, so we need to include it -->
  16.     <AsyncLogger name="com.foo.Bar" level="trace" includeLocation="true">
  17.       <AppenderRef ref="RandomAccessFile"/>
  18.     </AsyncLogger>
  19.     <Root level="info" includeLocation="true">
  20.       <AppenderRef ref="RandomAccessFile"/>
  21.     </Root>
  22.   </Loggers>
  23. </Configuration>

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/897677
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。