【源码解读】Retrofit网络请求过程源码解析

之前写了一个Gank.io的客户端练手学习了下RxJava+Retrofit的基本使用，顺着代码看了下相关的源码，将分析笔记记录于此，欢迎有兴趣的小伙伴多多指正，共同进步。

在写Gank的过程中，查看妹子福利时的代码如下，从创建接口到访问网络数据再到转换数据，RxJava+Retrofit到底是怎么完成的呢？

public interface GankApi {
@GET("data/福利/{number}/{page}")
Observable<GankGirlResult> getGirls(@Path("number") int number, @Path("page") int page);
}
//1.创建Retrofit对象
Retrofit retrofit = new Retrofit.Builder()
.client(okHttpClient)
.baseUrl(baseUrl)
.addConverterFactory(gsonConverterFactory)
.addCallAdapterFactory(rxJavaCallAdapterFactory)//4
.build();//5
//2.构造请求接口
gankApi = retrofit.create(GankApi.class);
//3.执行请求
gankApi.getGirls(10, page++)

按照代码我们的分析也分成了三块:Retrofit对象的创建、GankApi请求接口的生成、执行网络请求的调用。

一、Retrofit对象的创建

Retrofit采用Builder模式创建，首先从Builder开始看起，先是初始化平台对象，并向集合converterFactories中默认添加了一个BuiltInConverters对象

Builder(Platform platform) {
this.platform = platform;
// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
}

1.client(okHttpClient)与baseUrl(baseUrl)

我们知道Retrofit本质上还是利用OkHttp进行网络访问，这一步就是提供一个okHttpClient对象用来发送请求，同时设置请求地址的基本路径。如果不设置则会报异常。

2.addConverterFactory与addCallAdapterFactory

这一步指定使用Gson对返回数据进行解析，使用RxJava进行回调，具体创建操作后面再进行分析。

public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}

3.build()

这里就是基于Builder创建Retrofit的代码，主要信息都在注释里面了。

public Retrofit build() {

//1.如果没有设置baseUrl则抛出异常
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//2.如果没有设置OkHttpClient对象则进行设置
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//3.如果没有设置Executor则根据平台设置默认的Executor
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}

//4.基于Executor创建默认的CallAdapter.Factory,这里具体就是ExecutorCallAdapterFactory对象
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
callbackExecutor, validateEagerly);
}

上面就是其Retrofit的对象的构建过程，基本就是设置了OkHttpClient和基础路径，然后设置Converter.Factory和CallAdapter.Factory。有一点区别是Converter.Factory的集合在我们设置GsonConvert之前就添加了一个元素BuiltInConverters，而对于CallAdapter.Factory则是在设置完成后添加的。对于构建完成后的两个集合如下(偷懒直接断点截了个图，捂脸):



下面是我们关注的重点，其create方法创建我们想要的Api类以及方法的调用

二、请求接口的生成

通过下面的create方法的代码我们可以看出Retrofit是通过动态代理来创建调用我们的请求方法的，首先将调用的Method解析为ServiceMethod，

然后封装为OkHttpCall请求对象，最后通过CallAdapter执行请求返回数据。这一部分我们重点分析ServiceMethod的创建。

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, Object... args)
throws Throwable {
//...代码省略

//1.将Method解析为ServiceMethod对象
ServiceMethod serviceMethod = loadServiceMethod(method);
//2.将ServiceMethod和args参数封装为OkHttpCall对象
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
//3.发送请求返回封装好的Call对象，如果是RxJava作为Adapter则返回Observable对象
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}

1.将Method封装为ServiceMethod对象

public Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;、
this.method = method;
this.methodAnnotations = method.getAnnotations();//获取方法的注解数组
this.parameterTypes = method.getGenericParameterTypes();//获取形参数据
this.parameterAnnotationsArray = method.getParameterAnnotations();//获取形参的注解
}

public ServiceMethod build() {
//1.创建CallAdapter对象,并获取响应的数据类型,其实我们要转换的数据类型
callAdapter = createCallAdapter();
responseType = callAdapter.responseType();
//2.创建Converter对象
responseConverter = createResponseConverter();
//3.解析方法注解
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
//4.解析参数注解
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
return new ServiceMethod<>(this);
}

上面是去掉各种异常处理之后的简化代码，其主要做了四项操作。

下面来看下四步的代码(具体到细节的话每一步都可以写成一篇文章，因此这里只做简单分析):

CallAdapter的创建

最终调用的是Retrofit中的nextCallAdapter。

上面提到了，在构建Retrofit时，使用List集合存放CallAdapter.Factory,RxJavaCallAdapterFactory存放于0，默认的DefaultCallAdapterFactory或者ExecutorCallAdapterFactory存放于1，因此在创建CallAdapter时如果设置了RxJavaCallAdapterFactory优先使用RxJavaCallAdapterFactory创建Adapter。

//adapterFactories集合，默认skipPast为null，因此indexOf返回-1，start从0开始，遍历第一个就是RxJavaCallAdapterFactory
//使用该对象创建CallAdapter对象，
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");

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;
}
}
}

下面是RxJavaCallAdapterFactory的get方法具体的代码，returnType参数就是我们所调用方法的返回值类型

@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
Class<?> rawType = getRawType(returnType);
//获取全类名为rx.Observable因此isSingle与isCompletable均为false,最终调用getCallAdapter方法来获取对象
//具体细节这里不再分析，这里最终返回的是SimpleCallAdapter类的对象。
String canonicalName = rawType.getCanonicalName();
boolean isSingle = "rx.Single".equals(canonicalName);
boolean isCompletable = "rx.Completable".equals(canonicalName);
if (rawType != Observable.class && !isSingle && !isCompletable) {
return null;
}

if (isCompletable) {
return CompletableHelper.createCallAdapter(scheduler);
}

CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType, scheduler);
if (isSingle) {
return SingleHelper.makeSingle(callAdapter);
}
return callAdapter;
}

PS:RxJavaCallAdapterFactory提供了ResponseCallAdapter、SimpleCallAdapter、ResultCallAdapter三种Adapter,具体细节区别有兴趣的同学可以研究下源码。

Converter的创建

和存储RxJavaCallAdapterFactory的集合相反，存储Converter对象的集合第一个存储的是BuiltInConverters对象，其次存储的是我们的GsonConverterFactory,最终调用的是Retrofit中的nextResponseBodyConverter方法

其创建方法如下:

public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,
Type type, Annotation[] annotations) {
checkNotNull(type, "type == null");
checkNotNull(annotations, "annotations == null");
//start为0
int start = converterFactories.indexOf(skipPast) + 1;

for (int i = start, count = converterFactories.size(); i < count; i++) {
//首先遍历到的是BuiltInConverters,这时的返回类型就是我们定义方法里面的类型，BuiltInConverters的responseBodyConverter返回null。第二次遍历是GsonConverterFactory的GsonResponseBodyConverter，直接返回GsonResponseBodyConverter对象，
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<ResponseBody, T>) converter;
}
}

}
//创建GsonResponseBodyConverter
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}

解析方法注解和参数注解

解析方法注解,下面是我摘取的部分方法代码，可以看到我们很熟悉的GET和POST请求注解的解析，也包括http和head的解析。我们创建网络接口上的注解就是在这里进行解析的。

private void parseMethodAnnotation(Annotation annotation) {

if (annotation instanceof GET) {
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
} else if (annotation instanceof HEAD) {
parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
if (!Void.class.equals(responseType)) {
throw methodError("HEAD method must use Void as response type.");
}
}  else if (annotation instanceof POST) {
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
} else if (annotation instanceof PUT) {
parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
} else if (annotation instanceof OPTIONS) {
parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
} else if (annotation instanceof HTTP) {
HTTP http = (HTTP) annotation;
parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
}
}

对于参数注解的解析，首先遍历每一个参数的每一个注解，然后对每个参数的注解构造ParameterHandler对象。具体细节这里不再赘述

上述操作完成后就完成了ServiceMethod的构建。

三、执行请求

在构建请求完成后就是调用我们的方法了，具体到我们的代码就是调用了SimpleCallAdapter的adapt方法:

@Override public <R> Observable<R> adapt(Call<R> call) {
Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) //1.将call传递给CallOnSubscribe,执行网络请求
.flatMap(new Func1<Response<R>, Observable<R>>() {//2.对数据进行转换成函数所需要的Obserable对象，
@Override public Observable<R> call(Response<R> response) {
if (response.isSuccessful()) {
return Observable.just(response.body());
}
return Observable.error(new HttpException(response));
}
});
//
if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;

可以看到，首先是将call传递给了CallOnSubscribe。这是RxJavaCallAdapterFactory的一个内部类，简化后的代码如下

static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {
private final Call<T> originalCall;

CallOnSubscribe(Call<T> originalCall) {
this.originalCall = originalCall;
}

@Override public void call(final Subscriber<? super Response<T>> subscriber) {
// Since Call is a one-shot type, clone it for each new subscriber.
final Call<T> call = originalCall.clone();

// Attempt to cancel the call if it is still in-flight on unsubscription.
subscriber.add(Subscriptions.create(new Action0() {
@Override public void call() {
call.cancel();
}
}));
//执行网络请求
Response<T> response = call.execute();
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response);
}
}
}

可以看到是在CallOnSubscribe的call方法中执行了网络请求execute()并将Response对象作为参数通过flatMap转换为相应的Observable对象，也就是我们的接口方法的返回类型Observable,剩下的就是利用Gson和RxJava进行数据的解析和转换最终生成符合我们需要的数据。

到这里我们开头访问妹子福利代码的执行流程基本搞清楚了，总体而言Retrofit源码比较简单而且设计的非常好，建议大家都去认真阅读下。

最后总结下阅读源码的三点感受:

1. 不要只看分析文章,自己分析源码很重要

2. 结合代码，从一个点开始顺藤摸瓜，总会找到让你高潮的代码与逻辑

3. 断点调试很重要！断点调试很重要！断点调试很重要！