我們定義接口請(qǐng)求的接口類

interface Api {
    // 登錄
    @POST("v1/crmpassport/login")
    fun login(@Body body: Map<String, String>): Observable<ResponseJson<User>>
}
// 得到接口的實(shí)例對(duì)象
T = retrofit.create(clazz)
// 調(diào)用方法，返回一個(gè)Call或者Observable對(duì)象， 請(qǐng)求網(wǎng)絡(luò)
T.login(..): Call or Observable

Retrofit的create方法，是一個(gè)動(dòng)態(tài)代理

  public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
   ...
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
      ...
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

生成的動(dòng)態(tài)代理類中，接口Api中的方法，都會(huì)在代理類中生成一個(gè)方法，不過(guò)方法里中執(zhí)行的是InvocationHandler的invoke方法，再通過(guò)反射原理執(zhí)行調(diào)用的方法。
//TODO 生成的代理類，后續(xù)補(bǔ)上。

所以我們調(diào)用Api.login(...)時(shí)會(huì)最終會(huì)執(zhí)行到

new InvocationHandler() {
          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
            ...
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        }

到這，找到了我們執(zhí)行網(wǎng)絡(luò)請(qǐng)求的開(kāi)始。

針對(duì)每一個(gè)我們調(diào)用的方法，生成一個(gè)ServiceMethod對(duì)象，再根據(jù)serviewMethod生成一個(gè)OkHttpCall對(duì)象，OkHttpCall對(duì)象再去引用okhttp3.Call去發(fā)起請(qǐng)求

看下這個(gè)過(guò)程。

• 生成ServiceMethod對(duì)象

// this:retrofit對(duì)象
new ServiceMethod.Builder<>(this, method).build()

重點(diǎn)是build()方法
1、callAdapter: 由方法返回值和注解從我們添加的addCallAdapterFactory(...)的工廠類中獲取對(duì)應(yīng)的CallAdapter
2、responseType：由callAdapter獲取到接口返回的類型
// 注釋1，后續(xù)在講到得到http的Response之后如何轉(zhuǎn)換成我們需要的數(shù)據(jù)類型時(shí)，會(huì)詳細(xì)講到
3、responseConverter: 我們添加addConverterFactory的工廠類中得出 負(fù)責(zé)接口數(shù)據(jù)轉(zhuǎn)換
4、處理注解
...

接著執(zhí)行

serviceMethod.adapt(OkHttpCall)

 T adapt(Call<R> call) {
    return callAdapter.adapt(call);
  }

從上面可知callAdapter是我們add的適配器，我們按照RxJava2CallAdapterFactory對(duì)應(yīng)的RxJava2CallAdapter來(lái)分析adapt方法

// Call<R>是OkHttpCall針對(duì)我們請(qǐng)求方法的實(shí)例化對(duì)象
@Override public Object adapt(Call<R> call) {
    Observable<Response<R>> responseObservable = isAsync
        //異步請(qǐng)求網(wǎng)絡(luò)
        ? new CallEnqueueObservable<>(call)
        // 同步請(qǐng)求網(wǎng)絡(luò)
        : new CallExecuteObservable<>(call);
    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }
    ...
    // 注釋4， 為什么返回的Observable不是responseObservable呢？
    return observable
 }

我們來(lái)分析CallEnqueueObservable異步請(qǐng)求是如何實(shí)現(xiàn)的？

CallEnqueueObservable 和 CallExecuteObservable都繼承了Observable，所以我們?cè)谟嗛喠酥髸?huì)執(zhí)行subscribeActual方法。

@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
    // Since Call is a one-shot type, clone it for each new observer.
    Call<T> call = originalCall.clone();
    CallCallback<T> callback = new CallCallback<>(call, observer);
    observer.onSubscribe(callback);
    call.enqueue(callback);
  }

call對(duì)象是OkHttpCall的實(shí)例

@Override public void enqueue(final Callback<T> callback) {
     // 最終使用的Call對(duì)象是okhttp的
     okhttp3.Call call;
     ... //創(chuàng)建call對(duì)象
     // 執(zhí)行okhttp的方法
     call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)       {
        Response<T> response;
        try {
          // 注釋2，后續(xù)在講到得到http的Response之后如何轉(zhuǎn)換成我們需要的數(shù)據(jù)類型時(shí)，會(huì)詳細(xì)講到
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }

        try {
           // 回調(diào)到OkHttpCall中enqueue傳入的callback中，即我們分析的CallEnqueueObservable的 CallCallback中
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        callFailure(e);
      }

      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
}

CallEnqueueObservable內(nèi)部類CallCallback的onResponse方法

// 注釋3， 為什么得到的數(shù)據(jù)類型是Response類型，而不是我們自定義的返回類型（泛型）
@Override public void onResponse(Call<T> call, Response<T> response) {
      if (disposed) return;

      try {
        // 觸發(fā)觀察者的onNext方法
        observer.onNext(response);
        if (!disposed) {
          terminated = true;
           // 觸發(fā)觀察者的onComplete方法
          observer.onComplete();
        }
      } catch (Throwable t) {
        if (terminated) {
          RxJavaPlugins.onError(t);
        } else if (!disposed) {
          try {
            observer.onError(t);
          } catch (Throwable inner) {
            Exceptions.throwIfFatal(inner);
            RxJavaPlugins.onError(new CompositeException(t, inner));
          }
        }
      }
    }

觸發(fā)觀察者的相關(guān)操作，之后的處理，我們就可以自己封裝我們自己業(yè)務(wù)需要的Observer了

到這，我們走完了addCallAdapterFactory方法。

那我們?cè)鯓拥玫轿覀兯璧臄?shù)據(jù)類型呢？

回到我們?cè)谏蒘erviceMethod時(shí)候提到的注釋1
具體如何生成responseConverter并做了什么操作呢

private Converter<ResponseBody, T> createResponseConverter() {
      Annotation[] annotations = method.getAnnotations();
      try {
        // responseType是前面我們得到返回值的類型
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

 public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
  }

最終調(diào)用

// type 為我們的返回值類型
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
      @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
    checkNotNull(type, "type == null");
    checkNotNull(annotations, "annotations == null");
    
    int start = converterFactories.indexOf(skipPast) + 1;
    // 根據(jù)我們addConvertFactory()方法添加的converterFactories
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      Converter<ResponseBody, ?> converter =
          converterFactories.get(i).responseBodyConverter(type, annotations, this);
      if (converter != null) {
        //noinspection unchecked
        return (Converter<ResponseBody, T>) converter;
      }
    }
}

以我們經(jīng)常用到的GsonConverterFactory為例

@Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
      // 根據(jù)我們接口請(qǐng)求返回值類型，生成指定的TypeAdapter類型
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }

至此，我們得到的responseConverter是包含了我們請(qǐng)求返回值類型的轉(zhuǎn)換器

接著我們的注釋2 parseResponse方法，如何實(shí)現(xiàn)格式的轉(zhuǎn)換

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();
    ...
    // 調(diào)用serviceMethod實(shí)現(xiàn)轉(zhuǎn)換
    T body = serviceMethod.toResponse(catchingBody);
    // 封裝成Response對(duì)象傳遞給下一級(jí)
    return Response.success(body, rawResponse);   
}

 R toResponse(ResponseBody body) throws IOException {
    // responseConverter實(shí)際上是GsonResponseBodyConverter實(shí)例對(duì)象
    return responseConverter.convert(body);
  }

//簡(jiǎn)單的gson格式轉(zhuǎn)換
@Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      T result = adapter.read(jsonReader);
      if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
        throw new JsonIOException("JSON document was not fully consumed.");
      }
      return result;
    } finally {
      value.close();
    }
  }

得到數(shù)據(jù)類型之后，再封裝成Response<T>類型，回調(diào)到OkhttpCall中的CallCallback中的onResponse方法中。

當(dāng)然到這還沒(méi)有結(jié)束。還有注釋3和注釋4的疑問(wèn)
這兩個(gè)疑問(wèn)是相關(guān)聯(lián)的。

@Override public Object adapt(Call<R> call) {
    ...
     Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }
    ...
}

我們以ResultObservable為例來(lái)分析
將真正請(qǐng)求網(wǎng)絡(luò)的responseObservable賦值給ResultObservable，然后讓用戶去觀察ResultObservable，觸發(fā)ResultObservable的subscribeActual方法

ResultObservable(Observable<Response<T>> upstream) {
    this.upstream = upstream;
  }

@Override protected void subscribeActual(Observer<? super Result<T>> observer) {
    // 觸發(fā)真正網(wǎng)絡(luò)請(qǐng)求的Observable, 請(qǐng)求結(jié)果回掉給ResultObserver
    // 但是參數(shù)observer才是我們用戶真正的observer
    upstream.subscribe(new ResultObserver<T>(observer));
  }

private static class ResultObserver<R> implements Observer<Response<R>> {
    // this.observer 是我們用戶真正的observer
    ResultObserver(Observer<? super Result<R>> observer) {
      this.observer = observer;
    }
    // 真正網(wǎng)絡(luò)請(qǐng)求的Observable觸發(fā)onNext, 回掉到這
    @Override public void onNext(Response<R> response) {
       // 返回到用戶subscribe中的onNext方法中
      observer.onNext(Result.response(response));
    }
}

至此，整個(gè)過(guò)程分析完畢。

我還有一個(gè)疑問(wèn)的是，Result.response(response)返回的結(jié)果是Result<T>類型，但是我們?cè)趏nNext里面拿到的確是T