Retrofit是基于OkHttp封装的一个网络请求框架，底层网络请求通信由OkHttp实现。
上篇文章讲了一些OkHttp相关的一些东西，没看过的可以去看看 OkHttp相关
本篇基于v2.9.0版本分析源码及问答，先看看Retrofit的简单使用，基于使用来分析。
//1、创建OkHttpClient实例（非必须，内部帮你实例化了一个）
val mOkHttpClient = OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build()
//2、创建Retrofit实例
val mRetrofit = Retrofit.Builder()
.client(mOkHttpClient)
.baseUrl("http://api.wanandroid.com")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build()
//3、利用动态代理获取ApiService接口
val apiService = mRetrofit.create(ApiService::class.java)
//4、调用ApiService接口方法获取Call对象
val call = apiService.getCall()
//5、Call对象同步请求
val response = call.execute()
//5、Call对象异步请求
call.enqueue(object : Callback<String>{
override fun onFailure(call: Call<String>, t: Throwable) {
//请求失败
}
override fun onResponse(call: Call<String>, response: Response<String>) {
//请求成功
}
})
Retrofit的使用流程分为五个步骤：
1、创建OkHttpClient实例，但是这个步骤非必须，Retrofit中默认给初始化了一个OkHttpClient。
2、创建Retrofit实例（通过建造者模式），设置自定义的OkHttpClient对象、baseUrl、以及数据转换器、适配器等等。
3、利用动态代理获取ApiService接口的代理对象
4、使用代理对象获取Call对象
5、使用Call对象进行同步、异步网络请求。
创建OkHttpClient这步在上篇文章中已经说的挺多了，这里就不再解释。直接看如何创建Retrofit对象实例：
直接看看build方法，这里面其实默认了很多参数，唯独baseUrl
public Retrofit build() {
if (baseUrl == null) {
//如果baseUrl为空则直接抛出异常
throw new IllegalStateException("Base URL required.");
}
//默认一个callFactory（OkHttpClient）
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//回调执行器，默认实现为MainThreadExecutor，其实就是通过Handler切换线程用
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
// 网络请求适配器工厂类集合，默认设置为DefaultCallAdapterFactory，配合RxJava使用时，设置为RxJava2CallAdapterFactory
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
// 数据解析器
List<Converter.Factory> converterFactories =
new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
// 首先添加内置转换器工厂。这样既可以防止覆盖其行为，又可以在使用所有类型的转换器时确保正确的行为。
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
converterFactories.addAll(platform.defaultConverterFactories());
return new Retrofit(
callFactory,
baseUrl,
unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories),
callbackExecutor,
validateEagerly);
}
}
}
这里除了baseUrl没有默认，原因也很简单，不能默认请求地址吧？，所以如果请求地址为空，直接抛出异常。baseUrl方法可以将字符串转换成HttpUrl对象，具体看看源码：
public Builder baseUrl(String baseUrl) {
Objects.requireNonNull(baseUrl, "baseUrl == null");
return baseUrl(HttpUrl.get(baseUrl));
}
//HttpUrl是一个final修饰的类，代表着设置了以后无法再修改，这里就会引出一个问题：多baseUrl的应用应该怎么做？
public final class HttpUrl {}
问：多baseUrl该怎么处理
答：Retrofit中baseUrl(String baseUrl)方法最终会将baseUrl字符串转换成HttpUrl对象，而HttpUrl是final修饰的，也就是说设置了baseUrl以后，HttpUrl无法修改，解决方案如下：
1、不同baseUrl创建不同Retrofit的方式（这样会造成部分资源浪费，如果比较多的baseUrl也将难以管理）
1、@GET、@POST 等不仅可以传入接口地址，也可以传入全路径，从而实现多baseUrl效果。但是注解上的值只能是 final 的常量
3、 @Url 这个标注到每个接口方法参数上的注解,它可以将全路径作为参数传进接口作为每次请求的 Url 地址,每次请求接口都可以将不同的全路径作为参数,从而达到支持多个 BaseUrl 以及在运行时动态改变 BaseUrl
4、通过OkHttp拦截器实现动态切换baseUrl（传入不同的header，如果有特殊标识的header则使用新的url重新构建HttpUrl对象）
5、final修饰的HttpUrl无法修改，但是可以使用反射机制来实现动态切换baseUrl
Retrofit帮我们做了一件事就是允许开发者设置数据解析器，利用数据解析器将数据解析成开发者较为容易处理的数据。
接下来就是使用动态代理技术获取接口对象，通过接口对象调用接口中的方法获取Call对象，利用Call对象调用同步或异步请求方法，最终会转化为OkHttp的同步或异步方法。
来看看create()方法都做了些什么：
public <T> T create(final Class<T> service) {
//...
return (T)
//使用动态代理
Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// 如果该方法是Object的方法，直接执行
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
args = args != null ? args : emptyArgs;
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args); //重点关注一下这个方法（获取方法执行）
}
});
}
动态代理中最后执行了 获取方法并执行的操作：
//Retrofit.java
//缓存，用了线程安全ConcurrentHashMap
final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
//如果Service中的方法已经缓存，则直接返回缓存的方法
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
//解析method的注解，创建ServiceMethod并缓存起来
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
//解析method的注解 ServiceMethod.java
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//检查方法注解的path、返回值、请求方式等等是否合规，最后返回RequestFactory对象
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
//处理获取合适的 请求适配器以及数据处理转换器等，最后返回CallAdapted（先不管kotlin挂起函数）
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
//返回的CallAdapted对象后执行invoke函数，调用到了
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
return callAdapter.adapt(call);
}
之后，adapt的方法实现方法有：
这里就是在使用建造者模式创建Retrofit对象实例时addCallAdapterFactory()方法的CallAdapter适配器，如果不传则使用默认：
最后在代理对象调用同步或者异步方法时，调用响应的同步或异步方法，最终再通过OkHttp进行网络请求。
总结一下：
Retrofit就是一个网络请求框架的封装，底层的网络请求默认使用的Okhttp，本身只是简化了用户网络请求的参数配置等，还能与Rxjava相结合，使用起来更加简洁方便。
1、App应用程序通过Retrofit请求网络，实际上是使用Retrofit接口层封装请求参数，之后由OkHttp完成后续的请求操作。
2、在服务端返回数据之后，OkHttp将原始的结果交给Retrofit，Retrofit根据用户的需求对结果进行解析。
