概念
代理(Proxy)是一種設計模式,提供了對目標物件另外的訪問方式;即通過代理物件訪問目標物件。
使用圖表表示如下：

目的
在目標物件實現的基礎上,增強額外的功能操作,即擴充套件目標物件的功能。
使用場景
但需要對現有的程式碼增加新的功能時，如果直接在原有程式碼上修改，一方面要熟悉之前的程式碼，另外修改的程式碼還可能帶來新的問題。因此這時代理模式就可以很好的解決這個問題：不修改之前已經寫好的程式碼或者方法,通過代理的方式對該方法進行功能拓展。

兩種代理模式
1 靜態代理
關鍵點
使用者訪問的是目標物件的代理物件，目標物件與代理物件實現同一介面或繼承同一父類，且代理物件中持有目標物件。
舉例如下

public interface IBuy {
    void buy(long money);
}

買東西的使用者，實現這個買的介面：

public class User implements IBuy {
    @Override
    public void buy(long money) {
        System.out.println("買東西，一共花了"+ money+"元！"
 
);
    }
}

然後呢，樓下小商鋪代理，幫使用者從市場把東西買來了，那麼就要收點福利。。所以樓下小商鋪代理也具有買這個功能：

public class UserProxy implements IBuy {
    private IBuy mIBuy; // 真實代理的物件

    public UserProxy(IBuy IBuy) {
        mIBuy = IBuy;
    }

    @Override
    public void buy(long money) {
        long fee = (long) (money * 0.01); // 代理物件的一些附加福利
 

        System.out.println("靜態代理中介，坑了" + fee + "中介費！");

        mIBuy.buy(money + fee); // 真實物件執行
    }
}

然後是我們的測試程式碼：

    @Test
    public void buy() {
        IBuy user = new User();
        user.buy(10000);

        IBuy userProxy = new UserProxy(user);
        userProxy.buy(10000);
    }

執行，測試，輸出如下結果：

可以看到，第一行輸出是使用者直接購買物品說需要花費的錢，下面兩行是使用者使用了小商鋪這種代理，來購買東西，所需要付給小商鋪的福利，以及一共花費的金額。

這就是靜態代理模式的實現，從實現上看，代理物件的確沒有對目標物件的程式碼做修改，只是在目標物件功能的基礎上，添加了一些其他的附加功能；並且從代理物件中持有目標物件這一設計可以看出，代理物件可以完全控制目標物件的功能是否執行。但是，從中我們也可以看出靜態代理模式也存在下面這個缺點：

代理物件需要與目標物件實現一樣的介面,所以會有很多代理類,類太多.同時,一旦介面增加方法,目標物件與代理物件都要維護.

所以既然有靜態代理，那麼對應的應該也有個動態代理，不知道動態代理能不能解決這個缺點呢？

1 動態代理
關鍵點
1.代理物件,需要實現JDK中的介面：InvocationHandler，並實現方法invoke；
2.代理物件的生成,是利用JDK的API,程式執行時生成，動態的在記憶體中構建代理物件(需要我們指定建立代理物件/目標物件實現的介面的型別)
3.動態代理也叫做:JDK代理,介面代理
JDK api介紹
JDK中生成代理物件的API
代理類所在包:java.lang.reflect.Proxy
JDK實現代理只需要使用newProxyInstance方法,但是該方法需要接收三個引數,完整的寫法是:

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

ClassLoader loader：當前目標物件的類載入器
Class<>[] interfaces：目標物件實現的介面的型別,使用泛型方式確認型別
InvocationHandler h：實現了InvocationHandler介面的代理物件

程式碼實現
動態代理物件：

public class DProxy implements InvocationHandler {
    private IBuy mBuy; // 持有的目標物件

    public DProxy(IBuy buy) {
        mBuy = buy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("buy")) {
            long money = (long) args[0];
            long fee = (long) (money * 0.02);
            System.out.println("動態代理中介，坑了" + fee + "中介費！");
            long newMoney = money + fee;
            args[0] = newMoney;
            return method.invoke(mBuy, args);
        }
        return null;
    }
}

程式碼中，由於我們知道介面實現的名稱以及介面引數，所以在invoke中，我們直接對buy方法進行了額外的功能新增，如果不知道介面對應的名稱以及介面引數，那麼可以直接使用反射的方法執行method對應的invoke方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("附加功能1");
                        //執行目標物件方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("附加功能2");
                        return returnValue;
                    }

然後呢，是我們的測試程式碼：

    @Test
    public void buy() {
        IBuy user = new User();
        user.buy(10000);

        IBuy userProxy = new UserProxy(user);
        userProxy.buy(10000);

        IBuy dProxy = (IBuy) Proxy.newProxyInstance(user.getClass().getClassLoader(),user.getClass().getInterfaces(),new DProxy(user));
        dProxy.buy(10000);
    }

最終的執行結果：

總結：動態代理的invoke方法中，是利用反射的方法來執行介面中的method方法的，所以無論介面中的方法增加還是減少，都不影響動態代理的invoke方法執行，因而可以解決靜態代理中的問題。另外，動態代理的目標物件需要實現某一介面，這樣動態代理才可以代理該物件。