精华内容
下载资源
问答
  • logback配置详解

    2018-10-08 16:49:28
    logback配置详解,关于logback的spring集成配置的详细说明及示例
  • 该文件包含logback配置文件示例和配置文件内容解析,如果想深入学习的系哦小伙伴可以下载看看,如果只是想实现功能,可以查看我的博客 《整合篇------JAVA项目整合Logback》
  • NULL 博文链接:https://fanshuyao.iteye.com/blog/2414522
  • LogBack配置文件

    2015-01-29 17:42:08
    LogBack配置文件,主要包括LOGBack的配置文件内容
  • logback配置文件

    2015-06-30 17:45:56
    logback学习使用的配置文件,logback入门使用配置
  • 项目中在使用的logback,拿过去直接可以用,带完整的中文说明。
  • 微服务框架SpringBoot+通用Mapper(tk.Mybatis)整个项目架构,直接上手开用,yml和logback配置都已经配置完好
  • Logback配置文件

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

    千次阅读 2019-08-29 14:34:32
    Logback 配置实例 spring boot 默认日志系统采用 slf4j + logback 一下配置仅作为配置参考 开发环境配置 <?xml version="1.0" encoding="UTF-8"?> <!-- 不分级别同步文件日志输出配置 --> <!-- 级别...

    Logback 配置实例

    spring boot 默认日志系统采用 slf4j + logback
    一下配置仅作为配置参考

    开发环境配置

    <?xml version="1.0" encoding="UTF-8"?>
    <!-- 不分级别同步文件日志输出配置 -->
    <!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
    <!-- 日志输出规则 根据当前ROOT 级别,日志输出时,级别高于root默认的级别时 会输出 -->
    <!-- 以下 每个配置的 filter 是过滤掉输出文件里面,会出现高级别文件,依然出现低级别的日志信息,通过filter 过滤只记录本级别的日志 -->
    <!-- scan 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 -->
    <!-- scanPeriod 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
    <!-- debug 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
    <configuration scan="true" scanPeriod="60 seconds" debug="false" >
    
        <!-- logback项目名称 -->
        <property name="appName" value="noSeatBeltDev"/>
    
        <!-- 日志级别 -->
        <property name="logLevel" value="DEBUG"/>
    
        <!-- 日志地址 -->
        <property name="logPath" value="./logs"/>
    
        <!-- 最大保存时间 10天 -->
        <property name="maxHistory" value="10"/>
    
        <!-- 异步缓冲队列的深度,该值会影响性能.默认值为256 -->
        <property name="queueSize" value="512" />
    
        <!-- lOGGER  PATTERN  配置化输出语句 根据自己的喜好选择 -->
        <property name="logPattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n"/>
        <!-- %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n -->
        <!-- %d{yyyy-MM-dd HH:mm:ss} %-4relative [%thread] %-5level %logger{35} - %msg %n -->
        <!-- [ %-5level] [%date{yyyy-MM-dd HH:mm:ss.SSS}] %logger{96} [%line] [%thread]- %msg%n  -->
    
    
        <!-- 控制台打印日志的相关配置 -->
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <!-- 日志格式 -->
            <encoder>
                <charset>UTF-8</charset>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- 文件保存日志的相关配置 -->
        <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!-- 保存日志文件的路径 -->
            <file>${logPath}/${appName}.log</file>
    
            <!-- 日志格式 -->
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>${logLevel}</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
    
            <!-- 循环政策:基于时间创建日志文件 -->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!-- 日志文件名格式 -->
                <fileNamePattern>${logPath}/${appName}-%d{yyyy-MM-dd}.log</fileNamePattern>
                <!-- 最大保存时间-->
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
        </appender>
    
        <!--配置mybatis sql 日志-->
        <logger name="com.pf.org.cms.mapper" level="DEBUG"/>
        <!-- 基于INFO处理日志:具体控制台或者文件对日志级别的处理还要看所在appender配置的filter,如果没有配置filter,则使用root配置 -->
    
        <root level="${logLevel}">
            <appender-ref ref="STDOUT" />
            <!-- 开发可以只要控制台就OK -->
            <!-- <appender-ref ref="FILE" /> -->
        </root>
    </configuration>
    

    正式环境配置

    <?xml version="1.0" encoding="UTF-8"?>
    <!-- 分级别异步文件日志输出配置 -->
    <!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
    <!-- 日志输出规则 根据当前ROOT 级别,日志输出时,级别高于root默认的级别时 会输出 -->
    <!-- 以下 每个配置的 filter 是过滤掉输出文件里面,会出现高级别文件,依然出现低级别的日志信息,通过filter 过滤只记录本级别的日志 -->
    <!-- scan 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 -->
    <!-- scanPeriod 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
    <!-- debug 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
    <configuration scan="true" scanPeriod="60 seconds" debug="false">
    
        <!-- logback项目名称 -->
        <property name="appName" value="noSeatBeltProd"></property>
    
        <!-- 日志级别 DEBUGER INFO WARN ERROR -->
        <property name="logLevel" value="INFO"></property>
    
        <!-- 日志路径-->
        <property name="logPath" value="./logs"></property>
    
        <!-- 最大保存时间 30天-->
        <property name="maxHistory" value="3"/>
    
        <!-- 异步缓冲队列的深度,该值会影响性能.默认值为256 -->
        <property name="queueSize" value="256"></property>
    
        <!-- lOGGER  PATTERN 根据个人喜好选择匹配  -->
        <property name="logPattern" value="[ %-5level] [%date{yyyy-MM-dd HH:mm:ss.SSS}] %logger{96} [%line] [%thread]- %msg%n"></property>
        <!-- %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n -->
        <!-- %d{yyyy-MM-dd HH:mm:ss} %-4relative [%thread] %-5level %logger{35} - %msg %n -->
        <!-- [ %-5level] [%date{yyyy-MM-dd HH:mm:ss.SSS}] %logger{96} [%line] [%thread]- %msg%n  -->
    
        <!-- 动态日志级别 -->
        <jmxConfigurator/>
    
        <!-- 控制台的标准输出 -->
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <charset>UTF-8</charset>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- DUBUG 日志记录  -->
        <appender name="FILE_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>
            <file>${logPath}/${appName}_debug.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${logPath}/debug/${appName}_debug.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- INFO 级别的日志记录  -->
        <appender name="FILE_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>
            <file>${logPath}/${appName}_info.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${logPath}/info/${appName}_info.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!--  WARN 级别的日志记录 -->
        <appender name="FILE_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>
            <file>${logPath}/${appName}_warn.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${logPath}/warn/${appName}_warn.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- Error 级别的日志记录 -->
        <appender name="FILE_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>
            <file>${logPath}/${appName}_error.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${logPath}/error/${appName}_error.log.%d{yyyy-MM-dd}.zip
                </fileNamePattern>
                <maxHistory>${maxHistory}</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>${logPattern}</pattern>
            </encoder>
        </appender>
    
        <!-- ASYNC_LOG_DEBUG  -->
        <appender name="ASYNC_LOG_DEBUG" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_DEBUG"/>
        </appender>
    
        <!-- ASYNC_LOG_INFO -->
        <appender name="ASYNC_LOG_INFO" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_INFO"/>
        </appender>
    
        <!-- ASYNC_LOG_WARN -->
        <appender name="ASYNC_LOG_WARN" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_WARN"/>
        </appender>
    
        <!--ASYNC_LOG_ERROR  -->
        <appender name="ASYNC_LOG_ERROR" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <appender-ref ref="FILE_ERROR"/>
        </appender>
    
        <!-- 日志的记录级别 -->
        <!-- 在定义后引用APPENDER -->
        <root level="${logLevel}">
            <!--  控制台  -->
            <appender-ref ref="STDOUT"/>
    
            <!-- 具体的日志级别和文件的配置 -->
            <appender-ref ref="ASYNC_LOG_DEBUG"/>
            <appender-ref ref="ASYNC_LOG_INFO"/>
            <appender-ref ref="ASYNC_LOG_WARN"/>
            <appender-ref ref="ASYNC_LOG_ERROR"/>
        </root>
    </configuration>
    
    展开全文
  • slf4j + logback配置实例

    2019-08-07 01:47:27
    NULL 博文链接:https://200cc.iteye.com/blog/2109690
  • 在SpringBoot项目中使用Logback进行日志管理,Logback配置详解Logback简介SpringBoot的日志模块扩展Logbacklogback-spring.xml配置详解configurationconfiguration下一些配置appenderloggerrootlogger 中 additivity...


    Logback简介

    logback 官网:https://logback.qos.ch/

    logback是由log4j创始人设计的又一个开源日志组件 , 优化了log4j存在的性能问题。

    logback包含了三个模块:logback-core、logback-classic、logback-access。

    • logback-core 是其它模块的基础设施,其它模块基于它构建,显然,logback-core 提供了一些关键的通用机制。
    • logback-classic 的地位和作用等同于 Log4J,它也被认为是 Log4J 的一个改进版,并且它实现了简单日志门面 SLF4J
    • logback-access 主要作为一个与 Servlet 容器交互的模块,比如说tomcatjetty,提供一些与 HTTP 访问相关的功能。

    SpringBoot的日志模块

    在Spring官网,对SpringBoot日志的描述是:

    SpringBoot使用 Commons Logging 来记录所有内部日志,但是实现是开放的,默认配置中支持 Java Util LoggingLog4J2Logback. 。

    如果使用了启动器“ Starters ”,那么将会默认使用Logback作为日志系统。

    当需要配置日志信息时,可以在application.properties、application.yaml中进行简单的配置,比如日志级别。 SpringBoot默认为我们输出的日志级别为infowarnerror,如果还使用其他级别的日志,可以在配置中进行配置 。

    支持的日志级别有: ERROR, WARN, INFO, DEBUG , TRACE (Logback中没有FATAL级别,等同于ERROR)。

    日志级别 trace < debug < info < warn < error < fatal,高级别的日志会输出低级别的日志信息,反之不行,不区分大小写。

    在application.properties中配置:

    #配置根logger的输出级别,也可以直接使用大写的 LEVEL=WARN指定
    logging.level.root=WARN
    
    #指定logger的name属性为org.springframework.web,即该包下的日志级别为DEBUG
    logging.level.org.springframework.web=DEBUG
    logging.level.org.hibernate=ERROR
    
    #指定日志输出的文件路径,/在windows下是直接定位到当前工作文件磁盘下的
    logging.path=/logs
    #指定日志文件的名称
    logging.file=logs.log
    

    在application.yaml中:

    loggin: 
    	level: 
    		root: WARN
    

    扩展Logback

    SpringBoot系统配置文件中,对日志只有一些简单的配置。当无法满足使用需求时可以进行扩展,扩展时需在配置文件中自定义扩展日志配置文件名称,可以定义按模块分别打印日志等。

    在 application.properties 中定义扩展的日志文件名称:

    logging.config=classpath:logback-spring.xml
    

    在application.yaml中:

    logging:
      config: classpath:logback-spring.xml
    

    在官方文件中,建议Logback扩展文件命名使用logback-spring.xml,并建在 src/main/resources 目录下就能使用。

    根据不同的日志系统,你可以按如下规则组织配置文件名,就能被正确加载:

    日志类型扩展日志名称
    Logbacklogback-spring.xml、logback-spring.groovy、logback.xml 、 logback.groovy
    Log4j2log4j2-spring.xml 、 log4j2.xml
    JDK (Java Util Logging)logging.properties

    注:日志记录是在创建ApplicationContext之前初始化的,所以无法通过 @Configuration 文件中的 @PropertySources 去配置日志。 通过系统属性和传统的Spring Boot外部配置文件依然可以很好的支持日志控制和管理。


    logback-spring.xml配置详解

    接下来说说logback中各个配置怎么使用。首先看看下面这张图,这就是logback 整个配置文件的结构 。
    在这里插入图片描述
    文末有博主自己整理的所有配置参数详解的脑图,可以保存留用。

    configuration

    <configuration>是Logback配置的根节点,它可以设置以下信息。

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

    configuration下一些配置

    (1)<include>:用来引入外部资源文件

    • resource:表示资源路径

    (2)<contextName>:每个logger都关联到logger上下文,默认上下文名称为default,但可以使用设置成其他名字,用于区分不同应用程序的记录,一旦设置,不能修改,可以通过%contextName来打印日志上下文名称

    (3)<property>:自定义变量,使用${}来使用变量

    • name:变量名
    • value:变量值

    (4)<springProfile>:用来指定不同环境来使不同的日志输出。在此标签内相当于隔出了一个标签块,<root><logger>等可在其中使用并配置。

    • name:使用的环境名称,多个环境使用,分开,需在application.properties文件中通过spring.profiles.active来指定当前使用的环境,可以用!+ 环境名称表示当前环境不适用,如!dev即dev下禁用此日志配置

    • <root>:和上面的root配置一致

    • <logger>:和上面的root配置一致


    appender

    (1)<appender>:日志输出策略

    • name:策略名称
    • class:策略类型。
      • ch.qos.logback.core.ConsoleAppender是对应的控制台输出策略;
      • ch.qos.logback.core.rolling.RollingFileAppender是对应的文件输出策略。

    (2)<file>:日志输出的路径及文件名

    (3)<filter>:过滤规则,可以同时配置多个过滤规则,按照配置顺序执行。

    • class:过滤器类型。
      • ch.qos.logback.classic.filter.ThresholdFilter 临界值过滤器,过滤掉低于指定临界值的日志
        • <level>:日志输出级别
      • ch.qos.logback.classic.filter.LevelFilter 级别过滤器,被定义的日志级别根据规则过滤。
        • <level>:日志输出级别
        • <onMatch>:级别匹配时操作。即当日志的级别和定义的level匹配时,进行的过滤操作。
        • <onMismatch>:不匹配时操作 。即当日志的级别和定义的level匹配时,进行的过滤操作。

    ​级别过滤器 操作枚举有三个:

    • DENY:日志将立即被抛弃不再经过其他过滤器
    • NEUTRAL:有序列表里的下个过滤器接着处理日志
    • ACCEPT:日志会被立即处理,不再经过剩余过滤器

    (4)<encoder>:设置日志输出的格式。

    • class: 目前仅一种输出类型,ch.qos.logback.classic.encoder.PatternLayoutEncoder 把日志转换成字节流写入文件 。
    • charset:日志输出的编码。
    • <pattern>:日志输出的格式。

    (5)<rollingPolicy>:设置日志切割策略。

    • class:日志切割策略。
      • ch.qos.logback.core.rolling.TimeBasedRollingPolicy 按天切割 ;
      • SizeAndTimeBasedRollingPolicy 按天和文件大小切割 。
    • <fileNamePattern>:定义了日志的切割方式,切割后存放的文件名。
    • <maxFileSize>:指定单个日志文件的上限大小,超限就会进行切割。
    • <maxHistory>:表示只保存最近多少天的日志,以防止日志填满整个磁盘空间。
    • <totalSizeCap>:所有日志文件总上限 。

    (6) <triggeringPolicy> : 触发策略,在切割策略进行切割的过程中,满足触发策略也可以触发切割,作为补充条件 。 SizeBasedTriggeringPolicy 按文件大小切割 。



    logger

    <logger>:用来指定某一个包或者具体的类的日志打印级别。

    • name:指定某个包或者具体的类。
    • level:指定日志输出级别。
    • <level>:指定日志输出级别。
      • value:指定日志输出级别。
    • <appender-ref>:引用自定义的日志输出策略,就是引用<appender>
      • ref:引用日志输出策略。
    • additivity:是否向上级logger传递打印信息。默认是true。

    root

    <root>:用来指定最基础的日志输出级别。

    • level:指定日志输出级别。
    • <appender-ref>:引用自定义的日志输出策略,就是引用<appender>
      • ref:引用日志输出策略。

    logger 中 additivity=true是什么样的?

    我们先假设有一段代码,在该段代码中打印了各种级别的日志信息。

    @RestController
    public class testLogbackController {
        private Logger logger = LoggerFactory.getLogger(this.getClass());
    
        @RequestMapping(value = "/testLogbackController",method = RequestMethod.GET)
        public void login(HttpServletRequest request, HttpServletResponse response){
            //日志级别从低到高为 TRACE < DEBUG < INFO < WARN < ERROR,如果设置为WARN,则低于WARN的信息都不会输出。
            logger.trace("日志输出 trace");
            logger.debug("日志输出 debug");
            logger.info("日志输出 info");
            logger.warn("日志输出 warn");
            logger.error("日志输出 error");
        }
    }
    

    logger在实际使用的时候有两种情况 。

    第一种:不指定级别,不指定appender的logger的配置

    <root level="info">
    </root>
    
    <logger name="com.xxx.controller"/>
    

    由于logger没设置级别,所以继承上级(此处只有根logger)的级别为info,additivity默认为true开启。

    所以这个logger首先执行,然后将级别为“info”及大于“info”的日志信息传递给root。由于该logger没有定义打印方式,于是将在root的方式打印日志信息。


    第二种:带有指定级别,指定appender的logger的配置

    <logger name="com.xxx.controller" level="WARN" additivity="false">
            <appender-ref ref="console"/>
    </logger>
    

    将级别为“WARN”及大于“WARN”的日志信息交给此logger指定的名为“console”的appender处理,不再向上级root传递打印信息。

    如果你把additivity=”false”改成additivity=”true”的话,就会打印两次,因为打印信息向上级传递,logger本身打印一次,root接到后又打印一次。


    mybatis使用Logback不打印sql语句信息问题

    使用mybatis的时候,sql语句是debug下才会打印。所以想要查看sql语句的话,有以下两种操作:

    • 第一种:把<root level="info">改成<root level="DEBUG">这样就会打印sql,不过这样日志那边会出现很多其他消息。
    • 第二种:单独给mybatis或者dao目录配置debug模式。,这样配置sql语句会打印,其他还是正常info级别。
    #给dao包设置debug模式
    <logger name="com.xx.dao" additivity="false">
            <level value="DEBUG"/>
    </logger>
    
    #给mybatis包设置debug模式
    <logger name="org.mybatis" additivity="false">
            <level value="DEBUG"/>
    </logger>
    

    出现这个问题的原因是因为mybatis源代码BaseExceutor.java,在其中会判断是debug模式时才会打印sql语句。

      protected Connection getConnection(Log statementLog) throws SQLException {
        Connection connection = transaction.getConnection();
        if (statementLog.isDebugEnabled()) {
          return ConnectionLogger.newInstance(connection, statementLog);
        } else {
          return connection;
        }
      }
    

    Logback配置示例

    简单示例:

    ?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <include resource="org/springframework/boot/logging/logback/base.xml" />
        <logger name="org.springframework.web" level="INFO"/>
        <logger name="org.springboot.sample" level="TRACE" />
    
        <!-- 开发、测试环境 -->
        <springProfile name="dev,test">
            <logger name="org.springframework.web" level="INFO"/>
            <logger name="org.springboot.sample" level="INFO" />
            <logger name="com.xx.projectName" level="DEBUG" />
        </springProfile>
    
        <!-- 生产环境 -->
        <springProfile name="prod">
            <logger name="org.springframework.web" level="ERROR"/>
            <logger name="org.springboot.sample" level="INFO" />
            <logger name="com.xx.projectName" level="INFO" />
        </springProfile>
    
    	<!-- root用来指定最基础的日志输出级别 -->
        <root level="INFO">
        </root>
    </configuration>
    

    Logback详细配置示例:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration scan="true" scanPeriod="10 seconds" debug="false">
        <include resource="org/springframework/boot/logging/logback/base.xml"/>
        <contextName>logback</contextName>
    
        <property name="log_path" value="/log"/><!-- 如果在Windows环境下使用/开头的路径,将会被指定到项目所在的盘符 -->
        <!-- %d{yyyy-MM-dd HH:mm:ss.SSS}:日志输出时间,精确到分按天切割; -->
        <!-- %-5level:日志级别,并且使用5个字符靠左对齐; %thread:输出日志的进程名字 -->
        <!-- %logger{50}:日志输出者的名字; %msg:日志消息; %n:换行符 -->
        <property name="log_pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level --- [%thread] %logger{50} - %msg%n"/>
        <property name="log_fileNamePattern" value="-%d{yyyy-MM-dd}.%i.log"/>
        <property name="log_maxFileSize" value="100MB"/>
        <property name="log_maxHistory" value="15"/>
    
        <!-- 输出到控制台,一般生产环境都是后台启动,这个没太大作用 -->
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
            <encoder charset="UTF-8">
                <pattern>${log_pattern}</pattern>
            </encoder>
        </appender>
    
        <!-- 输出到app.log文件 -->
        <appender name="APP" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${log_path}/app.log</file>
            <encoder charset="UTF-8">
                <pattern>${log_pattern}</pattern>
            </encoder>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log_path}/app${log_fileNamePattern}</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${log_maxFileSize}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <maxHistory>${log_maxHistory}</maxHistory>
            </rollingPolicy>
        </appender>
    
        <!-- 输出到sql.log文件 -->
        <appender name="SQL" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${log_path}/sql.log</file>
            <encoder charset="UTF-8">
                <pattern>${log_pattern}</pattern>
            </encoder>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log_path}/sql-${log_fileNamePattern}</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${log_maxFileSize}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <maxHistory>${log_maxHistory}</maxHistory>
            </rollingPolicy>
        </appender>
    
        <!-- 自定义包日志级别要加上additivity="false",表示不会向上传递 -->
        <logger name="org.springframework">
            <level value="WARN"/>
        </logger>
        <logger name="org.apache" additivity="false">
            <level value="WARN"/>
        </logger>
        <logger name="org.mybatis" additivity="false">
            <level value="DEBUG"/>
        </logger>
    
        <!-- dao层的sql配置 -->
        <logger name="com.example.xxx.dao" level="DEBUG" additivity="false">
            <appender-ref ref="SQL" />
        </logger>
    
        <!-- root用来指定最基础的日志输出级别 -->
        <root level="INFO">
            <appender-ref ref="APP"/>
        </root>
    
    </configuration>
    

    Logback所有配置详解脑图

    Logback详细配置


    本文参考:
    [1] Spring官网 :SpringBoot 官网在线说明
    [2] @断橋殘雪 :SpringBoot整合logback实现对日志的管理
    [3] @glmapperl :看完这个不会配置 logback ,请你吃瓜!
    [4] @维1 :SpringBoot默认日志logback配置解析

    展开全文
  • logback配置文件详解

    千次阅读 2019-09-19 11:24:45
    文章目录一、logback的简单介绍二、logback的使用三、logback的配置四、关于SLF4j的日志输出级别五、logback配置详解 一、logback的简单介绍 logback是java的日志开源组件,是log4j创始人写的,性能比log4j要好,...

    一、logback的简单介绍

    logback是java的日志开源组件,是log4j创始人写的,性能比log4j要好,目前主要分为3个模块
    logback-core:核心代码模块
    logback-classic:log4j的一个改良版本,同时实现了slf4j的接口,这样你如果之后要切换其他日志组件也是一件很容易的事
    logback-access:访问模块与Servlet容器集成提供通过Http来访问日志的功能
    本篇博客会讲解logback的使用、配置详解、以及logback简单的一个原理。

    二、logback的使用

    <!--这个依赖直接包含了 logback-core 以及 slf4j-api的依赖-->
    <dependency>
         <groupId>ch.qos.logback</groupId>
         <artifactId>logback-classic</artifactId>
         <version>1.2.3</version>
    </dependency>
    

    然后就可以直接在代码中使用slf4j的接口获取Logger输出日志了。(配置在下面的章节介绍)

    private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
    
    public static void main(String[] args) throws InterruptedException {
        LOGGER.info("hello world");
    }
    

    三、logback的配置

    logback在启动的时候,会按照下面的顺序加载配置文件

    如果java程序启动时指定了logback.configurationFile属性,就用该属性指定的配置文件。
    如java -Dlogback.configurationFile=/path/to/mylogback.xml Test ,
    这样执行Test类的时候就会加载/path/to/mylogback.xml配置

    在classpath中查找 logback.groovy 文件
    在classpath中查找 logback-test.xml 文件
    在classpath中查找 logback.xml 文件
    如果是 jdk6+,那么会调用ServiceLoader 查找 com.qos.logback.classic.spi.Configurator接口的第一个实现类
    自动使用ch.qos.logback.classic.BasicConfigurator,在控制台输出日志
    上面的顺序表示优先级,使用java -D配置的优先级最高,只要获取到配置后就不会再执行下面的流程。相关代码可以看ContextInitializer#autoConfig()方法。

    四、关于SLF4j的日志输出级别

    在slf4j中,从小到大的日志级别依旧是trace、debug、info、warn、error。

    TRACE:很低的日志级别,一般不会使用
    DEBUG:指出细粒度信息事件对调试应用程序是非常有帮助的,主要用于开发过程中打印一些运行信息。
    INFO:消息在粗粒度级别上突出强调应用程序的运行过程。打印一些你感兴趣的或者重要的信息,这个可以用于生产环境中输出程序运行的一些重要信息,但是不能滥用,避免打印过多的日志。
    WARN:表明会出现潜在错误的情形,有些信息不是错误信息,但是也要给程序员的一些提示
    ERROR:指出虽然发生错误事件,但仍然不影响系统的继续运行。打印错误和异常信息,如果不想输出太多的日志,可以使用这个级别

    五、logback配置详解

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration debug="true" scan="true" scanPeriod="1 seconds">
    
        <contextName>logback</contextName>
        <!--定义参数,后面可以通过${app.name}使用-->
        <property name="app.name" value="logback_test"/>
        <!--ConsoleAppender 用于在屏幕上输出日志-->
        <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
            <!--定义了一个过滤器,在LEVEL之下的日志输出不会被打印出来-->
            <!--这里定义了DEBUG,也就是控制台不会输出比ERROR级别小的日志-->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>DEBUG</level>
            </filter>
            <!-- encoder 默认配置为PatternLayoutEncoder -->
            <!--定义控制台输出格式-->
            <encoder>
                <pattern>%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n</pattern>
            </encoder>
        </appender>
    
        <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--定义日志输出的路径-->
            <!--这里的scheduler.manager.server.home 没有在上面的配置中设定,所以会使用java启动时配置的值-->
            <!--比如通过 java -Dscheduler.manager.server.home=/path/to XXXX 配置该属性-->
            <file>${scheduler.manager.server.home}/logs/${app.name}.log</file>
            <!--定义日志滚动的策略-->
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!--定义文件滚动时的文件名的格式-->
                <fileNamePattern>${scheduler.manager.server.home}/logs/${app.name}.%d{yyyy-MM-dd.HH}.log.gz
                </fileNamePattern>
                <!--60天的时间周期,日志量最大20GB-->
                <maxHistory>60</maxHistory>
                <!-- 该属性在 1.1.6版本后 才开始支持-->
                <totalSizeCap>20GB</totalSizeCap>
            </rollingPolicy>
            <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
                <!--每个日志文件最大100MB-->
                <maxFileSize>100MB</maxFileSize>
            </triggeringPolicy>
            <!--定义输出格式-->
            <encoder>
                <pattern>%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n</pattern>
            </encoder>
        </appender>
    
        <!--root是默认的logger 这里设定输出级别是debug-->
        <root level="trace">
            <!--定义了两个appender,日志会通过往这两个appender里面写-->
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
        </root>
    
        <!--对于类路径以 com.example.logback 开头的Logger,输出级别设置为warn,并且只输出到控制台-->
        <!--这个logger没有指定appender,它会继承root节点中定义的那些appender-->
        <logger name="com.example.logback" level="warn"/>
    
        <!--通过 LoggerFactory.getLogger("mytest") 可以获取到这个logger-->
        <!--由于这个logger自动继承了root的appender,root中已经有stdout的appender了,自己这边又引入了stdout的appender-->
        <!--如果没有设置 additivity="false" ,就会导致一条日志在控制台输出两次的情况-->
        <!--additivity表示要不要使用rootLogger配置的appender进行输出-->
        <logger name="mytest" level="info" additivity="false">
            <appender-ref ref="stdout"/>
        </logger>
        
        <!--由于设置了 additivity="false" ,所以输出时不会使用rootLogger的appender-->
        <!--但是这个logger本身又没有配置appender,所以使用这个logger输出日志的话就不会输出到任何地方-->
        <logger name="mytest2" level="info" additivity="false"/>
    </configuration>
    
    展开全文
  • logback 配置详解

    万次阅读 2018-06-22 23:51:00
    简单地说,Logback 是一个 Java 领域的日志框架。它被认为是 Log4J 的继承人。 Logback 主要由三个模块组成: logback-core logback-classic logback-access logback-core 是其它模块的基础设施,...
  • Spring Boot Logback 配置详解

    千次阅读 2019-01-08 17:42:19
    1、Logback简介 Logback是由log4j创始人设计的又一个开源日志组件。 相比于log4j,Logback重写了内核,在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了, 初始化内存加载也更小;  logback当前...
  • logback加载外部配置文件 重置logback配置文件路径 logback作为一种成熟的日志框架,已被广泛应用在现代各种java项目中。以javaweb项目为例,使用logback.xml作为logback的配置文件时,在代码中通常是将该配置文件...
  • 使用Logback记录日志 Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log...
  • springboot读取配置文件是有优先级的,如果使用默认的logback.xml或者logback-spring.xml为配置文件名则会读取不到nacos上的配置。命名为logback-spring.xml程序只会在运行后一段时间内报错,一段时间后读取到nacos...
  • logback配置

    2016-08-08 17:40:56
    Dependencies如Slf4j、log4j、logback关系介绍中所说,sif4j+logback日志体系,其dependencies: slf4j-api (slf4j接口) logback-classic (logback服务于slf4j...logback配置logback.xml示例如下:<?xml version="1.
  • logback框架会默认加载classpath下命名为logback-spring.xml或logback.xml的配置文件。这篇文章主要介绍了Logback配置文件写法,需要的朋友可以参考下
  • SpringBoot(十) Logback 配置详解

    千次阅读 2018-11-06 16:24:45
    一.了解 简单地说,Logback 是一个 Java 领域的日志框架。它被认为是 Log4J 的继承人。...logback-core 是其它模块的基础设施,其它模块基于它构建,显然,logback-core 提供了一些关键的通用机制。logba...
  • logback配置类的初始化在: org.slf4j.impl.StaticLoggerBinder类中的静态代码块中: 初始化调用了上下文初始化的自动配置方法: 自动配置中的关键代码调用 findURLOfDefaultConfigurationFile,去查找配置文件...
  • 目录 1、根节点包含的属性 2、根节点的子节点  2.1、设置上下文名称:  2.2、设置loger、root 正文 1、根节点包含的属性 ...当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值
  • 主要介绍了Logback配置文件这么写(TPS提高10倍),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 转载请注明出处:... 在resources 下面新增日志配置文件 logback-spring.xml <?xml version="1.0" encoding="UTF-8"?> <!-- 日志级别从低到高分为TRACE < DEBUG < INF...
  • logback配置文件不生效问题 今天在做测试环境部署的时候,因为新版本上线需要做安全测试,所以需要应用生成一种特定的日志文件,这个时候就需要配置logback配置文件,因为应用的底层框架是使用已经封装好的框架,对...
  • 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 scanPeriod: 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,241
精华内容 17,296
关键字:

logback配置