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 被调用时，调用我们的的回调函数（对象）

参考资料

https://www.cnblogs.com/gonjan-blog/p/6685611.html