Retrofit+RxJava进行网络请求流程解析

1. 使用java 动态代理机制创建一个被代理的对象，也就是ApiService;

 

private <T> T getApiService(String baseUrl, Class<T> clz) {
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(baseUrl)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .build();
    return retrofit.create(clz);
}

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, 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);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
          ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.callAdapter.adapt(okHttpCall);
}
      });
}

   

2. 调用该对象的方法时，该方法的调用就会被转发到 InvocationHandler 接口的 invoke方法，也就是调用被代理对象的方法时会执行 InvocationHandler的 invoke 方法；

3.  在 invoke 方法中创建ServiceMethod类、创建OkHttpCall请求对象、在调用callAdapter 对象的 adapt方法，

那么callAdapter是哪里来的呢：以上代码片段中有一处

 ServiceMethod serviceMethod = loadServiceMethod(method)
ServiceMethod serviceMethod = loadServiceMethod(method);

;

创建了一个ServiceMethod对象，而callAdapter就是它的成员对象，那就来看看创建ServiceMethod的过程：

ServiceMethod loadServiceMethod(Method method) {
  ServiceMethod result;
  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
  }
return result;
}

首先从缓存中查找是否已经有这个方法了，如果有就直接返回，如果没有就创建，接下来看看其中的ServiceMethod.Builder(this, method).build()  方法，方法太长只贴一部分：

public ServiceMethod build() {
callAdapter = createCallAdapter();
responseType = callAdapter.responseType();
  if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw methodError("'"
+ Utils.getRawType(responseType).getName()
        + "' is not a valid response body type. Did you mean ResponseBody?");
}
responseConverter = createResponseConverter();

其中有个createCallAdapter() :

private CallAdapter<?> createCallAdapter() {
  Type returnType = method.getGenericReturnType();
  if (Utils.hasUnresolvableType(returnType)) {
throw methodError(
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw methodError("Service methods cannot return void.");
}
  Annotation[] annotations = method.getAnnotations();
  try {
return 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.callAdapter(returnType, annotations) 来创建callAdapter :

public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}

/**
 * Returns the {@link CallAdapter} for {@code returnType} from the available {@linkplain
* #callAdapterFactories() factories} except {@code skipPast}.
 *
 * @throws IllegalArgumentException if no call adapter available for {@code type}.
 */
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");

  int start = adapterFactories.indexOf(skipPast) + 1;
  for (int i = start, count = adapterFactories.size(); i < count; i++) {
    CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
    if (adapter != null) {
return adapter;
}
  }

  StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
      .append(returnType)
      .append(".\n");
  if (skipPast != null) {
    builder.append("  Skipped:");
    for (int i = 0; i < start; i++) {
      builder.append("\n   * ").append(adapterFactories.get(i).getClass().getName());
}
    builder.append('\n');
}
  builder.append("  Tried:");
  for (int i = start, count = adapterFactories.size(); i < count; i++) {
    builder.append("\n   * ").append(adapterFactories.get(i).getClass().getName());
}
throw new IllegalArgumentException(builder.toString());
}

可以看到它其实是在Retrofit这个对象的  private final List<CallAdapter.Factory> adapterFactories  中查找callAdapterFactory；

然后调用  CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this) 创建的：

这里的 adapterFactories 列表是我们在最开始设置Retrofit时设置的：

 .addCallAdapterFactory(RxJavaCallAdapterFactory.create())

此处添加的是 RxJavaCallAdapterFactory ，那么接下来就来看看  RxJavaCallAdapterFactory  类中的  get()  方法是怎么创建callAdapter的：

@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
  Class<?> rawType = getRawType(returnType);
String canonicalName = rawType.getCanonicalName();
  boolean isSingle = "rx.Single".equals(canonicalName);
  boolean isCompletable = "rx.Completable".equals(canonicalName);
  if (rawType != Observable.class && !isSingle && !isCompletable) {
return null;
}
if (!isCompletable && !(returnType instanceof ParameterizedType)) {
    String name = isSingle ? "Single" : "Observable";
    throw new IllegalStateException(name + " return type must be parameterized"
+ " as " + name + "<Foo> or " + name + "<? extends Foo>");
}

if (isCompletable) {
// Add Completable-converter wrapper from a separate class. This defers classloading such that
    // regular Observable operation can be leveraged without relying on this unstable RxJava API.
    // Note that this has to be done separately since Completable doesn't have a parametrized
    // type.
return CompletableHelper.createCallAdapter(scheduler);
}

  CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType, scheduler);
  if (isSingle) {
// Add Single-converter wrapper from a separate class. This defers classloading such that
    // regular Observable operation can be leveraged without relying on this unstable RxJava API.
return SingleHelper.makeSingle(callAdapter);
}
return callAdapter;
}

首先根据 我们定义的retrofit接口类中方法的返回值类型 来决定创建什么类型的callAdapter，这里我们就选择其中一种类型的callAdapter，来看看上面代码片段中以下这部分是怎么创建callAdapter的：

 CallAdapter<Observable<?>> callAdapter = getCallAdapter(returnType, scheduler);

看看getCallAdapter()方法详情：

private CallAdapter<Observable<?>> getCallAdapter(Type returnType, Scheduler scheduler) {
  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>");
}
    Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
    return new ResponseCallAdapter(responseType, scheduler);
}

if (rawObservableType == Result.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Result must be parameterized"
+ " as Result<Foo> or Result<? extends Foo>");
}
    Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
    return new ResultCallAdapter(responseType, scheduler);
}

return new SimpleCallAdapter(observableType, scheduler);
}

这里有可能返回3中类型的callAdapter，我们就看：

return new ResultCallAdapter(responseType, scheduler);

这句代码创建了一个 ResultCallAdapter 类型的Adapter，那我们就来看看它的 adapt() 方法吧：

@Override public <R> Observable<Result<R>> adapt(Call<R> call) {
  Observable<Result<R>> observable = Observable.create(new CallOnSubscribe<>(call)) //
.map(new Func1<Response<R>, Result<R>>() {
@Override public Result<R> call(Response<R> response) {
return Result.response(response);
}
      }).onErrorReturn(new Func1<Throwable, Result<R>>() {
@Override public Result<R> call(Throwable throwable) {
return Result.error(throwable);
}
      });
  if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;
}

该方法将做了两件事：1. 创建了一个 Observable 对象，在工作线程中调用call.execute()方法进行网络请求，并将 Observable 对象返回。下面来分析发请求的过程：

此处创建了一个任务

Observable<Result<R>> observable = Observable.create(new CallOnSubscribe<>(call)) //

来看看这个对象：

static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {
private final Call<T> originalCall;

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

@Override public void call(final Subscriber<? super Response<T>> subscriber) {
// Since Call is a one-shot type, clone it for each new subscriber.
Call<T> call = originalCall.clone();

// Wrap the call in a helper which handles both unsubscription and backpressure.
RequestArbiter<T> requestArbiter = new RequestArbiter<>(call, subscriber);
subscriber.add(requestArbiter);
subscriber.setProducer(requestArbiter);
}
}

在 call 方法中创建了一个 RequestArbiter 对象并执行了它的 request方法：

static final class RequestArbiter<T> extends AtomicBoolean implements Subscription, Producer {
private final Call<T> call;
  private final Subscriber<? super Response<T>> subscriber;

RequestArbiter(Call<T> call, Subscriber<? super Response<T>> subscriber) {
this.call = call;
    this.subscriber = subscriber;
}

@Override public void request(long n) {
if (n < 0) throw new IllegalArgumentException("n < 0: " + n);
    if (n == 0) return; // Nothing to do when requesting 0.
if (!compareAndSet(false, true)) return; // Request was already triggered.

try {
      Response<T> response = call.execute();
      if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response);
}
    } catch (Throwable t) {
      Exceptions.throwIfFatal(t);
      if (!subscriber.isUnsubscribed()) {
subscriber.onError(t);
}
return;
}

if (!subscriber.isUnsubscribed()) {
subscriber.onCompleted();
}
  }

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

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

在 request 方法中执行了  call.execute()  方法，该方法其实就是发起一个http请求；

4.  OkHttpCall对象的execute()方法实际上也是调用 okhttp3.Call 接口的execute()方法，OkHttpClient是okhttp3.Call.Factory 的实现类，所以调用的即 OkHttpClient对象中的 execute方法；

在OkHttpCall的execute方法中有以下代码：

call = rawCall;
  if (call == null) {
try {
call = rawCall = createRawCall();
} catch (IOException | RuntimeException e) {
creationFailure = e;
      throw e;
}
  }
}

if (canceled) {
call.cancel();
}

return parseResponse(call.execute());
private okhttp3.Call createRawCall() throws IOException {
  Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
  if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}

做了这几件事： 创建了一个 okhttp3.Call，调用的是serviceMethod.callFactory.newCall(request) 创建的；

而serviceMethod.callFactory 对象就是OkHttpClient 对象，也就是最早创建Retrofit对象时设置的 OkHttpClient；

所以 newCall(request) 方法的实现在OkHttpClient对象中：

@Override public Call newCall(Request request) {
return new RealCall(this, request);
}

创建了一个RealCall对象，

那么上文中

call.execute()

调用的其实是RealCall中的execute方法，

@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
try {
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain(false);
    if (result == null) throw new IOException("Canceled");
    return result;
} finally {
client.dispatcher().finished(this);
}
}

代码中：调用了Dispatcher对象中的execute()方法执行请求，其实就是将请求放到运行队列中进行执行；

/** Used by {@code Call#execute} to signal it is in-flight. */
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}

最后，Retrofit网络请求的全过程就说完啦~；如有不足之处，还请指出，谢谢啦