h(InvocationHandler): 代理攔截器接口，一般需要使用子類去實(shí)現(xiàn)該接口或匿名類去實(shí)現(xiàn)

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<);
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
       
        final Class<);//將interfaces的Class數(shù)組clone一份副本，賦值給intfs
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {//檢查創(chuàng)建一個(gè)新的代理類需要權(quán)限
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //注意點(diǎn)1: getProxyClass0方法拿到代理類的Class對(duì)象實(shí)例cl
         //注意傳入的參數(shù)就是從外部傳入的loader(被代理類的類加載器)、intfs(被代理類實(shí)現(xiàn)所接口的Class[]的副本)
        Class<);/*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            
            //注意點(diǎn)2: 拿到cl實(shí)例后，就通過反射機(jī)制創(chuàng)建代理類實(shí)例
            final Constructor<);//先拿到代理類的構(gòu)造器Constructor實(shí)例cons
            final InvocationHandler ih = h;
            //檢查代理類構(gòu)造器是否是公有的public權(quán)限, 不是就會(huì)通過AccessController去修改訪問權(quán)限以致于可以創(chuàng)建代理類實(shí)例
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);//將訪問權(quán)限設(shè)置為可訪問的
                        return null;
                    }
                });
            }
            //注意點(diǎn)3: 拿到構(gòu)造器實(shí)例cons后，就到了最為關(guān)鍵的也就是最后一步，創(chuàng)建代理類實(shí)例。
            //但是需要注意的是構(gòu)造器反射傳入的參數(shù)是h，也就是傳入的InvocationHandler的實(shí)例，也可以進(jìn)一步推論生成的代理類中存在以InvocationHandler為參數(shù)的構(gòu)造器。
            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三個(gè)參數(shù)，先將interfacesclone一份副本保存在intfs中，然后檢查創(chuàng)建一個(gè)新的代理類所需要的權(quán)限，接著到了我們第一個(gè)注意點(diǎn)1，就是通過getProxyClass0方法(需要傳入loader和intfs參數(shù))獲得代理類的Class對(duì)象實(shí)例。拿到了代理類實(shí)例后，我們就通過反射的機(jī)制創(chuàng)建代理類實(shí)例；

到了我們的注意點(diǎn)二，通過代理類Class對(duì)象cl獲得構(gòu)造器對(duì)象cons，并檢查構(gòu)造器對(duì)象是否是public,否則就強(qiáng)行修改訪問權(quán)限；

最后到了注意點(diǎn)三，通過cons.newInstance創(chuàng)建代理類對(duì)象，并且構(gòu)造器反射中傳入h(InvocationHandler對(duì)象)，說明我們可以推斷一下生成的代理類中存在以InvocationHandler為參數(shù)的構(gòu)造器。

3、第三步進(jìn)入getProxyClass0方法，傳入的參數(shù)loader和intfs，在該方法內(nèi)部會(huì)委托給proxyClassCache的get方法，如果給定的類加載器中定義的代理類實(shí)現(xiàn)了給定的接口，直接返回緩存中的副本，否則它將通過ProxyClassFactory創(chuàng)建代理類.

    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
        //請(qǐng)注意上面那段英文注釋: 如果給定的類加載器中定義的代理類實(shí)現(xiàn)了給定的接口，
        //那么就會(huì)直接返回緩存中的副本，否則它將通過ProxyClassFactory創(chuàng)建代理類
        //注意點(diǎn)1: proxyClassCache；注意點(diǎn)2: ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

4、第四步proxyClassCache的介紹和定義, 請(qǐng)注意創(chuàng)建proxyClassCache傳入的構(gòu)造器兩個(gè)參數(shù)分別是: KeyFactory和ProxyClassFactory

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

proxyClassCache是一個(gè)WeakCache對(duì)象，WeakCache中的K表示key值，P代表參數(shù)，V代表存儲(chǔ)的值。此類用于緩存(key, sub-key) -> value鍵值對(duì)。內(nèi)部具體實(shí)現(xiàn)是借助了ConcurentMap>>,Supplier是一個(gè)接口，就一個(gè)get方法用于獲得值，不過是泛型V的包裝類，第一個(gè)Object就是key（這里表達(dá)式不用泛型K是因?yàn)閗ey值可以為null)，第二個(gè)就是sub-key，那么它對(duì)應(yīng)著什么呢);P呢，這就需要引出另外一個(gè)函數(shù)接口BiFunction,該接口內(nèi)部存在R apply(T t, U u)方法，這個(gè)方法意思就是根據(jù)傳入兩個(gè)泛型T和U的值經(jīng)過一定計(jì)算得到泛型R的值。在WeakCache類中存在兩個(gè)BiFunction對(duì)象:

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 {
        //根據(jù)K,P得到sub-key算法
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        //根據(jù)K,P得到value算法
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }
    ...
}    

在WeakCahe類中只有一個(gè)核心get方法,里面包含了整個(gè)緩存的邏輯，注意我們獲取代理類Class對(duì)象，就是通過proxyClassCache.get(loader, interfaces);實(shí)際上就是調(diào)用WeakCache中的get方法.

//K泛型是一級(jí)map的緩存key, P泛型傳入的參數(shù)，分別對(duì)應(yīng)外部傳入的 loader和 interfaces
public V get(K key, P parameter) {
        ...
        //通過傳入一級(jí)map的key，通過CacheKey拿到最終
        Object cacheKey = CacheKey.valueOf(key, refQueue);
        // 懶初始化cacheKey對(duì)應(yīng)的二級(jí)valuesMap, 如果valuesMap為空，就會(huì)新創(chuàng)建一個(gè)空的ConcurrentMap的valueMap，put到一級(jí)緩存map中
        ConcurrentMap> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
        //如果valuesMap為空，就會(huì)新創(chuàng)建一個(gè)空的ConcurrentMap的valueMap
            ConcurrentMap> oldValuesMap = map.putIfAbsent(cacheKey,valuesMap = new ConcurrentHashMap<>());
            //如果內(nèi)部已經(jīng)存在原來的oldValuesMap直接用它
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

 //------注意點(diǎn)1: subKeyFactory.apply(key, parameter)-----
        //根據(jù)傳入的一級(jí)map的key和參數(shù)parameter，通過subKeyFactory中的apply方法獲得sub-key,
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        //然后通過我們的sub-key,從二級(jí)緩存的valuesMap中取的supplier對(duì)象
        Supplier supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                //supplier這個(gè)對(duì)象可能是Factory或CacheValue對(duì)象，
                //那么也就是supplier.get()方法可能是調(diào)用了Factory中的get方法或CacheValue中的get方法
//--------注意點(diǎn)2: supplier.get()-----            
                V value = supplier.get();
                //如果value不為空就返回value，結(jié)束整個(gè)get方法調(diào)用
                if (value != null) {
                    return value;
                }
            }
            //如果緩存中沒有supplier對(duì)象
            //或者supplier中g(shù)et返回是null
            //或者Factory對(duì)象沒有在CacheValue中被成功創(chuàng)建
            
            //factory為null，就會(huì)創(chuàng)建一個(gè)新的Factory實(shí)例
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            //supplier為null
            if (supplier == null) {
                //根據(jù)新創(chuàng)建的factory和subKey拿到supplier對(duì)象，如果valuesMap中存在subKey, factory鍵值對(duì)，就返回已經(jīng)存在的值，沒有直接返回null
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                 //如果拿到supplier為null,supplier就變?yōu)榱薴actory,這就是前面說supplier為一個(gè)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就是一個(gè)WeakCache實(shí)例對(duì)象，它有兩個(gè)構(gòu)造器參數(shù)subKeyFactory和valueFactory,創(chuàng)建proxyClassCache實(shí)例對(duì)應(yīng)傳入的是proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory())中的KeyFactory和ProxyClassFactory.

然后在WeakCache內(nèi)部存在二級(jí)ConcurrentHashMap, 一級(jí)map的key就是get方法傳入的key, 通過這個(gè)key拿到cacheKey,從而拿到對(duì)應(yīng)的valuesMap二級(jí)map。

然后又通過根據(jù)傳入的一級(jí)map的key和參數(shù)parameter，subKeyFactory中的apply方法獲得sub-key,通過sub-key拿到二級(jí)map中存儲(chǔ)的Supplier對(duì)象，它可能是一個(gè)CacheValue也有可能是一個(gè)Factory,

最終通過Factory的get方法拿到實(shí)際的值。

對(duì)于上述有兩個(gè)核心注意點(diǎn)

注意點(diǎn)1----->獲取subKey過程: 通過subKeyFactory.apply(key,parameter)拿到sub-key

//weakCache調(diào)用處: 
 Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
 //KeyFactory的定義
    private static final class KeyFactory
        implements BiFunction

注意點(diǎn)2----> supplier.get()獲取value的過程:

我們都知道supplier對(duì)應(yīng)的可以是Factory對(duì)象，也就是最后會(huì)調(diào)用Factory中的get方法。

  @Override
        public synchronized V get() { // serialize access
            // 再一次檢查supplier，如果傳入從valuesMap拿到的不等于當(dāng)前Factory對(duì)象，因?yàn)樗赡芤呀?jīng)變成CacheValue了，那就直接返回null
            Supplier supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }
            
            //創(chuàng)建一個(gè)新的value
            V value = null;
            try {
               //注意點(diǎn)出現(xiàn)，value最終會(huì)通過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包裝成一個(gè)CacheValue
            CacheValue cacheValue = new CacheValue<>(value);

            // 嘗試把valuesMap中的對(duì)應(yīng)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是啥嗎？沒錯(cuò)它就是ProxyClassFactory也就是最終定位到了ProxyClassFactory中的apply方法。這也就是為什么之前說如果緩存中有直接從緩存中返回緩存的副本，沒有就在ProxyClassFactory中創(chuàng)建代理對(duì)象。

5、第五步進(jìn)入ProxyClassFactory中的apply方法進(jìn)行探究，這是創(chuàng)建新的代理類Class對(duì)象唯一來源。

    private static final class ProxyClassFactory
        implements BiFunction

再重新梳理一下ProxyClassFactory中的apply中的邏輯，首先做一些接口驗(yàn)證操作，然后通過ProxyGenerator.generateProxyClass生成確定的代理類Class文件的byte數(shù)組,最后通過defineClass0方法傳入被代理類的類加載器、代理類唯一名稱、生成的代理類文件反序列化成一個(gè)代理類的Class對(duì)象

6、第六步進(jìn)入ProxyGenerator中的generateProxyClass方法進(jìn)行探究，主要通過它來生成代理類Class文件。generateProxyClass方法傳入的參數(shù)主要有: proxyName(唯一代理類名稱), interfaces(需要代理的接口Class數(shù)組), accessFlags(訪問權(quán)限標(biāo)識(shí))

    public static byte[] generateProxyClass(final String var0, Class<);int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //-----注意點(diǎn)----調(diào)用ProxyGenerator中的generateClassFile方法
        final byte[] var4 = var3.generateClassFile();
        //是否需要把生成Class文件保存在本地文件中，這個(gè)標(biāo)識(shí)可以從外部進(jìn)行配置
        //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、第七步進(jìn)入generateClassFile()方法，該方法主要生成Class文件。

 private byte[] generateClassFile() {
        //---注意點(diǎn)1----在生成的代理類中加入Object類幾個(gè)默認(rèn)方法比如常見的hashCode、equal、toString方法
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        //取出代理類的接口的Class數(shù)組
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

        int var3;
        Class var4;
        //----注意點(diǎn)2---遍歷代理類的接口的Class數(shù)組，將代理類接口中的方法加入生成的代理類中
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            //獲得每個(gè)接口中定義的所有方法Method對(duì)象
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;
            //然后再遍歷所有的Method對(duì)象，并把它加入到生成的代理類中
            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);
            }
        }
        ...
        try {
        //----注意點(diǎn)3 生成的代理類中加入生成構(gòu)造器方法generateConstructor----
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();
            ...
       //----注意點(diǎn)4 生成的代理類中加入生成靜態(tài)初始化塊----
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }
         
            ...
            //創(chuàng)建字節(jié)數(shù)組輸出流
            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
            DataOutputStream var14 = new DataOutputStream(var13);

            try {
                ...
                var14.writeShort(this.fields.size());
                var15 = this.fields.iterator();
                //往輸出流寫入生成代理類Filed字段相關(guān)信息
                while(var15.hasNext()) {
                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                    var20.write(var14);
                }

                var14.writeShort(this.methods.size());
                var15 = this.methods.iterator();
                //往輸出流寫入生成代理類Method方法相關(guān)信息
                while(var15.hasNext()) {
                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                    var21.write(var14);
                }

                var14.writeShort(0);
                //返回最終的Class文件的字節(jié)數(shù)組
                return var13.toByteArray();
            } catch (IOException var9) {
                throw 
                 

                                                                                                                    
                         GPU云服務(wù)器
                                             
                         云服務(wù)器
                                                                                                                                                 
                                      
                     
                    
                                                                                               Java設(shè)計(jì)模式之（五）——代理模式
                                                                                                           代理模式
                                                                                                           靜態(tài)代理模式
                                                                                                           java代理模式用處