代理模式也叫委托模式，是結構型設計模式。代理就是讓別人幫你做事，比如幫你帶飯，請律師打官司什么的。

博客地址

定義

為其他對象提供一種代理以控制對這個對象的訪問。

使用場景

• 當一個對象不能或者不想直接訪問另一個對象時，可以通過一個代理對象來間接訪問。為保證客戶端使用的透明性，委托對象和代理對象要實現同樣的接口。
• 被訪問的對象不想暴露全部內容時，可以通過代理去掉不想被訪問的內容。

UML

• Subject: 抽象主題類，聲明真是主體與代理主題的共同接口方法。
• RealSubject: 真實主題類，定義了代理所表示的真是對象，執行具體的業務方法。客戶端通過代理類來間接的調動這個真實主題中的方法。
• ProxySubject: 代理類，持有一個真實類的引用，在接口方法中調用真實主題相應的方法，達到代理的作用。

簡單實現

就以打官司為例。我們一般人要打官司都要找個律師來代理。

靜態代理

先建立一個起訴類的接口：

public interface ILawsuit {
    void submit();//提交申請
    void burden();//進行舉證
    void defend();//開始辯護
    void finish();//訴訟完成
}

真正的起訴者：

public class Civilian implements ILawsuit {
    @Override
    public void submit() {
        System.out.println("起訴");
    }

    @Override
    public void burden() {
        System.out.println("舉證");
    }

    @Override
    public void defend() {
        System.out.println("辯護");
    }

    @Override
    public void finish() {
        System.out.println("勝訴");
    }
}

找的律師：

public class Lawyer implements ILawsuit {
    private ILawsuit civilian;

    public Lawyer(ILawsuit civilian) {
        this.civilian = civilian;
    }

    @Override
    public void submit() {
        civilian.submit();
    }

    @Override
    public void burden() {
        civilian.burden();
    }

    @Override
    public void defend() {
        civilian.defend();
    }

    @Override
    public void finish() {
        civilian.finish();
    }
}

客戶端調用，調用律師的方法，通過律師調用真正的su起訴者的方法。

public class Client {
    public static void main(String[] args) {
        ILawsuit civilian = new Civilian();
        ILawsuit lawyer = new Lawyer(civilian);
        lawyer.submit();
        lawyer.burden();
        lawyer.defend();
        lawyer.finish();
    }
}

輸出：

一個代理可以代理多個類，就像這個律師可以給很多人打官司，只需要在實現一個具體的ILawsuit就行了。代理會根據傳進來的被代理者調用傳進來的被代理者的方法。

動態代理

代理模式大致分為兩大部分：靜態代理和動態代理。

上面是是一種靜態代理，代理者的代碼時先生成寫好，然后再對其進行編譯，在代碼運行前，代理類的class編譯文件就已經存在了。

動態代理是相反的，通過反射動態的生成代理者對象，也就是說在寫代碼的時候根本不知道要代理誰，具體代理誰會在執行階段決定。

Java提供了一個便捷的動態代理接口InvocationHandler，動態代理類只要實現這個接口就行：

public class DynamicProxy implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}

看一下動態代理的用法：

public class DynamicProxy implements InvocationHandler {
    private Object object;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //當然這里可以對方法名進行判斷過濾 if(method.getName().equals("***"))
        Object result = method.invoke(object,args);
        return result;
    }
}

客戶端調用：

public class Main {
    public static void main(String[] args) {
        ILawsuit lawsuit = new Civilian();
        DynamicProxy proxy = new DynamicProxy(lawsuit);
        ClassLoader loader = lawsuit.getClass().getClassLoader();
        //動態創建代理類，需要傳入一個類加載器ClassLoader；一個你希望這個代理實現的接口列表，這里要代理ILawsuit接口；
        //和一個InvocationHandler的實現，也就是前面創建的proxy。
        ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance(loader,new Class[]{ILawsuit.class},proxy);
        lawyer.submit();
        lawyer.burden();
        lawyer.defend();
        lawyer.finish();
    }
}

輸出和上面一毛一樣：

動態代理并不局限與代理一個接口的實現，可以根據運行時傳入的接口，動態的生成代理類，然后通過Method的invoke方法來執行被代理類的真實方法。非常靈活。

其他分類

靜態代理和動態代理是從code方便進行分類的。這兩個分類根據適用范圍來分都可以分為下面幾種：

• 遠程代理：為摸個對象在不同的內存地址空間提供局部代理，是系統Server部分隱藏，以便Client不用考慮Server的存在。
• 虛擬代理：如果要創建一個資源消耗較大的對象，可以先用一個代理對象表示，在真正需要的時候才真正創建。
• 保護代理：用代理對象控制對一個對象的訪問，給不同的用戶提供不同的訪問權限。
• 智能引用：在引用原始對象的時候附加額外操作，并對指向原始對象的引用增加引用計數。

總結

代理模式使用非常廣泛，從分類就能感覺出來，而且其他的設計模式中也會有代理模式的影子。

優點

優點可以從他的適用范圍看出來

• 協調調用者和被調用者，降低系統耦合度。
• 用小對象代表大對象，減少系統資源消耗，提高系統運行速度，如虛擬代理。
• 控制用戶對唄調用者的使用權限，如保護代理。

缺點

• 首先當然是比直接調用原始對象多了一個中間者，會讓結構有點復雜。
• 調用原始對象的方法要通過代理來調用，可能會造成請求處理速度變慢。