爱生活，爱分享
爱生活，爱分享
GitHub GitHub GitHub
爱生活，爱分享

SpringBoot日志框架的选择及使用原理

haiten 2019-10-05 621浏览 0条评论
首页/正文
分享到: / / / /

原文链接：https://blog.csdn.net/yu0_zhang0/article/details/83898819

原文链接：https://blog.csdn.net/flysun3344/article/details/80555746

一、日志框架介绍

对于我们日常开发日志是经常使用的，当然以前的我们可能还傻傻的各种System.out.println("重要数据")在控制台输出各种重要数据呢，投入生产的时候再注释掉。到现在为止呢，已经有很多日志可供选择了，而市面上常见的日志框架有很多，比如：JCL、SLF4J、Jboss-logging、jUL、log4j、log4j2、logback等等，我们该如何选择呢？

市面上的日志框架：

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…

日志的抽象层 日志实现
JCL（Jakarta Commons Logging） jboss-logging SLF4j（Simple Logging Facade for Java） Log4j Logback JUL（java.util.logging） Log4j2

左边选一个抽象层、右边来选一个实现；类似与我们经常使用的JDBC一样，选择不同的数据库驱动。

下面我们先看看日志的抽象层：JCL大家应该很熟悉，Commons Logging，spring中常用的框架最后一次更新2014年；jboss-logging使用的场景太少了；就剩下SLF4j了也是我们springboot中使用的日志抽象层。

日志实现：大家应该看着都很熟悉把Log4j大家应该用的挺多的，Logback是Log4j的升级版本出至于同一个人开发的，考虑到以后的升级使用等问题，又写出了SLF4j的日志抽象层使用起来更加灵活。JUL（java.util.logging）一看就知道是java util包下的；Log4j2 咋一看像是Log4j的升级版本，其实并不是，它是apache下生产的日志框架。

SpringBoot 选用 SLF4j 和 Logback。

二、SLF4j 使用原理

1、使用 SLF4j

SL4j官网

在使用手册中给我们写了一个著名的 Hello world：

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

public class HelloWorld {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(HelloWorld.class);
        logger.info("Hello World");
    }
}

下面我们看一张图到底如何使用：

我们现在已经知道了 springboot 中使用的是 SLF4j 和 logback，但是如果我们想使用 log4j 该怎么办呢，从上面的图示中我们可以看出想要使用 log4j 我们肯定还是要使用 SLF4j 作为抽象层，但是中间给我们加入了一层适配层（Adaptation layer）然后使用 log4j 进行实现，那么我们需要导入图示中的 jar 包即可，其他的也是一样了。所以说，以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法； 每一个日志的实现框架都有自己的配置文件。使用 slf4j 以后，配置文件还是做成日志实现框架自己本身的配置文件；

2、可能存在的问题

现在开发中我么想使用slf4j+logback，但是对于一些遗留项目中例如Spring（commons-logging）、Hibernate（jboss-logging）…等等，如何去做到日志同一呢？

你想到的问题 SLF4j 能想不到吗？答案是可以的，我们看看下面的图就明白了。

官方地址

让系统中所有的日志都统一到 slf4j：

1、将系统中其他日志框架先排除出去；

2、用中间包来替换原有的日志框架；

3、我们导入 slf4j 其他的实现；

其实通过 idea 我们创建一个 springboot 项目也可以查看日志依赖（截取其中部分）：

SpringBoot 使用它来做日志功能：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
</dependency>

SpringBoot 能自动适配所有的日志，而且底层使用 slf4j+logback 的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；

例如:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

三、日志的默认配置

package cn.zhangyu;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.applet.AppletContext;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Springboot1ApplicationTests {
    // 记录器
    Log log = LogFactory.getLog(Springboot1ApplicationTests.class);

    @Test
    public void test(){
        // 日志的级别；
        // 由低到高 trace<debug<info<warn<error
        // 可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效
        log.trace("trace级别的日志");
        log.debug("debug级别的日志");
        // SpringBoot 默认给我们使用的是 info 级别的，没有指定级别的就用 SpringBoot 默认规定的级别
        log.info("info级别的日志");
        log.warn("warn级别的日志");
        log.error("error级别的日志");
    }
}

其他配置:

# 修改日志的级别，默认 root 是 info
# logging.level.root=trace

# 文件输出
# 默认情况下，Spring Boot 将日志输出到控制台，不会写到日志文件。
# 如果要编写除控制台输出之外的日志文件，则需在 application.properties 中设置 logging.path 或 logging.file 属性。
# 默认情况下，日志文件的大小达到 10MB 时会切分一次，产生新的日志文件，默认级别为：ERROR、WARN、INFO
# 注：二者不能同时使用，如若同时使用，则只有 logging.file 生效。
# logging.path，设置目录，会在该目录下创建 spring.log 文件，并写入日志内容，如：
logging.path=/var/log
# logging.file，设置文件，可以是绝对路径，也可以是相对路径。如：
logging.file=my.log

# 日志输出格式：
# %d：表示日期时间，
# %thread：表示线程名，
# %-5level：级别从左显示5个字符宽度
# %logger{50}：表示logger名字最长50个字符，否则按照句点分割。 
# %msg：日志消息，
# %n：是换行符
# 在控制台输出的日志的格式
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
# 指定文件中日志输出的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n

四、自定义日志配置

1、自定义日志配置

由于日志服务一般都在 ApplicationContext 创建前就初始化了，它并不是必须通过 Spring 的配置文件控制。因此通过系统属性和传统的Spring Boot外部配置文件依然可以很好的支持日志控制和管理。

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

Logback：logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy

Log4j：log4j-spring.properties, log4j-spring.xml, log4j.properties, log4j.xml

Log4j2：log4j2-spring.xml, log4j2.xml

JDK (Java Util Logging)：logging.properties

上面是默认的命名规则，并且放在src/main/resources下面即可。

如果你即想完全掌控日志配置，但又不想用 logback.xml 作为 Logback 配置的名字，可以通过 logging.config 属性指定自定义的名字：

logging.config=classpath:logging-config.xml

虽然一般并不需要改变配置文件的名字，但是如果你想针对不同运行时Profile使用不同的日志配置，这个功能会很有用。

SpringBoot 官方推荐优先使用带有 -spring 的文件名作为你的日志配置（如使用 logback-spring.xml，而不是 logback.xml），命名为logback-spring.xml 的日志配置文件，spring boot 可以为它添加一些 springboot 特有的配置项（下面会提到）。

下面我们来看看一个普通的 logback-spring.xml 例子：

2、根节点 configuration 包含的属性

scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。

scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。

debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

configuration 下面一共有2个属性，3个子节点。

3、属性一：设置上下文名称 contextName

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

<contextName>logback</contextName>

4、属性二：设置变量 property

用来定义变量值的标签， 有两个属性，name 和 value；其中 name 的值是变量的名称，value 的值时变量定义的值。通过 定义的值会被插入到 logger 上下文中。定义变量后，可以使 “${}” 来使用变量。

<property name="log.path" value="E:\\logback.log" />

5、子节点一：appender

appender 用来格式化日志输出节点，有俩个属性 name 和 class，class 用来指定哪种输出策略，常用就是控制台输出策略和文件输出策略。

（1）控制台输出 ConsoleAppender

encoder 表示对日志进行编码：

%d{HH: mm:ss.SSS}——日志输出时间

%thread——输出日志的进程名字，这在Web应用以及异步任务处理中很有用

%-5level——日志级别，并且使用5个字符靠左对齐

%logger{36}——日志输出者的名字

%msg——日志消息

%n——平台的换行符

ThresholdFilter 为系统定义的拦截器，例如我们用 ThresholdFilter 来过滤掉 ERROR 级别以下的日志不输出到文件中。如果不用记得注释掉，不然你控制台会发现没日志~

（2）输出到文件 RollingFileAppender

另一种常见的日志输出到文件，随着应用的运行时间越来越长，日志也会增长的越来越多，将他们输出到同一个文件并非一个好办法。RollingFileAppender 用于切分文件日志：

其中重要的是 rollingPolicy 的定义，上例中 logback.%d{yyyy-MM-dd}.log 定义了日志的切分方式——把每一天的日志归档到一个文件中，30 表示只保留最近30天的日志，以防止日志填满整个磁盘空间。同理，可以使用 %d{yyyy-MM-dd_HH-mm} 来定义精确到分的日志切分方式。1GB 用来指定日志文件的上限大小，例如设置为 1GB 的话，那么到了这个值，就会删除旧的日志。

6、子节点二：root

root 节点是必选节点，用来指定最基础的日志输出级别，只有一个 level 属性。

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

可以包含零个或多个 元素，标识这个 appender 将会添加到这个 loger。

7、子节点三：loger

用来设置某一个包或者具体的某一个类的日志打印级别、以及指定 。 仅有一个 name 属性，一个可选的 level 和一个可选的 addtivity 属性。

name:用来指定受此loger约束的某一个包或者具体的某一个类。

level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。如果未设置此属性，那么当前loger将会继承上级的级别。

addtivity:是否向上级loger传递打印信息。默认是true。

loger在实际使用的时候有两种情况，先来看一看代码中如何使用：

这是一个登录的判断的方法，我们引入日志，并且打印不同级别的日志，然后根据 logback-spring.xml 中的配置来看看打印了哪几种级别日志。

（1）第一种：带有 loger 的配置，不指定级别，不指定 appender

<logger name="com.dudu.controller"/>

将控制 controller 包下的所有类的日志的打印，但是并没用设置打印级别，所以继承他的上级 的日志级别“info”；

没有设置 addtivity，默认为 true，将此 loger 的打印信息向上级传递；

没有设置 appender，此 loger 本身不打印任何信息；

将 root 的打印级别设置为 “info”，指定了名字为 “console” 的 appender。

当执行 com.dudu.controller.LearnController 类的 login 方法时，LearnController 在包 com.dudu.controller 中，所以首先执行 ，将级别为 “info” 及大于 “info” 的日志信息传递给 root，本身并不打印；root 接到下级传递的信息，交给已经配置好的名为 “console” 的 appender 处理，“console”appender 将信息打印到控制台；

打印结果如下：

（2）第二种：带有多个loger的配置，指定级别，指定appender

控制 com.dudu.controller.LearnController 类的日志打印，打印级别为 “WARN”；

additivity 属性为 false，表示此 loger 的打印信息不再向上级传递；

指定了名字为 “console” 的 appender，这时候执行 com.dudu.controller.LearnController 类的 login 方法时，先执行 ,将级别为 “WARN” 及大于 “WARN” 的日志信息交给此 loger 指定的名为 “console” 的 appender 处理，在控制台中打出日志，不再向上级 root 传递打印信息。

打印结果如下：

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

五、多环境日志输出

据不同环境（prod:生产环境，test:测试环境，dev:开发环境）来定义不同的日志输出，在 logback-spring.xml 中使用 springProfile 节点来定义，方法如下：

文件名称不是 logback.xml，想使用 spring 扩展 profile 支持，要以 logback-spring.xml 命名：

可以启动服务的时候指定 profile （如不指定使用默认），如指定 prod 的方式为：

java -jar xxx.jar --spring.profiles.active=prod

六、自定义配置模板

平时使用的时候推荐用自定义 logback-spring.xml 来配置，代码中使用日志也很简单，类里面添加 private Logger logger = LoggerFactory.getLogger(this.getClass()); 即可。

例子：

<?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="G:/logs/pmp" />
 
    <!--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>info</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}/web_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}/web-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}/web_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}/web-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}/web_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}/web-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}/web_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}/web-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. 最终的策略 -->
    <!-- 4.1 开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="com.sdcm.pmp" level="debug"/>
    </springProfile>
 
    <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>
 
    <!-- 4.2 生产环境:输出到文档
    <springProfile name="pro">
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile> -->
 
</configuration>

七、切换日志框架

可以按照idea中maven的关系图，进行相关的切换；

slf4j+log4j的方式；（不推荐，只是教大家如何切换）

1、修改为 log4j（pom.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>cn.zhangyu</groupId>
	<artifactId>springboot-1</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot-1</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>log4j-to-slf4j</artifactId>
					<groupId>org.apache.logging.log4j</groupId>
				</exclusion>
				<exclusion>
					<artifactId>logback-classic</artifactId>
					<groupId>ch.qos.logback</groupId>
				</exclusion>
			</exclusions>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
	
</project>

2、修改为 log4j2（pom.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>cn.zhangyu</groupId>
	<artifactId>springboot-1</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot-1</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>spring-boot-starter-logging</artifactId>
					<groupId>org.springframework.boot</groupId>
				</exclusion>
			</exclusions>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-log4j2</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

3、在 resource 目录下添加 log4j.properties：

### set log levels ###
log4j.rootLogger = debug ,  stdout ,  D ,  E

### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =  %d{ABSOLUTE} ===== %5p %c{ 1 }:%L - %m%n

#### 输出到日志文件 ###
#log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
#log4j.appender.D.File = logs/log.log
#log4j.appender.D.Append = true
#log4j.appender.D.Threshold = DEBUG ## 输出DEBUG级别以上的日志
#log4j.appender.D.layout = org.apache.log4j.PatternLayout
#log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

#### 保存异常信息到单独文件 ###
#log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
#log4j.appender.D.File = logs/error.log ## 异常日志文件名
#log4j.appender.D.Append = true
#log4j.appender.D.Threshold = ERROR ## 只输出ERROR级别以上的日志!!!
#log4j.appender.D.layout = org.apache.log4j.PatternLayout
#log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
最后修改：2019-10-05 13:21:57 © 著作权归作者所有
如果觉得我的文章对你有用，请随意赞赏
扫一扫支付
上一篇

发表评论

说点什么吧~

评论列表

还没有人评论哦~赶快抢占沙发吧~

热门文章

博客信息

  • 文章数目 115
  • 标签数目 22
  • 运行天数
  • 最后活动

广告

标签云

linux docker java spingboot nginx vue 服务器 加密 MySQL CSS

文章目录

     粤ICP备19153515号      粤公网安备 44080302000146号