一、简介

集成过Retrofit的猿们都知道，callback是运行在主线程中的，不用再通过异步机制处理。那么是怎么实现的呢，下面从源码角度进行分析，其中涉及到Android异步机制（Handler、Message、Looper、MessageQueue），猿们自行脑补。

二、Retrofit的创建

下面从Retrofit的创建开始，其中的秘密也在其中

Retrofit mRetrofit = new Retrofit.Builder()
                .baseUrl(UrlConfig.ROOT_URL)
                .client(genericClient())
                .addConverterFactory(GsonConverterFactory.create())
                .build();

.Builder()

public Builder() {
      this(Platform.get());
    }

private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        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();
    }

    @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);
      }
    }
  }

从上到下依次执行，最终到Android中，秘密就在defaultCallbackExecutor()中，从MainThreadExecutor命名就可以看出其作用，下面代码更是进行了验证

private final Handler handler = new Handler(Looper.getMainLooper());

不是别的就是基于主线程中的Looper创建了Handler，那么利用本Handler post进的Runnable就执行在主线程（不懂的猿们可自行脑补）中了。

题外话：还有更常见的一种是异步消息处理，在主线程中采用下列方式创建Handler

private final Handler handler = new Handler()

那么其中的Looper也是主线程中的Looper，Looper是从线程本地变量中获取的。

/**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

这种使用默认new Handler()构造的只能在主线程中创建，使用new Handler(Looper.getMainLooper())创建跟在哪儿创建无关，Looper都是主线程中的Looper

/**
     * Returns the application's main looper, which lives in the main thread of the application.
     */
    public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }

sMainLooper是应用的主线程looper，是由Android系统为应用创建的，不需要自己创建。

/**
     * Initialize the current thread as a looper, marking it as an
     * application's main looper. The main looper for your application
     * is created by the Android environment, so you should never need
     * to call this function yourself.  See also: {@link #prepare()}
     */
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

言归正传，看Retrofit的build

/**
     * Create the {@link Retrofit} instance using the configured values.
     * <p>
     * Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link
     * OkHttpClient} will be created and used.
     */
    public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }

其中callbackExecutor，就是上面创建的MainThreadExecutor，这里要记住，后面callback调用的时候要用

三、callBack的回调

先看使用

/**
     * 将call加入队列并实现回调
     *
     * @param context          应用上下文
     * @param call             调入的call
     * @param retrofitCallBack 回调
     * @param method           调用方法标志，回调用
     * @param <T>              泛型参数
     */
    public static <T> void addToEnqueue(final Context context, Call<T> call,
                                        final RetrofitCallBack retrofitCallBack, final int method) {
        call.enqueue(new Callback<T>() {
            @Override
            public void onResponse(Call<T> call, Response<T> response) {
                LogUtil.d("retrofit back code ====" + response.code());
                if (null != response.body()) {
                    if (response.code() == 200) {
                        LogUtil.d("retrofit back body ====" + new Gson().toJson(response.body()));
                        retrofitCallBack.onResponse(response, method);
                    } else {
                        LogUtil.d("toEnqueue, onResponse Fail:" + response.code());
                        ToastUtil.makeShortText(context, "网络连接错误" + response.code());
                        retrofitCallBack.onFailure(response, method);
                    }
                } else {
                    LogUtil.d("toEnqueue, onResponse Fail m:" + response.message());
                    ToastUtil.makeShortText(context, "网络连接错误" + response.message());
                    retrofitCallBack.onFailure(response, method);
                }
            }

            @Override
            public void onFailure(Call<T> call, Throwable t) {
                LogUtil.d("toEnqueue, onResponse Fail unKnown:" + t.getMessage());
                t.printStackTrace();
                ToastUtil.makeShortText(context, "网络连接错误" + t.getMessage());
                retrofitCallBack.onFailure(null, method);
            }
        });
    }

将callback加入到call的enqueue中，看下enqueue中都做了什么

@Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              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(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

其他不管，那么callback的方法就是在callbackExecutor被调用的，而这里的callbackExecutor就是MainThreadExecutor，因此这里的callback方法就运行在主线程中了。

总结：在这方面Retrofit对okhttp的封装，就好比Volley（最新的）对HttpUrlConnection的封装一样，都是采用这种方式将回调方法运行在主线程中的，其中都用到了Android最基本的异步机制（Handler、Looper、Message、MessageQueue）。通过基于主线程中的Looper创建Handler，从而实现通过此Handler post的消息能够被主线程中的Looper获取并运行在主线程中。