在说Retrofit之前 必须有了解动态代理，因为Retrofit的核心就是动态代理。
动态代理
- 动态代理就是在运行时动态创建某个interface的实例，通过Proxy.newProxyInstance产生代理类，调用接口的任何方法的时候，都会被InvocationHandler的invoke方法拦截，拿到传输的参数信息，可以做一些相应的处理。
Retrofit的Calladapter和Converter两个重要的对象
- calladapter 是适配器，帮助我们返回是适配返回的类型，
- Converter 数据组装器，负责把服务器返回的数据ResponseBody转换成T对象。
- 先看一下创建过程 也就是create
public <T> T create(final Class<T> service) {
validateServiceInterface(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
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 的creat 主要是动态代理模式，invoke方法。然后就是核心：loadServiceMethod（method）和 invoke（args）
- loadServiceMethod
这个方法主要将网络请求中的信息初步做处理，在api service中注解（@POST @GET）还有参数，进行解析，解析后有生成了一个RequestFactory的工厂对象，并利用这个对象创建了CallAdapter。 - invoke(args)
final @Nullable ReturnT invoke(Object[] args) {
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
主要是根绝loadserviceMethod 创建的RequestFactory 以及转换的参数 生产一个OkhttpCall对象。其实这个OkhttpCall对象就是对OKhttp RealCall的一个包装。
看一下OkhttpCall的网络请求：
@Override
public void enqueue(final Callback<T> callback) {
Objects.requireNonNull(callback, "callback == null");
okhttp3.Call call;
synchronized (this) {
...
if (call == null && failure == null) {
try {
call = rawCall = createRawCall();
}
}
...
call.enqueue(
new okhttp3.Callback() {
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
//解析请求返回值
response = parseResponse(rawResponse);
}
...
try {
callback.onResponse(OkHttpCall.this, response);
}
@Override
public void onFailure(okhttp3.Call call, IOException e) {
callFailure(e);
}
private void callFailure(Throwable e) {
try {
callback.onFailure(OkHttpCall.this, e);
}
}
});
}
- 调用了一个createRawCall()方法，创建rawCall，这个rawCall其实指代的就是Okhttp3的call，也就是OkHttp进行网络请求调用的一个调度器.
- 创建好OkHttp的call后,就开始调用enqueue进行异步请求.
3.okhttp3.Response这个响应，retrofit在收到结果后，进行新一轮的解析 response = parseResponse(rawResponse)，以Response对象的形式返回给开发者。
CallAdapted
loadserviceMethod 返回的是CallAdapted对象。
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
Type adapterType;
if (isKotlinSuspendFunction) {
Type[] parameterTypes = method.getGenericParameterTypes();
Type responseType =
Utils.getParameterLowerBound(
0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
// Unwrap the actual body type from Response<T>.
responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
continuationWantsResponse = true;
}
adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
} else {
adapterType = method.getGenericReturnType();
}
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
...
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
}
public CallAdapter<?, ?> nextCallAdapter(
@Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
CallAdapter根据returnType和annotation的类型，从calladapterfactories中进行查找，返回所对应的网络请求适配器。
总结一下：
- 开始动态代理调用loadServiceMethod方法，解析接口中的注解参数和头部信息。
- 根绝接口返回类型，从适配工厂集合中查询，生产相应的适配器CallAdapter，相同的形式取出数据转换器Converter。
- 用生产的CallAdapter 调用invoke方法，创建okhttpCall对象，然后进行网络请求，响应结果进行实体类转换，
- 创建好okhttpcall以后 调用CallAdapter的adapter，返回Rxjava的Observable.single或者call对象。
Retrofit结合动态代理，不用关心真正的接口方法，对符合规范的接口进行统一管理，以统一注解的方式和参数，拼接成request的请求。
retrofit是怎么将子线程切换到主线程
- 添加默认适配的时候 将callbackExecutor作为一个参数传进去了。
static final class ExecutorCallbackCall<T> implements Call<T> {
final Executor callbackExecutor;
final Call<T> delegate;
...
@Override
public void enqueue(final Callback<T> callback) {
delegate.enqueue(
new Callback<T>() {
@Override
public void onResponse(Call<T> call, final Response<T> response) {
callbackExecutor.execute(
() -> {
if (delegate.isCanceled()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on
// cancellation.
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
});
}
@Override
public void onFailure(Call<T> call, final Throwable t) {
callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
}
});
}
callbackExecutor 是一个线程调度器。在这里执行了一个异步操作delegate.enqueue.，在默认初始化中callbackExecutor = platform.defaultCallbackexcetuor().他其实内部调用的就是一个 new MainThreadExecutor(). handler.post(s) 内部使用使用Handler将响应抛到了主线程中去。这就是子线程切换到主线程的核心方法。
