Proxy创建代理对象源码解析（jdk1.8）

小灰灰 2022-05-28 05:24 142阅读 0赞

jdk代理和cglib代理动态代理的重要实现，今天就学习一下交流一下jdk代理

@CallerSensitive
        public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        {
            Objects.requireNonNull(h);
    
    		//克隆该接口
            final Class<?>[] intfs = interfaces.clone();
    		//获取系统安全接口  
    		//返回：
    		//如果已经为当前应用程序建立了安全管理器，则返回此安全管理器；否则，返回 null。
            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);
                }
    			//获取构造函数
                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);
            }
        }

从上述源码可以看出最重要的是获取代理对象的字节码对象

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

public V get(K key, P parameter) {
    		//检查指定类型的对象引用不为空null。当参数为null时，抛出空指针异常。
            Objects.requireNonNull(parameter);
    		//清除过期的缓存
            expungeStaleEntries();
    		//将ClassLoader包装成CacheKey, 作为一级缓存的key
            Object cacheKey = CacheKey.valueOf(key, refQueue);
    
            // lazily install the 2nd level valuesMap for the particular cacheKey
    		获取得到二级缓存
            ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    		//没有获取到对应的值
            if (valuesMap == null) {
                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) {
    			//如果通过subKey取出来的值不为空
    			if (supplier != null) {
    				// supplier might be a Factory or a CacheValue<V> instance
    				//在这里supplier可能是一个Factory也可能会是一个CacheValue
    				//在这里不作判断, 而是在Supplier实现类的get方法里面进行验证
    				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
    					 //到这里表明成功将factory放入缓存
    					 supplier = factory;
    				 }
    				 //否则, 可能期间有其他线程修改了值, 那么就不再继续给subKey赋值, 而是取出来直接用
    				  // else retry with winning supplier
    			} else {
    				 //期间可能其他线程修改了值, 那么就将原先的值替换
    				 if (valuesMap.replace(subKey, supplier, factory)) {
    					 // successfully replaced
                        // cleared CacheEntry / unsuccessful Factory
                        // with our Factory
    					 //成功将factory替换成新的值
    					 supplier = factory;
    				 } else {
    					 // retry with current supplier
    					 //替换失败, 继续使用原先的值
    					 supplier = valuesMap.get(subKey);
    				 }
    			}
            }
        }