外掛化開發筆記（一）代理模式

前言

      外掛化開發所涉及到的技術點非常多，比如程式的啟動流程、四大元件啟動流程、ClassLoader原理、上下文Context、AMS原理、反射、代理等。本篇主要簡單介紹代理模式（實際上只是一篇學習筆記），為後面介紹外掛化實現做知識鋪墊。

一、定義

       定義：為其他物件提供一種代理，以控制對這個物件的訪問，這種形式稱為代理模式。（看起來挺抽象的，不好理解，能理解下面的解釋就夠了）

       代理模式也叫委託模式，是結構性設計模式的一種。在現實生活中，我們用到類似代理模式的場景非常多，比如買房者找房屋中介買房、受害者委託律師打官司、老闆安排助理採購等。這些場景有一個共同特點：真正想做某件事的人 ，因為行業壁壘等各種原因自己不容易完成，於是轉而找其他專業人士來替自己完成這個意願。以老闆安排助理採購電腦裝置為例：老闆（即委託者）是真是需要購買電腦裝置的人，但由於缺乏對電腦裝置的瞭解，於是委派助理（即代理）來完成自己的這次採購意願。

 

二、角色及結構

       在代理模式中，包含了如下的角色：

       Subject：抽象主題類，宣告真實主題與代理的共同介面方法。也就是定義一個介面，定義老闆和助理的這次行為：採購！

       RealSubject：真實主題類，定義了代理所表示的集體物件，客戶端通過代理類間接呼叫真實主題類的方法。即老闆，真正需要採購的人。

       Proxy：代理類，持有對真實主題類的引用，在其所實現的介面方法中呼叫真實主題類中相應的介面方法執行。即助理，以老闆的名義去採購。

       Client：客戶端類。也就是一段邏輯程式碼，將上述角色組織起來，完成這次採購行為。

       類結構圖如下：

 

三、程式碼實現

       從編碼的角度來說，代理模式分為靜態代理和動態代理，可以結合下面的例子來理解。（1）靜態代理，在程式碼執行前代理類的class檔案就已經存在了，結合下面的程式碼直觀的理解就是，代理類Assistant類是寫死的，在執行前這個編譯類Assistant.class就存在了。（2）動態代理，則是在程式碼執行時才會通過反射來動態地生成代理類物件，並確定到底來代理誰。也就是說，我們在編碼階段並不會定義出這個代理類，而是在執行的時候動態生成。從下面的程式碼實現中，我們發現，動態代理實現時，並沒有出現Assistant這個類。

       下面我們來用程式碼實現靜態代理和動態代理。

    1、靜態代理

//Subject：抽象主題類，定義了老闆和助理的這次行為
public interface IShop {
    void buy();
}

//RealSubject:真實主體類。實現了抽象主題介面
public class Boss implements IShop {
    @Override
    public void buy() {
        System.out.println("I am boss,I buy buy buy");
    }
}

//Proxy：代理類。以組合的方式持有了對真實主題類Boss的引用，也實現了抽象主題介面。在實現的buy方法中，呼叫了真實主題Boss的對應方法。
public class Assistant implements IShop {
    private IShop mBoss;
    Assistant(IShop shoper) {
        mBoss = shoper;
    }

    @Override
    public void buy() {
        mBoss.buy();
    }
}

//Client：客戶端類
public class ProxyDemo {
    public static void main(String[] args) {
        IShop boss = new Boss();
        IShop assitant = new Assistant(boss);
        assitant.buy();
    }
}

 執行結果

I am boss,I buy buy buy

       這裡我們可以看到，Client類中呼叫的是代理Assistant的buy方法，而實際完成的是委託者Boss的buy方法，從而實現了這次代理行為。       

    2、動態代理

public interface IShop {
    void buy();
}

public class Boss implements IShop {
    @Override
    public void buy() {
        System.out.println("I am boss,I buy buy buy");
    }
}

//Java提供了動態的代理介面InvocationHandler，實現該介面需要重寫invoke方法。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {
    private Object mObject;

    DynamicProxy(Object object) {
        mObject = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        System.out.println("invoke methodName=" + method.getName());
        method.invoke(mObject, objects);
        return null;
    }
}

//Client
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        //建立boss類
        IShop boss = new Boss();
        //建立動態代理
        InvocationHandler proxyHandler = new DynamicProxy(boss);
        ClassLoader classLoader = boss.getClass().getClassLoader();
        //動態建立代理類
        IShop assitant = (IShop) Proxy.newProxyInstance(classLoader, new Class[]{IShop.class}, proxyHandler);
        assitant.buy();
    }
}

執行結果

invoke methodName=buy
I am boss,I buy buy buy

       在動態代理類DynamicProxy中，宣告瞭一個Object的引用，該應用指向被代理類物件（該例項中指向的就是Boss類物件），我們呼叫被代理類物件（Boss物件）的具體方法（該例子中指buy方法）會在invoke方法中執行。在Client類中的Proxy.newProxyInstance()來生成動態代理類物件assistant，而呼叫assistant.buy()方法時會呼叫DynamicProxy類中的invoke方法，這樣就間接地呼叫了Boss類中的buy()方法，從而實現了動態代理。

 

四、靜態代理和動態代理對比

       說到使用動態代理的好處，可能得一大篇文章才說得清楚，在這裡我只想提一點，就是動態代理下，直到執行時才會生成代理類，當代理場景比較多時，可以節約很多不必要的浪費。這裡我們比較一下，有多個代理場景時，靜態代理和動態代理的表現。

    1、靜態代理實現多個代理場景

public interface IShop {
    void buy();
}

public class Boss implements IShop {
    @Override
    public void buy() {
        System.out.println("I am boss,I buy buy buy");
    }
}

public class Assistant implements IShop {
    private IShop mBoss;
    Assistant(IShop shoper) {
        mBoss = shoper;
    }

    @Override
    public void buy() {
        mBoss.buy();
    }
}

public interface IDrive {
    void drive();
}

public class Leader implements IDrive {
    @Override
    public void drive() {
        System.out.println("I am leader,I drive drive drive");
    }
}

public class Driver implements IDrive {
    private IDrive mLeader;

    Driver(IDrive driver) {
        mLeader = driver;
    }

    @Override
    public void drive() {
        mLeader.drive();
    }
}

public class ProxyDemo {
    public static void main(String[] args) {
        IShop boss = new Boss();
        IShop assitant = new Assistant(boss);
        assitant.buy();

        IDrive leader = new Leader();
        IDrive driver = new Driver(leader);
        driver.drive();
    }
}

執行結果

I am boss, I buy buy buy
I am leader,I drive drive drive

     如上程式碼實際上就是兩個代理場景的疊加，增加一個場景，程式碼量增加一倍。

    2、動態代理實現多個代理場景

public interface IShop {
    void buy();
}

public class Boss implements IShop {
    @Override
    public void buy() {
        System.out.println("I am boss,I buy buy buy");
    }
}

public interface IDrive {
    void drive();
}

public class Leader implements IDrive {
    @Override
    public void drive() {
        System.out.println("I am leader,I drive drive drive");
    }
}

//動態代理類
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {
    private Object mObject;

    DynamicProxy(Object object) {
        mObject = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        System.out.println("invoke methodName=" + method.getName());
        method.invoke(mObject, objects);
        return null;
    }
}

//Client
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        IShop boss = new Boss();
        InvocationHandler proxyHandler = new DynamicProxy(boss);
        ClassLoader classLoader = boss.getClass().getClassLoader();
        IShop assitant = (IShop) Proxy.newProxyInstance(classLoader, new Class[]{IShop.class}, proxyHandler);
        assitant.buy();
    }
}

執行結果

invoke methodName=buy
I am boss, I buy buy buy
invoke methodName=drive
I am leader,I drive drive drive

       由於不需要單獨實現代理類，多個代理場景下實際上就節約了很多的程式碼量。

 

結語

       代理模式作為設計模式中的一種，使用比較廣泛，內容非常多，筆者知識有限，暫時先介紹這麼多，希望能幫助初學者能夠掌握代理模式的基本知識和使用。