设计模式之——JDK动态代理的源码分析

刺骨的言语ヽ痛彻心扉 2022-11-25 15:28 186阅读 0赞

JAVA的动态代理模式中有两种实现，一种是JDK默认的实现，一种是cglib包中的实现。这里我们通过源码带大家学习一下JDK中的动态代理的源码实现。

## JDK动态代理的使用 ##

JDK动态代理使用步骤大致分为这样几个步骤：

*  1、 新建一个**接口**（Transaction）
 *  2、 为接口创建一个**实现类**（AlipayTransaction）
 *  3、 创建**代理类**（ProxyAlipayTransaction），并实现InvocationHandler接口
 *  4、 在**测试类**（MainTest）中，将**实现类**和**代理类**关联，并通过代理类调用**接口**中的方法

### Transaction.class ###

package com.wuxiaolong.proxy.statics;
    
    import java.util.Map;
    
    /** * Description: 这是一套交易的接口 * * @author 诸葛小猿 * @date 2020-08-09 */
    public interface Transaction { 
    
        Map<String,String> pay(Map<String,String> params);
    }

### AlipayTransaction.class ###

package com.wuxiaolong.proxy.statics;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /** * Description: 真实的阿里交易 * * @author 诸葛小猿 * @date 2020-08-09 */
    public class AlipayTransaction implements Transaction { 
    
        @Override
        public Map<String,String> pay(Map<String,String> params) { 
    
            // 1.封装支付宝支付参数
            System.out.println("封装支付宝支付参数");
    
            // 2.调用支付宝支付接口
            System.out.println("调用支付宝支付接口");
    
            // 3.封装支付宝响应的支付结果
            Map<String,String> result = new HashMap<>();
            System.out.println("封装支付宝响应的支付结果");
    
            return result;
        }
    }

### ProxyAlipayTransaction.class ###

package com.wuxiaolong.design.pattern.proxy.dynamic.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Map;
    
    /** * Description: 动态代理对象 * * 需要实现jdk的InvocationHandler接口的invoke方法 * * @author 诸葛小猿 * @date 2020-08-09 */
    public class ProxyAlipayTransaction implements InvocationHandler { 
    
        /** * 自定义一个成员变量，用于存储真正的被代理对象的信息 */
        private Transaction target;
    
        /** * 自定义一个方法，动态获取被代理的对象信息 */
        public Object getInstance(Transaction target) throws Exception{ 
    
            // 将真正的被代理对象赋值给成员变量
            this.target = target;
    
            // 获得被代理对象的class
            Class clazz = target.getClass();
            System.out.println("ProxyAlipayTransaction获取的被代理对象的class是:"+clazz);
    
            // 通过反射，使用类加载器，实例化出真正的被代理对象，并实现相关的方法
            Object obj = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    
            return obj;
        }
    
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
            // 支付之前，记录订单信息
            System.out.println("支付之前，记录订单信息");
    
    
            // 调用真正的交易实现类完成支付业务
            System.out.println("---------------start----------------");
            Object result =method.invoke(this.target, args);
            System.out.println("---------------end----------------");
    
            // 支付之后，调用发票服务开发票
            System.out.println("支付之后，调用发票服务开发票");
    
            return result;
        }
    
    }

### MainTest.class ###

package com.wuxiaolong.design.pattern.proxy.dynamic.jdk;
    
    import java.util.HashMap;
    
    /** * Description: 测试类 * * @author 诸葛小猿 * @date 2020-08-09 */
    public class MainTest { 
    
        public static void main(String[] args) throws Exception{ 
    
            // 代理对象
            ProxyAlipayTransaction proxyAlipayTransaction = new ProxyAlipayTransaction();
    
            // 获得被代理对象的信息
            Transaction obj = (Transaction) proxyAlipayTransaction.getInstance(new AlipayTransaction());
            System.out.println("MainTest获取的被代理对象的class是:"+obj.getClass());
    
            // 执行代理对象的方法
            obj.pay(new HashMap<String, String>());
        }
    }

执行的结果：

ProxyAlipayTransaction获取的被代理对象的class是:class com.wuxiaolong.design.pattern.proxy.dynamic.jdk.AlipayTransaction
    MainTest获取的被代理对象的class是:class com.sun.proxy.$Proxy0
    支付之前，记录订单信息
    ---------------start----------------
    封装支付宝支付参数
    调用支付宝支付接口
    封装支付宝响应的支付结果
    ---------------end----------------
    支付之后，调用发票服务开发票

这里的log可以看出，`MainTest`中的代理对象不是`AlipayTransaction`,而是一个名叫`$Proxy0`的对象。这是由于，在JDK的动态代理中，代码在运行期，通过反射新生成了字节码`$Proxy0`，并且被JVM动态加载了，所以这里会新生成一个被代理的实例，这个实例同样也实现了`Transaction`的接口。

## $Proxy0.class的动态生成 ##

动态代理中的代理类，是程序运行期通过反射生成并加载到JVM的，而静态代理的类是在程序编译的时候就生成的。

下面打印出`$Proxy0.class`的字节码文件，可以通过在`MainTest.main()`方法的开头加上：

// 方式一、打开配置获得字节码，生成的字节码默认位置: 项目所在目录/com/sum/proxy/$Proxy0.class
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    
    // 方式二、手动通过ProxyGenerator.generateProxyClass方法获得对Transaction.class代理的对象并输出到文件。
    // byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Transaction.class});
    // FileOutputStream os = new FileOutputStream("./$Proxy0.class");
    // os.write(data);
    // os.close();

就可以获得字节码文件：

![format_png][]

反编译出源码（可以通过IDEA或jd-gui等工具反编译看到源码）：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.sun.proxy;
    
    import com.wuxiaolong.design.pattern.proxy.dynamic.jdk.Transaction;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    import java.util.Map;
    // 这个代理类也实现了Transaction，并且继承了Proxy
    public final class $Proxy0 extends Proxy implements Transaction { 
        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);
            }
        }
        // 这个pay方法就是Transaction中定义的，这里做了实现；当我们在MainTest中调用代理类的pay方法，实际就是调用这个方法；从下面static块中可以看出，m3就是pay方法
        public final Map pay(Map var1) throws  { 
            try { 
                return (Map)super.h.invoke(this, m3, 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 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.wuxiaolong.design.pattern.proxy.dynamic.jdk.Transaction").getMethod("pay", Class.forName("java.util.Map"));
                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.class`的源码可以看出，

*  1.$Proxy0这个类实现了要代理的`Transaction`接口，并且继承了`Proxy`。由于java不支持多继承，所以JDK动态代理不能代理类。
 *  2.重写了equals、hashCode、toString
 *  3.代码的最下面有一个静态代码块，通过反射或者代理类的所有方法
 *  4.当我们在`MainTest`中调用代理类的pay方法实际就是`$Proxy0.pay()`这个方法，\`\`$Proxy0.pay()`会调用`ProxyAlipayTransaction.invoke()`方法，从而调用`AlipayTransaction.pay()\`方法。

这个代理类`$Proxy0.class`是如何生成的呢？

## JDK动态代理源码分析 ##

这里查看JDK1.8的源码，通过debug学习JDK动态代理的实现原理

### 大概流程 ###

*  1、为接口创建代理类的字节码文件
 *  2、使用ClassLoader将字节码文件加载到JVM
 *  3、创建代理类实例对象，执行对象的目标方法

动态代理涉及到的主要类：

java.lang.reflect.Proxy  
java.lang.reflect.InvocationHandler  
java.lang.reflect.WeakCache  
sun.misc.ProxyGenerator

### Proxy.newProxyInstance() ###

首先看Proxy类中的newProxyInstance方法。

![format_png 1][]

在`ProxyAlipayTransaction.class`中，使用了`Proxy.newProxyInstance()`获得代理对象。`newProxyInstance`的源码：

@CallerSensitive
        public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        { 
            Objects.requireNonNull(h);
    
            final Class<?>[] intfs = interfaces.clone();
            final SecurityManager sm = System.getSecurityManager();
            if (sm != null) { 
                checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
            }
    
            /* * 生成接口的代理类的字节码文件 ******** */
            Class<?> cl = getProxyClass0(loader, intfs);
    
            /* * 使用自定义的InvocationHandler作为参数，调用构造函数获取代理类对象实例 */
            try { 
                if (sm != null) { 
                    checkNewProxyPermission(Reflection.getCallerClass(), cl);
                }
    
                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;
                        }
                    });
                }
                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);
            }
        }

### getProxyClass0() ###

`newProxyInstance`方法调用`getProxyClass0`方法生成代理类的字节码文件，`getProxyClass0`的源码如下：

/** * Generate a proxy class. */
        private static Class<?> getProxyClass0(ClassLoader loader,
                                               Class<?>... interfaces) { 
            if (interfaces.length > 65535) { 
                throw new IllegalArgumentException("interface limit exceeded");
            }
    
            // 如果缓存中已经存在相应接口的代理类，直接返回；否则，使用ProxyClassFactory创建代理类
            return proxyClassCache.get(loader, interfaces);
        }

### proxyClassCache ###

`proxyClassCache`是`Proxy.class`的成员变量，这个变量初始化的时候会实例化出`ProxyClassFactory`：

/** * 代理类会缓存到proxyClassCache中 */
        private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
            proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

### ProxyClassFactory ###

`ProxyClassFactory`的源码：

/** * A factory function that generates, defines and returns the proxy class given * the ClassLoader and array of interfaces. */
        private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>
        { 
            // 代理类前缀$Proxy
            private static final String proxyClassNamePrefix = "$Proxy";
    
            // 生成代理类名称的计数器 如 $Proxy0、$Proxy1、$Proxy2
            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) { 
                    /* * 校验类加载器是否能通过接口名称加载该类 */
                    Class<?> interfaceClass = null;
                    try { 
                        interfaceClass = Class.forName(intf.getName(), false, loader);
                    } catch (ClassNotFoundException e) { 
                    }
                    if (interfaceClass != intf) { 
                        throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                    }
    				/* * 校验该类是否是接口类型 */
                    if (!interfaceClass.isInterface()) { 
                        throw new IllegalArgumentException(
                            interfaceClass.getName() + " is not an interface");
                    }
                    /* * 校验接口是否重复 */
                    if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { 
                        throw new IllegalArgumentException(
                            "repeated interface: " + interfaceClass.getName());
                    }
                }
    			// 代理类的包名
                String proxyPkg = null;     
                int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
    
                /* * 非public接口，代理类的包名与接口的包名相同 */
                for (Class<?> intf : interfaces) { 
                    int flags = intf.getModifiers();
                    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");
                        }
                    }
                }
    
                if (proxyPkg == null) { 
                    // // public代理接口，使用com.sun.proxy包名
                    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
                }
    
                /* * 为代理类生成名字 如 $Proxy0、$Proxy1、$Proxy2 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
    
                /* * 真正生成代理类的字节码文件的地方 ******** */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
                try { 
                    // 使用类加载器将代理类的字节码文件加载到JVM中
                    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());
                }
            }
        }

### ProxyGenerator.generateProxyClass() ###

在上面`ProxyClassFactory`类的`apply`方法中可看出，真正生成代理类字节码的地方是`ProxyGenerator.generateProxyClass()`:

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;
        }

在上面`$Proxy0.class`字节码生成方式二，就是手动通过ProxyGenerator.generateProxyClass方法获得对Transaction.class代理的对象并输出到文件。

关注公众号，输入“**java-summary**”即可获得源码。

完成，收工！

![aHR0cHM6Ly9naXRlZS5jb20vd3V4aWFvbG9uZ2FoL2phdmEtc3VtbWFyeS9yYXcvbWFzdGVyL2ltZy82X3FyY29kZV9jaGUuZ2lm][]

【**传播知识，共享价值**】，感谢小伙伴们的关注和支持，我是【**诸葛小猿**】，一个彷徨中奋斗的互联网民工。

![format_png 2][]

[format_png]: /images/20221124/be5a6983fdf2493a9f0b39a6a39d9e6e.png
[format_png 1]: /images/20221124/fa8f6c27554b403280fdae75a7cb44c0.png
[aHR0cHM6Ly9naXRlZS5jb20vd3V4aWFvbG9uZ2FoL2phdmEtc3VtbWFyeS9yYXcvbWFzdGVyL2ltZy82X3FyY29kZV9jaGUuZ2lm]: /images/20221124/31f1acc122054018acbcbfec7f91cf8c.png
[format_png 2]: /images/20221124/cae52f8018a44caca348724b8220f088.png