java代理模式與動態代理模式詳解

1、代理模式

所謂代理，就是一個人或一個機構代表另一個人或另一個機構採取行動。在某些情況下，一個客戶不想或無法直接引用一個對象，而代理對象可以在客戶端和目標對象之前起到中介的作用。
代理模式提供某一個物件一個代理對象，並由代理對象控制對原對象的參考。

生活中的例子：過年加班比較忙，沒空去買火車票，這時可以打個電話到附近的票務中心，叫他們幫你買張回家的火車票，當然這會附加額外的勞務費。但要清楚票務中心自己不賣票，只有火車站才真正賣票，票務中心賣給你的票其實是透過火車站實現的。這點很重要！

上面這個例子，你就是“客戶”，票務中心就是“代理角色”，火車站是“真實角色”，賣票稱為“抽象角色”！

代理模式JAVA程式碼範例：
抽象角色：抽象類別或介面

interface Business  
{  
    void doAction();  
}

真實角色：真正實現了業務邏輯介面

代理角色：自己並未實現業務邏輯接口，而是調用真實角色來實現

代理角色：自己並未實現業務邏輯接口，而是調用真實角色來實現

class BusinessImplProxy implements Business  
{  
    private BusinessImpl bi;  
    public void doAction()  
    {  
        if (bi==null)  
        {  
            bi = new BusinessImpl();  
        }  
        doBefore();  
        bi.doAction();  
        doAfter();  
    }  
    public void doBefore()  
    {  
        System.out.println("前置处理！");  
    }  
    public void doAfter()  
    {  
        System.out.println("后置处理！");  
    }  
}  
//测试类  
class Test  
{  
    public static void main(String[] args)  
    {  
        //引用变量定义为抽象角色类型  
        Business bi = new BusinessImplProxy();  
        bi.doAction();  
    }  
}

<span></span>

所以，借助於JVM的支持，可以在運行時動態生成代理類（“代理角色”），我們就可以解決上述代理模式中代碼膨脹的問題，使用了動態代理後，“代理角色”將不用手動生成，而由JVM在執行時，透過指定類別載入器、介面陣列、呼叫處理程序這3個參數來動態生成。

動態代理模式JAVA代碼示例：

import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Proxy;
 import java.lang.reflect.Method;
 //抽象角色：java动态代理的实现目前只支持接口，不支持抽象类
 interface BusinessFoo
 {
     void foo();
 }
 interface BusinessBar
{
    String bar(String message);
}
//真实角色：真正实现业务逻辑方法
class BusinessFooImpl implements BusinessFoo
{
    public void foo()
    {
        System.out.println("BusinessFooImpl.foo()");
    }
}
class BusinessBarImpl implements BusinessBar
{
    public String bar(String message)
    {
        System.out.println("BusinessBarImpl.bar()");
        return message;
    }
}
//动态角色：动态生成代理类
class BusinessImplProxy implements InvocationHandler
{
    private Object obj;
    BusinessImplProxy() {
    }
    BusinessImplProxy(Object obj) {
        this.obj = obj;
    }
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
    {
        Object result = null;
        doBefore();
        result = method.invoke(obj,args);
        doAfter();
        return result;
    }
    public void doBefore(){
        System.out.println("do something before Business Logic");
    }
    public void doAfter(){
        System.out.println("do something after Business Logic");
    }
    public static Object factory(Object obj)
    {
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
    }
}
//测试类
public class DynamicProxy
{    
    public static void main(String[] args) throws Throwable
    {
        BusinessFooImpl bfoo = new BusinessFooImpl();
        BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
        bf.foo();
        System.out.println();

        BusinessBarImpl bbar = new BusinessBarImpl();
        BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
        String message = bb.bar("Hello,World");
        System.out.println(message);
    }
}

程序流程說明：

new BusinessFooImpl();創建一個“真實角色”，傳遞給工廠方法BusinessImplProxy.factory()，進而初始化“調用處理器”——即實現InvocationHandler的類別。並且傳回一個動態建立的代理類別實例，由於「代理角色」也必然實現了「抽象角色」提供的業務邏輯方法，故可向下轉型為BusinessBar，並賦值給指向BusinessBar類型的引用bb。

newProxyInstance(ClassLoader loader, Class>[] interfaces, InvocationHandler h)方法由程式設計師來指定參數動態傳回需要的代理類，而invoke(Object proxy, Method method, Object[] args) 方法則是由JVM在運行時動態調用的。當執行“bb.bar("Hello,World");”方法時，JVM動態指派“呼叫處理器”，向外層invoke傳遞參數，並呼叫method.invoke(obj,args)真正執行！

BusinessImplProxy.Factory靜態方法用來動態產生代理類別（「代理角色」），在運行時根據不同的業務邏輯介面BusinessFoo和BusinessBar，在運行時分別動態產生了代理角色。 「抽象角色」、「代理角色」以及呼叫處理器（實作InvocationHandler介面的類別）這三者都可以改變，所以說JAVA的動態代理十分強大。

🎜更多java代理模式與動態代理模式詳解相關文章請關注PHP中文網！ 🎜