spring面試大全

1、spring如何實現資源管理?
使用
applicationContext.getResource(「classpath:文件名」):在src根目錄下，在類路徑下
applicationContext.getResource(「classpath:/chap01/文件名」): 以src根目錄下的基準往下走。
applicationContext.getResource(「file:c:/a.properties」)：在系統文件目錄下。

2、請介紹一下Spring框架中Bean的做用域
在spring2.0以前bean只有2種做用域即：singleton(單例)、non-singleton（也稱 prototype），Spring2.0之後，增長了session、request、global session三種專用於Web應用程序上下文的Bean。所以，默認狀況下Spring2.0如今有五種類型的Bean。

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 scope=」singleton」/>

這裏的scope就是用來配置spring bean的做用域，它標識bean的做用域。

在spring2.0以前bean只有2種做用域即：singleton(單例)、non-singleton（也稱 prototype），Spring2.0之後，增長了session、request、global session三種專用於Web應用程序上下文的Bean。所以，默認狀況下Spring2.0如今有五種類型的Bean。固然，Spring2.0對 Bean的類型的設計進行了重構，並設計出靈活的Bean類型支持，理論上能夠有無數多種類型的Bean，用戶能夠根據本身的須要，增長新的Bean類型，知足實際應用需求。

一、singleton做用域

當一個bean的做用域設置爲singleton，那麼Spring IOC容器中只會存在一個共享的bean實例，而且全部對bean的請求，只要id與該bean定義相匹配，則只會返回bean的同一實例。換言之，當把一個bean定義設置爲singleton做用域時，Spring IOC容器只會建立該bean定義的惟一實例。這個單一實例會被存儲到單例緩存（singleton cache）中，而且全部針對該bean的後續請求和引用都將返回被緩存的對象實例，這裏要注意的是singleton做用域和GOF設計模式中的單例是徹底不一樣的，單例設計模式表示一個ClassLoader中只有一個class存在，而這裏的singleton則表示一個容器對應一個bean，也就是說當一個bean被標識爲singleton時候，spring的IOC容器中只會存在一個該bean。

配置實例：

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 scope=」singleton」/>

或者

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 singleton=」true」/>

二、prototype

prototype做用域部署的bean，每一次請求（將其注入到另外一個bean中，或者以程序的方式調用容器的getBean()方法）都會產生一個新的bean實例，至關於一個new的操做，對於prototype做用域的bean，有一點很是重要，那就是Spring不能對一個 prototype bean的整個生命週期負責，容器在初始化、配置、裝飾或者是裝配完一個prototype實例後，將它交給客戶端，隨後就對該prototype實例漠不關心了。無論何種做用域，容器都會調用全部對象的初始化生命週期回調方法，而對prototype而言，任何配置好的析構生命週期回調方法都將不會被調用。清除prototype做用域的對象並釋聽任何prototype bean所持有的昂貴資源，都是客戶端代碼的職責。（讓Spring容器釋放被singleton做用域bean佔用資源的一種可行方式是，經過使用 bean的後置處理器，該處理器持有要被清除的bean的引用。）

配置實例：

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 scope=」prototype」/>

或者

<beanid=」role」 class=」spring.chapter2.maryGame.Role」 singleton=」false」/>

三、request

request表示該針對每一次HTTP請求都會產生一個新的bean，同時該bean僅在當前HTTP request內有效，配置實例：

request、session、global session使用的時候，首先要在初始化web的web.xml中作以下配置：

若是你使用的是Servlet 2.4及以上的web容器，那麼你僅須要在web應用的XML聲明文件web.xml中增長下述ContextListener便可：

<web-app>
…
<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>
…
</web-app>

若是是Servlet2.4之前的web容器,那麼你要使用一個javax.servlet.Filter的實現：

<web-app>
..
<filter>
<filter-name>requestContextFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
…
</web-app>

接着既能夠配置bean的做用域了：

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 scope=」request」/>
四、session

session做用域表示該針對每一次HTTP請求都會產生一個新的bean，同時該bean僅在當前HTTP session內有效，配置實例：

配置實例：

和request配置實例的前提同樣，配置好web啓動文件就能夠以下配置：

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 scope=」session」/>

五、global session

global session做用域相似於標準的HTTP Session做用域，不過它僅僅在基於portlet的web應用中才有意義。Portlet規範定義了全局Session的概念，它被全部構成某個 portlet web應用的各類不一樣的portlet所共享。在global session做用域中定義的bean被限定於全局portlet Session的生命週期範圍內。若是你在web中使用global session做用域來標識bean，那麼，web會自動當成session類型來使用。

配置實例：

和request配置實例的前提同樣，配置好web啓動文件就能夠以下配置：

<bean id=」role」 class=」spring.chapter2.maryGame.Role」 scope=」global session」/>

六、自定義bean裝配做用域

在spring 2.0中做用域是能夠任意擴展的，你能夠自定義做用域，甚至你也能夠從新定義已有的做用域（可是你不能覆蓋singleton和 prototype），spring的做用域由接口org.springframework.beans.factory.config.Scope來定義，自定義本身的做用域只要實現該接口便可，下面給個實例：

咱們創建一個線程的scope，該scope在表示一個線程中有效，代碼以下：

publicclass MyScope implements Scope …{
privatefinal ThreadLocal threadScope = new ThreadLocal() …{
protected Object initialValue() …{
returnnew HashMap();
}
};
public Object get(String name, ObjectFactory objectFactory) …{
Map scope = (Map) threadScope.get();
Object object = scope.get(name);
if(object==null) …{
object = objectFactory.getObject();
scope.put(name, object);
}
return object;
}
public Object remove(String name) …{
Map scope = (Map) threadScope.get();
return scope.remove(name);
}
publicvoid registerDestructionCallback(String name, Runnable callback) …{
}
public String getConversationId() …{
// TODO Auto-generated method stub
returnnull;
}
}

3、Spring如何配置一個bean來從JNDI獲得DataSource
<bean id=」dataSource」 class=」org.springframework.jndi.JndiObjectFactoryBean」>
<property name=」jndiName」> <value>Java:comp/env/jdbc/myDatasource</value>
</property>
</bean>

4、Spring如何建立一個數據鏈接池
<bean id=」dataSource」 class=」org.apache.commons.dbcp.BasicDataSource」>
<property name=」driver」>
<value>${db.driver}</value>
</property>
<property name=」url」>
<value>${db.url}</value>
</property>
<property name=」username」>
<value>${db.username}</value>
</property>
<property name=」password」>
<value>${db.password}</value>
</property>
</bean>

5、在Spring框架中如何更加高效的使用JDBC
使用Spring框架提供的模板類JdbcTemplete能夠是JDBC更加高效

代碼以下：JdbcTemplate template = new JdbcTemplate(myDataSource);

DAO類的例子：

public class StudentDaoJdbc implements StudentDao {
private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
more..
}

配置文件：

<bean id=」jdbcTemplate」 class=」org.springframework.jdbc.core.JdbcTemplate」>
<property name=」dataSource」>
<ref bean=」dataSource」/>
</property>
</bean>
<bean id=」studentDao」 class=」StudentDaoJdbc」>
<property name=」jdbcTemplate」>
<ref bean=」jdbcTemplate」/>
</property>
</bean>
<bean id=」courseDao」 class=」CourseDaoJdbc」>
<property name=」jdbcTemplate」>
<ref bean=」jdbcTemplate」/>
</property>
</bean>

6、請你談談SSH整合
SSH：
Struts（表示層）+Spring（業務層）+hibernate（持久層）
Struts：
Struts是一個表示層框架，主要做用是界面展現，接收請求，分發請求。
在MVC框架中，Struts屬於VC層次，負責界面表現，負責MVC關係的分發。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）
Hibernate：
Hibernate是一個持久層框架，它只負責與關係數據庫的操做。
Spring：
Spring是一個業務層框架，是一個整合的框架，可以很好地黏合表示層與持久層。

7、一些Spring和Hibernate的面試題(附答案)
一、 簡述你對IoC（Inversion of Control）的理解，描述一下Spring中實現DI（Dependency Injection）的幾種方式。

二、 Spring的Bean有多種做用域，包括：

singleton、prototype、request、session、global session、application、自定義

三、 簡單描述Spring framework與Struts的不一樣之處，整合Spring與Struts有哪些方法，哪一種最好，爲何？

四、 Hibernate中的update()和saveOrUpdate()的區別

五、 Spring對多種ORM框架提供了很好的支持，簡單描述在Spring中使用Hibernate的方法，並結合事務管理。

答案：

一、好萊塢原則????不要打電話找我，我會打給你的。IoC將建立的職責從應用程序代碼搬到了框架中。Spring對Setter注入和構造方法注入提供支持。（詳見http://martinfowler.com/articles/injection.html，以及http: //www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators）

二、 除application（詳見Spring framework 2.0 Reference的3.4節bean的做用域）

三、 Spring是完整的一站式框架，而Struts僅是MVC框架，且着重於MVC中的C。Spring有三種方式整合Struts：使用 Spring 的 ActionSupport 類整合 Struts；使用 Spring 的 DelegatingRequestProcessor 覆蓋 Struts 的 RequestProcessor；將 Struts Action 管理委託給 Spring 框架，動做委託最好。（詳見使用Spring 更好地處理Struts 動做）

Spring 2.0新增一種方式：AutowiringRequestProcessor。（詳見http://www.javaeye.com/topic/24239）

四、 saveOrUpdate()方法能夠實現update()的功能，但會多些步驟，具體以下：

若是對象在該session中已經被持久化，不進行操做；

對象的標識符屬性(identifier property)在數據庫中不存在或者是個暫時的值，調用save()方法保存它；

若是session中的另外一個對象有相同的標識符拋出一個異常；

以上皆不符合則調用update()更新之。

五、 在context中定義DataSource，建立SessionFactoy，設置參數；DAO類繼承HibernateDaoSupport，實現具體接口，從中得到HibernateTemplate進行具體操做。

在使用中若是遇到OpenSessionInView的問題，能夠添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。（詳見Spring framework 2.0 Reference的12.2節Hibernate）

聲明式事務需聲明事務管理器，在context中設置指定屬性，用肯定和。

8、Struts，Spring，Hibernate面試題總結
轉載地址：http://blog.csdn.net/David8631/archive/2008/07/19/2676615.aspx

Hibernate工做原理及爲何要用？

原理：

1. 讀取並解析配置文件
2. 讀取並解析映射信息，建立SessionFactory
3. 打開Sesssion
4. 建立事務Transation
5. 持久化操做
6. 提交事務
7. 關閉Session
8. 關閉SesstionFactory

爲何要用：

* 對JDBC訪問數據庫的代碼作了封裝，大大簡化了數據訪問層繁瑣的重複性代碼。
* Hibernate是一個基於JDBC的主流持久化框架，是一個優秀的ORM實現。他很大程度的簡化DAO層的編碼工做
* hibernate使用Java反射機制，而不是字節碼加強程序來實現透明性。
* hibernate的性能很是好，由於它是個輕量級框架。映射的靈活性很出色。它支持各類關係數據庫，從一對一到多對多的各類複雜關係。

Hibernate是如何延遲加載?

* Hibernate2延遲加載實現：a)實體對象  b)集合（Collection）
* Hibernate3 提供了屬性的延遲加載功能

當Hibernate在查詢數據的時候，數據並無存在與內存中，當程序真正對數據的操做時，對象才存在與內存中，就實現了延遲加載，他節省了服務器的內存開銷，從而提升了服務器的性能。
Hibernate中怎樣實現類之間的關係?(如：一對多、多對多的關係)
類與類之間的關係主要體如今表與表之間的關係進行操做，它們都市對對象進行操做，咱們程序中把全部的表與類都映射在一塊兒，它們經過配置文件中的many-to-one、one-to-many、many-to-many、

說下Hibernate的緩存機制

* 內部緩存存在Hibernate中又叫一級緩存，屬於應用事物級緩存
* 二級緩存：

a)應用及緩存

b)分佈式緩存

條件：數據不會被第三方修改、數據大小在可接受範圍、數據更新頻率低、同一數據被系統頻繁使用、非              關鍵數據

c)  第三方緩存的實現
Hibernate的查詢方式
Sql、Criteria,object comptosition
Hql：

* 屬性查詢
* 參數查詢、命名參數查詢
* 關聯查詢
* 分頁查詢
* 統計函數

如何優化Hibernate？

* 使用雙向一對多關聯，不使用單向一對多
* 靈活使用單向一對多關聯
* 不用一對一，用多對一取代
* 配置對象緩存，不使用集合緩存
* 一對多集合使用Bag,多對多集合使用Set
* 繼承類使用顯式多態
* 表字段要少，表關聯不要怕多，有二級緩存撐腰

Struts工做機制？爲何要使用Struts？
工做機制：
Struts的工做流程:
在web應用啓動時就會加載初始化ActionServlet,ActionServlet從struts-config.xml文件中讀取配置信息,把它們存放到各類配置對象當ActionServlet接收到一個客戶請求時,將執行以下流程.
(1)檢索和用戶請求匹配的ActionMapping實例,若是不存在,就返回請求路徑無效信息;
(2)若是ActionForm實例不存在,就建立一個ActionForm對象,把客戶提交的表單數據保存到ActionForm對象中;
(3)根據配置信息決定是否須要表單驗證.若是須要驗證,就調用ActionForm的validate()方法;
(4)若是ActionForm的validate()方法返回null或返回一個不包含ActionMessage的ActuibErrors對象, 就表示表單驗證成功;
(5)ActionServlet根據ActionMapping所包含的映射信息決定將請求轉發給哪一個Action,若是相應的Action實例不存在,就先建立這個實例,而後調用Action的execute()方法;
(6)Action的execute()方法返回一個ActionForward對象,ActionServlet在把客戶請求轉發給ActionForward對象指向的JSP組件;
(7)ActionForward對象指向JSP組件生成動態網頁,返回給客戶;

爲何要用：
JSP、Servlet、JavaBean技術的出現給咱們構建強大的企業應用系統提供了可能。但用這些技術構建的系統很是的繁亂，因此在此之上，咱們須要一個規則、一個把這些技術組織起來的規則，這就是框架，Struts便應運而生。

基於Struts開發的應用由3類組件構成：控制器組件、模型組件、視圖組件
Struts的validate框架是如何驗證的？
在struts配置文件中配置具體的錯誤提示，再在FormBean中的validate()方法具體調用。

說下Struts的設計模式
MVC模式:  web應用程序啓動時就會加載並初始化ActionServler。用戶提交表單時，一個配置好的ActionForm對象被建立，並被填入表單相應的數據，ActionServler根據Struts-config.xml 文件配置好的設置決定是否須要表單驗證，若是須要就調用ActionForm的Validate（）驗證後選擇將請求發送到哪一個Action，若是 Action不存在，ActionServlet會先建立這個對象，而後調用Action的execute（）方法。Execute（）從 ActionForm對象中獲取數據，完成業務邏輯，返回一個ActionForward對象，ActionServlet再把客戶請求轉發給 ActionForward對象指定的jsp組件，ActionForward對象指定的jsp生成動態的網頁，返回給客戶。

單例模式

Factory(工廠模式)：

定義一個基類===》實現基類方法（子類經過不一樣的方法）===》定義一個工廠類（生成子類實例）

===》開發人員調用基類方法

Proxy(代理模式)

spring工做機制及爲何要用?
1.spring mvc請全部的請求都提交給DispatcherServlet,它會委託應用系統的其餘模塊負責負責對請求進行真正的處理工做。
2.DispatcherServlet查詢一個或多個HandlerMapping,找處處理請求的Controller.
3.DispatcherServlet請請求提交到目標Controller
4.Controller進行業務邏輯處理後，會返回一個ModelAndView
5.Dispathcher查詢一個或多個ViewResolver視圖解析器,找到ModelAndView對象指定的視圖對象
6.視圖對象負責渲染返回給客戶端。

爲何用：
AOP 讓開發人員能夠建立非行爲性的關注點，稱爲橫切關注點，並將它們插入到應用程序代碼中。使用 AOP 後，公共服務   （比 如日誌、持久性、事務等）就能夠分解成方面並應用到域對象上，同時不會增長域對象的對象模型的複雜性。

IOC 容許建立一個能夠構造對象的應用環境，而後向這些對象傳遞它們的協做對象。正如單詞 倒置 所代表的，IOC 就像反      過來的 JNDI。沒有使用一堆抽象工廠、服務定位器、單元素（singleton）和直接構造（straight construction），每個對象都是用     其協做對象構造的。所以是由容器管理協做對象（collaborator）。

Spring即便一個AOP框架，也是一IOC容器。 Spring 最好的地方是它有助於您替換對象。有了 Spring，只要用 JavaBean 屬性和配置文件加入依賴性（協做對象）。而後能夠很容易地在須要時替換具備相似接口的協做對象。

9、什麼是Spring, 它有什麼特色
Spring是一個輕量級的控制反轉(IoC)和麪向切面(AOP)的容器框架。

◆輕量——從大小與開銷兩方面而言Spring都是輕量的。完整的Spring框架能夠在一個大小隻有1MB多的JAR文件裏發佈。並 且Spring所需的處理開銷也是微不足道的。此外，Spring是非侵入式的：典型地，Spring應用中的對象不依賴於Spring的特定類。

◆控制反轉——Spring經過一種稱做控制反轉（IoC）的技術促進了鬆耦 合。當應用了IoC，一個對象依賴的其它對象會經過被動的方式傳遞進來，而不是這個對象本身建立或者查找依賴對象。你能夠認爲IoC與JNDI相反——不 是對象從容器中查找依賴，而是容器在對象初始化時不等對象請求就主動將依賴傳遞給它。
◆面向切面——Spring提供了面向切面編程的豐富支持，容許經過分離應用的 業務邏輯與系統級服務（例如審計（auditing）和事務（）管理）進行內聚性的開發。應用對象只實現它們應該作的——完成業務邏輯——僅此而已。它們 並不負責（甚至是意識）其它的系統級關注點，例如日誌或事務支持。
◆容器——Spring包含並管理應用對象的配置和生命週期，在這個意義上它是 一種容器，你能夠配置你的每一個bean如何被建立——基於一個可配置原型（prototype），你的bean能夠建立一個單獨的實例或者每次須要時都生 成一個新的實例——以及它們是如何相互關聯的。然而，Spring不該該被混同於傳統的重量級的EJB容器，它們常常是龐大與笨重的，難以使用。
◆框架——Spring能夠將簡單的組件配置、組合成爲複雜的應用。在Spring中，應用對象被聲明式地組合，典型地是在一個XML文件裏。Spring也提供了不少基礎功能（事務管理、持久化框架集成等等），將應用邏輯的開發留給了你。

10、使用Spring有什麼好處
◆Spring能有效地組織你的中間層對象,不管你是否選擇使用了EJB。若是你僅僅使用了Struts或其餘的包含了J2EE特有APIs的framework，你會發現Spring關注了遺留下的問題，。

◆Spring能消除在許多工程上對Singleton的過多使用。根據個人經驗，這是一個主要的問題，它減小了系統的可測試性和麪向對象特性。
◆Spring能消除使用各類各樣格式的屬性定製文件的須要,在整個應用和工程中，可經過一種 一致的方法來進行配置。曾經感到迷惑，一個特定類要查找迷幻般的屬性關鍵字或系統屬性,爲此不得不讀Javadoc乃至源編碼嗎？有了Spring，你可 很簡單地看到類的JavaBean屬性。倒置控制的使用(在下面討論)幫助完成這種簡化。
◆Spring能經過接口而不是類促進好的編程習慣，減小編程代價到幾乎爲零。
◆Spring被設計爲讓使用它建立的應用盡量少的依賴於他的APIs。在Spring應用中的大多數業務對象沒有依賴於Spring。
◆使用Spring構建的應用程序易於單元測試。
◆Spring能使EJB的使用成爲一個實現選擇,而不是應用架構的必然選擇。你能選擇用POJOs或local EJBs來實現業務接口，卻不會影響調用代碼。
◆Spring幫助你解決許多問題而無需使用EJB。Spring能提供一種EJB的替換物，它們適於許多web應用。例如,Spring能使用AOP提供聲明性事務而不經過使用EJB容器，若是你僅僅須要與單個的數據庫打交道，甚至不須要JTA實現。
■Spring爲數據存取提供了一致的框架,不管是使用JDBC或O/R mapping產品（如Hibernate）。
Spring確實使你能經過最簡單可行的解決辦法解決你的問題。這些特性是有很大價值的。
總結起來，Spring有以下優勢：
◆低侵入式設計，代碼污染極低
◆ 獨立於各類應用服務器，能夠真正實現Write Once,Run Anywhere的承諾
◆Spring的DI機制下降了業務對象替換的複雜性
◆Spring並不徹底依賴於Spring，開發者可自由選用Spring框架的部分或所有

11、Spring框架有哪幾部分組成？
Spring框架有七個模塊組成組成，這7個模塊(或組件)都可以單獨存在，也能夠與其它一個或多個模塊聯合使用，主要功能表現以下：

? Spring 核心容器（Core）：提供Spring框架的基本功能。核心容器的主要組件是BeanFactory，她是工廠模式的實現。BeanFactory使用控制反轉（Ioc）模式將應用程序的配置和依賴性規範與實際的應用代碼程序分開。

? Spring AOP：經過配置管理特性，Spring AOP模塊直接面向方面的編程功能集成到了Spring框架中，因此能夠很容易的使Spring框架管理的任何對象支持 AOP。Spring AOP模塊爲基於Spring的應用程序中的對象提供了事務管理服務。經過使用Spring AOP，不用依賴於EJB組件，就能夠將聲明性事務管理集成到應用程序中。

? Spring ORM：Spring框架集成了若干ORM框架,從而提供了ORM的對象關係工具,其中包括 JDO、Hibernate、iBatis和TopLink。全部這些都聽從Spring的通用事務和DAO異常層結構。

? Spring DAO：JDBC DAO抽象層提供了有意義的異常層次的結構，可用該結構來管理異常處理和不一樣數據供應商拋出的異常錯誤信息。異常層次結構簡化了錯誤處理，而且大大的下降 了須要編寫的異常代碼數量（例如，打開和關係鏈接）。Spring DAO的面向JDBC的異常聽從通用的DAO異常層結構。

? Spring WEB：Web上下文模塊創建在上下文模塊（Context）的基礎之上，爲基於Web服務的應用程序提供了上下文的服務。因此Spring框架支持 Jakarta Struts的集成。Web模塊還簡化了處理多部分請求及將請求參數綁定到域對象的工做。

? Spring上下文（Context）：Spring上下文是一個配置文件，向Spring框架提供上下文信息。Spring上下文包括企業服務，例如 JNDI、EJB、電子郵件、國際化校驗和調度功能。

? Spring MVC：Spring的MVC框架是一個全功能的構建Web應用程序的MVC實現。經過策略接口，MVC框架變成爲高度可配置的，MVC容納的大量視圖技術，包括JSP、Velocity、Tiles、iText和Pol

12、Spring如何獲取Bean
經過xml配置文件

bean配置在xml裏面，spring提供多種方式讀取配置文件獲得ApplicationContext.

第一種方式：FileSystemXmlApplicationContext

經過程序在初始化的時候，導入Bean配置文件，而後獲得Bean實例:
ApplicationContext ac = new FileSystemXmlApplicationContext(」applicationContext.xml」)
ac.getBean(」beanName」);

第二種方式：WebApplicationContextUtil

在B/S系統中,一般在web.xml初始化bean的配置文件，而後由WebAppliCationContextUtil獲得ApplicationContext.例如：
ApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc);
ApplicationContext ctx =   WebApplicationContextUtils.getWebApplicationContext(ServletContext sc);

其中 servletContext sc 能夠具體 換成 servlet.getServletContext()或者 this.getServletContext() 或者 request.getSession().getServletContext();

另外，因爲spring是注入的對象放在ServletContext中的，因此能夠直接在ServletContext取出WebApplicationContext 對象：

WebApplicationContext webApplicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

十3、請介紹一下Spring框架中Bean的生命週期
1、Bean的定義
Spring一般經過配置文件定義Bean。如：

<?xml version=」1.0″ encoding=」UTF-8″?>
<beans xmlns=」http://www.springframework.org/schema/beans」
xmlns:xsi=」http://www.w3.org/2001/XMLSchema-instance」
xsi:schemaLocation=」http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd」>
<bean id=」HelloWorld」 class=」com.pqf.beans.HelloWorld」>
<property name=」msg」>
<value>HelloWorld</value>
</property>
</bean>
</beans>

這個配置文件就定義了一個標識爲 HelloWorld 的Bean。在一個配置文檔中能夠定義多個Bean。

2、Bean的初始化
有兩種方式初始化Bean。
一、在配置文檔中經過指定init-method 屬性來完成
在Bean的類中實現一個初始化Bean屬性的方法，如init()，如：
public class HelloWorld{
public String msg=null;
public Date date=null;

public void init() {
msg=」HelloWorld」;
date=new Date();
}
……
}
而後，在配置文件中設置init-mothod屬性：
<bean id=」HelloWorld」 class=」com.pqf.beans.HelloWorld」 init-mothod=」init」 >
</bean>

二、實現 org.springframwork.beans.factory.InitializingBean接口
Bean實現InitializingBean接口，而且增長 afterPropertiesSet() 方法：

public class HelloWorld implement InitializingBean {
public String msg=null;
public Date date=null;

public void afterPropertiesSet() {
msg=」向全世界問好！」;
date=new Date();
}
……
}

那麼，當這個Bean的全部屬性被Spring的BeanFactory設置完後，會自動調用afterPropertiesSet()方法對Bean進行初始化，因而，配置文件就不用指定 init-method屬性了。

3、Bean的調用
有三種方式能夠獲得Bean並進行調用：
一、使用BeanWrapper
HelloWorld hw=new HelloWorld();
BeanWrapper bw=new BeanWrapperImpl(hw);
bw.setPropertyvalue(」msg」,」HelloWorld」);
system.out.println(bw.getPropertyCalue(」msg」));

二、使用BeanFactory
InputStream is=new FileInputStream(」config.xml」);
XmlBeanFactory factory=new XmlBeanFactory(is);
HelloWorld hw=(HelloWorld) factory.getBean(」HelloWorld」);
system.out.println(hw.getMsg());

三、使用ApplicationConttext
ApplicationContext actx=new FleSystemXmlApplicationContext(」config.xml」);
HelloWorld hw=(HelloWorld) actx.getBean(」HelloWorld」);
System.out.println(hw.getMsg());

4、Bean的銷燬
一、使用配置文件中的 destory-method 屬性
與初始化屬性 init-methods相似，在Bean的類中實現一個撤銷Bean的方法，而後在配置文件中經過 destory-method指定，那麼當bean銷燬時，Spring將自動調用指定的銷燬方法。

二、實現 org.springframwork.bean.factory.DisposebleBean接口
若是實現了DisposebleBean接口，那麼Spring將自動調用bean中的Destory方法進行銷燬，因此，Bean中必須提供Destory方法。

十4、簡述Hibernate的工做原理?
1.讀取並解析配置文件
2.讀取並解析映射信息，建立SessionFactory
3.打開Sesssion
4.建立事務Transation
5.持久化操做
6.提交事務
7.關閉Session
8.關閉SesstionFactory

十五.簡述Spring的工做原理?
1.spring mvc請全部的請求都提交給DispatcherServlet,它會委託應用系統的其餘模塊負責負責對請求進行真正的處理工做。
2.DispatcherServlet查詢一個或多個HandlerMapping,找處處理請求的Controller.
3.DispatcherServlet請請求提交到目標Controller
4.Controller進行業務邏輯處理後，會返回一個ModelAndView
5.Dispathcher查詢一個或多個ViewResolver視圖解析器,找到ModelAndView對象指定的視圖對象
6.視圖對象負責渲染返回給客戶端。