之前我们分析过了Okhttp这个优秀的网络请求库，但是在实际的使用时，还是会觉得有很多的不方便，你会发现它跟HttpUrlConnection，或者HttpClient一样，是一个比较底层的网络请求库，处理的是底层的网络请求和响应的问题。而我们在业务中要处理上层的逻辑，比如响应内容解析，方便的API实现等，这都需要我们对它进行重新封装，以适合我们特定的业务逻辑。那有没有比较简洁，方便，优雅的封装方式来封装Okhttp的使用呢，Square早以为我们考虑了这个问题，于是配套Okhttp，推出了Retrofit作为上层的网络请求库。Retrofit是Okhttp高效化封装之后的产物，虽然它之前也是可以定义使用其他底层网络库的（在Retrofit2之后去除了这个扩展）。在后面渐渐形成了Retrofit+Okhttp+RxJava网络请求三剑客的趋势。
Retrofit优点
那么Retrofit的优点是什么？（哈哈，没有优点，我凭什么使用它）
- 有容乃大，可扩展性强，底层网络请求集成了Okhttp，异步处理可集成RxJava，内容解析可集成Gson，Jackson等。
- 全面支持Restful请求，并且通过注解的方式，支持链式调用，使用简洁方便。
- 精妙的源码设计模式，内部层次分工明确，解耦性强。
一句话概括就是它以优秀的设计思想让我们能以轻松简洁的方式进行网络数据的请求。
Retrofit使用方式
接下来我们用一个简单的例子来看看它是如何处理的。
1.定义Bean类，代表请求数据的类型。
public class ZhihuDaily{
@SerializedName("date")
private String date;
@SerializedName("top_stories")
private ArrayList<ZhihuDailyItem> mZhihuDailyItems;
@SerializedName("stories")
private ArrayList<ZhihuDailyItem> stories;
//get,set方法省略
...
}
public class ZhihuDailyItem{
@SerializedName("images")
private String[] images;
@SerializedName("type")
private int type;
@SerializedName("id")
private String id;
@SerializedName("title")
private String title;
private String date;
//get,set方法省略
...
}
2.定义一个API请求接口，里面包括要访问的Restful api请求。
public interface RequestApi {
@GET("/api/4/news/latest")
Observable<ZhihuDaily> getLastDaily();
@GET("/api/4/news/before/{date}")
Observable<ZhihuDaily> getTheDaily(@Path("date") String date);
@GET("/api/4/news/{id}")
Call<ZhihuStory> getStory(@Path("id") String id);
@GET("http://lab.zuimeia.com/wallpaper/category/1/?page_size=1")
Observable<ImageResponse> getImage();
}
就是先定义一个接口，然后将开发文档中的一个REST API对应的写一个方法，在方法上加上注解，在方法参数上加上注解，返回值返回Call或者Observable，泛型类型为该数据解析之后的bean类型。这样一个请求接口就完成了。
3.获取Retrofit客户端对象。
//创建OkHttpClient对象，并对其进行配置
OkHttpClient client = new OkHttpClient.Builder()
.addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
.addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
.cache(cache)
.build();
//创建Retrofit对象，并对其进行配置
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.client(client)
.addConverterFactory(GsonConverterFactory.create())
.build().create(ZhihuApi.class);
创建一个Retrofit对象，对其进行初始化配置，这里可以对OkHttpClient对象进行配置，比如添加日志拦截，缓存设置，超时设置等，对Retrofit对象可以对CallAdapterFactory调用适配器和ConverterFactory响应数据解析器进行配置。
4.创建请求接口对象，调用响应的API方法。
RequestApi apiService = retrofit.create(RequestApi.class);
apiService.getLastDaily()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Joke>() {
@Override public void call(Joke joke) {
callBack.onSuccess(joke);
}
}, new Action1<Throwable>() {
@Override public void call(Throwable throwable) {
callBack.onFailure(throwable);
}
});
这是配合RxJava的使用方式，调用了getLastDaily方法请求数据，指定了请求在其他线程执行，响应回到主线程，成功响应到callBack.onSuccess(joke); 网络请求错误到callBack.onFailure(throwable);
在层次上来看，其实就是获取一个配置好的Retrofit客户端，然后根据配置好的RequestApi接口创建RequestApi对象，调用其中的某个API方法，然后采用RxJava的方式就可以完成一次网络数据的请求和解析处理了。我们再对其进行适合封装，会发现使用起来超级方便。
Retrofit整体架构
那么Retrofit内部是如何实现的，整体流程是怎么样的呢？在这里引用一张图让大家有Retrofit结构一个大体的了解。
Retrofit类分析
Retrofit使用建造者模式来创建对象，这样可以方便在创建Retrofit之前就对其进行一次性相应的配置。既然是采用建造者模式，里面必定是涉及一系列属性的设置，我们直接看看它的属性和内部Build构造方法。
public final class Retrofit {
//用于记录请求RequestApi中某个请求方法对应的处理方式
private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();
//okhttp的请求调用Factory
private final okhttp3.Call.Factory callFactory;
//封装的基础请求url，具体的请求就是将参数附加在其上得到具体的api地址
private final HttpUrl baseUrl;
//响应数据解析器列表
private final List<Converter.Factory> converterFactories;
//请求调用转换器列表
private final List<CallAdapter.Factory> adapterFactories;
//用于响应后的回调执行，默认是将响应post到主线程处理
private final Executor callbackExecutor;
//是否需要立即生成请求方法对应的处理对象，如果是，在create创建接口时就会生成一系列的ServiceMethod对象
private final boolean validateEagerly;
public static final class Builder {
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//没有指定OkHttpClient，则使用默认创建的OkHttpClient对象，它是实际处理底层网络请求的
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//android平台，默认callbackExecutor是ExecutorCallAdapterFactory，也就是将响应post到主线程处理
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
//调用转换器列表
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
//响应数据解析器列表
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
//生成Retrofit对象
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}
}
}
Retrofit创建接口对象
接下来我们分析Retrofit是如何根据定义的接口创建响应的可执行对象的。
public final class Retrofit {
public <T> T create(final Class<T> service) {
//验证是否接口，不是的话抛异常
Utils.validateServiceInterface(service);
//判断是否需要提前加载service中所有的method对应的ServiceMethod
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//使用动态代理的方式创建一个实现接口的对象
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
//获取平台，这里是android平台AndroidPlatform
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);
}
//默认AndroidPlatform返回false，不执行
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//最终执行这里
//加载调用方法对应的处理方式ServiceMethod
ServiceMethod serviceMethod = loadServiceMethod(method);
//创建一个原始的OkHttpCall，它内部直接使用Okhttp进行网络请求操作
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
//这里将OkHttpCall封装转换成另一种类型的对象，比如说Observable
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
//提前加载service中所有的method对应的ServiceMethod
private void eagerlyValidateMethods(Class<?> service) {
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method)) {
loadServiceMethod(method);
}
}
}
//加载service中的method对应的ServiceMethod
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;
}
}
可以看到，Retrofit是使用动态代理的方式创建了一个实现service接口的对象，当外部调用service接口方法，会调用invoke方法，然后加载当前方法对应的处理方式ServiceMethod，和创建原始的OkHttpCall，用于内部使用Okhttp去执行真正的网络请求，然后再将OkHttpCall对象封装转换成另一种类型的对象。
ServiceMethod的创建
接下来我们分析ServiceMethod做了什么。它同样使用了建造者模式进行对象创建，主要用于解析对应的接口方法。
final class ServiceMethod<T> {
static final class Builder<T> {
final Retrofit retrofit;
//对应方法
final Method method;
//方法上的注解
final Annotation[] methodAnnotations;
//方法参数上的注解
final Annotation[][] parameterAnnotationsArray;
//方法参数类型
final Type[] parameterTypes;
//返回的响应类型
Type responseType;
//判断是否找到了对应的注解
boolean gotField;
boolean gotPart;
boolean gotBody;
boolean gotPath;
boolean gotQuery;
boolean gotUrl;
//http请求方法，Get,Post等
String httpMethod;
//是否有请求体
boolean hasBody;
boolean isFormEncoded;
boolean isMultipart;
//方法上注解的相对地址url
String relativeUrl;
Headers headers;
MediaType contentType;
Set<String> relativeUrlParamNames;
//参数解析器，对诸如@GET("/api/4/news/{id}")进行解析，得到最终的url地址
ParameterHandler<?>[] parameterHandlers;
//响应内容转换器，将ResponseBody转换为其他类型
Converter<ResponseBody, T> responseConverter;
//请求调用转换器
CallAdapter<?> callAdapter;
}
//构建ServiceMethod对象
public ServiceMethod build() {
//创建CallAdapter
callAdapter = createCallAdapter();
//callAdapter的泛型类型，如某个Bean
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) {
parseMethodAnnotation(annotation);
}
if (httpMethod == null) {
throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
}
if (!hasBody) {
if (isMultipart) {
throw methodError(
"Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
}
if (isFormEncoded) {
throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
+ "request body (e.g., @POST).");
}
}
//解析参数注解
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
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);
}
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
if (parameterAnnotations == null) {
throw parameterError(p, "No Retrofit annotation found.");
}
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
if (relativeUrl == null && !gotUrl) {
throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
}
if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
throw methodError("Non-body HTTP method cannot contain @Body.");
}
if (isFormEncoded && !gotField) {
throw methodError("Form-encoded method must contain at least one @Field.");
}
if (isMultipart && !gotPart) {
throw methodError("Multipart method must contain at least one @Part.");
}
//创建最终ServiceMethod对象
return new ServiceMethod<>(this);
}
}
可以看到创建一个ServiceMethod对象需要依次创建CallAdapter请求调用转换器，创建ResponseConverter响应数据转换器，解析方法注解，方法参数注解，最后得到ServiceMethod对象。而CallAdapter和ResponseConverter的创建过程是通过查找Retrofit中的adapterFactories和converterFactories列表，根据方法的返回类型和参数类型查找是否有相应的Factory符合，如果有符合的Factory，即就可以得到最终的CallAdapter和ResponseConverter。
final class ServiceMethod<T> {
private CallAdapter<?> 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 {
return 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 final class Retrofit {
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);
//Factory获取的CallAdapter不为空，说明找到合适的CallAdapter了
if (adapter != null) {
return adapter;
}
}
...
}
}
默认CallAdapter的转换过程
默认Converter.Factory的列表中有一个ExecutorCallAdapterFactory，它的get方法返回一个CallAdapter对象，这个CallAdapter对象会将原始的OkHttpCall转换为ExecutorCallbackCall，这个ExecutorCallbackCall就是我们接口方法中返回值定义的Call接口，它封装了原始OkHttpCall用于网络请求和MainThreadExecutor用于响应数据时的线程切换。如
@GET("/api/4/news/{id}")
Call<ZhihuStory> getStory(@Path("id") String id);
//这个call就是ExecutorCallbackCall对象
Call<ZhihuStory> call = apiService.getStory("100");
call.enqueue(new Callback<Joke>() {
@Override public void onResponse(Call<Joke> call, Response<Joke> response) {
}
@Override public void onFailure(Call<Joke> call, Throwable t) {
}
});
当call调用它的enqueue方法时，就会调用它内部的OkHttpCall的enqueue方法，进而执行执行Okhttp的enqueue方法开始异步网络请求，响应返回时，用MainThreadExecutor对象将响应过程切换到主线程（默认Okhttp的响应方法是在其他线程中，MainThreadExecutor内部使用Handler将响应回调post到主线程处理）。
RxjavaCallAdapter的转换过程
如果添加了Rxjava的支持，那么在Converter.Factory列表中会有一个RxjavaCallAdapterFactory，它的get方法最终会返回一个SimpleCallAdapter对象（如果接口方法返回类型的泛型是我们定义的Bean类的话），这个SimpleCallAdapter对象会将原始的OkHttpCall转换为一个Observable对象。有了这个Observable对象就可以很方便的作线程切换和后续的其他处理了。接口方法返回类型的泛型是Response或Result，那么RxjavaCallAdapterFactory的get方法会返回ResponseCallAdapter或ResultCallAdapter。
public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
static final class SimpleCallAdapter implements CallAdapter<Observable<?>> {
private final Type responseType;
private final Scheduler scheduler;
SimpleCallAdapter(Type responseType, Scheduler scheduler) {
this.responseType = responseType;
this.scheduler = scheduler;
}
@Override public Type responseType() {
return responseType;
}
@Override public <R> Observable<R> adapt(Call<R> call) {
//这里将OkHttpCall对象转换为Observable对象
//CallOnSubscribe用于触发请求调用操作
Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) //
.lift(OperatorMapResponseToBodyOrError.<R>instance());
if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;
}
}
}
然后它在CallOnSubscribe中触发请求的调用。
public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
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.
Call<T> call = originalCall.clone();
// Wrap the call in a helper which handles both unsubscription and backpressure.
RequestArbiter<T> requestArbiter = new RequestArbiter<>(call, subscriber);
subscriber.add(requestArbiter);
subscriber.setProducer(requestArbiter);
}
}
static final class RequestArbiter<T> extends AtomicBoolean implements Subscription, Producer {
private final Call<T> call;
private final Subscriber<? super Response<T>> subscriber;
RequestArbiter(Call<T> call, Subscriber<? super Response<T>> subscriber) {
this.call = call;
this.subscriber = subscriber;
}
@Override public void request(long n) {
if (n < 0) throw new IllegalArgumentException("n < 0: " + n);
if (n == 0) return; // Nothing to do when requesting 0.
if (!compareAndSet(false, true)) return; // Request was already triggered.
//这里调用OkHttpCall的execute方法进行网络请求
try {
Response<T> response = call.execute();
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response);
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
if (!subscriber.isUnsubscribed()) {
subscriber.onError(t);
}
return;
}
if (!subscriber.isUnsubscribed()) {
subscriber.onCompleted();
}
}
@Override public void unsubscribe() {
call.cancel();
}
@Override public boolean isUnsubscribed() {
return call.isCanceled();
}
}
}
这样完成的RxJava式的转换请求流程就走通了。
CallAdapter的转换过程
那么响应数据是在哪里转换成我们定义的类型的呢？它是在OkhttpCall中进行响应数据解析转换的，不论是它的enqueue还是excute方法，响应结果都会交给parseResponse处理。
final class OkHttpCall<T> implements Call<T> {
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
//响应体
ResponseBody rawBody = rawResponse.body();
//用原始响应体封装一个新的响应体，是能够进行类型转换
// Remove the body's source (the only stateful object) so we can pass the response along.
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
//响应码
int code = rawResponse.code();
if (code < 200 || code >= 300) {
//错误响应
try {
// Buffer the entire body to avoid future I/O.
ResponseBody bufferedBody = Utils.buffer(rawBody);
return Response.error(bufferedBody, rawResponse);
} finally {
rawBody.close();
}
}
if (code == 204 || code == 205) {
//响应码为无内容，没有数据时，成功，但返回空
return Response.success(null, rawResponse);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
//这里调用serviceMethod去将响应体数据转换为指定类型
T body = serviceMethod.toResponse(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
// If the underlying source threw an exception, propagate that rather than indicating it was
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}
}
可以看到在enqueue或者excute方法执行得到响应数据后会到parseResponse将响应体数据转换为指定类型，是调用当前serviceMethod的toResponse方法进行转换，里面会调用responseConverter进行convert转换，如果我们在Retrofit配置时添加了GsonConverterFactory支持，那么就会使用GsonConverterFactory中的GsonResponseBodyConverter进行类型转换，而GsonResponseBodyConverter内部是使用gson进行类型转换。
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter<T> adapter;
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override public T convert(ResponseBody value) throws IOException {
//使用gson对ResponseBody转换为指定类型
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
}
这样响应数据类型的转换就走通了。
总结
Retrofit源码涉及了不少涉及模式，结构清晰，我想它最大的特点就是让我们以最简便的方式实现了我们的网络请求业务，同时高度的扩展性使能充分利用其它库的优点为其服务。Okhttp为其处理底层网络请求（还包括缓存处理，日志拦截等），RxJava为其提供更加广阔的调用处理方式，Gson等其他解析为响应数据解析提供了保证等等。所以借用农夫三拳的话说，“我们不生产水 我们只是大自然的搬运工”，哈哈，Retrofit，一个安静的集成管理者（美男子）。
