动态代理实现原理

动态代理是一种方便运行时动态构建代理、动态处理方法调用的机制，很多场景都是利用类似的机制实现的，比如用于包装RPC的远程调用、面向切面编程(AOP)等

实现原理

实现动态代理的方式很多，比如JDK提供的动态代理，主要就是利用到了反射机制。还有一些第三方的框架，比如更高性能的字节码操作技术，具体实现有ASM、CGLIB(基于ASM)、Javassist等。这里通过JDK提供的动态代理代码，了解下其实现原理。主要涉及到Proxy、InvocationHandler两个类

Proxy

位于java.lang.reflect包下，显然跟反射有关。Proxy提供了一个静态方法用于动态创建代理对象，下面用于创建Foo接口的代理对象。

//调用目标方法前后处理实现
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);

//InvocationHandler接口
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
//MyInvocationHandler实现
public MyInvocationHandler implements InvocationHandler {
      private Object target;//目标对象，实现了Foo接口
      public MyInvocationHandler(Object target){
          this.target = target;
      }

      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
          //前处理
          Object result = method.invoke(target,args);
          //后处理
        return result;
    }
}

动态代理类实现了Foo接口，也可以创建多个接口的代理类，MyInvocationHandler是InvocationHandler 的实现，用于在调用目标对象的方法前后进行其他处理。
生成的代理类有以下特点：

• 如果所有接口是public的，则生成的代理类是public，final，且不是abstract的
• 由于代理类创建时实现了所有指定接口，因此在其Class对象上调用getInterfaces将返回一个包含接口列表的数组，调用getMethods将返回一个包含这些接口中所有方法的Method对象
• 每个代理类都有一个public的构造器，接受一个InvocationHandler的入参

Proxy.newProxyInstance方法
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException
{
//判空
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
//先从缓存中搜索
Class<?> cl = getProxyClass0(loader, intfs);
//获取构造器，Class<?>[] constructorParams = { InvocationHandler.class };
final Constructor<?> cons = cl.getConstructor(constructorParams);
//创建代理对象
return cons.newInstance(new Object[]{h});
}

应用场景

• 代理机制其实就是一种代理模式，对目标方法的调用通过代理对象完成。这样可以让调用者和实现者之间解耦，比如进行RPC调用，调用过程中的寻址、序列化、反序列化等一些基础公共工作，对于调用者是不必关心的，那么通过代理，就可以把这些底层工作给做了，上层只需关心业务本身就好了。
• 同样开发中，我们经常会遇到调用第三方接口的情况，一般我们要拼装请求参数，发送http请求，返回的处理(比如json转对象)，有的还要加签名，系统中一个还好，多个就头疼了，那么这时候就可以把这些公共的代码抽出来采用动态代理。openFegin这个框架就是基于该原理实现的。
• spring框架中典型的应用就是Spring AOP 和 事务管理了
• 通用日志处理，安全校验，接口耗时统计等

各种动态代理实现的比较

通过上面的例子，我们知道JDK动态代理必须提供接口，也就是它只能生成接口的代理实现对象，如果被调用者没有实现接口或者部分方法不是接口中的实现，那如何生成代理对象呢？这时就可以考虑其他方式了，我们知道Spring AOP支持两种代理模式，JDK代理和CGLIB，如果选择CGLIB是不需要被调用者实现接口的。
CGLIB代理机制是创建目标类的子类，这样子类就可以调用父类中的方法了，同样实现了代理机制。
那么在开发中如何选择呢？
JDK Proxy

• 无需引入额外jar包，JDK官方实现，更可靠稳定，保证平滑升级新版本
• 最小化依赖关系，减少依赖意味着简化开发和维护
• 代码实现简单

CGLIB

• 无需目标类实现接口即可生成代理对象，减少接口的限制
• 性能比JDK Proxy高，后续JDK升级优化可能会降低这种差距