動態代理的使用以及其實現機制

　　一、動態代理的使用

　　動態代理可以提供對另一個對象的訪問，同時隱藏實際對象的具體事實。代理一般會實現它所表示的實際對象的接口。代理可以訪問實際對象，但是延遲實現實際對象的部分功能，實際對象實現系統的實際功能，代理對象對客戶隱藏了實際對象。客戶不知道它是與代理打交道還是與實際對象打交道。

　　動態代理主要包含以下角色：

　　動態代理類（以下簡稱為代理類）是一個實現在創建類時在運行時指定的接口列表的類，該類具有下面描述的行為。

　　代理接口 是代理類實現的一個接口。

　　代理實例 是代理類的一個實例。

　　每個代理實例都有一個關聯的調用處理程序 對象，它可以實現接口 InvocationHandler。通過其中一個代理接口的代理實例上的方法調用將被指派到實例的調用處理程序的 Invoke 方法，並傳遞代理實例、識別調用方法的 java.lang.reflect.Method 對象以及包含參數的 Object 類型的數組。調用處理程序以適當的方式處理編碼的方法調用，並且它返回的結果將作為代理實例上方法調用的結果返回。

　　

　　目前Java開發包中包含了對動態代理的支持，但是其實現只支持對接口的的實現。 其實現主要通過java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口。 Proxy類主要用來獲取動態代理對象，InvocationHandler接口用來約束調用者實現

　　下面看一個例子：

　　1.代理接口：IComputer.java

package com.proxy;

public interface IComputer {
    void execute();
}

　　2.被代理對象：Laptop.java

package com.proxy;

//筆記本電腦
public class Laptop implements IComputer {

    public void execute() {
        System.out.println("電腦正在執行中......");
    }

}

　　3.調用處理類：TimeHander.java

package com.proxy;

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

public class TimeHander implements InvocationHandler {
    private Object object;
    public TimeHander(Object object) {
        this.object = object;
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("start:"+start);
        method.invoke(object, args);
        Thread.sleep((int)(Math.random()*2000));
        long end = System.currentTimeMillis();
        System.out.println("end:"+end);
        System.out.println("total:"+(end-start));
        return null;
    }

}

　　4.測試程序：

package com.proxy;

import java.lang.reflect.Proxy;

public class ProxyTest {

    public static void main(String[] args) {
        Laptop laptop = new Laptop();
        TimeHander hander = new TimeHander(laptop);
        IComputer computer = (IComputer)Proxy.newProxyInstance(laptop.getClass().getClassLoader(), laptop.getClass().getInterfaces(), hander);
        computer.execute();
    }

}

程序運行結果：

start:1369118281186
電腦正在執行中......
end:1369118282849
total:1663

 

　　二、動態代理運行機制

　　Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法會返回一個代理對象類的實例。如上面例子中IComputer computer = (IComputer)Proxy.newProxyInstance(laptop.getClass().getClassLoader(), laptop.getClass().getInterfaces(), hander);執行這一句話的時候會通過反射機制動態的生成一個代理類，該類實現了IComputer接口，並且重寫了接口里面的方法（也就是說代理類與被代理類有相同的接口），在該代理類里面有一個InvocationHandler類型的成員變量，也就是調用處理程序，通過調用處理程序來給被代理類增強功能。創建好代理類后就調用類加載器將該類加載到類存，然后再通過反射創建一個該代理類的實例對象。

　　為了能夠更加的理解動態代理的運行機制，我自己來實現了一個動態代理：

　　1.代理接口：Moveable.java

package com.test;

public interface Moveable {
    void move();
}

　　2.被代理對象：Tank.java

package com.test;

import java.util.Random;

public class Tank implements Moveable {

    public void move() {
        System.out.println("Tank moving...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

　　3.下面寫一個Proxy類來為被代理對象產生一個代理類對象，來實現增加記錄運行時間的功能。

package com.test;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;

public class Proxy {
    public static Object newProxyInstance(Class interfaces,InvocationHandler h)throws Exception{
        StringBuffer methodStr = new StringBuffer();
        String tr = "\r\n";
        Method[] methods = interfaces.getMethods();
        //拼接代理類的方法
        for (Method method : methods) {
            methodStr.append(
            "    public "+ method.getReturnType()+ " " +method.getName()+"() {" + tr +
            "        try {" + tr +
            "            java.lang.reflect.Method md = " + interfaces.getName() + "." + "class.getMethod(\""  + method.getName() + "\");" + tr +
            "            h.invoke(this,md);" + tr +
            "        }catch(Exception e) {e.printStackTrace();}" + tr +
            "    }" + tr 
            );
        }
        
        //拼接代理類
        String src = "package com.test;" + tr +
        "import com.test.Moveable;" + tr +
        "public class TimeProxy implements " + interfaces.getName() + " {" + tr +
        "    private com.test.InvocationHandler h;" + tr +
        "    public TimeProxy(com.test.InvocationHandler h) {" + tr +
        "        this.h = h;" + tr +
        "    }" + tr +
        methodStr.toString() + tr +
        "}";
        //創建代理類
        String fileName = System.getProperty("user.dir") + "/src/com/test/TimeProxy.java";
        File file = new File(fileName);
        FileWriter writer = new FileWriter(file);
        writer.write(src);
        writer.flush();
        writer.close();
        //編譯
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileMgr.getJavaFileObjects(fileName);
        CompilationTask ct = compiler.getTask(null, fileMgr, null, null, null, units);
        ct.call();
        fileMgr.close();
        //加載類到內存：
        Class c = ClassLoader.getSystemClassLoader().loadClass("com.test.TimeProxy");
        Constructor constructor = c.getConstructor(InvocationHandler.class); //得到參數為InvocationHandler類型的構造方法
        Object m = constructor.newInstance(h); //通過該構造方法得到實例
        return m;
        
    }
}

　　4.TankProxy.java

package com.test;

import java.lang.reflect.Method;

public class TankProxy {
    public static <T> T getBean(final Object tank) throws Exception{
        return (T)Proxy.newProxyInstance(tank.getClass().getInterfaces()[0], new InvocationHandler(){
            public void invoke(Object proxy, Method method) {
                long start = System.currentTimeMillis();
                System.out.println("start:"+start);
                try {
                    method.invoke(tank, new Object[]{});
                } catch (Exception e) {
                    e.printStackTrace();
                }
                long end = System.currentTimeMillis();
                System.out.println("end:"+end);
                System.out.println("time:"+(end-start));
            }
            
        });
    }
}    

　　5.測試程序：

package com.test;

import java.util.List;

import com.extend.Tank2;
import com.extend.Tank3;
import com.juhe.LogProxy;
import com.juhe.TimeProxy;

public class Test {
    public static void main(String[] args) throws Exception {
        Tank tank = new Tank();
        Moveable m =  TankProxy.getBean(tank);
        m.move();
        
    }

}

執行該程序的結果為：
start:1369121253400
Tank moving...
end:1369121260078
time:6678

動態生成的代理類的內容如下：

package com.test;
import com.test.Moveable;
public class TimeProxy implements com.test.Moveable {
    private com.test.InvocationHandler h;
    public TimeProxy(com.test.InvocationHandler h) {
        this.h = h;
    }
    public void move() {
        try {
            java.lang.reflect.Method md = com.test.Moveable.class.getMethod("move");
            h.invoke(this,md);
        }catch(Exception e) {e.printStackTrace();}
    }

}

　　

　　看了這個例子，對動態代理的實現機制應該會有一定的了解了！

 　　小結：動態代理在運行期通過接口動態生成代理類，這為其帶來了一定的靈活性，但這個靈活性卻帶來了兩個問題，第一代理類必須實現一個接口，如果沒實現接口會拋出一個異常。第二性能影響，因為動態代理使用反射的機制實現的，首先反射肯定比直接調用要慢，其次使用反射大量生成類文件可能引起Full GC造成性能影響，因為字節碼文件加載后會存放在JVM運行時區的方法區（或者叫持久代）中，當方法區滿的時候，會引起Full GC，所以當你大量使用動態代理時，可以將持久代設置大一些，減少Full GC次數。