Retrofit是Square公司出品的一款产品，主要完成封装符合RESTful风格 的 HTTP的网络框架。Retrofit在2.0之后，HTTP网络框架内置了OKHttp，不能再配置其他的HTTP网络框架。它是一个高聚低耦的的代码结构，Client可以根据需要选择采用何种数据格式（XML/Json等）与Server交换数据，以及异步的请求结果以何种方式通知主线程（Call/Observable等）。
先从一个简单的例子说起
public interface GitHub {
@GET("/repos/{owner}/{repo}/contributors")
Call<List<Contributor>> contributors(
@Path("owner") String owner,
@Path("repo") String repo);
}
public static void main(String... args) throws IOException {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(API_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
GitHub github = retrofit.create(GitHub.class);
Call<List<Contributor>> call = github.contributors("square", "retrofit");
List<Contributor> contributors = call.execute().body();
call.enqueue(new Callback<List<Contributor>>() {
@Override
public void onResponse(Call<List<Contributor>> call, Response<List<Contributor>> response) {
List<Contributor> data = response.body();
}
@Override
public void onFailure(Call<List<Contributor>> call, Throwable t) {
}
});
for (Contributor contributor : contributors) {
System.out.println(contributor.login + " (" + contributor.contributions + ")");
}
}
以上的代码演示了retrofit的基本使用方法和步骤：
- 定义数据Bean结构
- 设计api接口
- 配置Retrofit对象
- 获得api接口的代理对象
- 执行http请求并处理返回的数据
需要一提的是，api接口的设计采用了注解的方式，好处是省去了开发者复杂的数据封装。
本篇文章主要对以上步骤3,4,5内容分析。
Retrofit类分析
Retrofit类内部主要管理3个对象
- Converter.Factory列表：主要用来管理数据序列化的，每一个converter代表一种数据格式，例如Json、Protobuf等。Retrofit允许client和server之间的数据传输可以采用多种数据格式。
- CallAdapter.Factory列表：主要管理返回结果异步处理方式，每一个callAdater代表了一种异步的处理方式，如Call，Rxjava等。Retrofit允许同时配置多种异步处理方式，默认的情况是Call的方式，现在比较流行的是Rxjava。
- ServiceMethod列表：serviceMethod是retrofit中关键的类，它完成了主要的请求封装，以及根据数据类型和api的返回类型完成converter和callAdapter的选择。
Retrofit的 配置主要就是设置Converter.Factory和 CallAdapter.Factory，以及配置一些okhttp相关的url，拦截器等。
api接口代理对象的产生过程
上图简单的展示了代理对象的产生过程：（图片来源 http://www.jianshu.com/p/45cb536be2f4）
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);
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
- 先获取serviceMethod：如果有缓存则从缓存中获取，否则创建一个新的对象。serviceMethod的创建过程非常繁琐，包括从配置的converterfactory,callAdapterFactory中选择适合该api接口的converter和callAdapter、注解的参数解析成http协议字段
- 利用serviceMethod和注解参数创建OkhttpCall，OkhttpCall是对Okhttp的封装，Retrofit2.0之后默内置了Okhttp，不再支持其他的网络框架。
- 将OkhttpCall通过callAdapter的方法adapt()转换之后返回，结果可以是Call、Obsevable等。
serviceMethod的创建过程
public ServiceMethod build() {
callAdapter = createCallAdapter();
...
responseConverter = createResponseConverter();
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
...
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
...
return new ServiceMethod<>(this);
}
- 首先选择该接口的callAdapter
- 然后选择Response的converter
- 解析接口的Method和Header
- 解析接口的参数，同时会选择Request的converter
callAdapter和converter的选择过程是retrofit设计高解耦低聚合的经典的地方，我们重点分析一下这里的源码。
serviceMethod的创建过程 -- callAdapter的选择过程
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;
}
}
...
new IllegalArgumentException(builder.toString());
}
从之前配置的callAdapter.Factory列表中依次判断是否支持某种返回类型，如果找到就返回callAdapter，否则就抛出异常。Retrofit把判断是否支持某种返回类型的操作交给了CallAdapter.Factory来做，而CallAdapter.factory是开发者自己实现的，可以自己定义CallAdapter.Factory支持哪些类型的api接口返回类型，从而实现了与Retrofit解耦。Retrofit提供了Rxjava类型的CallAdapter.Factory,开发者可以参考实现自己的CallAdapter.Factory。
serviceMethod的创建过程 -- Converter的选择过程
public <T> Converter<T, RequestBody> nextRequestBodyConverter(Converter.Factory skipPast,
Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
checkNotNull(type, "type == null");
checkNotNull(parameterAnnotations, "parameterAnnotations == null");
checkNotNull(methodAnnotations, "methodAnnotations == null");
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
Converter.Factory factory = converterFactories.get(i);
Converter<?, RequestBody> converter =
factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<T, RequestBody>) converter;
}
}
...
throw new IllegalArgumentException(builder.toString());
}
与callAdapter的选择过程类似，从之前配置的Converter.Factory列表中依次判断是否支持某种返回的数据类型，如果找到就返回converter，否则就抛出异常。Retrofit把判断是否支持某种返回数据类型的操作交给了Converter.Factory来做，而Converter.factory是开发者自己实现的，可以自己定义Converter.Factory支持哪些类型的api接口返回数据类型，从而实现了与Retrofit解耦。Retrofit提供了Json,Protobuf类型的Converter.Factory,开发者可以参考实现自己的Converter.Factory。
将OkhttpCall通过callAdapter的方法adapt()转换之后返回
在动态代理的创建过程中，最后调用CallAdapter.adapter(okhttpcall)返回，callAdapter是serviceMethod创建过程中选择的。如果没有设置Calladapter.Factory，retrofit会提供默认的CallAdapter.Factory。我们以Retrofit默认的CallAdapter.Factory为例分析。
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();
@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
return call;
}
};
}
可以看出，默认的callAdapter返回的是Call对象。
执行http请求
http请求的细节过程可以参考下一篇文章
