Java中代理

interface Interface{
    void dosomething();
    void dosomethingelse(String args);
}
class RealObject implements Interface{         //被代理的类

    @Override
    public void dosomething() {
        System.out.println("do something!!!");
    }

    @Override
    public void dosomethingelse(String args) {
        System.out.println("do something else:"+args);
    }
}
class CommonProxy implements Interface{　　　　　　　　 //代理类
    private Interface proxied;　　　　　　　　　　　　   //这个接口应该是指向被代理对象的实例

    public CommonProxy(Interface proxied) {
        this.proxied = proxied;
    }

    @Override
    public void dosomething() {
       proxied.dosomething();　　　　　　　　//直接调用被代理对象中的方法实现代理功能　　　　
    }

    @Override
    public void dosomethingelse(String args) {
        proxied.dosomethingelse(args);
    }
}
public class SimpleProxyDemo{
    public  static  void consumer(Interface inter){
        inter.dosomethingelse("booo");
        inter.dosomething();
    }
    
    public static void main(String[] args) {
        consumer(new CommonProxy(new RealObject()));
    }
}

class DynamicProxyHandler  implements InvocationHandler {
    Object proxied;

    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(proxied,args);
    }
}

public class DynamicProxyDemo{
    public static void main(String[] args) {
        RealObject realObject=new RealObject();
        Interface proxy = (Interface) Proxy
                .newProxyInstance(Interface.class.getClassLoader(), new Class[]{Interface.class}, new DynamicProxyHandler(new RealObject()));
        proxy.dosomethingelse("shei");
        proxy.dosomething();
    }
}

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);        //首先判断传递的调用处理器是不是空，否则就抛出空指针异常

        final Class<?>[] intfs = interfaces.clone();      //使用clone()函数实现初始化接口的Class对象数组。
        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);         //生成代理对象的Class对象实例。

/*
         * 借助调用处理器生成对应的代理类
         */
        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}); //使用代理类的构造函数和InvocationHandler实例化一个代理对象，最后返回代理对象
        } 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);
        }
    }

public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);

        expungeStaleEntries();

        Object cacheKey = CacheKey.valueOf(key, refQueue);

        // 根据由类加载器生成的一级缓存的key向缓存中取对应的concurrentmap值
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {                               //如果没有valuesmap就创建一对放进去，
　　　　　　　　　　　　　　　　　　　　　　　　　　　//只不过里面的concurrentmap还没有什么东西（二次缓存的key和工厂）
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // 运行到这里，生成二次缓存的key（使用classloader和interface生成），
        // 取出里面对应的代理类supplier
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // supplier可能是个工厂也可能是缓存，由他提供对应的代理类Class对象
                V value = supplier.get();         //注意这一步是生成代理Class对象的关键，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//如果没有他就会在get()函数中生成
                if (value != null) {
                    return value;
                }
            }
            // 否则没有supplier，由下面的语句生成对应的supplier
            // 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 = new Factory(key, parameter, subKey, valuesMap);　//这就是supplier　　　
            }

            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);    //将生成的factory放进缓存，方便下次使用。
                if (supplier == null) {            
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//supplier只是Factory的父接口
                if (valuesMap.replace(subKey, supplier, factory)) {   //有supplier但是经过get()方法得到的是空，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//及所以这里使用新的factory替换之前的supplier
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // 否则就使用现在的supplier重试
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

 public synchronized V get() { // serialize access
            // 根据二级的key查询得到factory对象，检查拿到的和现在的相比是否一致，
　　　　　　　　//factory中有点像循环引用，因为factory对象中的ConCurrentMap中含有当前对象的引用
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                // something changed while we were waiting:
                // might be that we were replaced by a CacheValue
                // or were removed because of failure ->
                // return null to signal WeakCache.get() to retry
                // the loop
                return null;
            }
            // else still us (supplier == this)

            // create new value
            V value = null;
            try {
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));  //生成对应的代理class对象，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//valueFactory就是上面ProxyClassCache的实现类
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            // the only path to reach here is with non-null value
            assert value != null;

            // wrap value with CacheValue (WeakReference)
            CacheValue<V> cacheValue = new CacheValue<>(value);

            // put into reverseMap
            reverseMap.put(cacheValue, Boolean.TRUE);

            // try replacing us with CacheValue (this should always succeed)
            if (!valuesMap.replace(subKey, this, cacheValue)) {
                throw new AssertionError("Should not reach here");
            }

            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }
    }

    private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 代理类的名字前缀
        private static final String proxyClassNamePrefix = "$Proxy";

        // 为下一个代理类产生独一无二的标志数，放在类的名字中
        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) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                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;

            /*
             * 判断是不是所有的非公有接口是不是在同一个包下，如果没有就会抛出异常
             */
            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) {
                // 如果没有非公有的interface就使用sun公司自己默认的包
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * 为代理类生成名字   类似  $proxy0
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 由proxygenerator生成对应的Class类的字节形式，使用我们给的类加载器加载对应的类。
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,     //native 方法
                                    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());
            }
        }
    }

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);//46在ASCII码中就是  “.”
                        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");//这个就是代理类的名字 $proxy0.class
                        } else {
                            var2 = Paths.get(var0 + ".class");//var2是代理类的全路径名
                        }

                        Files.write(var2, var4, new OpenOption[0]);//最后写进对应的文件。
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }

        return var4;
    }