前言
retrofit作为最近非常火的一个网络请求框架，已经被很多同学应用到了项目中。但是同学们都知道它运作的一个流程吗？我们不仅要知其然，更要知其所以然。看过很多人都写过了对retrofit的解析，而且都写的特别不错。但是别人写的始终是别人写的（包括我这篇），同学们一定要自己跟踪一遍执行的流程，相信一定会有很大的收获。之前总是看别人对源码的分析，过不了几天就忘了，但是这次把流程过了一遍，对我产生了很大的帮助。毕竟最快的学习方法出了多敲代码之外就是阅读优秀的开源代码了。
retrofit简介
retrofit官方介绍：“A type-safe REST client for Android and Java.”它可以通过注解来描述Http请求，URL参数，查询参数，同时，它还支持多个请求体和文件上传。
使用retrofit的好处：
1.底层进行网络请求的是okhttp，retrofit是对okhttp进行了一个上层的封装，okhttp在android 4.4已经被加入源码，所以它的强大就不用我多说了吧
2.使用灵活，支持多种数据的解析，无间配合rxjaxa
3.功能模块高度封装，解耦彻底
retrofit网络请求流程
从图中可以看出retrofit起到的是一个中间者的作用，app应用层通过retrofit请求网络，实际上是retrofit对请求的url、请求头等信息进行一层封装之后交给okhttp去请求服务器，之后服务器返回原始数据给okhttp，okhttp再交给retrofit进行数据转换，最终在应用层就看到了我们想要的结果。
Retrofit使用建造者模式创建所需对象，接下来结合源码分析：
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());
}
public Builder() {
//通过构造函数找到运行平台
this(Platform.get());
}
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
try {
//要求jvm查找并加载指定类，jvm会执行改类的静态代码块
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("org.robovm.apple.foundation.NSObject");
return new IOS();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
上面代码是通过Retrofit.Builder的构造方法找到运行平台，在这里肯定返回的是Android平台;
public Builder baseUrl(String baseUrl) {
//对baseUrl进行非空检查，为空抛出一个异常
checkNotNull(baseUrl, "baseUrl == null");
//将baseUrl转换为HttpUrl对象，这里会验证baseUrl是否为一个合法的Url地址
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();
//baseUrl是否以"/"结尾
if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
}
this.baseUrl = baseUrl;
return this;
}
static <T> T checkNotNull(T object, String message) {
if (object == null) {
throw new NullPointerException(message);
}
return object;
}
上面代码是build.baseUrl()方法的源码，主要进行的工作是检查url地址是否为空且是否合法
接下来是添加转换器和rajaxa适配器，代码很简单
/** Add converter factory for serialization and deserialization of objects. */
public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
/**
* Add a call adapter factory for supporting service method return types other than {@link
* Call}.
*/
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
至于validateEagerly()这个方法，我觉得大部分同学都没用过，我也是看了源码才知道有这个方法，那么这个方法用什么作用呢？
public Builder validateEagerly(boolean validateEagerly) {
this.validateEagerly = validateEagerly;
return this;
}
点进去看发现也只是将validateEagerly的值改变了，那么它的作用是什么，我后面讲retrofit.create()方法的时候再说。
参数都设置好呢，接下来就要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);
}
从 okhttp3.Call.Factory callFactory = this.callFactory（创建一个okhttpCilent对象）可以看出默认的网络请求是通过okhttp进行的。以上retrofit就把参数都配置好了，接下来是retrofit对接口的提供信息进行包装。
接下来就是重点了，retrofit通过create方法对接口中的注解、方法和参数进行包装
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
//是否验证在生成Retrofit实例时提供的配置
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);
}
ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
private void eagerlyValidateMethods(Class<?> service) {
Platform platform = Platform.get();
//遍历接口中的方法
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method)) {
loadServiceMethod(method);
}
}
}
ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder(this, method).build();
//将请求添加到缓存
serviceMethodCache.put(method, result);
}
}
return result;
}
其实validateEagerly为true时就是提前验证在生成Retrofit实例时提供的配置。可以看到它最终是生成了一个ServiceMethod对象，而动态代理中也是要生成ServiceMethod对象。
ServiceMethod就是对接口中的方法进行验证后包装成了一个HTTP请求。
来看一下 Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] { service },
new InvocationHandler())三个参数的意义
ClassLoader loader：定义了由哪个ClassLoader对象来对生成的代理对象进行加载
Class<？>[] interfaces：一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
InvocationHandler handler：一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
再看一下 invoke(Object proxy, Method method, Object... args)中的三个参数
- Object proxy：指代我们所代理的那个真实对象
- Method method：指代的是我们所要调用真实对象的某个方法的Method对象
- Object[] args：指代的是调用真实对象某个方法时接受的参数
代理的作用是：当我们把包含网络请求接口的类传入到Retrofit的create方法后，就会利用动态代理模式，将接口解析包装成ServiceMethod，再转化成OkHttpCall供OKhttp调用。
最后通过okhttp发送给服务器，就完成了一次网络请求。
还有许多细节没有讲到，比如为什么通过注解就可以决定post、get等请求及添加head。这里就交给同学们自己去摸索啦
