Spring boot学习（七）Spring boot配置slf4j+logback日志框架

前言

对于一个web项目来讲，日志框架是必不可少的，日志的记录能够帮助咱们在开发以及维护过程当中快速的定位错误。相信不少人据说过slf4j,log4j,logback,JDK Logging等跟日志框架有关的词语，因此这里也简单介绍下他们之间的关系。

文章首发于我的博客:【www.xiongfrblog.cn】

关系

首先slf4j能够理解为规则的制定者，是一个抽象层，定义了日志相关的接口。log4j,logback,JDK Logging都是slf4j的实现层，只是出处不一样，固然使用起来也就各有千秋，这里放一张网上的图更明了的解释了他们之间的关系：

能够看到logback是直接实现的slf4j，而其余的中间还有一个适配层，至于缘由也很简单，由于logback和slf4j的做者是一我的。关于这几个框架详细介绍信息，在网上找到一篇讲解的通俗易懂的文章，感兴趣的朋友能够了解下【传送门】

为何使用slf4j+logback

我使用这个框架是由于一开始接触的时候就用的这个，后来在网上了解到slf4j+logback也确实当下最流行的日志框架，而且本身用着也确实很顺手，也就一直用了下来，关于这个框架相比于其它日志框架的优点，由于我没用过其它的框架，这里也就不作那误人子弟的事了，也只是在网上作过了解，这里给出一篇介绍的比较详细的博文【传送门】

在Spring boot中使用slf4j+logback日志框架

添加配置文件

在Spring boot使用是很是方便的，不须要咱们有什么额外的配置，由于Spring boot默认支持的就是slf4j+logback的日志框架，想要灵活的定制日志策略，只须要咱们在src/main/resources下添加配置文件便可，只是默认状况下配置文件的命名须要符合如下规则：

• logback.xml
• logback-spring.xml

其中logback-spring.xml是官方推荐的，而且只有使用这种命名规则，才能够配置不一样环境使用不一样的日志策略这一功能。

配置文件详解

首先介绍配置文件的关键节点：

框架介绍

<configuration>：根节点,有三个属性：

1. scan：当配置文件发生修改时，是否从新加载该配置文件，两个可选值true or false，默认为true。
2. scanPeriod：检测配置文件是否修改的时间周期，当没有给出时间单位时默认单位为毫秒，默认值为一分钟,须要注意的是这个属性只有在scan属性值为true时才生效。
3. debug：是否打印loback内部日志信息，两个可选值true or false，默认为false。

根节点<configuration>有三个重要的子节点,正是这三个子节点的不一样组合构成配置文件的基本框架，使得logback.xml配置文件具有很强的灵活性:

• <appender>：定义日志策略的节点，一个日志策略对应一个<appender>，一个配置文件中能够有零个或者多该节点，但一个配置文件若是没有定义至少一个<appender>，虽然程序不会报错，但就不会有任何的日志信息输出，也失去了意义，该节点有两个必要的属性：

  1. name：指定该节点的名称，方便以后的引用。
  2. class：指定该节点的全限定名，所谓的全限定名就是定义该节点为哪一种类型的日志策略，好比咱们须要将日志输出到控制台，就须要指定class的值为ch.qos.logback.core.ConsoleAppender;须要将日志输出到文件，则class的值为ch.qos.logback.core.FileAppender等，想要了解全部的appender类型，能够查阅官方文档【传送门】

• <logger>：用来设置某个包或者类的日志打印级别，而且能够引用<appender>绑定日志策略，有三个属性：

  1. name：用来指定受此<logger>约束的包或者类。
  2. level：可选属性，用来指定日志的输出级别，若是不设置，那么当前<logger>会继承上级的级别。
  3. additivity：是否向上级传递输出信息，两个可选值true or false，默认为true。

在该节点内能够添加子节点<appender-ref>,该节点有一个必填的属性ref,值为咱们定义的<appender>节点的name属性的值。

• <root>：根<logger>一个特殊的<logger>，即默认name属性为root的<logger>，由于是根<logger>，因此不存在向上传递一说，故没有additivity属性,因此该节点只有一个level属性。

介绍了根节点的三个主要的子节点，下面再介绍两个不那么重要但能够了解的子节点：

• <contextName>：设置上下文名称，每一个<logger>都关联到<logger>上下文，默认上下文名称为default,但可使用设置成其余名字，用于区分不一样应用程序的记录,一旦设置，不能修改,能够经过 %contextName 来打印日志上下文名称，通常来讲咱们不用这个属性，无关紧要。
• <property>：用来定义变量的节点，定义变量后，可使${}来使用变量,两个属性,当定义了多个<appender>的时候仍是颇有用的：
  1. name：变量名
  2. value：变量值

好了，介绍了上边的节点咱们就已经能够搭建一个简单的配置文件框架了，以下：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 通常根节点不须要写属性了，使用默认的就好 -->
<configuration>

    <contextName>demo</contextName>
    
    <!-- 该变量表明日志文件存放的目录名 -->
    <property name="log.dir" value="logs"/>
    <!-- 该变量表明日志文件名 -->
	<property name="log.appname" value="eran"/>
    
    <!--定义一个将日志输出到控制台的appender，名称为STDOUT -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 内容待定 -->
    </appender>
    
    <!--定义一个将日志输出到文件的appender，名称为FILE_LOG -->
    <appender name="FILE_LOG" class="ch.qos.logback.core.FileAppender">
        <!-- 内容待定 -->
    </appender>
  
    <!-- 指定com.demo包下的日志打印级别为INFO，可是因为没有引用appender，因此该logger不会打印日志信息，日志信息向上传递 -->
    <logger name="com.demo" level="INFO"/>
  
    <!-- 指定最基础的日志输出级别为DEBUG，而且绑定了名为STDOUT的appender，表示将日志信息输出到控制台 -->
    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>
复制代码

上面搭建了框架，定义了一个输出到控制台的ConsoleAppender以及输出到文件的FileAppender，下面来细说这两个最基本的日志策略，并介绍最经常使用的滚动文件策略的RollingFileAppender，这三种类型的日志策略足够咱们的平常使用。

输出到控制台的ConsoleAppender的介绍：

先给出一个demo：

<!--定义一个将日志输出到控制台的appender，名称为STDOUT -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
    </encoder>
</appender>

复制代码

ConsoleAppender的功能是将日志输出到控制台，有一个<encoder>节点用来指定日志的输出格式，在较早之前的版本还有一个<layout>节点也是相同的做用，可是官方推荐使用encoder节点，因此这里咱们介绍encoder节点便可。

<encoder>节点介绍

该节点主要作两件事：

• 把日志信息转换成字节数组
• 将字节数组写到输出流

该节点的子节点<pattern>做用就是定义日志的格式，即定义一条日志信息包含哪些内容，例如当前时间，在代码中的行数线程名等。须要哪些内容由咱们本身定义，按照%+转换符的格式定义，下面列出经常使用的转换符：

• %date{}:输出时间，能够在花括号内指定时间格式，例如-%data{yyyy-MM-dd HH:mm:ss}，格式语法和java.text.SimpleDateFormat同样，能够简写为%d{}的形式，使用默认的格式时能够省略{}。
• %logger{}：日志的logger名称，能够简写为%c{},%lo{}的形式，使用默认的参数时能够省略{}，能够定义一个整形的参数来控制输出名称的长度，有下面三种状况：
  1. 不输入表示输出完整的<logger>名称
  2. 输入0表示只输出<logger>最右边点号以后的字符串
  3. 输入其余数字表示输出小数点最后边点号以前的字符数量
• %thread：产生日志的线程名，可简写为%t
• %line:当前打印日志的语句在程序中的行号，可简写为%L
• %level：日志级别,可简写为%le,%p
• %message：程序员定义的日志打印内容,可简写为%msg,%m
• %n：换行,即一条日志信息占一行

介绍了经常使用的转换符，咱们再看看上边的例子中咱们定义的格式：

<pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
复制代码

日志的格式一目了然，能够看出咱们在最前面加了[eran]的字符串，这里是我我的的使用习惯，通常将项目名统一展示在日志前边，并且在每一个转换符之间加了空格，这更便于咱们查看日志，而且使用了>>字符串来将%msg分割开来，更便于咱们找到日志信息中咱们关注的内容，这些东西你们能够本身按照本身的喜爱来。

输出到文件的FileAppender

先给出一个demo：

<!--定义一个将日志输出到文件的appender，名称为FILE_LOG -->
<appender name="FILE_LOG" class="ch.qos.logback.core.FileAppender">  
    <file>D:/test.log</file>
    <append>true</append>  
    <encoder>  
        <pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
    </encoder>
</appender>
复制代码

FileAppender表示将日志输出到文件，经常使用几个子节点：

• <file>：定义文件名和路径，能够是相对路径 , 也能够是绝对路径 , 若是路径不存在则会自动建立
• <append>：两个值true和false，默认为true，表示每第二天志输出到文件走追加在原来文件的结尾，false则表示清空现存文件
• <encoder>：和ConsoleAppender同样

显而易见，样例中咱们的日志策略表示，每次将日志信息追加到D:/test.log的文件中。

滚动文件策略RollingFileAppender介绍

按时间滚动TimeBasedRollingPolicy

demo以下：

<appender name="ROL-FILE-LOG" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
  <!--滚动策略，按照时间滚动 TimeBasedRollingPolicy-->
  <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  	<fileNamePattern>D:/logs/test.%d{yyyy-MM-dd}.log</fileNamePattern>
  	<!-- 只保留近七天的日志 -->
  	<maxHistory>7</maxHistory>
  	<!-- 用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志 -->
  	<totalSizeCap>1GB</totalSizeCap>
  </rollingPolicy> 
  
  <encoder>
	<pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
  </encoder>
</appender>
复制代码

RollingFileAppender是很是经常使用的一种日志类型，表示滚动纪录文件，先将日志记录到指定文件，当符合某种条件时，将日志记录到其余文件,经常使用的子节点：

• <rollingPolicy>：滚动策略，经过属性class来指定使用什么滚动策略，最经常使用是按时间滚动TimeBasedRollingPolicy,即负责滚动也负责触发滚动，有如下经常使用子节点：

  1. <fileNamePattern>：指定日志的路径以及日志文件名的命名规则，通常根据日志文件名+%d{}.log来命名，这边日期的格式默认为yyyy-MM-dd表示天天生成一个文件，即按天滚动yyyy-MM，表示每月生成一个文件，即按月滚动
  2. <maxHistory>：可选节点，控制保存的日志文件的最大数量，超出数量就删除旧文件，好比设置天天滚动，且<maxHistory> 是7，则只保存最近7天的文件，删除以前的旧文件
  3. <encoder>:同上
  4. <totalSizeCap>:这个节点表示设置全部的日志文件最多占的内存大小，当超过咱们设置的值时，logback就会删除最先建立的那一个日志文件。

以上就是关于RollingFileAppender的经常使用介绍，上面的demo的配置也基本知足了咱们按照时间滚动TimeBasedRollingPolicy生成日志的要求，下面再介绍一种经常使用的滚动类型SizeAndTimeBasedRollingPolicy,即按照时间和大小来滚动。

按时间和大小滚动SizeAndTimeBasedRollingPolicy

demo以下：

<appender name="ROL-SIZE-FILE-LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>D:/logs/test.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <!-- 单个文件的最大内存 -->
        <maxFileSize>100MB</maxFileSize>
        <!-- 只保留近七天的日志 -->
        <maxHistory>7</maxHistory>
        <!-- 用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志 -->
        <totalSizeCap>1GB</totalSizeCap>
    </rollingPolicy>
    
    <encoder>
        <pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
    </encoder>
</appender>
复制代码

仔细观察上边demo中的<fileNamePattern>会发现比TimeBasedRollingPolicy中定义的<fileNamePattern>多了.%i的字符，这个很关键，在SizeAndTimeBasedRollingPolicy中是必不可少的。

上边的demo中多了一个<maxFileSize>节点，这里介绍下，其余的节点上边已经解释过，这里就再也不赘述。

<maxFileSize>：表示单个文件占用的最大内存大小，当某个文件超过这个值，就会触发滚动策略，产生一个新的日志文件。

日志过滤

级别介绍

在说级别过滤以前，先介绍一下日志的级别信息：

• TRACE
• DEBUG
• INFO
• WARN
• ERROR

上述级别从上到下由低到高，咱们开发测试通常输出DEBUG级别的日志，生产环境配置只输出INFO级别甚至只输出ERROR级别的日志，这个根据状况而定，很灵活。

过滤节点<filter>介绍

过滤器一般配置在Appender中，一个Appender能够配置一个或者多个过滤器，有多个过滤器时按照配置顺序依次执行，固然也能够不配置，其实大多数状况下咱们都不须要配置，可是有的状况下又必须配置，因此这里也介绍下经常使用的也是笔者曾经使用过的两种过率机制：级别过滤器LevelFilter和临界值过滤器ThresholdFilter。

在此以前先说下<filter>的概念，首先一个过滤器<filter>的全部返回值有三个，每一个过滤器都只返回下面中的某一个值：

• DENY:日志将被过滤掉，而且不通过下一个过滤器
• NEUTRAL:日志将会到下一个过滤器继续过滤
• ACCEPT：日志被当即处理，再也不进入下一个过滤器

级别过滤器LevelFilter

过滤条件：只处理INFO级别的日志，格式以下：

<filter class="ch.qos.logback.classic.filter.LevelFilter">   
    <level>INFO</level>   
    <onMatch>ACCEPT</onMatch>   
    <onMismatch>DENY</onMismatch>   
</filter>
复制代码

• <level>:日志级别
• <onMatch>：配置知足过滤条件的处理方式
• <onMismatch>:配置不知足过滤条件的处理方式

就如上边的demo中的配置同样，设置了级别为INFO,知足的日志返回ACCEPT即当即处理，不知足条件的日志则返回DENY即丢弃掉，这样通过这一个过滤器就只有INFO级别的日志会被打印出输出。

临界值过滤器ThresholdFilter

过滤条件：只处理INFO级别之上的日志，格式以下：

<filter class="ch.qos.logback.classic.filter.ThresholdFilter">   
    <level>INFO</level>   
</filter>
复制代码

当日志级别等于或高于临界值时，过滤器返回NEUTRAL,当日志级别低于临界值时，返回DENY。

带过滤器的<Appender>

下面给出一个带过滤器的<Appender>:

<appender name="ROL-SIZE-FILE-LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>D:/logs/test.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <!-- 单个文件的最大内存 -->
        <maxFileSize>100MB</maxFileSize>
        <!-- 只保留近七天的日志 -->
        <maxHistory>7</maxHistory>
        <!-- 用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志 -->
        <totalSizeCap>1GB</totalSizeCap>
    </rollingPolicy>
    
    <encoder>
        <pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
    </encoder>
    
    <!-- 只处理INFO级别以及之上的日志 -->
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">   
        <level>INFO</level>   
    </filter>
    
    <!-- 只处理INFO级别的日志 -->
    <filter class="ch.qos.logback.classic.filter.LevelFilter">   
        <level>INFO</level>   
        <onMatch>ACCEPT</onMatch>   
        <onMismatch>DENY</onMismatch>   
    </filter>
</appender>
复制代码

上边的demo中,咱们给按时间和大小滚动SizeAndTimeBasedRollingPolicy的滚动类型加上了过滤条件。

异步写入日志AsyncAppender

都知道，咱们的日志语句是嵌入在程序内部，若是写入日志以及程序执行的处于一个串行的状态，那么日志的记录就必然会阻碍程序的执行，加长程序的响应时间，无疑是一种极为损耗效率的方式，因此实际的项目中咱们的日志记录通常都用异步的方式来记录，这样就和主程序造成一种并行的状态，不会影响咱们程序的运行，这也是咱们性能调优须要注意的一个点。

AsyncAppender并不处理日志，只是将日志缓冲到一个BlockingQueue里面去，并在内部建立一个工做线程从队列头部获取日志，以后将获取的日志循环记录到附加的其余appender上去，从而达到不阻塞主线程的效果。所以AsynAppender仅仅充当事件转发器，必须引用另外一个appender来写日志。

<appender name ="ASYNC" class= "ch.qos.logback.classic.AsyncAppender">  
    <!-- 不丢失日志.默认的,若是队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->  
    <discardingThreshold >0</discardingThreshold>  
    <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->  
    <queueSize>512</queueSize>  
    <!-- 添加附加的appender,最多只能添加一个 -->  
    <appender-ref ref ="FILE_LOG"/>
</appender>
复制代码

经常使用节点：

• <discardingThreshold>:默认状况下，当BlockingQueue还有20%容量，他将丢弃TRACE、DEBUG和INFO级别的日志，只保留WARN和ERROR级别的日志。为了保持全部的日志，设置该值为0。
• <queueSize>:BlockingQueue的最大容量，默认状况下，大小为256。
• <appender-ref>:添加附加的<appender>,最多只能添加一个

<logger>和<root>节点介绍

上边花费了很长的篇幅介绍了<appender>的相关内容，如今来详细介绍下<logger>节点以及<root>节点的相关内容。

上文已经简单介绍了<logger>节点的属性以及子节点，这里咱们就举例来讲明在logback-spring.xml文件中，该节点到底扮演怎样的角色，以及他的运行原理，看下边的demo：

首先在这里给出项目结构：

下面定义两个<logger>以及<root>：

<!-- logger1 -->
<logger name="com.example" level="ERROR">
	<appender-ref ref="STDOUT" />
</logger>

<!-- logger2 -->
<logger name="com.example.demo.controller" level="debug">
	<appender-ref ref="STDOUT" />
</logger>

<!-- 指定最基础的日志输出级别为DEBUG，而且绑定了名为STDOUT的appender，表示将日志信息输出到控制台 -->
<root level="INFO">
    <appender-ref ref="STDOUT" />
</root>
复制代码

当存在多个<logger>时，会有父级子级的概念，日志的处理流程是先子级再父级，固然<root>是最高级别，怎样区分级别大小呢，根据name属性指定的包名来判断，包名级别越高则<logger>的级别越高，跟咱们定义<logger>的顺序无关。

上边咱们定义了logger1和logger2，很明显看出logger1是logger2的父级，以本例给出多个<logger>与<root>之间的执行流程图：

流程图看着一目了然，这里就再也不赘述，只是在实际的项目中咱们通常都不让<logger>输出日志，统一放在<root>节点中输出，因此通常不给<logger>节点添加<appender>，固然这个按实际须要能够灵活配置。

配置profile

profile即根据不一样的环境使用不一样的日志策略，这里举例开发和生产环境：

<!-- 开发环境输出到控制台 -->
<springProfile name="dev">
    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>
</springProfile>

<!-- 生产环境输出到文件 -->
<springProfile name="prod">
    <root level="INFO">
        <appender-ref ref="FILE_LOG" />
    </root>
</springProfile>
复制代码

能够看到咱们只须要在<root>节点的外边再套一层<springProfile>就能够了，而且指定name属性的值，在配置文件里边配置好以后,怎么启用，这里介绍两种方式：

1. 执行jar包时添加参数：

java -jar xxx.jar --spring.profiles.active=prod
复制代码

2. 在项目的application.properties配置文件中添加：

spring.profiles.active=prod
复制代码

整合

最后将全部的模块整合在一块儿造成一个完整的配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>    
    <!--定义一个将日志输出到控制台的appender，名称为STDOUT -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>[%contextName]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
        </encoder>
    </appender> 
    
    <!--定义一个将日志输出到文件的appender，名称为FILE_LOG -->
    <appender name="FILE_LOG" class="ch.qos.logback.core.FileAppender">  
        <file>D:/test.log</file>
        <append>true</append>  
        <encoder>  
            <pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
        </encoder>
    </appender>  
    
    <!-- 按时间滚动产生日志文件 -->
    <appender name="ROL-FILE-LOG" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
      <!--滚动策略，按照时间滚动 TimeBasedRollingPolicy-->
      <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
      	<fileNamePattern>D:/logs/test.%d{yyyy-MM-dd}.log</fileNamePattern>
      	<!-- 只保留近七天的日志 -->
      	<maxHistory>7</maxHistory>
      	<!-- 用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志 -->
      	<totalSizeCap>1GB</totalSizeCap>
      </rollingPolicy> 
      
      <encoder>
    	<pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
      </encoder>
    </appender>
    
    <!-- 按时间和文件大小滚动产生日志文件 -->
    <appender name="ROL-SIZE-FILE-LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>D:/logs/test.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <!-- 单个文件的最大内存 -->
            <maxFileSize>100MB</maxFileSize>
            <!-- 只保留近七天的日志 -->
            <maxHistory>7</maxHistory>
            <!-- 用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志 -->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        
        <encoder>
            <pattern>[Eran]%date [%thread %line] %level >> %msg >> %logger{10}%n</pattern>
        </encoder>
        
        <!-- 只处理INFO级别以及之上的日志 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">   
            <level>INFO</level>   
        </filter>
        
        <!-- 只处理INFO级别的日志 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">   
            <level>INFO</level>   
            <onMatch>ACCEPT</onMatch>   
            <onMismatch>DENY</onMismatch>   
        </filter>
    </appender>
    
    <!-- 异步写入日志 -->
    <appender name ="ASYNC" class= "ch.qos.logback.classic.AsyncAppender">  
        <!-- 不丢失日志.默认的,若是队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->  
        <discardingThreshold >0</discardingThreshold>  
        <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->  
        <queueSize>512</queueSize>  
        <!-- 添加附加的appender,最多只能添加一个 -->  
        <appender-ref ref ="FILE_LOG"/>
    </appender>
    
    
    <!-- 指定com.demo包下的日志打印级别为DEBUG，可是因为没有引用appender，因此该logger不会打印日志信息，日志信息向上传递 -->
    <logger name="com.example" level="DEBUG"></logger>
    <!-- 这里的logger根据须要本身灵活配置 ，我这里只是给出一个demo-->
    
    <!-- 指定开发环境基础的日志输出级别为DEBUG，而且绑定了名为STDOUT的appender，表示将日志信息输出到控制台 -->
    <springProfile name="dev">
        <root level="DEBUG">
            <appender-ref ref="STDOUT" />
        </root>
    </springProfile>
    
    <!-- 指定生产环境基础的日志输出级别为INFO，而且绑定了名为ASYNC的appender，表示将日志信息异步输出到文件 -->
    <springProfile name="prod">
        <root level="INFO">
            <appender-ref ref="ASYNC" />
        </root>
    </springProfile>
</configuration>
复制代码

代码中使用

终于到最后一步了，上边介绍了怎么配置logback-spring.xml配置文件，下面介绍怎么在项目中引入日志对象，以及怎么使用它输出日志，直接上代码：

package com.example.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class TestLog {

	private final static Logger log = LoggerFactory.getLogger(TestLog.class);
	
	
	@RequestMapping(value="/log",method=RequestMethod.GET)
	public void testLog() {
		log.trace("trace级别的日志");
		log.debug("debug级别日志");
		log.info("info级别日志");
		log.warn("warn级别的日志");
		log.error("error级别日志");
	}
}

复制代码

在每个须要使用日志对象的方法里边都要定义一次private final static Logger log = LoggerFactory.getLogger(xxx.class);其中xxx代指当前类名，若是以为这样很麻烦，也能够经过@Slf4j注解的方式注入，可是这种方式须要添加pom依赖而且须要安装lombok插件，这里就不概述了，须要了解的朋友能够本身google。

结语

有差很少一个月的时间没有更新了，春节期间休息没写，节后一直加班，天天到家都差很少十点多了，从上周开始天天抽点时间写完这一篇博客，自认为写的还算详细，一方面是本身的加深印象，由于这一类的配置文件在实际的项目中不会每次都去配置，就拷贝粘贴一直用的，不少概念也早就忘记了，借着此次机会本身再巩固下，分享出来但愿能对更多的人有点帮助吧。