Java jdk动态代理实现及原理

1. 动态代理和 class 字节码的关系

1.1 动态代理有什么作用及应用场景

1、日志集中打印
2、事务
3、权限管理
4、AOP

1.2 在 Spring AOP 中有哪些方式及实现

1、Java Proxy：动态构建字节码（动态构建全新字节码， bean 初始化的时候）
2、cglib：动态构建字节码（动态构建全新字节码， bean 初始化的时候）
3、AspectJ ：修改目标类的字节，织入代理的字节在程序编译的时候插入动态代理事务字节码，不会生成全新的 Class
4、instrumentation ：修改目标类的字节码，类装载的时候动态拦截去修改

从上可以看出：
无论哪种方式实现动态代理，其本质都是对字节码的修改，其区别是从哪里进行切入修改字节码

所以如果能对 class 文件的修改，也就相当于对源程序进行修改了。后面两种c,d就是通过对字节码进行修改，把你要增强的逻辑编译成字节码，然后插入到源程序编译好的字节码里面的对应位置，就实现了增强

2. 什么是动态代理

定义网上有很多，省略…

动态代理中涉及的几个对象之间的关系，如下图所示
调用接口的调用方就是客户，接口的实现类就是委托类，再对委托类进行包装增强就是代理类，客户直接调用代理类就可以了

动态代理好处在于，通过代理类这中间一层，能有效控制对委托类对象的直接访问，可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性

2.1 动态代理的执行过程

客户类去调用 Proxy 类，Proxy 类调用实现了 InvocationHandler 的类，InvocationHandler 类再通过反射去调用目标业务方法。 实现了InvocationHandler 类的作用就是织入代理的前置逻辑和后置逻辑

2.2 案例演示

接口：
一个食物加工厂

public interface FoodFactory {
    public void createFood();
}

接口的实现类，即委托类：
苹果加工厂

//委托类
public class AppleFactory implements FoodFactory {

    public void createFood() {
        System.out.println("生产苹果....");
    }
}

对委托类进行包装，即代理类：
下面代码中 getProxy 就是我们获取代理类的方法

/**
 * 这个类主要是帮助我们生成一个代理对象
 * 1、Proxy 类，创建出代理对象
 * 2、InvocationHandler 接口：提供服务的接口
 */
public class MyProxyClass implements InvocationHandler {

    //传入目标对象，根据目标对象生成代理类
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 获取代理对象
    public Object getProxy(){
        // 参数含义：类加载器，委托类实现的全部接口，一个实现了InvocationHandler的类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    //提供服务的方法,可以对委托类里面的方法进行增强
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始生产了.....");
        //反射代码，执行目标代码的方法
        Object result= method.invoke(target);

        System.out.println("生产结束了.....");
        return result;
    }
}

Tip：Proxy.newProxyInstance 三个参数里面会传一个委托类实现的全部接口，目的在于让最终的代理类也能实现这些接口，为什么代理类和委托类要实现相同的接口？为了让访问者看来两者没有丝毫的区别。

调用接口的类就是客户：

// 客户类
public class CustomClass {
    public static void main(String[] args) {
        //创建一个目标对象
        FoodFactory appleFactory=new AppleFactory();

        MyProxyClass myProxyClass=new MyProxyClass();
        //设置委托类
        myProxyClass.setTarget(appleFactory);
        //得到一个代理类，这个类就是程序帮我们生成的类
        FoodFactory proxy= (FoodFactory) myProxyClass.getProxy();

        //调用代理对象的方法
        proxy.createFood();
    }
}

代理对象是程序帮我们生成的，那么它是怎么生成的呢？

3. 从源码解析代理对象生成过程

一般对象的生命周期：

代理对象的生命周期和一般对象不一样的就在于，他没有 Java源文件，而且这个 Java 字节码文件是在内存中生成的，且本质是一个字节数组，通过类加载器加载之后变成 Class 对象，再根据这个 Class 对象，利用反射最终创建出来 代理对象

源码实现过程和上面说的差不多，我截代码省略了不重要的部分：

 @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
    ...省略一部分代码
    /**
    * 查找或生成指定的代理的类，这句话做了两件事情：
    * 1、生成 Java 字节码文件
    * 2、把字节码文件加载进内存中，生成 Class 对象
    */
        Class<?> cl = getProxyClass0(loader, intfs);
....省略
	// 拿到构造器对象
		final Constructor<?> cons = cl.getConstructor(constructorParams);
... 省略
	//通过反射初始化一个实例对象
	 return cons.newInstance(new Object[]{h});
...省略
    }

    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
 ...省略
 // 从缓存中获取字节码对象，如果没有就创建一个新的字节码对象
        return proxyClassCache.get(loader, interfaces);
    }

    public V get(K key, P parameter) {
    // 这行代码就在帮你生成字节码文件和 Class 对象
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    }

    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

        //这个 byte 数组就是我们的字节码文件
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
        try {
            // 根据字节码文件生成 Class 对象,应该就是加载字节码，然后创建对象一系列的
            return defineClass0(loader, proxyName,
                    proxyClassFile, 0, proxyClassFile.length);
            ...省略
    }

最终会调用类 generateProxy 的 generateProxyClass 方法帮我们生成一个字节数组，然后利用类加载器把这个字节对象进行加载，就可以生成一个 Class 对象，有了 Class 对象就可以通过反射创建一个实例对象，即我们的代理对象

这个 ProxyGeneration 类是 sun.misc包下的一个类，这个类里面的这些数字，其实就是 JVM 字节码的表现形式，所谓的拼接一个程序（拼接一个代理类），就是把这些数字拼装起来，最后再把他序列化成一个文件。这个类就相当于一个简单版的 JVM 编译器

这个对象里面有个方法叫做：generateProxyClass 。这个方法就是直接帮我们生成代理类 字节 的方法（序列化好的字节），他的返回值byte[]就是序列化好了的字节对象

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if (var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                            Files.createDirectories(var3);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class");
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }

        return var4;
    }

补充：

什么时候去调用的 实现 InvocationHandler 那个类的 invoke 方法的以及怎么调用的？

程序帮我们生成的代理类是隐藏的，但是我们可以通过上面提到的 ProxyGeneration 类来自己生成代理类，就可以查看了，代码如下

    public static void main(String[] args) throws IOException {
        //参数含义：即将生成的代理类的名字(自己随便定义)，委托类实现的接口，
        byte[] bytes= ProxyGenerator.generateProxyClass("FoodFactory$Proxy",new Class[]{AppleFactory.class});
        //生成的文件所存放的位置，然后你可以在这个位置找到这个文件
        Files.write(new File("D:\\Code\\Java\\Idea\\Test\\target\\classes\\com\\xp\\FodFactory$Proxy.class").toPath(),bytes);
    }

这是生成的代理类中的 invoke 方法，他去调用了super.h.invoke(this, m3, (Object[])null);，super 什么意思，他的父类

再看所生成的代理的继承关系，他继承了 Proxy，我传的 AppleFactor是一个类，这里他应该是指的 AppleFactory 所实现的接口。

点击 h.invoke 这个方法，你会发现他指向的是 InvocationHandler 那个接口。接口里面又没有方法实现，所以他真正指向的是我们自己实现 InvocationHandler 接口的那个类里面的 invoke 方法。

所以这个代理类被执行的时候，就是我们自己定义的 invoke 方法被执行的时候。

代理类什么时候被执行就是我们自己调用的问题了，比如我写的案例，我自己去调用了生成的代理类的 createFood() 方法，就执行了代理类啊