Android网络框架系列: Retrofit2.5（2）-阿里云开发者社区

四.源码解析

读源码如何开始呢?

我们先带着问题看源码,Retrofit有几个关键的流程

Retrofit 如何将定义的interface转换成网络请求？
Retrofit的Converter机制是如何实现？
Retrofit的CallAdapter机制是如何实现？

1. 寻找入口

一行一行读,肯定是不可行的,太累了,而且脑容量不够,记不住,合适的读源码方式是从程序入口开始入手。当前功能开始读。

当前请求的入口发生在enqueue, 那么,我们就开始从这个Api入手读源码.

enqueue, 是进入队列的意思,进去查看,竟然是个

  void enqueue(Callback<T> callback);

如果出现类似抽象方法;就得往回看了,因为读不下去了

2. 寻找接口实现

所以我们往上面找,上面的Api是 enqueue,去找相关接口实现,找了半天,爱哭,接口实现是GithubService

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<MicroKibacoRepo>> listRepos(@Path("user") String user);
}

而GithubService.java是我自己创建的,怎么办呢? 继续往回看,找呀找, 找到了Retrofit的初始化方法 create,整个源码我就不翻出来了,翻一翻关键的部分,其中需要讲述的APi有:

eagerlyValidateMethods
newProxyInstance
Platform
invoke
invokeDefaultMethod

  public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    return (T) 
    // --------动态代理--------
    Proxy.newProxyInstance(
    //  提供动态类的实例
    service.getClassLoader(), 
    // 获取 GithubService 的实例,获取需要动态代理类的接口,在 retrofit.create 传入
    new Class<?>[] { service },
    // 
        new InvocationHandler() {
         // 判断接口平台,是JDK 7.0/8.0 或者 Android/IOS
          private final Platform platform = Platform.get();
          private final Object[] emptyArgs = new Object[0];
          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
            // 如果这个方法不是直接声明的,那么就直接调用了,兼容性,保护性,不至于越权
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
             // java 8 开始,接口运行有默认的方法实现了
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }
    static <T> void validateServiceInterface(Class<T> service) {
     // 1. 验证 GitHubService 是否为一个接口
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }
     // 2.验证 GitHubService 是否继承其他接口,只接受原生接口
    if (service.getInterfaces().length > 0) {
      throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
    }
  }
  // 3. 在被初始化的时候,是有一个初始化过程,会去读注解,中间是有耗时的,分布式加载网络请求, validateEagerly 是方便调试的
    private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        loadServiceMethod(method);
      }
    }
  }

Platform.java 看一下相关实现,里面包含两个平台一个是 Java8 还有一个 Android,这个APi主要是平台标识,知道就行了,没什么好说的

    private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
      // Android 平台
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
       // Java8 平台
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

loadServiceMethod 里面也没有 invoke,我们通过 parseAnnotations 去找一下invoke试试看能否找到,

  ServiceMethod<?> loadServiceMethod(Method method) {
    ServiceMethod<?> result = serviceMethodCache.get(method);
    if (result != null) return result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

ServiceMethod.java里面,不过也是一个抽象方法 ,于是我们往回看 parseAnnotations,看里面是否有 invoke 的逻辑实现,找到了,好家伙,parseAnnotations是ServiceMethod子类HttpServiceMethod实现方法,而HttpServiceMethod一定有invoke实现

abstract class ServiceMethod<T> {
  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
// 通过 parseAnnotations 去寻找 invoke实现
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }
  abstract T invoke(Object[] args);
}

不用说,我直接在HttpServiceMethod.java, ctr + f 搜,便搜到了invoke,原来底层真是通过OKHttp实现的:

final class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
 // ----为了避免浪费篇幅,省略若干无用代码----
 @Override ReturnT invoke(Object[] args) {
    return callAdapter.adapt(
        new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
  }
}

上面我说过,看到抽象方法,往回看 ,所以我们来看 okHttpCall,OKHttpCall实现了Call接口 ,重点说一下一下方法:

createRawCall

 // OKhttp3的Call帮助Retrofit实现网络请求的Call
  private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

call.enqueue

     call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
      // response 结果交给 Retrofit 使用
        Response<T> response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          throwIfFatal(e);
          callFailure(e);
          return;
        }
        try {
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
      @Override public void onFailure(okhttp3.Call call, IOException e) {
        callFailure(e);
      }
      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }

什么是动态代理?

动态代理是创建一个对象,这个对象传入一个接口并且帮你实现每一个接口的每一个方法,并且这每一个接口的每一个方法都会指向每一个接口每一个方法的invoke方法。

callAdapter

HttpServiceMethod.java里面的构造方法, 我们找到了 CallAdapter,然后去里面查看是通过 createCallAdapter返回的

  private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
      Retrofit retrofit, Method method) {
    Type returnType = method.getGenericReturnType();
    Annotation[] annotations = method.getAnnotations();
    try {
      // CallAdapter 创建
      return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
    } catch (RuntimeException e) { // Wide exception range because factories are user code.
      throw methodError(method, e, "Unable to create call adapter for %s", returnType);
    }
  }

进入 Retrofit.java 查看一下:

  public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }
    public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
 // 通过 callAdapterFactories 获取 callAdapter
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
 // ----为了避免浪费篇幅,省略若干无用代码----
  }

callAdaperFactory是通过 Retrofit 的 build 方法构建而来.

  public Retrofit build() {
      converterFactories.addAll(this.converterFactories);
      converterFactories.addAll(platform.defaultConverterFactories());
      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }

我们看到 callAdaperFactory 通过 addAll 一次性添加过来,所以有我们看一下defaultCallAdapterFactories方法.

    @Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
        @Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      ExecutorCallAdapterFactory executorFactory = new ExecutorCallAdapterFactory(callbackExecutor);
      return Build.VERSION.SDK_INT >= 24
        ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
        : singletonList(executorFactory);
    }

然后我们再看一下 ExecutorCallAdapterFactory

五. 面试题分享

Retrofit请求参数说明

Retrofit中的设计模式

1. 建造者模式

Retrofit对象的创建、ServiceMethod对象创建都使用Build模式，将复杂对象的创建和表示分离，调用者不需要知道复杂的创建过程，使用Build的相关方法进行配置创建对象。

2. 外观模式

Retrofit对外提供了统一的调度，屏蔽了内部的实现，使得使用该网络库简单便捷。门面模式: 提供一个统一的接口去访问多个子系统的多个不同的接口，它为子系统中的一组接口提供一个统一的高层接口。使用子系统更容易使用

3. 动态代理模式

通过动态代理的方式，当调用Retrofit的create()方法时，会进行动态代理监听。当执行具体的接口方法时，会回调InvocationHandler。通过反射解析method的标注及参数，生成ServiceMethod对象。

4. 静态代理模式

Android平台默认的适配器ExecutorCallbackCall，采用静态代理的模式。具体的实现delegate为OkHttpCall。

5. 工厂模式

Converter及CallAdapter的创建都采用了工厂模式进行创建。

6. 适配器模式

CallAdapter的adapt采用了适配器模式，使得interface的返回对象可以动态扩展，增强了灵活性

CallAdapter的种类

Converter种类

Retrofit支持多种数据解析方式，使用时需要在Gradle添加依赖。

Android网络框架系列: Retrofit2.5（2）