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

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

🔎 SpringBoot 领域知识 🔎

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

🏆 学习Java框架之Spring Boot

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

🍁🍁 01、Spring Boot 中的自动装配原理是怎样的？

Spring Boot的自动装配原理主要基于两个关键的概念：条件注解和Spring Boot的启动器。

1. 条件注解（Conditional Annotations）：Spring Boot通过条件注解来控制哪些自动装配的配置类应该生效。条件注解可以基于运行时的条件来判断是否满足某个条件，从而决定是否需要装配某个配置类。

常用的条件注解有：

@ConditionalOnClass、
@ConditionalOnBean、
@ConditionalOnProperty等。

通过合理使用条件注解，可以控制自动装配的精确度和条件。

2. 启动器（Starters）：Spring Boot的启动器是一系列依赖描述符的集合，可以让您方便地导入一组相关的依赖。启动器包含一组自动装配的配置类和依赖，根据您的项目需要来自动装配所需的功能。Spring Boot Starters使得构建特定类型的应用程序变得更容易，您可以通过添加适当的启动器来获取所需的依赖。

当应用程序启动时，Spring Boot会根据条件注解的设置以及应用程序的依赖关系，自动装配应用程序所需的各种配置类和其他组件。它会根据约定和配置去扫描和加载自动装配的Bean，并将它们注册到应用程序上下文中以供使用。

自动装配原理的核心在于Spring Boot的启动器以及条件注解的使用。启动器提供了一种方便的方式来引入所需的功能，而条件注解则通过对条件的判断来决定是否需要装配某个配置类。这种机制使得开发者可以根据实际需求进行自由定制和灵活配置。

🍁🍁 02、@SpringBootApplication 和 @SpringBootConfiguration 注解有什么区别？

@SpringBootApplication和@SpringBootConfiguration是Spring Boot中的两个注解，它们有一些区别和作用。

1. @SpringBootApplication是一个复合注解，它包含了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解。它的作用是标识一个类是Spring Boot应用程序的入口类，同时也是配置类。@EnableAutoConfiguration会自动根据项目的依赖和配置，进行自动装配，而@ComponentScan用于扫描并注册Spring组件。

2. @SpringBootConfiguration是一个元注解，它是Spring Boot提供的专门用于标识配置类的注解。与@Configuration注解类似，@SpringBootConfiguration表明一个类是一个Spring Boot的配置类，用于定义和组织Bean的创建和配置。@SpringBootConfiguration通常与@Configuration一起使用。

综上所述，@SpringBootApplication 是一个更为综合的注解，它不仅标识一个类是Spring Boot应用程序的入口类，同时也是配置类，并且包含了自动装配和组件扫描的功能。

@SpringBootConfiguration 只是一个用于标识配置类的注解，用于定义和组织Bean的创建和配置。通常情况下，我们会在Spring Boot应用程序的入口类上使用@SpringBootApplication注解，而在其他的配置类上使用@SpringBootConfiguration或@Configuration注解。

以下是 @SpringBootApplication 和 @SpringBootConfiguration 注解的区别总结：

区别点	@SpringBootApplication	@SpringBootConfiguration
作用	标识 Spring Boot 应用程序的入口类，同时也是配置类	用于标识 Spring Boot 的配置类
组合注解	由 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 三个注解组合而成	无
自动装配	包含 @EnableAutoConfiguration，用于自动装配	不包含
扫描组件	包含 @ComponentScan，用于扫描组件	不包含

总的来说，@SpringBootApplication 是一个更为综合的注解，包含了多个注解的功能，并作为 Spring Boot 应用程序的入口类。而 @SpringBootConfiguration 则是一个专门用于标识配置类的注解，作用相对单一。

🍁🍁 03、Spring Boot 的注解处理器是什么？它的作用是什么？

Spring Boot 的注解处理器是指用于处理 Spring Boot 注解的特殊处理器。它们用于解析和处理 Spring Boot 的特定注解，实现相应的功能。

在 Spring Boot 中，使用注解处理器可以帮助开发人员节省大量的配置代码，使得应用程序的开发更加简洁高效。以下是 Spring Boot 中常用的注解处理器：

1. @EnableAutoConfiguration: 这个注解处理器用于自动配置 Spring Boot 应用程序的参数。它基于应用的依赖和配置信息，自动进行相关的配置，简化了开发人员的工作。

2. @ComponentScan: 这个注解处理器用于自动扫描和注册 Spring 组件，包括普通的 Bean、组件、配置类等。通过指定包路径和过滤条件，@ComponentScan 可以快速地扫描和加载需要的组件。

3. @Conditional: 这个注解处理器用于条件化地装配和配置 Bean。通过在配置类或方法上添加 @Conditional 注解和相关的条件判断，开发人员可以根据特定的条件选择性地装配或配置 Bean。

4. @Profile: 这个注解处理器用于在多环境下选择性地激活配置。通过为配置类或方法添加 @Profile 注解，并指定相应的环境配置，开发人员可以根据不同的环境加载不同的配置。

这些注解处理器都是 Spring Boot 提供的核心功能，通过它们，开发人员可以简化配置代码，提高开发效率，并使得应用程序更加易于维护和扩展。

注解处理器在 Spring Boot 中的作用主要有以下几个方面：

1. 自动配置：@EnableAutoConfiguration 注解处理器用于自动配置 Spring Boot 应用程序的参数。它根据应用的依赖和配置信息，自动进行相关的配置，包括加载默认配置、装配 Bean、设置属性等。通过自动配置机制，开发人员可以省去大量的手动配置工作，使得应用程序的开发更加简洁高效。

2. 组件扫描和注册：@ComponentScan 注解处理器用于自动扫描和注册 Spring 组件。它可以扫描指定包路径下的组件，包括普通的 Bean、组件、配置类等，然后将它们注册到 Spring 容器中。通过组件扫描和注册的功能，开发人员可以更方便地管理和使用组件，减少手动注册的工作量。

3. 条件装配和配置：@Conditional 注解处理器用于条件化地装配和配置 Bean。通过在配置类或方法上添加 @Conditional 注解和相关的条件判断，可以根据特定的条件选择性地装配或配置 Bean。这样可以根据不同的环境或配置要求，在应用程序启动时动态地决定是否加载某个 Bean，从而实现更加灵活的配置管理。

4. 多环境配置：@Profile 注解处理器用于在多环境下选择性地激活配置。通过为配置类或方法添加 @Profile 注解，并指定相应的环境配置，可以根据不同的环境加载不同的配置。这样可以方便地管理不同环境下的配置信息，避免在不同环境中频繁修改配置文件。

总的来说，注解处理器在 Spring Boot 中的作用是简化配置代码、提高开发效率、实现灵活的配置管理和自动化的组件装配，使得应用程序的开发、配置和部署更加方便和高效。

🍁🍁 04、Spring Boot 中的配置属性是如何加载和绑定的？

在 Spring Boot 中，配置属性的加载和绑定是通过 @ConfigurationProperties 注解和 Binder 进行的。

1. 配置属性的加载：Spring Boot 会读取应用程序的配置文件（如 application.properties 或 application.yml）中定义的属性，并将其加载到一个属性源（ConfigurationPropertySources）中。属性源是一个包含了所有配置属性的集合。Spring Boot 支持多种类型的属性源，可以从不同的来源读取配置属性，包括特定配置文件、环境变量、系统属性、命令行参数等。

2. 配置属性的绑定：通过 @ConfigurationProperties 注解，开发人员可以将属性源中的属性绑定到特定的 Java 类上。在该类中，通过添加 @ConfigurationProperties 注解并指定前缀，可以将属性源中与前缀匹配的属性绑定到该类的属性上。绑定过程是通过 Binder 进行的，它会根据配置的规则和属性的类型进行属性值的转换和赋值。

在进行配置属性的绑定时，Spring Boot 还提供了一些其他的特性，包括属性值的验证、默认值的设置、多个配置文件的支持等。

通过加载和绑定配置属性，开发人员可以方便地将应用程序的配置信息映射到 Java 类的属性上。这样可以实现类型安全的配置管理，避免了硬编码的配置读取和转换工作，使得配置更加清晰、易于维护和扩展。

🍁🍁 05、如何使用 Spring Boot 创建一个可执行的 JAR 文件？

简单说明如何使用 Spring Boot 创建可执行的 JAR 文件。

1. 创建一个 Spring Boot 项目：使用 Spring Initializr 或手动创建一个基于 Spring Boot 的 Maven 项目。

2. 编写代码：在项目中编写你的应用程序代码，包括控制器、服务、实体类等。

3. 配置应用程序：在 application.properties 或 application.yml 文件中配置应用程序的相关属性，例如数据库连接、端口号等。

4. 编译和打包：在命令行中进入项目根目录，执行以下命令进行编译和打包：

mvn clean package

5. 在目标文件夹中找到可执行的 JAR 文件：打包完成后，可以在项目的 target 目录中找到生成的 JAR 文件。

6. 运行可执行的 JAR 文件：在命令行中切换到 JAR 文件所在的目录，执行以下命令运行可执行的 JAR 文件：

java -jar your-application.jar

其中，your-application.jar 是生成的 JAR 文件的名称。

7. 验证应用程序的运行：在浏览器中访问应用程序的端口号（默认为 8080），或使用其他工具发送 HTTP 请求，验证应用程序是否成功运行。

通过以上步骤，你就可以使用 Spring Boot 创建一个可执行的 JAR 文件并成功运行应用程序。这种打包方式方便快捷，可以快速部署和分发应用程序，适用于独立运行的 Spring Boot 应用程序。

使用 Spring Boot 创建一个可执行的 JAR 文件可以通过以下步骤完成：

1. 配置 Spring Boot Maven 插件：在 Maven 项目的 pom.xml 文件中，添加 Spring Boot Maven 插件的依赖配置。确保使用的插件版本与你所使用的 Spring Boot 版本相匹配。

<properties>
    <java.version>11</java.version>
    <spring-boot.version>2.5.4</spring-boot.version>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring-boot.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2. 打包应用程序：使用 Maven 命令进行应用程序的打包。在项目根目录执行以下命令：

mvn clean package

该命令会将应用程序的编译输出打包为一个 JAR 文件，并将依赖的类库也包含在其中。

3. 运行可执行的 JAR 文件：在打包完成后，可以在目标文件夹(target)找到生成的 JAR 文件。使用以下命令运行可执行的 JAR 文件：

java -jar your-application.jar

其中，your-application.jar 是生成的 JAR 文件的名称。

通过以上步骤，你可以创建一个包含了应用程序和其依赖的可执行的 JAR 文件。该 JAR 文件可以直接在运行环境中执行，无需依赖其他的部署工具或容器。这种方式非常适合于快速部署和分发独立的 Spring Boot 应用程序。

🍁🍁 06、Spring Boot 中的 DevTools 是用来做什么的？它的作用是什么？

Spring Boot 中的 DevTools 是一个开发辅助工具，主要用于提高开发效率和降低开发成本。

DevTools 提供如下功能：

1. 自动重启：在应用程序的 classpath 下的文件发生改变时，DevTools 会自动重启应用程序，加快开发效率。

2. 实时类加载：DevTools 通过在类加载器中注册一个特殊的类加载器，可以实现在运行时替换类文件的功能。这意味着你可以在不需要重启应用程序的情况下修改类文件并立即看到更改结果。

3. 静态资源变化监控：DevTools 可以监控类路径下静态资源文件（如 JavaScript、CSS、HTML 等），并在文件变化时重新加载。

4. 全局属性配置：通过 DevTools，你可以在运行时配置全局属性，例如：禁用模板缓存、修改日志级别等。

5. 自动配置：DevTools 可以检测应用程序中的依赖，并根据检测结果自动进行一些配置，例如：自动刷新数据库连接池、自动配置 JPA、自动配置消息处理等。

DevTools 是一个开发环境下非常有用的工具，可以提高开发效率和协作速度，并且使用它非常容易。只需在应用程序中添加以下 Maven 依赖即可：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-devtools</artifactId>
	<optional>true</optional>
</dependency>

综上所述，DevTools 是一个非常有用的开发辅助工具，可以提高开发效率和协作速度，在开发 Spring Boot 应用程序时非常值得尝试。

DevTools 的主要作用是提高开发效率和开发体验。下面列出了 DevTools 的几个作用：

1. 自动重启：DevTools 具有自动重启应用程序的功能，这意味着在开发过程中，当你修改了应用程序的代码或资源文件时，无需手动停止和重新启动应用程序，DevTools 会自动检测变化并重新启动应用程序，从而加快了开发的迭代速度。

2. 实时类加载：DevTools 通过在类加载过程中添加一个特殊的类加载器，实现了在运行时替换类文件的功能。这样，你可以在不关闭或重启应用程序的情况下修改类文件，并立即看到修改结果，无需等待重新编译和启动。

3. 静态资源变化监控：DevTools 可以监控类路径下的静态资源文件的变化，例如 HTML、CSS、JavaScript 文件等。当这些文件发生变化时，DevTools 会自动重新加载资源，无需手动刷新浏览器。

4. 全局属性配置：DevTools 提供了一些开发中常用的属性配置，例如禁用模板缓存、修改日志级别、配置全局错误页面等。这样，你可以在运行时对应用程序的属性进行更改，而无需重新编译和启动应用程序。

总的来说，DevTools 的作用是提高开发效率，加速开发迭代，并提供一些便利的开发工具和配置选项，使开发人员更专注于业务逻辑的开发，而不需要花费过多时间来启动、重启和刷新应用程序。

🍁🍁 07、Spring Boot Actuator 的工作原理是怎样的？

Spring Boot Actuator 是 Spring Boot 提供的一个管理端点的框架，可以方便地监控和管理 Spring Boot 应用。它的工作原理可以分为以下几点：

1. 对 Spring Boot 应用进行运行时监控：Actuator 通过内置的 HTTP 端点提供了一组基本的接口，包括 /health、/metrics、/info 等，这些接口可以用来检查应用程序的运行状况、收集度量数据以及暴露应用程序的信息。这些信息均以 JSON 或者类似的格式输出，可以轻松地进行解析和集成。

2. 集成 Spring Boot Starter：Actuator 可以轻松地与其他 Spring Boot Starter 集成，通过运行类似于 /actuator/env、/actuator/configprops、/actuator/mappings 等端点获取 Spring 的环境配置、Spring Boot 所有配置和 Spring MVC 映射等信息。

3. 自定义端点：Actuator 允许开发人员自定义端点，实现任何类型的运行时信息的监控和管理。这样，就可以方便地将自定义信息集成到应用程序管理服务中，从而更好地监督应用程序的性能和运行状况。

4. 安全和安全性设置：Actuator 支持与 Spring Security 进行集成以实现安全的元数据端点。Spring Boot Actuator 还提供了许多其他功能，例如通过监控 /shutdown 端点实现优雅地关闭应用程序等。

总的来说，Spring Boot Actuator 的工作原理是在应用程序中嵌入一组 HTTP 端点，用来实时监控和管理应用程序。这样，开发人员和系统管理员可以方便地检查应用程序的健康状况、度量数据和所有配置信息。Actuator 可以集成到任何基于 Spring Boot 的应用程序中，大大提高了应用程序的监管速度和管理能力。

🍁🍁 08、Spring Boot Actuator 中常见的端点有哪些？它们的作用是什么？

Spring Boot Actuator 提供了多个端点以方便用户监控 Spring Boot 应用程序的运行状况。以下是一些常见的端点：

1. /health：检查应用程序的运行状况，包括检查应用程序的磁盘空间是否足够、数据库是否连接、消息队列是否运行等。

2. /metrics：提供了用于监控 JVM 内存、HTTP 请求数量、响应时间等度量数据的端点。这些数据可以被外部系统使用，例如 Prometheus、Grafana 等度量监控平台。

3. /info：提供有关应用程序的基本信息，如 Spring Boot 版本、环境变量、系统属性等。

4. /trace：提供一个追踪端点来获取 HTTP 请求的跟踪信息，包括请求方法、请求 URL、响应码等。

5. /env：提供了应用程序的所有环境变量和系统属性。

6. /loggers：提供了所有日志记录器和它们的当前级别。它还允许用户设置特定记录器的级别。

7. /configprops：提供了所有配置属性及其源（包括默认值）的详细信息。

8. /dump：将线程转储输出到 HTTP 响应中，用于调试和故障排除。

9. /mappings：提供了所有 Spring MVC 映射的详细信息。

此外，还有一些自定义端点可以添加到 Actuator 中。开发人员可以添加自己的端点，以向 Actuator 中添加自定义信息。

这些常见端点在 Spring Boot Actuator 中具有以下作用：

1. /health：用于检查应用程序的健康状况。通过检查磁盘空间、数据库连接、消息队列等，可以确定应用程序是否正常运行。该端点对于监控应用程序的运行状况非常有用。

2. /metrics：用于获取应用程序的度量数据。可以监控 JVM 内存使用情况、HTTP 请求数量、请求响应时间等。这些度量数据可以用于性能监控、问题排查和系统优化。

3. /info：提供了应用程序的基本信息，如 Spring Boot 版本、环境变量、系统属性等。这对于了解应用程序的基本配置及其运行环境非常有用，特别是在多个环境中部署应用程序时。

4. /trace：用于获取 HTTP 请求的跟踪信息。可以查看每个请求的方法、URL、请求参数、响应码等。这对于定位和解决请求问题非常有帮助。

5. /env：提供了应用程序的所有环境变量和系统属性。这对于查看和调试应用程序的配置非常有用。

6. /loggers：提供了应用程序的所有日志记录器和它们的当前级别。可以查看和修改日志记录器的级别，以更好地管理应用程序的日志输出级别。

7. /configprops：提供了应用程序的所有配置属性和它们的来源信息。可以查看和调试应用程序的配置属性，包括默认值、命令行参数、配置文件等。

8. /dump：将线程转储输出到 HTTP 响应中。这对于调试和故障排除非常有用，可以查看应用程序中的线程状态及堆栈信息。

9. /mappings：提供了所有 Spring MVC 请求映射的详细信息。可以查看应用程序中的 URL 映射信息，包括请求路径、Controller、方法等。

这些端点可以通过 HTTP 请求访问，并以 JSON 格式返回相关信息。通过查看和利用这些端点，开发人员和系统管理员可以更好地监控、管理和调试 Spring Boot 应用程序。

🍁🍁 09、如何在 Spring Boot 中自定义 Actuator 端点？

在 Spring Boot 中，可以通过编写自定义的端点类来添加自定义 Actuator 端点。下面是一些步骤：

1. 创建一个新的 Spring Boot 项目或打开现有的项目。

2. 创建一个新的类，实现 Endpoint 接口或其子接口，用于定义自定义端点的行为和返回结果。

@Component
public class CustomEndpoint implements Endpoint<Map<String, Object>> {

    @Override
    public String getId() {
        return "customEndpoint";
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    @Override
    public boolean isSensitive() {
        return true;
    }

    @Override
    public Map<String, Object> invoke() {
        // 自定义端点的逻辑处理
        Map<String, Object> result = new HashMap<>();
        result.put("message", "This is a custom endpoint");
        return result;
    }
}

在上面的例子中，CustomEndpoint 类实现了 Endpoint 接口，并提供了自定义的端点逻辑。getId() 方法返回端点的唯一标识符，isEnabled() 方法确定端点是否启用，isSensitive() 方法确定端点是否包含敏感信息，invoke() 方法是自定义端点的实际逻辑实现。

3. 在该类上添加 @Component 注解，以将其声明为 Spring Bean。

4.（可选）自定义端点可以接受参数。可以在自定义的端点类中定义所需的参数，然后通过使用 @ReadOperation、@WriteOperation 或 @DeleteOperation 注解来处理相应的 HTTP 请求方法。

@Component
public class CustomEndpoint implements Endpoint<Map<String, Object>> {

    // ...

    @ReadOperation
    public Map<String, Object> getEndpointInfo(@Selector String name) {
        // 使用 @Selector 注解来接受参数
        Map<String, Object> result = new HashMap<>();
        result.put("message", "Hello, " + name);
        return result;
    }

    // ...
}

在上面的例子中，getEndpointInfo() 方法接受一个参数 name，可以通过 @Selector 注解来获取该参数。

5. 启动应用程序，自定义的端点将会被自动注册到 Actuator 端点中。

现在，你可以通过访问 /actuator/customEndpoint 端点来访问自定义的端点，并获取自定义的结果。根据实际需求，可以根据需要扩展、修改自定义端点的逻辑。自定义端点可以提供更多的应用程序信息，或者实现特定的监控或管理功能。

🍁🍁 10、Spring Boot 中的 Profile 是什么？如何使用它来实现多环境配置？

在 Spring Boot 中，Profile（配置文件） 是一种用于根据不同的环境或条件提供不同配置的机制。通过使用 Profile，可以在同一个应用程序中为不同的目标环境（如开发、测试、生产等）或应用程序需求定义不同的配置。

使用 Profile 可以在应用程序中定义不同的配置，例如数据库连接、日志级别、缓存策略等。在不同的环境或条件下，可以通过激活不同的 Profile 来加载相应的配置。

Spring Boot 提供了多种方式来激活和配置 Profile。下面是一些常用的方式：

1. 使用 spring.profiles.active 配置属性：可以通过在 application.properties 或 application.yml 文件中设置 spring.profiles.active 属性来指定要激活的 Profile。例如：

spring.profiles.active=dev

2. 使用命令行参数：可以使用 -Dspring.profiles.active=dev 命令行参数来指定要激活的 Profile。

3. 使用环境变量：可以设置名为 SPRING_PROFILES_ACTIVE 的环境变量来指定要激活的 Profile。

4. 使用 @Profile 注解：可以在 Spring Bean 上使用 @Profile 注解来指定该 Bean 在特定 Profile 下才会被创建。例如：

@Component
@Profile("dev")
public class DevBean {
    // ...
}

在上述示例中，DevBean Bean 只会在 dev Profile 下被创建。

当应用程序启动时，Spring Boot 会根据配置的 Profile 来加载相应的配置。如果未指定任何 Profile，Spring Boot 将使用默认的配置。

使用 Profile 可以轻松地在不同的环境或条件下提供不同的配置，使应用程序能够灵活地适应各种需求，从而实现更好的可配置性和可扩展性。

可以使用 Spring Boot 的 Profile 机制来实现多环境配置。下面是一个示例：

1. 创建不同环境的配置文件

在 src/main/resources 目录下创建多个配置文件，例如：

• application-dev.yml：开发环境配置
• application-test.yml：测试环境配置
• application-prod.yml：生产环境配置

在这些配置文件中，可以指定相应环境下的配置项，例如：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: mypassword

2. 指定要激活的 Profile

可以通过以下方式来指定要激活的 Profile：

• 在 application.properties 或 application.yml 文件中设置 spring.profiles.active 属性，例如：

  spring.profiles.active=dev
  

• 使用命令行参数 -Dspring.profiles.active=dev 来指定要激活的 Profile

3. 在代码中引用配置

可以使用 @Value 注解或使用 Environment 类来引用配置，例如：

@Component
public class MyComponent {
    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Autowired
    private Environment env;

    public void doSomething() {
        String password = env.getProperty("spring.datasource.password");
        // ...
    }
}

在上述示例中，MyComponent 类引用了 spring.datasource.url 和 spring.datasource.password 属性的值，这些属性值是在配置文件中定义的。

通过使用 Profile ，可以在不同环境下使用不同的配置文件，方便地管理相应环境下的配置，从而提高了系统的可维护性和可扩展性。

4. 使用不同的配置文件名

如果不想使用默认的配置文件名，可以使用 spring.config.name 和 spring.config.location 属性来指定要使用的配置文件名和路径。例如，可以将配置文件名改为 app-config.yml，并将路径设置为 /etc/myapp，并使用 dev Profile：

spring.config.location=classpath:/,file:/etc/myapp/
spring.config.name=app-config
spring.profiles.active=dev

在这种情况下，Spring Boot 将在 classpath:/ 和 /etc/myapp 目录下查找 app-config.yml 文件，并将 dev Profile 激活。

5. 使用自定义 Profile

除了使用 dev、test、prod 等标准的 Profile，还可以通过自定义 Profile 来加载自定义的配置。可以通过以下步骤来定义和激活自定义 Profile：

• 在 application.properties 或 application.yml 文件中设置自定义 Profile，例如：

  spring.profiles.active=mycustomprofile
  

• 创建一个名为 application-mycustomprofile.yml 的配置文件，其中的配置项适用于自定义 Profile

  mycustomproperty: mycustomvalue
  

• 在代码中引用自定义配置，例如：

  @Value("${mycustomproperty}")
  private String myCustomProperty;
  

在上述示例中，mycustomprofile 是自定义的 Profile 名称。通过使用自定义 Profile，可以为特定的使用场景定义特定的配置项，从而更加灵活地管理应用程序的配置。

总结：通过使用 Profile 机制，可以轻松地实现多环境配置，为不同的运行环境提供不同的配置。可以通过设置不同的 Profile 来激活相应配置，也可以使用自定义 Profile 来定义特定场景下的配置。这使得系统的配置更加灵活和可管理，提高了系统的可靠性和可扩展性。