Java 动态代理机制 （一） JDK Proxy详解

JDK Proxy 代理是可以根据我们的 接口 Interface 生成类的字节码，从而可以在 Java 中为所欲为的一种技术，包括对象增强（修改成员变量），函数增强（在函数前后执行别的代码），根据接口名执行不同逻辑 等。在 Mybatis 中有典型应用。它的本质是 由 Proxy 生成一个 代理对象，实现我们的接口。这个对象中有我们的回调函数。当调用 代理对象的接口方法时，这个对象再调用我们的回调函数，我们的回调函数再调用原对象的对应方法。从而实现代理。为了实现代理模式，Proxy 用了另外一种设计模式：命令模式。

不过，如果我们没有接口，直接是个类，那么 Proxy 将不能用，我们可能需要用 CGLIB 等 ASM 框架进行对类的字节码进行修改。

用法简介 定义一个接口和一个实现的对象

// 规定一个接口 public interface IHello {

void sayHello();

}

// 新建一个对象 IHello hello = new Hello(){

    @Override
    public void sayHello() {
        System.out.println("Hello!");
    }

}; 不增强时，我们平时调用的话是这样：

hello.sayHello()

// 输出： // Hello! 使用反射调用，可以达到同样的效果：

// 从类的字节码获取到方法 Method method = hello.getClass().getMethod("sayHello"); // 指定一个对象执行 method.invoke(hello); 我们使用 JDK 的 Proxy 对对象进行增强：

// 对这个对象进行增强，三个参数 IHello iHello = (IHello) Proxy.newProxyInstance(

            IHello.class.getClassLoader(), // 类加载器
            new Class[]{IHello.class}, // 所有接口
            new InvocationHandler() {  // 回调函数 handler 打包成对象，可以用 lambda
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("前置通知");
                    Object rs = method.invoke(hello, args); // 这里指定由我们的 hello 对象执行
                    System.out.println("后置通知");
                    return rs;
                }
            });

// 调用 iHello.sayHello();

// 输出： // 前置通知 // Hello! // 后置通知 我们看到，我们给 Proxy.newProxyInstance 传入了一个类加载器、一个接口的数组、一个 Handler。返回的是一个 动态生成的 Proxy 对象，实现了 IHello 接口

我们在调用 这个 Proxy 对象的 sayHello() 的时候，实际上调用的是我们 handler 的 invoke 方法，然后将我们的 method（类比上面的 hello.getClass().getMethod(“sayHello”)） 传入，然后我们在 invoke 方法里面已经指定了由原来的对象执行这个方法，method.invoke(hello, args)，所以整个代理就完成了。

用法解析 方法增强/对象增强 Proxy 本质上是根据我们的接口生成了一个 Proxy 对象，然后这个对象再调用我们指定的逻辑来实现动态代理的。而在我们的逻辑中，要用 反射的方法 回调真正对象的方法来实现对象增强。在反射调用的前后，我们还执行别的一些额外的逻辑。 为什么要这么增强呢？这其实是一种 AOP 的编程方法。 在 SpringMVC 的一些逻辑操作中，我们可以用到它，比如每个方法统一鉴权，日志处理等等，我们可以在一个地方写一次代码，就可以应用到全部方法中。当然 Proxy 还不灵活，默认会对接口的所有方法都执行同一个逻辑，所以我们还有 AspectJ 等包来灵活管理。

根据接口名执行不同方法 当然，我们也可以不做对象增强，而是直接读取我们的接口中的方法名，做一些别的逻辑，比如 在 Mybatis 中，我们只要定义接口，然后经过工厂返回一个 Proxy 对象，我们就可以调用到真正的逻辑代码，读取 map 和 数据库。

原理解析 眼见为实，我们来把经过代理后的对象的类文件导出来，再确认下我们的结论：

try(FileOutputStream fos = new FileOutputStream(path)) {

fos.write(classFile);
fos.flush();
System.out.println("代理类class文件写入成功");

} catch (Exception e) {

System.out.println("写文件错误");

} 为了简洁起见，这里删掉了对 Object 代理 的 一些方法

public final class $Proxy0 extends Proxy implements IHello { // 实现原接口，是代理模式的核心

private static Method m3;

static {
    try {
        m3 = Class.forName("test.ProxyTest$IHello").getMethod("sayHello"); // 调用了 getMethod 方法
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
}

public $Proxy0(InvocationHandler var1) throws  {
    super(var1); // 把我们的 Handler 传进来了
}

// super(var1) 方法的代码，非本文件
protected Proxy(InvocationHandler h) {
    Objects.requireNonNull(h);
    this.h = h;
}

public final void sayHello() throws  {
    try {
        // 这里回调我们传入的 handler 类
        super.h.invoke(this, m3, (Object[])null); // 因为我们的接口没有参数，所以这里传null
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}
// super.h.invoke 方法就是我们自己定义的 Handler 的 invoke 方法
// 如果有其他方法，就直接由生成器复制即可

} 这其实是命令模式的设计模式，我们先传入一个回调函数，Proxy 被调用时，调用我们的的回调函数（对象）