当Kotlin邂逅设计模式之代理模式(二)

h(InvocationHandler): 代理拦截器接口，一般需要使用子类去实现该接口或匿名类去实现

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<);
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
       
        final Class<);//将interfaces的Class数组clone一份副本，赋值给intfs
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {//检查创建一个新的代理类需要权限
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //注意点1: getProxyClass0方法拿到代理类的Class对象实例cl
         //注意传入的参数就是从外部传入的loader(被代理类的类加载器)、intfs(被代理类实现所接口的Class[]的副本)
        Class<);/*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            
            //注意点2: 拿到cl实例后，就通过反射机制创建代理类实例
            final Constructor<);//先拿到代理类的构造器Constructor实例cons
            final InvocationHandler ih = h;
            //检查代理类构造器是否是公有的public权限, 不是就会通过AccessController去修改访问权限以致于可以创建代理类实例
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);//将访问权限设置为可访问的
                        return null;
                    }
                });
            }
            //注意点3: 拿到构造器实例cons后，就到了最为关键的也就是最后一步，创建代理类实例。
            //但是需要注意的是构造器反射传入的参数是h，也就是传入的InvocationHandler的实例，也可以进一步推论生成的代理类中存在以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);
        }
    }

再一次来梳理下newProxyInstance源码流程:

首先传入loader、interfaces、h三个参数，先将interfacesclone一份副本保存在intfs中，然后检查创建一个新的代理类所需要的权限，接着到了我们第一个注意点1，就是通过getProxyClass0方法(需要传入loader和intfs参数)获得代理类的Class对象实例。拿到了代理类实例后，我们就通过反射的机制创建代理类实例；

到了我们的注意点二，通过代理类Class对象cl获得构造器对象cons，并检查构造器对象是否是public,否则就强行修改访问权限；

最后到了注意点三，通过cons.newInstance创建代理类对象，并且构造器反射中传入h(InvocationHandler对象)，说明我们可以推断一下生成的代理类中存在以InvocationHandler为参数的构造器。

3、第三步进入getProxyClass0方法，传入的参数loader和intfs，在该方法内部会委托给proxyClassCache的get方法，如果给定的类加载器中定义的代理类实现了给定的接口，直接返回缓存中的副本，否则它将通过ProxyClassFactory创建代理类.

    private static Class<);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
        //请注意上面那段英文注释: 如果给定的类加载器中定义的代理类实现了给定的接口，
        //那么就会直接返回缓存中的副本，否则它将通过ProxyClassFactory创建代理类
        //注意点1: proxyClassCache；注意点2: ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

4、第四步proxyClassCache的介绍和定义, 请注意创建proxyClassCache传入的构造器两个参数分别是: KeyFactory和ProxyClassFactory

    /**
     * a cache of proxy classes
     */
    private static final WeakCachenew WeakCache<>(new KeyFactory(), new ProxyClassFactory());

proxyClassCache是一个WeakCache对象，WeakCache中的K表示key值，P代表参数，V代表存储的值。此类用于缓存(key, sub-key) -> value键值对。内部具体实现是借助了ConcurentMap>>,Supplier是一个接口，就一个get方法用于获得值，不过是泛型V的包装类，第一个Object就是key（这里表达式不用泛型K是因为key值可以为null)，第二个就是sub-key，那么它对应着什么呢);P呢，这就需要引出另外一个函数接口BiFunction,该接口内部存在R apply(T t, U u)方法，这个方法意思就是根据传入两个泛型T和U的值经过一定计算得到泛型R的值。在WeakCache类中存在两个BiFunction对象:

final class WeakCache<K, P, V> {
    private final ReferenceQueue refQueue
        = new ReferenceQueue<>();
    // the key type is Object for supporting null key
    private final ConcurrentMap>> map
        = new ConcurrentHashMap<>();
    private final ConcurrentMap, Boolean> reverseMap
        = new ConcurrentHashMap<>();
    private final BiFunctionprivate final BiFunction valueFactory;
    
    public WeakCache(BiFunction {
        //根据K,P得到sub-key算法
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        //根据K,P得到value算法
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }
    ...
}    

在WeakCahe类中只有一个核心get方法,里面包含了整个缓存的逻辑，注意我们获取代理类Class对象，就是通过proxyClassCache.get(loader, interfaces);实际上就是调用WeakCache中的get方法.

//K泛型是一级map的缓存key, P泛型传入的参数，分别对应外部传入的 loader和 interfaces
public V get(K key, P parameter) {
        ...
        //通过传入一级map的key，通过CacheKey拿到最终
        Object cacheKey = CacheKey.valueOf(key, refQueue);
        // 懒初始化cacheKey对应的二级valuesMap, 如果valuesMap为空，就会新创建一个空的ConcurrentMap的valueMap，put到一级缓存map中
        ConcurrentMap> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
        //如果valuesMap为空，就会新创建一个空的ConcurrentMap的valueMap
            ConcurrentMap> oldValuesMap = map.putIfAbsent(cacheKey,valuesMap = new ConcurrentHashMap<>());
            //如果内部已经存在原来的oldValuesMap直接用它
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

 //------注意点1: subKeyFactory.apply(key, parameter)-----
        //根据传入的一级map的key和参数parameter，通过subKeyFactory中的apply方法获得sub-key,
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        //然后通过我们的sub-key,从二级缓存的valuesMap中取的supplier对象
        Supplier supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                //supplier这个对象可能是Factory或CacheValue对象，
                //那么也就是supplier.get()方法可能是调用了Factory中的get方法或CacheValue中的get方法
//--------注意点2: supplier.get()-----            
                V value = supplier.get();
                //如果value不为空就返回value，结束整个get方法调用
                if (value != null) {
                    return value;
                }
            }
            //如果缓存中没有supplier对象
            //或者supplier中get返回是null
            //或者Factory对象没有在CacheValue中被成功创建
            
            //factory为null，就会创建一个新的Factory实例
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            //supplier为null
            if (supplier == null) {
                //根据新创建的factory和subKey拿到supplier对象，如果valuesMap中存在subKey, factory键值对，就返回已经存在的值，没有直接返回null
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                 //如果拿到supplier为null,supplier就变为了factory,这就是前面说supplier为一个factory   
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    supplier = factory;
                } else {
                    //通过valuesMap.get()拿到supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

我们来一起梳理下WeakCache的逻辑: 首先proxyClassCache就是一个WeakCache实例对象，它有两个构造器参数subKeyFactory和valueFactory,创建proxyClassCache实例对应传入的是proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory())中的KeyFactory和ProxyClassFactory.

然后在WeakCache内部存在二级ConcurrentHashMap, 一级map的key就是get方法传入的key, 通过这个key拿到cacheKey,从而拿到对应的valuesMap二级map。

然后又通过根据传入的一级map的key和参数parameter，subKeyFactory中的apply方法获得sub-key,通过sub-key拿到二级map中存储的Supplier对象，它可能是一个CacheValue也有可能是一个Factory,

最终通过Factory的get方法拿到实际的值。

对于上述有两个核心注意点

注意点1----->获取subKey过程: 通过subKeyFactory.apply(key,parameter)拿到sub-key

//weakCache调用处: 
 Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
 //KeyFactory的定义
    private static final class KeyFactory
        implements BiFunction

注意点2----> supplier.get()获取value的过程:

我们都知道supplier对应的可以是Factory对象，也就是最后会调用Factory中的get方法。

  @Override
        public synchronized V get() { // serialize access
            // 再一次检查supplier，如果传入从valuesMap拿到的不等于当前Factory对象，因为它可能已经变成CacheValue了，那就直接返回null
            Supplier supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }
            
            //创建一个新的value
            V value = null;
            try {
               //注意点出现，value最终会通过valueFactory.apply(key, parameter)拿到
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            // 判断value是否为null
            assert value != null;

            // 将拿到的value包装成一个CacheValue
            CacheValue cacheValue = new CacheValue<>(value);

            // 尝试把valuesMap中的对应subKey的Factory替换成cacheValue，
            //这就是为什么前面说过valuesMap中取出的Supplier可能是Factory可能是CacheValue，有没有种偷梁换柱的赶脚
            if (valuesMap.replace(subKey, this, cacheValue)) {
                //替换成功后，并把cacheValue put到reverseMap中
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }

            // 成功替换了新的CacheValue,并返回最终的值
            return value;
        }

通过上述代码分析，我们知道最终value获取是来自于valueFactory中apply方法，还记得valueFactory是啥吗？没错它就是ProxyClassFactory也就是最终定位到了ProxyClassFactory中的apply方法。这也就是为什么之前说如果缓存中有直接从缓存中返回缓存的副本，没有就在ProxyClassFactory中创建代理对象。

5、第五步进入ProxyClassFactory中的apply方法进行探究，这是创建新的代理类Class对象唯一来源。

    private static final class ProxyClassFactory
        implements BiFunction

再重新梳理一下ProxyClassFactory中的apply中的逻辑，首先做一些接口验证操作，然后通过ProxyGenerator.generateProxyClass生成确定的代理类Class文件的byte数组,最后通过defineClass0方法传入被代理类的类加载器、代理类唯一名称、生成的代理类文件反序列化成一个代理类的Class对象

6、第六步进入ProxyGenerator中的generateProxyClass方法进行探究，主要通过它来生成代理类Class文件。generateProxyClass方法传入的参数主要有: proxyName(唯一代理类名称), interfaces(需要代理的接口Class数组), accessFlags(访问权限标识)

    public static byte[] generateProxyClass(final String var0, Class<);int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //-----注意点----调用ProxyGenerator中的generateClassFile方法
        final byte[] var4 = var3.generateClassFile();
        //是否需要把生成Class文件保存在本地文件中，这个标识可以从外部进行配置
        //boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction() {
                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;
    }

7、第七步进入generateClassFile()方法，该方法主要生成Class文件。

 private byte[] generateClassFile() {
        //---注意点1----在生成的代理类中加入Object类几个默认方法比如常见的hashCode、equal、toString方法
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        //取出代理类的接口的Class数组
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

        int var3;
        Class var4;
        //----注意点2---遍历代理类的接口的Class数组，将代理类接口中的方法加入生成的代理类中
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            //获得每个接口中定义的所有方法Method对象
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;
            //然后再遍历所有的Method对象，并把它加入到生成的代理类中
            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);
            }
        }
        ...
        try {
        //----注意点3 生成的代理类中加入生成构造器方法generateConstructor----
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();
            ...
       //----注意点4 生成的代理类中加入生成静态初始化块----
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }
         
            ...
            //创建字节数组输出流
            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
            DataOutputStream var14 = new DataOutputStream(var13);

            try {
                ...
                var14.writeShort(this.fields.size());
                var15 = this.fields.iterator();
                //往输出流写入生成代理类Filed字段相关信息
                while(var15.hasNext()) {
                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                    var20.write(var14);
                }

                var14.writeShort(this.methods.size());
                var15 = this.methods.iterator();
                //往输出流写入生成代理类Method方法相关信息
                while(var15.hasNext()) {
                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                    var21.write(var14);
                }

                var14.writeShort(0);
                //返回最终的Class文件的字节数组
                return var13.toByteArray();
            } catch (IOException var9) {
                throw 
                 

                                                                                                                    
                         云服务器
                                             
                         GPU云服务器
                                                                                                                                                 
                                      
                     
                    
                                                                                               Java设计模式之（五）——代理模式
                                                                                                           代理模式
                                                                                                           静态代理模式
                                                                                                           java代理模式用处