距离上次发布文章有一段时间了，这次会带来之前答应大家源码剖析系列的文章。这个系列的文章更多的是对自己源码学习的一些总结，希望有共同爱好的同学能跟我一起交流，如果我有错误，向我指正。
这次我要写的源码剖析是近一两年非常火的网络框架---Retrofit2，虽然网上关于它的分析还是比较多的，但是每个人都有自己的一些理解和总结，所以最后我还是决定将它写出来。
我们首先看看Retrofit类，短短几百行的代码，还夹杂着一大堆的注释，可以说它的封装性是特别强的。首先我们看看Retrofit类的几个变量：
// 网络请求配置对象
// 作用：存储网络请求相关的配置，如解析网络请求的方法、数据转换器（Converter）、网络请求适配器（CallAdapter）、网络请求工厂（CallFactory）、基础地址（BaseUrl）等
private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
//网络请求器的工厂
//作用：生产网络请求器（Call）
//Retrofit是默认使用okhttp（后面会解释）
final okhttp3.Call.Factory callFactory;
//网络请求的基础url地址
final HttpUrl baseUrl;
//数据转换器工厂的集合
//作用：放置数据转换器工厂
//数据转换器工厂作用：生产数据转换器（converter）
final List<Converter.Factory> converterFactories;
//网络请求适配器工厂的集合
//作用：放置网络请求适配器工厂
//网络请求适配器工厂作用：生产网络请求适配器（CallAdapter）
final List<CallAdapter.Factory> adapterFactories;
//回调方法执行器
final Executor callbackExecutor;
//标志位
//作用：是否提前对业务接口中的注解进行验证转换的标志位
final boolean validateEagerly;
可以看到，Retrofit类的变量并不多，下面我们看看构造函数：
//构造函数
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
@Nullable Executor callbackExecutor, boolean validateEagerly) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
}
其实就是对Retrofit的几个变量做了赋值。
下面我们来看看整个Retrofit的创建流程：
初始化步骤.png
步骤2：
步骤2.png
上面我们已经看过Retrofit的构造函数了，所以可以省略步骤1，那下面我们就开始看看步骤2，Retrofit的Builder这个类的构成：
//Builder类
public static final class Builder {
//平台
private final Platform platform;
//一下几个变量与Retrofit的构造函数大致相同
private okhttp3.Call.Factory callFactory;
private HttpUrl baseUrl;
private final List<Converter.Factory> converterFactories = new ArrayList<>();
private final List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
private Executor callbackExecutor;
private boolean validateEagerly;
Builder(Platform platform) {
this.platform = platform;
converterFactories.add(new BuiltInConverters());
}
//构造函数
public Builder() {
this(Platform.get());
}
}
我们可以看到Builder类除了Platform之外，其他几个变量我们都在前面见过，那究竟Platform是什么呢，我们来解密一下,首先我查了一下翻译，Platform是“平台”的意思，查了翻译我们就知道大概了，因为我们知道Retrofit支持不单止Android一个平台,那下面我们就来看看Platform类：
class Platform {
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
try {
// Class.forName(xxx.xx.xx)的作用：要求JVM查找并加载指定的类
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
// 如果是Android平台，就创建并返回一个Android对象
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
// 如果是Java平台，就创建并返回一个Java8对象
return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
Executor defaultCallbackExecutor() {
return null;
}
CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
if (callbackExecutor != null) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}
return DefaultCallAdapterFactory.INSTANCE;
}
// 用于接收服务器返回数据后进行线程切换在主线程显示结果
static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
// 获取与Android 主线程绑定的Handler
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
// 该Handler是上面获取的与Android 主线程绑定的Handler
// 在UI线程进行对网络请求返回数据处理等操作。
handler.post(r);
}
}
}
}
上面看完Platform类的findPlatform()方法之后，我们就很清楚的知道这个版本的Retrofit2.0是支持Android和Java平台的，此外，在Retrofit2其他版本中还会支持IOS的版本，在这个版本被去掉了。看源码重要的是在看完源码后能获取一些收获，所以像Retrofit这个这么成功的框架中我们需要去领会到它一些代码的写法。譬如在Platform这个类中，我们以后想做到分情况考虑的时候，也可以用像findPlatform()方法的这种实现（用了两个Class.forName(xxx.xx.xx)的方法就很好的区分了使用的平台），简洁而且实用。
我们可以看到其实步骤2的Builder类最特别的Platform分析完毕之后，步骤2就基本分析完了。这里的Retrofit使用了建造者模式，我们下面再做详细的分析。
下面我们看看步骤3：
步骤3：
步骤3.png
public Builder baseUrl(String baseUrl) {
checkNotNull(baseUrl, "baseUrl == null");
HttpUrl httpUrl = HttpUrl.parse(baseUrl);
if (httpUrl == null) {
throw new IllegalArgumentException("Illegal URL: " + baseUrl);
}
return baseUrl(httpUrl);
}
public Builder baseUrl(HttpUrl baseUrl) {
checkNotNull(baseUrl, "baseUrl == null");
List<String> pathSegments = baseUrl.pathSegments();
//注意点1
if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
}
this.baseUrl = baseUrl;
//注意点2
return this;
}
我们可以看到，代码很简单，就是两个方法，至于看到方法名大家更加清楚明白，这是一个设置基础URL的方法。上面我们只需要关注两个注意点：
1.baseUrl必须要以“/”结束，否则会抛出异常，其实他的源码注释也解释了一些特殊的情况。
baseUrl注释.png
2.return一个Builder类型，其实是建造者模式一个常用的手法，以供使用者很好的链式配置你想要的相关配置。
继续，步骤4：
步骤4（可选）：
配置client.png
public Builder client(OkHttpClient client) {
//注意点1
return callFactory(checkNotNull(client, "client == null"));
}
public Builder callFactory(okhttp3.Call.Factory factory) {
this.callFactory = checkNotNull(factory, "factory == null");
return this;
}
我们都知道Retrofit其实只是名义上可以称为一个网络框架，但是其实，完成网络请求这块的功能并不是Retrofit，而是我们耳熟能详的OKhttp。关于步骤4，我们看到client()方法传的参数是OkHttpClient 就知道这里是配置一个OkHttp的OkHttpClient，其实Retrofit默认就是使用OKhttp作为他的网络请求的载体，所以如果对OKhttp没有特殊要求（如设置拦截器之类）的同学可以忽略步骤4。
注意点1：我们可以上面两个方法看到其实Retrofit类里面的callFactory指的就是OkHttpClient
步骤5，6：
设置Factory.png
//设置数据交换器
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;
}
我们可以看到步骤5,6其实可以归到同一类去讲，就是添加适配器，我们更值得说的是，“···Factory”用的都是设计模式里面的工厂模式，而“···Adapter”用的就是设计模式里面的适配器模式。
步骤7：
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
//注意点1
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
// 如果没指定，则默认使用Platform检测环境时的默认callbackExecutor
// 即Android默认的callbackExecutor
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
// 在步骤2中已经添加了内置的数据转换器BuiltInConverters(）（添加到集合器的首位）
// 在步骤5中又插入了一个Gson的转换器 - GsonConverterFactory（添加到集合器的首二位）
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
// 最终返回一个Retrofit的对象，并传入上述已经配置好的成员变量
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}
我们可以看到，步骤7也就是最后一步，是通过前面几步设置的变量，最后返回一个新的Retrofit对象，创建一个Retrofit实例，很明显，通过这几步的配置，是用了设计模式里面的建造者模式，当然在这里我们又学到了，当我们自定义东西的时候，通过建造者模式，我们可以灵活的配置自己想要的东西，而不是一味的把代码写死，每次都是需要触碰到源代码的修改，适当的使用设计模式，会使你的代码更加灵活。
总结：
总结.png
上面我们看完了Retrofit是怎么配置参数源码，我们大致了解Retrofit是怎么进行初始化的，下面我们看看Retrofit在使用时是怎么运作的：
//步骤1
//Retrofit与很多网络框架不一样，使用前是需要先设置好JavaBean
public class WXItemBean {
}
//步骤2 定义网络请求的接口类
public interface TestApi {
//注解GET：采用Get方法发送网络请求
@GET("wxnew")
rx.Observable<WXHttpResponse<List<WXItemBean>>> getWXHot(@Query("key") String key, @Query("num") int num, @Query("page") int page);
}
//步骤3 创建接口类实例
testApi = retrofit.create(TestApi.class);
//步骤4 网络请求
Subscription subscribe = testApi.getWXHot(key, num, page)
.compose(RxUtil.<WXHttpResponse<List<WXItemBean>>>rxSchedulerHelper())
.compose(RxUtil.<List<WXItemBean>>handleResult1())
.subscribe(new BaseSubscriber1<List<WXItemBean>>() {
@Override
public void onNextT(List<WXItemBean> wxItemBeen) {
mView.testSuccess(wxItemBeen);
}
@Override
public void onErrorT(String msg) {
}
});
addSubscrebe(subscribe);
下面我们主要来分析一下步骤3，也就是create()。在介绍这个方法之前，我先告诉大家这个方法使用了设计模式的外观模式（大大降低了耦合度）和代理模式，其中代理模式用的是动态代理，什么是动态代理？其实Java早已经帮我们封装好了方法，我们来举个栗子：
public interface ITest
{
@GET("/wx")
public void add(int a, int b);
}
public static void main(String[] args)
{
ITest iTest = (ITest) Proxy.newProxyInstance(ITest.class.getClassLoader(), new Class<?>[]{ITest.class}, new InvocationHandler()
{
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
Integer a = (Integer) args[0];
Integer b = (Integer) args[1];
System.out.println("方法名：" + method.getName());
System.out.println("参数：" + a + " , " + b);
GET get = method.getAnnotation(GET.class);
System.out.println("注解：" + get.value());
return null;
}
});
iTest.add(3, 5);
}
结果为：
方法名：add
参数：3 , 5
注解：/wx
是不是觉得很神奇？有了这个例子我们接下来就很好理解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, 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);
}
//注意点1
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
//注意点2
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
//注意点3
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
很明显，我们看到create()方法最核心的东西是使用了动态代理的Proxy.newProxyInstance()方法，通过代理模式中的动态代理模式，动态生成网络请求接口的代理类，并将代理类的实例创建交给InvocationHandler类 作为具体的实现，并最终返回一个动态代理对象。而Proxy.newProxyInstance()方法的核心正正是我们标注的注意点1,2,3。我可以这样说，Retrofit这个框架运作的时候，最核心的就是我们看到的这三句话。
我们首先来看看注意点1：
ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);
我们来看看loadServiceMethod(method)这个方法：
ServiceMethod<?, ?> loadServiceMethod(Method method) {
//获取缓存
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
设置同步锁
synchronized (serviceMethodCache) {
//获取缓存
result = serviceMethodCache.get(method);
//如果没有缓存，则创建一个新的ServiceMethod实例
if (result == null) {
result = new ServiceMethod.Builder<>(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
那下面我们来看看ServiceMethod又是怎么创建出来的：
首先看看ServiceMethod的构造函数：
ServiceMethod(Builder<R, T> builder) {
this.callFactory = builder.retrofit.callFactory();
this.callAdapter = builder.callAdapter;
this.baseUrl = builder.retrofit.baseUrl();
this.responseConverter = builder.responseConverter;
this.httpMethod = builder.httpMethod;
this.relativeUrl = builder.relativeUrl;
this.headers = builder.headers;
this.contentType = builder.contentType;
this.hasBody = builder.hasBody;
this.isFormEncoded = builder.isFormEncoded;
this.isMultipart = builder.isMultipart;
this.parameterHandlers = builder.parameterHandlers;
}
我们可以看到在ServiceMethod设置了各种不同的网络参数，然后我们看看Builder<>(this, method)这个方法：
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
// 网络请求接口方法里的注释(如@GET("wxnew"))
this.methodAnnotations = method.getAnnotations();
// 网络请求接口方法里的参数类型
this.parameterTypes = method.getGenericParameterTypes();
//网络请求接口方法里的注解内容
this.parameterAnnotationsArray = method.getParameterAnnotations();
}
接下来我们看看建造者模式的最后一步build()方法：
public ServiceMethod build() {
//注意点1，从Retrofit对象中获取对应的网络请求适配器
callAdapter = createCallAdapter();
// 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取该网络适配器返回的数据类型
responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw methodError("'"
+ Utils.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
responseConverter = createResponseConverter();
for (Annotation annotation : methodAnnotations) {
// 解析获取Http请求的方法,如GET、POST、HEAD
parseMethodAnnotation(annotation);
}
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
// 为方法中的每个参数创建一个ParameterHandler<?>对象并解析每个参数使用的注解类型
// 该对象的创建过程就是对方法参数中注解进行解析
// 这里的注解包括：Body、PartMap、Part、FieldMap、Field、Header、QueryMap、Query、Path、Url
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
if (Utils.hasUnresolvableType(parameterType)) {
throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
parameterType);
}
//最后创建一个新的ServiceMethod实例
return new ServiceMethod<>(this);
}
我们看看注意点1，在ServiceMethod 中是如何创建CallAdapter的：
private CallAdapter<T, R> createCallAdapter() {
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw methodError("Service methods cannot return void.");
}
Annotation[] annotations = method.getAnnotations();
try {
//调用Retrofit类里面的callAdapter方法
return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(e, "Unable to create call adapter for %s", returnType);
}
}
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
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;
}
}
}
在上面这段代码中，通过遍历adapterFactories并根据我们的接口方法所中返回值类型来获取响应的适配器callAdapter。例如上面的例子中返回值是一个Call对象，将会采用默认的适配器，如果我们返回的是RxJava中Observable对象，如果我们添加了RxJavaCallAdapterFactory，那么返回的就是RxJavaCallAdapter。如果没有添加那么此处的adapter为null，便会抛出异常。
设置多个CallAdapterFactory.png
当我们初始配置的时候设置多个CallAdapterFactory，Retrofit会根据返回不同的对象，返回相应的CallAdapter。
ConverterFactory和CallAdapterFactory的创建原理基本一样，所以这里不多说。
下面我们看看整个CallAdapter创建的流程图：
CallAdapter创建过程.png
注意点1总结：
看完ServiceMethod这个类，我们就发现，这是一个非常非常重要的类，它把所有有关网络请求method，都转换成了Call的信息。
那下面我们看看注意点2
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
public class OkHttpCall {
private final ServiceMethod<T> serviceMethod; // 含有所有网络请求参数信息的对象
private final Object[] args; // 网络请求接口的参数
private okhttp3.Call rawCall; //实际进行网络访问的类
private Throwable creationFailure;
private boolean executed;
private volatile boolean canceled;
//构造函数
public OkHttpCall(ServiceMethod<T> serviceMethod, Object[] args) {
// 传入ServiceMethod对象和请求参数
this.serviceMethod = serviceMethod;
this.args = args;
}
我们知道Retrofit实际上是用okhttp做网络请求的，所以这句话大家都很清楚，把刚刚配置的ServiceMethod对象传进OkHttpCall，并创建一个事例。
注意点3:
return serviceMethod.callAdapter.adapt(okHttpCall);
看到adapt()这个方法，我们大家都懂，就是用callAdapter去绑定okHttpCall。那下面我们再看adapt()这个方法到底做了什么：
adapt().png
这里有三种不用的CallAdapter，我们使用的是RxJavaCallAdpter，所以点进去看看：
@Override public Object adapt(Call<R> call) {
//判断是同步还是异步请求，创建不同的OnSubscribe
OnSubscribe<Response<R>> callFunc = isAsync
? new CallEnqueueOnSubscribe<>(call)
: new CallExecuteOnSubscribe<>(call);
OnSubscribe<?> func;
if (isResult) {
func = new ResultOnSubscribe<>(callFunc);
} else if (isBody) {
func = new BodyOnSubscribe<>(callFunc);
} else {
func = callFunc;
}
Observable<?> observable = Observable.create(func);
if (scheduler != null) {
observable = observable.subscribeOn(scheduler);
}
···
return observable;
}
最后是返回一个Observable对象。
大致源码我们都看过分析过了，不清楚的流程的同学可以看看下面的流程图：
流程图.png
有同学可能最后会觉得有点奇怪，流程图的最后一步调用的是OkHttpCall.execute()（同步）方法，而不是使用OkHttpCall.enqueue()（异步）方法，为什么会这样呢？其实当Retrofit自己单独用的时候，网络请求确实调用的是OkHttpCall.enqueue()方法，但是当与RxJava一起使用的时候，Retrofit将切换线程这个工作交给了RxJava完成，所以Retrofit调用的是OkHttpCall.execute()方法，这点也是自己慢慢断点和一位师兄的提点才发现的。
从源码角度看，Retrofit更多算是一个封装库，把很多各种各样的框架连接在一起的桥梁，其中用了很多设计模式去封装，为大家带来了便捷。对于我来说，看完源码之后发现还是很多细节没弄懂，也促使自己慢慢去学习去探索，第一次发表关于源码的文章可能很多东西都有不足之处，希望大家一起指正我，跟我交流，大家一起成长！
基于以下项目讲解：
手把手为你封装一个MVP+RxJava+Retrofit2+Dagger2+BaseRecyclerView快速开发框架，两周一个版本不是梦
基于以下几位大神的文章编写：
Android：手把手带你深入剖析 Retrofit 2.0 源码
Retrofit2 完全解析 探索与okhttp之间的关系
Retrofit2.0源码解析
几个月前我在一个朋友的毕业照上再次遇到了她，其实我到现在也想不懂当初为什么会去参加。从那时候起，我就有了一种奇怪的感觉，大概那种就叫好感吧？但事以愿为，我来迟了。。。那一刻我在想，之前有多少次机会能拿到她的联系方式呢，最后因为自己的问题一次又一次的错过了。我很懊恼，那一晚我已经数不清重播了多少次《单城双恋》里面陈展鹏唱的那首《差半步》。虽然她平时很少跟我分享她开心、伤心的事，她也从来不告诉我她喜欢什么，但是我觉得能跟她普通的聊聊天我已经很知足了（她经常说知足常乐）。她说过她是一个比较特立独行的女孩，我也知道她外里总给人一种很坚强、独立的感觉，但是我觉得她的内心更需要别人的呵护、关心和督促。我很想成为那个当她迷路彷徨无助时帮助呵护她的人，很想成为那个当她伤心失落时陪伴关心她的人，也很想成为那个当她每晚晚睡督促她早睡的人。重遇她我改变了很多，以前别人都说我闷骚，现在哪怕遇到陌生人我也会慢慢试着表现自己。现在的我也敢于尝试很多东西，因为我不想再错过什么而让自己未来会后悔的事。重遇她，我才发现自己要努力成为一个优秀的人。不管以后怎样，我都希望笨笨的她能得到幸福，每天开开心心，她的学生不要欺负她，惹她生气。虽然昨天才是教师节，可能昨天赶不出文章是一个缩影，但是我也想给她一个迟来的祝福，教师节快乐！
网友评论