一、前言

在 Retrofit 知识梳理(1) - 流程分析 中，我们对于Retrofit的流程进行了简单的分析，大家谈到Retrofit的时候，往往也会提到动态代理，今天这篇文章，我们就来一起研究一下这一过程的内部实现。

二、内部实现

涉及到动态代理的部分为下面这两句：

//1.返回代理对象
GitHubService service = retrofit.create(GitHubService.class);
//2.调用该代理对象的接口方法
Call<ResponseBody> call = service.listRepos("octocat");

2.1 生成代理对象

第一步的目的就是通过Retrofit的create方法，根据GithubService这个接口所声明的方法来得到一个代理对象：

  @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  public <T> T create(final Class<T> service) {
    //...忽略
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, Object[] args)
              throws Throwable {
            //...

            //1.得到ServiceMethod对象.
            ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);

            //2.通过serviceMethod和args来构建OkHttpCall对象，args就是“octocat”.
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);

            //3.其实就是调用ExecutorCallbackCall.adapt方法.
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

可以看到，这里面最核心的方法就是：

Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

以上三个形参的含义为：

• ClassLoader：表示由哪一个ClassLoader来加载这个代理类。
• Class<?>[]：一个interface对象的数组，表明将要给被代理的对象提供一组什么样的接口来访问，这个可能比较抽象。从上面的例子来说，我们传入的是GitHubService.class，而它是一个接口，其方法包含有listRepos，那么Proxy.newProxyInstance所生成的代理对象也会有这个接口listRepos，所以我们才能在第二步当中调用它的方法。
• InvocationHandler：当调用代理对象的接口方法时，最终会回调到这个InvocationHandler对象的invoke方法中。

在对形参进行了简要的介绍之后，我们再来看一下其内部的实现：

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
        if (h == null) {
            throw new NullPointerException();
        }
        //1.根据前两个参数创建一个代理类.
        Class<?> cl = getProxyClass0(loader, interfaces);
        try {
            //2.实例化该代理类，并将第三个参数作为成员变量.
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            return newInstance(cons, h);
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

可以看到，生成代理对象又可以细分为两步：

• 根据类加载器和声明的接口，首先创建一个代理类，该代理类继承于Proxy，并且它实现了interfaces数组中所声明的接口
• 实例化第一步中创建的代理类，并将第三个参数所对象的InvocationHandler传入作为其成员变量h。

2.1.1 创建代理类

创建代理类的代码比较多，也就是对应于getProxyClass0方法：

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        //最终要创建的代理类
        Class<?> proxyClass = null;
        String[] interfaceNames = new String[interfaces.length];
        Set<Class<?>> interfaceSet = new HashSet<>();
        //1.遍历传入的接口数组
        for (int i = 0; i < interfaces.length; i++) {
            String interfaceName = interfaces[i].getName();
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(interfaceName, false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != interfaces[i]) {
                throw new IllegalArgumentException(
                    interfaces[i] + " is not visible from class loader");
            }
            //必须是接口
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            //不允许重复
            if (interfaceSet.contains(interfaceClass)) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
            interfaceSet.add(interfaceClass);

            interfaceNames[i] = interfaceName;
        }
        //2.如果之前已经生成过，那么就不需要再去生成.
        List<String> key = Arrays.asList(interfaceNames);
        Map<List<String>, Object> cache;
        synchronized (loaderToCache) {
            cache = loaderToCache.get(loader);
            if (cache == null) {
                cache = new HashMap<>();
                loaderToCache.put(loader, cache);
            }
        }
        synchronized (cache) {
            do {
                Object value = cache.get(key);
                if (value instanceof Reference) {
                    proxyClass = (Class<?>) ((Reference) value).get();
                }
                if (proxyClass != null) {
                    return proxyClass;
                } else if (value == pendingGenerationMarker) {
                    try {
                        cache.wait();
                    } catch (InterruptedException e) {
                    }
                    continue;
                } else {
                    cache.put(key, pendingGenerationMarker);
                    break;
                }
            } while (true);
        }
        //3.真正的产生操作.
        try {
            String proxyPkg = null;
            for (int i = 0; i < interfaces.length; i++) {
                int flags = interfaces[i].getModifiers();
                if (!Modifier.isPublic(flags)) {
                    String name = interfaces[i].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) {
                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()][]);

                final long num;
                synchronized (nextUniqueNumberLock) {
                    num = nextUniqueNumber++;
                }
                String proxyName = proxyPkg + proxyClassNamePrefix + num;

                proxyClass = generateProxy(proxyName, interfaces, loader, methodsArray,
                        exceptionsArray);
            }

            proxyClasses.put(proxyClass, null);

        } finally {
            synchronized (cache) {
                if (proxyClass != null) {
                    cache.put(key, new WeakReference<Class<?>>(proxyClass));
                } else {
                    cache.remove(key);
                }
                cache.notifyAll();
            }
        }
        return proxyClass;
    }

2.1.2 实例化代理类

当创建完代理类之后，接下来就是进行实例化，这里实例化调用的是参数为InvocationHandler的构造函数：

protected Proxy(InvocationHandler h) {
     this.h = h;
}

也就是说，最后通过Proxy.newProxyInstance返回的代理类实例，其内部的InvocationHandler对象，就是通过第三个参数所传入的对象，而当我们调用代理类所声明的方法时，最终会调用到该InvocationHandler的invoke方法，通过invoke方法的参数，我们又可以区分具体调用的方法。

2.2 调用代理对象的接口方法

通过第一步，我们就可以得到一个代理对象，而当我们调用这个代理对象的接口方法之后，该代理对象又会回调它的基类Proxy中的这个方法：

private static Object invoke(Proxy proxy, Method method, Object[] args) throws Throwable {
    InvocationHandler h = proxy.h;
    return h.invoke(proxy, method, args);
}

invoke的三个参数解释为：

• Proxy：代理对象实例，也就是上面在2.1中所返回的实例对象。
• Method：代理对象所被调用的对应接口方法。
• Object[]：接口方法所传入的参数。

三、示例

在第二节当中，我们对于源码进行了简单的走读，下面，我们以一个具体的示例来强化一下认识：

3.1 实例代码

** (1) 接口类**

对应于我们在上面所定义的GitHubService.java

public interface Subject {
    public CallObject getCallObject(String args);
}

(2) 请求类

对应于最终发起网络请求的类：

public class CallObject {

    private String args;

    public CallObject(String args) {
        this.args = args;
    }

    public void call() {
        Log.d("simulate", "call args=" + args);
    }
}

(3) 模拟代理过程

public class Simulator {

    public static void simulate() {
        Class mClass = Subject.class;
        Subject proxySubject = (Subject) Proxy.newProxyInstance(
                mClass.getClassLoader(),
                new Class[]{ mClass },
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String modifiedArgs = (String) args[0] + " after modified";
                        Log.d("simulate", "invoke");
                        return new CallObject(modifiedArgs);
                    }

                });
        Log.d("simulate", "createProxy finished");
        CallObject callObject = proxySubject.getCallObject("args");
        Log.d("simulate", "getCallObject finished");
        callObject.call();
    }
}

3.2 示例详解

按照我们之前的分析，在上面的模拟过程中的第三步，会返回一个代理类，我们来看一下这个代理类具体是什么：

通过断点，我们可以看到它不再是我们之前声明的接口，而是一个代理类$Proxy，它的内部有一个InvocationHandler的实现类h，也就是我们通过newProxyInstance传入的实例。

之后，我们调用该代理类的接口方法，那么上面的h对象的invoke方法的就被回调，我们可以从中获取到传入的参数、注解等信息，通过该信息，我们构造出一个CallObject对象。

最后，再通过这个CallObject发起请求：

四、总结

普通的代理模式，往往会在InvocationHandler的实现类中包含一个接口的实现类，当该InvocationHandler的invoke方法被回调时，再调用他所包含的接口实现类进行操作，并在之前和之后进行一些处理的操作。对于标准的动态代理，可以参考 这篇文章。

Retrofit用到的动态代理，并不能算是严格的代理模式。它只是利用了代理模式中invoke这一中转过程，来解析接口中的注解声明，然后通过这些注解声明来创建一个请求类，最终再通过该请求类来发起请求。

也就是说，Retrofit所关注的重点在于如何创建invoke方法所返回的实例，而普通的代理模式则在于控制接口实现类的访问。