带你一起探究Retrofit 源码，让你不再畏惧Retrofit的面试提问

带你一起探究Retrofit 源码，让你不再畏惧Retrofit的面试提问

Retrofit，OkHttp，Okio Square 安卓平台网络层三板斧源码学习。Retrofit 是 Square 安卓平台网络层三板斧最后一个项目，Retrofit 依赖 OkHttp 。Retrofit 让 http 网络请求更加清晰。

使用方式

一、声明一个接口，并用接口描述 request

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

二、方法上面的注释表示 request 的接口名 ,方法的返回类型就是 http 请求的返回值，方法的参数就是 http 的请求参数。

创建一个 Retrofit 客户端

 Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.github.com/") .build(); GitHubService service = retrofit.create(GitHubService.class); 

Retrofit 创建的时候指定了 request 的接口地址，然后调用 retrofit.create 方法创建一个 GitHubService 实例。

三、发起网络请求

 Call<List<Repo>> repos = service.listRepos("octocat"); repos.execute().body()

上面的例子可以看到，retrofit.create() 方法会创建一个 GitHubService 实例，但是 GitHubService 本身是一个接口。为了了解 retrofit.create() 方法，我们先看下 Retrofit 的创建过程。

Retrofit 创建 Service 实例

创建 Retrofit 对象。

Retrofit 和 OkHttp 一样都是使用构建者模式创建对象。先看下 Retrofit.Builder 的 build() 方法。

public Retrofit build() {        if (baseUrl == null) {            throw new IllegalStateException("Base URL required.");        }        okhttp3.Call.Factory callFactory = this.callFactory;        if (callFactory == null) {            callFactory = new OkHttpClient();        }        Executor callbackExecutor = this.callbackExecutor;        if (callbackExecutor == null) {            callbackExecutor = platform.defaultCallbackExecutor();        }        // Make a defensive copy of the adapters and add the default Call adapter.        List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);        adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));        // Make a defensive copy of the converters.        List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);        return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,                callbackExecutor, validateEagerly);    }

创建 Retrofit 的时候需要传递一下几个参数

• callFactory 用来创建一个实现了 okhttp3.Call.Factory 的对象，如果没有设置，默认为 OkHttpClient。

• baseUrl 网络接口的地址。-converterFactories 用来把服务器返回的数据转换为对象。

• adapterFactories 用来发起网络请求。

• callbackExecutor 是一个调度器，用来接收返回的数据，在 Android 上默认是封装了 handler 的 MainThreadExecutor

• validateEagerly 是一个开关，如果为 true 会缓存创建的 ServiceMethod 。

我们再来看一下retrofit.create()源码

public <T> T create(final Class<T> service) {   Utils.validateServiceInterface(service);   if (validateEagerly) {       eagerlyValidateMethods(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, @Nullable Object[] args)                       throws Throwable {                   // If the method is a method from Object then defer to normal invocation.                   if (method.getDeclaringClass() == Object.class) {                       return method.invoke(this, args);                   }                   if (platform.isDefaultMethod(method)) {                       return platform.invokeDefaultMethod(method, service, proxy, args);                   }                   ServiceMethod<Object, Object> serviceMethod =                           (ServiceMethod<Object, Object>) loadServiceMethod(method);                   OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);                   return serviceMethod.callAdapter.adapt(okHttpCall);               }           });}

这里用到了一个公共技术点之 Java 动态代理，create 方法传入一个 Class ，这个 Class 对象就是上文的 GitHubService 的 Class 。

GitHubService 的方法是由 InvocationHandler 代理实现的，重点看三行代码

......ServiceMethod<Object, Object> serviceMethod =(ServiceMethod<Object, Object>) loadServiceMethod(method);OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);return serviceMethod.callAdapter.adapt(okHttpCall);

第一行 loadServiceMethod(method)

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

这里创建了一个 ServiceMethod 对象。

第二行 new OkHttpCall<>(serviceMethod, args)

OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {    this.serviceMethod = serviceMethod;    this.args = args;}

创建了一个 OkHttpCall ，serviceMethod 和 args 是 OkHttpCall 的成员函数。

所以，

第三行 serviceMethod.callAdapter.adapt(okHttpCall)

这里需要明白 serviceMethod.callAdapter 是怎么来的

1. 在 ServiceMethod.Builder.build() 中调用 createCallAdapter()2. 在 createCallAdapter() 中会找到    (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations)3. 在 callAdapter() 中调用 nextCallAdapter4. nextCallAdapter 会遍历 adapterFactories 返回一个 CallAdapter。

这里再回头看下 adapterFactories Retrofit.Builder.build() 方法中

List<CallAdapter.Factory> adapterFactories =     new ArrayList<>(this.adapterFactories);adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

而在 Retrofit.nextCallAdapter() 中

int start = adapterFactories.indexOf(skipPast) + 1;for (int i = start, count = adapterFactories.size(); i < count; i++) {   CallAdapter<?, ?> adapter = adapterFactories.get(i).get(returnType, annotations, this);    if (adapter != null) {        return adapter;    }}

如果没有设置 AdapterFactory 将会使用一个默认的 AdapterFactory

CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {    if (callbackExecutor != null) {        return new ExecutorCallAdapterFactory(callbackExecutor);    }    return DefaultCallAdapterFactory.INSTANCE;}

所以如果我们设置了一个 RxJavaCallAdapterFactory，就会返回 RxJavaCallAdapterFactory。

整个创建Retrofit的过程流程为：

发起网络请求

通过 retrofit.create() 我们可以知道，retrofit.create() 返回的是一个代理对象InvocationHandler ，那么在执行

Call<List> repos = service.listRepos("octocat");方法时，调用的实际上是 callAdapter.adapt(okHttpCall)，以 DefaultCallAdapterFactory 为例

@Overridepublic CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {    if (getRawType(returnType) != Call.class) {        return null;    }    final Type responseType = Utils.getCallResponseType(returnType);    return new CallAdapter<Object, Call<?>>() {        @Override        public Type responseType() {            return responseType;        }        @Override        public Call<Object> adapt(Call<Object> call) {            return call;        }    };}

结合 retrofit.create() 方法可以得知这里返回的是一个 OkHttpCall 对象。

接下来使用 OkHttpCall.execute() 或者异步执行 enqueue(Callback callback)

这两种方式都会调用 createRawCall() 创建一个 okhttp3.Call

private okhttp3.Call createRawCall() throws IOException {    Request request = serviceMethod.toRequest(args);    okhttp3.Call call = serviceMethod.callFactory.newCall(request);    if (call == null) {        throw new NullPointerException("Call.Factory returned null.");    }    return call;}

此处的 serviceMethod.callFactory 就是 retrofit.create() 中创建的 OkHttpClient()后面的内容都是由 Okhttp 模块接管，进行网络请求，参考okHttp 框架源码学习

然后调用 parseResponse(call.execute())

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {    ResponseBody rawBody = rawResponse.body();    ……    省略一些 http 返回值处理逻辑    ……    try {        T body = serviceMethod.toResponse(catchingBody);        return Response.success(body, rawResponse);    } ……}

okHttp 请求网络的返回数据，会交给 serviceMethod.toResponse

R toResponse(ResponseBody body) throws IOException {    return responseConverter.convert(body);}

在 ServiceMethod.Builder.build() 方法中可以找到 responseConverter 是通过 createResponseConverter() 方法的返回对象。

createResponseConverter() 只是报包裹了 retrofit.responseBodyConverter(responseType, annotations) 方法。

retrofit.responseBodyConverter() 继续跟踪下去会得知，返回的是 converterFactories 数组的第 0 个对象，也就是内置的 BuiltInConverters.responseBodyConverter() 方法返回的 BufferingResponseBodyConverter

static final class BufferingResponseBodyConverter        implements Converter<ResponseBody, ResponseBody> {    static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();    @Override    public ResponseBody convert(ResponseBody value) throws IOException {        try {            // Buffer the entire body to avoid future I/O.            return Utils.buffer(value);        } finally {            value.close();        }    }}

再看一下 Utils.buffer(value)

static ResponseBody buffer(final ResponseBody body) throws IOException {    Buffer buffer = new Buffer();    body.source().readAll(buffer);    return ResponseBody.create(body.contentType(), body.contentLength(), buffer);}

最终会返回一个重新封装的 Okhttp 框架的 ResponseBody 对象，过程如下：

最后来个总结

• 第一步创建一个Retrofit对象

• 通过 Retrofit.onCreate()方法把我们所定义的接口转化为接口实例并使用接口中的方法

• 最终的实例都会调用okHttp的call，retrofit用于OKhttp的，比较灵活

相信自己，没有做不到的，只有想不到的！