Spring學習（5）：SpringAOP的5種增強型別

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

前言

Spring使用增強類定義橫切邏輯，同時由於Spring只支援方法連線點，增強類還包括在方法的哪一點加入橫切程式碼的方位資訊，所以增強既包含橫切邏輯，又包含部分連線點資訊。使用增強前，最好能理解動態代理的知識。本文分別採用繼承介面和使用配置檔案來實現增強。

這裡寫圖片描述

按照增強在目標類方法中的連線點位置，可以分為5種：

前置增強：org.springframework.aop.BeforeAdvice是前置增強頂層介面，因為Spring只支援方法的增強，其子介面MethodBeforeAdvice是目前可用的前置增強。表示在目標方法執行前實施增強。
後置增強：org.springframework.aop.AfterReturningAdvice是目前可用的後置增強，表示在目標方法執行後實施增強。

環繞增強：org.aopalliance.intercept.MethodInterceptor代表了環繞增強，表示在目標方法執行前後實施增強。直接使用了AOP聯盟定義的介面。
異常丟擲增強：org.springframework.aop.ThrowsAdvice代表了異常丟擲增強，表示在目標方法丟擲異常後實施增強。
引介增強：org.springframework.aop.IntroductionInterceptor代表引介增強，表示在目標類中新增一些新的方法和屬性。

正文

一，前置增強

1，我們先不用配置檔案，先使用原始的方法–繼承底層介面的形式來實現增強。配置檔案或者註解的底層也是使用這些介面來生成代理的。

首先，建立maven工程，利用pom檔案自動匯入所需的包。
然後，編寫目標類和增強類。

package com.jimmy.mvn.a.BeforeAdvice;

/**
 * 目標類(被增強類),say方法將被增強,其中say方法執行前後都可以是切入點(point-cut)
 */
public class Target {
    public void say() {
        System.out.println("我需要被增強!");
    }
}

package com.jimmy.mvn.a.BeforeAdvice;
import java.lang.reflect.Method;
import 
 org.springframework.aop.MethodBeforeAdvice;

/**
 * 增強類,用於在切入點處進行增強
 * 
 * 該類實現了MethodBeforeAdvice介面，並實現了唯一的before()方法。
 * 
 */
public class Advice implements MethodBeforeAdvice{

    /**
     * method是目標類的方法
     * args是目標類方法的入參
     * target是目標類例項
     * 
     * before()方法會在目標類方法呼叫前執行。
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("我是前置增強，很高興為你服務！");
    }   
}

最後，編寫測試類。

package com.jimmy.mvn.SpringAdvice;

import org.springframework.aop.framework.ProxyFactory;

import com.jimmy.mvn.a.BeforeAdvice.Advice;
import com.jimmy.mvn.a.BeforeAdvice.Target;

public class BeforeAdviceTest {
    public static void main(String[] args) {

        Target target = new Target();  // 目標類物件
        Advice advice = new Advice();  // 增強類物件

        ProxyFactory pf = new ProxyFactory(); // Spring提供的代理工廠
        pf.setTarget(target);  // 設定代理目標
        pf.addAdvice(advice);  // 為代理目標新增增強

        Target target2 = (Target) pf.getProxy(); // 生成代理例項
        target2.say();  // 代理物件再呼叫say()方法就能產生前置增強
    }
}

輸出結果：

我是前置增強，很高興為你服務！
我需要被增強!

2，我們來看如何使用xml配置檔案進行增強

首先，還是先建立maven工程，自動匯入需要的包。
然後，建立目標類和增強類。

package com.jimmy.mvn.a.BeforeAdviceXML;

/**
 * 目標類。同上，很普通的一個類，實際開發中往往是一個業務類 
 */
public class Target {
    public void say() {
        System.out.println("我需要被增強！");
    }
}

package com.jimmy.mvn.a.BeforeAdviceXML;

/**
 * 增強類，該類不再繼承任何介面，就是個普通的POJO類
 * 
 * 從外觀上看，根本看不出來這個類要幹嘛 
 */
public class Advice {   
    public void beforeAdvice() {
        System.out.println("我是前置增強，很高興為你服務！");
    }
}

再然後，寫配置檔案

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <bean id="target" class="com.jimmy.mvn.a.BeforeAdviceXML.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceXML.Advice"></bean>

    <aop:config>
        <aop:aspect ref="advice">           
            <aop:before method="beforeAdvice" pointcut="execution(* com.jimmy.mvn.a.BeforeAdviceXML.*.*(..))"/>         
        </aop:aspect>
    </aop:config>     
</beans>

解讀上面的配置檔案：
1，定義2個bean，target是增強後的bean，而advice是為了在檔案中被切面引用。
2，aop:config，AOP設定的最外層元素，一個檔案可以有多個aop:config，不同的aop:config可以採用不同的代理技術。
3，aop:aspect，改元素定義一個切面，其ref屬性用來引用增強類的bean。
4，aop:before，定義一個前置增強，method屬性是增強類bean中的方法名；pointcut屬性是一個“切點表示式”，該表示式用於匹配“切入點”，即需要被增強的bean的方法。

最後，寫測試程式碼：

package com.jimmy.mvn.SpringAdvice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jimmy.mvn.a.BeforeAdviceXML.Target;

public class BeforeAdviceXMLTest {
    public static void main(String[] args) {

        String path = "com/jimmy/mvn/a/BeforeAdviceXML/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}

輸出結果為：

我是前置增強，很高興為你服務！
我需要被增強！

注：配置檔案配置AOP時，有很多種寫法，還可以將“切點表示式”單獨命名，如下：

<bean id="target" class="com.jimmy.mvn.a.BeforeAdviceXML.Target"></bean>
<bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceXML.Advice"></bean>

<aop:config>
    <aop:aspect ref="advice">
        <aop:pointcut id="pointcut" expression="execution(* com.jimmy.mvn.a.BeforeAdviceXML.*.*(..))"/>
        <aop:before method="beforeAdvice" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>

當然，還可以將aop:pointcut提取出來，單獨寫，可以供很多切面aop:aspect引用：

    <bean id="target" class="com.jimmy.mvn.a.BeforeAdviceXML.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceXML.Advice"></bean>

    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.jimmy.mvn.a.BeforeAdviceXML.*.*(..))"/>

        <aop:aspect ref="advice">
            <aop:before method="beforeAdvice" pointcut-ref="pointcut"/>
        </aop:aspect>
        <aop:aspect ref="advice">
            <aop:before method="beforeAdvice" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

上面這個配置，對切入點進行了2次增強，輸出如下：

我是前置增強，很高興為你服務！
我是前置增強，很高興為你服務！
我需要被增強！

3，最後我們再來用註解Annotation開發

首先，建立maven工程，自動匯入所需要的包
然後，編寫目標類和增強類。

package com.jimmy.mvn.a.BeforeAdviceAnnotation;

/**
 * 目標類。同上，很普通的一個類，實際開發中往往是一個業務類 
 */
public class Target {
    public void say() {
        System.out.println("我還要被增強！");
    }
}

package com.jimmy.mvn.a.BeforeAdviceAnnotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * 增強類，使用註解開發，該類同樣不再繼承任何介面
 * 
 * @Aspect用於將類標識為一個切面
 * @Before("execution(...)")用於將方法標識為增強方法，"切入點表示式"用於定位被切入方法。
 */
@Aspect
public class Advice {   

    @Before("execution(* *..Target.*(..))")
    public void beforeAdvice() {
        System.out.println("我是前置增強，很高興為你服務！");
    }
}

再然後，我們仍然需要配置一點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" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <aop:aspectj-autoproxy/>
    <bean id="target" class="com.jimmy.mvn.a.BeforeAdviceAnnotation.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceAnnotation.Advice"></bean>       
</beans>

解讀上述配置檔案，檔案中只有短短的3行配置。
1，aop:aspectj-autoproxy自動為Spring容器中那些匹配@Aspect切面的bean建立代理，完成切面織入。
2，兩個bean，其中target供測試時getBean方法呼叫；advice可以沒有id，其為自動建立代理時使用。

最後，編寫測試類

package com.jimmy.mvn.SpringAdvice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jimmy.mvn.a.BeforeAdviceAnnotation.Target;

public class BeforeAdviceAnnotationTest1 {
    public static void main(String[] args) {        
        String path = "com/jimmy/mvn/a/BeforeAdviceAnnotation/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}

這裡的輸出結果是：

我是前置增強，很高興為你服務！
我還要被增強！

二，後置增強

跟前置增強的使用一樣一樣的。

三，環繞增強

1，還是先使用繼承底層介面的形式。

首先，建立maven工程，自動匯入jar包。
然後，建立目標類和增強類。

package com.jimmy.mvn.b.AroundAdvice;

/**
 * 目標類，普通POJO類，其say方法被增強。
 */
public class Target {
    public void say(){
        System.out.println("我需要前後都增強！");
    }
}

package com.jimmy.mvn.b.AroundAdvice;

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

/**
 * 增強類實現了MethodInterceptor介面，並實現了其中的invoke方法
 */
public class AroundAdvice implements MethodInterceptor{

    /**
     * 該方法截獲目標類方法的執行，並在前後加上橫斷邏輯
     */
    public Object invoke(MethodInvocation invocation) throws Throwable {

        System.out.println("我是前置增強，很高興為你服務！"); // 前置增強
        Object obj = invocation.proceed(); // 通過反射機制呼叫目標方法
        System.out.println("我是前置增強，很高興為你服務！"); // 後置增強
        return obj;
    }
}

最後，編寫測試類，該測試類跟前置增強時用的一樣。

package com.jimmy.mvn.SpringAdvice;

import org.springframework.aop.framework.ProxyFactory;

import com.jimmy.mvn.b.AroundAdvice.AroundAdvice;
import com.jimmy.mvn.b.AroundAdvice.Target;

public class AroundAdviceTest {
    public static void main(String[] args) {
        Target target = new Target();
        AroundAdvice advice = new AroundAdvice();

        ProxyFactory pf = new ProxyFactory();
        pf.setTarget(target);
        pf.addAdvice(advice);

        Target target2 = (Target) pf.getProxy();
        target2.say();
    }
}

輸出結果：

我是前置增強，很高興為你服務！
我需要前後都增強！
我是後置增強，很高興為你服務！

2，我們再來使用XML配置檔案配置環繞增強AOP

首先，建立maven工程，自動匯入jar包。
然後，建立目標類和增強類。

package com.jimmy.mvn.b.AroundAdviceXML;

/**
 * 目標類，跟上面是一樣一樣的。
 */
public class Target {
    public void say() {
        System.out.println("我還要前後增強！");
    }
}

package com.jimmy.mvn.b.AroundAdviceXML;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 增強類，普通POJO類，不再繼承任何介面。
 * 自定義環繞增強方法，由於是要在切入點前後橫插入邏輯，所以將ProceedingJoinPoint介面物件pjp作為方法的入參。
 * pjp.proceed()方法通過反射機制呼叫目標方法。
 * 在pjp.proceed()前後加上橫斷邏輯。
 */
public class AroundAdvice {

    public void myAroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("我是前置增強，很高興為你服務!");
        pjp.proceed();
        System.out.println("我是後置增強，很高興為你服務!");
    }
}

再然後，編寫配置檔案，smart-context.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" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <bean id="target" class="com.jimmy.mvn.b.AroundAdviceXML.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.b.AroundAdviceXML.AroundAdvice"></bean>

    <aop:config>
        <aop:aspect ref="advice">           
            <aop:around method="myAroundAdvice" pointcut="execution(* *..Target.*(..))"/>           
        </aop:aspect>
    </aop:config>     
</beans>

我們看到，配置檔案跟前置增強的差別不大，無非是把aop:before換成了aop:around。

最後，編寫測試類。

package com.jimmy.mvn.SpringAdvice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jimmy.mvn.b.AroundAdviceXML.Target;

public class AroundAdviceXMLTest {
    public static void main(String[] args) {
        String path = "com/jimmy/mvn/b/AroundAdviceXML/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}

輸出結果：

我是前置增強，很高興為你服務!
我還要前後增強！
我是後置增強，很高興為你服務!

3，最後我們用註解（Annotation）寫程式碼

首先，建立maven工程，自動匯入jar包。
然後，建立目標類和增強類。

package com.jimmy.mvn.b.AroundAdviceAnnotation;

public class Target {
    public void say() {
        System.out.println("我還要前後增強！");
    }
}

package com.jimmy.mvn.b.AroundAdviceAnnotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AroundAdvice {

    @Around(value = "execution(* *..Target.*(..))")
    public void myAroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("我是前置增強，很高興為你服務!");
        pjp.proceed();
        System.out.println("我是後置增強，很高興為你服務!");
    }
}

再然後，編寫配置檔案，smart-context.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" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <aop:aspectj-autoproxy/>
    <bean id="target" class="com.jimmy.mvn.b.AroundAdviceAnnotation.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.b.AroundAdviceAnnotation.AroundAdvice"></bean>  
</beans>

同樣，使用了註解，只有3句配置資訊。

最後，編寫測試程式碼

package com.jimmy.mvn.SpringAdvice;

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

import com.jimmy.mvn.b.AroundAdviceAnnotation.Target;

public class AroundAdviceAnnotationTest {
    public static void main(String[] args) {
        String path = "com/jimmy/mvn/b/AroundAdviceAnnotation/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}

輸出結果為：

我是前置增強，很高興為你服務!
我還要前後增強！
我是後置增強，很高興為你服務!

總結

SpringAOP的概念一開始不容易接受，一旦接受了，結合Spring提供的AOP框架使用起來就會很方便。

Spring學習（5）：SpringAOP的5種增強型別

前言

正文

總結

Spring學習（5）：SpringAOP的5種增強型別

mybatis學習（5）：關聯查詢的幾種方式

Spring學習（3）：Spring概述（轉載）

Spring學習（3）：IOC基礎（轉載）

tensorflow學習（5）：變數管理

多執行緒學習（4）：三種實現Java多執行緒的方法：Thread、Callable和Runable 的比較與區別

多執行緒學習（5）：synchronized 的基礎使用

three.js學習（5）：Renderer

caffe入門學習（5）：繪製網路結構圖

Spring學習（1）：控制反轉（IoC）和依賴注入（DI）的詳解以及註解（annotation）開發入門案例

mysql學習（5）：多表之間的關係

機器學習（5）：機器學習的一個例項

Spring學習6（5）：FactoryBean及使用註解配置

Swift學習筆記（5）：集合類型

SpringBoot學習筆記（5）：處理前端JSON返回的日期的格式

《Linux學習並不難》用戶管理（5）：修改Linux用戶賬戶

《Linux學習並不難》文件/目錄管理（5）： ls命令列出目錄和文件信息

Spring學習（4）IOC容器配置bean：定義與實例化

深入學習Redis（5）：叢集

linux學習筆記（5）：檔案許可權

Spring學習（5）：SpringAOP的5種增強型別

前言

正文

總結

相關推薦