約定程式設計與Sping AOP

阿新 • • 發佈：2022-04-12

一、約定程式設計

Spring AOP是一種約定流程的程式設計，咱們可以先通過動態代理模式的實現來理解Spring AOP的概念。

代理的邏輯很簡單，例如，當你需要採訪一名兒童時，首先需要經過他父母的同意，在一些問題上父母也許會替他回答，而對於另一些問題，也許父母覺得不太適合這個小孩會拒絕掉，顯然這時父母就是這名兒童的代理（proxy）了。通過代理可以增強或者控制對兒童這個真實物件（target）的訪問。

1. 首先實現攔截器介面Interceptor（自己定義的介面）

下面程式碼均使用spring boot 2.6.2

package com.springboot.chapter4.intercept;

 
import java.lang.reflect.InvocationTargetException;
import com.springboot.chapter4.invoke.Invocation;

public class MyInterceptor implements Interceptor {

    @Override
    public boolean before() {
        System.out.println("before ......");
        return true;
    }

    @Override
    public boolean 
 useAround() {
        return true;
    }

    @Override
    public void after() {
        System.out.println("after ......");
    }

    @Override
    public Object around(Invocation invocation) 
           throws InvocationTargetException, IllegalAccessException 
   {
        System.out.println("around before ......");
        Object obj  
= invocation.proceed();
        System.out.println("around after ......");
        return obj;
    }

    @Override
    public void afterReturning() {
        System.out.println("afterReturning......");

    }

    @Override
    public void afterThrowing() {
        System.out.println("afterThrowing......");
    }

}

2 建立代理物件

在Java的JDK中，提供了類Proxy的靜態方法——newProxyInstance，給予我們來生成一個代理物件（proxy）：

public static Object  newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces, 
    InvocationHandler invocationHandler) throws IllegalArgumentException

它有3個引數：

•classLoader——類載入器；（被代理的類）

•interfaces——繫結的介面，也就是把代理物件繫結到哪些介面下，可以是多個；（被代理的類實現的介面列表）

•invocationHandler ——繫結代理物件邏輯實現。

這裡的invocationHandler是一個介面InvocationHandler物件，它定義了一個invoke方法，這個方法就是實現代理物件的約定流程

package com.springboot.chapter4.proxy;
package com.springboot.chapter4.proxy;
/**** imports ****/
public class ProxyBean implements InvocationHandler {

     private Object target = null;//代理物件
     private Interceptor interceptor = null;//攔截器

     public ProxyBean (Object target,Interceptor interceptor){
       this.target=target;
       this.interceptor=interceptor;
     }

     /**
     * 處理代理物件方法邏輯
     * @param proxy 代理物件
     * @param method 當前方法
     * @param args  執行引數
     * @return 方法呼叫結果
     * @throws Throwable 異常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)  {
        // 異常標識
        boolean exceptionFlag = false;
        Invocation invocation = new Invocation(target, method, args);
        Object retObj = null; 
        try {
            if (this.interceptor.before()) {
                retObj = this.interceptor.around(invocation);
            } else {
                retObj = method.invoke(target, args);
            }
        } catch (Exception ex) {
            // 產生異常
            exceptionFlag = true;
        }
        this.interceptor.after();
        if (exceptionFlag) {
            this.interceptor.afterThrowing();
        } else {
            this.interceptor.afterReturning();
            return retObj;
        }
        return null;
    }

}

從上面例子可以看到：代理物件proxyBean定義了織入流程即invoke方法，將攔截器MyInterceptor包裝到目標物件tagert的method上。

3. 測試效果

/**
     * 繫結代理物件
     * @param target 被代理物件
     * @param interceptor 攔截器
     * @return 代理物件
     */
    public static Object getProxyObject(Object target, Interceptor interceptor) {
        ProxyBean proxyBean = new ProxyBean(target,interceptor);//proxyBean定義了織入流程即invoke方法
        // 生成代理物件
        Object proxy = Proxy.newProxyInstance(
                       target.getClass().getClassLoader(), 
                       target.getClass().getInterfaces(),
                       proxyBean);//proxyBean實現target物件的介面列表，實現方式為呼叫代理物件的方法時通過invoke（invoke可呼叫target物件的方法）呼叫target物件對應的方法。
        // 返回代理物件
        return proxy;
    }

private static void testProxy() {
    IHelloService helloService = new HelloServiceImpl();//被代理物件
    // 按約定獲取proxy
    IHelloService proxy = (IHelloService) getProxyObject(
        helloService, new MyInterceptor());
    proxy.sayHello("zhangsan");
    System.out.println("\n###############name is null!!#############\n");

    proxy.sayHello(null);
}

二、Spring AOP概念和術語

Spring AOP是一種基於方法的AOP，它只能應用於方法上。在Spring中可以使用多種方式配置AOP，因為Spring Boot採用註解方式，所以這裡只介紹使用@AspectJ註解的方式。AOP可以減少大量重複的工作，最為典型的應用場景就是資料庫事務的管控。比如資料庫的開啟和關閉以及事務的提交和回滾都有流程預設給你實現。換句話說，你都不需要完成它們，你需要完成的任務是編寫SQL這一步而已，然後織入流程中。

@Autowired
private UserDao = null;
......

@Transactional
public int inserUser(User user) {
    return userDao.insertUser(user);
}

這裡可以看到僅僅使用了一個註解@Transactional，表明該方法需要事務執行，沒有任何資料庫開啟和關閉的程式碼，也沒有事務回滾和提交的程式碼，卻實現了資料庫資源的開啟和關閉、事務的回滾和提交。

1.AOP術語：

•連線點（join point）：對應的是具體被攔截的物件，因為Spring只能支援方法，所以被攔截的物件往往就是指特定的方法，例如，我們前面提到的HelloServiceImpl的sayHello方法就是一個連線點，AOP將通過動態代理技術把它織入對應的流程中。

•切點（point cut）：有時候，我們的切面不單單應用於單個方法，也可能是多個類的不同方法，這時，可以通過正則式和指示器的規則去定義，從而適配連線點。切點就是提供這樣一個功能的概念。

•通知（advice）：就是按照約定的流程下的方法，分為前置通知（beforeadvice）、後置通知（after advice）、環繞通知（around advice）、事後返回通知（afterReturning advice）和異常通知（afterThrowing advice），它會根據約定織入流程中，需要弄明白它們在流程中的順序和執行的條件。

•目標物件（target）：即被代理物件，例如，約定程式設計中的HelloServiceImpl例項就是一個目標物件，它被代理了。

•引入（introduction）：是指引入新的類和其方法，增強現有Bean的功能。

•織入（weaving）：它是一個通過動態代理技術，為原有服務物件生成代理物件，然後將與切點定義匹配的連線點攔截，並按約定將各類通知織入約定流程的過程。

•切面（aspect）：是一個可以定義切點、各類通知和引入的內容，Spring AOP將通過它的資訊來增強Bean的功能或者將對應的方法織入流程。

2.具體實現

2.1.新增maven依賴

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2.2. 定義切面

首先Spring是以@Aspect作為切面宣告的，當以@Aspect作為註解時，Spring就會知道這是一個切面，然後我們就可以通過各類註解（@Before、@After、@AfterReturning和@AfterThrowing）來定義各類的通知了。

package com.springboot.chapter4.aspect;
/**** imports ****/
@Component //注入到Spring IOC
@Aspect //定義切面
public class MyAspect {

    //引入
    @DeclareParents(value= "co.springboot.chapter4.aspect.service.impl.UserServiceImpl",defaultImpl=UserValidatorImpl.class) 
    public UserValidator userValidator;

    //定義切點
    @Pointcut("execution(* com.springboot.chapter4.aspect.service.impl.UserServiceImpl.printUser(..))")
    public void pointCut() {
    }

//無參模式
    @Before("pointCut()")
    public void before() {
        System.out.println("before ......");
    }

    //獲取引數模式
    //方式1：切點處加入對應的正則式
    //方式2：對於非環繞通知還可以使用一個連線點（JoinPoint）型別的引數，通過它也可以獲取引數
    //正則式pointCut() && args(user)中，pointCut()表示啟用原來定義切點的規則，並且約定將連線點（目標物件方法）名稱為user的引數傳遞進來。這裡要注意，JoinPoint型別的引數對於非環繞通知而言，Spring AOP會自動地把它傳遞到通知中；對於環繞通知而言，可以使用ProceedingJoinPoint型別的引數。
    @Before("pointCut() && args(user)") 
    public void beforeParam(JoinPoint point, User user) {
        Object[] args = point.getArgs();
        System.out.println("before ......");
    }  

    //環繞通知
    //注意：用環繞通知註解測試的時候總是不按順序執行，估計是Spring版本之間的差異留下的問題，這是在使用時需要注意的。所以在沒有必要的時候，應儘量不要使用環繞通知，它很強大，但是也很危險。
   @Around("pointCut()")
   public void around(ProceedingJoinPoint jp) throws Throwable {
       System.out.println("around before......");
       jp.proceed();//回撥目標物件的原有方法

      System.out.println("around after......");
   }

    @After("pointCut()")
    public void after() {
        System.out.println("after ......");
    }

    @AfterReturning("pointCut()")
    public void afterReturning() {
        System.out.println("afterReturning ......");
    }

    @AfterThrowing("pointCut()")
    public void afterThrowing() {
        System.out.println("afterThrowing ......");
    }    
}

上述例子用到的基礎類如下

View Code

2.3 定義切點

execution(* com.springboot.chapter4.aspect.service.impl.UserServiceImpl.printUser(..))

•execution表示在執行的時候，攔截裡面的正則匹配的方法；　　
•* 表示任意返回型別的方法；

•com.springboot.chapter4.aspect.service.impl.UserServiceImpl 指定目標物件的全限定名稱；

•printUser指定目標物件的方法；

•(..)表示任意引數進行匹配。

2.4 使用@DeclareParents 定義引入

@DeclareParents，它的作用是在不侵入原有業務的前提上對原有的服務進行增強，它有兩個必須配置的屬性value和defaultImpl。

•value：指向你要增強功能的目標物件，這裡是要增強UserServiceImpl物件，因此可以看到配置為com.springboot.chapter4.aspect.service.impl.UserServiceImpl+。

•defaultImpl：引入增強功能的類，這裡配置為UserValidatorImpl，用來提供校驗使用者是否為空的功能。

2.5 使用切面的指示器

切面中可以使用的指示器如下，比如上述例子中arg()獲取切點的引數值

3.測試效果

package com.springboot.chapter4.aspect.controller;
/**** imports ****/
// 定義控制器
@Controller
// 定義類請求路徑
@RequestMapping("/user")
public class UserController {

    // 注入使用者服務
    @Autowired
    private UserService userService = null;

    // 定義請求
    @RequestMapping("/print")
    // 轉換為JSON
    @ResponseBody
    public User printUser(Long id, String userName, String note) {
        User user = new User();
        user.setId(id);
        user.setUsername(userName);
        user.setNote(note);
        userService.printUser(user);// 若user=null，則執行afterthrowing方法

        //測試引入
        UserValidator userValidator = (UserValidator)userService;
        if (userValidator.validate(user)) {
            userService.printUser(user);
        }
 
        return user;// 加入斷點
    }
}

3.1未引入效果

before ......
id =1 username =user_name_1 note =2323
after ......
afterReturning ......

3.2引入效果

引入新的介面：UserValidator
around before......
before ......
id =1 username =user_name_1 note =2323
around after......
after ......
afterReturning ......

3.4 引入原理

這裡的newProxyInstance的第二個引數為一個物件陣列，也就是說這裡生產代理物件時，Spring會把UserService和UserValidator兩個介面傳遞進去，讓代理物件下掛到這兩個介面下，這樣這個代理物件就能夠相互轉換並且使用它們的方法了。

Object proxy = Proxy.newProxyInstance(
    target.getClass().getClassLoader(), 
    target.getClass().getInterfaces(),
    proxyBean);

3.5 織入方式

上面我們都是採用介面（如UserService）+實現類（如UserServiceImpl）的模式，這是Spring推薦的方式，本書也遵循這樣的方式。但是對於是否擁有介面則不是Spring AOP的強制要求，對於動態代理的也有多種實現方式，我們之前談到的JDK只是其中的一種，業界比較流行的還有CGLIB、Javassist、ASM等。Spring採用了JDK和CGLIB，對於JDK而言，它是要求被代理的目標物件必須擁有介面，而對於CGLIB則不做要求。因此在預設的情況下，Spring會按照這樣的一條規則處理，即當你需要使用AOP的類擁有介面時，它會以JDK動態代理執行，否則以CGLIB執行。

不使用介面例子

......
// 定義控制器
@Controller
// 定義類請求路徑
@RequestMapping("/user")
public class UserController {
    // 使用非介面注入
    @Autowired
    private UserServiceImpl userService = null;

    // 定義請求
    @RequestMapping("/print")
    // 返回JSON
    @ResponseBody
    public User printUser(Long id, String userName, String note) {
        User user = new User();
        user.setId(id);
        user.setUsername(userName);
        user.setNote(note);
        userService.printUser(user);
        return user;// 加入斷點測試
     }
     ......
}

此時Spring已經使用了CGLIB為我們生成代理物件，從而將切面的內容織入對應的流程中。當使用介面時，用JDK為我們生成代理物件。

4. 多個切面

Spring提供了一個註解@Order和一個介面Ordered，我們可以使用它們的任意一個指定切面的順序。

......
@Aspect
@Order(1)
public class MyAspect1 {
......
}

//或者

......
@Aspect
public class MyAspect1 implements Ordered {
    // 指定順序
    @Override
    public int getOrder() {
        return 1;
    }
    ....
}

效果如下

MyAspect1 before ......
MyAspect2 before ......
MyAspect3 before ......
測試多個切面順序
MyAspect3 after ......
MyAspect3 afterReturning ......
MyAspect2 after ......
MyAspect2 afterReturning ......
MyAspect1 after ......
MyAspect1 afterReturning ......

約定程式設計與Sping AOP

約定程式設計與Sping AOP

開始約定程式設計——Spring AOP

1.3 約定程式設計Spring AOP

深入討論Python 裝飾器 (與Java Aop對比思考)

python 高階程式設計與非同步IO併發程式設計(一)python中一切皆物件

10_泛型程式設計與STL

nodejs.cn-Node.js-入門教程：JavaScript 非同步程式設計與回撥

Java 高併發程式設計與詳解筆記（一）-- 初識 Java 執行緒

網路程式設計與併發程式設計

Java語言程式設計與資料結構

WinForm多執行緒程式設計與Control.Invoke的應用淺談

C# 併發程式設計 (非同步程式設計與多執行緒)

JS 非同步程式設計與Promise，還有async與await例項

Java語言程式設計與資料結構（基礎篇）課後複習題第十章（一）

Java語言程式設計與資料結構（基礎篇）課後練習題第十章（二）

matlab 1到無窮_分析軟體工具 | MATLAB程式設計與應用第3版(劉衛國)課後實驗

jQuery: 鏈式程式設計與 end()

程式設計與程式設計軟體（python-pycharm）

《彙編程式設計與計算機體系結構》學習筆記（1）

3D遊戲程式設計與設計作業九

約定程式設計與Sping AOP

相關推薦