Java的代理模式之静态+动态代理

2019-10-10

代理模式

代理模式是java常见设计模式中的一种，他的主要作用是提供一个代理给外部访问，真实执行的对象通过代理间距去执行。比如：

fun main() {
    val proxy = MyProxy(Client())
    proxy.test()
}


interface IProxy {
    fun test()
}

class MyProxy(private val client: IProxy) : IProxy {
    override fun test() {
        client.test()
    }
}

class Client : IProxy {
    override fun test() {
        //正在执行
    }

}

该模式主要是应用在一个类对另外一个类的代理操作，他的缺点是当有多个类(比较多不同类，不同层级等)需要代理的时候，需要编写较多代理类，这时候我们就可以引入动态代理了。

动态代理

他是主要原理是利用反射机制在运行时创建代理类。比如上面的例子，我们使用动态代理的写法是：


fun main() {
    val client = Client()
    val handler = ProxyHandler(client)
    val proxy = Proxy.newProxyInstance(client.javaClass.classLoader, client.javaClass.interfaces, handler) as IProxy
    proxy.test()
}

class ProxyHandler(private val client: IProxy) : InvocationHandler {
    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
        method?.invoke(client)
        return Any()
    }

}

为什么类可以动态生成，参考深入理解Java动态代理，>类的加载阶段分为加载，验证，准备，解析，初始化，其中加载阶段需要完成下面三件事情：
a. 通过一个类的权限定名来获取定义该类的二进制字节流
b. 将字节流所代表的的静态存储接口转化为方法区的运行时数据结构
在内存中生成一个代表这个类的java.lang.class对象，作为方法去这个类的各种数据访问入口。
由于虚拟机规范对这三点要求并不具体，关于第一点有很多的途径：包括zip包获取，网络获取，运行时计算生成，其他文件生成，数据库获取等。

本文就是讨论运行时生成这种方式，主要是关乎两个类，Proxy和InvocationHandler。我们从例子看到Proxy主要作用是构造反射对象，InvocationHandler是处理对象的方法调用。我们就看下这两个类，首先是InvocationHandler，他是一个接口，定义了一个方法invoke

1
2
3

//proxy为代理对象，method是需要执行的方法，args是的参数
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable)

通过这个方法，可以让代理对象调用到真实对象的对应方法。

Proxy类提供一个方法

//loader用于定义动态代理类,interface是动态代理类需要实现的接口，必须是接口，而且数量不能超出65535,而且不能有相互继承，h就是我们的代理类调用正式对象的方法。
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

通过调用这个方法就可以生成一个代理类实现动态代理模式了。

动态代理的原理

他的主要关键点就是生成代理类，我们看下他的源码(注意：Android与纯Java的生成代理类的方式略有不同，这里使用的Android的)，可以参考视频：破解Retrofit

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        //一些check
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        //关键点，获取 代理的class对象，getProxyClass0是生成代理类的地方
        Class<?> cl = getProxyClass0(loader, intfs);
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
            cons.setAccessible(true);
            }
            //反射构造对象
            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);
        }
    }

//缓存并生成代理类的WeakCache
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
 private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        //省略代码
        return proxyClassCache.get(loader, interfaces);
    }

然后我们看WeakCache的get方法

public V get(K key, P parameter) {
        //省略代码
        //关键点
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        //省略代码
    }

可以看到最终是由我们传入WeakCache构造函数的ProxyClassFactory类负责生成的，他的apply方法

@Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            //一些检测，并把有效的接口存入interfaceSet这个set中
            for (Class<?> intf : interfaces) {
                //省略代码
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            //获取生成类的包名proxyPkg以及生成代理类的修饰符，比如生成的类是public的还是final的
            for (Class<?> intf : interfaces) {
                //省略代码
            }

            if (proxyPkg == null) {
                proxyPkg = "";
            }

            {
                // 获取所有方法
                List<Method> methods = getMethods(interfaces);
                Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);
                validateReturnTypes(methods);
                //获取方法抛出异常
                List<Class<?>[]> exceptions = deduplicateAndGetExceptions(methods);
                //转为数组
                Method[] methodsArray = methods.toArray(new Method[methods.size()]);
                Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
                //最终通过native代码生成代理类，通过classLoader载入
                return generateProxy(proxyName, interfaces, loader, methodsArray,exceptionsArray);
            }
        }
    }