Spring 面試問答 · HowToDoInJava 中文系列教程

# Spring 面試問答 > 原文： [https://howtodoinjava.com/interview-questions/top-spring-interview-questions-with-answers/](https://howtodoinjava.com/interview-questions/top-spring-interview-questions-with-answers/) 我已經嘗試收集了這些**Spring 面試問題**，您可能會在下一次技術面試中面對這些問題。對于其他 Spring 課程，我將分別分享面試問題和答案。如果您能提出以前面試中遇到過的更多類似 Spring 面試問題，并考慮提出它們作為**專家級 Spring 面試問題**，我將不勝感激。我將它們添加到此列表中。這對于其他學習者也將有很大的幫助。 ## Spring 面試題 [1.什么是 Spring Framework？它的主要模塊是什么？](#spring_framework) [2.使用 Spring Framework 有什么好處？](#spring_benefits) [3.什么是控制反轉（IoC）和依賴注入？](#ioc_di) [4.在 Spring Framework 中解釋 IoC？](#ioc_in_spring) [5\. `BeanFactory`和`ApplicationContext`之間的區別？](#beanfactory_vs_applicationcontext) [6.您可以通過多種方式將 Spring 配置到我們的應用程序中？](#spring_configuration_types) [7.什么是基于 Spring XML 的配置？](#xml_based_configuration) [8.什么是基于 Spring Java 的配置？](#java_based_configuration) [9.什么是基于 Spring 注解的配置？](#annotation_based_configuration) [10.解釋 Spring Bean 的生命周期嗎？](#bean_lifecycle) [11.什么是不同的 Spring Bean 范圍？](#bean_scopes) [12\. Spring 中的內部 bean 是什么？](#inner_beans) [13\. 單例 bean 在 Spring Framework 中線程安全嗎？](#singleton_bean_threadsafe) [14.如何在 Spring 中注入 Java 集合？舉個例子？](#inject_collection) [15.如何將`java.util.Properties`注入 Spring Bean？](#inject_properties) [16.解釋 Spring Bean 自動裝配嗎？](#bean_autowiring) [17.解釋 Bean 自動裝配的不同模式嗎？](#autowiring_modes) [18.如何打開基于注解的自動裝配？](#enable_autowiring) [19.用示例解釋`@Required`注解？](#required_annotation) [20.用示例解釋`@Autowired`注解？](#autowired_annotation) [21.用示例解釋`@Qualifier`注解？](#qualifier_annotation) [22.構造函數注入和 setter 注入之間的區別？](#constructor_vs_setter_injection) [23\. Spring 框架中不同類型的事件是什么？](#applicationcontext_events) [24\. `FileSystemResource`和`ClassPathResource`之間的區別？](#filesystemresource_vs_classpathresource) [25.列舉一些 Spring 框架中使用的設計模式嗎？](#design_patterns_used_in_spring) ## 1\. 什么是 Spring 框架？它的主要模塊是什么？ **Spring 框架**是一個 Java 平臺，為開發 Java 應用程序提供全面的基礎架構支持。 Spring 處理基礎結構部分，因此您可以專注于應用程序部分。在其內部，Spring 框架將形式化的設計模式編碼為一流的對象，您可以將它們集成到自己的應用程序中，而不必擔心它們在后端如何工作。目前，Spring 框架由組織為約 20 個模塊的功能組成。這些模塊分為核心容器，數據訪問/集成，Web，AOP（面向切面的編程），規范，消息傳遞和測試，如圖所示。下圖。 ![spring modules](https://img.kancloud.cn/52/38/5238ead049ab1b070bf09605f1b03575_720x540.jpg) > **閱讀更多： [Spring 框架教程](https://howtodoinjava.com/java-spring-framework-tutorials/)** ## 2\. 使用 Spring 框架有什么好處？以下是使用 Spring Framework 的一些主要好處的清單： * 使用 [**依賴注入（DI）**](https://howtodoinjava.com/spring/spring-core/inversion-of-control-ioc-and-dependency-injection-di-patterns-in-spring-framework-and-related-interview-questions/) 方法，依賴在構造函數或 JavaBean 屬性中是顯式的且顯而易見的。 * IoC 容器往往是輕量級的，特別是例如與 EJB 容器相比時。這對于在內存和 CPU 資源有限的計算機上開發和部署應用程序很有用。 * Spring 并沒有徹底改變這種狀況，它確實利用了一些現有技術，例如幾個 ORM 框架，日志記錄框架，JEE，Quartz 和 JDK 計時器以及其他視圖技術。 * Spring 以模塊化的方式組織。即使包和類的數量很多，您也只需要擔心需要的包而忽略其余的包。 * [**測試用 Spring 編寫的應用程序**](https://howtodoinjava.com/junit/how-to-unit-test-spring-security-authentication-with-junit/) 很簡單，因為依賴于環境的代碼已移入該框架。此外，通過使用 JavaBean 風格的 POJO，使用依賴注入來注入測試數據變得更加容易。 * Spring 的 Web 框架是精心設計的 Web MVC 框架，它提供了 Struts 之類的 Web 框架或其他經過精心設計或不太受歡迎的 Web 框架的絕佳替代。 * Spring 提供了一個一致的事務管理接口，該接口可以按比例縮小到本地事務（例如，使用單個數據庫），并可以擴大到全局事務（例如，使用 JTA）。 ## 3\. 什么是控制反轉（IoC）和依賴注入？在軟件工程中，控制反轉（IoC）是一種編程技術，其中對象耦合在運行時由匯編程序對象綁定，并且通常在編譯時使用靜態分析是未知的。在傳統編程中，業務邏輯的流程由靜態分配給彼此的對象確定。在控制反轉的情況下，流程依賴于由匯編程序實例化的對象圖，并且通過抽象定義對象交互來使流程成為可能。綁定過程是通過“依賴注入”實現的。 **控制反轉**是一種設計示例，旨在為您的應用程序的目標組件（實際上是在工作的組件）提供更多控制。 **依賴注入**是一種模式，用于創建其他對象依賴的對象實例，而在編譯時不知道將使用哪個類來提供該功能。控制反轉依賴于依賴項注入，因為需要一種機制來激活提供特定功能的組件。否則，如果框架不再受控制，框架將如何知道要創建哪些組件？在 Java 中，依賴項注入可能通過 3 種方式發生： 1. **構造函數注入** 2. **二傳手注入** 3. **接口注入** ## 4\. 在 Spring Framework 中解釋 IoC？ `org.springframework.beans`和`org.springframework.context`軟件包為 Spring Framework 的 IoC 容器提供了基礎。`BeanFactory`接口提供了一種高級配置機制，能夠管理任何性質的對象。`ApplicationContext`接口建立在`BeanFactory`之上（它是一個子接口），并添加了其他功能，例如[**集成更容易**](https://howtodoinjava.com/category/frameworks/java-spring-tutorials/spring-aop/)，[消息資源處理](https://howtodoinjava.com/spring/spring-mvc/spring-mvc-internationalization-i18n-and-localization-i10n-example/)（用于國際化），事件傳播和特定于應用程序層的上下文，例如`WebApplicationContext`用于 Web 應用程序。 `org.springframework.beans.factory.BeanFactory`是 Spring IoC 容器的實際表示，該容器負責包含和管理上述 bean。`BeanFactory`接口是 Spring 中的中央 IoC 容器接口。 ## 5\. `BeanFactory`和`ApplicationContext`之間的區別？ `BeanFactory`就像一個工廠類，其中包含一組 bean。 `BeanFactory` 在其內部保存多個 Bean 的 Bean 定義，然后在客戶要求時實例化 Bean。 `BeanFactory`能夠在實例化協作對象之間創建關聯。這消除了 bean 本身和 bean 客戶端的配置負擔。 `BeanFactory`也參與了 bean 的生命周期，調用了自定義的初始化和銷毀??方法。從表面上看，應用程序上下文與 Bean 工廠相同。兩者都裝入 bean 定義，將 bean 裝在一起，并根據請求分配 bean。但它也提供： 1. 解決文本消息的方法，包括對**國際化**的支持。 2. 加載文件資源的通用方法。 3. 注冊為監聽器的 bean 的事件。 `ApplicationContext`的三種常用實現是： 1. `ClassPathXmlApplicationContext`：它從位于類路徑中的 XML 文件中加載上下文定義，將上下文定義視為類路徑資源。使用代碼從應用程序的類路徑中加載應用程序上下文。 ```java ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”); ``` 2. `FileSystemXmlApplicationContext`：它從文件系統中的 XML 文件加載上下文定義。使用代碼從文件系統中加載應用程序上下文。 ```java ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”); ``` 3. `XmlWebApplicationContext`：它從 Web 應用程序中包含的 XML 文件中加載上下文定義。 ## 6\. 您可以通過多種方式將 Spring 配置到我們的應用程序中？您可以通過 3 種方式在應用程序中配置 spring： 1. 基于 XML 的配置 2. 基于注解的配置 3. 基于 Java 的配置 ## 7\. 什么是基于 Spring XML 的配置？在 Spring 框架中，bean 需要的依賴項和服務在配置文件中指定，配置文件通常以 XML 格式。這些配置文件通常以`<beans>`標記開頭，并包含許多 bean 定義和特定于應用程序的配置選項。 Spring XML 配置的主要目標是使用 xml 文件配置所有 Spring 組件。這意味著將不存在任何其他類型的 Spring 配置（例如注解或通過 Java 類進行的配置）。 **Spring XML 配置**使用 Spring 命名空間使配置中使用的 XML 標記集可用。 Spring 的主要名稱空間包括：`context`，`bean`，`jdbc`，`tx`，`aop`，`mvc`和`aso`。 ```java <beans>  <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/> <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/> <bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/> </beans> ``` 在下面僅配置`DispatcherServlet`的最簡單的`web.xml`文件將為您的應用程序加載配置文件并為您配置運行時組件。 ```java <web-app> <display-name>Archetype Created Web Application</display-name> <servlet> <servlet-name>spring</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>spring</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app> ``` ## 8\. 什么是基于 Spring Java 的配置？ Spring 的新 Java 配置支持中的主要工件是`@Configuration`注解的類和`@Bean`注解的方法。 `@Bean`注解用于指示方法實例化，配置和初始化要由 Spring IoC 容器管理的新對象。 `@Bean`注解與`<bean/>`元素具有相同的作用。用`@Configuration`注解一個類表示該類的主要目的是作為 Bean 定義的來源。此外，`@Configuration`類允許通過簡單地調用同一類中的其他`@Bean`方法來定義 Bean 之間的依賴關系。最簡單的`@Configuration`類如下： ```java @Configuration public class AppConfig { @Bean public MyService myService() { return new MyServiceImpl(); } } ``` 上面的 java 配置的等效 XML 配置為： ```java <beans> <bean id="myService" class="com.howtodoinjava.services.MyServiceImpl"/> </beans> ``` 要實例化此類配置，您將需要`AnnotationConfigApplicationContext`類的幫助。 ```java public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); MyService myService = ctx.getBean(MyService.class); myService.doStuff(); } ``` 要啟用組件掃描，只需注解您的`@Configuration`類，如下所示： ```java @Configuration @ComponentScan(basePackages = "com.howtodoinjava") public class AppConfig { ... } ``` 在上面的示例中，將掃描`com.acme`包，查找任何帶有`@Component`注解的類，并將這些類注冊為容器內的 Spring bean 定義。如果在 Web 應用程序中使用上述配置，則將使用`AnnotationConfigWebApplicationContext`類。在配置 Spring `ContextLoaderListener` Servlet 監聽器，Spring MVC `DispatcherServlet`等時，可以使用此實現。 ```java <web-app>  <context-param> <param-name>contextClass</param-name> <param-value> org.springframework.web.context.support.AnnotationConfigWebApplicationContext </param-value> </context-param>  <context-param> <param-name>contextConfigLocation</param-name> <param-value>com.howtodoinjava.AppConfig</param-value> </context-param>  <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>  <servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  <init-param> <param-name>contextClass</param-name> <param-value> org.springframework.web.context.support.AnnotationConfigWebApplicationContext </param-value> </init-param>  <init-param> <param-name>contextConfigLocation</param-name> <param-value>com.howtodoinjava.web.MvcConfig</param-value> </init-param> </servlet>  <servlet-mapping> <servlet-name>dispatcher</servlet-name> <url-pattern>/app/*</url-pattern> </servlet-mapping> </web-app> ``` ## 9\. 什么是基于 Spring 注解的配置？從 Spring 2.5 開始，可以使用注解配置依賴項注入。因此，可以使用相關類，方法或字段聲明上的注解，而不是使用 XML 來描述 bean 的連接，而可以將 bean 配置移入組件類本身。注解注入在 XML 注入之前執行，因此對于通過兩種方法連接的屬性，后一種配置將覆蓋前者。默認情況下，Spring 容器中的注解裝配未打開。因此，在使用基于注解的連接之前，我們需要在 Spring 配置文件中啟用它。因此，如果您想在 Spring 應用程序中使用任何注解，請考慮使用以下配置文件。 ```java <beans> <context:annotation-config/>  </beans> ``` 一旦配置了`<context:annotation-config/>`，就可以開始注解代碼，以指示 Spring 應該自動將值連接到屬性，方法和構造函數中。在這種類型的配置中，很少使用的重要注解是： 1. `@Required`：`@Required`注解適用于 bean 屬性設置器方法。 2. `@Autowired`：`@Autowired`注解可以應用于 bean 屬性設置器方法，非設置器方法，構造函數和屬性。 3. `@Qualifier`：`@Qualifier`注解與`@Autowired`一起使用，可以通過指定要連接的確切 bean 來消除混淆。 4. **JSR-250 注解**：Spring 支持基于 JSR-250 的注解，包括`@Resource`，`@PostConstruct`和`@PreDestroy`注解。 ## 10\. 解釋 Spring Bean 的生命周期嗎？易于理解的是 Spring bean 的生命周期。實例化 Bean 時，可能需要執行一些初始化以使其進入可用狀態。同樣，當不再需要 bean 并將其從容器中刪除時，可能需要進行一些清理。 Spring bean 工廠負責管理通過 spring 容器創建的 bean 的生命周期。 bean 的生命周期由**回調方法組成，這些方法可以大致分為兩類**： 1. 發布初始化回調方法 2. 銷毀前回調方法 Spring 框架提供了以下 **4 種方法來控制 bean 的生命周期事件**： * `InitializingBean`和`DisposableBean`回調接口 * 其他用于特定行為的`Aware`接口 * Bean 配置文件中的自定義`init()`和`destroy()`方法 * `@PostConstruct`和`@PreDestroy`注解例如，`customInit()`和`customDestroy()`方法是生命周期方法的示例。 ```java <beans> <bean id="demoBean" class="com.howtodoinjava.task.DemoBean" init-method="customInit" destroy-method="customDestroy"></bean> </beans> ``` > **閱讀更多信息：[SpringBean 生命周期](https://howtodoinjava.com/spring/spring-core/spring-bean-life-cycle/)** ## 11\. Spring Bean 范圍有哪些不同？可以在五個 **bean 范圍**中創建 spring 容器中的 bean。所有作用域名稱都是不言自明的，但請明確說明它們，以免產生任何疑問。 1. **單例**：此 bean 范圍是默認值，它強制容器在每個 spring 容器中只有一個實例，而不管您請求實例的時間是多少。這種單例行為由 bean 工廠本身維護。 2. **原型**：該 bean 作用域只是反轉單例作用域的行為，每次每次請求 bean 都產生一個新實例。 3. **請求**：在此 bean 作用域內，將為客戶端的每個 Web 請求創建一個新的 bean 實例。請求完成后，bean 將超出范圍并被垃圾回收。 4. **會話**：就像請求范圍一樣，這確保了每個用戶會話一個 bean 實例。用戶結束會話后，bean 不在范圍內。 5. **全局會話**：全局會話是連接到 Portlet 應用程序的東西。當您的應用程序在 Portlet 容器中工作時，它是由一定數量的 Portlet 構建的。每個 portlet 都有其自己的會話，但是如果要在應用程序中為所有 portlet 全局存儲變量，則應將其存儲在全局回話中。此作用域與基于 Servlet 的應用程序中的會話作用域沒有任何特殊作用。 > **閱讀更多：[SpringBean 范圍](https://howtodoinjava.com/spring/spring-core/spring-bean-scopes/)** ## 12\. 什么是 Spring Bean？在 Spring 框架中，每當一個 bean 僅用于一個特定屬性時，建議將其聲明為一個內部 bean。內部 bean 在 setter 注入`property`和構造函數注入`constructor-arg`中均受支持。例如，假設我們引用了`Person`類的一個`Customer`類。在我們的應用程序中，我們將只創建`Person`類的一個實例，并在`Customer`中使用它。 ```java public class Customer { private Person person; //Setters and Getters } ``` ```java public class Person { private String name; private String address; private int age; //Setters and Getters } ``` 現在，內部 bean 聲明將如下所示： ```java <bean id="CustomerBean" class="com.howtodoinjava.common.Customer"> <property name="person">  <bean class="com.howtodoinjava.common.Person"> <property name="name" value="adminis"></property> <property name="address" value="India"></property> <property name="age" value="34"></property> </bean> </property> </bean> ``` ## 13\. 在 Spring 框架中，單例 bean 線程安全嗎？對于[**單例**](https://howtodoinjava.com/design-patterns/singleton-design-pattern-in-java/) bean 的多線程行為，Spring 框架不做任何事情。開發人員有責任處理單例 bean 的并發問題和 [**線程安全**](https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/) 。實際上，大多數 SpringBean 沒有可變狀態（例如服務和 DAO 鎖類），因此線程安全性很小。但是如果您的 bean 處于可變狀態（例如，查看模型對象），那么您需要確保線程安全。解決此問題的最簡單，最明顯的方法是將可變 Bean 的范圍從`singleton`更改為`property`。 ## 14\. 如何在 Spring 中注入 Java 集合？舉個例子？ Spring 提供了四種類型的集合配置元素，如下所示： + `<list>`：這有助于裝配，即注入值列表，允許重復。 + `<set>`：這有助于裝配一組值，但沒有重復項。 + `<map>`：這可以用于注入名稱-值對的集合，其中名稱和值可以是任何類型。 + `<prop>`：這可用于注入名稱-值對的集合，其中名稱和值均為字符串。我們來看每種類型的示例。 ```java <beans>  <bean id="javaCollection" class="com.howtodoinjava.JavaCollection">  <property name="customList"> <list> <value>INDIA</value> <value>Pakistan</value> <value>USA</value> <value>UK</value> </list> </property>  <property name="customSet"> <set> <value>INDIA</value> <value>Pakistan</value> <value>USA</value> <value>UK</value> </set> </property>  <property name="customMap"> <map> <entry key="1" value="INDIA"/> <entry key="2" value="Pakistan"/> <entry key="3" value="USA"/> <entry key="4" value="UK"/> </map> </property>  <property name="customProperies"> <props> <prop key="admin">admin@nospam.com</prop> <prop key="support">support@nospam.com</prop> </props> </property> </bean> </beans> ``` ## 15\. 如何將`java.util.Properties`注入 Spring Bean？第一種方法是使用`<prop>`標簽，如下所示。 ```java <bean id="adminUser" class="com.howtodoinjava.common.Customer">  <property name="emails"> <props> <prop key="admin">admin@nospam.com</prop> <prop key="support">support@nospam.com</prop> </props> </property> </bean> ``` 您也可以使用`util:`命名空間從屬性文件創建屬性 bean，并使用 bean 引用進行 setter 注入。 ```java <util:properties id="emails" location="classpath:com/foo/emails.properties" /> ``` ## 16\. 解釋 Spring Bean 自動裝配嗎？在 spring 框架中，遵循配置文件中的 bean 依賴關系是一個好的做法，但是 spring 容器也能夠自動裝配協作 bean 之間的關系。這意味著可以通過檢查`BeanFactory`的內容來自動讓 Spring 為您的 bean 解決協作者（其他 bean）。 [**自動裝配**](https://howtodoinjava.com/2013/05/08/spring-beans-autowiring-concepts/) 為每個 bean 指定，因此可以為某些 bean 啟用，而其他 bean 將不會自動裝配。 XML 配置文件的以下摘錄顯示了按名稱自動裝配的 Bean。 ```java <bean id="employeeDAO" class="com.howtodoinjava.EmployeeDAOImpl" autowire="byName" /> ``` 除了 bean 配置文件中提供的自動裝配模式外，還可以使用`@Autowired`注解在 bean 類中指定自動裝配。要在 bean 類中使用`@Autowired`注解，必須首先使用以下配置在 spring 應用程序中啟用注解。 ```java <context:annotation-config /> ``` 使用配置文件中的`AutowiredAnnotationBeanPostProcessor` bean 定義可以實現相同的目的。 ```java <bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/> ``` 現在，啟用注解配置后，您可以使用`@Autowired`隨意地自動綁定 bean 依賴項。 ```java @Autowired public EmployeeDAOImpl ( EmployeeManager manager ) { this.manager = manager; } ``` ## 17\. 解釋 Bean 自動裝配的不同模式嗎？ Spring 框架中有**五種自動裝配模式**。讓我們一一討論。 1. `off`：該選項是 spring 框架的默認選項，表示自動裝配為 OFF。您必須使用 bean 定義中的標簽顯式設置依賴項。 2. `byName`：此選項啟用基于 bean 名稱的依賴項注入。在 Bean 中自動裝配屬性時，屬性名稱用于在配置文件中搜索匹配的 Bean 定義。如果找到這樣的 bean，則將其注入屬性。如果找不到這樣的 bean，則會引發錯誤。 3. `byType`：此選項啟用基于 bean 類型的依賴項注入。在 bean 中自動裝配屬性時，屬性的類類型用于在配置文件中搜索匹配的 bean 定義。如果找到這樣的 bean，則將其注入屬性。如果找不到這樣的 bean，則會引發錯誤。 4. `constructor`：構造函數自動裝配與`byType`相似，但適用于構造函數參數。在啟用自動裝配的 bean 中，它將查找構造函數參數的類類型，然后按類型對所有構造函數參數進行自動裝配。請注意，如果容器中沒有一個完全屬于構造函數參數類型的 bean，則會引發致命錯誤。 5. `autodetect`：通過自動檢測進行自動裝配使用兩種模式之一，即構造函數或`byType`模式。首先它將嘗試尋找帶有參數的有效構造函數，如果找到，則選擇構造函數模式。如果在 bean 中沒有定義構造函數，或者存在顯式的默認 no-args 構造函數，則選擇`byType`自動裝配模式。 ## 18\. 如何打開基于注解的自動裝配？要啟用`@Autowired`，您必須注冊`AutowiredAnnotationBeanPostProcessor`，并且可以通過兩種方式進行。 1.在 bean 配置文件中包含`<context:annotation-config >`。 ```java <beans> <context:annotation-config /> </beans> ``` 2.將`AutowiredAnnotationBeanPostProcessor`直接包含在 bean 配置文件中。 ```java <beans> <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/> </beans> ``` ## 19\. 用示例解釋`@Required`注解？在生產規模的應用程序中，可能在 IoC 容器中聲明了成百上千個 bean，并且它們之間的依賴關系通常非常復雜。 setter 注入的缺點之一是，您很難檢查是否已設置所有必需的屬性。為了解決這個問題，您可以設置`<bean>`的`依賴項檢查`屬性，并設置四個屬性之一，即無，簡單，對象或全部（默認為無）。在現實生活中的應用程序中，您將不需要檢查上下文文件中配置的所有 Bean 屬性。相反，您只想檢查是否僅在某些特定的 Bean 中設置了特定的屬性集。 Spring 使用`依賴項檢查`屬性的依賴項檢查功能在這種情況下將無法為您提供幫助。因此，要解決此問題，可以使用`@Required`注解。要在類文件中的 bean 屬性的 setter 方法上使用`@Required`注解，如下所示： ```java public class EmployeeFactoryBean extends AbstractFactoryBean<Object> { private String designation; public String getDesignation() { return designation; } @Required public void setDesignation(String designation) { this.designation = designation; } //more code here } ``` `RequiredAnnotationBeanPostProcessor`是一個 Spring bean 后處理器，用于檢查是否已設置所有帶有`@Required`注解的 bean 屬性。要啟用此 bean 后處理器進行屬性檢查，必須在 Spring IoC 容器中注冊它。 ```java <bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" /> ``` 如果尚未設置任何帶有`@Required`的屬性，則此 bean 后處理器將拋出`BeanInitializationException`。 ## 20\. 用示例解釋`@Autowired`注解？ `@Autowired`注解提供了在何處以及如何實現自動裝配的更細粒度的控制。 `@Autowired`注解可用于在 setter 方法上自動裝配 bean，就像`@Required`注解，構造函數，具有任意名稱和/或多個參數的屬性或方法一樣。例如。您可以在 setter 方法上使用`@Autowired`注解，以擺脫 XML 配置文件中的`<property>`元素。當 Spring 找到用于 setter 方法的`@Autowired`注解時，**它將嘗試通過在方法上鍵入自動裝配來執行**。您也可以將`@Autowired`應用于構造函數。構造函數`@Autowired`注解指示即使在 XML 文件中配置 Bean 時不使用`<constructor-arg>`元素，創建該 Bean 時也應自動構造該構造函數。 ```java public class TextEditor { private SpellChecker spellChecker; @Autowired public TextEditor(SpellChecker spellChecker){ System.out.println("Inside TextEditor constructor." ); this.spellChecker = spellChecker; } public void spellCheck(){ spellChecker.checkSpelling(); } } ``` 而且它的配置沒有構造函數參數。 ```java <beans> <context:annotation-config/>  <bean id="textEditor" class="com.howtodoinjava.TextEditor"> </bean>  <bean id="spellChecker" class="com.howtodoinjava.SpellChecker"> </bean> </beans> ``` ## 21\. 用示例解釋`@Qualifier`注解？ `@Qualifier`表示哪個 bean 可以在字段上自動裝配。如果 Spring 否則無法使用`@Qualifier`注解消除 Bean 引用的歧義。參見下面的示例，它將自動將`person` bean 連接到客戶的`person`屬性中。 ```java public class Customer { @Autowired private Person person; } ``` 對于`Person`類，我們有兩個 bean 定義。 ```java <bean id="customer" class="com.howtodoinjava.common.Customer" /> <bean id="personA" class="com.howtodoinjava.common.Person" > <property name="name" value="lokesh" /> </bean> <bean id="personB" class="com.howtodoinjava.common.Person" > <property name="name" value="alex" /> </bean> ``` Spring 會知道應該自動裝配哪個人的 bean？沒有。在上面的示例中運行時，它會在下面的異常中命中： ```java Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [com.howtodoinjava.common.Person] is defined: expected single matching bean but found 2: [personA, personB] ``` 要解決上述問題，您需要`@Quanlifier`告訴 Spring 應該自動裝配哪個 bean。 ```java public class Customer { @Autowired @Qualifier("personA") private Person person; } ``` ## 22\. 構造函數注入和 setter 注入之間的區別？請在下面找到明顯的區別： 1. 在 Setter 注入中，可能會部分注入依賴項，這意味著如果我們有 3 個依賴項（如`int`，`string`，`long`），那么如果使用 setter 注入，則不必注入所有值。如果您不注入，它將采用這些原語的默認值。在構造函數注入中，不可能部分注入依賴項，因為調用構造函數時必須正確傳遞所有參數，否則，可能會出錯。 2. 如果我們為同一屬性編寫 setter 和構造函數注入，則 Setter 注入將覆蓋構造函數注入值。但是，構造函數注入不能覆蓋 setter 注入的值。顯而易見，因為首先要調用構造函數才能創建實例。 3. 使用 setter 注入，您不能保證是否注入了某些依賴關系，這意味著您可能擁有不完全依賴關系的對象。另一切面，在準備好依賴項之前，構造函數注入不允許您構造對象。 4. 在構造函數注入中，如果對象 A 和 B 相互依賴，即 A 依賴于 B，反之亦然，則 Spring 在創建 A 和 B 的對象時會拋出`ObjectCurrentlyInCreationException`，因為在創建 B 之前無法創建對象，反之亦然。因此 spring 可以通過 setter 注入解決循環依賴關系，因為對象是在調用 setter 方法之前構造的。 ## 23\. Spring 框架中有哪些不同類型的事件？ Spring 的`ApplicationContext`提供了在代碼中支持事件和監聽器的功能。我們可以創建 bean 來監聽通過`ApplicationContext`發布的事件。通過`ApplicationEvent`類和`ApplicationListener`接口提供`ApplicationContext`中的事件處理。因此，如果 bean 實現`ApplicationListener`，則每次`ApplicationEvent`發布到`ApplicationContext`時，都會通知該 bean。 ```java public class AllApplicationEventListener implements ApplicationListener < ApplicationEvent > { @Override public void onApplicationEvent(ApplicationEvent applicationEvent) { //process event } } ``` Spring 提供以下 **5 個標準事件**： 1. `ContextRefreshedEvent`：在初始化或刷新`ApplicationContext`時，將發布此事件。也可以使用`ConfigurableApplicationContext`接口上的`refresh()`方法來提高它。 2. `ContextStartedEvent`：使用`ConfigurableApplicationContext`接口上的`start()`方法啟動`ApplicationContext`時，將發布此事件。您可以輪詢數據庫，也可以在收到此事件后重新/啟動任何已停止的應用程序。 3. `ContextStoppedEvent`：當使用`ConfigurableApplicationContext`接口上的`stop()`方法停止`ApplicationContext`時，將發布此事件。收到此活動后，您可以進行必要的整理工作。 4. `ContextClosedEvent`：當使用`ConfigurableApplicationContext`接口上的`close()`方法關閉`ApplicationContext`時，將發布此事件。關閉的環境已經到了生命的盡頭。它不能刷新或重新啟動。 5. `RequestHandledEvent`：這是一個特定于 Web 的事件，告訴所有 Bean HTTP 請求已得到服務。除上述之外，您可以通過擴展`ApplicationEvent`類來創建自己的自定義事件。例如 ```java public class CustomApplicationEvent extends ApplicationEvent { public CustomApplicationEvent ( Object source, final String msg ) { super(source); System.out.println("Created a Custom event"); } } ``` 要監聽此事件，請創建如下監聽器： ```java public class CustomEventListener implements ApplicationListener < CustomApplicationEvent > { @Override public void onApplicationEvent(CustomApplicationEvent applicationEvent) { //handle event } } ``` 要發布此事件，您將需要`ApplicationContext`實例的幫助。 ```java CustomApplicationEvent customEvent = new CustomApplicationEvent( applicationContext, "Test message" ); applicationContext.publishEvent ( customEvent ); ``` ## 24\. `FileSystemResource`和`ClassPathResource`之間的區別？在`FileSystemResource`中，您需要提供`spring-config.xml`（Spring 配置）文件相對于您的項目的路徑或文件的絕對位置。在`ClassPathResource`中，spring 使用`ClassPath`查找文件，因此`spring-config.xml`應該包含在類路徑中。如果`src`中有`spring-config.xml`，則由于`src`默認情況下位于類路徑中，因此我們只能給出其名稱。 **一句話，`ClassPathResource`在類路徑中查找，而`FileSystemResource`在文件系統中查找。** ## 25\. 舉出 Spring 框架中使用的一些設計模式嗎？有很多使用不同設計模式的負載，但是有一些顯而易見的負載： * **代理**-在 AOP 和遠程調用中大量使用。 * **單例** – Spring 配置文件中定義的 bean 默認為單例。 * **模板方法** – 廣泛用于處理樣板重復代碼，例如[`RestTemplate`](https://howtodoinjava.com/spring/spring-restful/spring-restful-client-resttemplate-example/)，`JmsTemplate`和`JpaTemplate`。 * **前端控制器** – Spring 提供`DispatcherServlet`以確保傳入的請求被分派到您的控制器。 * **視圖助手** -Spring 具有許多自定義 JSP 標簽和速度宏，以幫助將代碼與視圖中的表示分離。 * **依賴項注入** – 以整個`BeanFactory` / `ApplicationContext`概念為中心。 * **工廠模式**-用于創建對象實例的`BeanFactory`。 > **閱讀更多：[編寫 Spring 配置文件的最佳實踐](https://howtodoinjava.com/spring/spring-core/13-best-practices-for-writing-spring-configuration-files/)** 請分享**最新的 Spring 面試問題**，您可能在任何面試中都遇到過這些問題。學習愉快！參考文獻： [Spring beans 文檔](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html) [Spring 事務](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/transaction.html) [Spring AOP 官方指南](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html)