2. 程式人生 > >Spring學習筆記 —— AOP標籤詳解()

Spring學習筆記 —— AOP標籤詳解()

阿新 • • 發佈：2019-01-05

引言

但是，除了面向切面程式設計之外，AOP的名字空間中還包含了一些重要的標籤，比如”scoped-proxy”。這篇文章就會詳細介紹這個標籤的作用，以及它的實現方式分析。

scoped-proxy 標籤介紹

在 Spring學習筆記 —— 從IOC說起，我們介紹過，Spring中的Bean是有Scope屬性的，代表著bean的生存週期。而Spring中預設的Scope分為”singleton”和”prototype”兩種。

那麼，問題就來了，如果在一個singleton的Bean中引用了一個prototype的Bean，結果會怎樣呢？——在預設情況下，單例會永遠持有一開始構造所賦給它的值。

所以，為了讓我們在每次呼叫這個Bean的時候都能夠得到具體scope中的值，比如prototype，那麼我們希望每次在單例中呼叫這個Bean的時候，得到的都是一個新的prototype，Spring中AOP名字空間中引入了這個標籤。
xml
<aop:scoped-proxy/>

示例

舉個例子。
PrototypeBean.java這個類在初始化的時候會得到當前時間的時間戳，它的scope為prototype（每次獲取都會重新生成一個）。

public class PrototypeBean {
    private Long timeMilis;

    public
 
 PrototypeBean(){
        timeMilis = (new Date()).getTime();
    }

    public void printTime() {
        System.out.println(timeMilis+"");
    }
}

SingletonBean.java這個單例的Bean持有一個PrototypeBean，同時它的printTime()方法輸出PrototypeBean的時間戳。

public class SingletonBean {
    private PrototypeBean prototype;

    public
 
 void printTime() {
        prototype.printTime();
    }

    public void setPrototype(PrototypeBean prototype) {
        this.prototype = prototype;
    }
}

scopedProxyBean.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <bean id="protyotypBean" class="com.study.scopedProxy.PrototypeBean" scope="prototype">
    <aop:scoped-proxy/>
    </bean>

    <bean id="singletonBean" class="com.study.scopedProxy.SingletonBean">
        <property name="prototype">
            <ref bean="protyotypBean" />  
        </property>
    </bean>

</beans>

ScopedProxyMain.java

public class ScopedProxyMain {
    public static void main(String args[]) {
        ApplicationContext app = new ClassPathXmlApplicationContext("scopedProxyBean.xml");

        SingletonBean singleton = app.getBean(SingletonBean.class);

        singleton.printTime();
        //1477958215532
        singleton.printTime();
        //1477958215571
    }
}

如果不加上<aop:scoped-proxy/>這個標籤，那麼兩次將會輸出同樣的時間戳。而我們加上標籤之後，每次呼叫這個Bean的時候，系統就會先取一遍這個Bean，確保我們得到的Bean是在當前的scope當中的。

原始碼解析

那麼具體在程式碼層面，是如何完成這個實現的呢？

我們還是從AopNamespaceHandler先著手。

AopNamespaceHandler.init裡面是對各個標籤進行解析類註冊，我們能看到，scoped-proxy對應的註冊類就是ScopedProxyBeanDefinitionDecorator

registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

而再到這個類裡面，發現它實現了BeanDefinitionDecorator介面，於是檢視其decorate方法。

BeanDefinitionHolder holder =
                ScopedProxyUtils.createScopedProxy(definition, parserContext.getRegistry(), proxyTargetClass);

createScopedProxy

String originalBeanName = definition.getBeanName();
        BeanDefinition targetDefinition = definition.getBeanDefinition();
        String targetBeanName = getTargetBeanName(originalBeanName);

        // 建立一個ScopedProxyFactoryBean，這個Bean中儲存了目標Bean的名稱,
        // 同時在內部儲存了目標Bean定義的引用。注意並沒有對BeanDefinition設定scope，
        //因此這個代理bean的scope就預設是singleton了。
        RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
        proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
        proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
        proxyDefinition.setSource(definition.getSource());
        proxyDefinition.setRole(targetDefinition.getRole());

        proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
        // 預設情況下proxyTargetClass都是True
        if (proxyTargetClass) {
            targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);

        }
        else {
            proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
        }

        proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
        proxyDefinition.setPrimary(targetDefinition.isPrimary());
        if (targetDefinition instanceof AbstractBeanDefinition) {
            proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
        }


        targetDefinition.setAutowireCandidate(false);
        targetDefinition.setPrimary(false);

        // 因為在後面還是會用到目標Bean，因此也需要將它的定義註冊到Registry中
        registry.registerBeanDefinition(targetBeanName, targetDefinition);

        //將新的Bean返回
        return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());

對於BeanDefintion的解析，到這裡就可以看作結束了。那麼，這個ScopedProxyFactoryBean，又會在什麼時候建立，怎麼建立呢？

關鍵就是要看ScopedProxyFactoryBean.setBeanFactory

@Override
    public void setBeanFactory(BeanFactory beanFactory) {
        if (!(beanFactory instanceof ConfigurableBeanFactory)) {
            throw new IllegalStateException("Not running in a ConfigurableBeanFactory: " + beanFactory);
        }
        ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;

        this.scopedTargetSource.setBeanFactory(beanFactory);

        ProxyFactory pf = new ProxyFactory();
        pf.copyFrom(this);
        //這個這個代理Bean設定Bean的來源，很重要。這個方法決定了，
        //每次取target的時候，都會呼叫beanFactory.getBean。
        pf.setTargetSource(this.scopedTargetSource);

        Class<?> beanType = beanFactory.getType(this.targetBeanName);
        if (beanType == null) {
            throw new IllegalStateException("Cannot create scoped proxy for bean '" + this.targetBeanName +
                    "': Target type could not be determined at the time of proxy creation.");
        }
        if (!isProxyTargetClass() || beanType.isInterface() || Modifier.isPrivate(beanType.getModifiers())) {
            pf.setInterfaces(ClassUtils.getAllInterfacesForClass(beanType, cbf.getBeanClassLoader()));
        }

        // 構建一個introduction，這個introduction只實現了ScopedObject的所有介面
        ScopedObject scopedObject = new DefaultScopedObject(cbf, this.scopedTargetSource.getTargetBeanName());
        //將scopedObject作為通知加入到proxy中，DelegatingIntroductionInterceptor作為通知的攔截器，
        //實際上是使得所有在proxyBean上呼叫的'getTargetObject`方法都被代理到了`DefaultScopedObject`中。
        //在增加通知的同時會生成DefaultIntroductionAdvisor 作為advisor，
        pf.addAdvice(new DelegatingIntroductionInterceptor(scopedObject));

        pf.addInterface(AopInfrastructureBean.class);

        this.proxy = pf.getProxy(cbf.getBeanClassLoader());
    }

而在後面，根據advisor生成相應的代理類，在之前已經解釋過了，就不再贅述了。

而關於Introduction，這裡有一個很好的例子。你也可以將cglib生成的class檔案儲存，就能夠發現最後的Bean中的確存在著getTargetObject這個方法。

個人認為註冊Advice的作用並不是很大，因為我們已經為這個ProxyBean設定好它的target source了，對於scoped-proxy的目的也就達到了。

最後來看一下真正被使用的地方把。

DynamicAdvisedInterceptor.intercept，前文也說過了，這個是CglibAOP的攔截類。所有被攔截的方法都會首先呼叫這裡的intercept。

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Class<?> targetClass = null;
            Object target = null;
            try {
                if (this.advised.exposeProxy) {
                    // Make invocation available if necessary.
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }
                //最重要的就是這裡，getTarget，
                //這會到之前設定過的TargetSource中去獲取TargetObject，
                //也就是SimpleBeanTarget的getTarget方法，
                //到這一步，scoped的proxy已經完成。
                target = getTarget();
                //省略後續呼叫
        }

小結

在這裡我們介紹了AOP的一個重要標籤，scoped-proxy。它是由ScopedProxyFactoryBean進行建立的，在建立的時候，為生成代理Bean的ProxyFactory指定了TargetSource，因此在每次攔截方法，進行呼叫之前，首先都會到指定的TargetSouce，也就是SimpleBeanTargetSource中獲取對應Scoped下的Bean。

此外，ScopedProxyFactory還為這個Bean增加了getTargetObject的方法（使用Introduction），因此所有帶上了這個標籤的Bean，也就預設實現了ScopedObject的介面，可以呼叫getTargetObject方法。這個方法的意義在於，因為代理Bean的scope是預設singleton的，這也就意味著，我們每次呼叫applicationContext.getBean方法，總是返回同一個代理bean，如果我們想要獲得scope下真正的bean的話，就可以呼叫getTargetObject方法了。

相關推薦

Spring學習筆記 —— AOP標籤詳解()

引言 但是，除了面向切面程式設計之外，AOP的名字空間中還包含了一些重要的標籤，比如”scoped-proxy”。這篇文章就會詳細介紹這個標籤的作用，以及它的實現方式分析。 scoped-proxy 標籤介紹 在 Spring學習筆記 —

expect學習筆記及例項詳解

expect學習筆記及例項詳解 引用自：http://wenku.baidu.com/view/b65e103610661ed9ad51f374.html   1. expect 是基於tcl 演變而來的，所以很多語法和tcl 類似，基本的語法如下 所示： 1.1 首行

C語言學習筆記---malloc函式詳解

                                                                                            malloc函式詳解 一、malloc函式標頭檔案： #include<stdli

Spring學習筆記 —— AOP（面向切面程式設計） 之AspectJ

引言 在上一篇文章， Spring學習筆記 —— AOP（面向切面程式設計） 之Spring內建AOP中，我們簡單介紹了AOP的概念，也分析了Spring中使用proxyFactroyBean生成代理物件的實現原理。 當我們只需要對一個物件進行代理

斯坦福大學的機器學習筆記SVM初探詳解

最近在看斯坦福大學的機器學習的公開課，學習了支援向量機，再結合網上各位大神的學習經驗總結了自己的一些關於支援向量機知識。 一、什麼是支援向量機(SVM)? 1、支援向量機（Support Vector Machine，常簡稱為SVM）是一種監督式學習的方法，可廣泛地應用於統

YOLOv2--論文學習筆記（演算法詳解）

主要包括三個部分：Better，Faster，Stronger，其中前面兩部分基本上講的是YOLO v2，最後一部分講的是YOLO9000。 Better 這部分細節很多，要詳細瞭解的話還是需要結合原始碼來看。 本篇論文是YOLO作者為了改進原有的YOLO演

spring學習之@SessionAttributes運用詳解

  一、@ModelAttribute  在預設情況下，ModelMap 中的屬性作用域是 request 級別是，也就是說，當本次請求結束後，ModelMap中的屬性將銷燬。如果希望在多個請求中共享 ModelMap 中的屬性，必須將其屬性轉存到 session 中，這樣ModelMap 的屬性才可

Spring學習筆記 —— AOP（面向切面程式設計） 之使用ProxyFactoryBean實現AOP

引言 到上一篇文章Spring學習筆記 —— Spring Context為止，我們已經基本瞭解Spring中的基本物件——Bean——的建立、相關屬性的注入以及獲取。其實在這不難發現，Spring的容器設計與Java的物件設計之間是有相似的地方的，

PHPUnit學習筆記(四)斷言詳解

斷言(Assertions)是PHPUnit提供的一系列對程式執行結果測試的方法。通俗的講，就是斷言執行程式結果為我們期待的值，如果不是則測試失敗，下面是斷言方法的詳細介紹，內容全部來翻譯自PHPUnit的官方文件，部分方法官方介紹的很模糊，我根據官方的原始碼註釋增加了說明和註釋

Android學習筆記之選單詳解

選單概述 每個Activity都可以指定它自己的選單，按下硬體選單鍵即可顯示選項選單。。但是從 Android 3.0（API 級別 11）開始，硬體選單就變成了可選擇的。Activity推薦使用應用欄和溢位選單來代替傳統的6鍵選單。儘管某些選單項的設計和使用

iOS學習筆記5-MPMoviePlayerController詳解

MPMoviePlayerController 在iOS中播放視訊可以使用MediaPlayer.framework種的MPMoviePlayerController類來完成，它支援本地視訊和網路視訊播放。這個類實現了MPMediaPlayback協議，因此具備一般的播放器

Spring XML配置Bean標籤詳解

前段時間回顧Spring的一些技術和資訊，自己去試著配置框架進行練習,這裡就分享一下Spring bean配置的各種標籤方便自己去配置資訊， beans: 整個配置檔案的根節點，包含一個或多個Bean元素。在該標記中可配置名稱空間與schema的裝載路徑，還可以通過

Spring學習筆記（四）：Spring AOP詳解

一.前言 二、什麼是 AOP？ AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設計）的補充和完善。OOP引入封裝、繼承、多型等概念來建立一種

Spring學習筆記——Spring Scope（作用域）詳解

引言 在Spring學習筆記 —— 從IOC說起中，曾經提到過Spring中的Bean是根據Scope（作用域）來生成的，但是一直都沒有詳細解釋過，除了Singleton（單例）和prototype（原型）作用域之外，另外一種重要的作用域——使用者自定義

spring學習筆記(17)資料庫配置[1]spring資料連線池詳解

資料連線池 在spring中，常使用資料庫連線池來完成對資料庫的連線配置，類似於執行緒池的定義，資料庫連線池就是維護有一定數量資料庫連線的一個緩衝池，一方面，能夠即取即用，免去初始化的時間，另一方面，用完的資料連線會歸還到連線池中，這樣就免去了不必要的連線建立

spring學習筆記(11)@AspectJ研磨分析[2]切點表示式函式詳解

Spring中的AspectJ切點表示式函式 切點表示式函式就像我們的GPS導航軟體。通過切點表示式函式，再配合萬用字元和邏輯運算子的靈活運用，我們能很好定位到我們需要織入增強的連線點上。經過上面的鋪墊，下面來看看Springz中支援的切點表示式函式。

Spring batch學習 持久化表結構詳解(2)

true fig 序列化 roc col id字段 exce har class #接上一篇 這一篇講一下持久化需要表 batch_job_execution, batch_job_execution_context, batch_job_execution_pa

Spring AOP配置詳解

<aop:aspectj-autoproxy />的作用 通過配置織入@Aspectj切面 雖然可以通過程式設計的方式織入切面，但是一般情況下，我們還是使用spring的配置自動完成建立代理織入切面的工作。 通過aop名稱空間的<aop:aspectj-autoprox

82_h5筆記6_多媒體標籤 +棄用和新增標籤 + meta標籤詳解

一，video標籤 作用: 播放視訊 格式1: <video src=""> </video> video標籤的屬性 src: 告訴video標籤需要播放的視訊地址 autoplay: 告訴video標籤是否需要自動播放視訊

Spring註解標籤詳解@Autowired @Qualifier

@Autowired spring2.1中允許使用者通過@Autowired註解對Bean的屬性變數.屬性Setter方法以及建構函式進行標註,配合AutowiredAnnotationBeanProcessor完成Bean的自動配置。使用@Autowired註釋進行byType注入。 在a