SpringBoot日志

最新推荐文章于 2022-05-29 16:51:50 发布

唯♧

最新推荐文章于 2022-05-29 16:51:50 发布

阅读量150

点赞数

分类专栏： spring-boot

原文链接：https://blog.csdn.net/ztchun/article/details/79804583

版权

spring-boot 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1、日志框架比较（slf4j、log4j、logback、log4j2）

Spring Boot在所有内部日志中使用Commons Logging，但是默认配置也提供了对常用日志的支持，如：Java Util Logging，Log4J, Log4J2和Logback。每种Logger都可以通过配置使用控制台或者文件输出日志内容。

1.1 slf4j

slf4j是对所有日志框架制定的一种规范、标准、接口，并不是一个框架的具体的实现，因为接口并不能独立使用，需要和具体的日志框架实现配合使用（如log4j、logback）

为什么需要日志接口，直接使用具体的实现不就行了吗？

接口用于定制规范，可以有多个实现，使用时是面向接口的（导入的包都是slf4j的包而不是具体某个日志框架中的包），即直接和接口交互，不直接使用实现，所以可以任意的更换实现而不用更改代码中的日志相关代码。

比如：slf4j定义了一套日志接口，项目中使用的日志框架是logback，开发中调用的所有接口都是slf4j的，不直接使用logback，调用是自己的工程调用slf4j的接口，slf4j的接口去调用logback的实现，可以看到整个过程应用程序并没有直接使用logback，当项目需要更换更加优秀的日志框架时（如log4j2）只需要引入Log4j2的jar和Log4j2对应的配置文件即可，完全不用更改Java代码中的日志相关的代码logger.info(“xxx”)，也不用修改日志相关的类的导入的包（import org.slf4j.Logger;
import org.slf4j.LoggerFactory;）

使用日志接口便于更换为其他日志框架。
log4j、logback、log4j2都是一种日志具体实现框架，所以既可以单独使用也可以结合slf4j一起搭配使用）

1.2 log4j

log4j是apache实现的一个开源日志组件。通过使用log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1.3 logback

logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架，是slf4j的原生实现，所以logback与slf4j的结合最好。]

Logback，一个“可靠、通用、快速而又灵活的Java日志框架”。logback当前分成三个模块：logback-core，logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统如log4j或JDK Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。
1. logback-core: Joran, Status, context, pattern parsing
2. logback-classic: developer logging
3. logback-access: The log generated when a user accesses a web-page on a web server. Integrates seamlessly with Jetty and Tomcat.

选择logback的理由：
1. logback比log4j要快大约10倍，而且消耗更少的内存。
2. logback-classic模块直接实现了SLF4J的接口，所以我们迁移到logback几乎是零开销的。
3. logback不仅支持xml格式的配置文件，还支持groovy格式的配置文件。相比之下，Groovy风格的配置文件更加直观，简洁。
4. logback-classic能够检测到配置文件的更新，并且自动重新加载配置文件。
5. logback能够优雅的从I/O异常中恢复，从而我们不用重新启动应用程序来恢复logger。
6. logback能够根据配置文件中设置的上限值，自动删除旧的日志文件。
7. logback能够自动压缩日志文件。
8. logback能够在配置文件中加入条件判断（if-then-else)。可以避免不同的开发环境（dev、test、uat…）的配置文件的重复。
9. logback带来更多的filter。
10. logback的stack trace中会包含详细的包信息。
11. logback-access和Jetty、Tomcat集成提供了功能强大的HTTP-access日志。
配置文件：需要在项目的src目录下建立一个logback.xml。
注：（1）logback首先会试着查找logback.groovy文件；
（2）当没有找到时，继续试着查找logback-test.xml文件；
（3）当没有找到时，继续试着查找logback.xml文件；
（4）如果仍然没有找到，则使用默认配置（打印到控制台）。

1.4 log4j2

Log4j2是log4j 1.x和logback的改进版，据说采用了一些新技术（无锁异步、等等），使得日志的吞吐量、性能比log4j 1.x提高10倍，并解决了一些死锁的bug，而且配置更加简单灵活。

Spring Boot1.4以及之后的版本已经不支持log4j，log4j也很久没有更新了，现在已经有很多其他的日志框架对Log4j进行了改良，比如说SLF4J、Logback等。而且Log4j 2在各个方面都与Logback非常相似，那么为什么我们还需要Log4j 2呢？
1. 插件式结构。Log4j 2支持插件式结构。我们可以根据自己的需要自行扩展Log4j 2. 我们可以实现自己的appender、logger、filter。
2. 配置文件优化。在配置文件中可以引用属性，还可以直接替代或传递到组件。而且支持json格式的配置文件。不像其他的日志框架，它在重新配置的时候不会丢失之前的日志文件。
3. Java 5的并发性。Log4j 2利用Java 5中的并发特性支持，尽可能地执行最低层次的加锁。解决了在log4j 1.x中存留的死锁的问题。
4. 异步logger。Log4j 2是基于LMAX Disruptor库的。在多线程的场景下，和已有的日志框架相比，异步的logger拥有10倍左右的效率提升。

2、日志框架应用

2.1 slf4j

什么时候使用SLF4J比较合适呢？
如果你开发的是类库或者嵌入式组件，那么就应该考虑采用SLF4J，因为不可能影响最终用户选择哪种日志系统。在另一方面，如果是一个简单或者独立的应用，确定只有一种日志系统，那么就没有使用SLF4J的必要。假设你打算将你使用log4j的产品卖给要求使用JDK 1.8 Logging的用户时，面对成千上万的log4j调用的修改，相信这绝对不是一件轻松的事情。但是如果开始便使用SLF4J，那么这种转换将是非常轻松的事情。

首先引入slf4j包：
slf4j-simple是slf4j的一种日志系统实现，目前最新版本是1.7.7

<dependency>   
 <groupId>org.slf4j</groupId>   
 <artifactId>slf4j-simple</artifactId>   
 <version>1.7.7</version>
</dependency>

假如后期改变log实现系统，所有调用log4j的代码都需要进行修改，假如一开始都使用slf4j.Logger，后期将无需修改代码，通过修改配置文件即可切换日志系统。

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

private static Logger logger = LoggerFactory.getLogger(TestLog4jApplication.class);1234

2.2 log4j

log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、数据库等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
Log4j有7种不同的log级别，按照等级从低到高依次为：TRACE、DEBUG、INFO、WARN、ERROR、FATAL、OFF。如果配置为OFF级别，表示关闭log。
Log4j支持两种格式的配置文件：properties和xml。包含三个主要的组件：Logger、appender、Layout。

(1)控制台输出

通过如下配置，设定root日志的输出级别为INFO，appender为控制台输出stdout

# LOG4J配置
log4j.rootLogger=INFO,stdout
# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:123456

(2)输出到文件

在开发环境，我们只是输出到控制台没有问题，但是到了生产或测试环境，或许持久化日志内容，方便追溯问题原因。可以通过添加如下的appender内容，按天输出到不同的文件中去，同时还需要为log4j.rootLogger添加名为file的appender，这样root日志就可以输出到logs/springboot.log文件中了。输出到文件和输出到控制台是可以并行存在的。

# LOG4J配置
log4j.rootLogger=INFO,stdout,file
# 日志输出到文件
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.file=logs/springboot.log
log4j.appender.file.DatePattern='.'yyyy-MM-dd
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n12345678

(3)分类输出

当我们日志量较多的时候，查找问题会非常困难，常用的手段就是对日志进行分类，比如：
可以按不同package进行输出。通过定义输出到logs/my.log的appender，并对com.test包下的日志级别设定为DEBUG级别、appender设置为输出到logs/my.log的名为testlog的appender。

# com.test包下的日志配置
log4j.logger.com.test=DEBUG, testlog
# com.test下的日志输出
log4j.appender.testlog=org.apache.log4j.DailyRollingFileAppender
log4j.appender.testlog.file=logs/my.log
log4j.appender.testlog.DatePattern='.'yyyy-MM-dd
log4j.appender.testlog.layout=org.apache.log4j.PatternLayout
log4j.appender.testlog.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L ---- %m%n12345678

可以对不同级别进行分类，比如对ERROR级别输出到特定的日志文件中，具体配置可以如下：

# LOG4J配置
log4j.rootCategory=INFO, stdout,errorfile
log4j.logger.error=errorfile

# error日志输出
log4j.appender.errorfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorfile.file=logs/error.log
log4j.appender.errorfile.DatePattern='.'yyyy-MM-dd
log4j.appender.errorfile.Threshold = ERROR
log4j.appender.errorfile.layout=org.apache.log4j.PatternLayout
log4j.appender.errorfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n %5p %c{1}:%L - %m%n1234567891011

(4)输出到数据库
将日志文件输出到数据库配置：

# LOG4J配置
log4j.rootCategory=INFO,stdout,jdbc

# 数据库输出
log4j.appender.jdbc=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.jdbc.driver=com.mysql.jdbc.Driver
log4j.appender.jdbc.URL=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true
log4j.appender.jdbc.user=root
log4j.appender.jdbc.password=root
log4j.appender.jdbc.sql=insert into log_icecoldmonitor(level,category,thread,time,location,note) values('%p','%c','%t','%d{yyyy-MM-dd HH:mm:ss:SSS}','%l','%m')12345678910

引入数据库驱动:

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>1234

创建表：

CREATE TABLE `log_icecoldmonitor` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`level` varchar(255) NOT NULL DEFAULT '' COMMENT '优先级',
`category` varchar(255) NOT NULL DEFAULT '' COMMENT '类目',
`thread` varchar(255) NOT NULL DEFAULT '' COMMENT '进程',
`time` varchar(30) NOT NULL DEFAULT '' COMMENT '时间',
`location` varchar(255) NOT NULL DEFAULT '' COMMENT '位置',
`note` text COMMENT '日志信息',
PRIMARY KEY (`Id`)
)12345678910

这样就可以保存到日志到数据库了，可能会出现如下异常信息：
Java连接Mysql数据库警告：Establishing SSL connection
原因是MySQL在高版本需要指明是否进行SSL连接。解决方案如下：
在mysql连接字符串url中加入ssl=true或者false即可，如下所示。
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true

2.2.1 log4j在Spring Boot上的应用

（1）引入log4j依赖
在创建Spring Boot工程时，我们引入了spring-boot-starter，其中包含了spring-boot-starter-logging，该依赖内容就是Spring Boot默认的日志框架Logback，所以我们在引入log4j之前，需要先排除该包的依赖，再引入log4j的依赖。

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

值得注意的是，spring boot 1.3版本支持log4j，在spring boot 1.4的版本中，就需要使用log4j2，否则会出现如下错误：Project build error: ‘dependencies.dependency.version’ for org.springframework.boot:spring-boot-starter-log4j:jar is missing.

（2）配置log4j-spring.properties
在引入了log4j依赖之后，只需要在src/main/resources目录下加入log4j.properties（或log4j-spring.properties）配置文件，就可以开始对应用的日志进行配置使用。测试配置内容如下：

# DEBUG INFO WARN ERROR FATAL
log4j.rootLogger = info,stdout,errorlogfile

log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold = info
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n
log4j.appender.stdout.ImmediateFlush = true

log4j.appender.errorlogfile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorlogfile.Threshold = INFO
log4j.appender.errorlogfile.layout = org.apache.log4j.PatternLayout
log4j.appender.errorlogfile.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n
log4j.appender.errorlogfile.File = ../logs/testlog4j.log
log4j.appender.errorlogfile.Append = true
log4j.appender.errorlogfile.ImmediateFlush = true12345678910111213141516

（3）配置application.properties指定log配置文件

logging.config= classpath:log4j.properties1

（4）在启动类中进行测试

private static Logger logger = Logger.getLogger(TestLog4jApplication.class);

public static void main(String[] args) {
logger.info("log4j----------------\n");
SpringApplication.run(TestLog4jApplication.class, args);
}123456

运行项目，即可看到控制台打印出的日志信息，同时在项目同级目录下的logs/testlog4j.log中也会打印出比较详尽的日志信息。

2.3 log4j2

<dependency>
<groupId>com.lmax</groupId>
<artifactId>disruptor</artifactId>
<version>3.3.6</version>
</dependency>123456

异步日志分为两种：
a.全异步模式
这种异步日志方式，不需要修改修改原理的配置文件，Logger仍然使用 and
只需要在主程序代码开头，加一句系统属性的代码：

System.setProperty("Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"); 1

b.异步和非异步混合输出模式
在配置文件中Logger使用 or

<asyncRoot level="trace" includeLocation="true">
<appender-ref ref="Console" />
</asyncRoot>
</loggers>1234567891011

2.3.1 log4j2在Spring boot上的应用

（1）引入log4j2依赖
在创建Spring Boot工程时，我们引入了spring-boot-starter，其中包含了spring-boot-starter-logging，该依赖内容就是Spring Boot默认的日志框架Logback，所以我们在引入log4j2之前，需要先排除该包的依赖，再引入log4j2的依赖。

（2）log4j2.xml配置
有一点需要注意的是，假如想要在application.properties中指定日志文件存放路径或日志文件名，在log4j2.xml中使用LOGPATH或者LOGPATH或者{LOG_FILE}来引用，是无法获取到的（在logback中可以尽情使用）。log4j2支持xml、json、yaml等格式的配置文件。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Properties>
<property name="LOG_PATH">../logs/</property>
<property name="LOG_FILE">testlog4j2</property>
</Properties>
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout>
<pattern>%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n</pattern>
</PatternLayout>
</Console>
<RollingFile name="errorlogfile" fileName="${LOG_PATH}/${LOG_FILE}.log"
filePattern="${LOG_PATH}/$${date:yyyy-MM}/${LOG_FILE}-%d{yyyy-MM-dd HH-mm}-%i.log">
<PatternLayout>
<pattern>%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n</pattern>
</PatternLayout>
<Policies>
<TimeBasedTriggeringPolicy />
<SizeBasedTriggeringPolicy size="50 MB" />
</Policies>
<DefaultRolloverStrategy max="20" />
</RollingFile>
</Appenders>
<Loggers>
<root level="info">
<AppenderRef ref="Console"/>
<AppenderRef ref="errorlogfile" />
</root>
</Loggers>
</Configuration> 12345678910111213141516171819202122232425262728293031

（3）application.properties配置
指定log配置文件位置

logging.config= classpath:log4j2.xml1

（4）在启动类中进行测试

private static Logger logger = LogManager.getLogger(TestLog4j2Application.class);

public static void main(String[] args) {
logger.error("log4j2----------------\n");
SpringApplication.run(TestLog4j2Application.class, args);
}123456

运行项目，即可看到控制台打印出的日志信息，同时在项目同级目录下的logs/testlog4j2.log中也会打印出比较详尽的日志信息。

2.4 Logback

logback的一些配置介绍：
* 控制台输出
在Spring Boot中默认配置了ERROR、WARN和INFO级别的日志输出到控制台。我们可以通过两种方式切换至DEBUG级别：
在运行命令后加入–debug标志，如：$ java -jar test.jar –debug
在application.properties中配置debug=true，该属性置为true的时候，核心Logger（包含嵌入式容器、hibernate、spring）会输出更多内容，但是你自己应用的日志并不会输出为DEBUG级别。

多彩输出
如果你的终端支持ANSI，设置彩色输出会让日志更具可读性。通过在application.properties中设置spring.output.ansi.enabled参数来支持。
NEVER：禁用ANSI-colored输出（默认项）
DETECT：会检查终端是否支持ANSI，是的话就采用彩色输出（推荐项）
ALWAYS：总是使用ANSI-colored格式输出，若终端不支持的时候，会有很多干扰信息，不推荐使用

文件输出
Spring Boot默认配置只会输出到控制台，并不会记录到文件中，但是我们通常生产环境使用时都需要以文件方式记录。
若要增加文件输出，需要在application.properties中配置logging.file或logging.path属性。
logging.file，设置文件，可以是绝对路径，也可以是相对路径。如：logging.file=my.log
logging.path，设置目录，会在该目录下创建spring.log文件，并写入日志内容，如：logging.path=../logs
日志文件会在10Mb大小的时候被截断，产生新的日志文件，默认级别为：ERROR、WARN、INFO

级别控制
在Spring Boot中只需要在application.properties中进行配置完成日志记录的级别控制。
配置格式：logging.level.*=LEVEL
logging.level：日志级别控制前缀，*为包名或Logger名
LEVEL：选项TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF
举例：
logging.level.com.test=DEBUG：com.test包下所有class以DEBUG级别输出
logging.level.root=WARN：root日志以WARN级别输出

自定义输出格式
在Spring Boot中可以通过在application.properties配置如下参数控制输出格式：
logging.pattern.console：定义输出到控制台的样式（不支持JDK Logger）
logging.pattern.file：定义输出到文件的样式（不支持JDK Logger）

2.4.1 logback在Spring Boot中的应用

logback是Spring Boot默认的日志系统，假如对日志没有特殊要求，可以完全零配置使用 SLF4J（Simple Logging Facade For Java）的logback来输出日志。

package com.jianeye.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

SpringBootApplication
public class TestApplication {

private static Logger logger = LoggerFactory.getLogger(TestApplication.class);

public static void main(String[] args) {
logger.warn("logback --------------------------------\n");
SpringApplication.run(TestApplication.class, args);
logger.info("default log system *************************\n");
}
}123456789101112131415161718

Spring Boot也支持自定义日志配置，有以下两种方式。
1. 在 src/main/resources 下面创建logback.xml （根据不同环境来定义不同的日志输出，那么取名为logback-spring.xml 即可）文件，并按需求进行配置。

logback-spring.xml 文件：

<?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="staging">
<logger name="org.springboot.sample" level="INFO" />
</springProfile>
</configuration>1234567891011121314

（2）使用最简单的方法，在 application 配置文件中配置。

logging:
config: classpath:logback-spring.xml
file: cuckoo3
path: /cuckoo3-log/logs
level:
com.jianeye.cuckoo3.webside: DEBU123456

需要注意几点：
1. 这里若不配置具体的包的日志级别，日志文件信息将为空
2. 若只配置logging.path，那么将会在E:\logs文件夹生成一个日志文件为spring.log
3. 若只配置logging.file，那将会在项目的当前路径下生成一个demo.log日志文件
4. logging.path和logging.file同时配置，不会有在这个路径有E:\logs\demo.log日志生成，logging.path和logging.file不会进行叠加
5. logging.path和logging.file的value都可以是相对路径或者绝对路径

3、三种日志实现的性能比较

log4j2的异步模式表现了绝对的性能优势，优势主要得益于Disruptor框架的使用
请查看详细性能分析：https://my.oschina.net/OutOfMemory/blog/789267
————————————————
版权声明：本文为CSDN博主「chun_soft」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ztchun/article/details/79804583