Java動態代理的原理

Java動態代理機制的出現，使得 Java 開發人員不用手動編寫代理類，只要簡單地指定一組接口及委託類對象，便能動態地獲得代理類。 （建議：java影片教學）

代理程式類別會負責將所有的方法呼叫分派到委託物件上反射執行，在分派執行的過程中，開發人員也可以按需調整委託類物件及其功能，這是一套非常靈活有彈性的代理框架。下面我們開始動態代理的學習。

動態代理程式的簡要說明

在java的動態代理機制中，有兩個重要的類別或接口，一個是InvocationHandler( Interface)、另一個則是Proxy(Class)。

一、 InvocationHandler(interface)的描述：

InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一個動態代理類別都必須要實作InvocationHandler這個接口，並且每個代理類別的實例都關聯到了一個handler，當我們透過代理物件呼叫一個方法的時候，這個方法的呼叫就會被轉發為由InvocationHandler這個介面的invoke 方法來進行呼叫。我們來看看InvocationHandler這個介面的唯一一個方法 invoke 方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

這個方法接收三個參數和回傳一個Object類型，它們分別代表的意思如下：

proxy： 指涉我們所代理的那個真實物件

method： 指涉的是我們所要呼叫真實物件的方法的Method物件

args： 指涉的是呼叫真實物件某個方法時所接受的參數

傳回的Object是指真實物件方法的回傳類型，以上會在接下來的例子中加以深入理解。

the value to return from the method invocation on the proxy instance.

二、 Proxy(Class)的描述：

Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

Proxy這個類別的作用就是用來動態建立一個代理物件。我們常用的是newProxyInstance這個方法：

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

 參數的理解：

// 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
loader - the class loader to define the proxy class  
// 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口
interfaces - the list of interfaces for the proxy class to implement 
// 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
h - the invocation handler to dispatch method invocations to

傳回結果的理解： 一個代理物件的實例

##a proxy instance with the specified invocation handler of a proxy class that is defined by the specified class loader and that implements the specified interfaces 

簡單的Java代理

#我們創建一個Java項目用於對動態代理的測試與理解，專案架構如下：

一、 先定義一個介面Interface，新增兩個方法。

package com.huhx.proxy;

public interface Interface {
    void getMyName();

    String getNameById(String id);
}

二、 定義一個真實的實作上述介面的類，RealObject：

package com.huhx.proxy;

public class RealObject implements Interface {
    @Override
    public void getMyName() {
        System.out.println("my name is huhx");
    }

    @Override
    public String getNameById(String id) {
        System.out.println("argument id: " + id);
        return "huhx";
    }
}

三、 定義一個代理對象，也實現了上述的Interface介面：

package com.huhx.proxy;

public class SimpleProxy implements Interface {
    private Interface proxied;

    public SimpleProxy(Interface proxied) {
        this.proxied = proxied;
    }

    @Override
    public void getMyName() {
        System.out.println("proxy getmyname");
        proxied.getMyName();
    }

    @Override
    public String getNameById(String id) {
        System.out.println("proxy getnamebyid");
        return proxied.getNameById(id);
    }
}

四、 SimpleMain在Main方法中，測試上述的結果：

package com.huhx.proxy;

public class SimpleMain {
    private static void consume(Interface iface) {
        iface.getMyName();
        String name = iface.getNameById("1");
        System.out.println("name: " + name);
    }

    public static void main(String[] args) {
        consume(new RealObject());
        System.out.println("========================================================");
        consume(new SimpleProxy(new RealObject()));
    }
}

五、運行的結果如下：

my name is huhx
argument id: 1
name: huhx
========================================================
proxy getmyname
my name is huhx
proxy getnamebyid
argument id: 1
name: huhx

Java的動態代理

完成了上述簡單的Java代理，現在我們開始學習Java的動態代理，它比代理的思想更向前一步，因為它可以動態地創建代理並動態的處理對所代理方法的呼叫。在動態代理上所做的所有呼叫都會被重新導向到單一的呼叫處理器上，它的工作是揭示呼叫的類型並確定相應的對策。下面我們透過案例來加深Java動態代理的理解：

一、 建立一個繼承了InvocationHandler的處理器：DynamicProxyHandler

package com.huhx.dynamicproxy;

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

public class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        System.out.println("dynamic proxy handler constuctor: " + proxied.getClass());
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("dynamic proxy name: " + proxy.getClass());
        System.out.println("method: " + method.getName());
        System.out.println("args: " + Arrays.toString(args));
        
        Object invokeObject = method.invoke(proxied, args);
        if (invokeObject != null) {
            System.out.println("invoke object: " + invokeObject.getClass());
        } else {
            System.out.println("invoke object is null");
        }
        return invokeObject;
    }
}

# 二、 我們寫一個測試的Main方法，DynamicProxyMain：

package com.huhx.dynamicproxy;

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

import com.huhx.proxy.Interface;
import com.huhx.proxy.RealObject;

public class DynamicProxyMain {
    public static void consumer(Interface iface) {
        iface.getMyName();
        String name = iface.getNameById("1");
        System.out.println("name: " + name);
    }

    public static void main(String[] args) throws Exception, SecurityException, Throwable {
        RealObject realObject = new RealObject();
        consumer(realObject);
        System.out.println("==============================");

        // 动态代理
        ClassLoader classLoader = Interface.class.getClassLoader();
        Class<?>[] interfaces = new Class[] { Interface.class };
        InvocationHandler handler = new DynamicProxyHandler(realObject);
        Interface proxy = (Interface) Proxy.newProxyInstance(classLoader, interfaces, handler);

        System.out.println("in dynamicproxyMain proxy: " + proxy.getClass());
        consumer(proxy);
    }
}

三、 運行結果如下：

my name is huhx
argument id: 1
name: huhx
==============================
dynamic proxy handler constuctor: class com.huhx.proxy.RealObject
in dynamicproxyMain proxy: class com.sun.proxy.$Proxy0
dynamic proxy name: class com.sun.proxy.$Proxy0
method: getMyName
args: null
my name is huhx
invoke object is null
dynamic proxy name: class com.sun.proxy.$Proxy0
method: getNameById
args: [1]
argument id: 1
invoke object: class java.lang.String
name: huhx

從以上輸出結果，我們可以得到以下結論：

與代理物件相關聯的InvocationHandler，只有在代理物件呼叫方法時，才會執行它的invoke方法

invoke的三個參數的理解：Object proxy是代理的物件, Method method是真實物件中呼叫方法的Method類別, Object[] args是真實物件中呼叫方法的參數

Java動態代理程式的原理

一、動態代理程式的關鍵程式碼就是Proxy.newProxyInstance(classLoader, interfaces, handler)，我們跟進原始碼看看：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
　　// handler不能为空
    if (h == null) {
        throw new NullPointerException();
    }

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     */
　　// 通过loader和接口，得到代理的Class对象
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
            // create proxy instance with doPrivilege as the proxy class may
            // implement non-public interfaces that requires a special permission
            return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    return newInstance(cons, ih);
                }
            });
        } else {
　　　　　　　// 创建代理对象的实例
            return newInstance(cons, ih);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString());
    }
}

#二、 我們看一下newInstance方法的原始碼：

private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
    try {
        return cons.newInstance(new Object[] {h} );
    } catch (IllegalAccessException | InstantiationException e) {
        throw new InternalError(e.toString());
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString());
        }
    }
}

三、 當我們透過代理物件呼叫一個方法的時候，這個方法的呼叫就會被轉發為由InvocationHandler這個介面的invoke 方法來進行調用。

###反映這句話的程式碼，我在原始碼中沒有找到，於是我在測試類別的main方法中加入以下程式碼：###

if (proxy instanceof Proxy) {
    InvocationHandler invocationHandler = Proxy.getInvocationHandler(proxy);
    invocationHandler.invoke(proxy, realObject.getClass().getMethod("getMyName"), null);
    System.out.println("--------------------------------------");
}

这段代码的输出结果如下，与上述中调用代理对象中的getMyName方法输出是一样的，不知道Jvm底层是否是这样判断的：

dynamic proxy handler constuctor: class com.huhx.proxy.RealObject
dynamic proxy name: class com.sun.proxy.$Proxy0
method: getMyName
args: null
my name is huhx
invoke object is null
--------------------------------------

更多java知识请关注java基础教程栏目。

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