SpringBoot 日志深度解析：轻松上手，快速精通！

最新推荐文章于 2025-05-26 19:53:23 发布
最新推荐文章于 2025-05-26 19:53:23 发布
阅读量1.1k 收藏 16
点赞数 11
CC 4.0 BY-SA版权
分类专栏： # springboot 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Yaml4/article/details/143289391

前言

日志，是开发中熟悉又陌生的伙伴，熟悉是因为我们经常会在各种场合打印日志，陌生是因为大部分时候我们都不太关心日志是怎么打印出来的，因为打印一条日志，在我们看来是一件太平常不过的事情了，特别是在宇宙第一框架Springboot的加持下，日志打印是怎么工作的就更没人关注了。

但是了解日志框架怎么工作，以及学会Springboot怎么和Log4j2或Logback等日志框架集成，对我们扩展日志功能以及优雅打印日志大有好处，甚至在有些场景，还能通过调整日志的打印策略来提升我们的系统吞吐量。

所以本文将以Springboot集成Log4j2为例，详细说明Springboot框架下Log4j2是如何工作的，你可能会担心，如果是使用Logback日志框架该怎么办呢，其实Log4j2和Logback极其相似，Springboot在启动时处理Log4j2和处理Logback也几乎是一样的套路，所以学会Springboot框架下Log4j2如何工作，切换成Logback也是轻轻松松的。

本文遵循一个该深则深，该浅则浅的整体指导方针，全方位的阐述Springboot中日志怎么工作，思维导图如下所示。

一. Log4j2简单工作原理分析

Log4j2 是一个功能强大的 Java 日志框架，它提供了灵活的配置和高效的日志记录功能。以下是对 Log4j2 工作原理的详细分析，并结合代码进行说明。

1、核心组件

  1. Logger（日志记录器）：Logger 是 Log4j2 中用于记录日志的核心组件。每个 Logger 都有一个名称，用于标识不同的日志来源。Logger 可以根据日志级别来决定是否记录日志。常见的日志级别从低到高依次为：TRACE、DEBUG、INFO、WARN、ERROR 和 FATAL。

  2. Appender（输出目的地）：Appender 定义了日志的输出目的地，可以是控制台、文件、数据库等。Log4j2 支持多种类型的 Appender，开发人员可以根据实际需求进行配置。

  3. Layout（日志格式器）：Layout 用于定义日志的输出格式。它可以将日志事件转换为特定的字符串格式，以便于阅读和分析。Log4j2 提供了多种 Layout 实现，如 PatternLayout、JSONLayout 等。

2、工作原理

  1. 配置加载：在应用程序启动时，Log4j2 会加载配置文件。配置文件可以是 XML、JSON 或 properties 格式，其中包含了 Logger、Appender 和 Layout 的配置信息。Log4j2 根据配置文件创建相应的 Logger、Appender 和 Layout 对象。

  2. 日志记录：当应用程序需要记录日志时，会通过 Logger 对象的相应方法（如 debug、info、error 等）来记录日志。Logger 会根据当前的日志级别和配置来决定是否记录该日志。如果日志级别满足要求，Logger 会将日志事件传递给关联的 Appender。

  3. Appender 处理：Appender 接收到日志事件后，会根据其配置的 Layout 对日志事件进行格式化。然后，Appender 将格式化后的日志输出到指定的目的地，如控制台、文件或数据库。

  4. 异步日志记录：Log4j2 支持异步日志记录，这可以提高应用程序的性能。异步日志记录将日志的产生和输出分离，日志事件首先被放入一个队列中，然后由单独的线程从队列中取出并输出。这样可以避免在日志输出时阻塞应用程序的主线程。

3、代码示例

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Log4j2Example {
    private static final Logger logger = LogManager.getLogger(Log4j2Example.class);

    public static void main(String[] args) {
        logger.trace("This is a trace message.");
        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
        logger.fatal("This is a fatal message.");
    }
}

在这个例子中：

  • 首先，引入了 Log4j2 的相关库：
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
  • 创建一个静态的 Logger 对象：
private static final Logger logger = LogManager.getLogger(Log4j2Example.class);

这里通过 LogManager.getLogger 方法获取与当前类对应的 Logger 对象。每个 Logger 都有一个名称，这里使用当前类的全限定名作为 Logger 的名称，以便更好地区分不同模块的日志。

  • 在 main 方法中，使用不同的日志级别记录日志：
logger.trace("This is a trace message.");
logger.debug("This is a debug message.");
logger.info("This is an info message.");
logger.warn("This is a warning message.");
logger.error("This is an error message.");
logger.fatal("This is a fatal message.");

这些方法分别对应不同的日志级别。根据 Log4j2 的配置，只有级别高于或等于配置中指定的日志级别才会被输出。

例如，如果配置文件中设置的日志级别为 INFO，那么只有 info、warn、error 和 fatal 级别的日志会被输出，而 trace 和 debug 级别的日志将被忽略。

以下是一个简单的 Log4j2 XML 配置文件示例：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

在这个配置文件中：

  • <Appenders> 部分定义了输出目的地。这里定义了一个名为 Console 的输出目的地，将日志输出到控制台。<PatternLayout> 定义了日志的格式，包括时间戳、线程名称、日志级别、日志记录器名称和日志消息等。

  • <Loggers> 部分定义了日志记录器。<Root> 表示根日志记录器，这里设置其级别为 info，并将 Console 输出目的地关联到根日志记录器，意味着所有级别为 info 及以上的日志都会被输出到控制台。

四、总结

Log4j2 通过灵活的配置和强大的功能，为 Java 应用程序提供了高效的日志记录解决方案。开发人员可以根据实际需求配置不同的 Logger、Appender 和 Layout，以满足不同的日志记录需求。同时，Log4j2 的异步日志记录功能可以提高应用程序的性能，避免在日志输出时阻塞主线程。

二、Springboot日志简单配置说明

在 Spring Boot 中，日志配置相对简单，它默认使用 Logback 作为日志实现框架。以下是关于 Spring Boot 日志的详细介绍及结合代码的说明：

1、Spring Boot 日志的默认配置

Spring Boot 为开发者提供了一套默认的日志配置，无需额外的配置就可以在控制台输出日志信息。默认情况下，日志级别为 INFO，会输出 INFO、WARN、ERROR 级别的日志。

2、日志级别

Spring Boot 支持的日志级别从低到高依次为：TRACE、DEBUG、INFO、WARN、ERROR、FATAL。可以通过配置文件调整日志级别，以控制输出的日志详细程度。

例如，将日志级别调整为 DEBUG，可以看到更多的调试信息：

logging.level.root=DEBUG

3、配置文件

  • application.properties 文件：

可以在 application.properties 文件中进行简单的日志配置。

logging.level.com.example.demo=DEBUG
# 设置包 com.example.demo 的日志级别为 DEBUG

logging.file=myapp.log
# 指定日志输出到文件 myapp.log

logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
# 定义控制台输出的日志格式
  • application.yml 文件：

也可以使用 YAML 格式的配置文件进行日志配置。

例如：

logging:
  level:
    com.example.demo: DEBUG
  file: myapp.log
  pattern:
    console: '%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n'

4、代码中使用日志

在 Spring Boot 应用中，可以直接使用 SLF4J（Simple Logging Facade for Java）的接口来记录日志，而具体的日志实现由底层的日志框架（如 Logback）负责。

例如，在一个服务类中：

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

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    public void doSomething() {
        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
    }
}

五、总结

Spring Boot 的日志配置简单而强大，可以通过配置文件轻松调整日志级别、输出目的地和日志格式等。在开发过程中，合理地配置日志可以帮助开发者更好地了解应用程序的运行状态，便于调试和故障排除。

三. Springboot日志启动机制分析

1、依赖引入与自动配置

Spring Boot 在启动时会自动引入相关的日志依赖。默认情况下，它使用 Logback 作为日志实现框架。如果在项目中引入了其他日志框架，如 Log4j2 或 Java Util Logging，Spring Boot 会根据依赖的优先级进行自动配置。

在项目的 pom.xml 文件中，通常会有以下依赖：

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

这个启动器会自动引入一系列的基础依赖，其中包括日志相关的依赖。

2、日志配置文件加载

  1. 默认情况下，Spring Boot 会查找 classpath 下的 logback-spring.xml、logback-spring.groovy、logback.xml 或 logback.groovy 文件作为 Logback 的配置文件。如果使用其他日志框架，也会查找相应的配置文件。

  2. 配置文件可以设置日志级别、输出目的地、日志格式等。例如，一个简单的 Logback 配置文件 logback-spring.xml 如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

这个配置文件定义了一个输出到控制台的 Appender，并设置了日志格式和根日志级别为 INFO。

3、日志记录器的创建与使用

  • 在 Spring Boot 应用中，可以使用 SLF4J（Simple Logging Facade for Java）的接口来记录日志。SLF4J 提供了统一的日志接口，而具体的日志实现由底层的日志框架负责。

例如，在一个服务类中：

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

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    public void doSomething() {
        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
    }
}
  • 当应用程序启动时，SLF4J 会根据配置的日志框架创建相应的日志记录器（Logger）。在上面的代码中，通过 LoggerFactory.getLogger 方法获取与 MyService 类对应的日志记录器。

4、日志级别控制

  • 可以通过配置文件或在运行时动态调整日志级别。例如，在配置文件中设置特定包或类的日志级别：
<configuration>
   ...
    <logger name="com.example.demo" level="DEBUG"/>
   ...
</configuration>

这将设置包 com.example.demo 的日志级别为 DEBUG。

  • 也可以在运行时通过 JMX（Java Management Extensions）或使用特定的日志管理工具来动态调整日志级别。

5、总结

Spring Boot 的日志启动机制通过自动配置和依赖引入，使得日志配置变得简单而高效。开发者可以通过配置文件轻松地定制日志的输出格式、级别和目的地，并且可以在代码中使用统一的 SLF4J 接口来记录日志。这种机制有助于提高开发效率，便于调试和故障排除。

四、Springboot集成Log4j2原理

1、依赖引入与自动配置

  • 在 Spring Boot 项目中，要集成 Log4j2，首先需要在项目的依赖管理文件（如 Maven 的 pom.xml）中添加相应的依赖：
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-log4j2</artifactId>
   </dependency>

这个依赖会引入 Log4j2 相关的库以及与 Spring Boot 的集成组件。

Spring Boot 的自动配置机制会检测到这个依赖，并尝试进行 Log4j2 的自动配置。

2、配置文件加载

  • Spring Boot 会在项目的 classpath 下查找 Log4j2 的配置文件。默认情况下，会查找 log4j2.xml、log4j2.properties 或 log4j2.yml 文件。

    例如，一个简单的 log4j2.xml 配置文件如下：

   <?xml version="1.0" encoding="UTF-8"?>
   <Configuration status="WARN">
       <Appenders>
           <Console name="Console" target="SYSTEM_OUT">
               <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
           </Console>
       </Appenders>
       <Loggers>
           <Root level="info">
               <AppenderRef ref="Console"/>
           </Root>
       </Loggers>
   </Configuration>

这个配置文件定义了一个输出到控制台的 Appender，并设置了根日志记录器的级别为 info。

3、日志记录器的创建与使用

  • 在应用程序中，可以使用 SLF4J（Simple Logging Facade for Java）的接口来记录日志。SLF4J 提供了统一的日志接口，而具体的日志实现由底层的日志框架（这里是 Log4j2）负责。

    例如，在一个服务类中：

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

   public class MyService {
       private static final Logger logger = LoggerFactory.getLogger(MyService.class);

       public void doSomething() {
           logger.debug("This is a debug message.");
           logger.info("This is an info message.");
           logger.warn("This is a warning message.");
           logger.error("This is an error message.");
       }
   }

通过 LoggerFactory.getLogger 方法获取与 MyService 类对应的日志记录器。当调用日志记录方法时，SLF4J 会将日志请求转发给 Log4j2，Log4j2 根据配置文件中的设置来决定如何处理日志事件。

4、工作流程总结

当 Spring Boot 应用启动时：

  1. 首先，自动配置机制检测到 spring-boot-starter-log4j2 依赖，并尝试加载 Log4j2 的配置文件。

  2. 如果找到配置文件，Log4j2 根据配置文件创建相应的日志记录器、Appender 和 Layout。

  3. 在应用程序运行过程中，当使用 SLF4J 的接口记录日志时，SLF4J 将日志请求转发给 Log4j2。

  4. Log4j2 根据当前的日志级别和配置，决定是否记录日志以及将日志输出到何处。

五. Springboot日志打印器级别热更新

在 Spring Boot 中，可以实现日志打印器级别的热更新，这意味着可以在应用程序运行时动态地调整日志级别，而无需重新启动应用程序。以下是详细介绍并结合代码说明：

1、实现原理

Spring Boot 默认使用的日志框架是 Logback，但也可以集成其他日志框架如 Log4j2。无论是哪种框架，通常都支持通过特定的方式在运行时动态调整日志级别。一般来说，这是通过读取配置文件或者使用特定的管理工具来实现的。

2、使用配置文件实现热更新（以 Logback 为例）

  • 在 application.properties 或 application.yml 文件中，可以配置特定包或类的日志级别。例如：

    • 在 application.properties 文件中：
     logging.level.com.example.demo=DEBUG
  • 在 application.yml 文件中：
     logging:
       level:
         com.example.demo: DEBUG

这里将包 com.example.demo 的日志级别设置为 DEBUG。

  • 如果要在运行时动态更新这个级别，可以修改配置文件并让应用程序重新读取配置文件。有些应用服务器或工具可以实现配置文件的热加载，从而实现日志级别的热更新。

3、使用 JMX（Java Management Extensions）实现热更新

  • 可以通过 JMX 来动态调整日志级别。对于 Logback，可以使用 ch.qos.logback.classic.jmx.JMXConfigurator 来启用 JMX 支持。

    在 Logback 的配置文件（如 logback.xml）中添加以下配置：

   <configuration>
       <!-- 其他配置 -->
       <jmxConfigurator/>
   </configuration>
  • 然后，可以使用 JMX 工具（如 JConsole）连接到应用程序，并找到对应的 MBean（Managed Bean）来调整日志级别。

4、代码示例

以下是一个简单的 Spring Boot 应用程序，展示了如何在代码中获取日志记录器并输出不同级别的日志：

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

@SpringBootApplication
public class LoggingExampleApplication {

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

    public static void main(String[] args) {
        SpringApplication.run(LoggingExampleApplication.class, args);

        logger.debug("This is a debug message.");
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
        logger.error("This is an error message.");
    }
}

在运行这个应用程序后，可以通过上述提到的方法（如修改配置文件或使用 JMX 工具）来动态调整日志级别，观察不同级别日志的输出变化。

5、总结

Spring Boot 日志打印器级别的热更新可以提高开发和调试的效率，无需重新启动应用程序即可根据需要调整日志级别，以便更好地跟踪和排查问题。

六. 自定义Springboot下日志打印器级别热更新

在 Spring Boot 中可以自定义实现日志打印器级别的热更新。以下是详细介绍并结合代码说明：

1、实现思路

  1. 创建一个自定义的配置类，用于监听外部的配置变化事件，比如通过 HTTP 请求或者特定的配置文件变化来触发日志级别更新。
  2. 在配置类中，使用 Spring 的 @ConfigurationProperties 注解来绑定外部配置源的属性到 Java 对象中，以便获取新的日志级别设置。
  3. 利用 Spring 的 ApplicationEventPublisher 发布一个自定义的事件，通知应用程序中的其他组件日志级别发生了变化。
  4. 创建一个事件监听器，在接收到自定义事件时，更新日志打印器的级别。

2、代码实现

  • 创建自定义配置类：
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "logging")
public class LoggingConfig {

    private String level;

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }
}

这个类用于绑定外部配置源中以 logging 为前缀的属性，比如 logging.level。

  • 创建自定义事件：
import org.springframework.context.ApplicationEvent;

public class LoggingLevelChangeEvent extends ApplicationEvent {

    public LoggingLevelChangeEvent(Object source) {
        super(source);
    }
}
  • 创建事件发布者：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

@Component
public class LoggingLevelChangePublisher {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publishLoggingLevelChange() {
        applicationEventPublisher.publishEvent(new LoggingLevelChangeEvent(this));
    }
}

这个组件用于发布日志级别变化事件。

  • 创建事件监听器：
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class LoggingLevelChangeListener {

    @EventListener
    public void onLoggingLevelChange(LoggingLevelChangeEvent event) {
        // 假设这里从自定义配置类中获取新的日志级别
        LoggingConfig loggingConfig = new LoggingConfig();
        String newLevel = loggingConfig.getLevel();
        Logger logger = LogManager.getLogger(LoggingLevelChangeListener.class);
        logger.setLevel(Level.toLevel(newLevel));
    }
}

这个监听器在接收到日志级别变化事件时，更新指定日志记录器的级别。

  • 触发日志级别更新：

可以通过创建一个 HTTP 控制器或者其他方式来触发日志级别更新。例如，创建一个 HTTP 控制器方法，接收请求并调用事件发布者发布事件：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoggingController {

    @Autowired
    private LoggingLevelChangePublisher loggingLevelChangePublisher;

    @PostMapping("/updateLoggingLevel")
    public void updateLoggingLevel(@RequestParam String level) {
        // 设置新的日志级别到自定义配置类中
        LoggingConfig loggingConfig = new LoggingConfig();
        loggingConfig.setLevel(level);
        // 发布日志级别变化事件
        loggingLevelChangePublisher.publishLoggingLevelChange();
    }
}

3、总结

通过以上自定义的方式，可以实现根据特定的触发条件来动态更新 Spring Boot 应用中的日志打印器级别，提高了应用程序在运行时的灵活性和可调试性。

SpringBoot入门系列：第三篇 日志输出
lxhjh的专栏
06-24 4万+
Java程序，日志输出，我认为是第一位的，把它的应用拿到这里。 Spring-Boot对日志的处理，和我们往常的处理完全可以一致，通过logback.xml进行处理，即使有更先进的东西，我们也不用去管它。 这里，为了简便，我们任然使用前一篇的工程spring-boot-sample-data 第一步，在src/main/resources中增加logback.xml文件，文件内容为（这里仅最...
SpringBoot关于日志理解(一)--大体应用部分
weixin_45280713的博客
03-25 871
其中：
Spring Boot 中的日志
weixin_46103589的博客
06-21 3212
除此之外，日志还有其他作用：在此之前也许会经常使用 System.out.println 来作为日志打印信息，看程序运行到何处出现了问题，但是该方法所包含的信息太少，没有办法将信息持久化，没有办法控制日志等级从而进行信息的过滤…通过本节将介绍真正的高效日志的输出与存储日志等级的划分方便了程序员对信息的筛选trace 和 debug 这两种日志一般使用来记录系统运行状态，通过该日志，我们可以查看操纵的每一步执行的详细过程info 这种日志用来记录系统正常运行状态，比如系统初始化，请求成功执行…warn 这种日
springboot学习02-[热部署和日志]
Java修炼者的博客
06-24 554
热部署和日志热部署 热部署
Spring Boot日志：从Logger到@Slf4j的探秘
做技术人 · 产优质博客 · 找好工作
01-01 5141
本文主要介绍如何在Spring Boot中产生并打印日志的两种方式：从表层到原理剖析从Logger到@Slf4j的调用原理
“Elasticsearch精英进阶：从零到精通的安装，从Kibana到Java API，全面掌握CRUD与DSL查询及聚合技术全攻略“
欢迎来到Mn_Hz的小博站
07-26 1418
"Elasticsearch实战：从零到精通的安装、DSL查询与Java API全攻略"
SpringBoot-RabbitMQ篇-消息可靠投递
ITGENIUS1的博客
07-23 647
一、发送者异常监控 1.1 发送者异常种类 1.基本处理流程 补偿(兜底)方案 2.模拟broker宕机：修改发送者端口如5673，然后启动，发送消息，端口不对无法连接主机 错误信息：java.net.ConnectException: Connection timed out: connect 补偿方案：加入异常处理，如果不可达则返回错误 这种错误在发送的时候就已经可以发现，直接将错误返回给调用方即可 @RequestMapping("/direct") public Object sendEma
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 3621
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
技术文档炼成记：从新手到大神的爆款创作全攻略
最新发布
Start_mswin的博客
05-26 644
技术文档的质量直接影响着项目的生死存亡。本文将揭秘技术文档创作的核心法则，结合优快云平台特性，手把手教你打造阅读量10W+的爆款技术文档。
泛955、不加班、双休的公司名单来了！2021最新版！
ITGENIUS1的博客
07-30 2119
开始今天的正菜之前，我想先分享一个最近在知乎上看到的很奇葩的问题。大致意思就是：“我自己讨厌计算机这种要终身学习并且会经历 996 生活的专业，我却让朋友学计算机”。 当时，看到这个问题，我整个人就直接懵了！稍微清醒点，也不至于问出这样的问题吧？ 确实，在国内的话， 996 只是绝大部分程序员的选择，但绝不是唯一的选择！ 如果你想要 955/965 的工作，也有很多可供选择的公司（这个在后面会具体介绍到）。 并且，国内也有越来越多的公司开始/考虑取消大小周，开始强制执行 6 点下班！ 我并不觉得这
log4j 日志文件配置
06-28
private static final Logger log = LoggerFactory.getLogger(BaiduFace.class); log.info("消息等...");
SpringBoot中使用日志（LoggerFactory）
今天怎么又下雨的博客
01-31 1156
日志系统提供了高性能缓存机制，有着很好的性能，并且可以使用配置进行统一打开和关闭。4、INFO：信息等级的日志，指一些在粗粒度级别上需要强调的应用程序运行信息。1、FATAL：致命等级的日志，指发生了严重的会导致应用程序退出的事件。5、DEBUG：调试等级的日志，指一些细粒度的对于程序调试有帮助的信息。2、ERROR：错误等级的日志，指发生了错误，但是不影响系统运行。6、TRACE：跟踪等级的日志，指一些包含程序运行详细过程的信息。3、WARN： 警告等级的日志，指发生了异常，可能是潜在的错误。
20Springboot整合日志过程
qq_41946216的博客
03-24 2842
1、日志级别介绍 日志级别从高到低：error，warn，info，debug、trace error：抛出异常或者连接不上数据库等，需要人为接入和修复的 warn：不常用，只是警告 info：在未来进行定位和排查问题使用，例如用户请求和返回 debug：用于自身在开发过程中调试使用，例如打印某方法执行的时间，这些信息不需要以info级别记录。 trace；一般用于框架开发，不常用。 2、引入log4j2依赖 引入log4j2依赖，无需指定版本，因......
Springboot中日志的简单使用
weixin_46427348的博客
09-03 5356
这个带表整个项目是debug级别的日志 这个包下是info级别的日志 但这样设置特别麻烦所以可以设置分组。CRITICAL：特别严重的问题，导致程序不能再继续运行时使用，如:磁盘空间为空，一般很少使 用。在Springboot启动时默认使用的时INFO级别的日志，所以并不会显示DEBUG级别的日志。默认的是WARNING等级，当在WARNING或WARNING之上等级的才记录日志信息。1）记录日常运营的重要信息（峰值流量，平均响应时常。3.可以通过日志组或代码包的形式进行日志级别的控制。
SpringBoot快速入门（笔记四-实用运维篇）
南郊靳东的个人博客
03-21 2973
本章节将讲一下我们在实际部署springBoot 项目中需要注意的问题 一：打包与运行 二：配置高级 三：多环境开发 四：日志
SpringBoot对异常的统一处理
S mile0804的博客
01-23 1487
Spring Boot默认提供了一种映射到错误页面/error的机制来处理所有的错误，可以映射到名为404或500等的错误页面，但此种机制存在局限性。为此，SpringBoot提供了注解的方式自定义统一处理服务器500错误机制。 @ControllerAdvice注解表示我们定义的是一个控制器增强类，当其他任何控制器发生异常且异常类型符合@ExceptionHandler注解中指定的异常类时，原请求将会被拦截到这个我们自定义的控制器方法中。 其annotations参数表示我们要拦截的带有指定注解的类
SpringBoot启动报错：LoggerFactory is not a Logback LoggerContext but Logback is on the classpath
Hello World
07-31 2245
Exception in thread "main" java.lang.ClassCastException: org.apache.logging.slf4j.SLF4JLoggerContext cannot be cast to org.apache.logging.log4j.core.LoggerContext Exception in thread "main" java.l...
【Spring Boot】Spring Boot Logging 示例 | 日志记录
猫巳的博客
09-28 4808
文章目录logging.level | 设置日志级别logging.file | 指定输出日志文件的路径和名称logging.path | 指定输出日志文件的路径logging.pattern.console | 配置控制台输出格式logging.pattern.file | 配置日志文件输出格式使用命令行改变控制台输出的日志级别在我们的程序中使用日志记录使用 XML 文件配置 Logback使用自定义日志：Log4j2参考文献 在这个页面上，我们将提供spring boot日志记录的例子。 Spring
Spring Boot - 日志文件配置，logback 配置（超详细）
热门推荐
CYK_byte的博客
02-20 1万+
我们的Java程序在IDEA中执行完后，都会编译生成一个target文件，这个文件就是项目最终执行的代码（去掉注释等一系列工作后的文件），那么想要知道lombok的实现原理，就需要去观察这个文件~在生产环境下需要将日志信息保留下来，便于出现问题以后容易追溯问题，将日志保存下来这个活动叫做日志持久化。我们只需要在配置文件中指定日志的存储目录或者是指定日志保存文件名即可，如下。Ps：在没有指定文件名两次保存或者指定相同文件名进行两次保存的情况下，Ps：logger 对象是属于 org.slf4j 包下！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yaml墨韵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值