初探java动态代理

动态代理是什么

在Java API手册中原话是这样介绍动态代理的：

Using Java Reflection to create dynamic implementations of interfaces at runtime.

按我的理解，动态代理就是利用Java的反射机制，在运行时创建一个实现某些给定接口的新类（也称“动态代理类”）及其实例（对象）。
换句话说，代理的是接口(Interfaces)，不是类(Class)，更不是抽象类。
这正是面向接口编程的关键所在。

动态代理应用

• AOP中的面向切面编程
• 适配器(Adapter)或修饰器(Decorator)设计模式

动态代理的创建

在Java API手册Proxy类告诉我们，创建动态代理有两种方式

 InvocationHandler handler = new MyInvocationHandler(...);
//方式一
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(),Foo.class);
Foo f =(Foo)proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
//方式二 本文探究的方式
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

Proxy.newProxyInstance()方法有三个参数：

1. 类加载器

2. 需要实现的接口数组

3. InvocationHandler接口实现类。

代理生成时，会通过类加载器(Class Loader)获取被代理接口的相关资源，定义了由哪个ClassLoader对象来对生成的代理对象。代理会实现接口数组（interfaces）里的所有接口，这样我们就可以调用这组接口中的方法，或者将代理转换成其中一个接口。最后，进行加载所有动态代理类的方法调用，都会交由InvocationHandler接口实现类里的重写（override）后的invoke()方法去处理。这是动态代理的关键所在。

接下来我们来探究，实现动态代理时究竟代理了什么。

事前准备

车辆接口：

public interface IVehicle {
    void run(String s);
}

单车类：

public class Bicycle implements IVehicle {
    @Override
    public void run(String s) {
        System.out.println( s + "Bicycle is running");
    }
}

代理类：

public class VehicleProxy {

    private IVehicle vehicle;  //被代理接口

    public VehicleProxy(IVehicle vehicle) {
        this.vehicle = vehicle;
    }

    public IVehicle create(){  //创建代理方法
        final Class[] interfaces = new Class[]{IVehicle.class};
        final VehicleInvocationHandler handler = new VehicleInvocationHandler(vehicle);

        return (IVehicle) Proxy.newProxyInstance(IVehicle.class.getClassLoader(), interfaces, handler);
    }
}

InvocationHandler实现类：

public class VehicleInvocationHandler implements InvocationHandler {

    private final IVehicle vehicle;

    public VehicleInvocationHandler(IVehicle vehicle) {
        this.vehicle = vehicle;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("--before running...");
        Object ret = method.invoke(vehicle, args);
        System.out.println("--after running...");

        return ret;
    }
}

测试方法

public class ProxyTest {
    public static void main(String[] args){
        IVehicle bicycle = new Bicycle();
        VehicleProxy proxy = new VehicleProxy(bicycle);
        IVehicle proxyObj = proxy.create();
        proxyObj.run("BMW");  //宝马确实生成过单车
    }
}

结果：

--before running...
BMW Bicycle is running
--after running...

可以看到，对IVehical接口的调用，会交由Proxy的invoke方法处理，并在不改变run()的源代码下，新增了动态的逻辑（before running/after running)。AOP正是利用这个原理做的。

我们再通过debug看看代理调用方法过程中，代理对象是如何生成的，数据是如何传递的。

image.png

image.png

可以看出，通过create方法中调用Proxy.newProxyInstance，proxyObj接口获得了一个代理类。观察图2的proxy值我们发现，这代理类的名字有点特别，是以$开头的。这是动态代理的命名体现，证明这个类是继承Proxy类的代理类，而它现在充当着IVehicle的角色。

image.png

image.png

调用再进入到proxyObj.run("BMW");方法时，会触发InvocationHandler实现类中的invoke方法。从debug逐个分析invoke方法获得的三个参数：

1. proxy：与proxyObj名字相同，即代理类的实例引用，它里面存放着被代理对象vehicle
2. method: 实际被代理类的方法，在例子里是run()方法
3. args: 实际是代理proxyObj.run("BMW");的参数，可以用于传给被代理方法调用