Java動態代理與靜態代理的實例分析

一、靜態代理

靜態代理的使用

靜態代理，代理類別和被代理的類別實作了同樣的接口，代理類別同時持有被代理類別的引用，這樣，當我們需要呼叫被代理類別的方法時，可以透過呼叫代理類別的方法來做到。

範例：假設領導者的工作是開會和給員工考評。

先定義一個介面：

package com.sharpcj;
public interface IWork {
    void meeting();
    int evaluate(String name);
}

然後定義領導類別：

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");
    }
}

執行結果：

這個程式碼很簡單，注意在呼叫Secretary類別的meeting 方法時，我們呼叫了Leader類別的meeting 的方法，在此之前，我們也擴充了這個方法。這時有的人可能有疑惑了，這看起來有點是裝飾者模式了。這到底怎麼回事？

與裝飾者模式的差異

實際上，在裝飾器模式和代理模式之間還是有很多差別的。裝飾器模式關注於在一個物件上動態的添加方法，然而代理模式關注於控制對物件的存取。換句話說，用代理模式，代理類別（proxy class）可以對它的客戶隱藏一個物件的具體資訊。因此，當使用代理模式的時候，我們常常在一個代理類別中建立一個物件的實例。並且，當我們使用裝飾器模式的時候，我們通常的做法是將原始物件作為一個參數傳給裝飾者的建構器。

我們可以用另一句話來總結這些差異：使用代理模式，代理與真實物件之間的關係通常在編譯時就已經確定了，而裝飾者能夠在運行時遞歸地被構造。

先看看兩者的UML 類別圖差異：

#代理模式：

裝飾者模式：

「兩者偽代碼：

代理模式:

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 接口的類。

二、動態代理

動態代理程式的根據實作方式的差異可以分為 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 。

以上是Java動態代理與靜態代理的實例分析的詳細內容。更多資訊請關注PHP中文網其他相關文章！