深入淺出講解Spring框架中AOP及動態代理的應用

2022-03-31 13:03:21

一. Spring AOP

面向切面程式設計(Aspect Oriented Programming,AOP)是軟體程式設計思想發展到一定階段的產物，是對物件導向程式設計(Object Oriented Programming,OOP)的有益補充, 目前已成為一種比較成熟的程式設計方式。AOP適用於具有橫向邏輯的場所，如存取控制、事務管理、效能監測等。

1. 傳統問題：

在傳統的業務處理程式碼中，通常都會進行事務處理、紀錄檔記錄等操作。雖然OOP可以通過組合或者繼承的方式來達到程式碼的重用，但是比如實現紀錄檔記錄時，程式碼還是會分散到不同的方法中。這樣就會存在一個問題，如果想要關閉某個功能或者修改時，就必須要修改所有的相關方法。這不單單增加了開發人員的工作量，而且提高了程式碼的出錯率。

2. 問題的解決策略：

為了解決這個問題，AOP思想隨之產生。AOP採取橫向抽取機制，將分散在各個方法中的重複程式碼提取出來，然後在程式編譯或執行時，再將這些提取出來的程式碼應用到需要執行的地方。這種採用橫向抽取機制的方式，是傳統的OOP思想無法辦到的，因為OOP只能實現父子關係的縱向的重用。雖然AOP是一種新的程式設計思想，卻不是OOP的替代品，它只是OOP的延申和補充。

3. AOP優點：

AOP的使用讓開發人員在編寫業務邏輯時可以專心於核心業務，而不用過多地關注於其他業務邏輯的實現，這不但提高了開發效率，而且增強了程式碼的可維護性。

在AOP思想中，類於切面的關係如下圖所示。我們可以看出，通過Aspect(切面)分別在Class1和Class2的方法中加入了事務、紀錄檔、許可權和異常等功能。

二. 動態代理

通過學習我們知道了AOP中的代理就是由AOP框架動態生成的一個物件，該物件可以作為目標物件使用，對於面向切面程式設計，簡單地說，就是在不改變原程式的基礎上為程式碼段增加新的功能，對程式碼段進行增強處理。它的設計思想來源於代理設計模式，通常情況下呼叫物件的方法如下圖。

在代理模式中可以為該物件設定一個代理物件，代理物件為function()提供一個代理方法，當通過代理物件的function()方法呼叫原物件的function()方法時，就可以在代理方法中新增新的功能，即增強處理。增強的功能既可以插到原物件的function()前面，也可以插到其後面（如虛線）

1. JDK動態代理

JDK動態代理是通過java.lang.reflect.Proxy類來實現的，可以呼叫Proxy類的newProxyInstance()方法來建立代理物件。對於使用業務介面的類，Spring框架會預設使用JDK動態代理來實現AOP。通過一個案例來演示。

1. UserDao.java

package dao;
 
public interface UserDao {
    public void addUserDao();
    public void deleteUser();
}

2. UserDaoImpl.java

package dao;
 
public class UserDaoImpl implements UserDao{
    @Override
    public void addUserDao() {
        System.out.println("新增使用者");
    }
 
    @Override
    public void deleteUser() {
        System.out.println("刪除使用者");
    }
}

3. MyAspect.java

package aspect;
 
public class MyAspect {
    public void check_permission(){
        System.out.println("----模擬檢查存取----");
    }
    public void log(){
        System.out.println("----模擬記錄日記----");
    }
}

4. JdkProxy.java

package jdk;
 
import aspect.MyAspect;
import dao.UserDao;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
/**
 * Jdk代理類
 */
public class JdkProxy implements InvocationHandler {
    //宣告目標類介面
    private UserDao userdao;
//    建立代理方法
    public Object createProxy(UserDao userdao){
        this.userdao=userdao;
        //類載入器
        ClassLoader classLoader=JdkProxy.class.getClassLoader();
        //被代理物件實現的所有介面
        Class[] clazz=userdao.getClass().getInterfaces();
        //使用代理類進行增強，返回的是代理後的物件
        return Proxy.newProxyInstance(classLoader,clazz,this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //宣告切面
        MyAspect myAspect=new MyAspect();
        //前增強
        myAspect.check_permission();
        //在目標上呼叫方法，並傳入引數
        Object obj=method.invoke(userdao,args);
        //後增強
        myAspect.log();
        return obj;
    }
}

5. Test.java

    @Test
    public void shouldAnswerWithTrue()
    {
        JdkProxy jdkProxy=new JdkProxy();
        UserDao userDao=new UserDaoImpl();
        UserDao userDao1=(UserDao) jdkProxy.createProxy(userDao);
        userDao1.addUserDao();
        System.out.println("n-----------------------------分割線------------------------------------n");
        userDao1.deleteUser();
    }

結果：

2. CGLIB代理

JDK 動態代理的使用非常簡單，但它具有一定的侷限性（使用動態代理的物件必須實現一個或多個介面）如果要對沒有實現介面的類進行代理，那麼可以使用CGLIB代理。

CGLIB（Code Generation Library）是一個高效能開源的程式碼生成包，它採用非常底層的位元組碼技術，對指定的目標類生成一個子類，並對子類進行增強。在Spring框架的核心包中已經整合了CGLIB所需要的包，所以開發中不需要另外匯入jar包。

1. BookDao.java

package dao;
 
public class BookDao {
    public void addBook(){
        System.out.println("新增書本");
    }
    public void deleteBook(){
        System.out.println("刪除書本");
    }
}

2. CglibProxy.java

package jdk;
 
 
import aspect.MyAspect;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
 
import java.lang.reflect.Method;
 
public class CglibProxy implements MethodInterceptor {
    //代理方法
    public Object createProxy(Object target){
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
 
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        MyAspect myAspect=new MyAspect();
        myAspect.check_permission();
        Object o1=methodProxy.invokeSuper(proxy,args);
        myAspect.log();
        return o1;
    }
}

結果：

到此這篇關於深入淺出講解Spring框架中AOP及動態代理的應用的文章就介紹到這了,更多相關Spring AOP及動態代理內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！