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

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

🔎 SpringBoot 领域知识 🔎

链接	专栏
SpringBoot 专业知识学习一	SpringBoot专栏
SpringBoot 专业知识学习二	SpringBoot专栏
SpringBoot 专业知识学习三	SpringBoot专栏
SpringBoot 专业知识学习四	SpringBoot专栏
SpringBoot 专业知识学习五	SpringBoot专栏

🏆 Java框架之Spring Boot

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

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

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

1. 在 IDE 中直接运行：在开发环境中，你可以选择合适的启动类，并在 IDE 中直接运行 Spring Boot 应用程序。

2. 通过 Maven 或 Gradle 进行打包并在命令行中运行：使用 Maven 或 Gradle 将 Spring Boot 应用程序打包成可执行的 JAR 文件，然后在命令行中使用 java -jar 命令来运行应用程序。

3. 使用 Spring Boot Maven 插件进行直接运行：Spring Boot 提供了一个 Maven 插件，可以直接在命令行中运行应用程序，无需事先进行打包。使用命令 mvn spring-boot:run 即可启动应用程序。

4. 使用 Docker 镜像运行：将 Spring Boot 应用程序打包成 Docker 镜像，并使用 Docker 容器运行应用程序。这种方式提供了更好的隔离性和可移植性。

5. 使用控制台方式运行：在命令行中使用 Spring Boot 的 SpringApplication 类的静态 run 方法来启动应用程序，例如在 Java 类中编写 public static void main 方法并调用 SpringApplication.run(Application.class, args)。

6. 使用 Spring Boot DevTools 进行热部署：在开发环境中，你可以使用 Spring Boot DevTools 模块来实现代码的热部署。在应用程序启动时，DevTools 会监视代码的变化，并自动重新加载修改后的代码，从而加快开发过程。

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

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

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

1. 执行 main 方法：在 Spring Boot 应用程序的启动类中，执行 public static void main(String[] args) 方法。

2. 创建 SpringApplication 实例：用于自动配置所有Spring的环境并启动Spring应用程序，创建一个 SpringApplication 实例。

3. 加载配置文件：Spring Boot 应用程序会默认加载 application.properties 或 application.yml 配置文件，作为默认的配置文件，也可以通过设置启动参数 --spring.config.name 或 --spring.config.location 来指定其他的配置文件。

4. 执行自动配置过程：Spring Boot 应用程序会根据 classpath 中的依赖自动配置Spring环境，包括：自动配置数据源、Web应用程序、安全等等组件，也可以使用 @EnableAutoConfiguration 注解来手动配置。

5. 启动 Web 服务器：Spring Boot 应用程序会启动内嵌的 Web 服务器（如 Tomcat 或 Jetty），并根据配置的端口号等信息来监听请求。

6. 运行应用程序：应用程序启动后，可以执行自定义的逻辑或处理外部请求等，完成应用程序的启动。

7. 触发应用程序启动事件：在启动过程中，SpringApplication 实例会触发一系列的应用程序启动事件，比如 ApplicationStartingEvent、ApplicationEnvironmentPreparedEvent、ApplicationPreparedEvent 等。这些事件可以被监听器捕获，并执行相应的操作。

8. 加载启动类和应用程序上下文：SpringApplication 加载启动类，并创建应用程序上下文。这个上下文是 Spring 的 IoC 容器，负责管理 Bean 实例、依赖注入等。

9. 执行Spring Boot应用程序：SpringApplication 运行应用程序上下文，执行 Spring Boot 应用程序的逻辑代码。主要是执行启动类上的 @SpringBootApplication 注解或其他注解所标注的方法。

10. 启动完成：应用程序完成启动，服务器监听请求并响应。此时可以通过浏览器或其他客户端访问应用程序提供的服务。

在整个启动流程中，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中约定优于配置的例子：

1. 默认的目录结构：Spring Boot希望你的项目按照它约定的目录结构组织代码。例如，将应用程序主类放在顶层包（top-level package）中，将控制器放在controllers包中，将实体类放在models包中等等。这样的规约可让其他开发人员更容易理解你的项目，也能更轻松地找到特定的组件。

2. 自动配置：Spring Boot根据你的类路径、依赖和其他配置信息自动配置应用程序。这意味着你不需要显式地编写大量的配置代码。例如，当你添加Spring Data JPA依赖时，Spring Boot会自动配置JPA相关的Bean，以便你能够方便地使用它们。

3. 默认的属性配置：Spring Boot为许多常见的配置属性提供了默认值。例如，默认数据源配置、服务器端口等。你可以在需要的情况下覆盖这些默认属性，以满足你的应用程序需求。

4. 约定的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 的自动配置是通过条件化的配置和自动装配实现的。它的工作原理可以总结为以下几个步骤：

1. 类路径扫描：当应用程序启动时，Spring Boot 会扫描类路径上的依赖关系。这意味着 Spring Boot 可以检测到在应用程序类路径上存在的库和框架。

2. 自动配置候选项的识别：Spring Boot 根据类路径上发现的库和框架，自动识别可能与当前应用程序相关的自动配置候选项。每个自动配置候选项对应于一个或多个自动配置类。

3. 条件化的配置：Spring Boot 使用条件化注解来确定是否要激活某个自动配置。条件化注解允许根据一组条件来决定是否应该启用自动配置。例如，@ConditionalOnClass 注解会检查类路径上是否存在特定的类，如果存在，则激活自动配置。

4. 自动配置类的执行：当自动配置被激活时，相应的自动配置类会被加载和执行。自动配置类根据条件进行配置，例如注册适当的 Bean、应用默认属性等。

5. 用户自定义配置：如果用户提供了自己的配置，它会覆盖自动配置的默认值。用户可以通过 application.properties、application.yml、@ConfigurationProperties 注解等方式提供自己的配置。

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

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

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

1. 自动配置类：Spring Boot 使用很多自动配置类来根据应用程序的环境自动配置相应的组件，比如数据源、Web 容器、安全等等。

2. 自定义过滤器和拦截器：Spring Boot 允许开发者定义自己的过滤器和拦截器，并且自动配置它们。

3. 条件化的 Bean 创建：有时我们只想在满足某些条件时才创建某个 Bean，Spring Boot 提供了一些条件化的注解来满足这种需求，比如 @ConditionalOnProperty、@ConditionalOnClass 等等。

4. 自动配置的前置条件：有些自动配置需要满足一些前置条件才能生效，比如某个 Bean 已经存在、特定的类存在等等。Spring Boot 提供了一些前置条件来保证自动配置的正确性。

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

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

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

1. 优先使用用户定义的 Bean：当多个自动配置类尝试为相同的 Bean 创建实例时，Spring Boot 将优先考虑由用户显式定义的 Bean，而不是自动配置生成的 Bean。换句话说，如果在应用程序中定义了一个与自动配置类中相同类型和名称的 Bean，则Spring Boot将使用用户定义的 Bean，以解决冲突。

2. 后加载的 Bean 会覆盖先前加载的 Bean：当存在多个自动配置类为相同的 Bean 进行不同的配置时，Spring Boot会根据配置类加载顺序来决定使用哪种配置。在应用程序启动时，Spring Boot首先加载较早的自动配置类，并在后续加载的自动配置类中进行 Bean 的定义。这样，后加载的 Bean 将替换先前加载的 Bean，解决了冲突。

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

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

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

1. 创建自动配置类：创建一个 Java 类，一般以 xxxAutoConfiguration 或 XxxAutoConfiguration 命名，并使用 @Configuration 注解进行标记。

2. 编写自动配置逻辑：在自动配置类中，使用各种 Spring 的注解和配置方式，编写自动配置的逻辑。根据具体需求，可以使用 @Bean 注解创建需要自动配置的 Bean，并对其进行初始化和配置。

3. 使用条件注解：为了确保自定义的自动配置仅在特定条件下生效，可以使用条件注解来控制自动配置的生效条件。例如，使用 @ConditionalOnClass、@ConditionalOnProperty 等注解来指定某个类、某个属性满足条件时才进行自动配置。

4. 打包和引入：将编写好的自动配置类所在的模块打包为一个 Jar 文件，并将该 Jar 文件引入到您的项目中。可以使用 Maven、Gradle 等构建工具将模块打包为可发布的 Jar 文件。

5. 启用自动配置：在 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 的主要步骤：

1. 创建 Starter 模块：创建一个新的 Maven 或 Gradle 模块，作为定义自定义 Starter 的项目。

2. 定义 Starter 名称和描述：在 Starter 模块的 pom.xml（或相应的构建文件）中，定义 Starter 的名称和描述等元数据信息，以便其他开发人员了解这个 Starter 的用途和功能。

3. 添加 Starter 依赖：在 Starter 模块的 pom.xml（或相应的构建文件）中，添加需要封装的依赖库的依赖项。可以根据自己的需求选择需要的依赖库，例如数据库驱动、缓存库、消息中间件等。

4. 创建自定义配置类：在 Starter 模块中，创建一个专门用于配置 Starter 的类。这个类可以包含一些初始化配置、默认值等。可以使用 @ConfigurationProperties 注解声明配置属性，并使用 @Component 或 @Configuration 注解将其作为 Spring Bean 进行管理。

5. 编写自动配置类：在 Starter 模块中，创建一个自动配置类，类似于自定义自动配置的步骤。该自动配置类可根据 Starter 的功能和特点，创建一些必要的 Bean 并进行初始化和配置。

6. 打包和发布：使用构建工具将 Starter 模块打包为一个可发布的 Jar 文件。可以将其发布到本地 Maven 仓库，也可以发布到远程 Maven 仓库，以便其他开发人员可以通过 Maven 或 Gradle 方式引入使用。

7. 使用自定义 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;
    }

    @Bean
    public 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 提供的一些常用功能：

1. 应用健康指标：/actuator/health 端点提供了应用健康状态的指标，包括应用的基本信息、状态和是否存活等。

2. 应用信息终端：/actuator/info 端点提供了应用系统的信息，比如应用的版本信息、作者、反馈信息等。

3. 度量指标终端：/actuator/metrics 端点提供了一系列度量指标信息，如 CPU 使用率、内存使用率、请求计数器、并发请求数量、线程池占用情况以及 HTTP 请求响应时间等。

4. 环境信息终端：/actuator/env 端点提供了应用的环境变量信息和配置信息。

5. 线程信息终端：/actuator/threaddump 端点提供了 JVM 运行时的线程信息。

6. 请求追踪终端：/actuator/httptrace 端点提供了应用的 HTTP 请求追踪信息。

7. 关闭应用终端：/actuator/shutdown 端点提供了应用关闭的功能。

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