靜態代理和動態代理

時間  2019-12-07
標籤 靜態 代理 動態 欄目 網站開發 简体版
原文   原文鏈接

學習 Spring 的過程當中，不可避免要掌握代理模式。這篇文章總結一下代理模式。顧名思義，代理，就是你委託別人幫你辦事，因此代理模式也有人稱做委託模式的。好比領導要作什麼事，能夠委託他的祕書去幫忙作，這時就能夠把祕書看作領導的代理。下面將以這個例子來說解。
代理模式又分爲靜態代理和動態代理。java

1、靜態代理

靜態代理的使用

靜態代理，代理類和被代理的類實現了一樣的接口，代理類同時持有被代理類的引用，這樣，當咱們須要調用被代理類的方法時，能夠經過調用代理類的方法來作到。舉例以下：
假設領導的工做是開會和給員工考評。
先定義一個接口：dom

package com.sharpcj;

public interface IWork {
    void meeting();

    int evaluate(String name);
}

而後定義領導類：ide

package com.sharpcj;

import java.util.Random;

public class Leader implements IWork {

    @Override
    public void meeting() {
        System.out.println("領導早上要組織會議");
    }

    @Override
    public int evaluate(String name) {
        int score = new Random(System.currentTimeMillis()).nextInt(20) + 80;
        System.out.println(String.format("領導給%s的考評爲%s分", name, score));
        return score;
    }
}

祕書類：學習

package com.sharpcj;

public class Secretary implements IWork {
    private Leader mLeader;

    public Secretary(Leader mLeader) {
        this.mLeader = mLeader;
    }

    @Override
    public void meeting() {
        System.out.println("祕書先給老闆準備材料");
        mLeader.metting();
    }

    @Override
    public int evaluate(String name) {
        return mLeader.evaluate(name);
    }
}

測試類：測試

package com.sharpcj;

public class TestApp {
    public static void main(String[] args) {
        Leader leader = new Leader();
        Secretary secretary = new Secretary(leader);
        secretary.meeting();
        secretary.evaluate("Joy");
    }
}

執行結果：
gradle

這個代碼很簡單，注意在調用Secretary類的 meeting 方法時，咱們調用了Leader類的 meeting 的方法，在此以前，咱們還擴充了該方法。這時有的人可能有疑惑了，這看起來有點是裝飾者模式了。這到底怎麼回事？ui

與裝飾者模式的區別

實際上，在裝飾器模式和代理模式之間仍是有不少差異的。裝飾器模式關注於在一個對象上動態的添加方法，然而代理模式關注於控制對對象的訪問。換句話說，用代理模式，代理類（proxy class）能夠對它的客戶隱藏一個對象的具體信息。所以，當使用代理模式的時候，咱們經常在一個代理類中建立一個對象的實例。而且，當咱們使用裝飾器模式的時候，咱們一般的作法是將原始對象做爲一個參數傳給裝飾者的構造器。this

咱們能夠用另一句話來總結這些差異：使用代理模式，代理和真實對象之間的的關係一般在編譯時就已經肯定了，而裝飾者可以在運行時遞歸地被構造。lua

先看看二者的 UML 類圖區別：
代理模式
.net

裝飾者模式

二者僞代碼：
代理模式:

Interface Subject {
    void doAction()
}

public class RealSubject implements Subject{
    @Override
    public void doAction() {};
}


public class Proxy implements Subject{
       private RealSubject realSubject;

       public Proxy(RealSubject realSubject) {
             //關係在編譯時肯定
            this.realSubject = realSubject;
       }

       @Override
       public void doAction() {
             ….
             realSubject.doAction();
             ….
       }
}

// 裝飾者模式

Interface Component {
    void doAction()
}

public class ConcreteComponent implement Component {
    @Override
    public void doAction() {};
}

public class Decorator implements Component {
       private Component component;

       public Decorator(Component component) {
             //關係在編譯時肯定
            this.component = new component;
       }
       public void doAction() {
             ….
             component.doAction();
             ….
       }
}

其實代理模式和裝飾者模式側重點不同，代理模式重點在於明確了被代理的類。如上例中，祕書很明確要代理的是的領導。而裝飾者模式側重於拓展類的方法，裝飾類持有的實現Component接口的類的對象不是固定的，也就是說，裝飾類能夠根據在調用時傳入的參數，裝飾任意一個實現了 Component 接口的類。

2、動態代理

動態代理的根據實現方式的不一樣能夠分爲 JDK 動態代理和 CGlib 動態代理。
JDK 動態代理：利用反射機制生成一個實現代理接口的類，在調用具體方法前調用InvokeHandler來處理。
CGlib 動態代理：利用ASM（開源的Java字節碼編輯庫，操做字節碼）開源包，將代理對象類的class文件加載進來，經過修改其字節碼生成子類來處理。
區別：JDK代理只能對實現接口的類生成代理；CGlib是針對類實現代理，對指定的類生成一個子類，並覆蓋其中的方法，這種經過繼承類的實現方式，不能代理final修飾的類。

JDK 動態代理

仍是以上面的例子爲例：
首先，定一個類實現 InvocationHandler 接口，並實現 invoke 方法：

package com.sharpcj;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class WorkInvocationHandler implements InvocationHandler {
    private Object object;

    public WorkInvocationHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("object: " + object.getClass().getSimpleName());
        System.out.println("proxy: " + proxy.getClass().getSimpleName());

        if ("meeting".equals(method.getName())) {
            System.out.println("代理先準備會議材料...");
            return method.invoke(object, args);
        } else if ("evaluate".equals(method.getName())) {
            if(args[0] instanceof String) {
                if ("James".equals(args[0])) {
                    System.out.println("James 犯過錯誤，因此考評分數較低...");
                    return 70;
                }
            }
            return method.invoke(object, args);
        }
        return null;
    }
}

而後經過 Proxy.newProxyInstance() 方法建立代理對象：

package com.sharpcj;

import java.lang.reflect.Proxy;

public class TestApp {
    public static void main(String[] args) {
        /*Leader leader = new Leader();
        Secretary secretary = new Secretary(leader);
        secretary.meeting();
        secretary.evaluate("Joy");*/

        Leader leader = new Leader();
        IWork proxy = (IWork) Proxy.newProxyInstance(Leader.class.getClassLoader(),
                new Class[]{IWork.class}, new WorkInvocationHandler(leader));
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

輸出結果：

咱們看到，經過 WorkInvocationHandler 類，咱們一樣能夠代理 Leader 類的方法的實現，實際上咱們實現的是任意的方法的實現，只是咱們在建立代理對象的時候傳入的是 Iwork 接口以及 Leader 類對象。
這裏須要注意的是：在 InvocationHandler 接口的 invoke 方法中第一個參數 proxy, 並非咱們調用方法的對象，那這個參數是什麼呢？代碼中，我特別增長相應打印，打印出了 proxy 的類名，實際上 proxy 是代理對象自己，它的意義在於，咱們能夠在 invoke 方法中，返回該代理對象，而後進行連續調用。
看以下例子：

package com.sharpcj.proxytest;

public interface IWork {
    IWork work(String subject);
}
package com.sharpcj.proxytest;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class WorkInvocationHandler implements InvocationHandler {
    private Object object;

    public WorkInvocationHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("work".equals(method.getName())){
            System.out.println("--- work: " + args[0]);
            return proxy;
        }
        return null;
    }
}
package com.sharpcj.proxytest;

import java.lang.reflect.Proxy;

public class TestApp {
    public static void main(String[] args) {
        IWork worker = (IWork) Proxy.newProxyInstance(IWork.class.getClassLoader(), new Class[]{IWork.class},
                new WorkInvocationHandler(new IWork() {
                    @Override
                    public IWork work(String subject) {
                        return null;
                    }
                }));
        worker.work("AAA").work("BBB").work("CCC");
    }
}

結果以下：

CGlib 動態代理實現

首先添加 cglib 依賴
build.gradle 文件：

... 

dependencies {
    // 引入 cglib 庫
    compile 'cglib:cglib:3.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
...

前面說了，cglib 針對類進行代理，咱們以上面的 Leader 類爲例，先建立一個類實現 MethodInterceptor接口：

package com.sharpcj;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class LeaderMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if ("meeting".equals(method.getName())) {
            System.out.println("代理先準備會議材料...");
            return methodProxy.invokeSuper(o, objects);
        } else if ("evaluate".equals(method.getName())) {
            if(objects[0] instanceof String) {
                if ("James".equals(objects[0])) {
                    System.out.println("James 犯過錯誤，因此考評分數較低...");
                    return 70;
                }
            }
            return methodProxy.invokeSuper(o, objects);
        }
        return null;
    }
}

測試代碼：

package com.sharpcj;

import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;

import java.lang.reflect.Proxy;

public class TestApp {
    public static void main(String[] args) {
        // System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\temp\\code");  //保存生成的 class 文件
        Enhancer enhancer = new Enhancer(); // 經過CGLIB動態代理獲取代理對象的過程
        enhancer.setSuperclass(Leader.class); // 設置enhancer對象的父類
        enhancer.setCallback(new LeaderMethodInterceptor()); // 設置enhancer的回調對象
        Leader proxy= (Leader)enhancer.create(); // 建立代理對象

        // 經過代理對象調用目標方法
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

結果以下：

MethodInterceptor 接口只有一個 intercept 方法，這個方法有4個參數：
1）obj表示加強的對象，即實現這個接口類的一個對象；
2）method表示要被攔截的方法；
3）args表示要被攔截方法的參數；
4）proxy表示要觸發父類的方法對象；

須要注意的是，實際調用是 methodProxy.invokeSuper(), 若是使用 invoke() 方法，則須要傳入被代理的類對象，不然出現死循環，形成 stackOverflow 。
詳情參考： 聊聊cglib動態代理遇到的坑: https://blog.csdn.net/kingmax54212008/article/details/83902535

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程