动态代理

一、静态代理

先看代码：

public interface Movable {    void move();}

class Tank implements Movable {    @Override    public  void move() {        System.out.println("Tank is Moving.....");        try {            //模拟坦克的移动过程            Thread.sleep(new Random().nextInt(1000));        }catch (Exception e){            e.printStackTrace();        }    }}

Tank类实现了Movable接口，现在我们需要记录Tank运动的开始时间和结束时间

public class TankTimeProxy implements Movable {    Movable t;    //此处传入Tank参数    public TankTimeProxy(Movable t)    {        super();        this.t = t;    }    public void move() {        System.out.println(System.currentTimeMillis());        t.move();        System.out.println(System.currentTimeMillis());    }}

测试类

public class Client {    public static void main(String[] args) {        Movable t = new Tank();        Movable ttp = new TankTimeProxy(t);        ttp.move();        }}

这里我们使用组合的方式把Tank的实现作为参数传递给了TankTimeProxy

那么问题就来了，如果我们想要对坦克的运动加上日志是否需要重新实现代理类？

    如果我们需要给任任意类的方法加上日志和时间，那么我们需要些许多的代理类

很明显，这样的写法不具有扩展性，我们希望这个代理对象能够实现对任意对象的代理。

二、动态代理的原理

根据要求，动态代理需要实现的功能是，给被代理对象的的每个方法加上代理逻辑。因此，我们需要考虑以下问题：

1、如何得到被代理类的所有接口（也就是方法）

2、如何动态的生成新的代理类

第一个问题可以通过反射获得

对于第二个问题，一个很直观的想法是，在Proxy.newInstance()中，我们首先加上代理的逻辑（日志、事物、时间等），然后利用反射执行被代理对象的方法。生成新的代理类的JAVA文件，然后把上述代码进行编译，这个过程可参考JavaComplier的使用

这样即可得到代理对象的class文件，具体可以参照马士兵老师设计模式的课程。

三、Java对动态代理的支持

主要有两个类：Proxy和InvocationHandler(接口)

Proxy的主要作用是利用newProxyInstance()产生新的代理类

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

我们来看看这三个参数所代表的含义：

loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载，一般采用被代理对象的classLoader

interfaces:　　一个Interface型的数组，表示的是我将要给代理对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就可以实现该接口，并重写其中的每个方法

h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

每一个动态代理类都必须要实现InvocationHandler接口，通过newProxyInstance知道，每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转化为由InvocationHandler这个接口的 invoke 方法来进行调用。

public Object invoke(Object proxy, Method method, Object[] args)        throws Throwable;

proxy:　　指代我们所代理的那个真实对象，一般作为参数传入InvocationHandler这个接口中的实现类中（组合）
method:　指代的是我们所要调用真实对象的某个方法的Method对象
args:　　  指代的是调用真实对象某个方法时接受的参数

一个具体的例子：

public class TimeHander implements InvocationHandler{    Object target;    public TimeHander(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        beforeMethod();        method.invoke(target);        afterMethod();        return null;    }    public void beforeMethod(){        System.out.println("Start.....");    }    public void afterMethod(){        System.out.println("end....");    }}

public class client {    @Test    public void testProxy() {        Movable t = new Tank();        InvocationHandler h = new TimeHander(t);        //和被代理对象使用相同的classLoader        //代理后的Proxy无法看到生产的源码        Movable m = (Movable)Proxy.newProxyInstance(t.getClass().getClassLoader(),t.getClass().getInterfaces(),h);        m.move();        m.stop();    }}

三、动态代理的应用

在面向对象的设计思想中，使用动态代理可以很方便的增强一个类的行为，相比于继承和静态代理，使用动态代理无疑是更好的选择。

在web开发中，我们经常使用的拦截器以及基于AOP的对日志、权限的管理都是通过动态代理实现的。