Retrofit源码分析三 源码分析
RikkaTheWorld 2019-06-27
Retrofit源码分析三 源码分析
使用方法
我们先来看一下Retrofit的常见使用方法：
//创建网络请求接口类
public interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
//创建Retrofit实例对象
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.build();
//通过动态代理创建网络接口代理对象
GitHubService service = retrofit.create(GitHubService.class);
//获取Call对象
Call<List<Repo>> repos = service.listRepos("octocat");
//执行同步请求或异步请求
repos.execute();
repos.enqueue(callback)上面是Retrofit的最基本使用方法，当然现在使用最多的还是RxJava2+Retrofit搭配使用，关于RxJava2，大家可以看我的另一篇 RxJava2源码分析 ，当然RxJava2与Retrofit搭配使用的解析我会在稍后分析，这里我们先关注最基本的使用方法。
创建网络接口类
这一步的目的就是封装我们网络请求相关的一些参数，没什么好多说的。
创建Retrofit实例对象
Retrofit实例对象的创建很明显是采用了Builder模式，Builder模式在 Java语言中 创建一个 有很多可选配置参数 的对象的时候是很好的一种设计模式。Builder模式有两个重点，一个是在 Java语言中 中，另一个是 有很多可选配置参数，其实在现在的Android开发中，使用Kotlin开发Android已经很普遍了，熟悉Kotlin语法的小伙伴可能很熟悉了，由于Kotlin中 默认参数 的存在，所以在Kotlin中使用Builder模式的意义不大。但由于Java语法的限制，在创建一个 有很多可选配置参数 的时候，Builder模式还是首要选择。
我们来看一下Retrofit中的成员变量：
public final class Retrofit {
//缓存封装好的ServiceMethod
private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
//OKHttp中的网络请求工厂
final okhttp3.Call.Factory callFactory;
//BaseUrl
final HttpUrl baseUrl;
//数据转换器工厂集合
final List<Converter.Factory> converterFactories;
//网络请求适配器工厂集合
final List<CallAdapter.Factory> callAdapterFactories;
//处理线程切换
final @Nullable Executor callbackExecutor;
//不需要关注，默认为false
final boolean validateEagerly;
//忽略无关代码......
}serviceMethodCache 是一个HashMap，它的Key是Method，代表我们定义的网络请求接口类中的方法，它的Value是ServiceMethod，代表对网络请求接口类中的方法的一个封装，简单看一下它就明白了：
final class ServiceMethod<R, T> {
private final okhttp3.Call.Factory callFactory;
private final CallAdapter<R, T> callAdapter;
private final HttpUrl baseUrl;
private final Converter<ResponseBody, R> responseConverter;
private final String httpMethod;
private final String relativeUrl;
private final Headers headers;
private final MediaType contentType;
private final boolean hasBody;
private final boolean isFormEncoded;
private final boolean isMultipart;
private final ParameterHandler<?>[] parameterHandlers;
//忽略无关代码.......
}很明显了，ServiceMethod就是对网络请求参数的封装类，包含请求头、相对url、GET请求或者是POST请求等等对请求的配置信息。serviceMethodCache 就是一个对ServiceMethod的缓存，可以提高一定的效率。
在Retrofit中，默认的数据转换器工厂就是 GsonConverterFactory ，所以其实如果我们是使用 Gson 来做数据转换的，其实没有必要去配置。在Android平台，Retrofit中默认的网络请求适配器工厂是 ExecutorCallAdapterFactory ，我们简单瞅一眼它是如何被创建的：
static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
if (callbackExecutor == null) throw new AssertionError();
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
//注意这里创建了一个位于主线程的Handler
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
//通过handler.post(runnable)实现线程切换
handler.post(r);
}
}
}可以看到，在创建 ExecutorCallAdapterFactory 的同时传入了一个 callbackExecutor ，这个 callbackExecutor 也是Retrofit中默认的 callbackExecutor ，在Android平台中它是 MainThreadExecutor类型 ，可以看到，在它的内部创建了一个位于主线程的Handler。我们知道，使用Retrofit的时候不同于直接使用OKHttp，在使用Retrofit的异步网络请求时，网络结果的回调是位于主线程中的，那么Retrofit是如何切换的线程，看过上面的代码应该会心里有个数了，它是通过 handler.post(r) 来实现由子线程到主线程的切换。
通过动态代理创建网络接口代理对象
看过我的Retrofit源码分析第二篇：代理模式的小伙伴们应该都比较清楚了，在Retrofit的 create 方法中其实是使用了动态代理生成了一个代理对象，现在我们就来看一下 create 的源码：
public <T> T create(final Class<T> service) {
//忽略无关代码......
//下面就是JDK给我们提供的动态代理了
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 {
//忽略无关代码......
//获取method的网络请求参数的封装类ServiceMethod对象
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
//获取对OKHttp中的RealCall的一个包装类OkHttpCall对象
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
//通过网络请求适配器将原始的Call对象转换成需要的对象，比如RxJavaCallAdapter会将Call对象转换成Observable。
return serviceMethod.adapt(okHttpCall);
}
});
}在 create 方法中做了3件事：
- 封装网络请求方法
- 封装原始Call对象
- 通过CallAdapter转换Call对象
封装网络请求方法很容易理解，关于ServiceMethod上面已经说过，不再赘述。封装原始Call对象，对OKHttp源码熟悉的小伙伴应该知道，原始的Call其实就是OkHttp中的ReallCall。如果不熟悉OkHttp的同学可以看我之前的一篇 OkHttp源码分析 。我们可以简单看一下这个包装类 OkHttpCall :
final class OkHttpCall<T> implements Call<T> {
//忽略无关代码......
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
//熟悉OkHttp源码的同学应该很熟悉了，完全照抄OkHttp中的代码，确保每个Call只会被执行一次
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
//忽略无关代码......
call = rawCall;
if (call == null) {
try {
//创建OkHttp中的RealCall对象
call = rawCall = createRawCall();
} catch (IOException | RuntimeException | Error e) {
throwIfFatal(e); // Do not assign a fatal error to creationFailure.
creationFailure = e;
throw e;
}
}
}
if (canceled) {
call.cancel();
}
//解析OkHttp中的RealCall执行同步方法后返回的网络数据
return parseResponse(call.execute());
}
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
okhttp3.Call call;
Throwable failure;
//确保一个Call对象只被执行一次
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
//创建OkHttp中的RealCall对象
call = rawCall = createRawCall();
} catch (Throwable t) {
throwIfFatal(t);
failure = creationFailure = t;
}
}
}
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
//调用OkHttp中的RealCall的异步请求网络方法
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable 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();
}
}
});
}
}可以看到，Retrofit中的这个 OKHttpCall 完全是对OkHttp中的 RealCall 的一个包装。在 OKHttpCall 中的同步网络方法 execute 和异步网络方法 enQueue 中其实就做了三件事：获取 RealCall 对象，调用 RealCall 中的 execute 或者 enQueue 方法，然后去解析OkHttp返回的原始数据并转换成我们需要的类型，就这么简单。
接下来就 create 方法中就只剩下 通过CallAdapter转换Call对象 了，我们上面说过，在没有特别配置CallAdapter的时候，默认的CallAdapterFactory是 ExecutorCallAdapterFactory ，很明显，CallAdapter是由Factory创建的，那我们看一下这个默认的CallAdapterFactory：
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
//本质是传入的MainThreadExecutor
final Executor callbackExecutor;
ExecutorCallAdapterFactory(Executor callbackExecutor) {
this.callbackExecutor = callbackExecutor;
}
@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
//直接创建并返回一个CallAdapter的匿名对象
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
//返回默认的CallAdapter转换后的Call对象
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
static final class ExecutorCallbackCall<T> implements Call<T> {
//本质是传入的MainThreadExecutor
final Executor callbackExecutor;
//就是OKHttpCall，从名字也能理解，代理Call对象
final Call<T> delegate;
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
//调用OkHttp中RealCall的异步网络请求
delegate.enqueue(new Callback<T>() {
@Override public void onResponse(Call<T> call, final Response<T> response) {
//注意，OkHttp的异步回调是在子线程的，Retrofit这里实现了线程的切换，本质是调用了handler.post(runnable)
callbackExecutor.execute(new Runnable() {
@Override public void run() {
if (delegate.isCanceled()) {
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
}
});
}
@Override public void onFailure(Call<T> call, final Throwable t) {
//注意，OkHttp的异步回调是在子线程的，Retrofit这里实现了线程的切换，本质是调用了handler.post(runnable)
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(ExecutorCallbackCall.this, t);
}
});
}
});
}
@Override public boolean isExecuted() {
return delegate.isExecuted();
}
@Override public Response<T> execute() throws IOException {
//由于同步方法不需要切线程，所以直接执行并返回OKHttpCall的同步网络方法
return delegate.execute();
}
@Override public void cancel() {
delegate.cancel();
}
@Override public boolean isCanceled() {
return delegate.isCanceled();
}
@SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
@Override public Call<T> clone() {
return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
}
@Override public Request request() {
return delegate.request();
}
}
}上面的代码其实也很清晰了 ExecutorCallAdapterFactory 这个CallAdapter工厂类直接创建并返回一个CallAdapter的匿名对象，这个其实就是我们Retrofit的默认CallAdapter，关键是这个CallAdapter的adapt方法，它返回了 ExecutorCallbackCall 这个对OkHttpCall的包装类，我们关注这个包装类的 enqueue 方法，在这个方法中，它通过调用 callbackExecutor.execute 来实现了子线程到主线程的线程切换。这个 callbackExecutor 就是 MainThreadExecutor ，这个类我们上面提到过， MainThreadExecutor 中的 execute 方法内部就是 handler.post(r); ，这个 handler 其实就是主线程的，因此实现了线程切换。
获取Call对象并执行同步或异步方法
其实经过上一步的分析，我们已经知道了，我们获取的Call对象，其实是通过动态代理中 serviceMethod.adapt(okHttpCall) 返回的Call对象，这个其实就是 ExecutorCallbackCall ，这个我们都很清楚了，它是对OkHttp中RealCall的一个包装类，在它的异步方法中通过调用 callbackExecutor.execute 实现了线程的切换，当然本质还是通过 Handler 机制。
其实到此为止，基本的流程已经分析完毕了，我们到这里也会很清楚Retrofit的定位：Retrofit并不是一个网络请求的框架，而是一封装网络请求参数，解析网络返回结果的框架。下面我们来分析一下使用了RxJava2CallAdapter的情况。
RxJava2CallAdapter的原理
CallAdapter的重点是它的adapt方法，我们来看一下RxJava2CallAdapter中的adapt方法：
@Override public <R> Object adapt(Call<R> call) {
//创建一个发射网络返回结果的Observable
Observable<Response<R>> responseObservable = new CallObservable<>(call);
Observable<?> observable;
if (isResult) {
observable = new ResultObservable<>(responseObservable);
} else if (isBody) {
observable = new BodyObservable<>(responseObservable);
} else {
observable = responseObservable;
}
//默认scheduler为空
if (scheduler != null) {
observable = observable.subscribeOn(scheduler);
}
if (isFlowable) {
return observable.toFlowable(BackpressureStrategy.LATEST);
}
if (isSingle) {
return observable.singleOrError();
}
if (isMaybe) {
return observable.singleElement();
}
if (isCompletable) {
return observable.ignoreElements();
}
return observable;
}这段代码本质是创建一个发射网络返回结果的Observable，我们看一下 CallObservable 的内部实现，看过RxJava2源码的同学应该都知道，Observable的关键方法是 subscribeActual，我们就看一下这个方法内部都做了什么：
@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
// Since Call is a one-shot type, clone it for each new observer.
Call<T> call = originalCall.clone();
observer.onSubscribe(new CallDisposable(call));
boolean terminated = false;
try {
//调用了OKHttpCall的同步网络访问方法，并获取网络数据
Response<T> response = call.execute();
if (!call.isCanceled()) {
//将获取到的网络数据发送到观察者observer
observer.onNext(response);
}
if (!call.isCanceled()) {
terminated = true;
//发送结束事件
observer.onComplete();
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
if (terminated) {
RxJavaPlugins.onError(t);
} else if (!call.isCanceled()) {
try {
//发送错误事件
observer.onError(t);
} catch (Throwable inner) {
Exceptions.throwIfFatal(inner);
RxJavaPlugins.onError(new CompositeException(t, inner));
}
}
}
}熟悉RxJava2的同学看完就应该懂了：RxJava2CallAdapter通过adapt方法生成并返回一个 CallObservable 对象，在这个 CallObservable 内部通调用 OKHttpCall 的 execute() 方法进行网络访问，并将获取到的数据发送到下一级的观察者observer中。
到此为止，Retrofit的源码分析终于结束了，其实它并不难，但想要完全理解整个网络访问流程，除了要明白Retrofit，还需要了解OKHttp甚至是RxJava，对后两者不太熟悉的小伙伴们可以看我的另外两篇源码分析：OkHttp源码分析 ， RxJava2源码分析 ，在熟悉了OKHttp和RxJava2的基础上再回过头来看Retrofit，相信你会有更深的理解。
