Spring 相關 面試題錦 （全）

------------------------------------------------------------------------------------------------------------------------------------------

面試必問一些理論知識，時長肯定忘記提供給各位跳槽的大佬回顧一些忘記的知識點 以及剛上路的rookie急需面試的你們！！

                                                            （預祝大家早日找到滿意的工作）

------------------------------------------------------------------------------------------------------------------------------------------

Spring 概述

1. 什麼是spring?

spring 是個Java企業級應用的開源開發框架。Spring主要用來開發Java應用，但是有些擴展是針對構建J2EE平臺的web應用。Spring 框架目標是簡化Java企業級應用開發，並通過POJO爲基礎的編程模型促進良好的編程習慣。

2. 使用Spring框架的好處是什麼？

• 輕量：Spring 是輕量的，基本的版本大約2MB。
• 控制反轉：Spring通過控制反轉實現了鬆散耦合，對象們給出它們的依賴，而不是創建或查找依賴的對象們。
• 面向切面的編程(AOP)：Spring支持面向切面的編程，並且把應用業務邏輯和系統服務分開。
• 容器：Spring 包含並管理應用中對象的生命週期和配置。
• MVC框架：Spring的WEB框架是個精心設計的框架，是Web框架的一個很好的替代品。
• 事務管理：Spring 提供一個持續的事務管理接口，可以擴展到上至本地事務下至全局事務（JTA）。
• 異常處理：Spring 提供方便的API把具體技術相關的異常（比如由JDBC，Hibernate or JDO拋出的）轉化爲一致的unchecked 異常。

3. Spring由哪些模塊組成?

以下是Spring 框架的基本模塊：

• Core module
• Bean module
• Context module
• Expression Language module
• JDBC module
• ORM module
• OXM module
• Java Messaging Service(JMS) module
• Transaction module
• Web module
• Web-Servlet module
• Web-Struts module
• Web-Portlet module

4. 核心容器（應用上下文) 模塊。

這是基本的Spring模塊，提供spring 框架的基礎功能，BeanFactory 是 任何以spring爲基礎的應用的核心。Spring 框架建立在此模塊之上，它使Spring成爲一個容器。

5. BeanFactory – BeanFactory 實現舉例。

Bean 工廠是工廠模式的一個實現，提供了控制反轉功能，用來把應用的配置和依賴從正真的應用代碼中分離。

最常用的BeanFactory 實現是XmlBeanFactory 類。

6. XMLBeanFactory

最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory ，它根據XML文件中的定義加載beans。該容器從XML 文件讀取配置元數據並用它去創建一個完全配置的系統或應用。

7. 解釋AOP模塊

AOP模塊用於發給我們的Spring應用做面向切面的開發， 很多支持由AOP聯盟提供，這樣就確保了Spring和其他AOP框架的共通性。這個模塊將元數據編程引入Spring。

8. 解釋JDBC抽象和DAO模塊。

通過使用JDBC抽象和DAO模塊，保證數據庫代碼的簡潔，並能避免數據庫資源錯誤關閉導致的問題，它在各種不同的數據庫的錯誤信息之上，提供了一個統一的異常訪問層。它還利用Spring的AOP 模塊給Spring應用中的對象提供事務管理服務。

9. 解釋對象/關係映射集成模塊。

Spring 通過提供ORM模塊，支持我們在直接JDBC之上使用一個對象/關係映射映射(ORM)工具，Spring 支持集成主流的ORM框架，如Hiberate,JDO和 iBATIS SQL Maps。Spring的事務管理同樣支持以上所有ORM框架及JDBC。

10. 解釋WEB 模塊。

Spring的WEB模塊是構建在application context 模塊基礎之上，提供一個適合web應用的上下文。這個模塊也包括支持多種面向web的任務，如透明地處理多個文件上傳請求和程序級請求參數的綁定到你的業務對象。它也有對Jakarta Struts的支持。

12. Spring配置文件

Spring配置文件是個XML 文件，這個文件包含了類信息，描述瞭如何配置它們，以及如何相互調用。

13. 什麼是Spring IOC 容器？

Spring IOC 負責創建對象，管理對象（通過依賴注入（DI），裝配對象，配置對象，並且管理這些對象的整個生命週期。

14. IOC的優點是什麼？

IOC 或 依賴注入把應用的代碼量降到最低。它使應用容易測試，單元測試不再需要單例和JNDI查找機制。最小的代價和最小的侵入性使鬆散耦合得以實現。IOC容器支持加載服務時的餓漢式初始化和懶加載。

15. ApplicationContext通常的實現是什麼?

• FileSystemXmlApplicationContext ：此容器從一個XML文件中加載beans的定義，XML Bean 配置文件的全路徑名必須提供給它的構造函數。
• ClassPathXmlApplicationContext：此容器也從一個XML文件中加載beans的定義，這裏，你需要正確設置classpath因爲這個容器將在classpath裏找bean配置。
• WebXmlApplicationContext：此容器加載一個XML文件，此文件定義了一個WEB應用的所有bean。

16. Bean 工廠和 Application contexts 有什麼區別？

Application contexts提供一種方法處理文本消息，一個通常的做法是加載文件資源（比如鏡像），它們可以向註冊爲監聽器的bean發佈事件。另外，在容器或容器內的對象上執行的那些不得不由bean工廠以程序化方式處理的操作，可以在Application contexts中以聲明的方式處理。Application contexts實現了MessageSource接口，該接口的實現以可插拔的方式提供獲取本地化消息的方法。

17. 一個Spring的應用看起來象什麼？

• 一個定義了一些功能的接口。
• 這實現包括屬性，它的Setter ， getter 方法和函數等。
• Spring AOP。
• Spring 的XML 配置文件。
• 使用以上功能的客戶端程序。

依賴注入

18. 什麼是Spring的依賴注入？

依賴注入，是IOC的一個方面，是個通常的概念，它有多種解釋。這概念是說你不用創建對象，而只需要描述它如何被創建。你不在代碼裏直接組裝你的組件和服務，但是要在配置文件裏描述哪些組件需要哪些服務，之後一個容器（IOC容器）負責把他們組裝起來。

19. 有哪些不同類型的IOC（依賴注入）方式？

• 構造器依賴注入：構造器依賴注入通過容器觸發一個類的構造器來實現的，該類有一系列參數，每個參數代表一個對其他類的依賴。
• Setter方法注入：Setter方法注入是容器通過調用無參構造器或無參static工廠 方法實例化bean之後，調用該bean的setter方法，即實現了基於setter的依賴注入。

20. 哪種依賴注入方式你建議使用，構造器注入，還是 Setter方法注入？

你兩種依賴方式都可以使用，構造器注入和Setter方法注入。最好的解決方案是用構造器參數實現強制依賴，setter方法實現可選依賴。

Spring Beans

21.什麼是Spring beans?

Spring beans 是那些形成Spring應用的主幹的java對象。它們被Spring IOC容器初始化，裝配，和管理。這些beans通過容器中配置的元數據創建。比如，以XML文件中<bean/> 的形式定義。

Spring 框架定義的beans都是單件beans。在bean tag中有個屬性”singleton”，如果它被賦爲TRUE，bean 就是單件，否則就是一個 prototype bean。默認是TRUE，所以所有在Spring框架中的beans 缺省都是單件。

22. 一個 Spring Bean 定義 包含什麼？

一個Spring Bean 的定義包含容器必知的所有配置元數據，包括如何創建一個bean，它的生命週期詳情及它的依賴。

23. 如何給Spring 容器提供配置元數據?

這裏有三種重要的方法給Spring 容器提供配置元數據。

XML配置文件。

基於註解的配置。

基於java的配置。

24. 你怎樣定義類的作用域?

當定義一個<bean> 在Spring裏，我們還能給這個bean聲明一個作用域。它可以通過bean 定義中的scope屬性來定義。如，當Spring要在需要的時候每次生產一個新的bean實例，bean的scope屬性被指定爲prototype。另一方面，一個bean每次使用的時候必須返回同一個實例，這個bean的scope 屬性 必須設爲 singleton。

25. 解釋Spring支持的幾種bean的作用域。

Spring框架支持以下五種bean的作用域：

• singleton : bean在每個Spring ioc 容器中只有一個實例。
• prototype：一個bean的定義可以有多個實例。
• request：每次http請求都會創建一個bean，該作用域僅在基於web的Spring ApplicationContext情形下有效。
• session：在一個HTTP Session中，一個bean定義對應一個實例。該作用域僅在基於web的Spring ApplicationContext情形下有效。
• global-session：在一個全局的HTTP Session中，一個bean定義對應一個實例。該作用域僅在基於web的Spring ApplicationContext情形下有效。

缺省的Spring bean 的作用域是Singleton.

26. Spring框架中的單例bean是線程安全的嗎?

不，Spring框架中的單例bean不是線程安全的。

27. 解釋Spring框架中bean的生命週期。

• Spring容器 從XML 文件中讀取bean的定義，並實例化bean。
• Spring根據bean的定義填充所有的屬性。
• 如果bean實現了BeanNameAware 接口，Spring 傳遞bean 的ID 到 setBeanName方法。
• 如果Bean 實現了 BeanFactoryAware 接口， Spring傳遞beanfactory 給setBeanFactory 方法。
• 如果有任何與bean相關聯的BeanPostProcessors，Spring會在postProcesserBeforeInitialization()方法內調用它們。
• 如果bean實現IntializingBean了，調用它的afterPropertySet方法，如果bean聲明瞭初始化方法，調用此初始化方法。
• 如果有BeanPostProcessors 和bean 關聯，這些bean的postProcessAfterInitialization() 方法將被調用。
• 如果bean實現了 DisposableBean，它將調用destroy()方法。

28. 哪些是重要的bean生命週期方法？ 你能重載它們嗎？

有兩個重要的bean 生命週期方法，第一個是setup ， 它是在容器加載bean的時候被調用。第二個方法是 teardown 它是在容器卸載類的時候被調用。

The bean 標籤有兩個重要的屬性（init-method和destroy-method）。用它們你可以自己定製初始化和註銷方法。它們也有相應的註解（@PostConstruct和@PreDestroy）。

29. 什麼是Spring的內部bean？

當一個bean僅被用作另一個bean的屬性時，它能被聲明爲一個內部bean，爲了定義inner bean，在Spring 的 基於XML的 配置元數據中，可以在 <property/>或 <constructor-arg/> 元素內使用<bean/> 元素，內部bean通常是匿名的，它們的Scope一般是prototype。

30. 在 Spring中如何注入一個java集合？

Spring提供以下幾種集合的配置元素：

• <list>類型用於注入一列值，允許有相同的值。
• <set> 類型用於注入一組值，不允許有相同的值。
• <map> 類型用於注入一組鍵值對，鍵和值都可以爲任意類型。
• <props>類型用於注入一組鍵值對，鍵和值都只能爲String類型。

31. 什麼是bean裝配?

裝配，或bean 裝配是指在Spring 容器中把bean組裝到一起，前提是容器需要知道bean的依賴關係，如何通過依賴注入來把它們裝配到一起。

32. 什麼是bean的自動裝配？

Spring 容器能夠自動裝配相互合作的bean，這意味着容器不需要<constructor-arg>和<property>配置，能通過Bean工廠自動處理bean之間的協作。

33. 解釋不同方式的自動裝配 。

有五種自動裝配的方式，可以用來指導Spring容器用自動裝配方式來進行依賴注入。

• no：默認的方式是不進行自動裝配，通過顯式設置ref 屬性來進行裝配。
• byName：通過參數名 自動裝配，Spring容器在配置文件中發現bean的autowire屬性被設置成byname，之後容器試圖匹配、裝配和該bean的屬性具有相同名字的bean。
• byType:：通過參數類型自動裝配，Spring容器在配置文件中發現bean的autowire屬性被設置成byType，之後容器試圖匹配、裝配和該bean的屬性具有相同類型的bean。如果有多個bean符合條件，則拋出錯誤。
• constructor：這個方式類似於byType， 但是要提供給構造器參數，如果沒有確定的帶參數的構造器參數類型，將會拋出異常。
• autodetect：首先嚐試使用constructor來自動裝配，如果無法工作，則使用byType方式。

34.自動裝配有哪些侷限性 ?

自動裝配的侷限性是：

• 重寫： 你仍需用 <constructor-arg>和 <property> 配置來定義依賴，意味着總要重寫自動裝配。
• 基本數據類型：你不能自動裝配簡單的屬性，如基本數據類型，String字符串，和類。
• 模糊特性：自動裝配不如顯式裝配精確，如果有可能，建議使用顯式裝配。

35. 你可以在Spring中注入一個null 和一個空字符串嗎？

可以。

Spring註解

36. 什麼是基於Java的Spring註解配置? 給一些註解的例子.

基於Java的配置，允許你在少量的Java註解的幫助下，進行你的大部分Spring配置而非通過XML文件。

以@Configuration 註解爲例，它用來標記類可以當做一個bean的定義，被Spring IOC容器使用。另一個例子是@Bean註解，它表示此方法將要返回一個對象，作爲一個bean註冊進Spring應用上下文。

37. 什麼是基於註解的容器配置?

相對於XML文件，註解型的配置依賴於通過字節碼元數據裝配組件，而非尖括號的聲明。

開發者通過在相應的類，方法或屬性上使用註解的方式，直接組件類中進行配置，而不是使用xml表述bean的裝配關係。

38. 怎樣開啓註解裝配？

註解裝配在默認情況下是不開啓的，爲了使用註解裝配，我們必須在Spring配置文件中配置 <context:annotation-config/>元素。

39. @Required 註解

這個註解表明bean的屬性必須在配置的時候設置，通過一個bean定義的顯式的屬性值或通過自動裝配，若@Required註解的bean屬性未被設置，容器將拋出BeanInitializationException。

40. @Autowired 註解

@Autowired 註解提供了更細粒度的控制，包括在何處以及如何完成自動裝配。它的用法和@Required一樣，修飾setter方法、構造器、屬性或者具有任意名稱和/或多個參數的PN方法。

41. @Qualifier 註解

當有多個相同類型的bean卻只有一個需要自動裝配時，將@Qualifier 註解和@Autowire 註解結合使用以消除這種混淆，指定需要裝配的確切的bean。

Spring數據訪問

42.在Spring框架中如何更有效地使用JDBC?

使用SpringJDBC 框架，資源管理和錯誤處理的代價都會被減輕。所以開發者只需寫statements 和 queries從數據存取數據，JDBC也可以在Spring框架提供的模板類的幫助下更有效地被使用，這個模板叫JdbcTemplate （例子見這裏here）

43. JdbcTemplate

JdbcTemplate 類提供了很多便利的方法解決諸如把數據庫數據轉變成基本數據類型或對象，執行寫好的或可調用的數據庫操作語句，提供自定義的數據錯誤處理。

44. Spring對DAO的支持

Spring對數據訪問對象（DAO）的支持旨在簡化它和數據訪問技術如JDBC，hibernate or JDO 結合使用。這使我們可以方便切換持久層。編碼時也不用擔心會捕獲每種技術特有的異常。

45. 使用Spring通過什麼方式訪問Hibernate?

在Spring中有兩種方式訪問Hibernate：

• 控制反轉 Hibernate Template和 Callback。
• 繼承 HibernateDAOSupport提供一個AOP 攔截器。

46. Spring支持的ORM

Spring支持以下ORM：

• Hibernate
• iBatis
• JPA (Java Persistence API)
• TopLink
• JDO (Java Data Objects)
• OJB

47.如何通過HibernateDaoSupport將Spring和Hibernate結合起來？

用Spring的 SessionFactory 調用 LocalSessionFactory。集成過程分三步：

• 配置the Hibernate SessionFactory。
• 繼承HibernateDaoSupport實現一個DAO。
• 在AOP支持的事務中裝配。

48. Spring支持的事務管理類型

Spring支持兩種類型的事務管理：

• 編程式事務管理：這意味你通過編程的方式管理事務，給你帶來極大的靈活性，但是難維護。
• 聲明式事務管理：這意味着你可以將業務代碼和事務管理分離，你只需用註解和XML配置來管理事務。

49. Spring框架的事務管理有哪些優點？

• 它爲不同的事務API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一個不變的編程模式。
• 它爲編程式事務管理提供了一套簡單的API而不是一些複雜的事務API如
• 它支持聲明式事務管理。
• 它和Spring各種數據訪問抽象層很好得集成。

50. 你更傾向用那種事務管理類型？

大多數Spring框架的用戶選擇聲明式事務管理，因爲它對應用代碼的影響最小，因此更符合一個無侵入的輕量級容器的思想。聲明式事務管理要優於編程式事務管理，雖然比編程式事務管理（這種方式允許你通過代碼控制事務）少了一點靈活性。

Spring面向切面編程（AOP）

51. 解釋AOP

面向切面的編程，或AOP， 是一種編程技術，允許程序模塊化橫向切割關注點，或橫切典型的責任劃分，如日誌和事務管理。

52. Aspect 切面

AOP核心就是切面，它將多個類的通用行爲封裝成可重用的模塊，該模塊含有一組API提供橫切功能。比如，一個日誌模塊可以被稱作日誌的AOP切面。根據需求的不同，一個應用程序可以有若干切面。在Spring AOP中，切面通過帶有@Aspect註解的類實現。

52. 在Spring AOP 中，關注點和橫切關注的區別是什麼？

關注點是應用中一個模塊的行爲，一個關注點可能會被定義成一個我們想實現的一個功能。

橫切關注點是一個關注點，此關注點是整個應用都會使用的功能，並影響整個應用，比如日誌，安全和數據傳輸，幾乎應用的每個模塊都需要的功能。因此這些都屬於橫切關注點。

54. 連接點

連接點代表一個應用程序的某個位置，在這個位置我們可以插入一個AOP切面，它實際上是個應用程序執行Spring AOP的位置。

55. 通知

通知是個在方法執行前或執行後要做的動作，實際上是程序執行時要通過SpringAOP框架觸發的代碼段。

Spring切面可以應用五種類型的通知：

• before：前置通知，在一個方法執行前被調用。
• after: 在方法執行之後調用的通知，無論方法執行是否成功。
• after-returning: 僅當方法成功完成後執行的通知。
• after-throwing: 在方法拋出異常退出時執行的通知。
• around: 在方法執行之前和之後調用的通知。

56. 切點

切入點是一個或一組連接點，通知將在這些位置執行。可以通過表達式或匹配的方式指明切入點。

57. 什麼是引入?

引入允許我們在已存在的類中增加新的方法和屬性。

58. 什麼是目標對象?

被一個或者多個切面所通知的對象。它通常是一個代理對象。也指被通知（advised）對象。

59. 什麼是代理?

代理是通知目標對象後創建的對象。從客戶端的角度看，代理對象和目標對象是一樣的。

60. 有幾種不同類型的自動代理？

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

Metadata autoproxying

61. 什麼是織入。什麼是織入應用的不同點？

織入是將切面和到其他應用類型或對象連接或創建一個被通知對象的過程。

織入可以在編譯時，加載時，或運行時完成。

62. 解釋基於XML Schema方式的切面實現。

在這種情況下，切面由常規類以及基於XML的配置實現。

63. 解釋基於註解的切面實現

在這種情況下(基於@AspectJ的實現)，涉及到的切面聲明的風格與帶有java5標註的普通java類一致。

Spring 的MVC

64. 什麼是Spring的MVC框架？

Spring 配備構建Web 應用的全功能MVC框架。Spring可以很便捷地和其他MVC框架集成，如Struts，Spring 的MVC框架用控制反轉把業務對象和控制邏輯清晰地隔離。它也允許以聲明的方式把請求參數和業務對象綁定。

65. DispatcherServlet

Spring的MVC框架是圍繞DispatcherServlet來設計的，它用來處理所有的HTTP請求和響應。

66. WebApplicationContext

WebApplicationContext 繼承了ApplicationContext 並增加了一些WEB應用必備的特有功能，它不同於一般的ApplicationContext ，因爲它能處理主題，並找到被關聯的servlet。

67. 什麼是Spring MVC框架的控制器？

控制器提供一個訪問應用程序的行爲，此行爲通常通過服務接口實現。控制器解析用戶輸入並將其轉換爲一個由視圖呈現給用戶的模型。Spring用一個非常抽象的方式實現了一個控制層，允許用戶創建多種用途的控制器。

68. @Controller 註解

該註解表明該類扮演控制器的角色，Spring不需要你繼承任何其他控制器基類或引用Servlet API。

69. @RequestMapping 註解

該註解是用來映射一個URL到一個類或一個特定的方處理法上。

 

1、什麼是Spring框架？Spring框架有哪些主要模塊？

Spring框架是一個爲Java應用程序的開發提供了綜合、廣泛的基礎性支持的Java平臺。

 

 

Spring幫助開發者解決了開發中基礎性的問題，使得開發人員可以專注於應用程序的開發。

Spring框架本身亦是按照設計模式精心打造，這使得我們可以在開發環境中安心的集成Spring框架，不必擔心Spring是如何在後臺進行工作的。

Spring框架至今已集成了20多個模塊。這些模塊主要被分如下圖所示的核心容器、數據訪問/集成,、Web、AOP（面向切面編程）、工具、消息和測試模塊。

 

2、使用Spring框架能帶來哪些好處？

 

下面列舉了一些使用Spring框架帶來的主要好處：

• Dependency Injection(DI) 方法使得構造器和JavaBean properties文件中的依賴關係一目瞭然。
• 與EJB容器相比較，IoC容器更加趨向於輕量級。這樣一來IoC容器在有限的內存和CPU資源的情況下進行應用程序的開發和發佈就變得十分有利。
• Spring並沒有閉門造車，Spring利用了已有的技術比如ORM框架、logging框架、J2EE、Quartz和JDK Timer，以及其他視圖技術。
• Spring框架是按照模塊的形式來組織的。由包和類的編號就可以看出其所屬的模塊，開發者僅僅需要選用他們需要的模塊即可。
• 要測試一項用Spring開發的應用程序十分簡單，因爲測試相關的環境代碼都已經囊括在框架中了。更加簡單的是，利用JavaBean形式的POJO類，可以很方便的利用依賴注入來寫入測試數據。
• Spring的Web框架亦是一個精心設計的Web MVC框架，爲開發者們在web框架的選擇上提供了一個除了主流框架比如Struts、過度設計的、不流行web框架的以外的有力選項。
• Spring提供了一個便捷的事務管理接口，適用於小型的本地事物處理（比如在單DB的環境下）和複雜的共同事物處理（比如利用JTA的複雜DB環境）。

 

3、什麼是控制反轉(IOC)？什麼是依賴注入？

控制反轉是應用於軟件工程領域中的，在運行時被裝配器對象來綁定耦合對象的一種編程技巧，對象之間耦合關係在編譯時通常是未知的。在傳統的編程方式中，業務邏輯的流程是由應用程序中的早已被設定好關聯關係的對象來決定的。在使用控制反轉的情況下，業務邏輯的流程是由對象關係圖來決定的，該對象關係圖由裝配器負責實例化，這種實現方式還可以將對象之間的關聯關係的定義抽象化。而綁定的過程是通過“依賴注入”實現的。

控制反轉是一種以給予應用程序中目標組件更多控制爲目的設計範式，並在我們的實際工作中起到了有效的作用。

依賴注入是在編譯階段尚未知所需的功能是來自哪個的類的情況下，將其他對象所依賴的功能對象實例化的模式。這就需要一種機制用來激活相應的組件以提供特定的功能，所以依賴注入是控制反轉的基礎。否則如果在組件不受框架控制的情況下，框架又怎麼知道要創建哪個組件？

在Java中依然注入有以下三種實現方式：

1. 構造器注入
2. Setter方法注入
3. 接口注入

4、請解釋下Spring框架中的IoC？

Spring中的 org.springframework.beans 包和 org.springframework.context包構成了Spring框架IoC容器的基礎。

BeanFactory 接口提供了一個先進的配置機制，使得任何類型的對象的配置成爲可能。ApplicationContex接口對BeanFactory（是一個子接口）進行了擴展，在BeanFactory的基礎上添加了其他功能，比如與Spring的AOP更容易集成，也提供了處理message resource的機制（用於國際化）、事件傳播以及應用層的特別配置，比如針對Web應用的WebApplicationContext。

org.springframework.beans.factory.BeanFactory 是Spring IoC容器的具體實現，用來包裝和管理前面提到的各種bean。BeanFactory接口是Spring IoC 容器的核心接口。

IOC:把對象的創建、初始化、銷燬交給spring來管理，而不是由開發者控制，實現控制反轉。

 

 

5、BeanFactory和ApplicationContext有什麼區別？

 

BeanFactory 可以理解爲含有bean集合的工廠類。BeanFactory 包含了種bean的定義，以便在接收到客戶端請求時將對應的bean實例化。

BeanFactory還能在實例化對象的時生成協作類之間的關係。此舉將bean自身與bean客戶端的配置中解放出來。BeanFactory還包含了bean生命週期的控制，調用客戶端的初始化方法（initialization methods）和銷燬方法（destruction methods）。

從表面上看，application context如同bean factory一樣具有bean定義、bean關聯關係的設置，根據請求分發bean的功能。但applicationcontext在此基礎上還提供了其他的功能。

1. 提供了支持國際化的文本消息
2. 統一的資源文件讀取方式
3. 已在監聽器中註冊的bean的事件

以下是三種較常見的 ApplicationContext 實現方式：

1、ClassPathXmlApplicationContext：從classpath的XML配置文件中讀取上下文，並生成上下文定義。應用程序上下文從程序環境變量中取得。

1. ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);    

2、FileSystemXmlApplicationContext ：由文件系統中的XML配置文件讀取上下文。

1. ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);   

3、XmlWebApplicationContext：由Web應用的XML文件讀取上下文。

6、Spring有幾種配置方式？

將Spring配置到應用開發中有以下三種方式：

1. 基於XML的配置
2. 基於註解的配置
3. 基於Java的配置

7、如何用基於XML配置的方式配置Spring？

在Spring框架中，依賴和服務需要在專門的配置文件來實現，我常用的XML格式的配置文件。這些配置文件的格式通常用<beans>開頭，然後一系列的bean定義和專門的應用配置選項組成。

SpringXML配置的主要目的時候是使所有的Spring組件都可以用xml文件的形式來進行配置。這意味着不會出現其他的Spring配置類型（比如聲明的方式或基於Java Class的配置方式）

Spring的XML配置方式是使用被Spring命名空間的所支持的一系列的XML標籤來實現的。Spring有以下主要的命名空間：context、beans、jdbc、tx、aop、mvc和aso。

如：

1. <beans>    
2.     <!-- JSON Support -->    
3.     <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>    
4.     <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>    
5.     <bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>    
6. </beans>   

下面這個web.xml僅僅配置了DispatcherServlet，這件最簡單的配置便能滿足應用程序配置運行時組件的需求。

1. <web-app>    
2.     <display-name>Archetype Created Web Application</display-name>    
3.     <servlet>    
4.         <servlet-name>spring</servlet-name>    
5.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
6.         <load-on-startup>1</load-on-startup>    
7.     </servlet>    
8.     <servlet-mapping>    
9.         <servlet-name>spring</servlet-name>    
10.         <url-pattern>/</url-pattern>    
11.     </servlet-mapping>    
12. </web-app>   

 

8、如何用基於Java配置的方式配置Spring？

 

Spring對Java配置的支持是由@Configuration註解和@Bean註解來實現的。由@Bean註解的方法將會實例化、配置和初始化一個新對象，這個對象將由Spring的IoC容器來管理。@Bean聲明所起到的作用與<bean/> 元素類似。被@Configuration所註解的類則表示這個類的主要目的是作爲bean定義的資源。被@Configuration聲明的類可以通過在同一個類的內部調用@bean方法來設置嵌入bean的依賴關係。

最簡單的@Configuration 聲明類請參考下面的代碼：

1. @Configuration    
2. public class AppConfig{    
3.     @Bean    
4.     public MyService myService() {    
5.         return new MyServiceImpl();    
6.     }    
7. }   

對於上面的@Beans配置文件相同的XML配置文件如下：

1. <beans>    
2.     <bean id="myService" class="com.somnus.services.MyServiceImpl"/>    
3. </beans>   

上述配置方式的實例化方式如下：利用AnnotationConfigApplicationContext 類進行實例化

1. public static void main(String[] args) {    
2.     ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);    
3.     MyService myService = ctx.getBean(MyService.class);    
4.     myService.doStuff();    
5. }  

要使用組件組建掃描，僅需用@Configuration進行註解即可：

1. @Configuration    
2. @ComponentScan(basePackages = "com.somnus")    
3. public class AppConfig  {    
4.     ...    
5. }   

 

在上面的例子中，com.acme包首先會被掃到，然後再容器內查找被@Component 聲明的類，找到後將這些類按照Sring bean定義進行註冊。

如果你要在你的web應用開發中選用上述的配置的方式的話，需要用AnnotationConfigWebApplicationContext 類來讀取配置文件，可以用來配置Spring的Servlet監聽器ContextLoaderListener或者Spring MVC的DispatcherServlet。

1. <web-app>    
2.     <!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext    
3.         instead of the default XmlWebApplicationContext -->    
4.     <context-param>    
5.         <param-name>contextClass</param-name>    
6.         <param-value>    
7.             org.springframework.web.context.support.AnnotationConfigWebApplicationContext    
8.         </param-value>    
9.     </context-param>    
10.      
11.     <!-- Configuration locations must consist of one or more comma- or space-delimited    
12.         fully-qualified @Configuration classes. Fully-qualified packages may also be    
13.         specified for component-scanning -->    
14.     <context-param>    
15.         <param-name>contextConfigLocation</param-name>    
16.         <param-value>com.howtodoinjava.AppConfig</param-value>    
17.     </context-param>    
18.      
19.     <!-- Bootstrap the root application context as usual using ContextLoaderListener -->    
20.     <listener>    
21.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>    
22.     </listener>    
23.      
24.     <!-- Declare a Spring MVC DispatcherServlet as usual -->    
25.     <servlet>    
26.         <servlet-name>dispatcher</servlet-name>    
27.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
28.         <!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext    
29.             instead of the default XmlWebApplicationContext -->    
30.         <init-param>    
31.             <param-name>contextClass</param-name>    
32.             <param-value>    
33.                 org.springframework.web.context.support.AnnotationConfigWebApplicationContext    
34.             </param-value>    
35.         </init-param>    
36.         <!-- Again, config locations must consist of one or more comma- or space-delimited    
37.             and fully-qualified @Configuration classes -->    
38.         <init-param>    
39.             <param-name>contextConfigLocation</param-name>    
40.             <param-value>com.howtodoinjava.web.MvcConfig</param-value>    
41.         </init-param>    
42.     </servlet>    
43.      
44.     <!-- map all requests for /app/* to the dispatcher servlet -->    
45.     <servlet-mapping>    
46.         <servlet-name>dispatcher</servlet-name>    
47.         <url-pattern>/app/*</url-pattern>    
48.     </servlet-mapping>    
49. </web-app    

 

9、怎樣用註解的方式配置Spring？

Spring在2.5版本以後開始支持用註解的方式來配置依賴注入。可以用註解的方式來替代XML方式的bean描述，可以將bean描述轉移到組件類的內部，只需要在相關類上、方法上或者字段聲明上使用註解即可。註解注入將會被容器在XML注入之前被處理，所以後者會覆蓋掉前者對於同一個屬性的處理結果。

註解裝配在Spring中是默認關閉的。所以需要在Spring文件中配置一下才能使用基於註解的裝配模式。如果你想要在你的應用程序中使用關於註解的方法的話，請參考如下的配置。

1. <beans>    
2.    <context:annotation-config/>    
3.    <!-- bean definitions go here -->    
4. </beans>    

在 <context:annotation-config/>標籤配置完成以後，就可以用註解的方式在Spring中向屬性、方法和構造方法中自動裝配變量。

下面是幾種比較重要的註解類型：

1. @Required：該註解應用於設值方法。
2. @Autowired：該註解應用於有值設值方法、非設值方法、構造方法和變量。
3. @Qualifier：該註解和@Autowired註解搭配使用，用於消除特定bean自動裝配的歧義。
4. JSR-250 Annotations：Spring支持基於JSR-250 註解的以下註解，@Resource、@PostConstruct 和 @PreDestroy。

10、請解釋Spring Bean的生命週期？

Spring Bean的生命週期簡單易懂。在一個bean實例被初始化時，需要執行一系列的初始化操作以達到可用的狀態。同樣的，當一個bean不在被調用時需要進行相關的析構操作，並從bean容器中移除。

Spring bean factory 負責管理在spring容器中被創建的bean的生命週期。Bean的生命週期由兩組回調（call back）方法組成。

1. 初始化之後調用的回調方法。
2. 銷燬之前調用的回調方法。

Spring框架提供了以下四種方式來管理bean的生命週期事件：

• InitializingBean和DisposableBean回調接口
• 針對特殊行爲的其他Aware接口
• Bean配置文件中的Custom init()方法和destroy()方法
• @PostConstruct和@PreDestroy註解方式

使用customInit()和 customDestroy()方法管理bean生命週期的代碼樣例如下：

1. <beans>    
2.     <bean id="demoBean" class="com.somnus.task.DemoBean" init-method="customInit" destroy-method="customDestroy"></bean>    
3. </beans>    

11、Spring Bean的作用域之間有什麼區別？

Spring容器中的bean可以分爲5個範圍。所有範圍的名稱都是自說明的，但是爲了避免混淆，還是讓我們來解釋一下：

1. singleton：這種bean範圍是默認的，這種範圍確保不管接受到多少個請求，每個容器中只有一個bean的實例，單例的模式由bean factory自身來維護。
2. prototype：原形範圍與單例範圍相反，爲每一個bean請求提供一個實例。
3. request：在請求bean範圍內會每一個來自客戶端的網絡請求創建一個實例，在請求完成以後，bean會失效並被垃圾回收器回收。
4. Session：與請求範圍類似，確保每個session中有一個bean的實例，在session過期後，bean會隨之失效。
5. global-session：global-session和Portlet應用相關。當你的應用部署在Portlet容器中工作時，它包含很多portlet。如果你想要聲明讓所有的portlet共用全局的存儲變量的話，那麼這全局變量需要存儲在global-session中。

全局作用域與Servlet中的session作用域效果相同。

 

12、什麼是Spring inner beans？

 

在Spring框架中，無論何時bean被使用時，當僅被調用了一個屬性。一個明智的做法是將這個bean聲明爲內部bean。內部bean可以用setter注入“屬性”和構造方法注入“構造參數”的方式來實現。

比如，在我們的應用程序中，一個Customer類引用了一個Person類，我們的要做的是創建一個Person的實例，然後在Customer內部使用。

1. public class Customer{    
2.     private Person person;    
3.     //Setters and Getters    
4. }   
5. public class Person{    
6.     private String name;    
7.     private String address;    
8.     private int age;    
9.     //Setters and Getters    
10. }  

內部bean的聲明方式如下：

1. <bean id="CustomerBean" class="com.somnus.common.Customer">    
2.     <property name="person">    
3.         <!-- This is inner bean -->    
4.         <bean class="com.howtodoinjava.common.Person">    
5.             <property name="name" value="lokesh" />    
6.             <property name="address" value="India" />    
7.             <property name="age" value="34" />    
8.         </bean>    
9.     </property>    
10. </bean>   

 

13、Spring框架中的單例Beans是線程安全的麼？

Spring框架並沒有對單例bean進行任何多線程的封裝處理。關於單例bean的線程安全和併發問題需要開發者自行去搞定。但實際上，大部分的Spring bean並沒有可變的狀態(比如Serview類和DAO類)，所以在某種程度上說Spring的單例bean是線程安全的。如果你的bean有多種狀態的話（比如 View Model 對象），就需要自行保證線程安全。
最淺顯的解決辦法就是將多態bean的作用域由“singleton”變更爲“prototype”。

 

 

14、請舉例說明如何在Spring中注入一個Java Collection？

 

Spring提供了以下四種集合類的配置元素：

• <list> :   該標籤用來裝配可重複的list值。
• <set> :    該標籤用來裝配沒有重複的set值。
• <map>:   該標籤可用來注入鍵和值可以爲任何類型的鍵值對。
• <props> : 該標籤支持注入鍵和值都是字符串類型的鍵值對。

下面看一下具體的例子：

1. <beans>    
2.    <!-- Definition for javaCollection -->    
3.    <bean id="javaCollection" class="com.howtodoinjava.JavaCollection">    
4.       <!-- java.util.List -->    
5.       <property name="customList">    
6.         <list>    
7.            <value>INDIA</value>    
8.            <value>Pakistan</value>    
9.            <value>USA</value>    
10.            <value>UK</value>    
11.         </list>    
12.       </property>    
13.      
14.      <!-- java.util.Set -->    
15.      <property name="customSet">    
16.         <set>    
17.            <value>INDIA</value>    
18.            <value>Pakistan</value>    
19.            <value>USA</value>    
20.            <value>UK</value>    
21.         </set>    
22.       </property>    
23.      
24.      <!-- java.util.Map -->    
25.      <property name="customMap">    
26.         <map>    
27.            <entry key="1" value="INDIA"/>    
28.            <entry key="2" value="Pakistan"/>    
29.            <entry key="3" value="USA"/>    
30.            <entry key="4" value="UK"/>    
31.         </map>    
32.       </property>    
33.      
34.     <!-- java.util.Properties -->    
35.     <property name="customProperies">    
36.         <props>    
37.             <prop key="admin">[email protected]</prop>    
38.             <prop key="support">[email protected]</prop>    
39.         </props>    
40.     </property>    
41.      
42.    </bean>    
43. </beans>    

 

15、如何向Spring Bean中注入一個Java.util.Properties？

第一種方法是使用如下面代碼所示的<props> 標籤：

1. <bean id="adminUser" class="com.somnus.common.Customer">    
2.      
3.     <!-- java.util.Properties -->    
4.     <property name="emails">    
5.         <props>    
6.             <prop key="admin">[email protected]</prop>    
7.             <prop key="support">[email protected]</prop>    
8.         </props>    
9.     </property>    
10.      
11. </bean>   

也可用”util:”命名空間來從properties文件中創建出一個propertiesbean，然後利用setter方法注入bean的引用。
 

 

16、請解釋Spring Bean的自動裝配？

 

在Spring框架中，在配置文件中設定bean的依賴關係是一個很好的機制，Spring容器還可以自動裝配合作關係bean之間的關聯關係。這意味着Spring可以通過向Bean Factory中注入的方式自動搞定bean之間的依賴關係。自動裝配可以設置在每個bean上，也可以設定在特定的bean上。

下面的XML配置文件表明瞭如何根據名稱將一個bean設置爲自動裝配：

1. <bean id="employeeDAO" class="com.howtodoinjava.EmployeeDAOImpl" autowire="byName" />   

除了bean配置文件中提供的自動裝配模式，還可以使用@Autowired註解來自動裝配指定的bean。在使用@Autowired註解之前需要在按照如下的配置方式在Spring配置文件進行配置纔可以使用。

1. <context:annotation-config />  

也可以通過在配置文件中配置AutowiredAnnotationBeanPostProcessor 達到相同的效果。

1. <bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>    

配置好以後就可以使用@Autowired來標註了。

1. @Autowired    
2. public EmployeeDAOImpl ( EmployeeManager manager ) {    
3.     this.manager = manager;    
4. }  

 

 

17、請解釋自動裝配模式的區別？

 

在Spring框架中共有5種自動裝配，讓我們逐一分析。

1. no：這是Spring框架的默認設置，在該設置下自動裝配是關閉的，開發者需要自行在bean定義中用標籤明確的設置依賴關係。
2. byName：該選項可以根據bean名稱設置依賴關係。當向一個bean中自動裝配一個屬性時，容器將根據bean的名稱自動在在配置文件中查詢一個匹配的bean。如果找到的話，就裝配這個屬性，如果沒找到的話就報錯。
3. byType：該選項可以根據bean類型設置依賴關係。當向一個bean中自動裝配一個屬性時，容器將根據bean的類型自動在在配置文件中查詢一個匹配的bean。如果找到的話，就裝配這個屬性，如果沒找到的話就報錯。
4. constructor：造器的自動裝配和byType模式類似，但是僅僅適用於與有構造器相同參數的bean，如果在容器中沒有找到與構造器參數類型一致的bean，那麼將會拋出異常。
5. autodetect：該模式自動探測使用構造器自動裝配或者byType自動裝配。首先，首先會嘗試找合適的帶參數的構造器，如果找到的話就是用構造器自動裝配，如果在bean內部沒有找到相應的構造器或者是無參構造器，容器就會自動選擇byTpe的自動裝配方式。

18、如何開啓基於註解的自動裝配？

要使用 @Autowired，需要註冊 AutowiredAnnotationBeanPostProcessor，可以有以下兩種方式來實現：

1、引入配置文件中的<bean>下引入 <context:annotation-config>

1. <beans>    
2.     <context:annotation-config />    
3. </beans>   

2、在bean配置文件中直接引入AutowiredAnnotationBeanPostProcessor

1. <beans>    
2.     <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>    
3. </beans>    

 

19、請舉例解釋@Required註解？

在產品級別的應用中，IoC容器可能聲明瞭數十萬了bean，bean與bean之間有着複雜的依賴關係。設值註解方法的短板之一就是驗證所有的屬性是否被註解是一項十分困難的操作。可以通過在<bean>中設置“dependency-check”來解決這個問題。

在應用程序的生命週期中，你可能不大願意花時間在驗證所有bean的屬性是否按照上下文文件正確配置。或者你寧可驗證某個bean的特定屬性是否被正確的設置。即使是用“dependency-check”屬性也不能很好的解決這個問題，在這種情況下，你需要使用@Required 註解。

需要用如下的方式使用來標明bean的設值方法。

1. public class EmployeeFactoryBean extends AbstractFactoryBean<Object>{    
2.     private String designation;    
3.     public String getDesignation() {    
4.         return designation;    
5.     }    
6.     @Required    
7.     public void setDesignation(String designation) {    
8.         this.designation = designation;    
9.     }    
10.     //more code here    
11. }    

RequiredAnnotationBeanPostProcessor是Spring中的後置處理用來驗證被@Required 註解的bean屬性是否被正確的設置了。在使用RequiredAnnotationBeanPostProcesso來驗證bean屬性之前，首先要在IoC容器中對其進行註冊：

1. <bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />    

但是如果沒有屬性被用 @Required 註解過的話，後置處理器會拋出一個BeanInitializationException 異常。
 

 

20、請舉例解釋@Autowired註解？

 

@Autowired註解對自動裝配何時何處被實現提供了更多細粒度的控制。@Autowired註解可以像@Required註解、構造器一樣被用於在bean的設值方法上自動裝配bean的屬性，一個參數或者帶有任意名稱或帶有多個參數的方法。

比如，可以在設值方法上使用@Autowired註解來替代配置文件中的 <property>元素。當Spring容器在setter方法上找到@Autowired註解時，會嘗試用byType 自動裝配。

當然我們也可以在構造方法上使用@Autowired 註解。帶有@Autowired 註解的構造方法意味着在創建一個bean時將會被自動裝配，即便在配置文件中使用<constructor-arg> 元素。

1. public class TextEditor {    
2.    private SpellChecker spellChecker;    
3.    @Autowired    
4.    public TextEditor(SpellChecker spellChecker){    
5.       System.out.println("Inside TextEditor constructor." );    
6.       this.spellChecker = spellChecker;    
7.    }    
8.    public void spellCheck(){    
9.       spellChecker.checkSpelling();    
10.    }    
11. }    

下面是沒有構造參數的配置方式：

1. <beans>    
2.      
3.    <context:annotation-config/>    
4.      
5.    <!-- Definition for textEditor bean without constructor-arg  -->    
6.    <bean id="textEditor" class="com.howtodoinjava.TextEditor"/>    
7.      
8.    <!-- Definition for spellChecker bean -->    
9.    <bean id="spellChecker" class="com.howtodoinjava.SpellChecker"/>    
10.      
11. </beans>    

 

 

21、請舉例說明@Qualifier註解？

 

@Qualifier註解意味着可以在被標註bean的字段上可以自動裝配。Qualifier註解可以用來取消Spring不能取消的bean應用。

下面的示例將會在Customer的person屬性中自動裝配person的值。

1. public class Customer{    
2.     @Autowired    
3.     private Person person;    
4. }   

下面我們要在配置文件中來配置Person類。

 

1. <bean id="customer" class="com.somnus.common.Customer" />    
2.      
3. <bean id="personA" class="com.somnus.common.Person" >    
4.     <property name="name" value="lokesh" />    
5. </bean>    
6.      
7. <bean id="personB" class="com.somnus.common.Person" >    
8.     <property name="name" value="alex" />    
9. </bean>    

 

Spring會知道要自動裝配哪個person bean麼？不會的，但是運行上面的示例時，會拋出下面的異常：

1. Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:    
2.     No unique bean of type [com.howtodoinjava.common.Person] is defined:    
3.         expected single matching bean but found 2: [personA, personB]    

要解決上面的問題，需要使用 @Quanlifier註解來告訴Spring容器要裝配哪個bean：

1. public class Customer{    
2.     @Autowired    
3.     @Qualifier("personA")    
4.     private Person person;    
5. }  

 

22、構造方法注入和設值注入有什麼區別？

請注意以下明顯的區別：

1. 在設值注入方法支持大部分的依賴注入，如果我們僅需要注入int、string和long型的變量，我們不要用設值的方法注入。對於基本類型，如果我們沒有注入的話，可以爲基本類型設置默認值。在構造方法注入不支持大部分的依賴注入，因爲在調用構造方法中必須傳入正確的構造參數，否則的話爲報錯。
2. 設值注入不會重寫構造方法的值。如果我們對同一個變量同時使用了構造方法注入又使用了設置方法注入的話，那麼構造方法將不能覆蓋由設值方法注入的值。很明顯，因爲構造方法盡在對象被創建時調用。
3. 在使用設值注入時有可能還不能保證某種依賴是否已經被注入，也就是說這時對象的依賴關係有可能是不完整的。而在另一種情況下，構造器注入則不允許生成依賴關係不完整的對象。
4. 在設值注入時如果對象A和對象B互相依賴，在創建對象A時Spring會拋出sObjectCurrentlyInCreationException異常，因爲在B對象被創建之前A對象是不能被創建的，反之亦然。所以Spring用設值注入的方法解決了循環依賴的問題，因對象的設值方法是在對象被創建之前被調用的。

23、Spring框架中有哪些不同類型的事件？

Spring的ApplicationContext 提供了支持事件和代碼中監聽器的功能。

我們可以創建bean用來監聽在ApplicationContext 中發佈的事件。ApplicationEvent類和在ApplicationContext接口中處理的事件，如果一個bean實現了ApplicationListener接口，當一個ApplicationEvent 被髮布以後，bean會自動被通知。

1. public class AllApplicationEventListener implements ApplicationListener < ApplicationEvent >{    
2.     @Override    
3.     public void onApplicationEvent(ApplicationEvent applicationEvent)    
4.     {    
5.         //process event    
6.     }    
7. }    

 

Spring 提供了以下5中標準的事件：

1. 上下文更新事件（ContextRefreshedEvent）：該事件會在ApplicationContext被初始化或者更新時發佈。也可以在調用ConfigurableApplicationContext 接口中的refresh()方法時被觸發。
2. 上下文開始事件（ContextStartedEvent）：當容器調用ConfigurableApplicationContext的Start()方法開始/重新開始容器時觸發該事件。
3. 上下文停止事件（ContextStoppedEvent）：當容器調用ConfigurableApplicationContext的Stop()方法停止容器時觸發該事件。
4. 上下文關閉事件（ContextClosedEvent）：當ApplicationContext被關閉時觸發該事件。容器被關閉時，其管理的所有單例Bean都被銷燬。
5. 請求處理事件（RequestHandledEvent）：在Web應用中，當一個http請求（request）結束觸發該事件。

除了上面介紹的事件以外，還可以通過擴展ApplicationEvent 類來開發自定義的事件。

1. public class CustomApplicationEvent extends ApplicationEvent{    
2.     public CustomApplicationEvent ( Object source, final String msg ){    
3.         super(source);    
4.         System.out.println("Created a Custom event");    
5.     }    
6. }    

爲了監聽這個事件，還需要創建一個監聽器：

1. public class CustomEventListener implements ApplicationListener < CustomApplicationEvent >{    
2.     @Override    
3.     public void onApplicationEvent(CustomApplicationEvent applicationEvent) {    
4.         //handle event    
5.     }    
6. }    

之後通過applicationContext接口的publishEvent()方法來發布自定義事件。

1. CustomApplicationEvent customEvent = new CustomApplicationEvent(applicationContext, "Test message");    
2. applicationContext.publishEvent(customEvent);    

 

24、FileSystemResource和ClassPathResource有何區別？

在FileSystemResource 中需要給出spring-config.xml文件在你項目中的相對路徑或者絕對路徑。在ClassPathResource中spring會在ClassPath中自動搜尋配置文件，所以要把ClassPathResource 文件放在ClassPath下。

如果將spring-config.xml保存在了src文件夾下的話，只需給出配置文件的名稱即可，因爲src文件夾是默認。

簡而言之，ClassPathResource在環境變量中讀取配置文件，FileSystemResource在配置文件中讀取配置文件。

 

25、Spring 框架中都用到了哪些設計模式？

Spring框架中使用到了大量的設計模式，下面列舉了比較有代表性的：

• 代理模式—在AOP和remoting中被用的比較多。
• 單例模式—在spring配置文件中定義的bean默認爲單例模式。
• 模板方法—用來解決代碼重複的問題。比如. RestTemplate, JmsTemplate, JpaTemplate。
• 前端控制器—Spring提供了DispatcherServlet來對請求進行分發。
• 視圖幫助(View Helper )—Spring提供了一系列的JSP標籤，高效宏來輔助將分散的代碼整合在視圖裏。
• 依賴注入—貫穿於BeanFactory / ApplicationContext接口的核心理念。
• 工廠模式—BeanFactory用來創建對象的實例。

1.談談你對spring IOC和DI的理解，它們有什麼區別？

IoC Inverse of Control 反轉控制的概念，就是將原本在程序中手動創建UserService對象的控制權，交由Spring框架管理，簡單說，就是創建UserService對象控制權被反轉到了Spring框架

DI：Dependency Injection 依賴注入，在Spring框架負責創建Bean對象時，動態的將依賴對象注入到Bean組件

面試題： IoC 和 DI的區別？

IoC 控制反轉，指將對象的創建權，反轉到Spring容器 ， DI 依賴注入，指Spring創建對象的過程中，將對象依賴屬性通過配置進行注入

2.BeanFactory 接口和 ApplicationContext 接口有什麼區別 ？

    ①ApplicationContext 接口繼承BeanFactory接口，Spring核心工廠是BeanFactory ,BeanFactory採取延遲加載，第一次getBean時纔會初始化Bean, ApplicationContext是會在加載配置文件時初始化Bean。

    ②ApplicationContext是對BeanFactory擴展，它可以進行國際化處理、事件傳遞和bean自動裝配以及各種不同應用層的Context實現 

開發中基本都在使用ApplicationContext, web項目使用WebApplicationContext ，很少用到BeanFactory

 

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

IHelloService helloService = (IHelloService) beanFactory.getBean("helloService");

helloService.sayHello();

3.spring配置bean實例化有哪些方式？

    1）使用類構造器實例化(默認無參數)

 

<bean id="bean1" class="cn.itcast.spring.b_instance.Bean1"></bean>

    2）使用靜態工廠方法實例化(簡單工廠模式)

 

 

//下面這段配置的含義：調用Bean2Factory的getBean2方法得到bean2

<bean id="bean2" class="cn.itcast.spring.b_instance.Bean2Factory" factory-method="getBean2"></bean>

    3）使用實例工廠方法實例化(工廠方法模式)

 

 

//先創建工廠實例bean3Facory，再通過工廠實例創建目標bean實例

<bean id="bean3Factory" class="cn.itcast.spring.b_instance.Bean3Factory"></bean>

<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

4.簡單的說一下spring的生命週期？

    1)在配置 <bean> 元素，通過 init-method 指定Bean的初始化方法，通過 destroy-method 指定Bean銷燬方法

 

<beanid="lifeCycleBean"class="cn.itcast.spring.d_lifecycle.LifeCycleBean"init-method="setup"destroy-method="teardown"></bean>

需要注意的問題：

 

    *  destroy-method 只對 scope="singleton" 有效 

    *  銷燬方法，必須關閉ApplicationContext對象(手動調用)，纔會被調用

 

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

applicationContext.close();

    2)Bean的完整生命週期 （十一步驟）【瞭解內容，但是對於spring內部操作理解有一定幫助】

①instantiate bean對象實例化

②populate properties 封裝屬性

③如果Bean實現BeanNameAware 執行 setBeanName

④如果Bean實現BeanFactoryAware 或者 ApplicationContextAware 設置工廠 setBeanFactory 或者上下文對象 setApplicationContext

⑤如果存在類實現 BeanPostProcessor（後處理Bean） ，執行postProcessBeforeInitialization，BeanPostProcessor接口提供鉤子函數，用來動態擴展修改Bean。(程序自動調用後處理Bean)

 

publicclassMyBeanPostProcessorimplementsBeanPostProcessor{

publicObject postProcessAfterInitialization(Object bean,String beanName)

throwsBeansException{

System.out.println("第八步：後處理Bean，after初始化。");

//後處理Bean，在這裏加上一個動態代理，就把這個Bean給修改了。

return bean;//返回bean，表示沒有修改，如果使用動態代理，返回代理對象，那麼就修改了。

}

publicObject postProcessBeforeInitialization(Object bean,String beanName)

throwsBeansException{

System.out.println("第五步：後處理Bean的：before初始化！！");

//後處理Bean，在這裏加上一個動態代理，就把這個Bean給修改了。

return bean;//返回bean本身，表示沒有修改。

}

}

注意：這個前處理Bean和後處理Bean會對所有的Bean進行攔截。

⑥如果Bean實現InitializingBean 執行 afterPropertiesSet

 

⑦調用<bean init-method="init"> 指定初始化方法 init

⑧如果存在類實現 BeanPostProcessor（處理Bean） ，執行postProcessAfterInitialization

⑨執行業務處理

⑩如果Bean實現 DisposableBean 執行 destroy

⑪調用<bean destroy-method="customerDestroy"> 指定銷燬方法 customerDestroy

5.請介紹一下Spring框架中Bean的生命週期和作用域

 

(1)bean定義

    在配置文件裏面用<bean></bean>來進行定義。

(2)bean初始化

    有兩種方式初始化:

A.在配置文件中通過指定init-method屬性來完成

B.實現org.springframwork.beans.factory.InitializingBean接口

(3)bean調用

    有三種方式可以得到bean實例，並進行調用

(4)bean銷燬

    銷燬有兩種方式

A.使用配置文件指定的destroy-method屬性

B.實現org.springframwork.bean.factory.DisposeableBean接口

##作用域

singleton

當一個bean的作用域爲singleton, 那麼Spring IoC容器中只會存在一個共享的bean實例，並且所有對bean的請求，只要id與該bean定義相匹配，則只會返回bean的同一實例。

prototype

Prototype作用域的bean會導致在每次對該bean請求（將其注入到另一個bean中，或者以程序的方式調用容器的getBean() 方法）時都會創建一個新的bean實例。根據經驗，對所有有狀態的bean應該使用prototype作用域，而對無狀態的bean則應該使用 singleton作用域

request

在一次HTTP請求中，一個bean定義對應一個實例；即每次HTTP請求將會有各自的bean實例， 它們依據某個bean定義創建而成。該作用 域僅在基於web的Spring ApplicationContext情形下有效。

session

在一個HTTP Session中，一個bean定義對應一個實例。該作用域僅在基於web的Spring ApplicationContext情形下有效。

global session

在一個全局的HTTP Session中，一個bean定義對應一個實例。典型情況下，僅在使用portlet context的時候有效。該作用域僅在基於 web的Spring ApplicationContext情形下有效。

 

6.Bean注入屬性有哪幾種方式？

spring支持構造器注入和setter方法注入

    構造器注入，通過 <constructor-arg> 元素完成注入

    setter方法注入， 通過<property> 元素完成注入【開發中常用方式】

7.什麼是AOP，AOP的作用是什麼？

面向切面編程（AOP）提供另外一種角度來思考程序結構，通過這種方式彌補了面向對象編程（OOP）的不足，除了類（classes）以外，AOP提供了切面。切面對關注點進行模塊化，例如橫切多個類型和對象的事務管理

Spring的一個關鍵的組件就是AOP框架，可以自由選擇是否使用AOP 提供聲明式企業服務，特別是爲了替代EJB聲明式服務。最重要的服務是聲明性事務管理，這個服務建立在Spring的抽象事物管理之上。允許用戶實現自定義切面，用AOP來完善OOP的使用,可以把Spring AOP看作是對Spring的一種增強

8.Spring的核心類有哪些，各有什麼作用？

BeanFactory：產生一個新的實例，可以實現單例模式

BeanWrapper：提供統一的get及set方法

ApplicationContext:提供框架的實現，包括BeanFactory的所有功能

9.Spring裏面如何配置數據庫驅動？

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”數據源來配置數據庫驅動。示例如下：

1. <bean id=”dataSource”> 
2.     <property name=”driverClassName”> 
3.         <value>org.hsqldb.jdbcDriver</value>
4.     </property> 
5.     <property name=”url”> 
6.         <value>jdbc:hsqldb:db/appfuse</value> 
7.     </property> 
8.     <property name=”username”><value>abc</value></property> 
9.     <property name=”password”><value>abc</value></property> 
10. </bean> 

10.Spring裏面applicationContext.xml文件能不能改成其他文件名？

ContextLoaderListener是一個ServletContextListener, 它在你的web應用啓動的時候初始化。缺省情況下， 它會在WEB-INF/applicationContext.xml文件找Spring的配置。 你可以通過定義一個<context-param>元素名字爲”contextConfigLocation”來改變Spring配置文件的 位置。示例如下： 

 

1. <listener> 
2.     <listener-class>org.springframework.web.context.ContextLoaderListener
3.         <context-param> 
4.          <param-name>contextConfigLocation</param-name> 
5.          <param-value>/WEB-INF/xyz.xml</param-value> 
6.         </context-param>   
7.     </listener-class> 
8. </listener> 

11.Spring裏面如何定義hibernate mapping？

 

添加hibernate mapping 文件到web/WEB-INF目錄下的applicationContext.xml文件裏面。示例如下：

1. <property name=”mappingResources”> 
2.     <list> 
3.         <value>org/appfuse/model/User.hbm.xml</value> 
4.     </list> 
5. </property>

12.Spring如何處理線程併發問題？

Spring使用ThreadLocal解決線程安全問題

我們知道在一般情況下，只有無狀態的Bean纔可以在多線程環境下共享，在Spring中，絕大部分Bean都可以聲明爲singleton作用域。就是因爲Spring對一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非線程安全狀態採用ThreadLocal進行處理，讓它們也成爲線程安全的狀態，因爲有狀態的Bean就可以在多線程中共享了。

ThreadLocal和線程同步機制都是爲了解決多線程中相同變量的訪問衝突問題。

在同步機制中，通過對象的鎖機制保證同一時間只有一個線程訪問變量。這時該變量是多個線程共享的，使用同步機制要求程序慎密地分析什麼時候對變量進行讀寫，什麼時候需要鎖定某個對象，什麼時候釋放對象鎖等繁雜的問題，程序設計和編寫難度相對較大。

而ThreadLocal則從另一個角度來解決多線程的併發訪問。ThreadLocal會爲每一個線程提供一個獨立的變量副本，從而隔離了多個線程對數據的訪問衝突。因爲每一個線程都擁有自己的變量副本，從而也就沒有必要對該變量進行同步了。ThreadLocal提供了線程安全的共享對象，在編寫多線程代碼時，可以把不安全的變量封裝進ThreadLocal。

由於ThreadLocal中可以持有任何類型的對象，低版本JDK所提供的get()返回的是Object對象，需要強制類型轉換。但JDK5.0通過泛型很好的解決了這個問題，在一定程度地簡化ThreadLocal的使用。

概括起來說，對於多線程資源共享的問題，同步機制採用了“以時間換空間”的方式，而ThreadLocal採用了“以空間換時間”的方式。前者僅提供一份變量，讓不同的線程排隊訪問，而後者爲每一個線程都提供了一份變量，因此可以同時訪問而互不影響。

13.爲什麼要有事物傳播行爲？

14.介紹一下Spring的事物管理

    事務就是對一系列的數據庫操作（比如插入多條數據）進行統一的提交或回滾操作，如果插入成功，那麼一起成功，如果中間有一條出現異常，那麼回滾之前的所有操作。這樣可以防止出現髒數據，防止數據庫數據出現問題。

開發中爲了避免這種情況一般都會進行事務管理。Spring中也有自己的事務管理機制，一般是使用TransactionMananger進行管 理，可以通過Spring的注入來完成此功能。spring提供了幾個關於事務處理的類：

TransactionDefinition //事務屬性定義

TranscationStatus //代表了當前的事務，可以提交，回滾。

PlatformTransactionManager這個是spring提供的用於管理事務的基礎接口，其下有一個實現的抽象類 AbstractPlatformTransactionManager,我們使用的事務管理類例如 DataSourceTransactionManager等都是這個類的子類。

一般事務定義步驟：

 

1. TransactionDefinition td =newTransactionDefinition();
2. TransactionStatus ts = transactionManager.getTransaction(td);
3. try{ 
4.     //do sth
5.     transactionManager.commit(ts);
6. }catch(Exception e){
7.     transactionManager.rollback(ts);
8. }

    spring提供的事務管理可以分爲兩類：編程式的和聲明式的。編程式的，比較靈活，但是代碼量大，存在重複的代碼比較多；聲明式的比編程式的更靈活。

 

編程式主要使用transactionTemplate。省略了部分的提交，回滾，一系列的事務對象定義，需注入事務管理對象.

 

1. void add(){
2.     transactionTemplate.execute(newTransactionCallback(){
3.         pulic Object doInTransaction(TransactionStatus ts){
4.          //do sth
5.         }
6.     }
7. }

聲明式：

 

使用TransactionProxyFactoryBean:PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

圍繞Poxy的動態代理 能夠自動的提交和回滾事務

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持當前事務，如果當前沒有事務，就新建一個事務。這是最常見的選擇。

PROPAGATION_SUPPORTS–支持當前事務，如果當前沒有事務，就以非事務方式執行。

PROPAGATION_MANDATORY–支持當前事務，如果當前沒有事務，就拋出異常。

PROPAGATION_REQUIRES_NEW–新建事務，如果當前存在事務，把當前事務掛起。

PROPAGATION_NOT_SUPPORTED–以非事務方式執行操作，如果當前存在事務，就把當前事務掛起。

PROPAGATION_NEVER–以非事務方式執行，如果當前存在事務，則拋出異常。

PROPAGATION_NESTED–如果當前存在事務，則在嵌套事務內執行。如果當前沒有事務，則進行與 PROPAGATION_REQUIRED類似的操作。

15.解釋一下Spring AOP裏面的幾個名詞

切面（Aspect）：一個關注點的模塊化，這個關注點可能會橫切多個對象。事務管理是J2EE應用中一個關於橫切關注點的很好的例子。 在Spring AOP中，切面可以使用通用類（基於模式的風格） 或者在普通類中以 @Aspect 註解（@AspectJ風格）來實現。

連接點（Joinpoint）：在程序執行過程中某個特定的點，比如某方法調用的時候或者處理異常的時候。 在Spring AOP中，一個連接點 總是 代表一個方法的執行。 通過聲明一個org.aspectj.lang.JoinPoint類型的參數可以使通知（Advice）的主體部分獲得連接點信息。

通知（Advice）：在切面的某個特定的連接點（Joinpoint）上執行的動作。通知有各種類型，其中包括“around”、“before”和“after”等通知。 通知的類型將在後面部分進行討論。許多AOP框架，包括Spring，都是以攔截器做通知模型， 並維護一個以連接點爲中心的攔截器鏈。

切入點（Pointcut）：匹配連接點（Joinpoint）的斷言。通知和一個切入點表達式關聯，並在滿足這個切入點的連接點上運行（例如，當執行某個特定名稱的方法時）。 切入點表達式如何和連接點匹配是AOP的核心：Spring缺省使用AspectJ切入點語法。

引入（Introduction）：（也被稱爲內部類型聲明（inter-type declaration））。聲明額外的方法或者某個類型的字段。 Spring允許引入新的接口（以及一個對應的實現）到任何被代理的對象。例如，你可以使用一個引入來使bean實現 IsModified 接口，以便簡化緩存機制。

目標對象（Target Object）： 被一個或者多個切面（aspect）所通知（advise）的對象。也有人把它叫做 被通知（advised） 對象。 既然Spring AOP是通過運行時代理實現的，這個對象永遠是一個 被代理（proxied） 對象。

AOP代理（AOP Proxy）： AOP框架創建的對象，用來實現切面契約（aspect contract）（包括通知方法執行等功能）。 在Spring中，AOP代理可以是JDK動態代理或者CGLIB代理。 注意：Spring 2.0最新引入的基於模式（schema-based）風格和@AspectJ註解風格的切面聲明，對於使用這些風格的用戶來說，代理的創建是透明的。

織入（Weaving）：把切面（aspect）連接到其它的應用程序類型或者對象上，並創建一個被通知（advised）的對象。 這些可以在編譯時（例如使用AspectJ編譯器），類加載時和運行時完成。 Spring和其他純Java AOP框架一樣，在運行時完成織入。

16.通知有哪些類型？

前置通知（Before advice）：在某連接點（join point）之前執行的通知，但這個通知不能阻止連接點前的執行（除非它拋出一個異常）。

返回後通知（After returning advice）：在某連接點（join point）正常完成後執行的通知：例如，一個方法沒有拋出任何異常，正常返回。 
拋出異常後通知（After throwing advice）：在方法拋出異常退出時執行的通知。 
後通知（After (finally) advice）：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）。 
環繞通知（Around Advice）：包圍一個連接點（join point）的通知，如方法調用。這是最強大的一種通知類型。 環繞通知可以在方法調用前後完成自定義的行爲。它也會選擇是否繼續執行連接點或直接返回它們自己的返回值或拋出異常來結束執行。 
  
環繞通知是最常用的一種通知類型。大部分基於攔截的AOP框架，例如Nanning和JBoss4，都只提供環繞通知。 
切入點（pointcut）和連接點（join point）匹配的概念是AOP的關鍵，這使得AOP不同於其它僅僅提供攔截功能的舊技術。 切入點使得定位通知（advice）可獨立於OO層次。 例如，一個提供聲明式事務管理的around通知可以被應用到一組橫跨多個對象中的方法上（例如服務層的所有業務操作）。

-------------------------------------------------------------------------------------------------------------------------------------------------------------

--本文屬於博主轉載收藏最後發文

--原文鏈接供參考

https://blog.csdn.net/hrbeuwhw/article/details/79476988