Retrofit2＜二＞ RxJava2CallAdapter分析

首先承接上面一篇文章。分析其创建过程

public static RxJava2CallAdapterFactory create() {
  return new RxJava2CallAdapterFactory(null, false);
}

默认是不传入参数。继续看构造方法。

  private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
    this.scheduler = scheduler;
    this.isAsync = isAsync;
  }

私有的，允许从create创建。看下scheduler，中文意思，调度者。isAsync 是否异步。暂时不展开，根据业务去分析细节才能深入。
//以下方法是获取CallAdapter的方法。
还是写个Servcie放这。好分析。
@FormUrlEncoded
@POST(“app/rest/people/saveHeresy”)
Observable<Response<BaseResponse>> saveHeresyToResultBean(@Nullable @FieldMap Map<String, String> paramString);

  @Override public @Nullable CallAdapter<?, ?> get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
      
    Class<?> rawType = getRawType(returnType);
   //rawType 是获取的泛型类或者泛型接口<>前面这个类。 这个其实是获取service接口的返回值了。Completable.class没用过，暂时跳过。
    if (rawType == Completable.class) {
      // Completable is not parameterized (which is what the rest of this method deals with) so it
      // can only be created with a single configuration.
      return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
          false, true);
    }
    
    boolean isFlowable = rawType == Flowable.class;
    boolean isSingle = rawType == Single.class;
    boolean isMaybe = rawType == Maybe.class;
    // 我目前用到的一半为rawType为Observable 类。
    if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
      return null;
    }
    //
    boolean isResult = false;
    boolean isBody = false;
    Type responseType;
    //returnType  都是采用的泛型类。所以不走。
    if (!(returnType instanceof ParameterizedType)) {
      String name = isFlowable ? "Flowable"
          : isSingle ? "Single"
          : isMaybe ? "Maybe" : "Observable";
      throw new IllegalStateException(name + " return type must be parameterized"
          + " as " + name + "<Foo> or " + name + "<? extends Foo>");
    }
    // 获取的泛型参数。
    Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
    //获取的是泛型参数前面的<>的类或接口。有点晕看我前面那个。
    Class<?> rawObservableType = getRawType(observableType);
    //例子确实是 Response.class
    if (rawObservableType == Response.class) {
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized"
            + " as Response<Foo> or Response<? extends Foo>");
      }
      //获取泛型参数里面的泛型类。本例子就是最里层的BaseResponse。拿到responseType 那么直接进入最后面一个方法。
      responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
    } else if (rawObservableType == Result.class) {
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Result must be parameterized"
            + " as Result<Foo> or Result<? extends Foo>");
      }
      responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
      isResult = true;
    } else {
      responseType = observableType;
      isBody = true;
    }

    return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
        isSingle, isMaybe, false);
  }

new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
isSingle, isMaybe, false);
构造一个 RxJava2CallAdapter。看构造方法。基本上就是传值进入。里面的参数的意义，等用到的时候再讲。

     RxJava2CallAdapter(Type responseType, @Nullable Scheduler scheduler, boolean isAsync,
      boolean isResult, boolean isBody, boolean isFlowable, boolean isSingle, boolean isMaybe,
      boolean isCompletable) {
    this.responseType = responseType;
    this.scheduler = scheduler;
    this.isAsync = isAsync;
    this.isResult = isResult;
    this.isBody = isBody;
    this.isFlowable = isFlowable;
    this.isSingle = isSingle;
    this.isMaybe = isMaybe;
    this.isCompletable = isCompletable;
  } 

现在进入adapt方法。这个也是最终的落脚方法。

  @Override public Object adapt(Call<R> call) {
    //注意：Observable属于观察的事件。这里代表我们的OkHttpCall请求。分为同步可观察，和异步可观察。
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);
    //根据传入 的变量，是创建ResultObservable还是BodyObservable。如果都没有还是返回responseObservable 。这里的区别在于我们是观察的对象是结果，还是body，还是Response.
    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }
  //看到这里没有，如果有 scheduler 那么subscribeOn。目前我们的schedule 创建的时候为空。但是我们可以通过别的方法set。实际上我们在使用retrofit2的时候，会要传入这个参数进去的。我列举下我们的使用。
//这里是结合的rxjava和rxandroid来的。
   //private Observable request(Observable observable, int flag) {
   //     if (flag == SINGLE) {
            //Observable 映射
   //         return observable
                    .map(this.functionSingle())
                    .compose(schedulersTransformer());
   //     } else {
   //         return observable
   //                 .map(this.functionList())
   //                 .compose(schedulersTransformer());
   //    }
   //  }*

  //  /**
  //   * rxjava
  //   */
  //  private ObservableTransformer schedulersTransformer() {
  //       return new ObservableTransformer() {
            @Override
  //          public ObservableSource apply(Observable upstream) {
  //              return upstream
  //                      .subscribeOn(Schedulers.io())
  //                      .observeOn(AndroidSchedulers.mainThread());
  //          }
  //      };
  //  }


    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return RxJavaPlugins.onAssembly(observable);
  }

到了 return RxJavaPlugins.onAssembly(observable);了，结合上面我//的代码可以看到，我们设置观察的线程再UI线程了。并且Schedulers.io()进行调度。下面需要进入return RxJavaPlugins.onAssembly(observable); 这个涉及到RxJava的东西，后续我会专门开一篇来讲这个。