spingboot默认日志系统LogBack、Log4j和slf4j使用详解

柯柯不会Java

已于 2023-05-09 18:53:11 修改

阅读量9.4k

点赞数 3

分类专栏： java log 文章标签： java

于 2022-04-02 16:32:47 首次发布

本文链接：https://blog.csdn.net/qq_46601365/article/details/123923553

版权

java 同时被 2 个专栏收录

33 篇文章 0 订阅

订阅专栏

log

1 篇文章 0 订阅

订阅专栏

spingboot默认日志系统LogBack、Log4j和slf4j使用详解

spingboot默认日志系统LogBack

依赖引入

Spring Boot默认使用LogBack日志系统，如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。

如果要使用LogBack，原则上是需要添加dependency依赖的

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

但是因为新建的Spring Boot项目一般都会引用spring-boot-starter或者spring-boot-starter-web，而这两个起步依赖中都已经包含了对于spring-boot-starter-logging的依赖，所以，无需额外添加依赖。

如何在项目中打印日志

新建一个配置类LogConfig，注入一个Bean，并在方法中打印日志

package com.jackie.springbootdemo.config;

import com.jackie.springbootdemo.model.Person;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration 
public class LogConfig {
    private static final Logger LOG = LoggerFactory.getLogger(LogConfig.class);

    @Bean
    public Person logMethod() {
        LOG.info("==========print log==========");
        return new Person();
    }
}

Spring Boot默认的日志级别为INFO，这里打印的是INFO级别的日志所以可以显示。

很多开发者在日常写private static final Logger LOG = LoggerFactory.getLogger(LogConfig.class);总觉得后面的LogConfig.class可有可无，因为随便写个其他类也不会报错，但是准确编写class信息能够提供快速定位日志的效率。

我们看到打印的日志内容左侧就是对应的类名称，这个是通过private static final Logger LOG = LoggerFactory.getLogger(LogConfig.class);实现的。

如果将LogConfig.class换成xxx.class，输出日志就会显示对应的xxx类名。这样声明的好处就是方便定位日志。

如何将日志信息存储到文件

在本机环境，我们习惯在控制台看日志，但是线上我们还是要通过将日志信息保存到日志文件中，查询日志文件即可。

那么应该如何配置才能将日志信息保存到文件呢？

在我们创建的springboot项目中，resources目录下有个application.yml文件添加如下配置

logging:
  # 和file二写一，同时配置不能全部生效
  path: 
  file: springbootdemo.log

logging.path

该属性用来配置日志文件的路径

logging.file

该属性用来配置日志文件名，如果该属性不配置，默认文件名为spring.log

如何设置日志级别

日志级别总共有 ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF ，且级别是逐渐提供，如果日志级别设置为INFO，则意味TRACE和DEBUG级别的日志都看不到。ALL 最低等级的，用于打开所有日志记录。OFF 最高等级的，用于关闭所有日志记录。

上例中我们打印了一个INFO级别的日志，因为Spring Boot默认级别就是INFO，如果我们改为WARN，是否还能看到这行日志信息。

logging.level

该属性用于配置日志级别。

在applicaition.yml中添加

logging:
  level:
    root: warn

这里是用的root级别，即项目的所有日志，我们也可以使用package级别，即指定包下使用相应的日志级别，这里我们可以改动root还是INFO级别，将指定包下的日志级别设置为其它级别

logging:
  level:
    root: info
    com.fastech.framework: warn
    com.fastech.framework.mqtt.service: debug
    org.apache.hadoop.util.Shell: OFF
    org.mongodb.driver.*: OFF
    org.apache.zookeeper.ZooKeeper: OFF

如何定制自己的日志格式

在application.yml中添加

logging:
  pattern:
    console: "%clr(%d{MM-dd HH:mm:ss.SSS}){faint} %clr(${server.name} ${LOG_LEVEL_PATTERN}) %clr(${PID:- }){magenta} %clr([%5.5t]){faint} %clr(%-20.20logger{39} %5.5line){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:%wEx}}"
    file: "%clr(%d{MM-dd HH:mm:ss.SSS}){faint} %clr(${server.name} ${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr([%5.5t]){faint} %clr(%-20.20{39} %5.5line){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:%wEx}}"

logging.pattern.console

该属性用于定制日志控制台输出格式。

logging.pattern.file

该属性用于定制日志文件输出格式。

上述配置的编码中，对应符号的含义如下

%d{HH:mm:ss.SSS}——日志输出时间
%thread——输出日志的进程名字，这在Web应用以及异步任务处理中很有用
%-5level——日志级别，并且使用5个字符靠左对齐
%logger- ——日志输出者的名字
%msg——日志消息
%n——平台的换行符

Log4j的使用

依赖引入

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

需要注意的是
Spring Boot 只有1.3.x和1.3.x以下版本才支持log4j的日志配置，1.3.x以上版本只支持log4j2。

区别在于需要引入的包

<artifactId>spring-boot-starter-log4j</artifactId>

和

<artifactId>spring-boot-starter-log4j2</artifactId>

Spring Boot 1.3.x和1.3.x以下版本的pom文件如下:

<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>

Spring Boot 1.3.x以上版本的pom文件如下:

<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-log4j2</artifactId>
</dependency>

如果找不到

<artifactId>spring-boot-starter</artifactId>

则查找

<artifactId>spring-boot-starter-web</artifactId>

因为log4j2对于log4j来说有很多变动，如果不喜欢用log4j2，1.3.x版本以上的spring boot框架也可以引入以下两个包使用log4j。

<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

配置log4j2.xml

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

注意：Spring Boot官方推荐优先使用带有-spring的文件名作为你的日志配置（如使用log4j-spring.properties，而不是log4j.properties，不过取名为log4j.properties也是没有问题的）

但是 log4j2版本则需要注意，只能使用非properties文件进行配置，xml或者yml，或者Json。

更多配置文件格式相关参考:https://logging.apache.org/log4j/2.x/manual/configuration.html

在application.properties中指定特定配置文件

logging.config=classpath:log4j2.xml

配置输出日志到控制台

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

LOG4J根配置

log4j.rootCategory=INFO, stdout

其中INFO是日志输出级别，共有5级：

FATAL 0
ERROR 3
WARN 4
INFO 6
DEBUG 7

控制台输出log4j-spring.properties格式配置

log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

对应的xml格式如下：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
  <Appenders>
<Console name="Console" target="SYSTEM_OUT">
  <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n"/>
</Console>
  </Appenders>
  <Loggers>
<Root level="info">
  <AppenderRef ref="Console"/>
</Root>
  </Loggers>
</Configuration>

Layout：日志输出格式，Log4j提供的layout有以下几种：

org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

配置输出日志到文件log4j-spring.properties格式配置

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

LOG4J配置

log4j.rootCategory=INFO, stdout, file

输出到文件

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.file=logs/all.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%n

Appender 为日志输出目的地，Log4j提供的appender有以下几种：

org.apache.log4j.ConsoleAppender（控制台），
org.apache.log4j.FileAppender（文件），
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

配置日志分类输出log4j-spring.properties格式配置
当我们日志量较多的时候，查找问题会非常困难，常用的手段就是对日志进行分类，比如：

例子一:

可以按不同package进行输出。通过定义输出到logs/my.log的appender，并对com.test包下的日志级别设定为DEBUG级别、appender设置为输出到logs/my.log的名为test的appender。

com.test包下的日志配置

log4j.category.com.test=DEBUG, testfile

com.test下的日志输出

log4j.appender.testfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.testfile.file=logs/my.log
log4j.appender.testfile.DatePattern='.'yyyy-MM-dd
log4j.appender.testfile.layout=org.apache.log4j.PatternLayout
log4j.appender.testfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L ---- %m%n

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

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

例子二:

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.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.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = logs/error.log ## 异常日志文件名
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR ## 只输出ERROR级别以上的日志!!!
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

配置日志输出到数据库log4j-spring.properties格式配置

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

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')

引入数据库驱动：

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

创建表：

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`)
)

这样就可以保存到日志到数据库了，可能会出现如下异常信息：Java连接Mysql数据库警告：Establishing SSL connection

原因是MySQL在高版本需要指明是否进行SSL连接。解决方案如下：在mysql连接字符串url中加入ssl=true或者false即可，如下所示。

url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true

测试代码

package com.imooc.controller;

import org.apache.logging.log4j.Logger;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import org.apache.logging.log4j.LogManager;

/**
 * @ClassName: Log4jController
 * @Description:
 * @Author: keke
 * @Date: 2022/4/2
 */
@ApiIgnore //该controller就不会在api文档中出现
@RestController //默认所有请求返回的都是json对象
public class Log4jController {

    final static Logger logger = LogManager.getLogger(Log4jController.class);

    @GetMapping("/hello")
    public Object hello() {

        logger.debug("debug: hello~");
        logger.info("info: hello~"); 
        logger.warn("warn: hello~");
        logger.error("error: hello~");

        return "Hello World~";
    }

}

slf4j的使用

依赖引入

<!--排除springboot自带的logging日志jar包-->
<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>

<!--引入slf4j日志依赖 抽象层 与 实现层-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.21</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.21</version>
</dependency>

log4j.properties配置

log4j.rootLogger=DEBUG,stdout,file
log4j.additivity.org.apache=true

# 控制台输出
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=%-5p %c{1}:%L - %m%n

# 文件输出
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.DatePattern='.'yyyy-MM-dd-HH-mm
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
log4j.appender.file.Threshold=INFO
log4j.appender.file.append=true
# 输出路径
log4j.appender.file.File=/IdeaProjects/JGS/workspaces/logs/foodie-api/imooc.log

测试代码

package com.imooc.controller;

import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

@ApiIgnore //该controller就不会在api文档中出现
@RestController //默认所有请求返回的都是json对象
public class HelloController {

    final static Logger logger = LoggerFactory.getLogger(HelloController.class);

    @GetMapping("/hello")
    public Object hello() {

        logger.debug("debug: hello~");
        logger.info("info: hello~"); //会打印info及以上日志级别 因为log4j.properties里设置了log4j.appender.stdout.threshold=INFO
        logger.warn("warn: hello~");
        logger.error("error: hello~");

        return "Hello World~";
    }
  
}

将日志文件写入数据库

在上面项目的基础上加上连接数据库的jar包

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.18</version>
</dependency>

在log4j.properties的配置文件中添加将日志文件插入数据库的配置,同时需要将第一行配置文件改为：

# 日记级别(单个级别) 文件/控制台
log4j.rootLogger=DEBUG, stdout,file,datasource

下面是配置将日志信息插入数据库

配置输出目标为数据库（假如要将日志在控制台输出，配置为log4j.appender. stdout =org.apache.log4j.ConsoleAppender；将日志写入文件，配置为log4j.appender.logfile=org.apache.log4j.DailyRollingFileAppender#这样的配置在许多地方都要有，需要可查有关资料）,当然你也可以自己扩展org.apache.log4j.jdbc.JDBCAppender这个类，只需要在这里配置就可以了例如我们配置我自己扩展的MyJDBCAppender，配置为#log4j.appender.db=com.neam.commons.MyJDBCAppender

log4j.appender.datasource=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.datasource.layout=org.apache.log4j.PatternLayout
log4j.appender.datasource.driver=com.mysql.jdbc.Driver
#定义什么级别的错误将写入到数据库中
log4j.appender.datasource.BufferSize=1
#设置缓存大小，就是当有1条日志信息是才忘数据库插一次，我设置的数据库名和表名均为user
log4j.appender.datasource.URL=jdbc\:mysql\://localhost\:3306/user?characterEncoding\=UTF8&zeroDateTimeBehavior\=convertToNull
log4j.appender.datasource.user=root
log4j.appender.datasource.password=root
log4j.appender.datasource.sql=insert into user (class,method,create_time,log_level,log_line,msg) values ('%C','%M','%d{yyyy-MM-dd HH:mm:ss}','%p','%l','%m')

数据库设计

对比总结

1.SLF4J(Simple logging Facade for Java)

SLF4J意思为简单日志门面，它是把不同的日志系统的实现进行了具体的抽象化，只提供了统一的日志使用接口，使用时只需要按照其提供的接口方法进行调用即可，由于它只是一个接口，并不是一个具体的可以直接单独使用的日志框架，所以最终日志的格式、记录级别、输出方式等都要通过接口绑定的具体的日志系统来实现，这些具体的日志系统就有log4j,logback,java.util.logging等，它们才实现了具体的日志系统的功能。

如何使用SLF4J?

既然SLF4J只是一个接口，那么实际使用时必须要结合具体的日志系统来使用，我们首先来看SLF4J和各个具体的日志系统进行绑定时的框架原理图：

其实slf4j原理很简单，他只提供一个核心slf4j api(就是slf4j-api.jar包)，这个包只有日志的接口，并没有实现，所以如果要使用就得再给它提供一个实现了些接口的日志包，比如：log4j,common logging,jdk log日志实现包等，但是这些日志实现又不能通过接口直接调用，实现上他们根本就和slf4j-api不一致，因此slf4j又增加了一层来转换各日志实现包的使用，当然slf4j-simple除外。其结构如下：
slf4j-api(接口层)
|
各日志实现包的连接层( slf4j-jdk14, slf4j-log4j)
|
各日志实现包

所以，结合各日志实现包使用时提供的jar包情况为：

SLF4J和logback结合使用时需要提供的jar:slf4j-api.jar,logback-classic.jar,logback-core.jar

SLF4J和log4j结合使用时需要提供的jar:slf4j-api.jar,slf4j-log412.jar,log4j.jar

SLF4J和JDK中java.util.logging结合使用时需要提供的jar:slf4j-api.jar,slf4j-jdk14.jar

SLF4J和simple(SLF4J本身提供的一个接口的简单实现)结合使用时需要提供的jar:slf4j-api.jar,slf4j-simple.jar

当然还有其他的日志实现包，以上是经常会使用到的一些。

注意，以上slf4j和各日志实现包结合使用时最好只使用一种结合，不然的话会提示重复绑定日志，并且会导致日志无法输出。

slf4j-api.jar:对外提供统一的日志调用接口，该接口具体提供的调用方式和方法举例说明：见上slf4j的使用

如果系统中之前已经使用了log4j做日志输出，想使用slf4j作为统一的日志输出，该怎么办呢？

如果之前系统中是单独使用log4j做为日志输出的，这时再想使用slf4j做为日志输出时，如果系统中日志比较多，此时更改日志输出方法肯定是不太现实的，这个时候就可以使用log4j-over-slf4j.jar将使用log4j日志框架输出的日志路由到slf4j上来统一采用slf4j来输出日志。

为什么要使用SLF4J?

slf4j是一个日志接口，自己没有具体实现日志系统，只提供了一组标准的调用api,这样将调用和具体的日志实现分离，使用slf4j后有利于根据自己实际的需求更换具体的日志系统，比如，之前使用的具体的日志系统为log4j,想更换为logback时，只需要删除log4j相关的jar,然后加入logback相关的jar和日志配置文件即可，而不需要改动具体的日志输出方法，试想如果没有采用这种方式，当你的系统中日志输出有成千上万条时，你要更换日志系统将是多么庞大的一项工程。如果你开发的是一个面向公众使用的组件或公共服务模块，那么一定要使用slf4的这种形式，这有利于别人在调用你的模块时保持和他系统中使用统一的日志输出。
slf4j日志输出时可以使用{}占位符，如，logger.info(“testlog: {}”, “test”)，而如果只使用log4j做日志输出时，只能以logger.info(“testlog:”+“test”)这种形式，前者要比后者在性能上更好，后者采用+连接字符串时就是new 一个String 字符串，在性能上就不如前者。

2.log4j(log for java)

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

如何使用？

引入jar,使用log4j时需要的jar为：log4j.jar。
定义配置文件log4j.properties或log4j.xml
在具体的类中进行使用：
- 在需要日志输出的类中加入：private static final Logger logger = Logger.getLogger(Tester.class); //通过Logger获取Logger实例
- 在需要输出日志的地方调用相应方法即可：logger.debug(“System ……”)

关于如何单独使用log4j，建议详细阅读以下文章：

https://blog.csdn.net/u012422446/article/details/51199724

3.logback

logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架,是slf4j的原生实现(即直接实现了slf4j的接口，而log4j并没有直接实现，所以就需要一个适配器slf4j-log4j12.jar),logback一共有以下几个模块：

logback-core：其它两个模块的基础模块
logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging
logback-access：访问模块与Servlet容器集成提供通过Http来访问日志的功能

同样，单独使用它时，需要引入以上jar,然后进行配置文件的配置，最后就是在相关类中进行使用，使用时加入以下语句:

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

logger.info(“打印日志”);

对于logback的使用，详细使用方法及配置推荐阅读以下文章：

https://www.cnblogs.com/warking/p/5710303.html

4.总结如下：

1、slf4j是java的一个日志门面，实现了日志框架一些通用的api，log4j和logback是具体的日志框架。

2、他们可以单独的使用，也可以绑定slf4j一起使用。

单独使用，分别调用框架自己的方法来输出日志信息。绑定slf4j一起使用。调用slf4j的api来输入日志信息，具体使用与底层日志框架无关（需要底层框架的配置文件）。显然不推荐单独使用日志框架。假设项目中已经使用了log4j，而我们此时加载了一个类库，而这个类库依赖另一个日志框架。这个时候我们就需要维护两个日志框架，这是一个非常麻烦的事情。而使用了slf4j就不同了，由于应用调用的抽象层的api，与底层日志框架是无关的，因此可以任意更换日志框架。

参考文章

https://www.cnblogs.com/bt2882/p/13820092.html

https://www.cnblogs.com/hanszhao/p/9754419.html

https://zzq23.blog.csdn.net/article/details/87629782

柯柯不会Java

关注

3
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
spingboot默认日志系统LogBack、Log4j和slf4j使用详解

spingboot默认日志系统LogBack、Log4j和slf4j使用详解spingboot默认日志系统LogBack依赖引入Spring Boot默认使用LogBack日志系统，如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。如果要使用LogBack，原则上是需要添加dependency依赖的<groupId>org.springframework.boot</groupId><artifactId>
复制链接

扫一扫