2. 程式人生 > >Spring 四種切面技術（攔截）、獲取Spring容器的兩種辦法

Spring 四種切面技術（攔截）、獲取Spring容器的兩種辦法

阿新 • • 發佈：2019-02-11

Spring AOP程式設計

切面（Aspect）：簡單的理解就是把那些與核心業務無關的程式碼提取出來，進行封裝成一個或幾個模組用來處理那些附加的功能程式碼。（如日誌，事務，安全驗證）我們把這個模組的作用理解為一個切面，其實切面就是我們寫一個類，這個類中的程式碼原來是在業務模組中完成的，現在單獨成一個或幾個類。在業務模組需要的時候才織入。

連線點（Joinpoint）：在程式執行過程中某個特定的點，比如某方法呼叫的時候或者處理異常的時候。 在Spring AOP中，一個連線點總是代表一個方法的執行。通過宣告一個JoinPoint型別的引數可以使通知（Advice）的主體部分獲得連線點資訊。

切入點（Pointcut）：本質上是一個捕獲連線點的結構。在AOP中，可以定義一個pointcut，來捕獲相關方法的呼叫

織入（Weaving）：把切面（aspect）連線到其它的應用程式型別或者物件上，並建立一個被通知（advised）的物件。這些可以在編譯時，類載入時和執行時完成。Spring和其它純Java AOP框架一樣，在執行時完成織入。

通知（Advice）：在切面的某個特定的連線點（Joinpoint）上執行的動作。通知有各種型別，其中包括“around”、“before”和“after”等通知。通知的型別將在後面部分進行討論。許多AOP框架，包括Spring，都是以攔截器做通知模型，並維護一個以連線點為中心的攔截器鏈。

通知的型別：

前置通知（Before advice）：在某連線點（join point）之前執行的通知，但這個通知不能阻止連線點前的執行（除非它丟擲一個異常）。

返回後通知（After returning advice）：在某連線點（join point）正常完成後執行的通知：例如，一個方法沒有丟擲任何異常，正常返回。

丟擲異常後通知（After throwing advice）：在方法丟擲異常退出時執行的通知。

後置通知（After（finally）advice）：當某連線點退出的時候執行的通知（不論是正常返回還是異常退出）。

環繞通知（Around Advice）：包圍一個連線點（join point）的通知，如方法呼叫。這是最強大的一種通知型別。 環繞通知可以在方法呼叫前後完成自定義的行為。它也會選擇是否繼續執行連線點或直接返回它們自己的返回值或丟擲異常來結束執行。

1.RegexpMethodPointcutAdvisor切面技術
純Java的方式實現切面(攔截)技術
下面演示程式碼：

public class AopDemo {
    @Test//純Java的方式實現切面(攔截)技術
    public void demo1(){
        Person p=new Person();
        ProxyFactory factory=new ProxyFactory(); //該類的功能沒有ProxyFactoryBean強
        factory.setTarget(p);//1 給代理工廠一個原型物件
        //切面 = 切點 + 通知
        //切點
        JdkRegexpMethodPointcut pointcut=new JdkRegexpMethodPointcut();
        pointcut.setPattern("cn.hncu.spring4x.domain.Person.run");
        //      pointcut.setPattern(".*run.*");ProxyFactory對setPattern無效
        Advice advice=new MethodInterceptor() {

            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("前面攔截");
                Object obj=invocation.proceed();
                System.out.println("後面攔截");
                return obj;
            }
        };
        //切面 = 切點 + 通知
        Advisor advisor=new DefaultPointcutAdvisor(pointcut, advice);

        factory.addAdvice(advice);

        Person p2=(Person) factory.getProxy();
//      p2.run();
//      p2.run(5);
        p2.say();
    }
    @Test//純Java的方式實現切面(攔截)技術
    public void demo2(){
        ProxyFactoryBean factoryBean=new ProxyFactoryBean();
        factoryBean.setTarget(new Person());
        //切面 = 切點 + 通知
        //切點
        JdkRegexpMethodPointcut pointcut=new JdkRegexpMethodPointcut();
        pointcut.setPattern(".*run.*");

        //通知  前切面---不需要放行，原方法也能執行
        Advice beforeAdvice=new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] args, Object target)
                    throws Throwable {
                System.out.println("beforeAdvice攔截");//正則表示式有效
            }
        };
        Advice afterReturning=new AfterReturningAdvice() {
            @Override
            public void afterReturning(Object returnValue, Method method,
                    Object[] args, Object target) throws Throwable {
                System.out.println("afterReturning");
            }
        };

        Advice aroundAdvice=new MethodInterceptor() {

            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("前面攔截");
                Object obj=invocation.proceed();
                System.out.println("後面攔截");
                return obj;
            }
        };
        Advisor advisor1=new DefaultPointcutAdvisor(pointcut, beforeAdvice);
        Advisor advisor2=new DefaultPointcutAdvisor(pointcut, afterReturning);
        Advisor advisor3=new DefaultPointcutAdvisor(pointcut, aroundAdvice);
        factoryBean.addAdvisors(advisor1,advisor2,advisor3);
        //2 給代理工廠一個切面 ---注意,新增的順序的攔截動作執行的順序是有關係的!!!
        //先加的切面，如果攔前面，就攔在最前面，如果攔後面，就攔在最後面.
        Person p = (Person) factoryBean.getObject(); //3 從代理工廠中獲取一個代理後的物件
        //p.run();
        //p.run(0);
        p.say();
    }

}

下面演示5種方式配置檔案AOP

通知：AroundAdvice.java


import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AroundAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("前面攔攔....");
        Object resObj = invocation.proceed();//放行
        System.out.println("後面攔攔.....");
        return resObj;
    }

}

測試程式碼：



import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopXmlDemo {
    @Test//採用配置檔案的方式使用切面攔截
    public void demo1(){
        ApplicationContext act=new ClassPathXmlApplicationContext("cn/hncu/spring4x/aop/1.xml");
        Cat cat=act.getBean("catProxide",Cat.class);//要從catProxide返回
        cat.run();
        cat.say();
        cat.run(6);
    }
    @Test//把切點和通知配置成 切面的內部bean
    public void demo2(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("cn/hncu/spring4x/aop/2.xml");
        Cat cat = ctx.getBean("catProxide",Cat.class);
        cat.run();
        cat.say();
        cat.run(7);
    }
    @Test//直接在切面bean中配置“切點的正則表示式”，省去“切點bean”的配置
    public void demo3(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("cn/hncu/spring4x/aop/3.xml");
        Cat cat = ctx.getBean("catProxide",Cat.class);
        cat.run();
        cat.say();
        cat.run(7);
    }
    @Test//自動代理
    public void demo4(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("cn/hncu/spring4x/aop/4.xml");
        Cat cat = ctx.getBean(Cat.class);
        cat.run();
        cat.say();
        cat.run(7);
    }
    @Test//自己寫的自動代理
    public void demo5(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("cn/hncu/spring4x/aop/5.xml");
        Cat cat = ctx.getBean("cat",Cat.class);
//      cat.run();
//      cat.say();
//      cat.run(7);
    }

}

v1.xml:

<!--?xml version="1.0" encoding="UTF-8"?-->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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.3.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <bean class="cn.hncu.spring4x.aop.Cat" id="cat"></bean>
    <!-- 切點 -->
    <bean class="org.springframework.aop.support.JdkRegexpMethodPointcut" id="pointcut">
        <property name="pattern" value=".*run.*"></property>
    </bean>
    <!-- 通知 ,要自己寫-->
    <bean class="cn.hncu.spring4x.aop.AroundAdvice" id="advice"></bean>

    <!-- 切面=切點+通知 -->
    <bean class="org.springframework.aop.support.DefaultPointcutAdvisor" id="advisor">
        <property name="advice" ref="advice"></property>
        <property name="pointcut" ref="pointcut"></property>
    </bean>

    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="catProxide">
        <property name="target" ref="cat"></property>
        <property name="interceptorNames">
            <list>
                <value>advisor</value>
            </list>
        </property>
    </bean>
</beans>

v2.xml

<!--?xml version="1.0" encoding="UTF-8"?-->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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.3.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <bean class="cn.hncu.spring4x.aop.Cat" id="cat"></bean>

    <!-- 切面=切點+通知 (把切點和通知寫成內部bean)-->
    <bean class="org.springframework.aop.support.DefaultPointcutAdvisor" id="advisor">
        <property name="advice">
            <bean class="cn.hncu.spring4x.aop.AroundAdvice"></bean>
        </property>
        <property name="pointcut">
            <bean class="org.springframework.aop.support.JdkRegexpMethodPointcut">
             <property name="patterns">
                <list>
                    <value>.*run.*</value>
                    <value>.*say.*</value>
                </list>
             </property>

            </bean>
        </property>
    </bean>

    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="catProxide">
        <property name="target" ref="cat"></property>
        <property name="interceptorNames">
            <list>
                <value>advisor</value>
            </list>
        </property>
    </bean>
</beans>

v3.xml

<!--?xml version="1.0" encoding="UTF-8"?-->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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.3.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <bean class="cn.hncu.spring4x.aop.Cat" id="cat"></bean>

    <!--//直接在切面bean中配置“切點的正則表示式”，省去“切點bean”的配置 用到這個類 org.springframework.aop.support.RegexpMethodPointcutAdvisor -->
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="advisor">
        <property name="advice">
            <bean class="cn.hncu.spring4x.aop.AroundAdvice"></bean>
        </property>
        <property name="patterns">
            <list>
                <value>.*run.*</value>
            </list>
        </property>
    </bean>

    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="catProxide">
        <property name="target" ref="cat"></property>
        <property name="interceptorNames">
            <list>
                <value>advisor</value>
            </list>
        </property>
    </bean>
</beans>

v4.xml

<!--?xml version="1.0" encoding="UTF-8"?-->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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.3.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <bean class="cn.hncu.spring4x.aop.Cat" id="cat"></bean>

    <!--//直接在切面bean中配置“切點的正則表示式”，省去“切點bean”的配置 用到這個類 org.springframework.aop.support.RegexpMethodPointcutAdvisor -->
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="advisor">
        <property name="advice">
            <bean class="cn.hncu.spring4x.aop.AroundAdvice"></bean>
        </property>
        <property name="patterns">
            <list>
                <value>.*run.*</value>
            </list>
        </property>
    </bean>
    <!-- 自動代理 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
</beans>

v5.xml

<!--?xml version="1.0" encoding="UTF-8"?-->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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.3.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <bean class="cn.hncu.spring4x.aop.Cat" id="cat"></bean>

    <!--//直接在切面bean中配置“切點的正則表示式”，省去“切點bean”的配置 用到這個類 org.springframework.aop.support.RegexpMethodPointcutAdvisor -->
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="advisor">
        <property name="advice">
            <bean class="cn.hncu.spring4x.aop.AroundAdvice"></bean>
        </property>
        <property name="patterns">
            <list>
                <value>.*run.*</value>
            </list>
        </property>
    </bean>
    <!-- 自動代理 -->

    <bean class="cn.hncu.spring4x.aop.MyAutoProxy"></bean>
</beans>

相關推薦

Spring 四種切面技術（攔截）、獲取Spring容器的兩種辦法

Spring AOP程式設計 切面（Aspect）：簡單的理解就是把那些與核心業務無關的程式碼提取出來，進行封裝成一個或幾個模組用來處理那些附加的功能程式碼。（如日誌，事務，安全驗證）我們把這個模組的作用理解為一個切面，其實切面就是我們寫一個類，這個類中的程式

Spring之面向切面程式設計（AOP）四種通知

面向切面程式設計（AOP）面向切面的程式設計：指很多功能都有重複的程式碼，把這些重複的程式碼獨立出來實現，再在執行的時候動態加入“切面類程式碼”。AOP是一種設計思想，和具體的程式碼實現無關。優點：      A、把共性功能和核心業務功能解耦。      B、共性程式碼的複用

Spring 詳解（二）------- AOP關鍵概念以及兩種實現方式

目錄 1. AOP 關鍵詞 2. AOP 的作用 3. AOP 的通知型別 4. 基於 xml 的配置方式 5. 基於註解的配置方式 6. 切面的優先順序 7. 重用切點表示式 8. 兩種方式的比較（摘自 spring 官方文件） 1. AOP 關鍵詞

在idea中利用Spring進行面向切面程式設計（AOP）的一個例子

（1）在idea中新建立一個maven專案aopAspectj，，編寫POM檔案，匯入jar包： <dependencies> <!--aspectj依賴--> <dependency> <grou

C語言中存儲類別又分為四類：自動（auto）、靜態（static）、寄存器的（register）和外部的（extern）。

字符變量 修飾 例如 register ext 進行 適合 sta -- 除法運算中註意： 如果相除的兩個數都是整數的話，則結果也為整數，小數部分省略，如8/3 = 2；而兩數中有一個為小數，結果則為小數，如：9.0/2 = 4.500000。 取余運算中註意： 該運算只適

文件操作（三）——文件的修改兩種方式

none new enc ast view 決定 cnblogs utf-8 logs #文件的修改兩種方式：# 1、讀入內存，再寫；# 2、硬盤模式決定，將文件先讀出來，寫完再另存，邊讀邊寫。這樣就需要打開兩個文件 1 f=open(‘my_heart_will_go

小橙書閱讀指南（五）——歸並排序的兩種實現

system .so generator tor ide ret style 鏈接 步長 算法描述：將兩個較小的有序數組合並成為一個較大的有序數組是比較容易的事情。我們只需要按照相同的順序依次比較最左側的元素，然後交替的放進新數組即可。這就是自頂向下的歸並排序的實現思路。與

玩轉SpringCloud 三．斷路器（Hystrix）RestTemplate+Ribbon和Feign兩種方式

 此文章基於： 三．斷路器（Hystrix） 在微服務架構中，根據業務來拆分成一個個的服務，服務與服務之間可以相互呼叫（RPC），在Spring Cloud可以用來呼叫。為了保證其高可用，單個服務通常會叢集部署。由於網路原因或者自身的原因，服務並不能保證100%可用，如果單個服務出現問

redis原始碼分析與思考（三）——字典中鍵的兩種hash演算法

      在Redis字典中，得到鍵的hash值顯得尤為重要，因為這個不僅關乎到是否字典能做到負載均衡，以及在效能上優勢是否突出，一個良好的hash演算法在此時就能發揮出巨大的作用。而一個良好的has

SpringBoot學習筆記（二） SpringBoot專案建立的兩種方式

叄念 springboot 專案建立方式其實有多種，這裡我們主要介紹兩種方式： 當然這裡建議大家用方式一來建立，方式二用於理解 方式

（六）、獲取Keystone token的三種方式

讓我們粗略看一下，三種從Keystone獲得token的方式。在嘗試這三種方式之前，你得確保已經裝好Keystone終端。如果還沒有裝好，可以看grizzly安裝版本的Keystone 安裝部分。 Note:這些呼叫都將請求的是Keystone v2版本

N76E003 復位引腳（P20）配置為輸入的兩種方法

由於N76E003管腳比較少，17個標準通用管腳，另外還有一個只能做輸入的引腳（RESET），在專案中就可能需要用到RESET引腳作為輸入，那麼問題來了，怎麼配置RESET引腳當作輸入呢？這裡介紹兩種方法。 先來看下手冊中的介紹，在“配置字”這一章。 主要配置紅色框的位，RPD(R

android介面設計筆記（二）底部導航欄的兩種實現方式

demo:https://github.com/linliangliang/BottomNavagationBar android底部導航欄的實現方式比較多，今天學習其中兩種方式： 一、使用tabLayout+Fragment實現。 二、使用BottomNavagationBar實現。 第一

android介面設計筆記（一）底部導航欄的兩種實現方式

demo:https://github.com/linliangliang/BottomNavagationBar android底部導航欄的實現方式比較多，今天學習其中兩種方式： 一、使用tabLayout+Fragment實現。 二、使用BottomNavigationBar實現。

android介面設計（二）側邊欄的兩種實現方式

dome：https://github.com/linliangliang/sidebar 一、使用sideingMenu結合fragment實現。 二、使用NavigationView和DrawerLayout實現。 第一種實現方式：https://mp.csdn.net/posted

android介面設計（一）側邊欄的兩種實現方式

dome：https://github.com/linliangliang/sidebar 一、使用slideingMenu結合fragment實現。 二、使用Navigation和DrawerLayout實現。 第二種實現方式：https://mp.csdn.net/postedit/

網路程式設計（46）—— windows核心物件的兩種狀態

一、 什麼是核心物件？         我們知道程序、執行緒、檔案、互斥、訊號量這些都是作業系統級別的資源。我們在使用這些資源時，實際上都是由作業系統進行建立和管理的。作業系統為了管理這些資 源，會在其內部建立一個數據塊，也可以理解為一個結構體物件。這個資料塊就是核心物件。

SparkSQL學習（三）SparkSQL讀取Mysql的兩種方式

第一種：package Mysql import java.util.Properties import org.apache.spark.sql.DataFrame import org.apach

Intellij IDEA使用（七）—— 使用Intellij IDEA配置Java（JavaWeb）專案jar包的兩種方式

▶ 配置jar包前的相同操作 1、新建一個lib目錄 2、將jar包複製到lib目錄下 3、開啟配置頁面 ▶ 配置jar包 第一種方式 1、選擇Modules 2、選擇新增JARs 3、新增專案中的jar包 4、新增成功 5、儲存並測試 第二種方式 1、選

Spring Boot 實踐折騰記（11）：使用 Spring 5的WebFlux快速構建效響應式REST API

關於Spring 5中的反應式程式設計支援Reactor類庫，上一篇文章《 Spring Boot 實踐折騰記（10）：2.0+版本中的反應式程式設計支援——Reactor》已經簡要介紹過，Spring 5 框架所包含的內容很多，本文還會繼續介紹其中新增的 W