Logback日志框架使用

已于 2022-06-29 02:26:30 修改
阅读量6.2k 收藏 39
点赞数 6
分类专栏： java 文章标签： log4j java apache
于 2022-06-29 02:25:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45514735/article/details/125511476
版权
本文详细介绍了Logback日志框架，包括其作为log4j的升级版特性，日志的五个等级，记录器的层级结构与属性设置，以及如何通过XML配置文件调整日志级别。此外，还探讨了控制台和文件附加器的使用，特别是滚动文件附加器的两种策略，并简单提及了过滤器的作用和常用类型。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

Logback简介

一、引入依赖

二、尝试生成一条日志

三、记录器

 四、每个记录器的属性

 五、XML配置文件配置框架

六、附加器Appender

        七、过滤器Filter

Logback简介

目前比较常用的ava日志框架:Logback、log4j、log4j2、JUL等等。


Logback是在log4j的基础上重新开发的一套日志框架，是完全实现SLF4J接口API(也叫日志门面)。


Logback 的架构非常通用，可以应用于不同的环境。目前logback分为三个模块，logback-core,logback-classic和logback-access。


logback-core模块为其他两个模块奠定了基础。logback-classic模块原生实现了SLF4JAPI,因此您可以轻松地在logback和其他日志记录框架(例如 log4j1.x或java.util.logging (JUL))之间来回切换。


logback-access模块与Tomcat和 Jetty 等 Servlet容器集成，以提供HTTP访问日志功能。请注意,您可以轻松地在logback-core之上构建自己的模块。

一、引入依赖

        1）创建一个maven项目

        2）引入logback依赖 

Maven Repository: logback (mvnrepository.com)

 

找个稳定版

 

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
            
        </dependency>

二、尝试生成一条日志

 创建测试类

test.applog.java

创建一个记录器

用记录器生成日志

package test;

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

public class applog {
    static Logger logger= LoggerFactory.getLogger("自定义日志名.test.applog");//名字同时代表了级别

    public static void main(String[] args) {
        logger.info("no1");
    }
}

 运行

 成功将日志输出到了控制台，因为我们没有做相关的配置，所以只能将debug及以上的日志输出到控制台（日志分为五个等级）

日志的五个等级

TRACE < DEBUG < INFO < WARN <ERROR

拓展：日志一共分成5个等级，从低到高分别是：

DEBUG：详细的信息,通常只出现在诊断问题上


INFO：确认一切按预期运行


WARNING：一个迹象表明,一些意想不到的事情发生了,或表明一些问题在不久的将来(例如。磁盘空间低”)。这个软件还能按预期工作。


ERROR：更严重的问题,软件没能执行一些功能


CRITICAL：一个严重的错误,这表明程序本身可能无法继续运行


这5个等级，也分别对应5种打日志的方法： debug 、info 、warning 、error 、critical。默认的是WARNING，当在WARNING或之上时才被跟踪。
 

三、记录器

日志记录器(Logger):控制要输出哪些日志记录语句，对日志信息进行级别限制。如何生成记录器:


final static Logger logger = LoggerFactory.getLogger(“名称”);
 

        1）记录器层级结构

所有的记录器都是缓存在 Map中的，记录器的关系有点类似于继承，是由名称决定的 

 父记录器logger2和子记录器logger,如果没有.标记，顶层记录器继承自root根记录器。

    static Logger logger= LoggerFactory.getLogger("自定义日志名.test.applog");//名字同时代表了级别
    static Logger logger2= LoggerFactory.getLogger("自定义日志名.test");//名字同时代表了级别，父记录器

         2）子记录器会同时创建父类记录器

 当父记录器存在的时候，再次创建子记录器则只会创建子记录器。

 四、每个记录器的属性

name属性:记录器的名称        


level属性(可选):记录器的级别，允许的级别从低到高，TRACE<DEBUG<INFO< WARN <ERROR
        logger.setLevel() ；      设置日志级别。可以使用设置的以及以上的级别的日志 
        logger.getLevel();        查看设置的级别
        logger.getEffectiveLevel()        查看实际生效的级别，比如默认或者继承自父记录器的级别


additivity属性(可选):是否允许叠加打印日志， true或false


说明:
1)如果记录器未设置level属性，则该记录器的级别从上级记录器继承
2)如果想查看记录器的级别，应该通过logger.getEffectiveLevel()方法，同时要将Logger转为ch.qos.logback.classic.Logger类型，如下:
        ch.qos.logback.classic.Logger logger =
                (ch.qos.logback.classic.Logger)LoggerFactory.getLogger(App.class);

        1）简单演示修改日志级别

package test;

import ch.qos.logback.classic.Level;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/*
* 创建测试类

test.applog.java

创建一个记录器

用记录器生成日志
* */
public class applog2 {



    public static void main(String[] args) {
        ch.qos.logback.classic.Logger logger= (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("自定义日志名");//名字同时代表了级别
        System.out.println("设置之前的级别");
        System.out.println(logger.getLevel());
        System.out.println(logger.getEffectiveLevel());
        logger.setLevel(Level.INFO);
        System.out.println("设置之后的级别");
        System.out.println(logger.getLevel());
        System.out.println(logger.getEffectiveLevel());
        logger.trace("no0");
        logger.debug("no1");
        logger.info("no2");
        logger.warn("no3");
        logger.error("no4");
        /*
        * 成功将日志输出到了控制台，因为我们没有做相关的配置，所以只能将debug及以上的日志输出到控制台（日志分为五个等级）
        * 日志的五个等级
        * TRACE < DEBUG < INFO < WARN <ERROR
        * */
    }
}

输出

设置之前的级别
null
DEBUG
设置之后的级别
INFO
INFO
23:47:37.632 [main] INFO 自定义日志名 - no2
23:47:37.647 [main] WARN 自定义日志名 - no3
23:47:37.647 [main] ERROR 自定义日志名 - no4

进程已结束,退出代码0

代码中我们将日志级别置为INFO，测试打印日志，打印出来了 INFO以及更高级别的日志记录，同时可以看到设置之前的日志级别和手动或执行后的日志级别。

         2）修改父类日志级别查看子类日志级别

package test;

import ch.qos.logback.classic.Level;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/*
* 创建测试类

test.applog.java

创建一个记录器

用记录器生成日志
* */
public class applog3 {



    public static void main(String[] args) {
        ch.qos.logback.classic.Logger logger= (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("自定义日志名");//名字同时代表了级别
        ch.qos.logback.classic.Logger rootLogger=(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);//获取Root根记录器
        rootLogger.setLevel(Level.INFO);
        System.out.println("设置之前的级别");
        System.out.println(logger.getLevel());
        System.out.println(logger.getEffectiveLevel());
        logger.setLevel(Level.INFO);
        System.out.println("设置之后的级别");
        System.out.println(logger.getLevel());
        System.out.println(logger.getEffectiveLevel());
        logger.trace("no0");
        logger.debug("no1");
        logger.info("no2");
        logger.warn("no3");
        logger.error("no4");
        /*
        * 成功将日志输出到了控制台，因为我们没有做相关的配置，所以只能将debug及以上的日志输出到控制台（日志分为五个等级）
        * 日志的五个等级
        * TRACE < DEBUG < INFO < WARN <ERROR
        * */
    }
}

输出 

设置之前的级别
null
INFO
设置之后的级别
INFO
INFO
00:00:27.430 [main] INFO 自定义日志名 - no2
00:00:27.437 [main] WARN 自定义日志名 - no3
00:00:27.437 [main] ERROR 自定义日志名 - no4

进程已结束,退出代码0
 

提前把Root根记录器的日志级别改为INFO后，可以看出子类的生效级别变成了INFO.

        3）层次结构

当前的记录器如果没有设置级别的话，就会向父类查询，如果父类也没有设置就向父类递归查询到ROOT记录器，默认DEBUG级别 

 五、XML配置文件配置框架

        1）创建配置文件 main-》resource->logback.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">


</configuration>

 如果命名空间和资源有问题的话，将光标移到xsd资源上按住 ALT+回车 手动设置外部资源，将外部资源导入就好了。

         2）设置ROOT级别

代码中加入

<root level="info"></root>
<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">
<root level="info"></root>

</configuration>

 测试java代码

package test;

import ch.qos.logback.classic.Level;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/*
* 创建测试类

test.applog.java

创建一个记录器

用记录器生成日志
* */
public class applog4 {



    public static void main(String[] args) {

        ch.qos.logback.classic.Logger rootLogger=(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);//获取Root根记录器
        rootLogger.setLevel(Level.INFO);
        System.out.println("设置之前的级别");
        System.out.println(rootLogger.getLevel());
        System.out.println(rootLogger.getEffectiveLevel());
        rootLogger.setLevel(Level.WARN);
        System.out.println("设置之后的级别");
        System.out.println(rootLogger.getLevel());
        System.out.println(rootLogger.getEffectiveLevel());
        rootLogger.trace("no0");
        rootLogger.debug("no1");
        rootLogger.info("no2");
        rootLogger.warn("no3");
        rootLogger.error("no4");
        /*
        * 成功将日志输出到了控制台，因为我们没有做相关的配置，所以只能将debug及以上的日志输出到控制台（日志分为五个等级）
        * 日志的五个等级
        * TRACE < DEBUG < INFO < WARN <ERROR
        * */
    }
}

输出

设置之前的级别
INFO
INFO
设置之后的级别
WARN
WARN

进程已结束,退出代码0

可以看到默认的ROOT记录器日志级别从DEBUG变成了配置文件里的INFO。 

        3）设置其他记录器级别

修改配置文件加入

<logger name="com.aa" level="debug"></logger>
<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">
<root level="info"></root>
    <logger name="com.aa" level="debug">

    </logger>

</configuration>

使用java程序测试 

package test;

import ch.qos.logback.classic.Level;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/*
* 创建测试类

test.applog.java

创建一个记录器

用记录器生成日志
* */
public class applog5 {



    public static void main(String[] args) {
        ch.qos.logback.classic.Logger logger= (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.aa");//名字同时代表了级别

        System.out.println("com.aa级别");
        System.out.println(logger.getLevel());
        System.out.println(logger.getEffectiveLevel());
        ch.qos.logback.classic.Logger logger2= (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com");//名字同时代表了级别
        System.out.println("com的级别");
        System.out.println(logger2.getLevel());
        System.out.println(logger2.getEffectiveLevel());

        /*
         * 成功将日志输出到了控制台，因为我们没有做相关的配置，所以只能将debug及以上的日志输出到控制台（日志分为五个等级）
         * 日志的五个等级
         * TRACE < DEBUG < INFO < WARN <ERROR
         * */
    }
}

输出

com.aa级别
DEBUG
DEBUG
com的级别
null
INFO

进程已结束,退出代码0

在这里可以看到，提前设置好 <logger name="com.aa" level="debug"></logger>，那么以com.aa命名的记录器将不受ROOT记录器影响，在创建后就被就设置了日志级别。但是父记录器com依然是继承自ROOT的INFO级别。

六、附加器Appender

 什么是附加器?


记录器会将输出日志的狂务交给附加器完成，不同的附加器会将日志输出到不同的地方，比如控制台附加器、文件附加器、网络附加器等等。


常用的附加器


控制台附加器:             ch.qos.logback.core.ConsoleAppender

文件附加器:                ch.qos.logback.core.FileAppender
滚动文件附加器:         ch.qos.logback.core.rolling.RollingFileAppender

实际上仅仅有记录器是不能写日志的 ，附加器才是日志输出的工具。实现附加器需要设置附加器名字和Class实现类，并且要配置编码器模板，配置完成后将附加器放到记录器里面

        1）控制台附加器输出 

<!--实现附加器需要设置附加器名字和Class实现类，并且要配置编码器模板，配置完成后将附加器放到记录器里面-->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

将附加器放到纪录器里，可以放多个附加器。 

<logger name = "org.example.App" level = "DEBUG" >
        <appender-ref ref="FILE" />
        <appender-ref ref="STDOUT" />
    </logger>

测试：

完整的xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
<root level="info"></root>
    <logger name="com.aa" level="debug">
        <appender-ref ref="STDOUT" />
    </logger>

</configuration>

java程序

package test;

import org.slf4j.LoggerFactory;

/*
* 创建测试类

test.applog.java

创建一个记录器

用记录器生成日志
* */
public class applog6 {



    public static void main(String[] args) {
        ch.qos.logback.classic.Logger logger= (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.aa");//名字同时代表了级别

        System.out.println("com.aa级别");
        System.out.println(logger.getLevel());
        System.out.println(logger.getEffectiveLevel());
        logger.trace("no0");
        logger.debug("no1");
        logger.info("no2");
        logger.warn("no3");
        logger.error("no4");

        /*
         * 成功将日志输出到了控制台，因为我们没有做相关的配置，所以只能将debug及以上的日志输出到控制台（日志分为五个等级）
         * 日志的五个等级
         * TRACE < DEBUG < INFO < WARN <ERROR
         * */
    }
}

输出：

com.aa级别
DEBUG
DEBUG
00:46:30 [main] DEBUG com.aa - no1
00:46:30 [main] INFO  com.aa - no2
00:46:30 [main] WARN  com.aa - no3
00:46:30 [main] ERROR com.aa - no4

进程已结束,退出代码0

        2）pattern标签

Pattern由文字文本和转换说明符的格式控制表达式组成。您可以在其中自由插入任何文字文本。每个转换说明符都以百分号"%'，后跟可选的格式修饰符、转换字和大括号之间的可选参数。转换字控制要转换的数据字段，例如记录器名称、级别、日期或线程名称。格式修饰符控制字段宽度、填充以及左对齐或右对齐。

         3）文件附加器输出

需要多配置一个file标签，用于存放文件

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>myApp.log</file>
        <encoder>
            <pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
        </encoder>
    </appender>

 完整xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>myApp.log</file>
        <encoder>
            <pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
        </encoder>
        <append>true</append>
        <!--表示记录方式为追加-->
    </appender>
<root level="info"></root>
    <logger name = "com.aa" level = "DEBUG" >
        <appender-ref ref="FILE" />
        <appender-ref ref="STDOUT" />
    </logger>

</configuration>

依然执行上一个测试用例

输出了一个日志文件

 这个方法生成的日志会不断叠加，更多的使用的是滚动文件附加器，可以设置时间和大小生成多个文件，方便阅读调阅。

        4）滚动文件附加器 

滚动策略


1.基于时间的滚动策略
ch.qos.logback.core.rolling.TimeBasedRollingPolicy
2.基于大小和时间的滚动策略
ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy
 

                （1）基于时间的 


    <!--滚动文件附加器-->
    <appender name="runFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>mylog2.log</file>

        <!--编码器-->
        <encoder>
            <pattern>%50date %msg</pattern>
        </encoder>
        <!--滚动策略-->
        <!--按照时间滚动生成-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>%d{yyyy-mm-dd HH-mm-ss}.log</fileNamePattern>
            <maxFileSize>10</maxFileSize>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
    </appender>

 这里面的mylog2.log指的是当前正在工作的日志文件，当满足设定条件后就重构重命名为归档文件，

<maxFileSize>10</maxFileSize>        则是设定归档文件的最大数量，超过数量会删除最早的归档文件。

<totalSizeCap>5GB</totalSizeCap>        用于设置所有日志文件的大小

测试

<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>myApp.log</file>
        <encoder>
            <pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
        </encoder>
        <append>true</append>
        <!--表示记录方式为追加-->
    </appender>
    <!--滚动文件附加器-->
    <appender name="runFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>mylog2.log</file>

        <!--编码器-->
        <encoder>
            <pattern>%50date %msg</pattern>
        </encoder>
        <!--滚动策略-->
        <!--按照时间滚动生成-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>%d{yyyy-mm-dd HH-mm-ss}.log</fileNamePattern>
            <!--编设定每秒执行一次归档文件-->
            <maxFileSize>10</maxFileSize>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
    </appender>
<root level="info"></root>
    <logger name = "com.aa" level = "DEBUG" >
        <appender-ref ref="runFile"/>
        <appender-ref ref="FILE" />
        <appender-ref ref="STDOUT" />
    </logger>

</configuration>

 执行程序

设定为每秒一个日志，执行多次程序后，日志1被输出到文件列表 

        （2）基于时间和大小的 

<!--滚动文件附加器-->
    <appender name="runFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>mylog3.log</file>

        <!--编码器-->
        <encoder>
            <pattern>%50date %msg</pattern>
        </encoder>
        <!--滚动策略-->
        <!--按照时间滚动生成-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>%d{yyyy-mm-dd HH-mm-ss}.%i.log</fileNamePattern>
            <maxFileSize>10</maxFileSize>
            <totalSizeCap>5GB</totalSizeCap>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>
    </appender>

这里面的标签多了一个

<maxFileSize>1KB</maxFileSize>

        用于限定日志文件的大小

<fileNamePattern>%d{yyyy-mm-dd HH-mm-ss}.%i.log</fileNamePattern>

这个标签没发生一次变化代表着一个新的文件，前面是时间，后面的%i则是第几个触发的文件编号。

<maxFileSize>10</maxFileSize>

        这个标签是按照时间的归档数量，而不是文件数量。

<?xml version="1.0" encoding="UTF-8" ?>
<configuration xmlns="http://ch.qos.logback/xml/ns/logback"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback
               https://raw.githubusercontent.com/enricopulatzo/logback-XSD/master/src/main/xsd/logback.xsd">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>myApp.log</file>
        <encoder>
            <pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
        </encoder>
        <append>true</append>
        <!--表示记录方式为追加-->
    </appender>
    <!--滚动文件附加器-->
    <appender name="runFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>mylog2.log</file>

        <!--编码器-->
        <encoder>
            <pattern>%50date %msg</pattern>
        </encoder>
        <!--滚动策略-->
        <!--按照时间滚动生成-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>%d{yyyy-mm-dd HH-mm-ss}.log</fileNamePattern>
            <maxFileSize>10</maxFileSize>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    <!--滚动文件附加器-->
    <appender name="runFiletime" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>mylog3.log</file>

        <!--编码器-->
        <encoder>
            <pattern>%50date %msg</pattern>
        </encoder>
        <!--滚动策略-->
        <!--按照时间滚动生成-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>%d{yyyy-mm-dd HH-mm-ss}.%i.log</fileNamePattern>
            <maxFileSize>10</maxFileSize>
            <totalSizeCap>5GB</totalSizeCap>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>
    </appender>
<root level="info"></root>
    <logger name = "com.aa" level = "DEBUG" >
        <appender-ref ref="runFile"/>
        <appender-ref ref="runFiletime"/>
        <appender-ref ref="FILE" />
        <appender-ref ref="STDOUT" />
    </logger>

</configuration>

         自定义附加器

        模拟控制台附加器

                自行探索吧。。。

        七、过滤器Filter

过滤器是附加器的一个组件，它用于决定附加器是否输出日志。一个附加器可以包含一个或多个过滤器。每个过滤器都会返回一个枚举值，可选的值:DENY、NEUTRAL、ACCEPT
附加器根据过滤器返回值判断是否输出日志:
DENY :不输出日志
ACCEPT:输出日志
NEUTRAL:中立，即不决定是否输出日志

如果当前过滤器决定输出日志，那么日志直接输出，忽略后面的过滤器

如果当前过滤器决定不输出日志，那么日志直接不输出，忽略后面的过滤器

如果当前过滤器待定是否输出日志，那么将询问下一个过滤器是否输出

常用的过滤器


LevelFilter(级别过滤器)︰实现类ch.qos.logback.classic.filter.LevelFilter


ThresholdFilter(阈值过滤器):实现类ch.qos.logback.classic.filter.ThresholdFilter

EvaluatorFilter(评估者过滤器):实现类ch.qos.logback.core.filter.EvaluatorFilterJanino

EventEvaluator过滤器:实现类ch.qos.logback.core.filter.EvaluatorFilter

TurboFilter涡轮过滤器


DuplicateMessageFilter重复消息过滤器
 

级别过滤器

 级别匹配一致打印日志并返回

级别匹配不一致不打印日志并返回

 可以更改返回值。

         自定义过滤器

logback日志框架
smilehjl
07-13 891
Logback是一个用于Java应用程序的日志框架，它由log4j框架的创始人Ceki Gülcü开发。logback是log4j框架的继承者和改进版，并提供了更好的性能、可扩展性和灵活性。与Log4j相比，Logback提供了更快的速度和更低的内存占用，这使得它成为大型企业级应用程序的理想选择。
logback日志框架源码分析
lft18的博客
12-31 1794
在我们使用logback日志框架时，通常都会通过配置logback.xml定制化我们的日志需求。但你是否对loback日志如何加载配置感到好奇？如果没有logback.xml，logback的默认配置又是什么样的？配置文件中定义的appender和logger又是什么关系呢？在这一篇章我们会通过深入logback源码进行分析。
logback-core-1.2.11.jar
06-05
logback-core-1.2.11.jar
logback日志框架依赖
xiaoxiao1777的博客
02-17 2253
<dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-core</artifactId> <version>1.2.3</version> </dependency> &...
Logback使用和常用配置
最新发布
zrhsmile的博客
03-25 1348
Logback的配置和使用
日志框架logback的使用和配置详解
外星人的程序生涯
07-17 443
1. 前言 Logback是由log4j创始人设计的又一个开源日志组件, 查了一些资料说比log4j的性能还好, 以后将会逐步地替代掉log4j. 那么现在就来学学怎么使用logback吧 2. 导入依赖 这里务必使用最新的版本 <dependency> <groupId>ch.qos.logback</groupId> <artifa...
Logback的使用
爪哇人的博客
01-16 3641
1 logback大致介绍 Logback是由log4j创始人设计的另外一种开源日志组件，性能比log4j要好 Logback主要分为3个模块： logback-core：其他两个模块的基础模块 logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4jAPI logback-access:访问模块与Servlet容器集成提供通过Http来访问日志的功能 logback组件之间的关系 1 Logger：日志的记录器，把它关联到应用的对应context上后，.
Logback依赖配置
Android菜鸟的专栏
03-24 4701
在IntelliJ IDEA中创建一个基于gradle的Java项目，然后添加依赖： // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic implementation group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3' 这里这需要依赖logback-classic即可，通过双击gradle命令：dependencies，如下： 从这里可知
SpringBoot logback日志框架使用过程解析
08-24
SpringBoot logback日志框架使用过程解析 SpringBoot logback日志框架是SpringBoot项目中的一种日志记录方式，默认情况下，SpringBoot使用logback作为日志框架。下面我们将详细介绍SpringBoot logback日志框架的...
java的Logback日志框架jar包
07-11
SLF4J提供了一层抽象，允许你在不修改代码的情况下，用其他日志框架（如log4j或java.util.logging）替换Logback。此外，logback-classic还包含了一个名为`ch.qos.logback.classic.Logger`的类，它是SLF4J的实现，...
SpringBoot集成Logback日志框架全攻略
lucky_fd的博客
08-11 1463
Logback是SLF4J（Simple Logging Facade for Java）的一个实现，由同一个作者开发。它被认为是Log4j的继任者，提供了更快的速度和更好的功能。Logback包括三个主要组件：Logger、Appender和Layout。Logger负责记录日志信息，Appender负责将日志信息输出到目的地（如控制台、文件等），而Layout则负责定义日志的格式。Spring Boot在创建新项目时，如果未指定其他日志框架，则默认使用Logback作为日志实现。
logback日志框架所需要的jar包
01-29
包含logback所需：logback-classic-1.1.7.jar、logback-classic-1.1.7-sources.jar、logback-core-1.1.7.jar、logback-core-1.1.7-sources.jar、slf4j-api-1.7.21.jar、slf4j-api-1.7.21-sources.jar
logback所需maven依赖
热门推荐
书香水墨
02-28 2万+
1 maven依赖 &lt;dependency&gt; &lt;groupId&gt;org.slf4j&lt;/groupId&gt; &lt;artifactId&gt;slf4j-api&lt;/artifactId&gt; &lt;version&gt;1.7.25&lt;/version&gt; &lt;/dependency&gt; &
logback日志详解
liyuguanguan的博客
01-22 658
具体参考： http://tengj.top/2017/04/05/springboot7/
Logback使用
weixin_34037977的博客
02-29 89
OK，现在让我们开始logback吧。关于logback的使用，网上的资料良莠不齐，权威一点的材料比如书我是没有找到。所以只好去官网上看文档，本人英语一般，所以只能一边翻译，一边研究。这里来整理一份相对比较详细的博客。 logback概述 LogBack是由log4j的创始人开发的一个日志组件，用于替代log4j。LogBack的架构设计足够通用，可适用于不同的...
java操作LogBack（maven项目）
xiaobao5214的博客
07-20 817
pom.xml   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">   4.0.0   LogBack   LogBack   0.0.1-SNAPSHOT   jar   LogBack   http://maven.
Logback从添加依赖，到配置给中打印级别，archive相关信息配置，在项目中的常见的用法，一个完整的过程
咸鱼梦想
11-08 684
encoder>这里需要借鉴一下其他人的内容，着急做项目的话先用着，收尾的时候慢慢调整，根据不同的用户需求，做出对应的调整原文链接：https://blog.youkuaiyun.com/zhou920786312/article/details/125411387--scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。-->--scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。
logback日志配置及使用
weixin_43790613的博客
11-01 6820
配置介绍 日志级别从低到高 TRACE < DEBUG < INFO < WARN < ERROR < FATAL 只能展示大于或等于设置的日志级别的日志 日志配置文件名 Logback：logback.xml, logback-spring.xml, logback-spring.groovy, logback.groovy Log4j：log4j.properties, log4j.xml，log4j-spring.properties, log4j-spring.x
logback 的属性
my博客
11-15 3154
文章目录spring Boot 日志Spring Boot 配置文件配置日志logback依赖logback配置文件logback 彩色日志logback 常用的输出方式ConsoleAppenderFileAppenderRollingFileAppenderTimeBasedRollingPolicy错误Could not find Janino library on the class p...
Logback日志框架的十大优势
Logback是一款功能强大且广泛应用的日志记录工具，为什么选择使用Logback？以下是10个理由： **1. 高性能** Logback的性能远远超过其他日志记录工具。它使用了高效的缓存机制和异步日志记录，确保了高性能和低延迟...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值