java logback日志

最新推荐文章于 2023-10-21 19:55:24 发布

SeaSky_Steven

最新推荐文章于 2023-10-21 19:55:24 发布

阅读量315

点赞数

分类专栏： Java 文章标签： java logback 日志 log

Java 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

在java开发中，日志系统是java项目中必不可少的组成部分。日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。我们在日常开发中主要使用的java日志框架组件是：log4j、SLF4J、Commons Logging

日志级别一般分为7个打印级别（不同的日志框架组件可能打印的日志级别区别不大）：

OFF-关闭所有日志；

FATAL-记录严重的错误，并且会导致应用程序退出；

ERROR-记录严重的错误，但不会影响程序的运行；

WARN-记录警告；

INFO-记录程序中比较有意义的信息；

DEBUG-记录程序中的细节信息；

ALL-记录所有的日志；

    package logging;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

    public class LogTest {

       private static Logger logger = LoggerFactory.getLogger(LogTest.class);

       public static void main(String[] args) {
           logger.trace("trace.......");
           logger.debug("debug.......");
           logger.info("info.......");
           logger.warn("warn.......");
           logger.error("error.......");
           String exception = "exception";
           String excepDesc = "exception desc";
           String[] err = {"error", "error desc"};
           //提供了占位符"{}"，使书写布局更加灵活。占位符减少了日志信息中字符串的拼接，减少了内存和cpu的性能消耗。
           logger.info("problem: {}", exception);
           logger.info("problem: {},{}", exception, excepDesc);
           logger.info("problem: {},{}", err);
       }
    }

因为没有配置文件，log日志会默认在控制台输出结果：

    12:11:49.888 [main] DEBUG logging.LogTest - debug.......
    12:11:49.905 [main] INFO logging.LogTest - info.......
    12:11:49.906 [main] WARN logging.LogTest - warn.......
    12:11:49.906 [main] ERROR logging.LogTest - error.......
    12:11:49.906 [main] INFO logging.LogTest - problem: exception
    12:11:49.908 [main] INFO logging.LogTest - problem: exception,exception desc
    12:11:49.909 [main] INFO logging.LogTest - problem: error,error desc

下面就讲一下日志的配置文件logback.xml。

由以上的代码可知，配置文件有一个根节点<configuration></configuration>，根节点有三个属性scan，scanPeriod，debug。

1、scan：当此属性设置为true时，配置文件发生改变时，将会重新加载该配置文件。默认值是true。

2、scanPeriod：设置监测配置文件是否发生改变的时间间隔。当scan为true时该属性才会生效。默认的时间间隔是60000毫秒。

3、debug：此属性设置为true时，会打印出logback内部日志信息，这个属性默认为false。建议不要开启，因为会打印很多无用日志，影响对项目的观察。

下图是<configuration>标签中包含的标签：

1、<contextName>：每个logger都关联到logger上下文，默认上下文的名称是“default”。但可以使用此标签设置为其他名字，用于区分不同应用程序的记录。一旦设置，不允许更改。

2、<property>用来定义变量值的标签，此标签有两个属性，name（变量的名称）和value（变量定义的值），通过这个标签定义的变量可以通过“${}”应用到其他标签中。

    －X: X信息输出时左对齐
    %p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
    %d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy-MM-dd HH:mm:ss,SSS}，输出类似：2011-10-18 22:10:28,921
    %r: 输出自应用启动到输出该log信息耗费的毫秒数
    %c: 输出日志信息所属的类目，通常就是所在类的全名
    %t: 输出产生该日志事件的线程名
    %l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。
    %x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
    %%: 输出一个"%"字符
    %F: 输出日志消息产生时所在的文件名称
    %L: 输出代码中的行号
    %m: 输出代码中指定的消息,产生的日志具体信息
    %n: 输出一个回车换行符，Windows平台为"\r\n"，Unix平台为"\n"输出日志信息换行

    可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
    1)%20c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
    2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。
    3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
    4)%20.30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边交远销出的字符截掉

    log4j.rootLogger=warn,myconsole,errinfo

    #输出到控制台的日志
    log4j.appender.myconsole=org.apache.log4j.ConsoleAppender
    log4j.appender.myconsole.layout=org.apache.log4j.PatternLayout
    #log4j.appender.myconsole.Threshold=warn
    log4j.appender.myconsole.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p [%t] (%F:%L) - %m%n

    #输出到文件的异常日志文件
    log4j.appender.errinfo=org.apache.log4j.FileAppender
    log4j.appender.errinfo.File=D:/ERROR.LOG
    log4j.appender.errinfo.Threshold =ERROR
    log4j.appender.errinfo.layout=org.apache.log4j.PatternLayout
    log4j.appender.errinfo.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p [%t] (%F:%L) - %m%n

3、<timestamp>：获取时间戳，有两个属性key（标识标签的名字，可以理解为变量名）和datePattern（设置将解析配置文件的时间转换成字符串，符合java.txt.SimpleDateFormat的格式）。

4、<logger>：用来设置某一个包或者某一个具体类的日志打印级别，以及指定<appender>。<logger>有三个属性：name、level和additivity。

（1）name：用来指定需要设置的包或者类的名称；

（2）level：用来设置打印级别，TRACE，DEBUG，INFO，WARN，ERROR，ALL，OFF，还有INHERITED或者NULL（代表强制执行上级的级别），如果没有设置level，那么logger将会继承上级的级别。

（3）additivity：是否向上级logger传递打印信息默认是true。

<logger>可以包含0个或多个<appender-ref>元素，标识<appender>会添加到该<logger>。

5、<root>：相当于"根<logger>"，只有一个level属性，没有INHERITED或者NULL，默认为debug。

6、<appender>：是负责写日志的组件。有两个属性name（appender名称）和class（appender的全限定名）。

appender的全限定名。

（1）、ConsoleAppender：把日志添加到控制台，有两个子节点<encoder>（对日志进行格式化）和<target>（System.out或者System.err，默认是System.out）；

（2）、FileAppender：把日志添加到文件，其子节点有

<file>（被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在，会自动创建）、

<append>（如果是true，日志被追加到文件结尾，如果是false，清空现存文件，默认是true）、

<encoder>（格式化）

<prudent>（如果是true，日志会被安全的写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认是false）。

（3）、RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。其子节点有：

<file>（被写入的文件名）

<rollingPolicy>（当发生滚动时，决定RollingFileAppender的行为，涉及文件移动和重命名）

rollingPolicy：（1）、TimeBaseRollingPolicy：最常用的滚动策略，它根据时间来指定滚动策略，既负责滚动也负责触发滚动。其子节点有：

<fileNamePattern>：必要节点，包含文件名及“%d”转换符（可以按照SimpleDateForm格式来表示时间，例如：%d{yyyyMM}），

（2）、RollingFilePolicy:它的file子节点可有可无，通过设置file，可以为活动文件和归档文件指定不同位置，当前日志总是记录到file指定的文件（活动文件），活动文件的名字不会改变；如果没设置file，活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次。“/”和“\”会被作为文件分割符。

<maxHistory>：可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每个月滚动，且<maxHistory>是6，则只保存最近6个月的文件，删除之前的旧文件。注意，删除旧文件时，那些为了归档而创建的目录也会被删除。

（3）、FixedWindowRollingPolicy：根据固定窗口算法重命名文件的滚动策略。其子节点如下：

<minIndex>：窗口索引最小值。

<maxIndex>：窗口索引最大值，当用户指定的窗口过大时，会自动将窗口设置成12。

<fileNamePattern>：必须包含“%i”，例如：假设最小值和最大值分别为1和2，命名模式为mylog%i.log，会产生归档文件mylog1.log和 mylog2.log。还可以指定文件压缩选项，例如：mylog%i.log.gz或者mylog%i.log.zip。

<triggeringPolicy>（通知RollingFileApender何时启动滚动）

（1）、triggeringPolicy：

a、SizeBasedTriggeringPolicy：查看当前活动文件的大小，如果超过指定大小会通知。

b、RollingFileAppender：触发当前活动文件滚动。只有一个节点：

<maxFileSize>：这时活动文件的大小，默认为10MB。

<prudent>（当为true时，不支持FixedWindowRollingPolicy。支持TimeBaseRollingPolicy，但是有两个限制，1、不支持也不允许文件压缩，2、不能设置file属性，必须留空）。

<encoder>：负责两件事，一是把日志信息转化为字节数组，二是把字节数据写入到输出流。目前PatternLayoutEncoder是唯一有用的且默认的encoder，有一个<pattern>节点，用来设置日志的输入格式。使用“%”加转换符的方式，如果要输出“%”，必须要用“\”对“\%“进行转义。

pattern里的转换符说明：

c {length }
lo {length }
logger {length }    输出日志的logger名，可有一个整形参数，功能是缩短logger名，设置为0表示只输入logger最右边点符号之后的字符串。 Conversion specifier Logger name Result
%logger    mainPackage.sub.sample.Bar    mainPackage.sub.sample.Bar
%logger{0}    mainPackage.sub.sample.Bar    Bar
%logger{5}    mainPackage.sub.sample.Bar    m.s.s.Bar
%logger{10}    mainPackage.sub.sample.Bar    m.s.s.Bar
%logger{15}    mainPackage.sub.sample.Bar    m.s.sample.Bar
%logger{16}    mainPackage.sub.sample.Bar    m.sub.sample.Bar
%logger{26}    mainPackage.sub.sample.Bar    mainPackage.sub.sample.Bar

C {length }
class {length }    输出执行记录请求的调用者的全限定名。参数与上面的一样。尽量避免使用，除非执行速度不造成任何问题。
contextName
cn    输出上下文名称。
d {pattern }
date {pattern }    输出日志的打印日志，模式语法与java.text.SimpleDateFormat 兼容。 Conversion Pattern Result
%d    2006-10-20 14:06:49,812
%date    2006-10-20 14:06:49,812
%date{ISO8601}    2006-10-20 14:06:49,812
%date{HH:mm:ss.SSS}    14:06:49.812
%date{dd MMM yyyy ;HH:mm:ss.SSS}    20 oct. 2006;14:06:49.812
F / file    输出执行记录请求的java源文件名。尽量避免使用，除非执行速度不造成任何问题。
caller{depth}caller{depth, evaluator-1, ... evaluator-n}    输出生成日志的调用者的位置信息，整数选项表示输出信息深度。

例如， %caller{2} 输出为：

0    [main] DEBUG - logging statement
Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)

例如， %caller{3} 输出为：

16   [main] DEBUG - logging statement
Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)
Caller+2   at mainPackage.ConfigTester.main(ConfigTester.java:38)

L / line 输出执行日志请求的行号。尽量避免使用，除非执行速度不造成任何问题。
m / msg / message

输出应用程序提供的信息。
M / method    输出执行日志请求的方法名。尽量避免使用，除非执行速度不造成任何问题。
n    输出平台先关的分行符“\n”或者“\r\n”。
p / le / level    输出日志级别。
r / relative    输出从程序启动到创建日志记录的时间，单位是毫秒
t / thread    输出产生日志的线程名。
replace(p ){r, t}

p 为日志内容，r 是正则表达式，将p 中符合r 的内容替换为t 。

例如， "%replace(%msg){'\s', ''}"

例如， %caller{2} 输出为：

0    [main] DEBUG - logging statement
Caller+0   at mainPackage.sub.sample.Bar.sampleMethodName(Bar.java:22)
Caller+1   at mainPackage.sub.sample.Bar.createLoggingRequest(Bar.java:17)

例如， %caller{3} 输出为：

L / line 输出执行日志请求的行号。尽量避免使用，除非执行速度不造成任何问题。
m / msg / message

p 为日志内容，r 是正则表达式，将p 中符合r 的内容替换为t 。

例如， "%replace(%msg){'\s', ''}"

格式修饰符，与转换符共同使用：
可选的格式修饰符位于“%”和转换符之间。
第一个可选修饰符是左对齐标志，符号是减号“-”；接着是可选的最小宽度修饰符，用十进制数表示。如果字符小于最小宽度，则左填充或右填充，默认是左填充（即右对齐），填充符为空格。如果字符大于最小宽度，字符永远不会被截断。最大宽度修饰符，符号是点号"."后面加十进制数。如果字符大于最大宽度，则从前面截断。点符号“.”后面加减号“-”在加数字，表示从尾部截断。

例如：%-4relative 表示，将输出从程序启动到创建日志记录的时间进行左对齐且最小宽度为4。
---------------------
作者：认真的学生
来源：CSDN
原文：https://blog.csdn.net/u013473691/article/details/52708509/
版权声明：本文为博主原创文章，转载请附上博文链接！

maven配置：

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.7</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
        <version>1.1.7</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-access</artifactId>
        <version>1.1.7</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.1.7</version>
    </dependency>

logback.xml配置：

<configuration scan="true" scanPeriod="60 seconds" debug="false">
        
        <jmxConfigurator />
        
        
        <property name="log_dir" value="/home/hadmin/data/logs/src" />
        
        <property name="maxHistory" value="30" />

        
        <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>
                    
                    %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n
                </pattern>
            </encoder>
        </appender>

        
        
        <appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                
                <level>ERROR</level>
                
                <onMatch>ACCEPT</onMatch>
                
                <onMismatch>DENY</onMismatch>
            </filter>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                
                <fileNamePattern>
                    ${log_dir}/error/%d{yyyy-MM-dd}/error-log.log
                </fileNamePattern>
                
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>
                    
                    %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n
                </pattern>
            </encoder>
        </appender>

        
        <appender name="WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                
                <level>WARN</level>
                
                <onMatch>ACCEPT</onMatch>
                
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                
                <fileNamePattern>${log_dir}/warn/%d{yyyy-MM-dd}/warn-log.log</fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
            </encoder>
        </appender>

        
        <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>INFO</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log_dir}/info/%d{yyyy-MM-dd}/info-log.log</fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
            </encoder>
        </appender>

        
        <appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>DEBUG</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log_dir}/debug/%d{yyyy-MM-dd}/debug-log.log</fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
            </encoder>
        </appender>

        
        <appender name="TRACE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>TRACE</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log_dir}/trace/%d{yyyy-MM-dd}/trace-log.log</fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
            </encoder>
        </appender>

        
        <root>
            
            <level value="debug" />
            
            <appender-ref ref="console" />
            
            <appender-ref ref="ERROR" />
            <appender-ref ref="INFO" />
            <appender-ref ref="WARN" />
            <appender-ref ref="DEBUG" />
            <appender-ref ref="TRACE" />
        </root>
    </configuration>

logback.xml常用配置详解

(1) 根节点<configuration>，包含下面三个属性：

scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
debug: 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。
例如：

(2) 子节点<contextName>：用来设置上下文名称，每个logger都关联到logger上下文，默认上下文名称为default。但可以使用<contextName>设置成其他名字，用于区分不同应用程序的记录。一旦设置，不能修改。

例如：

<configuration scan="true" scanPeriod="60 seconds" debug="false">
         <contextName>myAppName</contextName>
    
    </configuration>

(3) 子节点<property> ：用来定义变量值，它有两个属性name和value，通过<property>定义的值会被插入到logger上下文中，可以使“${}”来使用变量。

name: 变量的名称
value: 的值时变量定义的值
例如：

(4) 子节点<timestamp>：获取时间戳字符串，他有两个属性key和datePattern

key: 标识此<timestamp> 的名字；
datePattern: 设置将当前时间（解析配置文件的时间）转换为字符串的模式，遵循java.txt.SimpleDateFormat的格式。
例如：

<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <timestamp key="bySecond" datePattern="yyyyMMdd'T'HHmmss"/>
    <contextName>${bySecond}</contextName>
    
    </configuration>

(5) 子节点<appender>：负责写日志的组件，它有两个必要属性name和class。name指定appender名称，class指定appender的全限定名

5.1、ConsoleAppender 把日志输出到控制台，有以下子节点：
<encoder>：对日志进行格式化。（具体参数稍后讲解）
<target>：字符串System.out(默认)或者System.err（区别不多说了）
例如：

    <configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
    <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>
    </encoder>
    </appender>

    <root level="DEBUG">
    <appender-ref ref="STDOUT" />
    </root>
    </configuration>

上述配置表示把>=DEBUG级别的日志都输出到控制台

5.2、FileAppender：把日志添加到文件，有以下子节点：
<file>：被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在会自动创建，没有默认值。
<append>：如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true。
<encoder>：对记录事件进行格式化。（具体参数稍后讲解）
<prudent>：如果是 true，日志会被安全的写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认是 false。
例如：

    <configuration>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
    <file>testFile.log</file>
    <append>true</append>
    <encoder>
    <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
    </encoder>
    </appender>

    <root level="DEBUG">
    <appender-ref ref="FILE" />
    </root>
    </configuration>

上述配置表示把>=DEBUG级别的日志都输出到testFile.log

5.3、RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。有以下子节点：
<file>：被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在会自动创建，没有默认值。
<append>：如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true。
<rollingPolicy>:当发生滚动时，决定RollingFileAppender的行为，涉及文件移动和重命名。属性class定义具体的滚动策略类
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"：最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。有以下子节点：
<fileNamePattern>：必要节点，包含文件名及“%d”转换符，“%d”可以包含一个java.text.SimpleDateFormat指定的时间格式，如：%d{yyyy-MM}。
如果直接使用 %d，默认格式是 yyyy-MM-dd。RollingFileAppender的file字节点可有可无，通过设置file，可以为活动文件和归档文件指定不同位置，当前日志总是记录到file指定的文件（活动文件），活动文件的名字不会改变；
如果没设置file，活动文件的名字会根据fileNamePattern 的值，每隔一段时间改变一次。“/”或者“\”会被当做目录分隔符。
<maxHistory>:
可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每个月滚动，且<maxHistory>是6，则只保存最近6个月的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除。

class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"：查看当前活动文件的大小，如果超过指定大小会告知RollingFileAppender 触发当前活动文件滚动。只有一个节点:
<maxFileSize>:这是活动文件的大小，默认值是10MB。
<prudent>：当为true时，不支持FixedWindowRollingPolicy。支持TimeBasedRollingPolicy，但是有两个限制，1不支持也不允许文件压缩，2不能设置file属性，必须留空。

<triggeringPolicy >: 告知 RollingFileAppender 合适激活滚动。
class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy" 根据固定窗口算法重命名文件的滚动策略。有以下子节点：
<minIndex>:窗口索引最小值
<maxIndex>:窗口索引最大值，当用户指定的窗口过大时，会自动将窗口设置为12。
<fileNamePattern>:必须包含“%i”例如，假设最小值和最大值分别为1和2，命名模式为 mylog%i.log,会产生归档文件mylog1.log和mylog2.log。还可以指定文件压缩选项，例如，mylog%i.log.gz 或者没有log%i.log.zip
例如：

    <configuration>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
    <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
    <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
    <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
    </encoder>
    </appender>

    <root level="DEBUG">
    <appender-ref ref="FILE" />
    </root>
    </configuration>

备注：上述配置表示每天生成一个日志文件，保存30天的日志文件。

    <configuration>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>test.log</file>

    <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
    <fileNamePattern>tests.%i.log.zip</fileNamePattern>
    <minIndex>1</minIndex>
    <maxIndex>3</maxIndex>
    </rollingPolicy>

    <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
    <maxFileSize>5MB</maxFileSize>
    </triggeringPolicy>
    <encoder>
    <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
    </encoder>
    </appender>

    <root level="DEBUG">
    <appender-ref ref="FILE" />
    </root>
    </configuration>

备注：上述配置表示按照固定窗口模式生成日志文件，当文件大于20MB时，生成新的日志文件。窗口大小是1到3，当保存了3个归档文件后，将覆盖最早的日志。
<encoder>：对记录事件进行格式化。负责两件事，一是把日志信息转换成字节数组，二是把字节数组写入到输出流。
PatternLayoutEncoder 是唯一有用的且默认的encoder ，有一个<pattern>节点，用来设置日志的输入格式。使用“%”加“转换符”方式，如果要输出“%”，则必须用“\”对“\%”进行转义。
5.4、还有SocketAppender、SMTPAppender、DBAppender、SyslogAppender、SiftingAppender，并不常用，这里就不详解了。
大家可以参考官方文档（https://logback.qos.ch/documentation.html），还可以编写自己的Appender。

（6）子节点<loger>：用来设置某一个包或具体的某一个类的日志打印级别、以及指定<appender>。<loger>仅有一个name属性，一个可选的level和一个可选的addtivity属性。

可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个loger
name: 用来指定受此loger约束的某一个包或者具体的某一个类。
level: 用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL和OFF，还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。如果未设置此属性，那么当前loger将会继承上级的级别。
addtivity: 是否向上级loger传递打印信息。默认是true。同<loger>一样，可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个loger。

（7）子节点<root>:它也是<loger>元素，但是它是根loger,是所有<loger>的上级。只有一个level属性，因为name已经被命名为"root",且已经是最上级了。

level: 用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL和OFF，不能设置为INHERITED或者同义词NULL。默认是DEBUG。
六、常用loger配置

<logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE" />
    <logger name="org.hibernate.type.descriptor.sql.BasicExtractor" level="DEBUG" />
    <logger name="org.hibernate.SQL" level="DEBUG" />
    <logger name="org.hibernate.engine.QueryParameters" level="DEBUG" />
    <logger name="org.hibernate.engine.query.HQLQueryPlan" level="DEBUG" />

    
    <logger name="com.apache.ibatis" level="TRACE"/>
    <logger name="java.sql.Connection" level="DEBUG"/>
    <logger name="java.sql.Statement" level="DEBUG"/>
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>

设置 SizeAndTimeBasedRollingPolicy规则一天一归类和多久删除之前日志

<appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
           <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
               
               <FileNamePattern>${log_dir}/info/%d{yyyy-MM-dd}/LJWEBInfo.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
               
               <maxFileSize>10MB</maxFileSize>
               <maxHistory>60</maxHistory>
               
           </rollingPolicy>
           <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
               
               <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
           </encoder>
       </appender>

    每天一归档： <FileNamePattern>${log_dir}/info/%d{yyyy-MM-dd}/LJWEBInfo.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
    单个日志文件最多 100MB： <maxFileSize>100MB</maxFileSize>
     60天的日志周期，删除之前的：   <maxHistory>60</maxHistory>
    最大不能超过20GB 超过删除： <totalSizeCap>20GB</totalSizeCap>
     maxHistory    和 totalSizeCap 选择一个就好

java:

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

    public class LogBack {
        private final Logger logger = LoggerFactory.getLogger(this.getClass());

        public static void main(String[] args) {
            logger.debug("print debug log.");
            logger.info("print info log.");
            logger.error("print error log.");
        }

    }

产生文件

---------------------
作者：a_Ygygs_Dxdsr_XdMss
来源：CSDN
原文：https://blog.csdn.net/weixin_42749765/article/details/84837346
版权声明：本文为博主原创文章，转载请附上博文链接！

SeaSky_Steven

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java logback日志

在java开发中，日志系统是java项目中必不可少的组成部分。日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。我们在日常开发中主要使用的java日志框架组件是：log4j、SLF4J、Commons Logging日志级别一般分为7个打印级别（不同的日志框架组件可能打印的日志级别区别不大）：OFF-关闭所有日志；FATAL-记录严重的错误，并且会导致应用...
复制链接

扫一扫