spring面向切面編程

『壹』 項目中如何體現Spring中的切面編程

面向切面編程：主要是橫切一個關注點,將一個關注點模塊化成一個切面。在切面上聲明一個通知(Advice)和切入點(Pointcut); 通知: 是指在切面的某個特定的連接點(代表一個方法的執行。通過聲明一個org.aspectj.lang.JoinPoint類型的參數可以使通知（Advice）的主體部分獲得連接點信息。)上執行的動作。通知中定義了要插入的方法。切入點：切入點的內容是一個表達式，以描述需要在哪些對象的哪些方法上插入通知中定義的方法。 項目中用到的Spring中的切面編程最多的地方：聲明式事務管理。 a、定義一個事務管理器 b、配置事務特性(相當於聲明通知。一般在業務層的類的一些方法上定義事務)

『貳』 spring的ioc和aop都是什麼

什麼是IoC

Ioc—Inversion of
Control，即「控制反轉」，不是什麼技術，而是一種設計思想。在java開發中，Ioc意味著將你設計好的對象交給容器控制，而不是傳統的在你的對象內部直接控制。如何理解好Ioc呢？理解好Ioc的關鍵是要明確「誰控制誰，控制什麼，為何是反轉（有反轉就應該有正轉了），哪些方面反轉了」，那我們來深入分析一下：

控制是什麼：傳統Java
SE程序設計，我們直接在對象內部通過new進行創建對象，是程序主動去創建依賴對象；而IoC是有專門一個容器來創建這些對象，即由Ioc容器來控制對象的創建；誰控制誰？當然是IoC
容器控制了對象；控制什麼？那就是主要控制了外部資源獲取（不只是對象包括比如文件等）。

為何是反轉，哪些方面反轉了：有反轉就有正轉，傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉；而反轉則是由容器來幫忙創建及注入依賴對象；為何是反轉？因為由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉；哪些方面反轉了？依賴對象的獲取被反轉了。

IoC能做什麼

IoC不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難於測試；有了IoC容器後，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是鬆散耦合，這樣也方便測試，利於功能復用，更重要的是使得程序的整個體系結構變得非常靈活。

其實IoC對編程帶來的最大改變不是從代碼上，而是從思想上，發生了「主從換位」的變化。應用程序原本是老大，要獲取什麼資源都是主動出擊，但是在IoC/DI思想中，應用程序就變成被動的了，被動的等待IoC容器來創建並注入它所需要的資源了。

IoC和DI

DI—Dependency
Injection，即「依賴注入」：是組件之間依賴關系由容器在運行期決定，形象的說，即由容器動態的將某個依賴關系注入到組件之中。依賴注入的目的並非為軟體系統帶來更多功能，而是為了提升組件重用的頻率，並為系統搭建一個靈活、可擴展的平台。通過依賴注入機制，我們只需要通過簡單的配置，而無需任何代碼就可指定目標需要的資源，完成自身的業務邏輯，而不需要關心具體的資源來自何處，由誰實現。

註：如果想要更加深入的了解IoC和DI，請參考大師級人物Martin Fowler的一篇經典文章《Inversion of Control
Containers and the Dependency Injection
pattern》，原文地址：http://www.martinfowler.com/articles/injection.html。

AOP：面向切面編程

什麼是AOP：

概念：在軟體業，AOP為Aspect Oriented
Programming的縮寫，意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。（網路）

簡單的說：就是將程序中重復的代碼抽取出來，在需要執行的時候，使用動態代理的技術，在不修改源碼的基礎上，對我們的已有方法進行增強。

AOP的作用和優勢：

作用：從定義中來看，就是為了在程序運行期間，不修改源碼對已有方法進行增強。

優勢：減少重復代碼 提交了開發效率 維護方便

實現方式： 就是動態代理的技術

具體的作用：實現事務的控制 日誌 和 安全模塊

想系統的學習編程可以來我這看看，希望對您有所幫助！~

『叄』 spring中的aop 是怎麼面向切面編程的

Spring面向切面編程(AOP)

1 spring容器中bean特性

Spring容器的javabean對象默認是單例的。

通過在xml文件中，配置可以使用某些對象為多列。

Spring容器中的javabean對象默認是立即載入（立即實例化：spring載入完成，立即創建對象）

scope:屬性

singleton：默認值為單例，默認也是立即載入,在載入完成spring容器的時候，bean對象已經創建完成

prototype：多例的，默認懶載入，spring容器載入完成的時候，不會創建bean的對象，只有從容器獲得bean對象的時候，才進行bean對象的實例化

request: 將創建的javabean對象，封裝到request范圍

session:將創建的javabean對象，封裝到session范圍

Spring容器bean的對象生命周期：

Bean對象的創建一直到銷毀為bean的生命周期。

生命周期的開始：

如果為單例，由載入完spring容器開始

如果為多例，由從容器獲得bean對象開始

實例化

初始化

服務

銷毀(單例：關閉容器的時候，多例由jvm自動回收)

2 spring的AOP面向切面編程

2.1 模擬銀行轉賬業務

需求：實現銀行的轉賬功能，在轉賬的時候需要完成

1 身份認證（登陸）

2 許可權的驗證

3 轉賬實現

4 歷史交易記錄，

分析：1，2，4三個功能對於銀行的業務，屬於公共的功能（共性的功能）

在功能實現的時候，需要將1，2，4抽取出來，單獨實現，

做到了將共性的功能和核心的業務功能進行了分離

通過動態代理實現：共性的功能和核心業務功能的合並，產生核心業務對象的

在代碼實現的時候，進行了功能實現的分離：

代碼開發的進行分離，程序在運行的時候進行合並。

2.2 springAOP的思想

在系統開發中，將系統的共性的公共的功能獨立實現，在程序運行的過程中，將共性功能和核心的業務功能，進行整合。

好處：

1 完成共性功能和核心業務功能的解耦合

2 提供共性功能的復用性。

2.3springAOP的概念

Aspect切面：封裝共性功能的（增強功能的）類

Advice通過：切面類中封裝的增強功能的方法。

PointCut:切入點，是一個集合的概念，該集合的表達使用一個正則表達式表達

所有核心業務對象的所有方法的前後（事務處理AOP典型的應用）

JoinPoint:連接點，程序中需要加入advice的地方，而且正在執行的ponitCut

織入(Weaving)：將aspect和核心業務對象，進行整合的過程。

3 springAOP的實現

3.1通過特定介面實現

Aop通知的類型：

Before:前置通知

After：後置通知

Around：環繞通知

Throwing：異常通知

需求：實現在業務對象中的方法執行的時候，記錄日誌功能

3.1.1前置通知

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Arrays;
importjava.util.Date;
importorg.springframework.aop.MethodBeforeAdvice;
/****
*前置增強：
*MethodBeforeAdvice介面表示重寫的方法為前置advice
****/

{
@Override
publicvoidbefore(Methodmethod,
Object[]args,Objectobj)
throwsThrowable
{
System.out.println(method);
System.out.println(Arrays.toString(args));
System.out.println(obj);
System.out.println("BeforeLog-------------"+newDate());
}
}

AOP配置:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--到入xml文件的約束-->
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:p="http://www.springframework.org/schema/p"
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-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--實例化BeforeLog對象-->
<beanid="bf"class="org.guangsoft.utils.BeforeLog"></bean>
<!--實例化service對象-->
<beanid="us"class="org.guangsoft.service.impl.UsersServiceImpl"/>
<!--進行aop的配置，產生代理對象-->
<aop:config>
<!--聲明切入點-->
<aop:pointcutexpression="execution(*org.guansoft.service.impl.*.*(..))"
id="pc"/>
<!--織入將通知和切入點進行合並（切面+核心業務對象）-->
<aop:advisoradvice-ref="bf"pointcut-ref="pc"/>
</aop:config>
</beans>

3.1.2後置通知

對業務對象的方法進行後增強。

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Date;
importorg.springframework.aop.AfterReturningAdvice;
/***
*後置通知
****/

{
@Override
publicvoidafterReturning(Objectobj1,//obj1接收目標方法的返回值
Methodmethod,
Object[]args,
Objectobj2)throwsThrowable
{
//System.out.println(obj1+"----------------------"+obj2);
System.out.println("AfterLog-------------------"+newDate());
}
}

AOP配置:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--到入xml文件的約束-->
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:p="http://www.springframework.org/schema/p"
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-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--實例化BeforeLog對象-->
<beanid="bf"class="org.guangsoft.utils.BeforeLog"></bean>
<beanid="af"class="org.guangsoft.utils.AfterLog"></bean>
<!--實例化service對象-->
<beanid="us"class="org.guangsoft.service.impl.UsersServiceImpl"/>
<!--進行aop的配置，產生代理對象-->
<aop:config>
<!--聲明切入點-->
<aop:pointcutexpression="execution(*org.guangsoft.service.impl.*.*(..))"
id="pc"/>
<!--織入將通知和切入點進行合並（切面+核心業務對象）-->
<aop:advisoradvice-ref="bf"pointcut-ref="pc"/>
<aop:advisoradvice-ref="af"pointcut-ref="pc"/>
</aop:config>
</beans>

3.1.3環繞通知

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Arrays;
importjava.util.Date;
importorg.aopalliance.intercept.MethodInterceptor;
importorg.aopalliance.intercept.MethodInvocation;
/***
*環繞通知
****/

{
/**
*MethodInvocation中封裝了目標對象，調用的方法，方法需要的參數
****/
@Override
publicObjectinvoke(MethodInvocationmi)throwsThrowable
{
Methodmethod=mi.getMethod();
Object[]args=mi.getArguments();
Objectobj=mi.getThis();
System.out.println(method);
System.out.println(Arrays.toString(args));
System.out.println(obj);
System.out.println("around------before--------"+newDate());
Objectrv=method.invoke(obj,args);//調用目標對象的方法，放行
System.out.println("around------after--------"+newDate());
returnrv;
}
}

AOP配置：同上

3.1.4 異常通知

packageorg.guangsoft.utils;
importjava.util.Date;
importorg.springframework.aop.ThrowsAdvice;
/****
*異常通知
***/

{
/***
*該類中的方法參考AfterReturningAdvice寫
*該參數是用來接收異常信息的
****/
publicvoidafterThrowing(Throwableex)throwsThrowable
{
//System.out.println(obj1+"----------------------"+obj2);
System.out.println("ExceptionLog-----------"+ex.getMessage()
+"--------"+newDate());
}
}

Pointcut:核心業務對象

Advice：通知

『肆』 如何在Spring框架中進行面向切面編程

什麼是DI（ioc）機制？

依賴注入（Dependecy Injection）和控制反轉（Inversion of Control）是同一個概念，具體的講：當某個角色

需要另外一個角色協助的時候，在傳統的程序設計過程中，通常由調用者來創建被調用者的實例。但在spring中

創建被調用者的工作不再由調用者來完成，因此稱為控制反轉。創建被調用者的工作由spring來完成，然後注入調用者

因此也稱為依賴注入。

spring以動態靈活的方式來管理對象 ， 注入的兩種方式，設置注入和構造注入。

設置注入的優點：直觀，自然

構造注入的優點：可以在構造器中決定依賴關系的順序。

什麼是AOP？

面向切面編程（AOP）完善spring的依賴注入（DI），面向切面編程在spring中主要表現為兩個方面

1. 面向切面編程提供聲明式事務管理

2. 2.spring支持用戶自定義的切面
   

『伍』 什麼是spring的ioc aop

ioc和aop是spring兩個重要的核心，ioc是應用容器的依賴注入，最明顯的優勢在於你用spring可以應用它提供的註解來注入。aop是面向切面編程，可以用它來做如日誌攔截等的功能，使得代碼更容易管理，耦合性降低。

『陸』 Spring中ioc的面向切面編程的意思

這么來說吧，在一個動作或者事件中，比如說，你現在想寫字（Action），那麼你需要筆，於是乎，你new了一個筆來寫字，這里，你用了new筆，你這個動作和筆有了關聯，沒了筆，你就寫不了字，也就是說，你的這個行為依賴於筆了，他們就構成了依賴關系。或者你現在想組裝一台電腦（Transaction），那麼你就需要顯示器、主板、鍵鼠光碟機等對象，這些對象通常是new出來的，new出來的對象和當前（this）對象就有了依賴關系。

spring中對依賴的對象採用注入，這就是常說的依賴注入吧.

再說AOP，還是以上面的例子。
比如你想在每次寫字之前都檢查一下筆里有沒有墨水了，通常的做法是：在寫字這個Action里調用判斷是否有墨水的方法。這樣做的不好一個方面是，寫字的action和是否有墨水的方法產生了依賴，如果你有十幾支不同的筆寫字，每一個筆的Action里都要調用判斷是否有墨水的方法；另一個方面是：就面向對象的程序設計來說，寫字和判斷是否有墨水的方法是同一等級的，如果你讓寫字這個動作來判斷是否有墨水不夠人性化，有違面向對象的程序設計的思想。
如果用Spring的AOP，是把寫字的Action作為一個切面，在每次調用不同的筆來寫字的方法之前，調用判斷是否有墨水的方法。它是由<aop:config/>標簽在Spring配置文件里定義的，形式如：
<aop:config>
<aop:pointcut id="allManagerMethod" expression="execution(* com...write*(..))"/>
<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>
</aop:config>
這里，對com..下所有以write開頭的方法做了一個切面，做要做的操作是以下面的pointcut-ref="allManagerMethod"來定義的。

具體到你這個配置文件，這里沒有AOP，只有IOC。

『柒』 從頭認識Spring-1.2 什麼是AOP為什麼需要面向切面編程

面向切面變成能夠很大程度上較少代碼量，並且可以深入到方法內部，動態給方法添加功能，比如增加日誌的功能，設置前置功能，後置補充功能。Aop用到面向對象的編程中，簡直就是如虎添翼。這么方便的東西為什麼不使用呢？

舉個例子，你要給一個方法，添加動態添加段功能，比如說做前置校驗：

publicvoidtest(){
//code
}

如果你採用傳統方法，可能需要藉助動態代理來生成一個代理類，通過代理對象的invoke()方法利用反射原理給方法添加功能，但是這樣做的話，會很麻煩，並且很容易出錯。藉助於Aop，就可以直接定義一個切面，然後聲明一個切點，給方法動態添加了功能，並且不具有侵入性。

『捌』 spring aop的切面類是指什麼

面向切面編程，是一種思想，也是一套規則，像用戶驗證之類的都是可以這么理解，如果項目中很多地方需要驗證用戶是否登錄，那麼進行統一設置就可以不需要單獨寫代碼。另外，例如:前置通知，後置通知，等等都是

『玖』 spring框架的面向切面編程如何理解

Spring提供了對AOP技術的良好封裝，AOP稱為面向切面編程，就是系統中有很多各不相乾的類的方法，在這些眾多的方法中要加入某種系統功能代碼，例如：加入日誌、許可權判斷、異常處理等，這種應用成為AOP。
實現AOP功能採用的是代理技術，客戶端程序不再調用目標，而調用代理類，代理類與目標類對外具有相同的方法聲明，有兩種方式可以實現相同的方法聲明，一是實現相同的介面，而是作為目標的子類在JDK中採用Proxy類產生動態代理的方式為某個介面生成實現類，如果要為某類個生成子類，則可以用CGLIB。
在生成的代理類的方法中加入系統功能和調用目標類的相應方法，系統功能的代理以Advice對象進行提供，顯然要創建出代理對象，至少需要目標類和Advice類。
Sping提供了這種支持，只需要在Sping配置文件中配置這兩個元素即可實現代理和Aop功能，
例如：
<bean id = "proxy" type = "org.spring.framework.aop.ProxyBeanFacory">
<property name = "target" ref = ""></property>

<property name = "advisor" ref = ""></property>

</bean>

『拾』 什麼是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 mole
Bean mole
Context mole
Expression Language mole
JDBC mole
ORM mole
OXM mole
Java Messaging Service(JMS) mole
Transaction mole
Web mole
Web-Servlet mole
Web-Struts mole
Web-Portlet mole
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通常的實現是什麼?
：此容器從一個XML文件中載入beans的定義，XML Bean 配置文件的全路徑名必須提供給它的構造函數。
：此容器也從一個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會在()方法內調用它們。
如果bean實現IntializingBean了，調用它的afterPropertySet方法，如果bean聲明了初始化方法，調用此初始化方法。
如果有BeanPostProcessors 和bean 關聯，這些bean的() 方法將被調用。
如果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

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到一個類或一個特定的方處理法上。