深入理解动态代理

代理模式是在不修改原有代码逻辑的情况下，对原有代码逻辑增强的一种方式，要了解什么是动态代理，首先要知道什么是静态代理。

一、静态代理

假设一种场景，一个汽车类（Car）有一个启动方法（run），我在不修改业务逻辑的情况下，我想知道启动汽车花了多长时间该如何实现呢？

公共的汽车接口

/**
 * 机动车接口
 *
 */
public interface Auto {
    void run() throws Exception;
}

小汽车实现类

/**
 * 机动车接口
 *
 */
public class Car implements Auto {
    public void run() throws Exception {
        //模拟方法执行过程
        Thread.sleep(new Random().nextInt(10));
        System.out.println("Car run");
    }
}

通过代理类实现对原有方法的增强，代理类实现相同的接口，并将被代理类指派给代理类的属性对象。

/**
 * 代理类
 */
public class AutoProxy implements Auto {
    Auto auto;

    public AutoProxy(Auto auto) {
        this.auto = auto;
    }

    @Override
    public void run() throws Exception {
        long start = System.currentTimeMillis();
        auto.run();
        long end = System.currentTimeMillis();
        System.out.println("启动时间：" + (end - start));
    }
}

运行代理类

public class Main {
    public static void main(String[] args) throws Exception {
        AutoProxy proxy = new AutoProxy(new Car());
        proxy.run();
    }
}

Car run
启动时间：1

静态代理的几个要素：
接口：Auto
被代理类：Car
代理类：AutoProxy，实现相同接口，对原实现类进行增强
静态代理的特点是在程序编译期就已经编译好了，即代理类在运行之前就已经存在了。假如随着业务的发展，不光有小汽车，还出现了公交车（Bus），警车（Police Car）等等，如果用静态代理，需要为每个被代理类实现一个代理类，那有没有更优雅的方式呢？答案就是动态代理。

二、动态代理

动态代理模式下，代理类实现InvocationHandler接口，被代理的业务无任何侵入，即可实现对一组接口实现类的增强。

代理类

/**
 * 动态代理
 */
public class DynamicAutoProxy implements InvocationHandler {
    Auto auto;

    public Object bind(Auto auto) {
        this.auto = auto;
        //生成代理对象
        //第一个参数为被代理类的类加载器
        //第二个参数为被代理类的接口
        //第三个参数为代理类实例，这里传入this
        return Proxy.newProxyInstance(auto.getClass().getClassLoader(), auto.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();
        //反射调用实际的方法
        Object object = method.invoke(auto, args);
        long end = System.currentTimeMillis();
        System.out.println("启动时间：" + (end - start));
        return object;
    }
}

动态代理类的几个要素：
1、被代理对象（Car、Bus）
2、执行者对象（DynamicAutoProxy）
3、代理对象，在执行者对象中通过Proxy.newProxyInstance生成的代理对象。

运行代理类

public class Main {
    public static void main(String[] args) throws Exception {
        DynamicAutoProxy proxy = new DynamicAutoProxy();
        Auto car = (Auto) proxy.bind(new Car());
        car.run();

        Auto bus = (Auto) proxy.bind(new Bus());
        bus.run();
    }
}

Car run
启动时间：1
Bus run
启动时间：5

代理对象Proxy是如何生成的呢，跟踪下源码可以看出，只是对创建动态代理类的过程进行了封装。

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        // 执行者对象判空
        Objects.requireNonNull(h);
        // 复制被代理类的接口
        final Class[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        // 通过类加载器生成指定代理类
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 实例化一个Proxy代理对象
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

动态代理本质上是在代码运行的过程中动态的创建了Proxy代理对象。

jdk动态代理的前提是被代理类实现了接口，如果没有实现接口又将如何代理呢，cglib动态代理就是为了解决这个问题。
springboot中通过@EnableAspectJAutoProxy与@Aspect注解实现动态代理，实际上@SpringBootApplication会自动开启@EnableAspectJAutoProxy，不需要手工指定。
可通过下面代码跟踪
@SpringBootApplication->@EnableAutoConfiguration->spring.factories->@AopAutoConfiguration->@EnableAspectJAutoProxy

public @interface EnableAspectJAutoProxy {

    // true: 使用cglib代理，false：使用jdk动态代理，默认为false
    boolean proxyTargetClass() default false;

    //是否通过aop框架暴露代理对象
    boolean exposeProxy() default false;

}