科普文：Spring Boot面试一问一答系列之十

什么是 Spring Boot？

Spring Boot 是一个建立在 Spring 框架之上的开源 Java 框架。Spring Boot 旨在以最少的设置和配置更轻松地创建独立的、生产就绪的应用程序。

Spring Boot的主要优点是什么？

Spring Boot 为 Java 应用程序开发提供了几个显著的优势。一些主要优势包括：

1. 简化配置：Spring Boot 通过提供合理的默认值和自动配置，消除了手动配置的需要。它减少了样板代码，使开发人员能够更多地关注业务逻辑。
2. 快速应用程序开发：Spring Boot 提供了一系列提高生产力的功能，例如嵌入式服务器、自动依赖项管理和热重载。这些功能可加快开发速度并缩短上市时间。
3. 固执己见的方法：Spring Boot 遵循固执己见的方法，提供预定义的约定和最佳实践。它促进了一致性，并减少了做出配置决策的认知负荷。
4. 微服务友好：Spring Boot 与 Spring Cloud 无缝集成，促进了微服务架构的开发。它为服务发现、分布式配置、负载均衡等提供内置支持。
5. 生产就绪功能：Spring Boot Actuator 提供了一组用于监视、运行状况检查、指标和安全性的生产就绪功能。它使开发人员能够深入了解应用程序性能并轻松监控系统运行状况。
6. 嵌入式服务器：Spring Boot 附带了 Tomcat、Jetty 和 Undertow 等嵌入式服务器。这消除了手动服务器设置和配置的需要。
7. 自动配置：Spring Boot 的自动配置功能会根据类路径依赖关系自动配置应用程序。它简化了设置过程并减少了手动配置工作。
8. 社区支持：Spring Boot 拥有庞大而活跃的开发人员社区。这意味着有大量的资源、文档和社区支持可用于故障排除和共享最佳实践。
9. 生态系统集成：Spring Boot 与其他 Spring 项目和第三方库无缝集成。它利用强大的 Spring 生态系统，允许开发人员将各种工具和库用于各种目的。
10. 可测试性：Spring Boot 为测试提供了出色的支持，包括单元测试、集成测试和端到端测试。它提供了测试切片、模拟对象等功能，并针对不同的测试框架进行了简单配置。

Spring Boot 的关键组件是什么？

Spring Boot 包含多个关键组件，这些组件协同工作以提供简化且高效的开发体验。Spring Boot 的主要组件包括：

1. 自动配置：Spring Boot 的自动配置功能会根据类路径上检测到的依赖关系自动配置应用程序。它消除了手动配置的需要，并减少了样板代码。
2. Starter 依赖：Spring Boot 提供了一组 starter 依赖，这些依赖是预先打包的依赖，便于配置常见用例。Starters 简化了依赖项管理，并帮助开发人员快速开始使用 Web 应用程序、数据访问、安全性、测试等基本功能。
3. 嵌入式服务器：Spring Boot 包括嵌入式 servlet 容器，如 Tomcat、Jetty 和 Undertow。这些嵌入式服务器允许开发人员将应用程序打包为可执行的 JAR 文件，从而简化部署并使应用程序独立。
4. Spring Boot 执行器：Spring Boot 执行器提供用于监视和管理应用程序的生产就绪功能。它提供用于运行状况检查、指标、日志记录、跟踪等的终结点。执行器可在生产环境中轻松监控和管理应用。
5. Spring Boot 命令行界面：Spring Boot 命令行界面 （CLI） 允许开发人员使用命令行界面与 Spring Boot 应用程序进行交互。它提供了一种方便的方法，可以快速制作原型、开发和测试 Spring Boot 应用程序，而无需复杂的设置和配置。
6. Spring Boot DevTools：Spring Boot DevTools 是一组增强开发体验的工具。它包括自动应用程序重启、静态资源的实时重载和增强的错误报告等功能。DevTools 显著提高了开发人员的工作效率并加快了开发过程。
7. Spring Boot 测试：Spring Boot 为测试应用程序提供了出色的支持。它提供了各种测试实用程序，包括测试切片、模拟对象和针对不同测试框架的简单配置。Spring Boot 测试使编写和执行 Spring Boot 应用程序测试变得更加容易。

Spring 和 Spring Boot 有什么区别？

以下是 Spring 和 Spring Boot 之间的比较：

特征	Spring	Spring Boot
配置	需要手动配置	提供自动配置和合理的默认值
依赖关系管理	手动依赖项管理	使用启动器简化依赖关系管理
XML 配置	严重依赖 XML 配置	鼓励使用注解和 Java 配置
嵌入式服务器	需要手动设置和配置	包括嵌入式服务器，便于部署
自动配置	自动配置功能有限	强大的自动配置功能，可实现快速开发
开发时间	更长的开发设置和配置	使用开箱即用的默认值加快开发速度
约定优先于配置	强调配置	强调约定而不是配置
微服务支持	支持微服务架构	提供与 Spring Cloud 的无缝集成
测试支持	Spring Test 提供强大的测试支持	使用 Spring Boot Test 增强了测试支持
驱动器	执行器可作为单独的模块提供	执行器集成到核心框架中

需要注意的是，Spring 和 Spring Boot 并不相互排斥。Spring Boot 建立在 Spring 框架之上，并提供了额外的功能来简化和加速 Spring 应用程序开发。

@SpringBootApplication注释的目的是什么？

@SpringBootApplication注释结合了其他三种常用注释：@Configuration、@EnableAutoConfiguration 和 @ComponentScan。这种单一注释允许对应用程序进行简洁和简化的配置。

@SpringBootApplication注解通常放置在 Spring Boot 应用程序的主类上。它充当应用程序的入口点，并引导Spring Boot运行时环境。

什么是 Spring Boot 启动器？

Spring Boot 启动器是预配置依赖项的精选集合，可简化 Spring Boot 应用程序中特定功能的设置和配置。它们提供必要的依赖项、合理的默认配置和自动配置。

例如，spring-boot-starter-web starter 包含对 Web 相关库的依赖项，并提供用于处理 Web 请求的默认配置。Starters 简化了依赖关系管理，并确保所需的组件无缝协作。

通过在项目中加入入门程序，您可以避免手动配置，从而节省时间和精力，并获得 Spring Boot 固执己见的应用程序开发方法的好处。

常用的 Spring Boot 启动器示例

以下是一些常用的 Spring Boot 启动器示例：

1. spring-boot-starter-web：此入门器用于使用 Spring MVC 开发 Web 应用程序。它包括用于处理 HTTP 请求、管理 Web 会话和提供静态资源的依赖项。
2. spring-boot-starter-data-jpa：此入门器支持使用 Java 持久性 API （JPA） 和 Hibernate 作为默认实现进行数据访问。它包括数据库连接、实体管理和事务管理的依赖关系。
3. spring-boot-starter-security：此启动器用于向 Spring Boot 应用程序添加安全功能。它包括身份验证、授权和安全通信的依赖项。
4. spring-boot-starter-test：此入门器用于在 Spring Boot 应用程序中编写单元测试和集成测试。它包括用于测试 JUnit、Mockito 和 Spring Test 等框架的依赖项。
5. spring-boot-starter-actuator：此入门版添加了生产就绪功能来监视和管理应用程序。它包括用于运行状况检查、指标、日志记录等的终结点。
6. spring-boot-starter-data-redis：此启动器用于处理内存中数据存储 Redis。它包括用于连接到 Redis 服务器和执行数据操作的依赖关系。
7. spring-boot-starter-amqp：此初学者支持使用高级消息队列协议 （AMQP） 进行消息传递。它包括消息传递组件（如 RabbitMQ）的依赖项。
8. spring-boot-starter-mail：此启动器用于在Spring Boot应用程序中发送电子邮件。它包括与电子邮件相关的功能的依赖关系。
9. spring-boot-starter-cache：此启动器支持在 Spring Boot 应用程序中缓存数据。它包括对 Ehcache 和 Redis 等缓存框架的依赖项。
10. spring-boot-starter-oauth2-client：此入门器用于在 Spring Boot 应用程序中实现 OAuth 2.0 客户端功能。它包括用于与 OAuth 2.0 授权服务器交互的依赖项。

Spring Boot 启动器的完整列表可以在 Spring Boot 官方网站上找到。这是官方 Spring Boot Starters 文档的链接：Spring Boot Application :: Spring Boot。

Spring Boot 使用的默认嵌入式服务器是什么？

Spring Boot 使用的默认嵌入式服务器是 Apache Tomcat。Spring Boot 将 Tomcat 作为依赖项包含在内，并在使用 spring-boot-starter-web starter 或任何其他与 Web 相关的启动器时自动将其配置为默认嵌入式服务器。

如何在 Spring Boot 应用程序中配置属性？

在 Spring Boot 应用程序中，可以使用各种方法配置属性。以下是常用的方法：

1. application.properties 或 application.yml 文件：Spring Boot 允许您在 application.properties 文件（对于键值格式的属性）或 application.yml 文件（对于 YAML 格式的属性）中定义配置属性。
2. 命令行参数：Spring Boot 支持使用命令行参数配置属性。在运行应用程序时，可以将属性作为命令行参数以该格式传递。例如：。--property=valuejava -jar myapp.jar --server.port=8080
3. 环境变量：Spring Boot 可以从环境变量中读取属性。您可以使用属性名称和值定义环境变量，Spring Boot 会自动将它们映射到相应的属性。
4. 系统属性：Spring Boot 还支持使用系统属性配置属性。可以在运行应用程序时使用标志将系统属性传递给应用程序。例如：。-Djava -jar myapp.jar -Dserver.port=8080
5. @ConfigurationProperties注解：Spring Boot 提供了@ConfigurationPropertiesannotation，它允许您将外部属性直接绑定到 Java 对象。您可以定义一个用 @ConfigurationProperties 批注的配置类，并指定要绑定的属性的前缀。Spring Boot 会自动将属性映射到配置类的相应字段。

什么是 Spring Boot 自动配置，它是如何工作的？

Spring Boot 自动配置会根据类路径依赖关系自动配置应用程序上下文，从而减少手动配置的需要。它扫描类路径以查找所需的库，并设置必要的 Bean 和组件。自动配置遵循预定义的规则，并使用 @ConditionalOnClass 和 @ConditionalOnMissingBean 等注释有选择地启用配置。通过将@EnableAutoConfiguration注解添加到主应用程序类，Spring Boot 会触发自动配置过程。自动配置类通常打包在启动器中，其中包含必要的配置类和依赖项。在项目中包含启动器使 Spring Boot 能够自动配置相关组件。

Spring Boot 自动配置的好处包括：

1. 减少样板代码：自动配置消除了手动配置的需要，减少了设置常用功能所需的样板代码量。
2. 自以为是的默认值：自动配置根据最佳实践提供合理的默认值和约定。这使开发人员可以快速开始使用 Spring Boot 项目，而无需花费时间进行手动配置。
3. 与第三方库集成：自动配置与常用库和框架无缝集成，自动配置使用它们所需的必要 Bean 和组件。
4. 条件配置：自动配置根据特定类或 Bean 的存在与否有条件地应用配置。这样可以避免冲突的配置，并且仅应用相关配置。

如何使用 Spring Initializer 创建 Spring Boot 应用程序？

使用 Spring Initializr 可以轻松创建 Spring Boot 应用程序。Spring Initializr 是一个基于 Web 的工具，用于生成一个项目模板，其中包含 Spring Boot 应用程序的所有必要依赖项和配置。

要使用 Spring Initializr 轻松创建 Spring Boot 应用程序，您可以按照下列步骤操作：

1. 访问 Spring Initializr 网站：转到 Spring Initializr 官方网站，https://start.spring.io/。
2. 配置项目设置：在 Spring Initializr 网站上，您将找到用于配置项目的各种选项。提供以下详细信息：
3. 项目：选择项目类型（Maven 或 Gradle）。
4. 语言：选择编程语言（Java 或 Kotlin）。
5. Spring Boot 版本：选择所需的 Spring Boot 版本。
6. 项目元数据：指定项目的组、项目和包名称。
7. 添加依赖项：在“依赖项”部分，您可以搜索并选择项目所需的依赖项。Spring Initializr 提供了广泛的选项，例如 Spring Web、Spring Data JPA、Spring Security 等。您还可以在搜索栏中搜索特定的依赖项。
8. 生成项目：配置项目设置并添加所需的依赖项后，单击“生成”按钮。Spring Initializr 将根据您的选择生成一个可下载的项目存档（ZIP 文件）。
9. 提取项目：下载生成的 ZIP 文件并将其解压缩到计算机上所需的位置。
10. 在 IDE 中导入项目：打开首选 IDE（例如 IntelliJ IDEA、Eclipse 或 Visual Studio Code），然后将提取的项目导入为 Maven 或 Gradle 项目。
11. 开始开发：导入项目后，您可以开始开发 Spring Boot 应用程序。添加应用程序逻辑，创建控制器、服务、存储库和其他必要组件，以实现所需的功能。
12. 运行应用程序：使用 IDE 的运行配置或命令行工具运行 Spring Boot 应用程序。应用程序将启动，您可以使用提供的 URL 或终结点访问它。

什么是弹簧启动执行器？什么是不同的执行器端点？

Spring Boot 执行器是 Spring Boot 框架提供的一组生产就绪管理和监视工具。它们使您能够在运行时监视 Spring Boot 应用程序并与之交互，从而提供有关其运行状况、指标和其他各个方面的宝贵见解。

执行器公开一组 RESTful 端点，允许您访问有用的信息并在 Spring Boot 应用程序上执行某些操作。一些常用的终结点包括：

1. /actuator/health：提供有关应用程序运行状况的信息，指示应用程序是否已启动并正在运行或遇到任何问题。
2. /actuator/info：显示有关应用程序的常规信息，可以自定义这些信息以包含版本、描述和其他相关元数据等详细信息。
3. /actuator/metrics：提供有关应用程序各个方面的指标，例如内存使用率、CPU 使用率、请求/响应时间等。这些指标有助于监视和性能分析。
4. /actuator/env：显示当前环境属性及其值，包括来自外部源（如 application.properties 或环境变量）的配置属性。
5. /actuator/loggers：允许您动态查看和修改应用程序记录器的日志记录级别。这对于故障排除和调试目的非常有用。
6. /actuator/mappings：显示应用程序公开的所有终结点的详细映射，包括每个终结点支持的 HTTP 方法。
7. /actuator/beans：提供应用程序中所有 Spring Bean 的完整列表，包括它们的名称、类型和依赖关系等信息。

解释 Spring Boot 配置文件的概念以及如何使用它们

Spring Boot 配置文件提供了一种管理不同环境或部署方案的应用程序配置的方法。使用配置文件，您可以为开发、测试、生产和任何其他特定环境定义不同的配置集。

以下是 Spring Boot 配置文件的工作原理以及如何使用它们的简要说明：

1. 定义配置文件：在 Spring Boot 应用程序中，可以通过为每个环境创建单独的属性文件来定义配置文件。例如，您可以将 application-dev.properties 用于开发环境，将 application-test.properties 用于测试，将 application-prod.properties 用于生产环境。
2. 激活配置文件：可以通过多种方式激活配置文件：
3. 通过在application.properties中设置spring.profiles.active属性，或在启动应用程序时将其设置为命令行参数。
4. 通过在测试中使用类级别的@ActiveProfiles注释。
5. 通过使用系统环境变量或 JVM 系统属性来指定活动概要文件。
6. 特定于配置文件的配置：激活配置文件后，Spring Boot将加载相应的属性文件并应用其中定义的配置。例如，如果 devprofile 处于活动状态。Spring Boot 将加载 application-dev.properties 文件并应用其中定义的配置。
7. 覆盖配置：特定于配置文件的配置可以覆盖 application.properties 或其他属性文件中定义的默认配置。这允许您专门为每个环境自定义某些设置，而无需修改核心应用程序代码。
8. Bean 和组件扫描：Bean 和组件扫描：配置文件还可用于控制 Bean 和组件扫描过程。您可以使用 @Profile 注释 Bean 或组件，以指定仅在特定配置文件处于活动状态时才应创建和注册它们。
9. Spring Boot 的默认配置文件：Spring Boot 提供了一些默认配置文件，例如 default、dev、test 和 prod。默认配置文件始终处于活动状态，其他配置文件可以根据部署环境激活。

Spring Boot 中常用的注解有哪些？

以下是一些常用的 Spring Boot 注解：

1. @SpringBootApplication：此注解用于标记 Spring Boot 应用程序的主类。它结合了三个注释：@Configuration、@EnableAutoConfiguration 和 @ComponentScan。它支持在应用程序中进行自动配置和组件扫描。
2. @RestController：此注解用于指示类是 RESTful 控制器。它结合了@Controller和@ResponseBody注释。它简化了 RESTful Web 服务的开发，无需用 @ResponseBody 注释每个方法。
3. @RequestMapping：此注解用于将 HTTP 请求映射到特定的处理程序方法。它可以在类级别应用，为类中的所有方法指定基 URL，也可以在方法级别应用，为特定处理程序方法定义 URL 和 HTTP 方法。
4. @Autowired：此注解用于自动将依赖项连接到 Spring 管理的 Bean 中。它允许 Spring 自动发现并注入所需的 bean，而无需显式 bean 配置。
5. @Value：此注解用于将属性文件或环境变量中的值注入 Spring Beans。它可用于注入简单的值，如字符串或数字，以及复杂的对象。
6. @Configuration：此注解用于指示类为 Spring 应用程序上下文提供配置。它通常与 @Bean 结合使用，以定义 Bean 和其他配置元素。
7. @ComponentScan：此注解用于指定要扫描 Spring 组件（如控制器、服务和存储库）的基本包。它允许 Spring 在应用程序上下文中自动发现和注册这些组件。
8. @EnableAutoConfiguration：此注解启用了 Spring Boot 的自动配置机制，该机制会根据依赖关系和类路径自动配置各种组件和 bean。
9. @Conditional：此注解用于根据特定条件有条件地启用或禁用 Bean 和配置。它允许您根据特定条件或环境设置自定义应用程序的行为。

中级 Spring Boot 面试问题

@ConfigurationProperties注释有什么用？

Spring Boot 中的@ConfigurationProperties注用于将外部配置属性绑定到 Java 类。它提供了一种将配置文件（如 application.properties 或 application.yml）中定义的属性映射到配置类中的相应字段的便捷方法。

使用@ConfigurationProperties的好处包括：

1. 类型安全：注释可确保配置属性绑定到配置类中定义的相应类型，从而防止类型不匹配和潜在的运行时错误。
2. 属性验证：属性验证：您可以使用 Spring 提供的各种验证注释来验证属性，例如 @NotNull、@Min、@Max 和自定义验证。
3. 分层属性映射：您可以定义嵌套配置类来表示复杂的配置结构，并将它们分层映射到相应的属性。
4. 易于集成：带注释的配置类可以很容易地自动连接并在整个应用程序中使用，从而简化了不同组件中配置值的检索。

下面是一个使用示例：@ConfigurationProperties

@Configuration
@ConfigurationProperties(prefix = "myapp")
public class MyAppConfiguration {
    private String name;
    private int port;

    // Getters and setters

    // Other custom methods or business logic
}

# Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=myusername
spring.datasource.password=mypassword

# Server Configuration
server.port=8080
server.servlet.context-path=/myapp

# Custom Application Properties
myapp.name=My Application
myapp.api.key=abc123在此示例中，MyAppConfiguration 类使用 @ConfigurationProperties 进行批注，并指定前缀“myapp”。配置文件中以前缀“myapp”定义的属性将绑定到此类中的相应字段。

Spring Boot 如何支持微服务架构？

Spring Boot 为构建基于微服务的应用程序提供了广泛的支持。它提供了一系列功能和集成，可简化微服务的开发、部署和管理。以下是 Spring Boot 支持微服务架构的方式：

1. Spring Cloud：Spring Boot 与 Spring Cloud 无缝集成，Spring Cloud 是一组旨在构建和运行云原生微服务的工具和框架。Spring Cloud 提供服务发现、客户端负载均衡、分布式配置管理、熔断机制等功能。
2. 微服务设计模式：Spring Boot 采用微服务设计模式，例如使用 RESTful API 进行服务之间的通信、无状态服务以实现可扩展性以及去中心化数据管理。它提供了一个轻量级和灵活的框架，使开发人员能够轻松实现这些模式。
3. 服务注册和发现：Spring Boot 与服务注册和发现工具集成，例如 Netflix Eureka 和 Consul。这些工具允许微服务将自己注册到注册表中，并动态发现其他服务。这有助于实现服务弹性、负载均衡和自动服务发现。
4. 外部化配置：Spring Boot支持外部化配置，可以根据环境或特定部署需求轻松配置微服务。它支持将配置与代码分离，从而更轻松地跨多个微服务管理配置属性。
5. 分布式跟踪和监控：Spring Boot 与 Zipkin 和 Sleuth 等分布式跟踪系统集成，支持跨多个微服务跟踪请求。它还提供与 Prometheus 和 Grafana 等监控工具的集成，以监控微服务的运行状况、性能和资源使用情况。
6. 复原能力和容错能力：Spring Boot 支持使用断路器（例如 Netflix Hystrix）等功能实现容错微服务，这有助于防止分布式系统中的级联故障。它还提供了用于处理微服务交互中的重试、超时和回退的机制。
7. 容器化和部署：Spring Boot 应用程序可以使用 Docker 等技术轻松容器化，从而允许使用 Kubernetes 等容器编排平台无缝部署和扩展微服务。

什么是 Spring Data？Spring Boot 中使用哪些不同的 Spring Data Starters？

Spring Data 是 Spring Framework 的一个子项目，它通过为不同的数据存储技术提供统一的编程模型来简化数据访问。它减少了样板代码，并允许开发人员专注于业务逻辑。Spring Data 支持关系数据库、NoSQL 数据库等。它利用存储库来抽象数据访问操作，无需手动 CRUD 代码。Spring Data的启动器为特定数据库提供预配置的依赖项和自动配置，从而简化了设置过程。借助 Spring Data，开发人员可以轻松地与数据源进行交互，并从其强大的查询功能中受益。

以下是适用于不同类型数据库的 Spring Data 启动器的一些示例：

1. spring-boot-starter-data-jpa：此入门器提供对 Java 持久性 API （JPA） 和 Hibernate 的支持。它包括使用 JPA 处理关系数据库所需的依赖关系和配置。
2. spring-boot-starter-data-mongodb：此启动器提供对 MongoDB（一种流行的 NoSQL 数据库）的支持。它包括使用 Spring Data MongoDB 处理 MongoDB 所需的依赖项和配置。
3. spring-boot-starter-data-redis：此启动器提供对 Redis 的支持，Redis 是一种内存中数据结构存储。它包括使用 Spring Data Redis 处理 Redis 所需的依赖项和配置。
4. spring-boot-starter-data-cassandra：此入门器提供对 Apache Cassandra 的支持，这是一个高度可扩展的 NoSQL 数据库。它包括使用 Spring Data Cassandra 处理 Cassandra 所需的依赖项和配置。
5. spring-boot-starter-data-elasticsearch：此入门器提供对分布式搜索和分析引擎 Elasticsearch 的支持。它包括使用 Spring Data Elasticsearch 处理 Elasticsearch 所需的依赖项和配置。

如何在 Spring Boot 应用程序中使用 RESTful Web 服务？

在 Spring Boot 应用程序中，您可以使用 RestTemplate 或 WebClient 使用 RESTful Web 服务。RestTemplate 提供了用于发出 HTTP 请求的同步 API，而 WebClient 提供了一种非阻塞和反应式方法。两者都允许您发送 GET、POST、PUT、DELETE 请求、处理响应数据并将其反序列化为 Java 对象。

如何为 Spring Boot 应用程序创建和运行单元测试？

在 Spring Boot 应用程序中，您可以使用 Spring Test 框架创建和运行单元测试。通过利用 @RunWith（SpringRunner.class） 和 @SpringBootTest 等注释，您可以初始化应用程序上下文并对 Bean 和组件执行测试。

此外，您可以使用 Mockito 或其他模拟框架来模拟依赖项并隔离被测单元。借助 JUnit 或 AssertJ 的断言，可以验证预期的行为和断言。

最后，可以使用 Maven 或 Gradle 等工具运行测试，这些工具执行测试并提供有关测试结果和覆盖率的报告。

如何在Spring Boot应用程序中启用调试日志？

若要在 Spring Boot 应用程序中启用调试日志，可以将 application.properties 或 application.yml 文件中的 logging.level 属性设置为“DEBUG”。此配置将使日志记录框架能够输出详细的调试信息。或者，您可以对类使用@Slf4j注释来启用该特定类的日志记录。此外，还可以通过设置 logging.level 来配置特定包或类的日志记录级别。{package/class} 属性。

若要为整个应用程序启用调试日志，请使用：

logging.level.<package-name>=DEBUG

若要为整个应用程序启用调试日志，请使用：

logging.level.root=DEBUG

Spring Boot 中如何支持响应式编程

Spring Boot 通过与 Spring WebFlux 模块的集成来支持响应式编程。它允许开发人员构建非阻塞、事件驱动的应用程序，这些应用程序可以有效地处理大量并发请求，利用反应式流和反应式编程模型。

如何在 Spring Boot 应用程序中启用安全性？

我们可以使用以下不同的选项。

1. 使用 Spring Security： 通过将 Spring Security Starter 依赖项添加到项目的构建配置中来启用安全性。
2. OAuth2 和 OpenID 连接：使用 OAuth2 和 OpenID Connect 协议实现安全身份验证和授权。
3. LDAP集成： 通过与 LDAP（轻量级目录访问协议）服务器集成以进行用户身份验证和授权来启用安全性。
4. JWT（JSON Web 令牌）身份验证：通过实施基于 JWT 的身份验证来实现无状态和可扩展的身份验证，从而实现安全性。
5. 自定义身份验证提供程序：通过创建自定义身份验证提供程序来根据您自己的逻辑处理身份验证，从而实现安全性。

Spring Boot DevTools 的目的是什么？我们如何启用它？

它旨在提高生产力，简化开发工作流程，并在开发阶段实现应用程序快速重启。

以下是 Spring Boot DevTools 的一些主要功能和优势：

1. 自动重启：DevTools 监视类路径中是否有任何更改，并在检测到修改时自动重启应用程序。
2. 实时重载：DevTools 支持实时重载静态资源，如 HTML、CSS、JavaScript 文件。
3. 远程应用程序重启：DevTools 提供远程触发应用程序重启的功能。在分布式环境中工作或应用程序在远程服务器上运行时，这可能很有用。
4. 开发人员友好的错误页：DevTools 提供了一个增强的错误页，提供有关应用程序开发过程中遇到的异常和错误的详细信息。
5. 配置属性支持：DevTools 支持热重载 Spring Boot 配置属性。对 application.properties 或 application.yml 文件所做的更改将自动应用，而无需重新启动应用程序，从而允许快速更新配置。
6. 数据库控制台：DevTools 包括一个嵌入式数据库控制台，该控制台提供基于 Web 的界面来与应用程序的数据库进行交互。这使开发人员能够轻松执行 SQL 查询、查看和修改数据以及执行其他与数据库相关的任务，而无需外部工具。

若要在 Spring Boot 应用程序中启用 Spring Boot DevTools，需要包含相应的依赖项和配置。下面是启用 DevTools 的步骤：

添加 DevTools 依赖项：在 pom.xml 文件（适用于 Maven）或 build.gradle 文件（适用于 Gradle）中，添加以下依赖项：

<!-- Maven -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

// Gradle
implementation 'org.springframework.boot:spring-boot-devtools'

启用自动重启：默认情况下，为使用 spring-boot：run 命令或从 IDE 运行的应用程序启用 DevTools。但是，您也可以通过将以下配置属性添加到 application.properties 或 application.ymlfile 中来为打包的应用程序启用它：

spring.devtools.restart.enabled=true

有经验的人的高级 Spring Boot 面试问题

如何在 Spring Boot 应用程序中启用 HTTPS？

若要在 Spring Boot 应用程序中启用 HTTPS，需要配置应用程序的服务器属性并提供必要的 SSL/TLS 证书。以下是启用 HTTPS 的一般步骤：

• 获取 SSL/TLS 证书：从受信任的证书颁发机构 （CA） 获取 SSL/TLS 证书或生成用于开发/测试目的的自签名证书。
• 配置服务器属性：使用以下服务器配置更新application.properties 或者 application.yml文件：

server.port=8443
server.ssl.key-store-type=PKCS12
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=your_keystore_password
server.ssl.key-alias=your_alias_name

在上面的示例中，替换为密钥库文件的路径，并设置适当的密码和别名值。keystore.p12

• 提供 SSL/TLS 证书：将 SSL/TLS 证书文件 （） 放在类路径中，或在服务器属性中指定绝对文件路径。keystore.p12
• 重新启动应用程序：重新启动 Spring Boot 应用程序以使更改生效。
• 完成这些步骤后，Spring Boot 应用程序将配置为使用 HTTPS。您可以使用 https://localhost:8443 或服务器配置中指定的相应主机名和端口访问应用程序。

如何在 Spring Boot 中配置外部配置

若要在 Spring Boot 中配置项目外部的外部配置，可以使用以下方法之一：

1. 外部配置文件：您可以使用 spring.config.name 和 spring.config.location 属性指定外部配置文件的位置，而不是将 application.properties 或 application.ymlfile 放在项目中。例如，您可以将配置文件放在单独的目录中，并通过命令行或环境变量提供其位置。
2. 操作系统环境变量：您可以利用操作系统提供的环境变量来配置 Spring Boot 应用程序。将所需的配置属性定义为环境变量，并使用@Value注释或 Environment 对象在应用程序中访问它们。
3. Spring Cloud Config：如果您有更复杂的配置设置或需要集中配置管理，则可以使用 Spring Cloud Config。它提供了一个服务器端组件，您可以在其中存储和管理多个应用程序的配置。然后，您的 Spring Boot 应用程序可以从 Spring Cloud Config 服务器获取其配置。
4. 配置服务器：另一种选择是使用外部配置服务器，如 Apache ZooKeeper 或 HashiCorp Consul。这些服务器充当配置的中央存储库，可由多个应用程序访问。

如何使用 Maven 创建 Spring Boot 应用程序？

若要使用 Maven 创建 Spring Boot 应用程序，请按照下列步骤操作：

设置 Maven：确保系统上安装了 Maven。您可以从 Apache Maven 网站下载 Maven 并按照安装说明进行操作。

创建 Maven 项目：打开命令行或终端，然后导航到要创建项目的目录。使用以下 Maven 命令创建新项目：

mvn archetype:generate -DgroupId=com.example -DartifactId=my-spring-boot-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

此命令使用指定的 groupId 和 artifactId 创建新的 Maven 项目。根据项目需求调整这些值。

添加 Spring Boot Starter 依赖项：打开项目的pom.xml文件，并为 Spring Boot 添加以下依赖项：

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

此依赖项包括应用程序所需的 Spring Boot 库。

创建 Spring Boot 主类：在 Maven 项目的相应包中创建一个新的 Java 类。此类将用作 Spring Boot 应用程序的入口点。下面是一个示例：

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MySpringBootApplication {

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

该@SpringBootApplication注解结合了基本 Spring Boot 应用程序所需的多个注解。

生成并运行应用程序：使用以下 Maven 命令生成并运行 Spring Boot 应用程序：

mvn spring-boot:run

Maven 将构建您的项目，解析依赖项，并启动 Spring Boot 应用程序。

应用程序运行后，您可以使用http://localhost:8080（默认情况下）或指定的端口（如果您已自定义）在 Web 浏览器中访问它。

就是这样！您已使用 Maven 创建了 Spring Boot 应用程序。现在，您可以添加其他依赖项、配置应用程序并开发所需的功能。

条件注释有哪些不同类型？

Spring Boot 中一些常用的条件注解是：

1. @ConditionalOnClass：如果类路径中存在特定类，则此注释将配置 Bean 或组件。
2. @ConditionalOnMissingClass：如果类路径中不存在特定类，则此注释将配置 Bean 或组件。
3. @ConditionalOnBean：仅当应用程序上下文中存在另一个特定 Bean 时，此注释才配置 Bean 或组件。
4. @ConditionalOnMissingBean：仅当应用程序上下文中不存在另一个特定 Bean 时，此注释才配置 Bean 或组件。
5. @ConditionalOnProperty：此注解根据应用程序配置文件中特定属性的值配置 Bean 或组件。
6. @ConditionalOnExpression：此注解基于 SpEL（Spring 表达式语言）表达式配置 Bean 或组件。
7. @ConditionalOnWebApplication：仅当应用程序是 Web 应用程序时，此注释才配置 Bean 或组件。
8. @ConditionalOnNotWebApplication：仅当应用程序不是 Web 应用程序时，此注释才配置 Bean 或组件。

您能否解释一下 Spring Boot 执行器运行状况检查以及创建自定义运行状况指示器的过程？

运行状况检查提供有关应用程序整体运行状况的宝贵信息，例如数据库连接、外部服务可用性或您定义的任何其他自定义检查。

默认情况下，Spring Boot Actuator 提供一组预定义的运行状况指示器，用于检查各种组件（如数据库、磁盘空间等）的运行状况。但是，您也可以创建自定义运行状况指示器来监视应用程序的特定方面。

要创建自定义运行状况指示器，您需要实现 HealthIndicator 接口并覆盖 health（） 方法。health（） 方法应返回一个 Health 实例，该实例表示自定义组件的运行状况。可以使用 Health 类来指示组件是启动、关闭还是处于未知状态。

下面是自定义运行状况指示器的示例：

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class CustomHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        // 在此处执行自定义运行状况检查逻辑
        boolean isHealthy = true; // 替换为实际运行状况检查逻辑

        if (isHealthy) {
            return Health.up().build();
        } else {
            return Health.down().withDetail("CustomComponent", "Not Healthy").build();
        }
    }
}

在此示例中，CustomHealthIndicator 类实现 HealthIndicator 接口并重写 health（） 方法。在 health（） 方法中，您可以编写自定义运行状况检查逻辑。如果组件运行正常，则可以返回 Health.up（）。否则，您可以使用 withDetail（） 方法返回 Health.down（） 以及其他详细信息。

创建自定义运行状况指示器后，Spring Boot Actuator 将自动检测到它，并通过 /actuator/health 端点公开其运行状况检查。

如何在 Spring Boot 中创建自定义执行器端点？

要在 Spring Boot 中创建自定义 Actuator 端点，您可以按照下列步骤操作：

1. 创建自定义终结点：创建一个表示自定义终结点的新类。此类应使用 @Endpoint 进行批注，以指示它是执行器端点。您还可以使用其他注释（如 @ReadOperation、@WriteOperation 或 @DeleteOperation）来定义终端节点支持的操作类型。
2. 定义终结点操作：在自定义终结点类中，定义终结点应执行的操作。您可以将 @ReadOperation 等注释用于只读操作，将 @WriteOperation 用于写入操作，将 @DeleteOperation 用于删除操作。这些注释有助于定义终结点的 HTTP 方法和请求映射。
3. 实现终结点逻辑：为自定义终结点的每个操作实现逻辑。这可能包括检索信息、修改应用程序状态或执行任何其他所需的操作。您可以根据特定要求灵活地定义功能。
4. （可选）添加安全配置：如果自定义终结点需要安全限制，则可以通过添加安全注释或修改应用程序的安全配置来配置它。

下面是创建自定义执行器端点的示例：

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.boot.actuate.endpoint.annotation.WriteOperation;
import org.springframework.stereotype.Component;

@Component
@Endpoint(id = "customEndpoint")
public class CustomEndpoint {

    @ReadOperation
    public String getInformation() {
        // 检索和返回信息
        return "这是自定义终结点信息。";
    }

    @WriteOperation
    public void updateInformation(String newInformation) {
        // 更新信息
        // ...
    }
}

在此示例中，CustomEndpoint 类使用 @Endpoint 进行批注，以将其定义为 Actuator 终结点。它有两个操作：getInformation（） 用 @ReadOperation 注释用于检索信息，updateInformation（） 用 @WriteOperation 注释用于更新信息。

创建自定义终结点后，它将自动注册到 Spring Boot Actuator，您可以通过 /actuator 基本路径和终结点 ID 访问它。在这种情况下，可以通过 /actuator/customEndpoint 访问自定义终结点。

如何在 Spring Boot 应用程序中启用 CORS（跨域资源共享）？

若要在 Spring Boot 应用程序中启用跨域资源共享 （CORS），可以执行以下步骤：

添加 CORS 配置：创建一个配置类并使用 @Configuration 对其进行批注以定义 CORS 配置。在类中，创建一个 CorsFilter 类型的 Bean 来配置 CORS 设置。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class CorsConfig {

    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();

        // 允许来自任何来源的请求
        config.addAllowedOrigin("*");

        // 允许特定的 HTTP methods (e.g., GET, POST, PUT, DELETE)
        config.addAllowedMethod("*");

        // 允许特定的 HTTP headers
        config.addAllowedHeader("*");

        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }
}

在此示例中，我们将 CORS 配置为允许来自任何源 的请求、允许所有 HTTP 方法 和允许所有 HTTP 标头 。您可以根据特定要求自定义这些设置。

启用 Web MVC 配置：如果尚未启用此操作，请确保通过在配置类上使用 @EnableWebMvc 注释或扩展 WebMvcConfigurerAdapter 类，在 Spring Boot 应用程序中启用 Web MVC 配置。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    // 如果需要，其他 Web MVC 配置
}

测试 CORS 配置：在 Spring Boot 应用程序中启用 CORS 后，可以通过向终端节点发出跨域请求来测试它。确保响应中包含必要的 CORS 标头，例如 Access-Control-Allow-Origin、Access-Control-Allow-Methods 和 Access-Control-Allow-Headers。

启用 CORS 后，Spring Boot 应用程序可以处理跨域请求并做出适当的响应。请务必考虑安全隐患，并根据应用程序的要求和安全策略配置 CORS 设置。

如何在 Spring Boot 应用程序中安排任务？

在 Spring Boot 应用程序中，您可以使用 Spring 的任务调度功能提供的@Scheduled注解来调度任务。以下是在 Spring Boot 应用程序中计划任务的方法：

启用计划：首先，确保在 Spring Boot 应用程序中启用了任务计划。这可以通过在配置类上使用 @EnableScheduling 注释或在主应用程序类上添加@SpringBootApplication注释以及@EnableScheduling来完成。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class MyAppApplication {

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

创建计划任务方法：在应用程序中定义要计划的方法。用 @Scheduled 注释方法，并使用 cron、固定延迟或固定速率指定所需的调度表达式。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyScheduledTasks {

    @Scheduled(cron = "0 0 8 * * *") //每天早上 8 点跑
    public void executeTask() {

        System.out.println("计划任务已执行！");
    }
}

在此示例中，该executeTask()方法计划根据提供的 cron 表达式在每天上午 8 点运行。

测试计划任务：定义计划任务后，可以启动 Spring Boot 应用程序并观察根据指定计划执行的计划任务。

@Scheduled注释提供了多个用于指定调度表达式的选项，包括 cron 表达式、固定延迟和固定速率。您可以根据计划要求选择最合适的选项。

如何在 Spring Boot 应用程序中启用缓存？

若要在 Spring Boot 应用程序中启用缓存，可以按照下列步骤操作：

添加缓存依赖项：确保必要的缓存依赖项包含在项目的依赖项中。Spring Boot 支持各种缓存提供程序，例如 Ehcache、Redis 和 Caffeine。将相应的缓存依赖项添加到项目的pom.xml文件中。

例如，要使用 Ehcache 缓存提供程序，请添加以下依赖项：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

启用缓存：要在 Spring Boot 应用程序中启用缓存，请@EnableCaching将注释添加到配置类中。此注解启用了 Spring 的缓存基础结构，并为应用程序准备了缓存。

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CachingConfig {
    //其他配置
}

批注缓存方法：确定应用程序中要缓存的方法，并使用适当的缓存批注对其进行批注。Spring Boot 为缓存操作提供了 @Cacheable、@CachePut 和 @CacheEvict 等注释。

例如，假设您有一个从数据库检索数据的方法，并且您想要缓存结果。可以使用 @Cacheable 对方法进行批注并指定缓存名称。

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class DataService {

    @Cacheable("dataCache")
    public Data getData(String key) {
        // 从数据库或外部服务获取数据的逻辑
        return data;
    }
}

在此示例中，getData（） 方法使用 @Cacheable 进行注释，并将缓存名称指定为“dataCache”。首次使用特定键调用此方法时，将提取并缓存数据。使用相同键的后续调用将从缓存中检索数据，而不是执行该方法。

配置缓存设置：如果需要自定义缓存行为，可以提供特定于所选缓存提供程序的其他配置属性。可以在 application.properties 或 application.yml 文件中设置这些配置属性。

例如，如果您使用的是 Ehcache，则可以在 ehcache.xml 文件中配置缓存设置，并在 application.properties 文件中指定文件的位置。

通过执行这些步骤，您可以在 Spring Boot 应用程序中启用缓存，并利用缓存的优势来提高性能并减少数据库或外部服务调用。