2023 年面向程序员和软件工程师的 Spring Boot 关键面试问题

【关于TalkX】

TalkX是一款基于GPT实现的IDE智能开发插件，专注于编程领域，是开发者在日常编码中提高编码效率及质量的辅助工具，TalkX常用的功能包括但不限于：解释代码、中英翻译、性能检查、安全检查、样式检查、优化并改进、提高可读性、清理代码、生成测试用例等。

TalkX建立了全球加速网络，不需要考虑网络环境，响应速度快，界面效果和交互体验更流畅。并为用户提供了OpenAI的密钥，不需要ApiKey，不需要自备账号，不需要魔法。

TalkX产品支持：JetBrains (包括 IntelliJ IDEA、PyCharm、WebStorm、Android Studio)、HBuilder、VS Code、Goland.

What are the steps to connect an external database like MySQL or Oracle?

连接 MySQL 或 Oracle 等外部数据库的步骤是什么？

To connect an external database like MySQL or Oracle in a Spring Boot application, you can follow these steps

要在 Spring Boot 应用程序中连接 MySQL 或 Oracle 等外部数据库，可以按照以下步骤操作

1. Include Database Driver Add the corresponding database driver dependency for MySQL or Oracle in your project’s pom.xml (Maven) or build.gradle (Gradle) file.

1. 包含数据库驱动程序 在项目的 pom.xml (Maven) 或 build.gradle (Gradle) 文件中添加相应的 MySQL 或 Oracle 数据库驱动程序依赖关系。

2. Configure Connection Properties In your application.properties or application.yml file, specify the necessary configuration properties for the database connection. These properties typically include the URL, username, password, and driver class specific to the database you are connecting to.

2. 配置连接属性 在 application.properties 或 application.yml 文件中，为数据库连接指定必要的配置属性。这些属性通常包括 URL、用户名、密码和所连接数据库的特定驱动程序类。

3. Use Spring Data JPA (optional) If you plan to use Spring Data JPA for database operations, include the necessary dependencies and configure the entity classes, repositories, and other JPA-related settings.

3. 使用 Spring Data JPA（可选） 如果计划使用 Spring Data JPA 进行数据库操作，请包含必要的依赖关系并配置实体类、存储库和其他 JPA 相关设置

4. Create Data Source Bean Create a bean that defines the data source configuration for the external database. In this bean, set the required properties such as URL, username, password, and driver class.

4. 创建数据源 Bean 创建一个定义外部数据库数据源配置的 Bean。在此 Bean 中，设置所需的属性，如 URL、用户名、密码和驱动程序类。

5. Inject Data Source Inject the data source bean into the appropriate components or repositories that need database access. You can use dependency injection annotations like @Autowired or constructor injection to obtain a reference to the data source.

5. 注入数据源 将数据源 Bean 注入到需要访问数据库的相应组件或资源库中。您可以使用依赖注入注解（如 @Autowired 或构造器注入）来获取对数据源的引用。

6. Perform Database Operations With the data source configured and injected, you can now use JDBC, JPA, or other database frameworks to perform database operations, execute queries, and interact with the external database.

6. 执行数据库操作 在配置并注入数据源后，您现在可以使用 JDBC、JPA 或其他数据库框架来执行数据库操作、执行查询并与外部数据库交互。

Inversion of Control vs Dependency Injection?

反转控制与依赖注入的区别是什么？

Inversion of Control (IoC) is a broader design principle that aims to invert the control of object creation and management from the application code to a container or framework. It promotes loose coupling and modular design by delegating the responsibility of creating and managing dependencies to an external entity.

控制反转（IoC）是一种更广泛的设计原则，旨在将对象创建和管理的控制权从应用程序代码反转到容器或框架。它将创建和管理依赖关系的责任委托给外部实体，从而促进松散耦合和模块化设计。

Dependency Injection (DI) is a specific implementation of IoC, where dependencies are “injected” into a class rather than being created internally. DI is a way to achieve IoC by allowing dependencies to be provided from external sources, such as through constructor parameters, setter methods, or interfaces.

依赖注入（DI）是 IoC 的一种特定实现，其中依赖被 "注入 "到类中，而不是在内部创建。DI 是实现 IoC 的一种方法，它允许从外部来源（如通过构造器参数、设置器方法或接口）提供依赖关系。

What is Bean in Spring Boot?

Spring Boot中的Bean是什么？

In Spring Boot, a “bean” is simply a Java object managed by the Spring framework’s Inversion of Control (IoC) container. These beans are created, configured, and managed by the Spring framework, and they typically represent components or services used in your application. Beans can be defined using annotations or XML configuration and are automatically wired together by Spring, allowing for easy dependency injection and modular application design.

在 Spring Boot 中，"Bean "是由 Spring 框架的反转控制 (IoC) 容器管理的 Java 对象。这些 Bean 由 Spring 框架创建、配置和管理，通常代表应用程序中使用的组件或服务。豆可以使用注解或 XML 配置来定义，并由 Spring 自动连接在一起，从而实现轻松的依赖注入和模块化应用设计。

Explain about Bean LifeCycle.

解释 Bean 生命周期。

The lifecycle of a bean in the Spring framework consists of several key phases:

Spring 框架中 bean 的生命周期包括几个关键阶段：

1. Instantiation: This is the creation of a bean instance. It can happen through constructors, factory methods, or other means.

1. 实例化： 即创建 bean 实例。可以通过构造函数、工厂方法或其他方式进行。

2. Population of Properties: Once the bean is created, Spring sets its properties and dependencies.

2. 填充属性： 创建 Bean 后，Spring 会设置其属性和依赖关系。

3. Bean Post-Processing: This is an optional step where you can apply custom logic before and after initialization. You can implement interfaces like BeanPostProcessor for this.

3. Bean 后处理： 这是一个可选步骤，您可以在初始化前后应用自定义逻辑。为此，您可以实现 "BeanPostProcessor "等接口。

4. Initialization: After properties are set, the bean’s init method is called, if defined. This is where you can perform any initialization tasks.

4. 初始化： 属性设置完成后，如果定义了 bean 的 init 方法，则会调用该方法。您可以在此执行任何初始化任务。

5. In Use: The bean is now available for use in your application. Other beans can inject it, and your application can use its functionality.

5. 使用中：现在，您可以在应用程序中使用 bean。其他 Bean 可以注入它，您的应用程序也可以使用它的功能。

6. Destruction: When the application context is closed or explicitly, the bean’s destroy method, if defined, is called to release resources and perform cleanup.

6. 销毁： 当应用程序上下文关闭或显式关闭时，Bean 的 "销毁 "方法（如果已定义）将被调用，以释放资源并执行清理。

These phases represent the lifecycle of a Spring bean, allowing you to control and customize its behavior at various points, like setting properties, initializing resources, and cleaning up when no longer needed.

这些阶段代表了 Spring Bean 的生命周期，允许您在不同阶段控制和自定义其行为，如设置属性、初始化资源以及在不再需要时进行清理。

Explain about different types of beans.

解释不同类型的Beans：

Different Types of Beans:

不同类型的Beans：

1. Singleton Bean: A singleton bean is a single instance of a bean per Spring IoC container. It is created once and shared by multiple requests or references within the application context.

1. 单例 Bean： 单例 Bean 是每个 Spring IoC 容器的一个 Bean 实例。它只创建一次，并由应用程序上下文中的多个请求或引用共享。

2. Prototype Bean: A prototype bean is a new instance of a bean created each time it is requested from the Spring IoC container. Each request for a prototype bean results in the creation of a new instance

2. 原型 Bean： 原型 Bean 是每次从 Spring IoC 容器请求时创建的 Bean 新实例。每次请求原型 Bean 都会创建一个新实例。

3. Request Bean: A request bean is tied to the lifecycle of an HTTP request in web applications. It is created and made available for the duration of a single HTTP request and is destroyed afterward.

3. 请求 Bean： 请求 Bean 与网络应用中 HTTP 请求的生命周期息息相关。它在单个 HTTP 请求的持续时间内创建并可用，之后被销毁。

4. Session Bean: A session bean is tied to the lifecycle of an HTTP session in web applications. It is created when a new session is started and remains active until the session is invalidated or expired.

4. 会话 Bean： 会话 Bean 与网络应用程序中 HTTP 会话的生命周期相关联。它在新会话开始时创建，并保持激活状态，直到会话失效或过期。

5. Application Bean: An application bean is tied to the lifecycle of a Spring application context. It is created when the application context is initialized and destroyed when the application context is closed.

5. 应用程序 Bean： 应用程序 Bean 与 Spring 应用程序上下文的生命周期相关联。它在应用上下文初始化时创建，并在应用上下文关闭时销毁。

These are some commonly used types of beans in Spring. Each bean type has its own lifecycle and scope, providing flexibility in managing object instances based on the application’s requirements.

以上是 Spring 中一些常用的 Bean 类型。每种 Bean 类型都有自己的生命周期和范围，可根据应用程序的要求灵活管理对象实例。

What is graceful shutdown in Spring Boot?

什么是 Spring Boot 中的优雅关闭？

Graceful shutdown in Spring Boot refers to the process of gracefully stopping a running Spring Boot application, allowing it to complete its ongoing tasks and clean up resources before shutting down. It ensures that all active requests are processed or interrupted in a controlled manner, preventing abrupt termination.

Spring Boot 中的优雅关机是指优雅地停止运行中的 Spring Boot 应用程序，使其在关闭前完成正在进行的任务并清理资源的过程。它能确保以受控方式处理或中断所有活动请求，防止突然终止。

During a graceful shutdown, Spring Boot initiates a sequence of steps to gracefully stop the application. These steps may include

在优雅关机过程中，Spring Boot 会启动一系列步骤来优雅地停止应用程序。这些步骤可能包括：

1. Rejecting New Requests The application stops accepting new requests, ensuring that no new tasks are initiated.

1. 拒绝新请求 应用程序停止接受新请求，确保不会启动新任务。

2. Waiting for Active Requests to Complete The application waits for the ongoing requests to finish processing. This allows the application to complete any pending tasks or operations.

2. 等待活动请求处理完毕 应用程序等待正在处理的请求处理完毕。这样，应用程序就可以完成任何待处理的任务或操作。

3. Shutting Down Components Once all active requests are completed, the application proceeds to shut down its components, releasing resources, closing connections, and performing any necessary cleanup.

3. 关闭组件 一旦完成所有活动请求，应用程序就会关闭其组件、释放资源、关闭连接并执行必要的清理工作。

4. Notifying External Systems Optionally, the application may notify external systems, such as service registries or load balancers, to mark the application as unavailable during the shutdown process.

4. 通知外部系统 应用程序可选择通知外部系统（如服务注册表或负载平衡器），将应用程序标记为在关闭过程中不可用。

Graceful shutdown is particularly important in scenarios where the application needs to perform cleanup tasks, release resources, or ensure data consistency. It helps prevent data loss, incomplete operations, or unexpected behavior during application shutdown.

在应用程序需要执行清理任务、释放资源或确保数据一致性的情况下，优雅关机尤为重要。它有助于防止在应用程序关闭期间出现数据丢失、操作不完整或意外行为。

Spring Boot provides mechanisms and hooks, such as the ApplicationContext events, SmartLifecycle interface, or custom shutdown hooks, to facilitate graceful shutdown in applications. These mechanisms allow developers to define custom behavior and perform necessary cleanup actions before the application terminates.

Spring Boot 提供了各种机制和钩子，如 "ApplicationContext "事件、"SmartLifecycle "接口或自定义关机钩子，以促进应用程序的优雅关机。这些机制允许开发人员定义自定义行为，并在应用程序终止前执行必要的清理操作。

What are all the different HTTP Methods?

不同的 HTTP 方法都有哪些？

Here are the commonly used HTTP methods

以下是常用的 HTTP 方法

1. GET: Retrieves a resource or data from a server.

1. GET： 从服务器读取资源或数据。

2. POST: Submits data to be processed to a server, typically resulting in the creation of a new resource.

2.POST： 向服务器提交要处理的数据，通常会创建一个新资源。

3. PUT: Updates or replaces an existing resource with new data.

3. PUT 用新数据更新或替换现有资源。

4. DELETE: Deletes a specified resource.

4. DELETE：删除指定的资源。

5. PATCH: Partially updates an existing resource with new data.

5. PATCH：用新数据部分更新现有资源。

6. HEAD: Retrieves metadata of a resource without fetching the actual content.

6. HEAD：检索资源的元数据，而不获取实际内容。

7. OPTIONS: Returns the allowed HTTP methods and capabilities of a server for a given resource.

7. OPTIONS：选项： 返回服务器针对给定资源允许使用的 HTTP 方法和能力。

These HTTP methods provide different ways to interact with resources on a server, enabling various operations such as retrieving, creating, updating, or deleting data.

这些 HTTP 方法提供了与服务器上的资源交互的不同方式，可进行各种操作，如检索、创建、更新或删除数据。

What is Idempotency?

什么是等效性？

Explain about Idempotent methods.
解释一下等效方法。

In REST (Representational State Transfer), idempotency refers to the property of certain HTTP methods where repeated identical requests have the same effect as a single request. In other words, performing an idempotent operation multiple times produces the same result as if it were done once.

在 REST（表征状态传输）中，惰性是指某些 HTTP 方法的特性，即重复相同的请求与单个请求具有相同的效果。换句话说，多次执行惰性操作会产生与一次相同的结果。

Idempotent methods in REST ensure that even if a request is duplicated or retried due to network issues or client behavior, the system remains in the same state and does not produce unintended side effects. Idempotent methods are designed to be safe for retries without causing inconsistencies or unexpected behavior.

REST 中的惰性方法可确保即使由于网络问题或客户端行为导致请求重复或重试，系统也能保持相同的状态，不会产生意想不到的副作用。闲置方法旨在确保重试的安全性，而不会导致不一致或意外行为。

The following HTTP methods are considered idempotent in REST

在 REST 中，以下 HTTP 方法被认为是empotent 方法

• GET: Retrieving a resource multiple times does not change the state of the server.

- GET： 多次检索资源不会改变服务器的状态。

• PUT: Updating a resource with the same data multiple times produces the same result.

- PUT： 多次使用相同数据更新资源会产生相同结果。

• DELETE: Deleting a resource multiple times results in the same outcome.

- DELETE：多次删除资源的结果相同。

Designing idempotent methods in RESTful APIs helps ensure reliability, consistency, and fault tolerance in distributed systems, allowing for robust and predictable behavior.

在 RESTful 应用程序接口中设计幂等方法有助于确保分布式系统的可靠性、一致性和容错性，从而实现稳健和可预测的行为。

What is @Async in Spring Boot?

什么是Spring Boot中的@Async？

The @Async annotation in Spring Boot is used to indicate that a method should be executed asynchronously. When a method is annotated with @Async, it is executed in a separate thread, allowing the calling thread to continue its execution without waiting for the completion of the annotated method.

Spring Boot 中的 @Async 注解用于表示方法应异步执行。使用 @Async 注解的方法在单独的线程中执行，允许调用线程继续执行，而无需等待注解方法的完成。

By using @Async, time-consuming or blocking operations can be offloaded to separate threads, improving the overall responsiveness and performance of the application. This annotation is typically used in scenarios where certain methods can be executed independently and their results are not immediately needed by the calling thread.

通过使用 @Async，耗时或阻塞操作可以被卸载到单独的线程中，从而提高应用程序的整体响应速度和性能。该注解通常用于某些方法可以独立执行，且调用线程不会立即需要其结果的情况。

To enable asynchronous execution in Spring Boot, you need to configure a task executor bean and annotate the target method with @Async. Spring Boot will automatically detect the @Async annotation and execute the annotated method asynchronously using the specified task executor.

要在 Spring Boot 中启用异步执行，您需要配置一个任务执行器 Bean，并用 @Async 对目标方法进行注解。Spring Boot 会自动检测 @Async 注释，并使用指定的任务执行器异步执行被注释的方法。

What is the difference between CrudRepository vs. JPARespository?

CrudRepository 与 JPARespository 之间有何不同？

The main difference between CrudRepository and JpaRepository is that JpaRepository is an extension of CrudRepository that provides additional JPA-specific features.

CrudRepository "和 "JpaRepository "的主要区别在于，"JpaRepository "是 "CrudRepository "的扩展，它提供了额外的 JPA 特定功能。

While both interfaces provide basic CRUD (Create, Read, Update, Delete) operations, JpaRepository offers additional functionality such as query creation methods, pagination support, and the ability to flush changes to the database.

虽然这两个接口都提供基本的 CRUD（创建、读取、更新、删除）操作，但 JpaRepository 提供了更多的功能，如查询创建方法、分页支持以及将更改刷新到数据库的功能。

In summary, CrudRepository is suitable for generic CRUD operations, while JpaRepository is more feature-rich and specifically designed for JPA-based applications, providing advanced querying capabilities on top of the basic CRUD operations.

总之，"CrudRepository "适用于一般的 CRUD 操作，而 "JpaRepository "功能更丰富，专门为基于 JPA 的应用程序设计，在基本 CRUD 操作的基础上提供高级查询功能。

Explain about different starter dependencies of Spring-boot.

解释 Spring-boot 的不同启动器依赖关系。

Spring Boot starter dependencies are a set of curated dependencies that simplify the configuration and setup of specific functionalities or frameworks within a Spring Boot application. Here are explanations of some commonly used starter dependencies

Spring Boot 启动依赖项是一组精心策划的依赖项，可简化 Spring Boot 应用程序中特定功能或框架的配置和设置。以下是一些常用启动依赖项的说明

1. spring-boot-starter-web Includes dependencies for building web applications with Spring MVC, including embedded Tomcat or Jetty server, Spring Web, and other related components.

1. Spring-boot-starter-web` 包括使用 Spring MVC 构建 Web 应用程序的依赖项，包括嵌入式 Tomcat 或 Jetty 服务器、Spring Web 和其他相关组件。

2. spring-boot-starter-data-jpa Provides dependencies for working with JPA (Java Persistence API), including Hibernate, Spring Data JPA, and database connectors.

2. spring-boot-starter-data-jpa 提供用于使用 JPA（Java Persistence API）的依赖项，包括 Hibernate、Spring Data JPA 和数据库连接器。

3. spring-boot-starter-security Includes dependencies for adding security features to the application, such as authentication, authorization, and encryption. It integrates with Spring Security and offers additional features like OAuth support.

3. spring-boot-starter-security 包括为应用程序添加安全功能（如身份验证、授权和加密）的依赖项。它与 Spring Security 集成，并提供 OAuth 支持等附加功能。

4. spring-boot-starter-test Provides dependencies for testing the application, including JUnit, Mockito, and Spring Test. It simplifies the setup of unit tests, integration tests, and other testing scenarios.

4. spring-boot-starter-test 提供用于测试应用程序的依赖项，包括 JUnit、Mockito 和 Spring Test。它简化了单元测试、集成测试和其他测试场景的设置。

5. spring-boot-starter-cache Includes dependencies for adding caching capabilities to the application. It integrates with popular caching libraries like Ehcache, Caffeine, or Redis.

5. spring-boot-starter-cache 包括为应用程序添加缓存功能的依赖项。它集成了 Ehcache、Caffeine 或 Redis 等流行的缓存库。

6. spring-boot-starter-amqp Provides dependencies for working with messaging and AMQP (Advanced Message Queuing Protocol) implementations, such as RabbitMQ.

6. spring-boot-starter-amqp 提供了与消息传递和 AMQP（高级消息队列协议）实现（如 RabbitMQ）配合使用的依赖项。

7. spring-boot-starter-data-redis Includes dependencies for using Redis as a data store, providing features for caching, distributed sessions, and more.

7. spring-boot-starter-data-redis 包括将 Redis 用作数据存储的依赖项，提供缓存、分布式会话等功能。

These are just a few examples of the various starter dependencies available in Spring Boot. Each starter simplifies the configuration and setup of a specific functionality or integration, allowing developers to quickly include and utilize the required features in their Spring Boot applications.

这些只是 Spring Boot 中各种启动依赖项的几个示例。每个启动程序都简化了特定功能或集成的配置和设置，使开发人员能够在其 Spring Boot 应用程序中快速包含和使用所需的功能。

Which one is better YAML file or the Properties file and the different ways to load the YAML file in Spring boot.

YAML 文件和属性文件哪个更好，以及在 Spring boot 中加载 YAML 文件的不同方法。

Whether YAML or Properties file is better depends on your personal preference and the complexity of your configuration. Here are some considerations

YAML 文件还是属性文件更好，取决于个人偏好和配置的复杂程度。以下是一些考虑因素

1. Readability YAML provides a more human-readable and structured format, allowing for nested data structures and indentation. Properties files use a simple ****key-value pair structure.

1. 可读性 YAML 提供了一种更适合人类阅读的结构化格式，允许嵌套数据结构和缩进。属性文件使用简单的键值对结构。

2. Complex Configurations YAML is more suitable for complex configurations with nested properties or arrays. It supports multi-line values and hierarchical structures.

2. 复杂配置 YAML 更适用于具有嵌套属性或数组的复杂配置。它支持多行值和分层结构。

3. Simplicity Properties files are simpler and more familiar to developers who are accustomed to key-value configurations.

3. 简单 属性文件更简单，对于习惯键值配置的开发人员来说更熟悉。

4. Spring Boot’s Default Spring Boot favors the use of YAML by default for external configuration, but it also supports Properties files.

4. Spring Boot 的默认 Spring Boot 默认使用 YAML 进行外部配置，但它也支持属性文件。

To load a YAML file in Spring Boot, you can use the following methods

要在 Spring Boot 中加载 YAML 文件，可以使用以下方法

1. Using @ConfigurationProperties Annotate a class with @ConfigurationProperties and provide the YAML file’s path in the value attribute. Spring Boot will bind the YAML properties to the annotated class.

1. 使用 @ConfigurationProperties 用 @ConfigurationProperties 注释一个类，并在 value 属性中提供 YAML 文件的路径。Spring Boot 会将 YAML 属性绑定到注解的类。

2. Using @PropertySource Use @PropertySource in conjunction with @Configuration to load a YAML file. Specify the YAML file’s location using the value attribute, and Spring Boot will load the properties into the environment.

2. 使用 @PropertySource 将 @PropertySource 与 @Configuration 结合使用以加载 YAML 文件。使用 value 属性指定 YAML 文件的位置，Spring Boot 就会将属性加载到环境中。

3. Using application.yml or application.yaml By default, Spring Boot looks for the application.yml or application.yaml file in the classpath and automatically loads its properties into the application context.

3. 使用 application.yml 或 application.yaml 默认情况下，Spring Boot 会在类路径中查找 application.yml 或 application.yaml 文件，并自动将其属性加载到应用程序上下文中。

These methods allow you to load YAML files and access their properties in a Spring Boot application, providing flexibility in configuring and customizing your application’s behavior.

通过这些方法，您可以在 Spring Boot 应用程序中加载 YAML 文件并访问其属性，从而灵活配置和自定义应用程序的行为。

Conclusion 结论

As we step into 2023, it’s evident that a strong foundation in core Java is no longer adequate. A substantial portion of interview questions now revolves around Spring Boot and Microservices. By thoroughly exploring these questions, you not only enhance your knowledge but also prepare yourself for the essential topics in today’s tech landscape. Don’t forget to check out our related article on Spring Boot for further insights. Stay ahead in your career by keeping up with these evolving technologies.

随着我们步入 2023 年，核心 Java 的坚实基础显然已不再足够。现在，很大一部分面试问题都围绕着 Spring Boot 和微服务展开。通过深入探讨这些问题，您不仅能增长知识，还能为应对当今技术领域的重要话题做好准备。别忘了查看我们关于 Spring Boot 的相关文章，了解更多详情。紧跟这些不断发展的技术，在你的职业生涯中保持领先。

【参考文献】

上述译文仅供参考，原文请查看下面链接，解释权归原作者所有

文章：《50+ Key Spring Boot Interview Questions for Programmers and Software Engineers in 2023》

作者：Ajay Rathod
发布日期：2023.09.16

⚠️：文章翻译上如有语法不准确或者内容纰漏，欢迎各位评论区指正。

【关于TalkX】

TalkX是一款基于GPT实现的IDE智能开发插件，专注于编程领域，是开发者在日常编码中提高编码效率及质量的辅助工具，TalkX常用的功能包括但不限于：解释代码、中英翻译、性能检查、安全检查、样式检查、优化并改进、提高可读性、清理代码、生成测试用例等。

TalkX建立了全球加速网络，不需要考虑网络环境，响应速度快，界面效果和交互体验更流畅。并为用户提供了OpenAI的密钥，不需要ApiKey，不需要自备账号，不需要魔法。

TalkX产品支持：JetBrains (包括 IntelliJ IDEA、PyCharm、WebStorm、Android Studio)、HBuilder、VS Code、Goland.