Spring Boot日志：从Logger到@Slf4j的探秘

本文比较了Spring Boot中日志记录的两种方式：Logger和@Slf4j注解，并介绍了自定义日志输出和日志级别的方法。适合想要深入了解Spring Boot日志的开发人员。

两者的介绍与大体区别

Logger 和 @Slf4j 都与日志（logging）有关，而 @Slf4j 实际上是 Lombok（一种Java库）提供的一个注解，用于简化日志的创建。让我们详细了解它们之间的区别。

Logger

Logger 是 Java 中的一个接口，通常由各种日志框架实现，比如 Java 自带的 java.util.logging、Apache Log4j、SLF4J（Simple Logging Facade for Java）等。Logger 提供了一组用于记录消息的方法，包括 debug、info、warn、error 等级别。

使用 Logger 的典型方式是通过类的静态字段获取一个 logger 实例，例如：

import java.util.logging.Logger;

public class MyClass {
    private static final Logger logger = Logger.getLogger(MyClass.class.getName());

    public void myMethod() {
        logger.info("This is an info message");
        logger.warning("This is a warning message");
        // ...
    }
}

@Slf4j

@Slf4j 是 Lombok 提供的一个注解，它简化了创建 logger 实例的过程。使用 @Slf4j 注解的类将自动在编译时生成一个名为 log 的 logger 实例。这减少了在每个类中手动创建 logger 的需要。

使用 @Slf4j 的示例：

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyClass {
    public void myMethod() {
        log.info("This is an info message");
        log.warn("This is a warning message");
        // ...
    }
}

通过使用 @Slf4j，你无需手动创建 logger 实例，而是直接使用 log 字段记录日志。

区别和总结

1. 创建方式：

   • Logger：通过调用框架提供的静态方法获取 logger 实例。
   • @Slf4j：通过 Lombok 注解自动生成 logger 实例。

2. 灵活性：

   • Logger：更灵活，可以选择使用不同的日志框架。
   • @Slf4j：通常与 SLF4J 框架结合使用，相对更简洁。

3. 使用场景：

   • Logger：在不使用 Lombok 或在需要更大灵活性时使用。
   • @Slf4j：在使用 Lombok 且不需要过多定制日志配置时使用。

总的来说，Logger 是一种更通用的方式，而 @Slf4j 是在使用 SLF4J 框架且希望简化代码的情况下的便利工具。选择使用哪一种方式取决于你的项目需求和个人偏好。

在Springboot中如何自定义日志的输出

在Spring Boot中，你可以通过配置文件或Java类来自定义日志的输出。Spring Boot使用的默认日志框架是SLF4J（Simple Logging Facade for Java），并在底层使用Logback。

以下是一些自定义日志输出的常见方法：

1. 使用 application.properties 或 application.yml：

在 application.properties 或 application.yml 文件中，你可以配置日志级别和输出格式等信息。例如：

# 配置日志级别
logging.level.root=info
logging.level.org.springframework=debug

# 配置输出格式
logging.pattern.console=%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n

2. 使用 logback-spring.xml 配置文件：

在Spring Boot项目中，你可以创建一个名为 logback-spring.xml 的配置文件，并在其中配置Logback。例如：

<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml" />

    <!-- 自定义配置 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

3. 使用编程方式配置：

你还可以通过编写Java代码来配置日志。例如，在Spring Boot应用程序的任何 @Configuration 类中，你可以使用 LoggerContext 进行配置：

import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LoggingConfig {

    @PostConstruct
    public void configure() {
        ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        root.setLevel(Level.INFO);

        // 添加自定义的appender和其他配置
    }
}

以上只是一些常见的配置方法，你可以根据项目的需要进行更详细的配置。请查阅相关文档以获取更多有关Spring Boot日志配置的信息。

在代码中的具体使用方法

在每个文件中都添加获取Logger的代码可能会显得冗余。为了避免在每个类中都添加这一行，你可以考虑以下两种方式：

1. 使用 Lombok 的 @Slf4j 注解：

Lombok 提供了 @Slf4j 注解，它可以在编译时自动生成类的 Logger 字段。使用这个注解，你不需要在每个类中显式地声明Logger字段，而是只需使用 log 字段即可。

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class MyService {

    public void performAction() {
        try {
            // 业务逻辑

            // 记录成功日志
            log.info("Action performed successfully");
        } catch (Exception e) {
            // 记录失败日志
            log.error("Error performing action", e);
        }
    }
}

2. 使用全局 Logger：

你可以创建一个全局的 Logger 配置类，该类在应用程序初始化时加载，并提供一个静态方法用于获取 Logger 实例。这样，所有的类都可以通过这个全局的 Logger 配置类获取 Logger，避免在每个类中声明 Logger。

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

public class GlobalLogger {

    public static Logger getLogger(Class<?> clazz) {
        return LoggerFactory.getLogger(clazz);
    }
}

然后在你的业务类中使用：

import org.slf4j.Logger;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    private static final Logger logger = GlobalLogger.getLogger(MyService.class);

    public void performAction() {
        try {
            // 业务逻辑

            // 记录成功日志
            logger.info("Action performed successfully");
        } catch (Exception e) {
            // 记录失败日志
            logger.error("Error performing action", e);
        }
    }
}

这样，你只需要在全局配置类中添加 Logger 配置，而不必在每个业务类中都声明 Logger。

日志级别

日志级别是指日志信息的优先级或重要性，用于指定记录日志的详细程度。日志级别是根据不同的情况来确定记录的信息量，允许开发人员过滤和控制日志输出。

在常见的日志系统中，如SLF4J、Log4j、Logback等，日志级别通常分为以下几个：

1. TRACE（跟踪）：

   • 提供比DEBUG更详细的信息，用于诊断问题。
   • 通常情况下，开发过程中很少使用。

2. DEBUG：

   • 提供调试信息，用于定位问题。
   • 通常在开发和测试过程中使用，生产环境中可能关闭。

3. INFO（信息）：

   • 提供一般性的信息，用于标记应用程序运行的关键事件。
   • 通常记录业务流程中的关键步骤，用于监测应用程序状态。

4. WARN（警告）：

   • 表示潜在的问题，不影响应用程序正常运行。
   • 用于警告开发人员或系统管理员可能需要关注的情况。

5. ERROR（错误）：

   • 表示错误情况，可能会导致应用程序发生故障。
   • 需要立即处理，以防止应用程序出现严重问题。

6. FATAL（致命）：

   • 表示致命错误，可能会导致应用程序无法继续运行。
   • 通常是最高级别，表示严重的问题。

不同的日志级别允许开发人员在不同环境和不同场景下灵活地控制日志输出的详细程度。在生产环境中，通常会将日志级别设置为较高的级别，以减少不必要的日志输出，提高性能。在开发和测试环境中，通常可以使用更低级别的日志，以便更好地了解应用程序的内部工作流程和排查问题。

# 日志级别设置
logging:
  level:
    root: error // 则会记录error以上级别的所有日志

# 日志级别设置
logging:
  level:
    root: error
    com.example.package1: warn
    com.example.package2: fatal

在这个例子中，根Logger的级别是error，而com.example.package1包的级别是warn，com.example.package2包的级别是fatal。这意味着根Logger只记录error级别及以上的日志，com.example.package1包记录warn级别及以上的日志，而com.example.package2包记录fatal级别及以上的日志。

在代码中，通过选择适当的日志级别，你可以使用相应级别的日志方法记录信息。例如，使用logger.info()记录INFO级别的日志，使用logger.error()记录ERROR级别的日志等。