Retrofit的CallAdapter创建过程分析

Call创建过程

在使用Retrofit时，需要创建Call对象，示例代码如下：

// ApiService apiService = retrofit.create(ApiService.class);
Call<User> call = apiService.getUser("exampleUser");

当调用apiService.getUser时，InvocationHandler的invoke方法会拦截方法调用并进行相应处理：

public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
            ServiceMethod serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

            // 接收一个 `okHttpCall` 对象作为参数，并返回 Call 对象
            return serviceMethod.callAdapter.adapt(okHttpCall);
        }
    });
}

在invoke方法中，创建了ServiceMethod和OkHttpCall对象，并 return 了serviceMethod.callAdapter.adapt(okHttpCall)。

在示例代码Call<User> call = apiService.getUser("exampleUser") 中，Call<User> call其实就是callAdapter.adapt(okHttpCall)的返回值。

接下来我们将分析callAdapter是如何创建的，以及callAdapter.adapt返回的具体类型。

CallAdapter的创建过程

在ServiceMethod的build()方法中，不仅处理了方法参数和注解的解析，还创建了CallAdapter和ResponseConverter：

// 构建 ServiceMethod 对象
public ServiceMethod build() {
    // 创建调用适配器
    callAdapter = createCallAdapter();
    // 获取响应类型 (responseType)
    responseType = callAdapter.responseType();
    // 创建响应转换器 (responseConverter)
    responseConverter = createResponseConverter();
    // 省略... 解析方法注解、解析方法参数过程
}

`createCallAdapter` 方法

在ServiceMethod类中，createCallAdapter方法用于获取方法的返回类型，并根据返回类型获取相应的CallAdapter：

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) {
        throw methodError(e, "Unable to create call adapter for %s", returnType);
    }
}

验证返回类型的可解析性：通过Utils.hasUnresolvableType(returnType)确保返回类型不包含类型变量或通配符。
获取注解和返回类型：使用method.getAnnotations()获取方法的所有注解，并调用retrofit.callAdapter(returnType, annotations)获取对应的CallAdapter。

Retrofit的构造函数和Builder模式

Retrofit通过Builder模式创建，并在其中设置了默认的CallAdapter.Factory。如果没有自定义的CallAdapter.Factory，将会使用默认的工厂来创建CallAdapter：

public final class Retrofit {
    private final List<CallAdapter.Factory> adapterFactories;

    Retrofit(List<CallAdapter.Factory> adapterFactories, ...) {
        this.adapterFactories = unmodifiableList(adapterFactories); // 在调用处进行防御性复制
        // ...
    }

    public static final class Builder {
        private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();

        public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
            adapterFactories.add(checkNotNull(factory, "factory == null"));
            return this;
        }

        public Retrofit build() {
            // ...
            List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
            adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
            // ...
        }
    }
}

默认的CallAdapter.Factory：如果没有自定义的CallAdapter.Factory，会调用platform.defaultCallAdapterFactory(callbackExecutor)来添加默认的工厂。

默认的CallAdapter工厂

Retrofit使用ExecutorCallAdapterFactory作为默认的CallAdapter工厂，它根据返回类型创建CallAdapter：

final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
    final Executor callbackExecutor;

    ExecutorCallAdapterFactory(Executor callbackExecutor) {
        this.callbackExecutor = callbackExecutor;
    }

    @Override
    public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        if (getRawType(returnType) != Call.class) {
            return null;
        }
        final Type responseType = Utils.getCallResponseType(returnType);
        return new CallAdapter<Call<?>>() {
            @Override
            public Type responseType() {
                return responseType;
            }
            
            @Override
            public <R> Call<R> adapt(Call<R> call) {
                return new ExecutorCallbackCall<>(callbackExecutor, call);
            }
        };
    }
}

ExecutorCallAdapterFactory的作用：根据Type创建适当的CallAdapter实例，它负责将Call对象适配为特定的响应类型。
adapt方法：在Retrofit的create方法的InvocationHandler.invoke方法中，通过serviceMethod.callAdapter.adapt(okHttpCall)调用，callAdapter.adapt(okHttpCall)方法接收okHttpCall对象，返回的是ExecutorCallbackCall对象。

总结

Retrofit的CallAdapter通过自定义和默认的CallAdapter.Factory来创建。在ServiceMethod类的build()方法中，createCallAdapter()用于获取适当的CallAdapter，从而支持动态地处理接口方法的返回类型转换。最终，CallAdapter将OkHttpCall适配为所需的响应类型，确保网络请求的结果能够方便地被客户端代码使用。

03_Retrofit工作流程-的CallAdapter创建过程