Logback配置

2018-06-18 00:39:51来源：未知阅读 ()

首先，看一段真实的配置

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <configuration debug="true">
  3     <springProperty scope="context" name="logLevel" source="log.level"/>
  4     <springProperty scope="context" name="logPath" source="log.path"/>
  5 
  6     <!-- 输出格式 -->
  7     <property name="out.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5p] [%t] [%c][%L] - %m%n" />
  8     <!-- 活动文件的大小 -->
  9     <property name="max.file.size" value="500MB"/>
 10     <!-- 保留的归档文件的最大数量 -->
 11     <property name="max.history" value="30"/>
 12     <!-- 控制所有归档日志文件的总大小 -->
 13     <property name="total.size.cap" value="30GB"/>
 14 
 15     <!-- 控制台 -->
 16     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
 17         <withJansi>true</withJansi>
 18         <encoder>
 19             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%highlight(%-5p)] [%t] [%cyan(%c)][%L] - %m%n</pattern>
 20         </encoder>
 21     </appender>
 22 
 23     <!-- DEBUG日志 -->
 24     <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
 25         <file>${logPath}/debug.log</file>
 26         <filter class="ch.qos.logback.classic.filter.LevelFilter">
 27             <level>DEBUG</level>
 28             <onMatch>ACCEPT</onMatch>
 29             <onMismatch>DENY</onMismatch>
 30         </filter>
 31         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
 32             <fileNamePattern>${logPath}/debug.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
 33             <maxFileSize>${max.file.size}</maxFileSize>
 34             <maxHistory>${max.history}</maxHistory>
 35             <totalSizeCap>${total.size.cap}</totalSizeCap>
 36         </rollingPolicy>
 37         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 38             <pattern>${out.pattern}</pattern>
 39             <charset>UTF-8</charset>
 40         </encoder>
 41     </appender>
 42 
 43     <!-- INFO日志 -->
 44     <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
 45         <file>${logPath}/info.log</file>
 46         <filter class="ch.qos.logback.classic.filter.LevelFilter">
 47             <level>INFO</level>
 48             <onMatch>ACCEPT</onMatch>
 49             <onMismatch>DENY</onMismatch>
 50         </filter>
 51         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
 52             <fileNamePattern>${logPath}/info.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
 53             <maxFileSize>${max.file.size}</maxFileSize>
 54             <maxHistory>${max.history}</maxHistory>
 55             <totalSizeCap>${total.size.cap}</totalSizeCap>
 56         </rollingPolicy>
 57         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 58             <pattern>${out.pattern}</pattern>
 59             <charset>UTF-8</charset>
 60         </encoder>
 61     </appender>
 62 
 63     <!-- ERROR日志 -->
 64     <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
 65         <file>${logPath}/error.log</file>
 66         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 67             <level>ERROR</level>
 68         </filter>
 69         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
 70             <fileNamePattern>${logPath}/error.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
 71             <maxFileSize>${max.file.size}</maxFileSize>
 72             <maxHistory>${max.history}</maxHistory>
 73             <totalSizeCap>${total.size.cap}</totalSizeCap>
 74         </rollingPolicy>
 75         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 76             <pattern>${out.pattern}</pattern>
 77             <charset>UTF-8</charset>
 78         </encoder>
 79     </appender>
 80 
 81     <!-- logger命中中包含Mapper的单独输出到一个文件 -->
 82     <appender name="SQL_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
 83         <file>${logPath}/sql.log</file>
 84         <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
 85             <evaluator class="ch.qos.logback.classic.boolex.JaninoEventEvaluator">
 86                 <expression>logger.contains("Mapper")</expression>
 87             </evaluator>
 88             <onMatch>ACCEPT</onMatch>
 89             <onMismatch>DENY</onMismatch>
 90         </filter>
 91         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 92             <fileNamePattern>${logPath}/sql.%d{yyyy-MM-dd}.log</fileNamePattern>
 93             <maxHistory>${max.history}</maxHistory>
 94             <totalSizeCap>${total.size.cap}</totalSizeCap>
 95         </rollingPolicy>
 96         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 97             <pattern>${out.pattern}</pattern>
 98         </encoder>
 99     </appender>
100 
101     <appender name="OTHER_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
102         <file>logFile.log</file>
103         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
104             <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
105             <maxHistory>${max.history}</maxHistory>
106             <totalSizeCap>${total.size.cap}</totalSizeCap>
107         </rollingPolicy>
108         <encoder>
109             <pattern>${out.pattern}</pattern>
110         </encoder>
111     </appender>
112 
113     <!-- com.ourhours.coupon.service包下的日志都输出到单独一个文件 -->
114     <logger name="com.ourhours.coupon.service" level="INFO">
115         <appender-ref ref="OTHER_FILE" />
116     </logger>
117 
118     <root level="${logLevel}">
119         <appender-ref ref="STDOUT" />
120         <appender-ref ref="DEBUG_FILE" />
121         <appender-ref ref="INFO_FILE" />
122         <appender-ref ref="ERROR_FILE" />
123         <appender-ref ref="SQL_FILE" />
124     </root>
125 
126 </configuration>

1. Appender

1.1. ConsoleAppender

输出到控制台

1.2. FileAppender

输出到文件

1.3. RollingFileAppender

RollingFileAppender继承自FileAppender，并有滚动日志文件的能力。

RollingFileAppender有两个重要的组件。第一个组件是RollingPolicy，它决定怎样滚动；第二个组件是TriggeringPolicy，它决定什么时候执行滚动。

从字面上也很好理解，触发策略决定什么时候发生滚动，而滚动策略则定义当滚动发生的时候做什么。因此，RollingPolicy就是what，TriggeringPolicy就是when。

Thus, RollingPolicy is responsible for the what and TriggeringPolicy is responsible for the when.

RollingPolicy

TimeBasedRollingPolicy

TimeBasedRollingPolicy是最受欢迎的rolling策略。它是基于时间的，例如：按天或者按月。

Size and time based rolling policy

有时候你可能希望按天归档文件，与此同时还想限制每个日志文件的大小。为了达到这个目的，可以使用SizeAndTimeBasedRollingPolicy

注意，TimeBasedRollingPolicy已经运行你限制总的日志文件大小。通过设置totalSizeCap。

Both the %i and %d tokens are mandatory.

注意，%i和%d是强制的。每次当前日志达到maxFileSize时将被归档，并且带一个自增的从0开始的index。

SizeBasedTriggeringPolicy

SizeBasedTriggeringPolicy只接受一个参数，参数的名字是maxFileSize，它的默认值是10MB。

SizeBasedTriggeringPolicy accepts only one parameter, namely maxFileSize, with a default value of 10 MB.

maxFileSize的单位可以是字节，KB，MB，GB

例如：5000000，5000KB，5MB，2GB这些都是有效的值，而且它们等价的。

2. Filter

Filter有三种回复，分别是ACCEPT（接受）、NEUTRAL（不接受也不拒绝）、DENY（拒绝）。

2.1. LevelFilter

LevelFilter是基于事件的级别来过滤的，如果事件的级别与配置的级别相等，接受或者拒绝这个事件取决于onMatch和onMismatch配置。

2.2. ThresholdFilter

ThresholdFilter过滤器是基于threshold（阈值）过滤的。对于级别等于或者高于threshold的事件，当它的decide()方法被调用的时候ThresholdFilter过滤器将回复NEUTRAL。

级别低于threshold的事件将被拒绝。

2.3. EvaluatorFilter

EvaluatorFilter是EventEvaluator的一个封装。EventEvaluator会计算给定的事件是否满足指定的条件。

通过指定onMatch和onMismatch属性，EvaluatorFilter将返回匹配还是不匹配。

注意，EventEvaluator是一个抽象类，你可以实现自己的逻辑。

JaninoEventEvaluator

JaninoEventEvaluator是EventEvaluator的一个具体实现。

JaninoEventEvaluator用任意的Java代码块返回的一个boolean值作为条件计算的结果。我们把这种Java语音的boolean表达式称之为“计算表达式”。计算表达式在计算过程中非常灵活。

JaninoEventEvaluator需要Janino库。因此，为了使用JaninoEventEvaluator。我们需要引入一个jar包。

JaninoEventEvaluator taking an arbitrary Java language block returning a boolean value as the evaluation criteria.

We refer to such Java language boolean expressions as "evaluation expressions".

Evaluation expressions enable great flexibility in event filtering.

JaninoEventEvaluator requires the Janino library.

计算表达式在当前的日志事件中被计算。为了能够在计算表达式中访问当前事件的属性，Logback-classic自动将日志事件的各种字段导出并作为变量以供计算表达式使用。