Retrofit 创建过程分析

Retrofit 是一个强大的网络请求库，通过 Builder 模式创建实例，允许配置基础 URL、数据转换器、调用适配器等关键组件。

创建 Retrofit 代码示例

// 创建 Retrofit 实例
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.example.com/") // 设置基础 URL
        .addConverterFactory(GsonConverterFactory.create()) // 设置使用 Gson 解析 JSON
        .build();

源码分析

Retrofit.Builder 分析

Retrofit 的核心是通过 Retrofit.Builder 来配置实例。以下是 Builder 类的主要成员变量和方法：

public static final class Builder {
    private Platform platform; // 平台实例，用于获取当前平台的特定功能
    private okhttp3.Call.Factory callFactory; // OkHttp 的调用工厂，用于创建网络调用。OkHttpClient实现了Factory接口
    private HttpUrl baseUrl; // 基础 URL
    private List<Converter.Factory> converterFactories = new ArrayList<>(); // 数据转换器工厂集合
    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>(); // 调用适配器工厂集合
    private Executor callbackExecutor; // 回调执行器，用于在异步操作完成后执行回调
    private boolean validateEagerly; // 是否提前验证

    public Builder() {
        // 使用 Platform.get() 获取当前平台的实例，以便在不同平台上执行不同的逻辑
        this(Platform.get());
    }

    public Builder(Platform platform) {
        this.platform = platform;
    }

    public Builder client(OkHttpClient client) {
        // 设置 OkHttpClient 实例作为调用工厂
        return callFactory(checkNotNull(client, "client == null"));
    }

    public Builder callFactory(okhttp3.Call.Factory factory) {
        // 设置 OkHttp 的调用工厂
        this.callFactory = checkNotNull(factory, "factory == null");
        return this;
    }

    public Builder baseUrl(String baseUrl) {
        // 设置基础 URL
        checkNotNull(baseUrl, "baseUrl == null");
        HttpUrl httpUrl = HttpUrl.parse(baseUrl);
        if (httpUrl == null) {
            throw new IllegalArgumentException("Illegal URL: " + baseUrl);
        }
        return baseUrl(httpUrl);
    }

    public Builder baseUrl(HttpUrl baseUrl) {
        // 设置基础 URL
        this.baseUrl = checkNotNull(baseUrl, "baseUrl == null");
        return this;
    }

    public Builder addConverterFactory(Converter.Factory factory) {
        // 添加数据转换器工厂
        converterFactories.add(checkNotNull(factory, "factory == null"));
        return this;
    }

    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
        // 添加调用适配器工厂
        adapterFactories.add(checkNotNull(factory, "factory == null"));
        return this;
    }

    public Builder callbackExecutor(Executor executor) {
        // 设置回调执行器，用于在指定的线程中执行回调
        this.callbackExecutor = checkNotNull(executor, "executor == null");
        return this;
    }

    public Builder validateEagerly(boolean validateEagerly) {
        // 设置是否提前验证
        this.validateEagerly = validateEagerly;
        return this;
    }

    public Retrofit build() {
        // 检查基础 URL 是否为空，如果为空则抛出异常
        if (baseUrl == null) {
            throw new IllegalStateException("Base URL required.");
        }

        // 如果没有设置自定义的调用工厂（OkHttpClient），则使用默认的 OkHttpClient
        okhttp3.Call.Factory callFactory = this.callFactory;
        if (callFactory == null) {
            callFactory = new OkHttpClient();
        }

        // 如果没有设置自定义的回调执行器，使用平台默认的回调执行器
        Executor callbackExecutor = this.callbackExecutor;
        if (callbackExecutor == null) {
            callbackExecutor = platform.defaultCallbackExecutor();
        }

        // 复制当前的调用适配器工厂列表，并添加平台默认的调用适配器工厂
        List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.adapterFactories);
        callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

        // 复制当前的转换器工厂列表
        List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

        // 创建并返回一个新的 Retrofit 实例
        return new Retrofit(callFactory, baseUrl, converterFactories, callAdapterFactories, callbackExecutor, validateEagerly);
    }
}

Platform 类分析

分析Retrofit.Builder源码可以发现，在其构造方法中调用了 Platform.get() 方法， 在其 build() 方法中调用了 platform.defaultCallbackExecutor 和 platform.defaultCallAdapterFactory 方法，下面看下Platform的源码。

class Platform {
    private static final Platform PLATFORM = findPlatform();

    static Platform get() {
        return PLATFORM;
    }

    private static Platform findPlatform() {
        try {
            // 检查是否存在 android.os.Build 类
            Class.forName("android.os.Build");
            // 判断 Build.VERSION.SDK_INT 是否大于 0
            if (Build.VERSION.SDK_INT != 0) {
                // 返回 Android 平台
                return new Android();
            }
        } catch (ClassNotFoundException ignored) {
        }
        try {
            Class.forName("java.util.Optional");
            return new Java8();
        } catch (ClassNotFoundException ignored) {
        }
        try {
            Class.forName("org.robovm.apple.foundation.NSObject");
            return new IOS();
        } catch (ClassNotFoundException ignored) {
        }
        return new Platform();
    }

    // 平台的静态内部类
    static class Android extends Platform {
        // 默认线程池
        @Override
        public Executor defaultCallbackExecutor() {
            return new MainThreadExecutor();
        }

        // 默认 CallAdapterFactory
        @Override
        CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
            return new ExecutorCallAdapterFactory(callbackExecutor);
        }

        static class MainThreadExecutor implements Executor {
            private final Handler handler = new Handler(Looper.getMainLooper());

            @Override
            public void execute(Runnable r) {
                handler.post(r);
            }
        }
    }
}

Platform 类是 Retrofit 内部使用的工具类，根据当前运行的平台提供特定的功能支持。例如，提供默认的线程池和调用适配器。