动态代理：面向接口编程，屏蔽RPC处理过程

RPC远程调用

使用 RPC 时，一般的做法是先找服务提供方要接口，通过 Maven把接口依赖到项目中。在编写业务逻辑的时候，如果要调用提供方的接口，只需要通过依赖注入的方式把接口注入到项目中，然后在代码里面直接调用接口的方法。

接口里并不会包含真实的业务逻辑，业务逻辑都在服务提供方。

核心技术：动态代理。

RPC 会自动给接口生成一个代理类，项目中注入接口的时候，运行过程中实际绑定的是这个接口生成的代理类。在接口方法被调用的时候，实际上是被生成代理类拦截到，这样就可以在生成的代理类里面，加入远程调用逻辑。

流程如下：

实现原理

jdk动态代理：

java 复制代码

/**
 * 要代理的接口
 */
public interface Hello {
    String say();
}

/**
 * 真实调用对象
 */
public class RealHello {

    public String haha(){
        return "i'm proxy";
    }
}

代理类实现InvocationHandler接口

java 复制代码

/**
 * JDK代理类生成
 */
public class JDKProxy implements InvocationHandler {
    private Object target;

    JDKProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] paramValues) {
        return ((RealHello)target).haha();
    }
}

public class TestProxy {

    public static void main(String[] args){
        // 构建代理器
        JDKProxy proxy = new JDKProxy(new RealHello());
        ClassLoader classLoader = Hello.class.getClassLoader();
        // 把生成的代理类保存到文件
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        // 生成代理类
        Hello test = (Hello) Proxy.newProxyInstance(classLoader, new Class[]{Hello.class}, proxy);
        // 方法调用
        System.out.println(test.say());
    }
}

解释：给 Hello 接口生成一个动态代理类，并调用接口 say() 方法，但真实返回的值是来自 RealHello 里面的 haha() 方法返回值。

重点是代理类的生成 ，Proxy.newProxyInstance。

参数 saveGeneratedFiles 来控制是否把生成的字节码保存到本地磁盘。

key为"sun.misc.ProxyGenerator.saveGeneratedFiles"的Property来控制的，动态生成的类会保存在工程根目录下的 com/sun/proxy 目录里面。

生成的代理类。

java 复制代码

package com.sun.proxy;

import com.lkl.proxy.Hello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Hello {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String say() throws  {
        try {
            // 代理类执行
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.lkl.proxy.Hello").getMethod("say");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

$Proxy0 类里面有一个跟 Hello 一样签名的 say() 方法，其中 this.h 绑定的是刚才传入的 JDKProxy 对象，所以当调用 Hello.say() 的时候，实际被转发到了JDKProxy.invoke()。

单纯从代理功能上来看，JDK 默认的代理功能是有一定的局限性的，要求被代理的只能是接口 。原因是生成的代理类会继承 Proxy 类，但Java不支持多重继承。

JDK默认的代理功能，最大的问题就是性能问题。生成后的代理类是使用反射来完成方法调用，而这种方式相对直接用编码调用来说，性能会降低，但JDK8及以上版本对反射调用的性能有很大的提升。

除了JDK 默认的nvocationHandler能完成代理功能，还有很多其他的第三方框架也可以实现，比如Javassist 、Byte Buddy 这样的框架。

Javassist 定位是能够操纵底层字节码，要生成动态代理类比较复杂。但是，通过Javassist生成字节码，不需要通过反射完成方法调用，所以性能会高一些。问题：通过Javassist生成一个代理类后，此 CtClass 对象会被冻结起来，不允许再修改；否则，再次生成时会报错。

Byte Buddy提供了更容易操作的API，编写的代码可读性更高。并且生成的代理类执行速度比Javassist更快。

动态代理框架选型

三个角度考虑：

代理类是在运行中生成的，那么代理框架生成代理类的速度 、生成代理类的字节码大小等等，都会影响到其性能------生成的字节码越小，运行所占资源就越小。
生成的代理类，是用于接口方法请求拦截的，所以每次调用接口方法的时候，都会执行生成的代理类，生成的代理类的执行效率就需要很高效。
从使用角度出发的，选择使用起来很方便、好上手的代理类框架。