精华内容
下载资源
问答
  • logback

    2021-01-12 17:54:19
    logback LogBack是一个日志框架,它是Log4j作者Ceki的又一个日志组件。 logback如何配置springboot框架 创建logback-spring.xm在src/main/resources下面(springboot推荐使用logback-spring.xml而不是logback.xml)...

    logback

    LogBack是一个日志框架,它是Log4j作者Ceki的又一个日志组件。

    • logback如何配置springboot框架
      在src/main/resources下面创建logback-spring.xml
      (springboot推荐使用logback-spring.xml而不是logback.xml)文件。
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
    根节点: configuration 
        scan属性: 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
        scanPeriod属性: 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。
        debug属性: 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。
        configuration 子节点为 appender、logger、root
    -->
    <configuration scan="true" scanPeriod="60 seconds" debug="false">
    
        <!--contextName: 设置上下文名称-->
        <contextName>test-logback</contextName>
    
        <!--property: 设置变量:配置生成日志文件所在目录-->
        <property name="LOG_HOME_WINDOWS" value="D:/logs"/>
        <property name="LOG_HOME_LINUX" value="./logs"/>
    
        <!-- 彩色日志 -->
        <!-- 彩色日志依赖的渲染类 -->
        <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
        <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
        <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
        <!-- 彩色日志格式   [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n  -->
        <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
        
    <!-- appender节点: 负责写日志的组件。 -->
        <!--appender的class属性: ConsoleAppender-把日志输出到控制台-->
        <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度 %logger输出日志的logger名 %msg:日志消息,%n是换行符 -->
                <pattern>${CONSOLE_LOG_PATTERN}</pattern><!--彩打日志-->
                <charset>UTF-8</charset>
            </encoder>
        </appender>
    
        <!--appender的class属性: RollingFileAppender-滚动记录文件:先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件-->
        <appender name="infoFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- ThresholdFilter:临界值过滤器,过滤掉 TRACE 和 DEBUG 级别的日志 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
            <!-- rollingPolicy节点: 当发生滚动时,决定 RollingFileAppender 的行为,涉及文件移动和重命名。
            	TimeBasedRollingPolicy属性: 最常用的滚动策略,它根据时间来制定滚动策略,既负责滚动也负责触发滚动 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            	<!-- 活动文件的名字会根据fileNamePattern的值,每隔一段时间改变一次 -->
                <fileNamePattern>${LOG_HOME_WINDOWS}/info/info.%d{yyyy-MM-dd}.log</fileNamePattern>
    			<maxFileSize>100MB</maxFileSize><!--单个日志文件最大100M,到了这个值就会再创建一个日志文件,日志文件的名字最后+1-->
                <maxHistory>30</maxHistory><!--保存最近30天的日志-->
                <totalSizeCap>20GB</totalSizeCap><!--所有的日志文件最大20G,超过就会删除旧的日志-->
            </rollingPolicy>
            <encoder>
                <charset>UTF-8</charset>
                <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] %-5level %logger{36} : %msg%n</pattern>
            </encoder>
        </appender>
    
        <appender name="errorFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- ThresholdFilter:临界值过滤器,过滤掉 TRACE 和 DEBUG 级别的日志 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>error</level>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${LOG_HOME_WINDOWS}/error/error.%d{yyyy-MM-dd}.log</fileNamePattern>
                <maxHistory>30</maxHistory>
                <totalSizeCap>20GB</totalSizeCap>
            </rollingPolicy>
            <encoder>
                <charset>UTF-8</charset>
                <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] %-5level %logger{36} : %msg%n</pattern>
            </encoder>
        </appender>
        
    
    	<!--root 节点: 也是<loger>元素,但是它是根loger。只有一个level属性
    	<root>可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个loger-->
    	<root level="INFO">             
        	<appender-ref ref="stdout" />
        </root>
        <!--logger节点: 用来设置某一个包或者具体的某一个类的日志打印级别, 
        所有logger的初始级均继承root,如果某一个自定义的logger没有指定level,就会寻找父logger看有没有指定级别,直到找到root
        没有设置addtivity,默认为true,将此loger的打印信息向上级传递;
    	没有设置appender,此loger本身不打印任何信息。-->
    	<logger name="com.minlia" level="DEBUG"/>
    	
    <!--springProfile节点: 配置多环境日志输出  
    	在application.properties中配置选择哪个profiles : spring.profiles.active=dev-->
        <!--开发环境:打印控制台-->
        <springProfile name="dev">
            <root level="debug">
                <appender-ref ref="stdout" />
                <appender-ref ref="infoFile" />
                <appender-ref ref="errorFile" />
            </root>
    		<logger name="com.dcfs.smartaibank" level="debug" additivity="false">
    			<appender-ref ref="stdout" />
    		</logger>
        </springProfile>
        <!--生产环境:输出到文件-->
        <springProfile name="prd">
            <root level="info">
                <appender-ref ref="infoFile" />
                <appender-ref ref="errorFile" />
            </root>
        </springProfile>
    
    </configuration>
    

    参考:

    • https://www.cnblogs.com/mahoshojo/p/12920473.html
    • https://blog.csdn.net/Char_CN/article/details/7839318?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control
    展开全文
  • LogBack

    2019-10-08 19:10:13
    Logback 是什么? Logback 是一个 Java 平台上的日志框架,是 log4j 的加强版本,目前分为以下模块: logback-core,放置为下面两个模块服务的基础代码; logback-classic,log4j 的加强版本,实现了 SLF4J API,以...

    Logback 是什么?

    Logback 是一个 Java 平台上的日志框架,是 log4j 的加强版本,目前分为以下模块:

    1. logback-core,放置为下面两个模块服务的基础代码;
    2. logback-classic,log4j 的加强版本,实现了 SLF4J API,以便于切换其他日志框架;
    3. logback-access,与 Servlet 容器集成,提供 HTTP 访问日志功能。

    SLF4J:The Simple Logging Facade for Java(简单日志门面抽象框架),提供的是日志的 Facade API,需要配合 Log4j、Logback 或 java.util.logging 使用。

    快速开始

    (1)引入依赖

    compile "org.slf4j:slf4j-api:1.7.+"
    compile "ch.qos.logback:logback-core:1.2.+"
    compile "ch.qos.logback:logback-classic:1.2.+"

    (2)编写 logback.xml 并放置到 resources 文件夹中

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
      <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
          <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
      </appender>
      <root level="DEBUG">          
        <appender-ref ref="STDOUT" />
      </root>  
    </configuration>

    (3)在代码中使用

    Logger LOGGER = LoggerFactory.getLogger(Main.class);
    LOGGER.debug("Hello, Logback");

    参考

    1. Logback Project - logback.qos.ch
    2. LogBack 入门实践

    转载于:https://www.cnblogs.com/lshare/p/11334367.html

    展开全文
  • Logback

    2016-01-21 15:15:33
    一、logback的介绍  Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是...

    一、logback的介绍

         Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。 Logback是要与SLF4J结合起来用两个组件的官方网站如下:

        logback的官方网站: http://logback.qos.ch

        SLF4J的官方网站:http://www.slf4j.org

        本文章用到的组件如下:请自行到官方网站下载!

        logback-access-1.0.0.jar

        logback-classic-1.0.0.jar

        logback-core-1.0.0.jar

        slf4j-api-1.6.0.jar

    二、logback取代 log4j的理由:

        Logback和log4j是非常相似的,如果你对log4j很熟悉,那对logback很快就会得心应手。下面列了logback相对于log4j的一些优点:

        1、更快的实现  Logback的内核重写了,在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了,初始化内存加载也更小了。

        2、非常充分的测试  Logback经过了几年,数不清小时的测试。Logback的测试完全不同级别的。在作者的观点,这是简单重要的原因选择logback而不是log4j。

        3、Logback-classic非常自然实现了SLF4j    Logback-classic实现了 SLF4j。在使用SLF4j中,你都感觉不到logback-classic。而且因为logback-classic非常自然地实现了SLF4J,  所 以切换到log4j或者其他,非常容易,只需要提供成另一个jar包就OK,根本不需要去动那些通过SLF4JAPI实现的代码。

        4、非常充分的文档  官方网站有两百多页的文档。

        5、自动重新加载配置文件  当配置文件修改了,Logback-classic能自动重新加载配置文件。扫描过程快且安全,它并不需要另外创建一个扫描线程。这个技术充分保证了应用程序能跑得很欢在JEE环境里面。

        6、Lilith   Lilith是log事件的观察者,和log4j的chainsaw类似。而lilith还能处理大数量的log数据 。

        7、谨慎的模式和非常友好的恢复  在谨慎模式下,多个FileAppender实例跑在多个JVM下,能 够安全地写道同一个日志文件。RollingFileAppender会有些限制。Logback的FileAppender和它的子类包括 RollingFileAppender能够非常友好地从I/O异常中恢复。

        8、配置文件可以处理不同的情况   开发人员经常需要判断不同的Logback配置文件在不同的环境下(开发,测试,生产)。而这些配置文件仅仅只有一些很小的不同,可以通过,和来实现,这样一个配置文件就可以适应多个环境。

        9、Filters(过滤器)  有些时候,需要诊断一个问题,需要打出日志。在log4j,只有降低日志级别,不过这样会打出大量的日志,会影响应用性能。在Logback,你可以继续 保持那个日志级别而除掉某种特殊情况,如alice这个用户登录,她的日志将打在DEBUG级别而其他用户可以继续打在WARN级别。要实现这个功能只需 加4行XML配置。可以参考MDCFIlter 。

       10、SiftingAppender(一个非常多功能的Appender)  它可以用来分割日志文件根据任何一个给定的运行参数。如,SiftingAppender能够区别日志事件跟进用户的Session,然后每个用户会有一个日志文件。

       11、自动压缩已经打出来的log  RollingFileAppender在产生新文件的时候,会自动压缩已经打出来的日志文件。压缩是个异步过程,所以甚至对于大的日志文件,在压缩过程中应用不会受任何影响。

       12、堆栈树带有包版本  Logback在打出堆栈树日志时,会带上包的数据。

       13、自动去除旧的日志文件  通过设置TimeBasedRollingPolicy或者SizeAndTimeBasedFNATP的maxHistory属性,你可以控制已经产生日志文件的最大数量。如果设置maxHistory 12,那那些log文件超过12个月的都会被自动移除。

        总之,logback比log4j太优秀了,让我们的应用全部建立logback上吧 !

    、Logback的配置介绍

        1、Logger、appender及layout

           Logger作为日志的记录器,把它关联到应用的对应的context上后,主要用于存放日志对象,也可以定义日志类型、级别。

        Appender主要用于指定日志输出的目的地,目的地可以是控制台、文件、远程套接字服务器、 MySQL、PostreSQL、 Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。 

        Layout 负责把事件转换成字符串,格式化的日志信息的输出。

         2、logger context

           各个logger 都被关联到一个 LoggerContext,LoggerContext负责制造logger,也负责以树结构排列各logger。其他所有logger也通过org.slf4j.LoggerFactory 类的静态方法getLogger取得。 getLogger方法以 logger名称为参数。用同一名字调用LoggerFactory.getLogger 方法所得到的永远都是同一个logger对象的引用。

       3、有效级别及级别的继承

          Logger 可以被分配级别。级别包括:TRACE、DEBUG、INFO、WARN 和 ERROR,定义于ch.qos.logback.classic.Level类。如果 logger没有被分配级别,那么它将从有被分配级别的最近的祖先那里继承级别。root logger 默认级别是 DEBUG。

       4、打印方法与基本的选择规则

        打印方法决定记录请求的级别。例如,如果 L 是一个 logger 实例,那么,语句 L.info("..")是一条级别为 INFO的记录语句。记录请求的级别在高于或等于其 logger 的有效级别时被称为被启用,否则,称为被禁用。记录请求级别为 p,其 logger的有效级别为 q,只有则当 p>=q时,该请求才会被执行。

        该规则是 logback 的核心。级别排序为: TRACE < DEBUG < INFO < WARN < ERROR

     

    四、Logback的默认配置

          如果配置文件 logback-test.xml 和 logback.xml 都不存在,那么 logback 默认地会调用BasicConfigurator ,创建一个最小化配置。最小化配置由一个关联到根 logger 的ConsoleAppender 组成。输出用模式为%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 的 PatternLayoutEncoder 进行格式化。root logger 默认级别是 DEBUG。

         1、Logback的配置文件

          Logback 配置文件的语法非常灵活。正因为灵活,所以无法用 DTD 或 XML schema 进行定义。尽管如此,可以这样描述配置文件的基本结构:以<configuration>开头,后面有零个或多个<appender>元素,有零个或多个<logger>元素,有最多一个<root>元素。

         2、Logback默认配置的步骤

         (1). 尝试在 classpath 下查找文件 logback-test.xml;

         (2). 如果文件不存在,则查找文件 logback.xml;

         (3). 如果两个文件都不存在,logback 用 Bas icConfigurator 自动对自己进行配置,这会导致记录输出到控制台。

        3、Logback.xml 文件     

      

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->  
        <property name="LOG_HOME" value="c:/log" />  
        <!-- 控制台输出 -->   
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
           <!-- 日志输出编码 -->  
           <Encoding>UTF-8</Encoding>   
            <layout class="ch.qos.logback.classic.PatternLayout">   
                 <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符--> 
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n   
                </pattern>   
            </layout>   
        </appender>   
        <!-- 按照每天生成日志文件 -->   
        <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">   
            <Encoding>UTF-8</Encoding>   
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!--日志文件输出的文件名-->
                <FileNamePattern>${LOG_HOME}/myApp.log.%d{yyyy-MM-dd}.log</FileNamePattern>   
                <MaxHistory>30</MaxHistory>
            </rollingPolicy>   
            <layout class="ch.qos.logback.classic.PatternLayout">  
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符--> 
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n   
                </pattern>   
           </layout> 
            <!--日志文件最大的大小-->
           <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
             <MaxFileSize>10MB</MaxFileSize>
           </triggeringPolicy>
        </appender> 
       <!-- show parameters for hibernate sql 专为 Hibernate 定制 -->  
        <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" />  
        
        <!-- 日志输出级别 -->
        <root level="INFO">   
            <appender-ref ref="STDOUT" />   
            <appender-ref ref="FILE" />   
        </root> 
         
         <!--日志异步到数据库 -->  
        <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
            <!--日志异步到数据库 --> 
            <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
               <!--连接池 --> 
               <dataSource class="com.mchange.v2.c3p0.ComboPooledDataSource">
                  <driverClass>com.mysql.jdbc.Driver</driverClass>
                  <url>jdbc:mysql://127.0.0.1:3306/databaseName</url>
                  <user>root</user>
                  <password>root</password>
                </dataSource>
            </connectionSource>
      </appender> -->
    </configuration>



    五、在程序用引用Logback

    package com.stu.system.action; 
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class BlogAction{
         //定义一个全局的记录器,通过LoggerFactory获取
         private final static Logger logger = LoggerFactory.getLogger(BlogAction.class); 
         /**
         * @param args
         */
        public static void main(String[] args) {
            logger.info("logback 成功了");
            logger.error("logback 成功了");
        }
    }
    展开全文
  • --定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径 --> <property name="LOG_HOME" value="logs" /> <property name="SYS_NAME" value="system" /> <property name="DATA_NAME" ...
  • logback-spring.xml配置文件

    万次阅读 多人点赞 2018-05-18 15:01:16
    logback-spring.xml配置文件 &amp;amp;amp;lt;?xml version=&amp;amp;quot;1.0&amp;amp;quot; encoding=&amp;amp;quot;UTF-8&amp;amp;quot;?&amp;amp;amp;gt; &amp;amp;amp;lt;!-- ...

    logback-spring.xml配置文件

    • 自己改下value="/var/log/myapp"这个值,如果你相关依赖弄好的话,直接复制粘贴即用
    • 启动时加参数(值随环境变):-Dspring.profiles.active=dev
    • 集成到springboot的yml格式配置文件的示例:
    logging:
      config: classpath:logback-spring.xml
      level:
        dao: debug
        org:
          mybatis: debug
    
    • 下面是具体logback配置:
    <?xml version="1.0" encoding="UTF-8"?>
    <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL,比如: 如果设置为WARN,则低于WARN的信息都不会输出 -->
    <!-- scan:当此属性设置为true时,配置文档如果发生改变,将会被重新加载,默认值为true -->
    <!-- scanPeriod:设置监测配置文档是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
    <!-- debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
    <configuration  scan="true" scanPeriod="10 seconds">
        <contextName>logback</contextName>
    
        <!-- name的值是变量的名称,value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后,可以使“${}”来使用变量。 -->
        <property name="log.path" value="/var/log/myapp"/>
    
        <!--0. 日志格式和颜色渲染 -->
        <!-- 彩色日志依赖的渲染类 -->
        <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
        <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
        <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
        <!-- 彩色日志格式 -->
        <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
    
        <!--1. 输出到控制台-->
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <!--此日志appender是为开发使用,只配置最底级别,控制台输出的日志级别是大于或等于此级别的日志信息-->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>debug</level>
            </filter>
            <encoder>
                <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
                <!-- 设置字符集 -->
                <charset>UTF-8</charset>
            </encoder>
        </appender>
    
        <!--2. 输出到文档-->
        <!-- 2.1 level为 DEBUG 日志,时间滚动输出  -->
        <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 正在记录的日志文档的路径及文档名 -->
            <file>${log.path}/debug.log</file>
            <!--日志文档输出格式-->
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset> <!-- 设置字符集 -->
            </encoder>
            <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!-- 日志归档 -->
                <fileNamePattern>${log.path}/debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <!--日志文档保留天数-->
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            <!-- 此日志文档只记录debug级别的 -->
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>debug</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        <!-- 2.2 level为 INFO 日志,时间滚动输出  -->
        <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 正在记录的日志文档的路径及文档名 -->
            <file>${log.path}/info.log</file>
            <!--日志文档输出格式-->
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset>
            </encoder>
            <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!-- 每天日志归档路径以及格式 -->
                <fileNamePattern>${log.path}/info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <!--日志文档保留天数-->
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            <!-- 此日志文档只记录info级别的 -->
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>info</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        <!-- 2.3 level为 WARN 日志,时间滚动输出  -->
        <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 正在记录的日志文档的路径及文档名 -->
            <file>${log.path}/warn.log</file>
            <!--日志文档输出格式-->
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset> <!-- 此处设置字符集 -->
            </encoder>
            <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}/warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <!--日志文档保留天数-->
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            <!-- 此日志文档只记录warn级别的 -->
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>warn</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        <!-- 2.4 level为 ERROR 日志,时间滚动输出  -->
        <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 正在记录的日志文档的路径及文档名 -->
            <file>${log.path}/error.log</file>
            <!--日志文档输出格式-->
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset> <!-- 此处设置字符集 -->
            </encoder>
            <!-- 日志记录器的滚动策略,按日期,按大小记录 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}/error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <!--日志文档保留天数-->
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            <!-- 此日志文档只记录ERROR级别的 -->
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        <!--
            <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
            以及指定<appender>。<logger>仅有一个name属性,
            一个可选的level和一个可选的addtivity属性。
            name:用来指定受此logger约束的某一个包或者具体的某一个类。
            level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,
                  还有一个特殊值INHERITED或者同义词NULL,代表强制执行上级的级别。
                  如果未设置此属性,那么当前logger将会继承上级的级别。
            addtivity:是否向上级logger传递打印信息。默认是true。
            <logger name="org.springframework.web" level="info"/>
            <logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>
        -->
    
        <!--
            使用mybatis的时候,sql语句是debug下才会打印,而这里我们只配置了info,所以想要查看sql语句的话,有以下两种操作:
            第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql,不过这样日志那边会出现很多其他消息
            第二种就是单独给dao下目录配置debug模式,代码如下,这样配置sql语句会打印,其他还是正常info级别:
            【logging.level.org.mybatis=debug logging.level.dao=debug】
         -->
    
        <!--
            root节点是必选节点,用来指定最基础的日志输出级别,只有一个level属性
            level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,
            不能设置为INHERITED或者同义词NULL。默认是DEBUG
            可以包含零个或多个元素,标识这个appender将会添加到这个logger。
        -->
    
    
    
    
    
    
    
        <!-- 4  最终的策略:
                     基本策略(root级) + 根据profile在启动时, logger标签中定制化package日志级别(优先级高于上面的root级)-->
        <springProfile name="dev">
            <root level="info">
                <appender-ref ref="CONSOLE" />
                <appender-ref ref="DEBUG_FILE" />
                <appender-ref ref="INFO_FILE" />
                <appender-ref ref="WARN_FILE" />
                <appender-ref ref="ERROR_FILE" />
            </root>
            <logger name="com.xusanduo.demo" level="debug"/> <!-- 开发环境, 指定某包日志为debug级 -->
        </springProfile>
    
        <springProfile name="test">
            <root level="info">
                <appender-ref ref="CONSOLE" />
                <appender-ref ref="DEBUG_FILE" />
                <appender-ref ref="INFO_FILE" />
                <appender-ref ref="WARN_FILE" />
                <appender-ref ref="ERROR_FILE" />
            </root>
            <logger name="com.xusanduo.demo" level="info"/> <!-- 测试环境, 指定某包日志为info级 -->
        </springProfile>
    
        <springProfile name="pro">
            <root level="info">
                <!-- 生产环境最好不配置console写文件 -->
                <appender-ref ref="DEBUG_FILE" />
                <appender-ref ref="INFO_FILE" />
                <appender-ref ref="WARN_FILE" />
                <appender-ref ref="ERROR_FILE" />
            </root>
            <logger name="com.xusanduo.demo" level="warn"/> <!-- 生产环境, 指定某包日志为warn级 -->
            <logger name="com.xusanduo.demo.MyApplication" level="info"/> <!-- 特定某个类打印info日志, 比如application启动成功后的提示语 -->
        </springProfile>
    
    </configuration>
    
    
    展开全文
  • logback开发文档

    2017-06-05 00:31:30
    logback
  • logback详解与错误

    万次阅读 2021-03-30 14:18:59
    logback 配置与踩坑 ** logback.xml示例(内容包括info、error、RocketMQ)** 官方文档推荐使用logback-spring.xml命名而不是logback.xml <?xml version="1.0" encoding="UTF-8"?> <!-- scan 配置文件如果...
  • logback文档

    2018-01-17 17:46:45
    本书详细的介绍了logback的配置已经使用方法,对于logback的原理认识很有帮助
  • logback日志配置

    2021-05-28 14:45:50
    logback日志配置
  • Slf4j+logback实现logback测试,Slf4j+logback实现logback测试
  • logback-access 的使用,如果将tomcat 默认的日志输出换成logback,则需要提供这两个jar 包。将logback-access.jar 与 logback-core.jar 复制到 $TOMCAT_HOME/lib/目录下
  • Logback详解

    千次阅读 多人点赞 2020-09-13 21:58:57
    Logback是SpringBoot内置的日志处理框架,你会发现spring-boot-starter其中包含了spring-boot-starter-logging,该依赖内容就是 Spring Boot 默认的日志框架 logback。官方文档:http://logback.qos.ch/manual/ ...
  • logback-chinese-manual logback 中文手册 翻译自 简介 Logback 继承自 log4j。 Logback 的架构非常的通用,适用不同的使用场景。Logback 被分成三个不同的模块:logback-core,logback-classic,logback-access。 ...
  • logback.zip

    2019-12-28 16:24:19
    logback-examples-1.2.3.jar logback-access-1.2.3.jar logback-classic-1.2.3.jar logback-core-1.2.3.jar slf4j-api-1.7.7.jar log4j-over-slf4j-1.7.7.jar
  • logback简介

    千次阅读 2020-04-30 10:47:14
    logback 是什么 logback 继承自 log4j,它建立在有十年工业经验的日志系统之上。它比其它所有的日志系统更快并且更小,包含了许多独特并且有用的特性。 开始使用logback 要求 logback-classic 模块需要在 classpath ...
  • logback 介绍

    2014-12-05 03:59:47
    logback 介绍 Logback为取代log4j而生。 Logback由log4j的创立者Ceki Gülcü设计。以十多年设计工业级记录系统的经验为基础,所创建的logback比现有任何记录系统更快、占用资源更少,有时差距非常大。
  • Logback配置文件

    2020-09-22 16:46:33
    logback配置文件demo,用于在springboot项目中放到resource 目录下即可 logback配置文件demo,用于在springboot项目中放到resource 目录下即可
  • logback.xml

    2021-06-08 11:31:27
    Logback日志配置文件,可以配置打印的日志信息的颜色
  • logback 中文手册

    2020-11-04 07:29:52
    Logback非常自然地实现了 SLF4J,不需要像 Log4j 和 JUL 那样加一个适配层。Spring Boot 的默认日志框架使用的是 Logback。支持自动重新加载配置文件,不需要另外创建扫描线程来监视。PDF 共 200 页,非常全面。
  • Logback中文文档

    2018-01-23 10:00:25
    Logback中文文档

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,543
精华内容 24,217
关键字:

logback