一、spring工作原理：

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



二、為什么要用spring:

AOP 讓開發人員可以創建非行為性的關注點，稱為橫切關注點，并將它們插入到應用程序代碼中。使用 AOP 后，公共服務?? （比 如日志、持久性、事務等）就可以分解成方面并應用到域對象上，同時不會增加域對象的對象模型的復雜性。

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

Spring即使一個AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替換對象。有了 Spring，只要用 JavaBean 屬性和配置文件加入依賴性（協作對象）。然后可以很容易地在需要時替換具有類似接口的協作對象。

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

四、介紹一下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類似的操作。

五、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>

六、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>

七、如何在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

八、Spring里面如何定義hibernate mapping？

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

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

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

十、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>

十一、如何在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);

十二、如何配置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”/>

十三、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文件是否正確

十四、如何在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(“鍵名”,”參數”,”區域”)取出相關的信息。

十五、spring中的核心類有那些，各有什么作用?

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

十六、什么是aop，aop的作用是什么?

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

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

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

十九、請介紹一下Spring框架中Bean的生命周期

一、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。

二、Bean的初始化
有兩種方式初始化Bean。
1、在配置文檔中通過指定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>

2、實現 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屬性了。

三、Bean的調用
有三種方式可以得到Bean并進行調用：
1、使用BeanWrapper
HelloWorld hw=new HelloWorld();
BeanWrapper bw=new BeanWrapperImpl(hw);
bw.setPropertyvalue(”msg”,”HelloWorld”);
system.out.println(bw.getPropertyCalue(”msg”));

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

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

四、Bean的銷毀
1、使用配置文件中的 destory-method 屬性
與初始化屬性 init-methods類似，在Bean的類中實現一個撤銷Bean的方法，然后在配置文件中通過 destory-method指定，那么當bean銷毀時，Spring將自動調用指定的銷毀方法。

2、實現 org.springframwork.bean.factory.DisposebleBean接口
如果實現了DisposebleBean接口，那么Spring將自動調用bean中的Destory方法進行銷毀，所以，Bean中必須提供Destory方法。

二十、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通知可以被應用到一組橫跨多個對象中的方法上（例如服務層的所有業務操作）。 為了您的安全，請只打開來源可靠的網址

打開網站????取消

來自: http://hi.baidu.com/%C6%AE%B9%FD%CD%B8%D0%C4%C1%B9/blog/item/839b301895133e76dab4bd87.html

總結

以上是生活随笔為你收集整理的spring 面试题的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。