java多線程與併發（七）——java的動態代理

轉自https://blog.csdn.net/u011784767/article/details/78281384

(1)什麼是代理？

大道理上講代理是一種軟件設計模式，目的地希望能做到代碼重用。具體上講，代理這種設計模式是通過不直接訪問被代理對象的方式，而訪問被代理對象的方法。這個就好比 商戶—->明星經紀人(代理)—->明星這種模式。我們可以不通過直接與明星對話的情況下，而通過明星經紀人(代理)與其產生間接對話。

(2)什麼情況下使用代理？

Spring的AOP，加事務，加權限，加日誌

(1)設計模式中有一個設計原則是開閉原則，是說對修改關閉對擴展開放，我們在工作中有時會接手很多前人的代碼，裏面代碼邏輯讓人摸不着頭腦(sometimes the code is really like shit)，這時就很難去下手修改代碼，那麼這時我們就可以通過代理對類進行增強。

(2)我們在使用RPC（遠程過程調用）框架的時候，框架本身並不能提前知道各個業務方要調用哪些接口的哪些方法 。那麼這個時候，就可用通過動態代理的方式來建立一箇中間人給客戶端使用，也方便框架進行搭建邏輯，某種程度上也是客戶端代碼和框架鬆耦合的一種表現。（RPC詳細介紹：https://blog.csdn.net/zhaowen25/article/details/45443951）

(3)Spring的AOP機制就是採用動態代理的機制來實現切面編程。

(3)靜態代理和動態代理

我們根據加載被代理類的時機不同，將代理分爲靜態代理和動態代理。如果在代碼編譯時就確定了被代理的類是哪一個，那麼就可以直接使用靜態代理；如果不能確定，那麼可以使用類的動態加載機制，在代碼運行期間加載被代理的類這就是動態代理，比如RPC框架和Spring AOP機制。

(4)靜態代理

我們先創建一個接口，遺憾的是java api代理機制求被代理類必須要實現某個接口，對於靜態代理方式代理類也要實現和被代理類相同的接口；對於動態代理代理類則不需要顯示的實現被代理類所實現的接口。
示例：

/**
 * 頂層接口
 */
public interface Person {
    public void sayHello(String content,int age);
    public void sayGoodBye(boolean seeAgin,double time);
}
/**
 * 需要被代理的類，實現了一個接口
 */
public class Student implements Person {
    @Override
    public void sayHello(String content,int age){
        System.out.println("student say hello"+content+" "+age);
    }
    @Override
    public void sayGoodBye(boolean seeAgin,double time){
        System.out.println("student say good bye"+time+" "+seeAgin);
    }
}
/**
 * 靜態代理，這個代理類也必須實現和被代理類相同的接口
 */
public class ProxyTest implements Person {
    private Person o;
    public ProxyTest(Person o){
        this.o=o;
    }
    public static void main(String[] args){
        //s爲被代理的對象，某些情況下，我們不希望修改已有的代碼，採用代理來間接訪問
        Student s=new Student();
        //創建代理類對象的方法
        ProxyTest proxy=new ProxyTest(s);
        proxy.sayHello("welcome to java",20);
        System.out.println("******");
        proxy.sayGoodBye(true,100);
    }
    @Override
    public void sayHello(String content,int age){
        System.out.println("ProxyTest say hello begin");
        //在代理類的方法中，間接訪問被代理對象的方法
        o.sayHello(content,age);
        System.out.println("ProxyTest say hello end");
    }
    @Override
    public void sayGoodBye(boolean seeAgin,double time){
        System.out.println("ProxyTest say good bye begin");
        //在代理類的方法中，間接訪問被代理對象的方法
        o.sayGoodBye(seeAgin,time);
        System.out.println("ProxyTest say good bye end");
    }
}

靜態代理看起來是比較簡單的，沒有什麼問題只不過是在代理類中引入了被代理類的對象而已。

(5)動態代理

我們先直接上動態代理的代碼，之後再分析代碼的行爲，上面的Person接口和Student被代理類保持不變。

import java.lang.reflect.*;

/**
 * 動態代理,動態代理類不要顯示的實現被代理類所實現的接口
 * @author yujie.wang
 *
 */
public class MyInvocationHandler implements InvocationHandler {

    private Object object;

    public MyInvocationHandler(Object object){
        this.object = object;
    }
//這裏涉及到java反射包下的一個接口InvocationHandler和一個類Proxy。
//這個接口只有一個invoke方法，我們在通過代理類調用被代理類的方法時，最終都會委託給這個invoke方法執行，
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("MyInvocationHandler invoke begin");
        System.out.println("proxy: "+ proxy.getClass().getName());
        System.out.println("method: "+ method.getName());
        for(Object o : args){
            System.out.println("arg: "+ o);
        }
        //通過反射調用 被代理類的方法
        method.invoke(object, args);
        System.out.println("MyInvocationHandler invoke end");
        return null;
    }

    public static void main(String [] args){
        //創建需要被代理的類
        Student s = new Student();
        //這一句是生成代理類的class文件，前提是你需要在工程根目錄下創建com/sun/proxy目錄，不然會報找不到路徑的io異常
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        //獲得加載被代理類的 類加載器
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        //指明被代理類實現的接口
        Class<?>[] interfaces = s.getClass().getInterfaces();
        // 創建被代理類的委託類,之後想要調用被代理類的方法時，都會委託給這個類的invoke(Object proxy, Method method, Object[] args)方法
        MyInvocationHandler h = new MyInvocationHandler(s);
        //生成代理類
        Person proxy = (Person)Proxy.newProxyInstance(loader, interfaces, h);
        //通過代理類調用 被代理類的方法
        proxy.sayHello("yujie.wang", 20);
        proxy.sayGoodBye(true, 100);
        System.out.println("end");
    }

}

所以我們就可以在這個invoke方法中對被代理類進行增強或做一些其他操作。
Proxy類的public static Object newProxyInstance(ClassLoader loader,Class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxyDemo.Person;
/**
代理類實現了被代理類的接口，並繼承了Proxy類
*/
public final class $Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
//實現了Person接口的方法，這就是我們調用這個方法Proxy.newProxyInstance必須提供第二個參數的作用 
    public final void sayGoodBye(boolean var1, double var2) throws  {
        try {
        // 我們看到通過調用代理類的方法時，最終方法都會委託給InvocationHandler實現類的invoke方法
    // m4爲代理類通過反射獲得的Method
            super.h.invoke(this, m4, new Object[]{var1, var2});
        } catch (RuntimeException | Error var5) {
            throw var5;
        } catch (Throwable var6) {
            throw new UndeclaredThrowableException(var6);
        }
    }

    public final void sayHello(String var1, int var2) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
        //代理類通過反射 獲得的接口方法Method
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("proxyDemo.Person").getMethod("sayGoodBye", Boolean.TYPE, Double.TYPE);
            m3 = Class.forName("proxyDemo.Person").getMethod("sayHello", Class.forName("java.lang.String"), Integer.TYPE);
            //代理類通過反射 獲得的接口方法Method
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

總結：
jdk的代理讓我們在不直接訪問某些對象的情況下，通過代理機制也可以訪問被代理對象的方法，這種技術可以應用在很多地方比如RPC框架，Spring AOP機制，但是我們看到jdk的代理機制必須要求被代理類實現某個方法，這樣在生成代理類的時候才能知道重新那些方法。這樣一個沒有實現任何接口的類就無法通過jdk的代理機制進行代理，當然解決方法是使用cglib的代理機制進行代理。