万字干货|JDK动态代理及其源码解析 拿捏了

发表于 更新于 分类于 阅读次数：

作者：小牛呼噜噜 | https://xiaoniuhululu.com
计算机内功、JAVA底层、面试相关资料等更多精彩文章在公众号「小牛呼噜噜 」

在之前的一篇文章-Java注解中，我们详细讲解了Java注解及其原理，其中反射调用注解的时候（class.getAnnotation），会继承动态代理类AnotationInvocationHandler，创建注解的代理实例，来让开发者后续操作注解。本篇文章将深入聊聊什么是动态代理

代理模式

首先我们要明白动态代理属于设计模式中的代理模式
所谓代理模式是指 通过访问目标对象的代理对象，再由代理对象去访问目标对象

通俗点讲，本来我们只可直接去商店买药 ;突然有一天，我们的车坏了，导致我们无法直接去商店买药。这个时候，又急着需要药，我们可以打电话叫代理人:小张去商店帮我们买药，然后再让他把药给我们带回来。这样最终我们拿到了药。

这样一来就可以在不修改原目标对象的前提下，提供额外的功能操作，实现扩展目标对象的功能。

静态代理

代理模式有静态代理和动态代理两种实现方式

静态代理和动态代理的区别？什么是静态、动态？

从 JVM 层面来说:

  1. 静态代理：
  • 在编译时就已经实现，编译完成后代理类是一个实际的class文件
  • 代理类和委托类的关系在程序运行前就已确定
  1. 动态代理：
  • 在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中
  • 代理类和委托类的关系是在程序运行时确定

静态代理的使用步骤

我们先聊聊静态代理, 其一般使用步骤：

  1. 定义一个接口及其实现类；
  2. 创建一个代理类同样实现这个接口
  3. 将目标对象注入进代理类，然后就可以在代理类的对应方法调用目标类中的对应方法

示例

我们来模拟一下上文买药的例子，另外我们想代理人顺便帮我们在买点水果啥的

定义一个接口，来代表我们的目标

1
2
3
public interface OurService {
    void buyMed();
}

再实现我们的接口

1
2
3
4
5
6
public class OurServiceImpl implements OurService {
    @Override
    public void buyMed() {
        System.out.println("买药。。。");
    }
}

创建代理类并额外附表其他目标，比如买蛋糕、水果啊之类的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyStaticProxy implements OurService {
    private OurService ourService;

    public MyStaticProxy(OurService ourService) {
        this.ourService = ourService;
    }
    @Override
    public void buyMed() {

        System.out.println("买药前，先去买蛋糕。。。");
        ourService.buyMed();
        System.out.println("买药后，再去买水果。。。");
    }
}

最后测试类

1
2
3
4
5
6
7
8
public class TestStaticProxy {
    public static void main(String[] args) {
        OurService ourService = new OurServiceImpl();
        //userService.buyMed(); 直接执行
        MyStaticProxy myStaticProxy = new MyStaticProxy(ourService);
        myStaticProxy.buyMed();//委托 代理类 去执行
    }
}

结果：

买药前，先去买蛋糕。。。

买药。。。

买药后，再去买水果。。。

静态代理的缺陷

从上面的例子，我们可以发现静态代理非常容易地实现了对一个类的代理操作，但是也有几个缺点：

  1. 静态代理不能使一个代理类反复作用于多个目标对象，代理对象直接持有目标对象的引用，这导致代理对象和目标对象类型紧密耦合了在一起，需要对每个目标类都单独写一个代理类。
  2. 不易维护，一旦接口更改，代理类和目标类都需要更改，比较繁琐。

解决静态代理的缺陷的思路

通过上文我们可以发现静态代理最大的缺点，就是不能使一个代理类反复作用于多个目标对象，要想实现不同的增强功能，必须编写不同的代理类，耦合性高。那我们能不能对于不同的源程序，让JVM自动生成对应的代理类？如果可以的话，这样不就可以解决问题了嘛。

首先我们得思考一个问题，java怎样才能动态地生成代理类？
我们先来回顾一下对象的创建过程

推荐阅读：https://mp.weixin.qq.com/s/tsbDfyYLqr3ctzwHirQ8UQ

创建一个实例对象的底层逻辑，其实与.class文件和Class对象息息相关
“没有对象， 那就new一个”,对于每个javar来说都太熟悉了，但这样往往忽视了底层的细节–最核心就是得到对应的Class对象

在文章https://mp.weixin.qq.com/s/v91bqRiKDWWgeNl1DIdaDQ中，我们聊到了JVM类的加载过程

加载阶段：指的是将类对应的.class文件中的二进制字节流读入到内存中，将这个字节流转化为方法区的运行时数据结构，然后在堆区创建一个java.lang.Class 对象，作为对方法区中这些数据的访问入口

其中将类对应的.class文件中的二进制字节流读入到内存中，JVM虚拟机规范并没有
指明二进制字节流必须得从某个Class文件中获取，确切地说是根本没有指明要从哪里获取、如何获取。
所以获取类的二进制字节流(class字节码)有很多途径：

  • 从ZIP包获取，这是JAR、EAR、WAR等格式的基础
  • 从网络中获取，典型的应用是 Applet
  • 运行时计算生成，这种场景使用最多的是动态代理技术，在 java.lang.reflect.Proxy 类中，就是用了 ProxyGenerator.generateProxyClass 来为特定接口生成形式为 *$Proxy 的代理类的二进制字节流
  • 由其他文件生成，典型场景是JSP应用，由JSP文件生成对应的Class文件。
  • 从数据库中读取，这种场景相对少见些，例如有些中间件服务器（如SAP Netweaver）可以选择 把程序安装到数据库中来完成程序代码在集群间的分发。
  • 可以从加密文件中获取，这是典型的防Class文件被反编译的保护措施，通过加载时解密Class文 件来保障程序运行逻辑不被窥探。

在笔者之前讲解Java反射的文章https://mp.weixin.qq.com/s/_n8HTIjkw7Emcunpb4-Iwg中，我们知晓：

  1. 类也是可以用来存储数据的，Class类就像 普通类的模板 一样，用来保存“类所有相关信息”的类，得到了Class对象也就可以得到了代理类
  2. 还讲解了获取Class实例4种方式，前提都需要先有代理类，但我们现在需要反过来先获取代理类的字节码，从而动态生成代理类

所以要想解决静态代理的缺陷，我们就得 想办法先得到代理类的字节码，从而动态生成代理类！

这时候动态代理就应运而生了，动态代理无需声明式的创建java代理类，而是在运行过程中动态生成"代理类"，即编译完成后 **没有实际的class文件** 而是在运行时动态生成**类字节码**，并加载到JVM中。从而避免了静态代理那样需要声明大量的代理类。

为了让生成的代理类与目标对象保持一致性，我们将介绍两种最常见的途径：

  • 通过目标类实现的接口 -> JDK动态代理
  • 通过目标类本身 -> CGLIB动态代理

JDK动态代理

JDK 动态代理类使用步骤

  1. 定义一个接口及其实现类；
  2. 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
  3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

示例

我们继续沿用本文上面的例子OurService，我们来为其再编写一个自定义的JDK动态代理类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MyInvocationHandler implements InvocationHandler {
    //需要代理的目标对象
    private Object target;


    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加额外逻辑
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们也可以添加额外逻辑
        System.out.println("after method " + method.getName());
        return result;
    }
}

接着编写测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class TestDynamicProxy {
    public static void main(String[] args) {
        //查看代理类源码,会在项目根目录生成一个目录:com/sum/proxy/$Proxy0.java
        //System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        //创建一个实例对象，这个对象是被代理的对象（这里是接口实现类）
        OurService ourService = new OurServiceImpl();

        //创建一个与代理对象相关联的InvocationHandler
        InvocationHandler stuHandler = new MyInvocationHandler(ourService);

        //创建一个代理对象stuProxy来代理OurServiceImpl
        // 代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        OurService stuProxy = (OurService)Proxy.newProxyInstance(
                ourService.getClass().getClassLoader(), // 目标类的类加载
                ourService.getClass().getInterfaces(),  // 需要代理的接口，可指定多个
                stuHandler);

        //代理去执行方法--买药
        stuProxy.buyMed();
    }
}

结果：

before method buyMed

买药。。。

after method buyMed

这样我们就能够实现代码复用，增加程序的解耦能力，解决静态代理的缺陷。

底层原理

这块是本文的重点，我们来看看源码，分析分析JDK动态代理是怎么实现的？
我们来看下Proxy._newProxyInstance_的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
       //验证传入的InvocationHandler不能为空
        Objects.requireNonNull(h);
        //克隆代理类实现的所有接口
        final Class<?>[] intfs = interfaces.clone();
        //获取安全管理器
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);//校验
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //先从缓存获取代理类, 如果没有再去生成一个代理类!!!
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //获取参数类型是InvocationHandler.class的代理类构造器!!!
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //如果代理类是不可访问的, 就使用特权将它的构造器设置为可访问
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);//此处很熟悉吧，反射那块的放开权限！
                        return null;
                    }
                });
            }
            //传入InvocationHandler实例去构造一个代理类的实例 !!!
           //所有代理类都继承自Proxy, 因此这里会调用Proxy的构造器将InvocationHandler引用传入
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

主要是3个核心的步骤：

  1. Class<?> cl = getProxyClass0(loader, intfs);``从缓存获取代理类, 如果没有再去通过 目标类的实现接口 生成一个代理类Class对象
  2. final Constructor<?> cons = cl.getConstructor(constructorParams);通过代理类Class对象获取代理类构造器
  3. cons.newInstance(new Object[]{h});通过反射将代理类Class对象生成代理类的实例

我们来看下其中最核心的方法：
Class<?> cl = _getProxyClass0_(loader, intfs);

此处获得了代理类Class对象，后面代码中获取构造器也是通过这里产生的类来获得，是整个动态代理最核心的地方。

查看getProxyClass0源码：

1
2
3
4
5
6
7
8
9
10
11
private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}

proxyClassCache.get(loader, interfaces);这边有段注释大致的意思：“先从缓存获取代理类, 如果没有命中缓存，再去通过ProxyClassFactory生成代理类”
我们继续往下看proxyClassCache.get(loader, interfaces)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public V get(K key, P parameter) {
    //要求参数，传进来的接口不能为空
    Objects.requireNonNull(parameter);
    //清除过期的缓存
    expungeStaleEntries();
    //将ClassLoader包装成CacheKey, 作为一级缓存的key
    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // lazily install the 2nd level valuesMap for the particular cacheKey
    //获取得到二级缓存，用ConcurrentMap接受，保证线程安全
    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
        //以CAS方式放入, 如果不存在则放入，否则返回原先的值
        ConcurrentMap<Object, Supplier<V>> oldValuesMap
            = map.putIfAbsent(cacheKey,
                              valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }

    // create subKey and retrieve the possible Supplier<V> stored by that
    // subKey from valuesMap
    //根据代理类实现的接口数组 来生成二级缓存key并检索
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    //这里通过subKey获取到二级缓存的值
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;

    while (true) {//死循环，命中缓存就直接返回结果，不然就创建代理对象然后返回
        if (supplier != null) {
            // supplier might be a Factory or a CacheValue<V> instance
            //在这里supplier可能是一个Factory也可能会是一个CacheValue
            //命中缓存就直接返回结果，不然就创建代理对象
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }
        // else no supplier in cache
        // or a supplier that returned null (could be a cleared CacheValue
        // or a Factory that wasn't successful in installing the CacheValue)

        // lazily construct a Factory
        if (factory == null) {
             //新建一个Factory实例作为subKey对应的值
            factory = new Factory(key, parameter, subKey, valuesMap);
        }

        if (supplier == null) {
            //到这里表明subKey没有对应的值, 就将factory作为subKey的值放入
            supplier = valuesMap.putIfAbsent(subKey, factory);
            if (supplier == null) {
                // successfully installed Factory
                supplier = factory;
            }
            // else retry with winning supplier
            //否则, 可能期间有其他线程修改了值, 那么直接将subKey取出
        } else {
            if (valuesMap.replace(subKey, supplier, factory)) {
                // successfully replaced
                // cleared CacheEntry / unsuccessful Factory
                // with our Factory
                supplier = factory;
            } else {
                // retry with current supplier
                supplier = valuesMap.get(subKey);
            }
        }
    }
}

这是WeakCache缓存类，非常复杂，我们只需关注
V value = supplier.get();这里supplier可能是一个Factory也可能会是一个CacheValue，如果命中缓存就直接返回结果结束循环
不然再次循环的时候
factory = new Factory(key, parameter, subKey, valuesMap);
supplier = factory;
这个时候 V value = supplier.get();，其实调的是Factory.get()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
@Override
        public synchronized V get() { // serialize access
            // re-check
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                // something changed while we were waiting:
                // might be that we were replaced by a CacheValue
                // or were removed because of failure ->
                // return null to signal WeakCache.get() to retry
                // the loop
                return null;
            }
            // else still us (supplier == this)

            // create new value
            V value = null;
            try {
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            // the only path to reach here is with non-null value
            assert value != null;

            // wrap value with CacheValue (WeakReference)
            CacheValue<V> cacheValue = new CacheValue<>(value);

            // put into reverseMap
            reverseMap.put(cacheValue, Boolean.TRUE);

            // try replacing us with CacheValue (this should always succeed)
            if (!valuesMap.replace(subKey, this, cacheValue)) {
                throw new AssertionError("Should not reach here");
            }

            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }

该get()方法，主要是 通过valueFactory创建代理类后 将代理类包装为CacheValue类，并将valuesMap缓存中对应代理类的Supplier替换为包装后的CacheValue,这样后面就可以直接调用CacheValue的get方法来获取代理类
其中 value = Objects.requireNonNull(valueFactory.apply(key, parameter));此处valueFactory我们来看下它是怎么过来的

1
2
3
4
5
6
7
8
9
10
11
12
final class WeakCache<K, P, V> {
    ...
    private final BiFunction<K, P, V> valueFactory;

    public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }
    ...
}

发现其是WeakCache类初始化的时候，就过来的，我们再去上层找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Proxy implements java.io.Serializable {
    ...
        
        private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    ...
        private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }
    ...
    
}

终于找到来源proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
那valueFactory.apply(key, parameter)，parameter参数是目标类实现的接口Class对象 ,其实调到是ProxyClassFactory.apply()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // prefix for all proxy class names
        //代理类名称前缀
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        //用原子类来生成代理类的序号, 以此来确定唯一的代理类
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

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

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class<?> interfaceClass = null;
                try {
                //验证intf是否可以由指定的类加载进行加载
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                 //验证intf是否是一个接口
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 */
                //验证intf在数组中是否有重复
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
            //生成代理类的包名
            String proxyPkg = null;     // package to define proxy class in
             //生成代理类的访问标志, 默认是public final的
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                //如果接口的访问标志不是public, 那么生成代理类的包名和接口包名相同
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }
            //如果接口访问标志都是public的话, 那生成的代理类都放到默认的包下：com.sun.proxy
            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * Choose a name for the proxy class to generate.
             */
             //生成代理类的序号
            long num = nextUniqueNumber.getAndIncrement();
            //生成代理类的全限定名, 包名+前缀+序号, 例如：com.sun.proxy.$Proxy0.这个就是我们debug经常看到的
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * Generate the specified proxy class.
             */
             // 用ProxyGenerator来生成字节码, 该类放在sun.misc包下 !!!
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                //根据二进制文件生成相应的Class实例
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

其中byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); （这里我们留意一下参数）用ProxyGenerator来生成字节码,我们来看下generateProxyClass（）核心方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        //初始化 ProxyGenerator，并将参数放入构造器中
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //获取ClassFile的二进制
        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;
    }

其中最关键的是final byte[] var4 = var3.generateClassFile();我们来看下generateClassFile（）方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
private byte[] generateClassFile() {
        //将所有的方法组装成ProxyMethod对象
        //为代理类生成toString, hashCode, equals等方法
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        
        //目标类要实现的接口
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

        int var3;
        Class var4;
        //遍历每一个接口的每一个方法, 并且为其生成ProxyMethod对象
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);
            }
        }

        Iterator var11 = this.proxyMethods.values().iterator();

        List var12;
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            checkReturnTypes(var12);
        }

        Iterator var15;
        //组装要生成的class文件的所有的字段信息和方法信息!!!
        try {
            //添加构造器
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();

            while(var11.hasNext()) {
                var12 = (List)var11.next();
                var15 = var12.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                    //添加代理类的静态字段
                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                    //添加代理类的代理方法
                    this.methods.add(var16.generateMethod());
                }
            }
            //添加代理类的静态字段初始化方法
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }

        if (this.methods.size() > 65535) {
            throw new IllegalArgumentException("method limit exceeded");
        } else if (this.fields.size() > 65535) {
            throw new IllegalArgumentException("field limit exceeded");
        } else {
            
            this.cp.getClass(dotToSlash(this.className));
            this.cp.getClass("java/lang/reflect/Proxy");
            var1 = this.interfaces;
            var2 = var1.length;

            for(var3 = 0; var3 < var2; ++var3) {
                var4 = var1[var3];
                this.cp.getClass(dotToSlash(var4.getName()));
            }

            this.cp.setReadOnly();
            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
            DataOutputStream var14 = new DataOutputStream(var13);
            //构造class信息，并写入最终的class文件！！！
            try {
                var14.writeInt(-889275714);
                var14.writeShort(0);
                var14.writeShort(49);
                this.cp.write(var14);
                var14.writeShort(this.accessFlags);
                //写入类索引
                var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
                //写入父类索引, 生成的代理类都继承自Proxy
                var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
                var14.writeShort(this.interfaces.length);
                Class[] var17 = this.interfaces;
                int var18 = var17.length;
                
                for(int var19 = 0; var19 < var18; ++var19) {
                    Class var22 = var17[var19];
                    var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
                }
                //写入字段计数值
                var14.writeShort(this.fields.size());
                var15 = this.fields.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                    //写入字段集合
                    var20.write(var14);
                }
                //写入方法计数值
                var14.writeShort(this.methods.size());
                var15 = this.methods.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                    //写入方法集合
                    var21.write(var14);
                }
                //写入属性计数值, 代理类class文件没有属性所以为0
                var14.writeShort(0);
                return var13.toByteArray();
            } catch (IOException var9) {
                throw new InternalError("unexpected I/O Exception", var9);
            }
        }
    }

我们可以发现generateClassFile()方法是按照Class文件结构去填充数据，生产代理类Class

Class类就像 普通类的模板 一样，用来保存“类所有相关信息”的类。

大概有3个步骤：

  1. 获取目标类要实现的接口方法，将其包装成ProxyMethod对象并注册到Map集合中。
  2. 组装要生成的class文件的所有的字段信息和方法信息等其他信息
  3. 构造class信息，并写入最终的class文件

至此，我们明白了 Class<?> cl = getProxyClass0(loader, intfs);是如何通过目标类实现的接口Class 产生代理类的Class对象，而有代理类的Class对象，我们就能通过反射 获得代理类实例对象。

我们再看一下，产生的代理类，在执行获取代理类前加上一句
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
会在项目根目录生成一个目录: com/sum/proxy/$Proxy0.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public final class $Proxy0 extends Proxy implements OurService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    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 void buyMed() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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 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"));
            m3 = Class.forName("com.zj.demotest.test4.OurService").getMethod("buyMed");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            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的代码中我们可以发现：

  • $Proxy0继承了 Proxy 类，继承目标类实现的接口，并且实现了被代理的所有接口，以及equals、hashCode、toString等方法

其实我们可以发现为什么JDK动态代理只能代理接口？因为Java中类只支持单继承，接口可以多继承，所以JDK动态代理只能去实现接口。

  • 类和所有方法都被 public final 修饰，所以代理类只可被使用，不可以再被继承
  • proxy对象的原理是：内部维护一个InvocationHandler，而InvocationHandler是对自定义逻辑的抽象。通过抽取InvocationHandler，将代理对象和自定义逻辑解耦。
  • 代理对象的方法调用 都是 通过 super.h.invoke(this, m1, (Object[])null); 调用，其中的 super.h.invoke 实际上是在创建代理的时候传递给 Proxy.newProxyInstance 的 MyInvocationHandler对象，它继承InvocationHandler类，负责实际的调用处理逻辑。MyInvocationHandler.invoke()接收到 method、args 等参数后, 然后通过反射让被代理的对象 target 执行方法

补充： CGLIB动态代理

CGLIB 动态代理类使用步骤

  1. 定义一个类；
  2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
  3. 通过 Enhancer 类的 create()创建代理类；

示例

CGLIB是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

1
2
3
4
5
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>x.x.x</version>
</dependency>

Spring在5.X之前默认的动态代理实现一直是jdk动态代理。但是从5.X开始，spring就开始默认使用CGLIB来作为动态代理实现。并且springboot从2.X开始也转向了CGLIB动态代理实现。

编写一个目标类：

1
2
3
4
5
6
7
public class Doctor {
    private String name;

    public void work() {
        System.out.println("上班。。。");
    }
}

自定义 MethodInterceptor（方法拦截器）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MyMethodInterceptor implements MethodInterceptor {
    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加额外逻辑
        System.out.println("before method " + method.getName());
        //这里要调用proxy.invokeSuper，而不是method.invoke，不然会出现栈溢出等问题
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们可以添加额外逻辑
        System.out.println("after method " + method.getName());
        return object;
    }
}

最后编写测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TestCGlib {
    public static void main(String[] args) {

        Class cl = Doctor.class;
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(cl.getClassLoader());
        // 设置目标类
        enhancer.setSuperclass(cl);
        // 设置方法拦截器
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理类
        Doctor proxy = (Doctor) enhancer.create();
        //执行方法
        proxy.work();
    }
}

结果：

before method work

上班。。。

after method work

由于本文篇幅过长且CGLIB不是本文的重点 ，CGLIB源码分析就不展开了，待后面有空出一下。

JDK 动态代理和 CGLIB 动态代理对比

  1. 可以代理的类型：
  • JDK 动态代理只能代理实现了接口的类或者直接代理接口,由于默认继承Proxy类，java类是单继承，接口可以多继承
  • CGLIB 可以代理未实现任何接口的类
  • CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，子类会被覆盖其中的方法，并覆盖其中方法的增强，因为采用的是继承，所以不能代理声明为 final 类型的类和方法。
  1. 原理：
  • JDK动态代理 ，通过目标类实现的接口Class 产生代理类的Class对象，而有了代理类的Class对象，我们就能通过反射机制 获得代理类实例对象
  • CGLIB动态代理利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理
  1. 效率
  • CGLIB 底层是ASM字节码生成框架,在Jdk1.6之前比使用java反射的效率要高，但随着jdk的不断优化，在1.8的时候JDK动态代理的效率已高于cglib，而且随着 JDK 版本的升级，这个优势会愈加明显。
  1. Spring如何选择是用JDK代理还是CGLIB代理？
  • 当bean实现接口时，会用JDK代理模式
  • 当bean没有实现接口，用cglib实现
  • 可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>）

参考资料：
《Java虚拟机规范》

《深入理解Java虚拟机：JVM高级特性与最佳实践第3版》

https://blog.csdn.net/huweiliyi/article/details/107609881

https://www.cnblogs.com/liuyun1995/p/8157098.html

本篇文章到这里就结束啦，很感谢你能看到最后，如果喜欢的话，点赞收藏转发，欢迎关注！更多精彩的文章