目前打算选用Retrofit2+RxJava2作为网络请求框架，下面从源码角度分析下这两个框架是怎么粘合在一起的。

看完本文，你将会看到:
- 动态代理模式在Retrofit中的运用。
- 抽象工厂模式在Retrofit中的运用。
- RxJava2如何和Retrofit结合实现网络请求模块。

使用Retrofit实现网络请求

定义一个Service接口

//https://api.douban.com/v2/book/1220562
public interface IDoubanService {
    

        @GET("/v2/{book}/{bookId}")
        Call<Book> getBookInfo(@Path("book") String book, @Path("bookId") String bookId);

        @GET("/v2/{book}/{bookId}")
        Observable<Book> getBookInfoObservable(@Path("book") String book, @Path("bookId") String bookId);
}

接口中的方法就是我们实际要执行的网络请求，方法的返回值就是CallAdapter的返回值，如果没有的话，默认返回Call对象。

如果我们自定义了一个返回类型，并且没有加上对应的CallAdapterFactory的话，那么抛出异常，如下：

  Caused by: java.lang.IllegalArgumentException: Unable to create call adapter for class java.lang.String

使用Retrofit创建接口的动态代理

final String bookId = "1220562";
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.douban.com/")
        // 将Response通过GSON转成POJO
        .addConverterFactory(GsonConverterFactory.create())
        // 将接口方法根据类型返回
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .client(new OkHttpClient())
        .build();
// 使用Retrofit创建接口的代理对象
IDoubanService service = retrofit.create(IDoubanService.class);
Call<Book> call = service.getBookInfo("book", bookId);
// 使用Call对象获取网络请求结果
Response<Book> response = call.execute();
Book book = response.body();

上面的示例中使用的Call进行获取的网络请求，实际上我们可以通过CallAdapterFactory这种抽象工厂来创建我们自己的返回类型，稍后详细分析。

Retrofit中的create()，用来创建动态代理

 public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(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 {
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // Platform这个类用来区分平台，如果是Java8的话，接口中会有default方法
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 将这个反射的方法封装成ServiceMethod
            // ServiceMethod会将接口中的注解进行解析
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            // 创建真实的Call对象    
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);

            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

ServiceMethod中的createCallAdapter()用于获取CallAdapter

private CallAdapter<T, R> createCallAdapter() {
      // 获取接口方法的返回值
      Type returnType = method.getGenericReturnType();

      // 检查返回类型
      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      // 返回值不能是void
      if (returnType == void.class) {
        throw methodError("Service methods cannot return void.");
      }
      Annotation[] annotations = method.getAnnotations();
      try {
        //noinspection unchecked
        // 最终会从Retrofit的CallAdapter中进行查找，还记得之前的addCallAdapterFactroy()抽象工厂么？
        return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }

最终会调到Retrofit#nextCallAdapter()，在这个方法中，会进行遍历，将Annotion和returnType传入，直到有一个Factroy能够返回非空的CallAdapter

 /**
     * Returns a call adapter for interface methods that return {@code returnType}, or null if it
     * cannot be handled by this factory.
     */
     // 这个方法需要返回非空的CallAdapter
    public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);

RxJava2ConvertFactory的实现

核心的get()

  @Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    Class<?> rawType = getRawType(returnType);

    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;
    if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
      return null;
    }

    boolean isResult = false;
    boolean isBody = false;
    Type responseType;
    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);
    if (rawObservableType == Response.class) {
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized"
            + " as Response<Foo> or Response<? extends Foo>");
      }
      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;
    }
    // 一般情况返回一个 RxJava2CallAdapter
    return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
        isSingle, isMaybe, false);
  }

RxJava2CallAdapter中的adaper()

CallAdapter中有一个核心方法是adapt()，作用是将Call对象转化成任意的类型

  /**
   * Returns an instance of {
   @code T} which delegates to {
   @code call}.
   * <p>
   * For example, given an instance for a hypothetical utility, {
   @code Async}, this instance would
   * return a new {
   @code Async<R>} which invoked {
   @code call} when run.
   * <pre><code>
   * &#64;Override
   * public &lt;R&gt; Async&lt;R&gt; adapt(final Call&lt;R&gt; call) {
   *   return Async.create(new Callable&lt;Response&lt;R&gt;&gt;() {
   *     &#64;Override
   *     public Response&lt;R&gt; call() throws Exception {
   *       return call.execute();
   *     }
   *   });
   * }
   * </code></pre>
   */
  T adapt(Call<R> call);

RxJava2CallAdapter中的实现

 // 此处就将Call对象转换成Observable了
  @Override public Object adapt(Call<R> call) {
  // 先创建一个Observable对象，根据是否是异步，默认情况下不是异步
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    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 observable;
  }

RxJava进行网络请求

RxJava接受网络请求的过程如下

observable
        // 网络请求在IO线程执行
        .subscribeOn(Schedulers.io())
        // 回调到主线程
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe((book) -> {
            mTvText.setText(String.valueOf(book));
        });

Retrofit+Factory将网络请求抽象成了一个Observable对象，那么我们可以通过RxJava这样的方法操作网络请求了。
Retrofit返回Observable的实现是CallExecuteObservable或者CallEnqueueObservable，我们看下这个Observable的实现。

final class CallExecuteObservable<T> extends Observable<Response<T>> {
    
  private final Call<T> originalCall;

  CallExecuteObservable(Call<T> originalCall) {
    this.originalCall = originalCall;
  }

  // 如果在Observeable中进行订阅操作，那么实际会调用到这个方法
  @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();
    observer.onSubscribe(new CallDisposable(call));

    boolean terminated = false;
    try {
    // 会调用Call执行网络请求，获取Response对象
      Response<T> response = call.execute();
      if (!call.isCanceled()) {
        observer.onNext(response);
      }
      if (!call.isCanceled()) {
        terminated = true;
        observer.onComplete();
      }
    } catch (Throwable t) {
      Exceptions.throwIfFatal(t);
      if (terminated) {
        RxJavaPlugins.onError(t);
      } else if (!call.isCanceled()) {
        try {
          observer.onError(t);
        } catch (Throwable inner) {
          Exceptions.throwIfFatal(inner);
          RxJavaPlugins.onError(new CompositeException(t, inner));
        }
      }
    }
  }

  private static final class CallDisposable implements Disposable {
    
    private final Call<?> call;

    CallDisposable(Call<?> call) {
      this.call = call;
    }

    @Override public void dispose() {
      call.cancel();
    }

    @Override public boolean isDisposed() {
      return call.isCanceled();
    }
  }
}

整体流程