JDK8源码分析Jdk动态代理底层原理

 本文侧重分析JDK8中jdk动态代理的源码，若是想看JDK17源码分析可以看我的这一篇文章 JDK17源码分析Jdk动态代理底层原理-CSDN博客
两者之间有着略微的差别，JDK17在JDK8上改进了不少
目录
源码分析 
过程
生成的代理类大致结构

---

 本文侧重分析JDK8中jdk动态代理的源码，若是想看JDK17源码分析可以看我的这一篇文章 JDK17源码分析Jdk动态代理底层原理-CSDN博客
两者之间有着略微的差别，JDK17在JDK8上改进了不少

      InvocationHandler最终存储在代理类实例的h字段中，这个字段是从Proxy类继承的。当调用代理对象的方法时，会调用这个h字段引用的InvocationHandler实例的invoke方法。如许就实现了方法调用的拦截和处置惩罚。 

源码分析 

1. public class Proxy implements java.io.Serializable {
2.     /**
3.      * InvocationHandler对象，用于处理代理类的方法调用
4.      * 这个字段会被所有代理类继承，存储在代理类实例中
5.      */
6.     protected InvocationHandler h;
7.    
8.     /**
9.      * 代理类的构造函数，将InvocationHandler传递给代理类实例
10.      * 这个构造函数会被所有代理类调用
11.      */
12.     protected Proxy(InvocationHandler h) {
13.         Objects.requireNonNull(h);
14.         this.h = h;
15.     }
17.     /**
18.      * 创建代理类实例的核心方法
19.      * loader: 类加载器，用于加载代理类
20.      * interfaces: 代理类需要实现的接口数组
21.      * h: 调用处理器，用于处理代理类的方法调用
22.      */
23.     @CallerSensitive
24.     public static Object newProxyInstance(ClassLoader loader,
25.                                         Class<?>[] interfaces,
26.                                         InvocationHandler h) {
27.         // 检查InvocationHandler是否为空
28.         Objects.requireNonNull(h);
30.         // 复制接口数组，确保安全性
31.         final Class<?>[] intfs = interfaces.clone();
32.         
33.         // 获取安全管理器
34.         final SecurityManager sm = System.getSecurityManager();
35.         if (sm != null) {
36.             // 检查权限
37.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
38.         }
40.         /*
41.          * 查找或生成代理类
42.          * 这是最核心的步骤，会生成代理类的字节码
43.          */
44.         Class<?> cl = getProxyClass0(loader, intfs);
46.         try {
47.             // 检查权限
48.             if (sm != null) {
49.                 checkNewProxyPermission(Reflection.getCallerClass(), cl);
50.             }
52.             // 获取代理类的构造函数
53.             final Constructor<?> cons = cl.getConstructor(constructorParams);
54.             final InvocationHandler ih = h;
55.             
56.             // 如果构造函数是非public的，设置其可访问
57.             if (!Modifier.isPublic(cl.getModifiers())) {
58.                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
59.                     public Void run() {
60.                         cons.setAccessible(true);
61.                         return null;
62.                     }
63.                 });
64.             }
65.             
66.             // 创建代理类实例
67.             return cons.newInstance(new Object[]{h});
68.             
69.         } catch (IllegalAccessException|InstantiationException e) {
70.             throw new InternalError(e.toString(), e);
71.         } catch (InvocationTargetException e) {
72.             throw new InternalError(e.toString(), e);
73.         } catch (NoSuchMethodException e) {
74.             throw new InternalError(e.toString(), e);
75.         }
76.     }
78.     /**
79.      * 获取代理类的核心方法
80.      * 这个方法会调用ProxyClassFactory来生成代理类
81.      */
82.     private static Class<?> getProxyClass0(ClassLoader loader,
83.                                          Class<?>[] interfaces) {
84.         // 如果接口数量超过65535，抛出异常
85.         if (interfaces.length > 65535) {
86.             throw new IllegalArgumentException("interface limit exceeded");
87.         }
89.         // 从缓存中获取代理类，如果不存在则生成
90.         return proxyClassCache.get(loader, interfaces);
91.     }
92. }
94. /**
95. * 代理类工厂，负责生成代理类的字节码
96. */
97. private static final class ProxyClassFactory
98.     implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
99.    
100.     // 代理类名称前缀
101.     private static final String proxyClassNamePrefix = "$Proxy";
103.     // 原子计数器，用于生成唯一的代理类名
104.     private static final AtomicLong nextUniqueNumber = new AtomicLong();
106.     @Override
107.     public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
108.         Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
109.         
110.         // 验证接口
111.         for (Class<?> intf : interfaces) {
112.             // 验证类加载器能否加载这个接口
113.             validateInterface(intf, loader, interfaceSet);
114.         }
116.         // 生成代理类的名称
117.         String proxyPkg = null;     // 包名
118.         int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
120.         // 检查所有非公共接口是否在同一个包中
121.         for (Class<?> intf : interfaces) {
122.             int flags = intf.getModifiers();
123.             if (!Modifier.isPublic(flags)) {
124.                 accessFlags = Modifier.FINAL;  // 移除public标志
125.                 String pkg = intf.getPackageName();
126.                 if (proxyPkg == null) {
127.                     proxyPkg = pkg;
128.                 } else if (!pkg.equals(proxyPkg)) {
129.                     throw new IllegalArgumentException(
130.                         "non-public interfaces from different packages");
131.                 }
132.             }
133.         }
135.         // 如果没有指定包名，默认使用com.sun.proxy
136.         if (proxyPkg == null) {
137.             proxyPkg = "com.sun.proxy";
138.         }
140.         // 生成代理类的完整名称
141.         long num = nextUniqueNumber.getAndIncrement();
142.         String proxyName = proxyPkg.isEmpty()
143.                           ? proxyClassNamePrefix + num
144.                           : proxyPkg + "." + proxyClassNamePrefix + num;
146.         // 生成代理类的字节码
147.         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
148.             proxyName, interfaces, accessFlags);
150.         try {
151.             // 加载代理类
152.             return defineClass0(loader, proxyName,
153.                               proxyClassFile, 0, proxyClassFile.length);
154.         } catch (ClassFormatError e) {
155.             throw new IllegalArgumentException(e.toString());
156.         }
157.     }
158. }

复制代码

过程

JDK动态代理生成代理对象的过程可以分为以下几个关键步调：
1.调用Proxy.newProxyInstance方法，传入类加载器、接口数组和InvocationHandler实例。这是整个代理创建过程的入口。
2.通过getProxyClass0方法获取代理类。这个方法会首先查抄缓存中是否已经存在对应的代理类，如果不存在则创建新的代理类。
3.ProxyClassFactory负责生成代理类的字节码，此中会，验证接口的合法性，生成唯一的代理类名，确定代理类的包名，调用ProxyGenerator生成字节码
4. 获取代理类的构造函数，这个构造函数吸取一个InvocationHandler参数。
5.使用构造函数创建代理类实例，将InvocationHandler传入。这个InvocationHandler会被存储在代理类的h字段中。

生成的代理类大致结构

1. public final class $Proxy0 extends Proxy implements UserService {
2.    
3.    
4.     // 静态方法对象，用于方法调用
5.     private static Method m1;
6.     private static Method m2;
7.     private static Method m3;
8.    
9.     static {
10.         try {
11.             // 初始化方法对象
12.             m1 = Class.forName("java.lang.Object")
13.                      .getMethod("equals", Object.class);
14.             m2 = Class.forName("com.example.UserService")
15.                      .getMethod("addUser", String.class);
16.             // ... 其他方法
17.         } catch (NoSuchMethodException e) {
18.             throw new NoSuchMethodError(e.getMessage());
19.         }
20.     }
21.    
22.     // 构造函数，调用父类构造函数存储InvocationHandler
23.     public $Proxy0(InvocationHandler h) {
24.         super(h);
25.     }
26.    
27.     // 实现接口方法
28.     @Override
29.     public void addUser(String name) {
30.         try {
31.             // 调用InvocationHandler的invoke方法
32.             h.invoke(this, m2, new Object[]{name});
33.         } catch (Throwable e) {
34.             throw new UndeclaredThrowableException(e);
35.         }
36.     }
37. }

复制代码

       InvocationHandler最终存储在代理类实例的h字段中，这个字段是从Proxy类继承的。当调用代理对象的方法时，会调用这个h字段引用的InvocationHandler实例的invoke方法。如许就实现了方法调用的拦截和处置惩罚。 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。