您现在的位置： Linux教程網 >> UnixLinux > >> Linux編程 >> Linux編程

Spring的IOC和AOP之深剖

我們首先要知道，用Spring主要是兩件事：

1、開發Bean；2、配置Bean。對於Spring框架來說，它要做的，就是根據配置文件來創建bean實例，並調用bean實例的方法完成“依賴注入”。

Spring框架的作用是什麼？有什麼優點？

1.降低了組件之間的耦合性，實現了軟件各層之間的解耦
2.可以使用容易提供的眾多服務，如事務管理，消息服務等
3.容器提供單例模式支持
4.容器提供了AOP技術，利用它很容易實現如權限攔截，運行期監控等功能
5.容器提供了眾多的輔助類，能加快應用的開發
6.spring對於主流的應用框架提供了集成支持，如hibernate，JPA，Struts等
7.spring屬於低侵入式設計，代碼的污染極低
8.獨立於各種應用服務器
9.spring的DI機制降低了業務對象替換的復雜性
10.Spring的高度開放性，並不強制應用完全依賴於Spring，開發者可以自由選擇spring的部分或全部

什麼是DI機制？

依賴注入（Dependecy Injection）和控制反轉（Inversion of Control）是同一個概念，具體的講：當某個角色
需要另外一個角色協助的時候，在傳統的程序設計過程中，通常由調用者來創建被調用者的實例。但在spring中
創建被調用者的工作不再由調用者來完成，因此稱為控制反轉。創建被調用者的工作由spring來完成，然後注入調用者
因此也稱為依賴注入。是面向編程中的一種設計理念，用來減低程序代碼之間的耦合度。
spring以動態靈活的方式來管理對象，注入的兩種方式，設置注入和構造注入。
設置注入的優點：直觀，自然
構造注入的優點：可以在構造器中決定依賴關系的順序。

現在我們用例子來具體理解它

1.Spring提供的幾種依賴注入(控制反轉)的方式

1）setter（設置）注入
2）構造器注入
3）接口注入

但是，我們要了解什麼是依賴？

我們所知道的依賴：

①依靠別人或事物而不能自立或自給；②指各個事物或現象互為條件而不可分離。

專業解析：依賴，在代碼中一般指通過局部變量，方法參數，返回值等建立的對於其他對象的調用關系。

例如:在A類的方法中，實例化了B類的對象並調用其方法以完成特定的功能，我們就說A類依賴於B類。

Spring設置注入和構造注入的區別

設置注入是先通過調用無參構造器創建一個bean實例，然後調用對應的setter方法注入依賴關系；而構造注入則直接調用有參數的構造器，當bean實例創建完成後，已經完成了依賴關系的注入。另外這兩種依賴注入的方式，並沒有絕對的好壞，只是適應的場景有所不同。

setter方法注入：

Entity

public class Happy {
private String happyInfo;

public void happy(){
System.out.println(happyInfo);
}

public String getHappyInfo() {
return happyInfo;
}

public void setHappyInfo(String happyInfo) {
this.happyInfo = happyInfo;
}

applicationContext.xml:

<?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.xsd">

<bean id="happy" class="cn.wgy.day_01.entity.Happy">



<property name="happyInfo" value="中秋快樂"></property>

</bean>
</beans>

test類

public static void main(String[] args) {
//獲取上下文對象
//ApplicationContext context2=new FileSystemXmlApplicationContext("applicationContext.xml");

//BeanFactory beanf=new FileSystemXmlApplicationContext("applicationContext.xml");

ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
// Object getBean(String name) throws BeansException;
Happy happy = (Happy) context.getBean("happy");

happy.happy();
}
}

注意:ApplicationContext ,其實還有BeauFactory也可以，那麼它們兩的區別是啥呢？請看下面

BeanFacotry是spring中比較原始的Factory。如XMLBeanFactory就是一種典型的BeanFactory。原始的BeanFactory無法支持spring的許多插件，如AOP功能、Web應用等。
ApplicationContext接口,它由BeanFactory接口派生而來，因而提供BeanFactory所有的功能。ApplicationContext以一種更向面向框架的方式工作以及對上下文進行分層和實現繼承，ApplicationContext包還提供了以下的功能：
01.MessageSource, 提供國際化的消息訪問
02. 資源訪問，如URL和文件
03.事件傳播
04. 載入多個（有繼承關系）上下文，使得每一個上下文都專注於一個特定的層次，比如應用的web層
1.利用MessageSource進行國際化
BeanFactory是不支持國際化功能的，因為BeanFactory沒有擴展Spring中MessageResource接口。相反，由於ApplicationContext擴展了MessageResource接口，因而具有消息處理的能力(i18N)

2.強大的事件機制(Event)
基本上牽涉到事件(Event)方面的設計，就離不開觀察者模式。不明白觀察者模式的朋友，最好上網了解下。因為，這種模式在java開發中是比較常用的，又是比較重要的。
ApplicationContext的事件機制主要通過ApplicationEvent和ApplicationListener這兩個接口來提供的，和java swing中的事件機制一樣。即當ApplicationContext中發布一個事件的時，所有擴展了ApplicationListener的Bean都將會接受到這個事件，並進行相應的處理。

Spring提供了部分內置事件，主要有以下幾種：
ContextRefreshedEvent ：ApplicationContext發送該事件時，表示該容器中所有的Bean都已經被裝載完成，此ApplicationContext已就緒可用
ContextStartedEvent：生命周期 beans的啟動信號
ContextStoppedEvent: 生命周期 beans的停止信號
ContextClosedEvent：ApplicationContext關閉事件，則context不能刷新和重啟，從而所有的singleton bean全部銷毀(因為singleton bean是存在容器緩存中的)

雖然，spring提供了許多內置事件，但用戶也可根據自己需要來擴展spriong中的事物。注意，要擴展的事件都要實現ApplicationEvent接口。

3.底層資源的訪問
ApplicationContext擴展了ResourceLoader(資源加載器)接口，從而可以用來加載多個Resource，而BeanFactory是沒有擴展ResourceLoader

4.對Web應用的支持
與BeanFactory通常以編程的方式被創建不同的是，ApplicationContext能以聲明的方式創建，如使用ContextLoader。當然你也可以使用ApplicationContext的實現之一來以編程的方式創建ApplicationContext實例。

ContextLoader有兩個實現：ContextLoaderListener和ContextLoaderServlet。它們兩個有著同樣的功能，除了listener不能在Servlet 2.2兼容的容器中使用。自從Servelt 2.4規范，listener被要求在web應用啟動後初始化。很多2.3兼容的容器已經實現了這個特性。使用哪一個取決於你自己，但是如果所有的條件都一樣，你大概會更喜歡ContextLoaderListener；關於兼容方面的更多信息可以參照ContextLoaderServlet的JavaDoc。

這個listener需要檢查contextConfigLocation參數。如果不存在的話，它將默認使用/WEB-INF/applicationContext.xml。如果它存在，它就會用預先定義的分隔符（逗號，分號和空格）分開分割字符串，並將這些值作為應用上下文將要搜索的位置。ContextLoaderServlet可以用來替換ContextLoaderListener。這個servlet像listener那樣使用contextConfigLocation參數。

5.其它區別
1).BeanFactroy采用的是延遲加載形式來注入Bean的，即只有在使用到某個Bean時(調用getBean())，才對該Bean進行加載實例化，這樣，我們就不能發現一些存在的spring的配置問題。而ApplicationContext則相反，它是在容器啟動時，一次性創建了所有的Bean。這樣，在容器啟動時，我們就可以發現Spring中存在的配置錯誤。

2).BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但兩者之間的區別是：BeanFactory需要手動注冊，而ApplicationContext則是自動注冊

構造器注入：

其他的代碼都差不多，這裡我就直接寫applicationContext.xml

">

<bean id="user1" class="cn.wgy.day01.entity.User">
<constructor-arg index="0" type="java.lang.String" value="Promise"/>
<constructor-arg index="1" type="java.lang.String" value="[email protected]"/>
</bean>
</beans>

多種方式實現依賴注入

設值注入：普通屬性，域屬性（JavaBean屬性）

構造注入：普通屬性，域屬性（JavaBean屬性）

命名空間p注入：普通屬性，域屬性（JavaBean屬性）

我們使用前要先要在Spring配置文件中引入p命名空間：xmlns:p="http://www.springframework.org/schema/p"

注入不同數據類型：

1.注入直接量

2.引用bean組件

3.使用內部bean

4.注入集合類型的屬性

5.注入null和空字符串

<bean id="user" class="cn.wgy.day01.entity.User" p:username="Promise"></bean>

<bean id="dao" class="cn.wgy.day01.dao.impl.UserDao" />

<bean id="biz" class="cn.wgy.day01.biz.impl.UserBiz" p:dao-ref="dao"></bean>


<bean id="list" class="cn.wgy.day01.entity.CollectionBean">
<property name="names">
<list>
<value>Promise</value>
<value>Promise2</value>
</list>
</property>
</bean>

<bean id="set" class="cn.wgy.day01.entity.CollectionBean">
<property name="address">
<set>
<value>北京</value>
<value>上海</value>
</set>
</property>
</bean>

<bean id="map" class="cn.wgy.day01.entity.CollectionBean">
<property name="map">
<map>
<entry key="nh">
<key>
<value>1</value>
</key>
<value>12</value>

</entry>
<entry>
<key>
<value>2</value>
</key>
<value>20</value>

</entry>
</map>
</property>
</bean>

現在我們來理解AOP

什麼是AOP？

面向切面編程（AOP）完善spring的依賴注入（DI），面向切面編程在spring中主要表現為兩個方面
1.面向切面編程提供聲明式事務管理
2.spring支持用戶自定義的切面

面向切面編程（aop）是對面向對象編程（oop）的補充，
面向對象編程將程序分解成各個層次的對象，面向切面編程將程序運行過程分解成各個切面。
AOP從程序運行角度考慮程序的結構，提取業務處理過程的切面，oop是靜態的抽象，aop是動態的抽象，
是對應用執行過程中的步驟進行抽象，，從而獲得步驟之間的邏輯劃分。

aop框架具有的兩個特征：
1.各個步驟之間的良好隔離性
2.源代碼無關性

話不多說，我們直接來代碼，加強理解

我們先看一個簡單的例子：Spring AOP實現日志的輸出，即後置增強和前置增強

我們看看代碼

aop包下

我們要實現AfterReturningAdvice 接口

public class LoggerAfter implements AfterReturningAdvice {
//save()之後執行它
public void afterReturning(Object returnValue, Method method, Object[] arguments ,
Object target) throws Throwable {
System.out.println("===========後置增強代碼==========");

}

}

前置，我們要實現MethodBeforeAdvice接口

*/
public class LoggerBefore implements MethodBeforeAdvice {
//獲取日志對象
private static final Logger log = Logger.getLogger(LoggerBefore.class);
//save()之前執行它
public void before(Method method, Object[] arguments, Object target)
throws Throwable {
log.info("==========前置增強代碼==========");

}

}

實現類：

biz:

public class UserBiz implements IUserBiz {
//實例化所依賴的UserDao對象，植入接口對象
private IDao dao;
public void save2(User user) {
//調用UserDao的方法保存信息
dao.save(user);
}
//dao 屬性的setter訪問器，會被Spring調用，實現設值注入
public IDao getDao() {
return dao;
}
public void setDao(IDao dao) {
this.dao = dao;
}

dao:

public class UserDao implements IDao {
/**
* 保存用戶信息的方法
* @param user
*/
public void save(User user) {
System.out.println("save success!");
}

}

src下的applicationContext.xml

<bean id="dao" class="cn.wgy.day01.dao.impl.UserDao"/>
<bean id="biz" class="cn.wgy.day01.biz.impl.UserBiz">
<property name="dao" ref="dao"></property>
</bean>

<bean id="loggerBefore" class="cn.wgy.day01.aop.LoggerBefore"/>

<bean id="loggerAfter" class="cn.wgy.day01.aop.LoggerAfter"/>

<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="targetName" value="biz"></property>
<property name="interceptorNames" value="loggerBefore,loggerAfter"></property>
</bean>

test

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//獲取到biz對象，即業務邏輯層對象

IUserBiz biz=(IUserBiz)ctx.getBean("serviceProxy");
User user=new User();
/**
* 執行這個方法時，先走前置增強，before（），然後走中間的方法，最後走後置增強
*/
biz.save2(user);
System.out.println("success!");
}

這個簡單的例子就很好的體現出了Spring AOP的力量

順便我們一起來看看其他增強類型

環繞增強：可以把前置增強和後置增強結合起來，spring吧目標的方法的控制權全部交給了它。我們要實現MethodInterceptor接口

aop：

public class AroundLog implements MethodInterceptor {
private static final Logger log = Logger.getLogger(AroundLog.class);

public Object invoke(MethodInvocation arg0) throws Throwable {
/*Object target = arg0.getThis(); // 獲取被代理對象
Method method = arg0.getMethod(); // 獲取被代理方法
Object[] args = arg0.getArguments(); // 獲取方法參數
log.info("調用 " + target + " 的 " + method.getName() + " 方法。方法入參："
+ Arrays.toString(args));
try { Object result = arg0.proceed(); // 調用目標方法，獲取目標方法返回值
log.info("調用 " + target + " 的 " + method.getName() + " 方法。 "
+ "方法返回值：" + result);
return result;
} catch (Throwable e) {
log.error(method.getName() + " 方法發生異常：" + e); throw e;
}*/
//環繞增強
System.out.println("===before=====");

//調用目標對象的方法
Object result = arg0.proceed();
System.out.println("===after=====");

return result;
}

applicationContext.xml：

<bean id="service" class="cn.wgy.day01.service.UserService"/>

<bean id="around" class="cn.wgy.day01.aop.AroundLog"/>

異常增強，我們要實現ThrowsAdvice接口

你注意看沒有，都沒有實現方法，怎麼辦呢？你別急，其實已經給我們規定了方法名稱，而且必須是它才能。就是 void AfterThrowing（）它提供了一個參數，三個參數的。

aop：

public class ErrorLog implements ThrowsAdvice {
private static final Logger log=Logger.getLogger(ErrorLog.class);

@SuppressWarnings("unused")
private void AfterThrowing(Method method, Object[] args, Object target,
RuntimeException e) {
log.error(method.getName()+"方法發生異常"+e);

}

service

public class UserService {
public void delete() {

int result=5/0;
System.out.println(result);

}
}

applicationContext.xml

<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="service"></property>
<property name="interceptorNames" value="error"></property>
</bean>

到這裡我要思考一下，我們可以applicationContext.xml裡面的bean組件修改修改，我們用了顧問(Advisor)要包裝通知（Advice）,比較靈活，可以只針對某一個方法進行處理。

對於環繞增強：

<bean id="advisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<property name="advice" ref="around"></property>
<property name="mappedNames" value="delete"></property>
</bean>

還有一個知識點，我們可以更方便的寫bean組件，正則表達式

</bean>

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames" value="service"></property>
<property name="interceptorNames" value="regex"></property>
</bean>

到這裡呢，算是差不多了，但是我們缺少了分析下源代碼

我們知道，實現aop，其實源代碼裡面通過了動態代理來實現

我們來了解一下代理模式的定義：

為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個對象不適合或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。

代理模式使用代理對象完成用戶請求，屏蔽用戶對真實對象的訪問。

在軟件設計中，使用代理模式的意圖也很多，比如因為安全原因需要屏蔽客戶端直接訪問真實對象，或者在遠程調用中需要使用代理類處理遠程方法調用的技術細節 (如 RMI)，也可能為了提升系統性能，對真實對象進行封裝，從而達到延遲加載的目的。

代理模式角色分為 4 種：

主題接口：定義代理類和真實主題的公共對外方法，也是代理類代理真實主題的方法；

真實主題：真正實現業務邏輯的類；

代理類：用來代理和封裝真實主題；

Main：客戶端，使用代理類和主題接口完成一些工作。

1.什麼是動態代理?

答：動態代理可以提供對另一個對象的訪問，同時隱藏實際對象的具體事實。代理一般會實現它所表示的實際對象的接口。代理可以訪問實際對象，但是延遲實現實際對象的部分功能，實際對象實現系統的實際功能，代理對象對客戶隱藏了實際對象。客戶不知道它是與代理打交道還是與實際對象打交道。
2.為什麼使用動態代理?

答：因為動態代理可以對請求進行任何處理

3.哪些地方需要動態代理?

答：不允許直接訪問某些類；對訪問要做特殊處理等

JAVA 動態代理的作用是什麼？

主要用來做方法的增強，讓你可以在不修改源碼的情況下，增強一些方法，在方法執行前後做任何你想做的事情（甚至根本不去執行這個方法），因為在InvocationHandler的invoke方法中，你可以直接獲取正在調用方法對應的Method對象，具體應用的話，比如可以添加調用日志，做事務控制等。

還有一個有趣的作用是可以用作遠程調用，比如現在有Java接口，這個接口的實現部署在其它服務器上，在編寫客戶端代碼的時候，沒辦法直接調用接口方法，因為接口是不能直接生成對象的，這個時候就可以考慮代理模式（動態代理）了，通過Proxy.newProxyInstance代理一個該接口對應的InvocationHandler對象，然後在InvocationHandler的invoke方法內封裝通訊細節就可以了。具體的應用，最經典的當然是Java標准庫的RMI，其它比如hessian，各種webservice框架中的遠程調用，大致都是這麼實現的。

動態代理我們分之為jdk動態代理和cglib動態代理

JDK實現動態代理需要實現類通過接口定義業務方法，對於沒有接口的類，如何實現動態代理呢，這就需要CGLib了。CGLib采用了非常底層的字節碼技術，其原理是通過字節碼技術為一個類創建子類，並在子類中采用方法攔截的技術攔截所有父類方法的調用，順勢織入橫切邏輯。JDK動態代理與CGLib動態代理均是實現Spring AOP的基礎。

CGLib創建的動態代理對象性能比JDK創建的動態代理對象的性能高不少，但是CGLib在創建代理對象時所花費的時間卻比JDK多得多，所以對於單例的對象，因為無需頻繁創建對象，用CGLib合適，反之，使用JDK方式要更為合適一些。同時，由於CGLib由於是采用動態創建子類的方法，對於final方法，無法進行代理。

1.JDK動態代理

·此時代理對象和目標對象實現了相同的接口，目標對象作為代理對象的一個屬性，具體接口實現中，可以在調用目標對象相應方法前後加上其他業務處理邏輯。

代理模式在實際使用時需要指定具體的目標對象，如果為每個類都添加一個代理類的話，會導致類很多，同時如果不知道具體類的話，怎樣實現代理模式呢？這就引出動態代理。

JDK動態代理只能針對實現了接口的類生成代理。

看看代碼：

dao實現類

public class UserDaoImpl implements UserDao {

public void add() {
System.out.println("add success");
}

}

public class ProxySubject implements Subject {
private Subject realSubject;
public String request() {
System.out.println("代理增強");
return realSubject.request();
}
public Subject getRealSubject() {
return realSubject;
}
public void setRealSubject(Subject realSubject) {
this.realSubject = realSubject;
}

public class RealSubject implements Subject {

public String request() {
// TODO Auto-generated method stub
return "真實主題";
}

}

*/
public interface Subject {
public String request();
}

test

public static void main(String[] args) {
/**
* 靜態代理
*/
/*Subject sub=new RealSubject();//被代理對象
System.out.println(sub.toString());
ProxySubject ps=new ProxySubject();//代理對象
System.out.println(ps.toString());
ps.setRealSubject(sub);
String request = ps.request();//走真實代理對象 RealSubject
System.out.println(request);*/

/**
* 動態代理
*/
final UserDao dao=new UserDaoImpl();
//代理對象
//第一個參數：獲取和dao一樣的類加載器，通過反射機制獲取類加載器
//new InvocationHandler()叫匿名內部類，拿到了接口的實現類
UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {
//newProxyInstance 被代理對象
public Object invoke(Object newProxyInstance, Method method, Object[] args)
throws Throwable {
System.out.println("增強");
//原始對象 dao 真正的dao
Object invoke = method.invoke(dao, args);
System.out.println("記錄日志");
return invoke;
}

});
//增強代理對象，方法
newProxyInstance.add();
}

applicationContext.xml

2.CGLIB代理

CGLIB（CODE GENERLIZE LIBRARY）代理是針對類實現代理，主要是對指定的類生成一個子類，覆蓋其中的所有方法，所以該類或方法不能聲明稱final的。

如果目標對象沒有實現接口，則默認會采用CGLIB代理；

如果目標對象實現了接口，可以強制使用CGLIB實現代理（添加CGLIB庫，並在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>）

public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
//設置需要創建子類的類
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
//通過字節碼技術動態創建子類實例
return enhancer.create();
}
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("前置代理");
//通過代理類調用父類中的方法
Object result = proxy.invokeSuper(obj, args);
System.out.println("後置代理");
return result;
}

test

public class Test {
public static void main(String[] args) {
final UserService service=new UserService();
//1.創建
Enhancer enhancer=new Enhancer();
//2.設置根據哪個類生成子類
enhancer.setSuperclass(service.getClass());
//3.指定回調函數
enhancer.setCallback(new MethodInterceptor() {
//實現MethodInterceptor接口方法
public Object intercept(Object proxy, Method method, Object[] object,
MethodProxy methodproxy) throws Throwable {
//System.out.println("代碼增強");
System.out.println("前置代理");
//通過代理類調用父類中的方法
Object invoke = method.invoke(service, object);
System.out.println("後置代理");
return invoke;
}
});
//通過字節碼技術動態創建子類實例
UserService proxy = (UserService) enhancer.create();
proxy.delete();
}
}

applicationContext.xml

Spring AOP四種實現方式 http://www.linuxidc.com/Linux/2016-10/135993.htm

Spring AOP自定義注解方式實現日志管理 http://www.linuxidc.com/Linux/2015-11/125019.htm

Spring AOP進行日志記錄 http://www.linuxidc.com/Linux/2015-11/124731.htm

使用Spring AOP進行性能監控 http://www.linuxidc.com/Linux/2012-07/64681.htm

利用Spring AOP 更新Memcached 緩存策略的實現 http://www.linuxidc.com/Linux/2012-03/56503.htm

Spring AOP的兩種代理 http://www.linuxidc.com/Linux/2015-11/125017.htm

Spring AOP的注解實例 http://www.linuxidc.com/Linux/2015-11/125018.htm

上一篇文章： Java Swing 去掉按鈕文字周圍的焦點框
下一篇文章： Android sound driver拒絕服務漏洞(CVE-2016-6690)

Linux編程

Spring IOC的簡單實現

Spring：源碼解讀Spring IOC原理

Spring中的IOC和AOP概念淺析

Spring AOP的注解實例

Spring AOP的兩種代理

Spring之AOP模塊

Spring的IOC原理

Spring中的AOP

相關文章

Spring IOC代碼閱讀

Spring AOP四種實現方式

Spring總結—— IOC 和 Bean 的總結

Spring AOP詳細介紹

Spring核心概念之Ioc

Spring核心概念之AOP

Spring學習之IoC總結篇

Spring學習之AOP總結帖

Spring AOP的實現原理

Spring中AOP實例詳解

Spring AOP進行日志記錄

談談對Spring IOC的理解

Linux編程

SHELL編程

PERL編程