Spring面試大全

新開公衆號，歡迎關注：裏面有幾個T的免費的學習資源

• Spring的優點有什麼?
  
  1. Spring是分層的架構，你可以選擇使用你需要的層而不用管不需要的部分
  2. Spring是POJO編程，POJO編程使得可持續構建和可測試能力提高
  3. 依賴注入和IoC使得JDBC操作簡單化
  4. Spring是開源的免費的
  5. Spring使得對象管理集中化合簡單化
• 描述一下spring中實現DI（dependency injection）的幾種方式
  方式一：接口注入，在實際中得到了普遍應用，即使在IOC的概念尚未確立時，這樣的方法也已經頻繁出現在我們的代碼中。
  方式二：Type2 IoC: Setter injection對象創建之後，將被依賴對象通過set方法設置進去
  方式三：Type3 IoC: Constructor injection對象創建時，被依賴對象以構造方法參數的方式注入
  Spring的方式
• 簡單描述下IOC(inversion of control)的理解
  一個類需要用到某個接口的方法，我們需要將類A和接口B的實現關聯起來，最簡單的方法是類A中創建一個對於接口B的實現C的實例，但這種方法顯然兩者的依賴（Dependency）太大了。而IoC的方法是隻在類A中定義好用於關聯接口B的實現的方法，將類A，接口B和接口B的實現C放入IoC的 容器（Container）中，通過一定的配置由容器（Container）來實現類A與接口B的實現C的關聯。
• Spring對很多ORM框架提供了很好支持，描述下在spring使用hibernate的方法
  在context中定義DataSource，創建SessionFactoy，設置參數；DAO類繼承HibernateDaoSupport，實現具體接口，從中獲得HibernateTemplate進行具體操作。在使用中如果遇到OpenSessionInView的問題，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor
• 請介紹下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的applicationContext.xml使用JNDI而不是DataSource
可以使用”org.springframework.jndi.JndiObjectFactoryBean”來實現。示例如下：

<bean id=”dataSource”>
    <property name=”jndiName”>
        <value>java:comp/env/jdbc/appfuse</value>
    </property>
</bean>

• 在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的配置。 你可以通過定義一個元素名字爲”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
  在J2EE的web應用裏面配置spring非常簡單，最簡單的只需要把spring得ContextLoaderListener添加到你的web.xml文件裏面就可以了，示例如下：

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
*  在spring中如何定義hibernate Mapping？
添加hibernate mapping 文件到web/WEB-INF目錄下的applicationContext.xml文件裏面。示例如下：
<property name=”mappingResources”>
    <list>
        <value>org/appfuse/model/User.hbm.xml</value>
    </list>
</property>

• 兩種依賴注入的類型是什麼?
  兩種依賴注入的類型分別是setter注入和構造方法注入。
  setter注入： 一般情況下所有的java bean, 我們都會使用setter方法和getter方法去設置和獲取屬性的值，示例如下：

public class namebean {
     String      name;  
     public void setName(String a) {
        name = a; }
     public String getName() {
        return name; }
    }

我們會創建一個bean的實例然後設置屬性的值，spring的配置文件如下：

<bean id=”bean1″  >
   <property   name=”name” >
       <value>tom</value>
   </property>
</bean>

Spring會調用setName方法來只是name熟悉爲tom
構造方法注入：構造方法注入中，我們使用帶參數的構造方法如下：
public class namebean {
String name;
public namebean(String a) {
name = a;
}
}
我們會在創建bean實例的時候以new namebean(”tom”)的方式來設置name屬性, Spring配置文件如下：

<bean id=”bean1″ >
    <constructor-arg>
       <value>My Bean Value</value>
   </constructor-arg>
</bean>

使用constructor-arg標籤來設置構造方法的參數。
* 解釋一下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加入
* Spring 和 hibernate的配置文件中的主要類型有哪些？如何配置?
在myeclipse中先加入spring環境再加入hibernate環境。
如果spring與hibernate結合在一起可以不需要hibernate.cfg.xml文件是否正確?
spring+hibernate的配置文件中的主要類有那些?如何配置?
dataSource
sessionFactory:hibernate.cfg.xml
transactionManager
userDao (extends HibernateDaoSupport)
sessionFactory
facade
proxy
sessionFactory
transactionManager
facade
* 在spring中如何配置容器的事物管理，相關的類有哪些?
Datasouce
transactionManager
userDao要注入
Datasouce
Proxy代理
Target:userDao：代理對象(目標對象)
transactionAttributes(那些方法需要事務處理)
transactionManager(事務處理服務)
* 在spring中如何配代碼的事務管理器
Datasouce
transactionManager
userDao要注入
Datasouce
transactionManager
通過如下類實現
TransactionTemplate
JdbcTemplate
* Spring中有幾種事物管理，分別是什麼?
代碼管理的事務處理
TransactonTemplate的execute方法中的內部類TransactionCallback中的doInTransaction方法中使用。

public void make()
 { 
  TransactionTemplate jtm=new TransactionTemplate(this.getTransactionManager());
  jtm.execute(new myClass1());
 }
 public class myClass1 implements TransactionCallback
 {
  public Object doInTransaction(TransactionStatus trans)
  {
   JdbcTemplate jdbc=new JdbcTemplate(dataSource);
   jdbc.execute(”insert into customer(customerName) values(’b')”);
   jdbc.execute(”insert into customer(customerName) values(’b')”);
   return null;
  }  
 }

容器管理的事務處理
* spring中的jdbc與傳統的jdbc有什麼區別?
Spring的jdbc:節省代碼，不管連接(Connection)，不管事務、不管異常、不管關閉(con.close() ps.close )
JdbcTemplate(dataSource):增、刪、改、查
TransactionTemplate(transactionManager):進行事務處理
* Spring配置的主要標籤有什麼?有什麼作用?

<beans>
   <bean id=”” class=”” init=”” destroy=”” singleton=””>
    <property name=””>
     <value></value>
    </property>
    <property name=””>
     <ref local></ref>
    </property>
   </bean>
</beans>

• 如何在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中如何實現事件處理
事件
Extends ApplicationEvent
監聽器
Implements ApplicationListener
事件源
Implements ApplicationContextAware
在applicationContext.xml中配置事件源、監聽器
先得到事件源，調用事件源的方法，通知監聽器。
* 如何將spring加入web容器中
在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如何實現資源管理?
使用
applicationContext.getResource(“classpath:文件名”):在src根目錄下，在類路徑下
applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目錄下的基準往下走。
applicationContext.getResource(“file:c:/a.properties”)：在系統文件目錄下。
* Spring的ApplicationContext的作用?
beanFactory
國際化(getMesage)
資源管理:可以直接讀取一個文件的內容(getResource)
加入web框架中(加入一個servlet或監聽器)
事件處理
* spring的核心是什麼，各有什麼作用？
BeanFactory：產生一個新的實例，可以實現單例模式
BeanWrapper：提供統一的get及set方法
ApplicationContext:提供框架的實現，包括BeanFactory的所有功能
* Spring中aop的關鍵名詞有哪些？各有什麼作用?
攔截器: 代理
裝備(advice)
目標對象
關切點:條件
連接點:方法、屬性
* Spring與struts的區別？
strusts：是一種基於MVC模式的一個web層的處理。
Spring:提供了通用的服務，ioc/di aop,關心的不僅僅web層，應當j2ee整體的一個服務，可以很容易融合不同的技術struts hibernate ibatis ejb remote springJDBC springMVC
* spring與struts的面試題
1.struts
Action是不是線程安全的？如果不是，有什麼方式可以保證Action的線程安全？如果是，說明原因
2.MVC，分析一下struts是如何實現MVC的
3.struts中的幾個關鍵對象的作用(說說幾個關鍵對象的作用)
4.spring
說說AOP和IOC的概念以及在spring中是如何應用的
5.Hibernate有哪幾種查詢數據的方式
6.load()和get()的區別
回答：
1.Struts1 Action是單例模式並且必須是線程安全的，因爲僅有Action的一個實例來處理所有的請求。單例策略限制了Struts1 Action能作的事，並且要在開發時特別小心。Action資源必須是線程安全的或同步的。
Struts2 Action對象爲每一個請求產生一個實例，因此沒有線程安全問題。（實際上，servlet容器給每個請求產生許多可丟棄的對象，並且不會導致性能和垃圾回收問題）
2.struts是用一組類,servlet 和jsp規範實現mvc的
3.ActionFrom ActionServlet Action struts-config.xml
4.spring的核心就是IOC,通過指定對象的創建辦法,描述對象與服務之間的關係,而不生成對象
5.3種,hql 條件查詢() 原生sql
6.load()方法認爲該數據一定存在,可以放心的使用代理來延時加載 ,如果使用過程中發現了問題,就拋出異常;
get()方法一定要獲取到真實的數據,否則返回null
* Spring, hibernate ,struts面試題
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 屬性和配置文件加入依賴性（協作對象）。然後可以很容易地在需要時替換具有類似接口的協作對象。
* 一些spring與hibernate的面試題
1、 簡述你對IoC（Inversion of Control）的理解，描述一下Spring中實現DI（Dependency Injection）的幾種方式。
2、 Spring的Bean有多種作用域，包括：
singleton、prototype、request、session、global session、application、自定義
3、 簡單描述Spring framework與Struts的不同之處，整合Spring與Struts有哪些方法，哪種最好，爲什麼？
4、 Hibernate中的update()和saveOrUpdate()的區別
5、 Spring對多種ORM框架提供了很好的支持，簡單描述在Spring中使用Hibernate的方法，並結合事務管理。
答案：
1、好萊塢原則€€€€不要打電話找我，我會打給你的。IoC將創建的職責從應用程序代碼搬到了框架中。Spring對Setter注入和構造方法注入提供支持。（詳見http://martinfowler.com/articles/injection.html，以及http: //www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators）
2、 除application（詳見Spring framework 2.0 Reference的3.4節bean的作用域）
3、 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）
4、 saveOrUpdate()方法可以實現update()的功能，但會多些步驟，具體如下：
如果對象在該session中已經被持久化，不進行操作；
對象的標識符屬性(identifier property)在數據庫中不存在或者是個暫時的值，調用save()方法保存它；
如果session中的另一個對象有相同的標識符拋出一個異常；
以上皆不符合則調用update()更新之。
5、 在context中定義DataSource，創建SessionFactoy，設置參數；DAO類繼承HibernateDaoSupport，實現具體接口，從中獲得HibernateTemplate進行具體操作。
在使用中如果遇到OpenSessionInView的問題，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。（詳見Spring framework 2.0 Reference的12.2節Hibernate）
聲明式事務需聲明事務管理器，在context中設置指定屬性，用確定和。
* 在spring中如何更加高效的使用JDBC
使用Spring框架提供的模板類JdbcTemplete可以是JDBC更加高效
代碼如下：

dbcTemplate 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>

• 在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>

• 在spring中如何配置一個bean來從JNDI到dataSource

<bean id=”dataSource” class=”org.springframework.jndi.JndiObjectFactoryBean”>
<property name=”jndiName”> <value>java:comp/env/jdbc/myDatasource</value>
</property>
</bean>

• 請介紹下spring中bean的作用域
  在spring2.0之前bean只有2種作用域即：singleton(單例)、non-singleton（也稱 prototype），Spring2.0以後，增加了session、request、global session三種專用於Web應用程序上下文的Bean。因此，默認情況下Spring2.0現在有五種類型的Bean。
  
  這裏的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類型，滿足實際應用需求。
  1、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。
  配置實例：
  
  或者
  
  2、prototype
  prototype作用域部署的bean，每一次請求（將其注入到另一個bean中，或者以程序的方式調用容器的getBean()方法）都會產生一個新的bean實例，相當於一個new的操作，對於prototype作用域的bean，有一點非常重要，那就是Spring不能對一個 prototype bean的整個生命週期負責，容器在初始化、配置、裝飾或者是裝配完一個prototype實例後，將它交給客戶端，隨後就對該prototype實例不聞不問了。不管何種作用域，容器都會調用所有對象的初始化生命週期回調方法，而對prototype而言，任何配置好的析構生命週期回調方法都將不會被調用。清除prototype作用域的對象並釋放任何prototype bean所持有的昂貴資源，都是客戶端代碼的職責。（讓Spring容器釋放被singleton作用域bean佔用資源的一種可行方式是，通過使用 bean的後置處理器，該處理器持有要被清除的bean的引用。）
  配置實例：
  
  或者
  

<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的作用域了：

4、session
session作用域表示該針對每一次HTTP請求都會產生一個新的bean，同時該bean僅在當前HTTP session內有效，配置實例：
配置實例：
和request配置實例的前提一樣，配置好web啓動文件就可以如下配置：

5、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啓動文件就可以如下配置：

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;
}
}

• 請介紹 一下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屬性：


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方法。
* 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);

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