Retrofit是目前比较流行的网络框架，它封装了okhttp作为底层的网络通讯框架, 使用动态代理方式来解析注解, 今天来扒一扒它的运行原理.
通常Retrofit的使用分为如下四步:
第一步: 定义网络接口
public interface PostRequest_Interface {
@POST("translate?doctype=json&jsonversion=&type=&keyfrom=&model=&mid=&imei=&vendor=&screen=&ssid=&network=&abtest=")
@FormUrlEncoded
Call<Translation1> getCall(@Field("i") String targetSentence);
}
第二步: 创建Retrofit
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/") // 设置 网络请求 Url
.addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
.build();
第三步: 创建代理对象
PostRequest_Interface request = retrofit.create(PostRequest_Interface.class);
第四步: 创建Call对象
Call<Translation1> call = request.getCall("I love you");
第五步:执行异步网络请求
call.enqueue(new Callback<Translation1>() {
//请求成功时回调
@Override
public void onResponse(Call<Translation1> call, Response<Translation1> response) {
System.out.println(response.body().getTranslateResult().get(0).get(0).getTgt());
}
//请求失败时回调
@Override
public void onFailure(Call<Translation1> call, Throwable throwable) {
System.out.println("请求失败");
System.out.println(throwable.getMessage());
}
});
下面通过解析源码来看看，整个内部实现原理是怎样的.
我们从第二步代码开始
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/") // 设置 网络请求 Url
.addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
.build();
这里首先会实例化一个
public Builder() {
this(Platform.get());
}
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());
}
其实这就是以build模式创建一个Retrofit实例. 接下来我们看下第三步创建代理对象
PostRequest_Interface request = retrofit.create(PostRequest_Interface.class);
下面代码比较关键，也是Retrofit的精髓所在.
image.png
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, @Nullable 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);
}
});
}
这段代码主要用到了动态代理，它通过newProxyInstance返回一个T类型的动态代理对象（实际上就是PostRequest_Interface），当我们调用
request.getCall("I love you");
实际上会执行invoke代理方法返回一个Object. 具体来看看他是怎么执行的呢。
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
通常上面这些代码一般都不会执行到,所以重点来看看下面的代码. 分为3步来看.
1，ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
2，OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
3，return serviceMethod.callAdapter.adapt(okHttpCall);
1，创建一个ServiceMethod
ServiceMethod<?, ?> loadServiceMethod(Method method) {
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder<>(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
ServiceMethod的创建是通过构造模式，构造函数中传入了method对象，在build过程中，有个比较关键函数，用于对method注解进行处理
public ServiceMethod build() {
//代码省略...
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
//代码省略...
}
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {
parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
} else if (annotation instanceof HEAD) {
parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
if (!Void.class.equals(responseType)) {
throw methodError("HEAD method must use Void as response type.");
}
}
//代码省略...
}
2，创建OkHttpCall对象，传入刚才创建serviceMethod和args
OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
this.serviceMethod = serviceMethod;
this.args = args;
}
3，用serviceMethod的callAdapter适配OkHttpCall然后返回一个T对象（此刻应该是PostRequest_Interface）
serviceMethod如何进行适配的呢,首先Retrofit创建的时候有一个接口,提供CallAdapter的创建工厂
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
callAdapter也是一个成员变量，通过build模式创建
final class ServiceMethod<R, T>{
this.callAdapter = builder.callAdapter;
}
在Builder调用createCallAdapter
static final class Builder<T, R> {
public ServiceMethod build() {
callAdapter = createCallAdapter();
}
}
private CallAdapter<T, R> createCallAdapter() {
return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
}
接着Retrofit中调用callAdapter，执行nextCallAdapter
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
CallAdapter<?, ?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
}
CallAdapter是从adapterFactories中获得. adapterFactories来自于2个地方，第一是调用
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
第二是:
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
if (callbackExecutor != null) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}
return DefaultCallAdapterFactory.INSTANCE;
}
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对象，没有做任何操作. 所以说上面
return serviceMethod.callAdapter.adapt(okHttpCall);
在第四步中实际上返回的就是okHttpCall对象.
第五步执行enqueue方法，实际上也是okHttpCall的enqueue方法
public void enqueue(final Callback<T> callback) {
if (call == null && failure == null) {
try {
call = rawCall = createRawCall();
} catch (Throwable t) {
failure = creationFailure = t;
}
}
call.enqueue()....
//代码省略...
}
call来自于createRawCall
private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
return call;
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
callFactory就是OkHttpClient， 在OkHttpClient中返回一个RealCall对象
public Call newCall(Request request) {
return new RealCall(this, request, false /* for web socket */);
}
RealCall就是okhttp提供的对象，接下来enqueue走的就是okhttp流程了.
总的来说Retrofit只是一套解析接口注解转换为一个okhttp call，然后走okhttp流程的注解解析框架.
