spring面試題

1、spring工做原理： 

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



2、爲何要用spring: 

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

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

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

3、請你談談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是一個業務層框架，是一個整合的框架，可以很好地黏合表示層與持久層。 

4、介紹一下Spring的事務管理： 

事務就是對一系列的數據庫操做（好比插入多條數據）進行統一的提交或回滾操做，若是插入成功，那麼一塊兒成功，若是中間有一條出現異常，那麼回滾以前的全部操做。 
這樣能夠防止出現髒數據，防止數據庫數據出現問題。 
開發中爲了不這種狀況通常都會進行事務管理。Spring中也有本身的事務管理機制，通常是使用TransactionMananger進行管理，能夠經過Spring的注入來完成此功能。 

spring提供了幾個關於事務處理的類： 
TransactionDefinition //事務屬性定義 
TranscationStatus //表明了當前的事務，能夠提交，回滾。 
PlatformTransactionManager這個是spring提供的用於管理事務的基礎接口，其下有一個實現的抽象類AbstractPlatformTransactionManager,咱們使用的事務管理類例如DataSourceTransactionManager等都是這個類的子類。 

通常事務定義步驟： 

TransactionDefinition td = new TransactionDefinition(); 
TransactionStatus ts = transactionManager.getTransaction(td); 
try 
{ //do sth 
transactionManager.commit(ts); 
} 
catch(Exception e){transactionManager.rollback(ts);} 

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

編程式主要使用transactionTemplate。省略了部分的提交，回滾，一系列的事務對象定義，需注入事務管理對象. 
void add(){ 
transactionTemplate.execute( new TransactionCallback(){ 
pulic Object doInTransaction(TransactionStatus ts) 
{ //do sth} 
} 
} 

聲明式： 

使用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相似的操做。 

5、Spring裏面如何配置數據庫驅動？ 

使用」org.springframework.jdbc.datasource.DriverManagerDataSource」數據源來配置數據庫驅動。示例以下： 
<bean id=」dataSource」> 
    <property name=」driverClassName」> 
        <value>org.hsqldb.jdbcDriver</value> 
    </property> 
    <property name=」url」> 
        <value>jdbc:hsqldb:db/appfuse</value> 
    </property> 
    <property name=」username」><value>sa</value></property> 
    <property name=」password」><value></value></property> 
</bean> 

6、Spring裏面applicationContext.xml文件能不能改爲其餘文件名？ 

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

<listener> 
    <listener-class>org.springframework.web.context.ContextLoaderListener 
    <context-param> 
        <param-name>contextConfigLocation</param-name> 
        <param-value>/WEB-INF/xyz.xml</param-value> 
    </context-param> 
    </listener-class> 
</listener> 

7、如何在web應用裏面配置spring? 

在web.xml中加入以下同容,在啓動web服務器時加載/WEB-INF/applicationContext.xml中的內容。 
<servlet> 
<servlet-name>context</servlet-name> 
<servlet-class> 
org.springframework.web.context.ContextLoaderServlet 
</servlet-class> 
<load-on-startup>1</load-on-startup> 
</servlet> 
經過以下類獲得ApplicationContext實例 
    WebApplicationContextUtils.getWebApplicationContext 

8、Spring裏面如何定義hibernate mapping？ 

添加hibernate mapping 文件到web/WEB-INF目錄下的applicationContext.xml文件裏面。示例以下： 
<property name=」mappingResources」> 
    <list> 
        <value>org/appfuse/model/User.hbm.xml</value> 
    </list> 
</property> 

9、解釋一下Dependency injection(DI,依賴注入)和IOC(Inversion of control,控制反轉)? 

依賴注入DI是一個程序設計模式和架構模型， 一些時候也稱做控制反轉，儘管在技術上來說，依賴注入是一個IOC的特殊實現，依賴注入是指一個對象應用另一個對象來提供一個特殊的能力，例如：把一個數據庫鏈接已參數的形式傳到一個對象的結構方法裏面而不是在那個對象內部自行建立一個鏈接。控制反轉和依賴注入的基本思想就是把類的依賴從類內部轉化到外部以減小依賴 
應用控制反轉，對象在被建立的時候，由一個調控系統內全部對象的外界實體，將其所依賴的對象的引用，傳遞給它。也能夠說，依賴被注入到對象中。因此，控制反轉是，關於一個對象如何獲取他所依賴的對象的引用，這個責任的反轉。 

10、spring中的BeanFactory與ApplicationContext的做用有哪些？ 

1. BeanFactory負責讀取bean配置文檔，管理bean的加載，實例化，維護bean之間的依賴關係，負責bean的聲明週期。 
2. ApplicationContext除了提供上述BeanFactory所能提供的功能以外，還提供了更完整的框架功能： 

a. 國際化支持 
b. 資源訪問：Resource rs = ctx. getResource(」classpath:config.properties」), 「file:c:/config.properties」 
c. 事件傳遞：經過實現ApplicationContextAware接口 
3. 經常使用的獲取ApplicationContext的方法： 
FileSystemXmlApplicationContext：從文件系統或者url指定的xml配置文件建立，參數爲配置文件名或文件名數組 
ClassPathXmlApplicationContext：從classpath的xml配置文件建立，能夠從jar包中讀取配置文件 
WebApplicationContextUtils：從web應用的根目錄讀取配置文件，須要先在web.xml中配置，能夠配置監聽器或者servlet來實現 
<listener> 
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
</listener> 
<servlet> 
<servlet-name>context</servlet-name> 
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> 
<load-on-startup>1</load-on-startup> 
</servlet> 
這兩種方式都默認配置文件爲web-inf/applicationContext.xml，也可以使用context-param指定配置文件 
<context-param> 
<param-name>contextConfigLocation</param-name> 
<param-value>/WEB-INF/myApplicationContext.xml</param-value> 
</context-param> 

11、如何在web環境中配置applicationContext.xml文件? 

<listener> 
   <listener-class> 
    org.springframework.web.context.ContextLoaderListener 
   </listener-class> 
</listener> 
或： 
<servlet> 
   <servlet-name>context</servlet-name> 
    <servlet-class> 
     org.springframework.web.context.ContextLoaderServlet 
    </servlet-class> 
   <load-on-startup>1</load-on-startup> 
</servlet> 
經過以下方法取出applicationContext實例: 
ApplicationContext ac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext); 

12、如何配置spring+struts? 

在struts-config.xml加入一個插件，經過它加載applicationContext.xml 
 在struts-config.xml修改action-mapping標記，具體action交給了DelegateActionProxy 
 經過DelegateActionProxy進入一spring的環境。 
 在spring的applicationContext.xml加入<bean name=」/login」 class=」" singleton=」false」/> 

十3、spring+hibernate的配置文件中的主要類有那些?如何配置? 

dataSource 
   sessionFactory:hibernate.cfg.xml 
   transactionManager 
   userDao (extends HibernateDaoSupport) 
   sessionFactory 
   facade 
   proxy 
   sessionFactory 
   transactionManager 
   facade 

在myeclipse中先加入spring環境再加入hibernate環境。 
若是spring與hibernate結合在一塊兒能夠不須要hibernate.cfg.xml文件是否正確 

十4、如何在spring中實現國際化? 

在applicationContext.xml加載一個bean 
<bean id=」messageSource」 class=」org.springframework.context.support.ResourceBundleMessageSource」> 
   <property name=」basename」> 
    <value>message</value> 
   </property> 
</bean> 
 在src目錄下建多個properties文件 
 對於非英文的要用native2ascii -encoding gb2312 源 目轉化文件相關內容 
 其命名格式是message_語言_國家。 
 頁面中的中顯示提示信息，鍵名取鍵值。 
 當給定國家，系統會自動加載對應的國家的properties信息。 
 經過applictionContext.getMessage(「鍵名」,」參數」,」區域」)取出相關的信息。 

十5、spring中的核心類有那些，各有什麼做用? 

BeanFactory：產生一個新的實例，能夠實現單例模式 
BeanWrapper：提供統一的get及set方法 
ApplicationContext:提供框架的實現，包括BeanFactory的全部功能 

十6、什麼是aop，aop的做用是什麼? 

面向切面編程（AOP）提供另一種角度來思考程序結構，經過這種方式彌補了面向對象編程（OOP）的不足 
除了類（classes）之外，AOP提供了切面。切面對關注點進行模塊化，例如橫切多個類型和對象的事務管理 
Spring的一個關鍵的組件就是AOP框架，能夠自由選擇是否使用AOP 
提供聲明式企業服務，特別是爲了替代EJB聲明式服務。最重要的服務是聲明性事務管理，這個服務創建在Spring的抽象事物管理之上 
容許用戶實現自定義切面，用AOP來完善OOP的使用 
能夠把Spring AOP看做是對Spring的一種加強 

十7、使用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框架的部分或所有 

十8、什麼是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也提供了不少基礎功能（事務管理、持久化框架集成等等），將應用邏輯的開發留給了你。 

十9、請介紹一下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方法。 

二10、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框架同樣，在運行時完成織入。 

通知的類型： 

前置通知（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通知能夠被應用到一組橫跨多個對象中的方法上（例如服務層的全部業務操做）。