当前位置：首页 > news >正文

Java学习，一文掌握Java之SpringBoot框架学习文集(1)

news 文章来源：https://blog.csdn.net/m0_50308467/article/details/135322153 2024/9/21 12:42:10

在这里插入图片描述

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
🎉欢迎 👍点赞✍评论⭐收藏

SpringBoot知识专栏学习

SpringBoot知识云集	访问地址	备注
SpringBoot知识点(1)	https://blog.csdn.net/m0_50308467/article/details/135322153	SpringBoot专栏

文章目录

🏆 Java框架之Spring Boot
- 🔎 Java框架之Spring Boot学习(1)
- - 🍁🍁 01、Spring Boot 应用程序的运行方式有哪些？
  - 🍁🍁 02、Spring Boot 应用程序的启动流程是什么样的？
  - 🍁🍁 03、Spring Boot 中的 "约定优于配置" 是什么意思？
  - 🍁🍁 04、Spring Boot 应用程序的入口类需要添加哪个注解来启用自动配置机制？
  - 🍁🍁 05、如何覆盖默认的 Spring Boot 配置项？
  - 🍁🍁 06、Spring Boot 中的自动配置是如何工作的？
  - 🍁🍁 07、Spring Boot 中的自动配置是如何解决冲突的？
  - 🍁🍁 08、如何自定义 Spring Boot 的自动配置？
  - 🍁🍁 09、如何定义一个自定义的 Starters？
  - 🍁🍁 10、Spring Boot Actuator 提供了哪些功能？

🏆 Java框架之Spring Boot

🔎 Java框架之Spring Boot学习(1)

🍁🍁 01、Spring Boot 应用程序的运行方式有哪些？

Spring Boot 应用程序有以下几种运行方式：

在 IDE 中直接运行：在开发环境中，你可以选择合适的启动类，并在 IDE 中直接运行 Spring Boot 应用程序。
通过 Maven 或 Gradle 进行打包并在命令行中运行：使用 Maven 或 Gradle 将 Spring Boot 应用程序打包成可执行的 JAR 文件，然后在命令行中使用 java -jar 命令来运行应用程序。
使用 Spring Boot Maven 插件进行直接运行：Spring Boot 提供了一个 Maven 插件，可以直接在命令行中运行应用程序，无需事先进行打包。使用命令 mvn spring-boot:run 即可启动应用程序。
使用 Docker 镜像运行：将 Spring Boot 应用程序打包成 Docker 镜像，并使用 Docker 容器运行应用程序。这种方式提供了更好的隔离性和可移植性。
使用控制台方式运行：在命令行中使用 Spring Boot 的 SpringApplication 类的静态 run 方法来启动应用程序，例如在 Java 类中编写 public static void main 方法并调用 SpringApplication.run(Application.class, args)。
使用 Spring Boot DevTools 进行热部署：在开发环境中，你可以使用 Spring Boot DevTools 模块来实现代码的热部署。在应用程序启动时，DevTools 会监视代码的变化，并自动重新加载修改后的代码，从而加快开发过程。

无论选择哪种运行方式，Spring Boot 应用程序都会使用内嵌的 Tomcat、Jetty 或 Undertow 服务器来运行。

🍁🍁 02、Spring Boot 应用程序的启动流程是什么样的？

Spring Boot 应用程序的启动流程如下：

执行 main 方法：在 Spring Boot 应用程序的启动类中，执行 public static void main(String[] args) 方法。
创建 SpringApplication 实例：用于自动配置所有Spring的环境并启动Spring应用程序，创建一个 SpringApplication 实例。
加载配置文件：Spring Boot 应用程序会默认加载 application.properties 或 application.yml 配置文件，作为默认的配置文件，也可以通过设置启动参数 --spring.config.name 或 --spring.config.location 来指定其他的配置文件。
执行自动配置过程：Spring Boot 应用程序会根据 classpath 中的依赖自动配置Spring环境，包括：自动配置数据源、Web应用程序、安全等等组件，也可以使用 @EnableAutoConfiguration 注解来手动配置。
启动 Web 服务器：Spring Boot 应用程序会启动内嵌的 Web 服务器（如 Tomcat 或 Jetty），并根据配置的端口号等信息来监听请求。
运行应用程序：应用程序启动后，可以执行自定义的逻辑或处理外部请求等，完成应用程序的启动。
触发应用程序启动事件：在启动过程中，SpringApplication 实例会触发一系列的应用程序启动事件，比如 ApplicationStartingEvent、ApplicationEnvironmentPreparedEvent、ApplicationPreparedEvent 等。这些事件可以被监听器捕获，并执行相应的操作。
加载启动类和应用程序上下文：SpringApplication 加载启动类，并创建应用程序上下文。这个上下文是 Spring 的 IoC 容器，负责管理 Bean 实例、依赖注入等。
执行Spring Boot应用程序：SpringApplication 运行应用程序上下文，执行 Spring Boot 应用程序的逻辑代码。主要是执行启动类上的 @SpringBootApplication 注解或其他注解所标注的方法。
启动完成：应用程序完成启动，服务器监听请求并响应。此时可以通过浏览器或其他客户端访问应用程序提供的服务。

在整个启动流程中，Spring Boot 提供了一系列的可扩展点和监听器，允许开发者自定义启动时的行为，如自定义配置加载、自定义 Bean 注册等。这使得 Spring Boot 在不同场景下都具备灵活性和可扩展性。

在以上过程中，Spring Boot 应用程序有两个重要的组件，即 SpringApplication 和 SpringApplicationRunListener。SpringApplication 负责调用 SpringApplicationRunListener 中的方法，来在启动过程中触发所需要的事件。

🍁🍁 03、Spring Boot 中的 “约定优于配置” 是什么意思？

“约定优于配置”（Convention over configuration）是 Spring Boot 的设计思想之一。它的主要含义就是在框架的设计中，遵循一定的约定，减少配置的工作量，从而提高开发效率。

在 Spring Boot 中，很多常见的配置已经被预设好了，例如内嵌的 Tomcat 服务器、通用的数据访问、日志记录等功能。开发者只需要遵循一定的默认约定，就可以快速创建可执行的 Spring 应用程序，而不需要过多的配置或管理。

举个例子，Spring Boot 中的项目结构、Bean 命名规范、依赖管理等都有一定的约定，这些约定可以使得开发者能够使用更加简洁、明了的代码来实现应用程序的功能。

这种设计思想可以让开发者专注于应用程序的业务逻辑，而避免关注框架本身的细节。这样能够提高开发效率，让开发者更加专注于实现具体的业务需求。同时，这也使得应用程序的维护成本降低，因为维护者们只需要关注一些必要的配置，而不需要去深入了解框架本身的工作原理。

总之，“约定优于配置”是 Spring Boot 设计的一种思想，可以让开发者只需关注应用程序的逻辑实现，而无需过多关注框架本身的细节，从而提高开发效率和降低维护成本。

当你使用Spring Boot开发应用程序时，它遵循了一系列的默认约定。这些约定旨在帮助你快速搭建应用程序，并以最小的配置工作启动。

以下是一些关于Spring Boot中约定优于配置的例子：

默认的目录结构：Spring Boot希望你的项目按照它约定的目录结构组织代码。例如，将应用程序主类放在顶层包（top-level package）中，将控制器放在controllers包中，将实体类放在models包中等等。这样的规约可让其他开发人员更容易理解你的项目，也能更轻松地找到特定的组件。
自动配置：Spring Boot根据你的类路径、依赖和其他配置信息自动配置应用程序。这意味着你不需要显式地编写大量的配置代码。例如，当你添加Spring Data JPA依赖时，Spring Boot会自动配置JPA相关的Bean，以便你能够方便地使用它们。
默认的属性配置：Spring Boot为许多常见的配置属性提供了默认值。例如，默认数据源配置、服务器端口等。你可以在需要的情况下覆盖这些默认属性，以满足你的应用程序需求。
约定的Bean命名：Spring Boot会根据约定为某些Bean（如控制器、存储库、服务等）生成默认的Bean名称。这使得组件的自动装配变得更简单，无需手动指定Bean名称或使用注解。

这些约定在Spring Boot中充分利用了约定，使得开发过程更加高效和简洁。虽然你可以通过自定义配置来覆盖这些约定，但在大多数情况下，你只需要遵循这些默认约定就能够快速构建和启动应用程序。

🍁🍁 04、Spring Boot 应用程序的入口类需要添加哪个注解来启用自动配置机制？

在 Spring Boot 应用程序的入口类中，你需要添加 @SpringBootApplication 注解来启用自动配置机制。

@SpringBootApplication 是一个组合注解，它包含了以下三个注解的功能：

@Configuration：将该类标记为配置类。
@EnableAutoConfiguration：启用自动配置机制。
@ComponentScan：启用组件扫描，以便发现和装配其他组件。

通过添加 @SpringBootApplication 注解，你可以简化入口类的代码，并确保 Spring Boot 自动加载配置并扫描组件。

以下是一个示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class MyApplication {public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}}

在这个示例中，@SpringBootApplication 注解用于标记 MyApplication 类作为 Spring Boot 应用程序的入口点。SpringApplication.run() 方法用于启动应用程序，并自动加载配置以及扫描组件。

需要注意的是，入口类应该位于包的顶层（top-level package）中，这样可以确保自动扫描到所有的组件。同时，@SpringBootApplication 注解也可以用于额外的配置类上，以确保这些配置类也能够被自动加载和扫描。

除了 @SpringBootApplication 注解，还有一些其他的启动注解也可用于启用自动配置机制，这些注解包括：

@EnableAutoConfiguration：启用自动配置机制。
@ComponentScan：启用组件扫描，以便发现和装配其他组件。
@Configuration：将该类标记为配置类。
@SpringBootConfiguration：将该类标记为 Spring Boot 的配置类。
@EnableAutoConfiguration 和 @ComponentScan 的组合注解：这是 @SpringBootApplication 注解内部就包含了这些注解。

在大多数情况下，你可以直接使用 @SpringBootApplication 注解来启用自动配置机制，而不必使用其他特定的注解。

但如果需要对自动配置进行更深入的控制，你可以选择使用其他启动注解。例如，如果你需要排除特定的自动配置，可以使用 @EnableAutoConfiguration(exclude = {...}) 注解来排除不需要的自动配置。

总之，在 Spring Boot 应用程序的入口类中，添加合适的启动注解是启用自动配置机制的必要步骤，可以大大简化应用程序的构建和配置。

🍁🍁 05、如何覆盖默认的 Spring Boot 配置项？

在 Spring Boot 应用程序中，可以通过多种方式来修改或覆盖默认的配置项。以下是一些常见的方法：

1. application.properties/application.yml 配置文件

在应用程序的 classpath 中的 application.properties 或 application.yml 中覆盖默认属性。例如，你可以在这些文件中添加以下配置来更改默认端口：

# application.properties
server.port=8080

或者使用 YAML 格式的配置文件：

# application.yml
server:port: 8080

2. 命令行参数

启动应用程序时，可以使用命令行参数来覆盖默认属性。例如，以下命令将更改默认端口：

java -jar myapp.jar --server.port=8080

3. 在代码中修改属性

使用 Spring 的 Environment 抽象类可以在代码中修改属性。例如，以下代码会将端口设置为 8080：

@Autowired
private Environment env;public void setPort() {env.setProperty("server.port", "8080");
}

4. 使用配置类

可以使用 @ConfigurationProperties 注解创建一个配置类，并在其中定义应用程序的配置项，然后将其注入到代码中以便在运行时修改属性。例如，以下代码片段创建了一个名为 MyConfig 配置类，其中的属性 server.port 具有默认值 8080：

@Configuration
@ConfigurationProperties(prefix = "server")
public class MyConfig {private int port = 8080;public void setPort(int port) {this.port = port;}public int getPort() {return port;}
}

在应用程序的其他组件中可以使用 @Autowired 注解将 MyConfig 类注入到代码中，然后以相同的方式使用属性。

@Autowired
private MyConfig myConfig;public void setPort() {myConfig.setPort(8080);
}

无论使用哪种方法，都可以通过修改或覆盖默认配置项来自定义 Spring Boot 应用程序的行为。需要注意的是，某些配置属性只能通过一种或几种方法进行修改或覆盖，具体要根据属性的类型和用途来确定最佳配置方式。

🍁🍁 06、Spring Boot 中的自动配置是如何工作的？

Spring Boot 的自动配置是通过条件化的配置和自动装配实现的。它的工作原理可以总结为以下几个步骤：

类路径扫描：当应用程序启动时，Spring Boot 会扫描类路径上的依赖关系。这意味着 Spring Boot 可以检测到在应用程序类路径上存在的库和框架。
自动配置候选项的识别：Spring Boot 根据类路径上发现的库和框架，自动识别可能与当前应用程序相关的自动配置候选项。每个自动配置候选项对应于一个或多个自动配置类。
条件化的配置：Spring Boot 使用条件化注解来确定是否要激活某个自动配置。条件化注解允许根据一组条件来决定是否应该启用自动配置。例如，@ConditionalOnClass 注解会检查类路径上是否存在特定的类，如果存在，则激活自动配置。
自动配置类的执行：当自动配置被激活时，相应的自动配置类会被加载和执行。自动配置类根据条件进行配置，例如注册适当的 Bean、应用默认属性等。
用户自定义配置：如果用户提供了自己的配置，它会覆盖自动配置的默认值。用户可以通过 application.properties、application.yml、@ConfigurationProperties 注解等方式提供自己的配置。

通过这个自动配置的过程，Spring Boot 可以根据应用程序的类路径和用户的自定义配置，提供合理且默认的配置，减少了开发者的工作量。同时，开发者也可以通过自定义配置来覆盖或扩展默认的自动配置，以满足特定的需求。

需要注意的是，自动配置并不是万能的，它只提供了一种方便的方式来配置应用程序，对于更复杂的需求，仍然需要开发者手动进行配置。另外，为了避免不必要的自动配置，开发者也可以通过 @EnableAutoConfiguration(exclude = {...}) 来排除掉某些不需要的自动配置。

另外，Spring Boot 中的自动配置还有以下一些特性：

自动配置类：Spring Boot 使用很多自动配置类来根据应用程序的环境自动配置相应的组件，比如数据源、Web 容器、安全等等。
自定义过滤器和拦截器：Spring Boot 允许开发者定义自己的过滤器和拦截器，并且自动配置它们。
条件化的 Bean 创建：有时我们只想在满足某些条件时才创建某个 Bean，Spring Boot 提供了一些条件化的注解来满足这种需求，比如 @ConditionalOnProperty、@ConditionalOnClass 等等。
自动配置的前置条件：有些自动配置需要满足一些前置条件才能生效，比如某个 Bean 已经存在、特定的类存在等等。Spring Boot 提供了一些前置条件来保证自动配置的正确性。

总之，Spring Boot 的自动配置是一种非常便捷和强大的特性，它在很大程度上简化了应用程序的配置工作，节约了开发者的时间和精力。当然，现有的自动配置并不一定满足所有场景，对于一些特殊的需求，我们仍然需要开发者手动进行配置。

🍁🍁 07、Spring Boot 中的自动配置是如何解决冲突的？

在 Spring Boot 中，自动配置可能会发生冲突。为解决冲突，Spring Boot采用了以下两个策略：

优先使用用户定义的 Bean：当多个自动配置类尝试为相同的 Bean 创建实例时，Spring Boot 将优先考虑由用户显式定义的 Bean，而不是自动配置生成的 Bean。换句话说，如果在应用程序中定义了一个与自动配置类中相同类型和名称的 Bean，则Spring Boot将使用用户定义的 Bean，以解决冲突。
后加载的 Bean 会覆盖先前加载的 Bean：当存在多个自动配置类为相同的 Bean 进行不同的配置时，Spring Boot会根据配置类加载顺序来决定使用哪种配置。在应用程序启动时，Spring Boot首先加载较早的自动配置类，并在后续加载的自动配置类中进行 Bean 的定义。这样，后加载的 Bean 将替换先前加载的 Bean，解决了冲突。

请注意，自动配置的冲突在绝大多数情况下并不常见。当然，在遇到冲突时，我们应仔细研究其原因，并考虑采取手动配置或者排除某些自动配置的方式来解决冲突。有时候，自定义条件类也可以用来控制哪些自动配置应该生效，进一步解决自动配置的冲突。

🍁🍁 08、如何自定义 Spring Boot 的自动配置？

自定义 Spring Boot 的自动配置可以让您根据项目的需求或特定的场景进行定制化配置。下面是自定义 Spring Boot 自动配置的主要步骤，以下重点内容已加粗显示：

创建自动配置类：创建一个 Java 类，一般以 xxxAutoConfiguration 或 XxxAutoConfiguration 命名，并使用 @Configuration 注解进行标记。
编写自动配置逻辑：在自动配置类中，使用各种 Spring 的注解和配置方式，编写自动配置的逻辑。根据具体需求，可以使用 @Bean 注解创建需要自动配置的 Bean，并对其进行初始化和配置。
使用条件注解：为了确保自定义的自动配置仅在特定条件下生效，可以使用条件注解来控制自动配置的生效条件。例如，使用 @ConditionalOnClass、@ConditionalOnProperty 等注解来指定某个类、某个属性满足条件时才进行自动配置。
打包和引入：将编写好的自动配置类所在的模块打包为一个 Jar 文件，并将该 Jar 文件引入到您的项目中。可以使用 Maven、Gradle 等构建工具将模块打包为可发布的 Jar 文件。
启用自动配置：在 Spring Boot 主应用程序的入口类上使用 @EnableAutoConfiguration 注解来启用自定义的自动配置。这样，当应用启动时，Spring Boot 将加载并应用自定义的自动配置。

需要注意的是，自定义自动配置通常是为了解决特定需求或提供额外功能，而不是完全替换 Spring Boot 的默认自动配置。因此，在自定义自动配置时，应尽量遵循 Spring Boot 的自动配置规范，并确保自定义的配置与默认的配置可以和谐共存。

请参考以下示例说明每个步骤：

1. 创建自动配置类：

@Configuration
public class MyAutoConfiguration {// 配置代码将在这里
}

2. 编写自动配置逻辑：

在自动配置类中，可以使用 @Bean 注解创建需要自动配置的 Bean，并对其进行初始化和配置。例如，创建一个名为 myBean 的 Bean，并设置它的属性：

@Bean
public MyBean myBean() {MyBean bean = new MyBean();bean.setProperty("some value");return bean;
}

3. 使用条件注解：

为了确保自定义的自动配置仅在特定条件下生效，可以使用条件注解来控制自动配置的生效条件。例如，使用 @ConditionalOnClass 注解确保特定的类可用时才进行自动配置：

@Configuration
@ConditionalOnClass(ConditionClass.class)
public class MyAutoConfiguration {// 配置代码将在这里
}

4. 打包和引入：

使用构建工具（例如 Maven 或 Gradle）将自动配置类所在的模块打包为一个可发布的 Jar 文件。

5. 启用自动配置：

在 Spring Boot 主应用程序的入口类上使用 @EnableAutoConfiguration 注解来启用自定义的自动配置。例如：

@SpringBootApplication
@EnableAutoConfiguration(MyAutoConfiguration.class)
public class MyApp {public static void main(String[] args) {SpringApplication.run(MyApp.class, args);}
}

🍁🍁 09、如何定义一个自定义的 Starters？

自定义 Starters 是通过封装常用的依赖和配置，方便其他开发人员在 Spring Boot 项目中快速集成自定义功能的一种方式。下面是定义一个自定义 Starters 的主要步骤：

创建 Starter 模块：创建一个新的 Maven 或 Gradle 模块，作为定义自定义 Starter 的项目。
定义 Starter 名称和描述：在 Starter 模块的 pom.xml（或相应的构建文件）中，定义 Starter 的名称和描述等元数据信息，以便其他开发人员了解这个 Starter 的用途和功能。
添加 Starter 依赖：在 Starter 模块的 pom.xml（或相应的构建文件）中，添加需要封装的依赖库的依赖项。可以根据自己的需求选择需要的依赖库，例如数据库驱动、缓存库、消息中间件等。
创建自定义配置类：在 Starter 模块中，创建一个专门用于配置 Starter 的类。这个类可以包含一些初始化配置、默认值等。可以使用 @ConfigurationProperties 注解声明配置属性，并使用 @Component 或 @Configuration 注解将其作为 Spring Bean 进行管理。
编写自动配置类：在 Starter 模块中，创建一个自动配置类，类似于自定义自动配置的步骤。该自动配置类可根据 Starter 的功能和特点，创建一些必要的 Bean 并进行初始化和配置。
打包和发布：使用构建工具将 Starter 模块打包为一个可发布的 Jar 文件。可以将其发布到本地 Maven 仓库，也可以发布到远程 Maven 仓库，以便其他开发人员可以通过 Maven 或 Gradle 方式引入使用。
使用自定义 Starter：在其他项目中，可以通过 Maven 或 Gradle 的方式引入刚才创建的自定义 Starter，即可获得该 Starter 封装的依赖和配置。可以在项目的 pom.xml（或相应的构建文件）中添加对 Starter 的依赖，并在项目的配置文件中使用 Starter 提供的配置。

通过自定义 Starters，可以将常用的依赖和配置进行封装，使项目的集成更加简单和统一。同时，也方便了其他开发人员在 Spring Boot 项目中快速集成自定义功能。

当然，请参考以下示例说明每个步骤：

1. 创建 Starter 模块：

创建一个新的 Maven 或 Gradle 模块，作为定义自定义 Starter 的项目。命名为 my-starter。

2. 定义 Starter 名称和描述：

在 my-starter 的 pom.xml（或相应的构建文件）中，定义 Starter 的名称和描述等元数据信息：

<artifactId>my-starter</artifactId>
<name>My Starter</name>
<description>A custom starter for my project</description>

3. 添加 Starter 依赖：

在 my-starter 的 pom.xml（或相应的构建文件）中，添加需要封装的依赖库的依赖项。例如，添加 Spring Boot Starter Web 的依赖：

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

4. 创建自定义配置类：

在 my-starter 中，创建一个用于配置 Starter 的类 MyStarterProperties：

@ConfigurationProperties("my.starter")
public class MyStarterProperties {private String message = "Hello, Starter";public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}
}

5. 编写自动配置类：

在 my-starter 中，创建一个自动配置类 MyStarterAutoConfiguration：

@Configuration
@ConditionalOnClass(WebMvcConfigurer.class)
@EnableConfigurationProperties(MyStarterProperties.class)
public class MyStarterAutoConfiguration {private final MyStarterProperties properties;public MyStarterAutoConfiguration(MyStarterProperties properties) {this.properties = properties;}@Beanpublic MyStarterBean myStarterBean() {MyStarterBean bean = new MyStarterBean();bean.setMessage(properties.getMessage());return bean;}
}

6. 打包和发布：

构建 my-starter 模块，并将其打包为一个可发布的 Jar 文件。可以使用 Maven 或 Gradle 命令进行构建。

7. 使用自定义 Starter：

在其他项目中，可以通过 Maven 或 Gradle 的方式引入 my-starter。例如，在项目的 pom.xml（或相应的构建文件）中添加对 Starter 的依赖：

<dependencies><dependency><groupId>com.example</groupId><artifactId>my-starter</artifactId><version>1.0.0</version></dependency>
</dependencies>

8. 项目配置文件中使用 Starter 配置

然后，在项目的配置文件中使用 Starter 提供的配置：

my:starter:message: "Hello, Custom Starter"

🍁🍁 10、Spring Boot Actuator 提供了哪些功能？

Spring Boot Actuator 是一个用来监控和管理 Spring Boot 应用的框架，提供了一组 HTTP 端点（Endpoint）和 JMX Bean，用于获取应用的健康状况、度量信息、配置信息等。以下是 Spring Boot Actuator 提供的一些常用功能：

应用健康指标：/actuator/health 端点提供了应用健康状态的指标，包括应用的基本信息、状态和是否存活等。
应用信息终端：/actuator/info 端点提供了应用系统的信息，比如应用的版本信息、作者、反馈信息等。
度量指标终端：/actuator/metrics 端点提供了一系列度量指标信息，如 CPU 使用率、内存使用率、请求计数器、并发请求数量、线程池占用情况以及 HTTP 请求响应时间等。
环境信息终端：/actuator/env 端点提供了应用的环境变量信息和配置信息。
线程信息终端：/actuator/threaddump 端点提供了 JVM 运行时的线程信息。
请求追踪终端：/actuator/httptrace 端点提供了应用的 HTTP 请求追踪信息。
关闭应用终端：/actuator/shutdown 端点提供了应用关闭的功能。

以上为 Spring Boot Actuator 提供的常用功能，但它同时提供了许多其他功能的端点和扩展，如缓存信息、数据库连接状况、JMS 队列信息等。您可以根据具体的业务需求，选择相应的端点和功能来监控和管理应用。