process
1 use（0.01）
- 新建接口APIService，定义方法、新增注解；
- 建造者模式新建retrofit实例；
- Retrofit.create(APIService.class)返回APIService对象实例；
- APIService.getData() 返回Call
- call.execute或者call.enqueue(callback)使用
2 Retrofit.class（40）
-
2.1 Retrofit.create(APIService.class)方法
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
// @{注解1 dynamic proxy }
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 Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
{@ 注解2 **实际调用httpServiceMethod.invoke 方法** }
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
}
-
2.2 Proxy调用 开闭原则
-
2.3 封装OKHttp请求过程 迪米特法则
2.3.1 ServiceMethod 接口隔离
ServiceMethod<?> loadServiceMethod(Method method) {
// {@1} ConCurrentHAshMap 缓存ServiceMethod (原因请查看{@HttpServiceMethod.parseAnnotation 注解})
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
//{@2 解析注解 生成httpServiceMethod实例 以及requestFactory实例 }
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
生成httpServiceMethod以及requestFactory过程
abstract class ServiceMethod<T> {
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
{@1 通过解析注解生成request}
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(method,
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw methodError(method, "Service methods cannot return void.");
}
{@2 @link HttpServiceMethod {作用：将接口方法的调用调整为HTTP调用} 请求过程 }
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
@{Retrofit#create方法 中实际调用的方法（HttpServiceMethod#invoke方法）}
@Override ReturnT invoke(Object[] args) {
解释1：callAdapter 是在Retrofit.builder().build()中 注入的 ExecutorCallAdapterFactory 的get方法中拿到的
{2.3.1 注解3 }HttpServiceMethod#invoke 方法返回OKHttpCall对象
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
2.3.2 httpServiceMethod#invoke 中的callAdapter来自哪呢？
结论：实际是在
Retrofit#loadServiceMethod -->
ServiceMethod#parseAnnotations-->
HttpServiceMethod#parseAnnotations-->
createCallAdapter()-->
retrofit#callAdapter-->
retrofit#nextCallAdapter（这个方法遍历了retrofi实例的callAdapterFactories，返回第一个不为空的callAdapter）
==最终其实回到了Retrofit的建造者的build方法中==
public Retrofit build() {
------
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(
@{ 2.3.2 注解1 默认的callAdapterFactory}
platform.defaultCallAdapterFactories(callbackExecutor));
-------
}
{ @link 对 2.3.2 注解1的解释 }
List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
if (callbackExecutor != null) {
@{ 2.3.2 注解2 回调不 为空 }
return singletonList(new ExecutorCallAdapterFactory(callbackExecutor));
}
@{ 2.3.2 注解3 回调为空}
return singletonList(DefaultCallAdapterFactory.INSTANCE);
}
@{link ==2.3.2 注解2的解释== ExecutorCallAdapterFactory#get }
@Override public @Nullable CallAdapter<?, ?> get(Type returnType,Annotation[] annotations, Retrofit retrofit) {
// {@ 2.3.2 注解4 这个是 httpMethodService#invoke方法中的实际callAdapter }
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
1、这个call是 httpMethodService#invoke（2.3.1 注解3）中传入的OkHttpCall
2、callbackExecutor实例是 在retrofit.builder()#build中注入的
Android 平台默认使用MainThreadExecutor 切换到主线程
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
// 最终调用过程
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
1、这个delegate是
httpMethodService#invoke（2.3.1 注解3）中传入的OkHttpCall对象
2、okhttpcall.enqueue 方法下面有解析
delegate.enqueue(new Callback<T>() {
@Override public void onResponse(Call<T> call, final Response<T> response) {
// Android平台默认使用MainThreadExecutor 切换到主线程
callbackExecutor.execute(new Runnable() {
@Override public void run() {
if (delegate.isCanceled()) {
1、执行retrofit回调
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
}
});
}
@Override public void onFailure(Call<T> call, final Throwable t) {
// Android 平台默认使用MainThreadExecutor 切换到主线程
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(ExecutorCallbackCall.this, t);
}
});
}
});
}
2.3.3 通过注解生成RequestBodyFactory继而生成request的过程
- 一个serviceMethod对应咱们定义的网络请求接口中的一个方法，比如栗子中的serviceApi()这个方法
- 二维数组：parameterAnnotationsArray[p][index]存所有annotation以及value 一个method N个参数parameter，一参数p对应多个annotation。
{@2.3.3 注解1 RequestFactory.Builder#build();}
RequestFactory build() {
for (Annotation annotation : methodAnnotations) {
// 解析方法名 相对路径 headers 以及path参数名
parseMethodAnnotation(annotation);
}
// 方法中参数的数量
int parameterCount = parameterAnnotationsArray.
// ParameterHandler 用于处理方法中的参数
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
{@ 2.3.3 注解2 解析参数 }
parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p]);
}
}
{ 对 2.3.3 注解2的 解释 }
private ParameterHandler<?> parseParameter(
int p, Type parameterType,@第一处 Annotation[] annotations) {
ParameterHandler<?> result = null;
if (annotations != null) {
for (Annotation annotation : annotations) {
@第二处 从单个注解中解析多个参数注解
ParameterHandler<?> annotationAction =
parseParameterAnnotation(p, parameterType, annotations, annotation);
if (annotationAction == null) {
continue;
}
result = annotationAction;
}
}
return result;
}
处理Method 中parameter 的annotation的逻辑，放入handler中
parseParameterAnnotation方法.png
2.3.4 HttpServiceMethod exatnd ServiceMethod（生成 HttpServiceMethod 的过程）
HttpServiceMethod.parseAnnotation(retrofit, method, requestFactory) 方法解析
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
Type responseType = callAdapter.responseType();
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
callFactory 这个注意一下 ！！
okhttp3.Call.Factory callFactory = retrofit.callFactory;
return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter); }
可以看到最终调用HttpServiceMethod的构造方法，callFactory 在OkHttp中会提到，至此retrofit的流程就结束了，紧接着就是okhttp的调用过程。
