RxJava + Retrofit源码解析

RxJava + Retrofit怎么请求网络，具体的用法这里就不讲了，本文只讲一些重点源码。

版本如下：

okhttp                         : "com.squareup.okhttp3:okhttp:3.10.0",
okhttp3_integration            : "com.github.bumptech.glide:okhttp3-integration:1.4.0@aar",
retrofit                       : "com.squareup.retrofit2:retrofit:2.4.0",
converter_gson                 : "com.squareup.retrofit2:converter-gson:2.3.0",
converter_scalars              : "com.squareup.retrofit2:converter-scalars:2.3.0",
converter_protobuf             : "com.squareup.retrofit2:converter-protobuf:2.3.0",
adapter_rxjava2                : "com.squareup.retrofit2:adapter-rxjava2:2.2.0",
logging_interceptor            : "com.squareup.okhttp3:logging-interceptor:3.10.0",
rxjava                         : "io.reactivex.rxjava2:rxjava:2.1.12",
rxandroid                      : "io.reactivex.rxjava2:rxandroid:2.0.2",

一、首先关于Retrofit的初始化：

private void initRetrofit() {
    ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance();
    retrofit = new Retrofit.Builder()
            .baseUrl(baseUrl) //设置地址
            .client(client.build()) //设置自定义的OkHttpClient
            .addConverterFactory(ProtoConverterFactory.createWithRegistry(extensionRegistry))
            .addConverterFactory(StringConverterFactory.create())
            .addConverterFactory(GsonConverterFactory.create(buildGson()))
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build();
    service = retrofit.create(ApiService.class);
}

.addConverterFactory(ProtoConverterFactory.createWithRegistry(extensionRegistry))
.addConverterFactory(StringConverterFactory.create())
.addConverterFactory(GsonConverterFactory.create(buildGson()))
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

添加了数据转换器与请求适配器。

Retrofit的初始化采用了Builder模式。

Retrofit.Builder()这一步,获取了一个平台，肯定就是Android()了，后面有地方会用到。

Builder(Platform platform) {
  this.platform = platform;
}
public Builder() {
  this(Platform.get());
}
class Platform {
  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) {
    }
    return new Platform();
  }
}

在看最后的build（）；方法：

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> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
  callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
  // Make a defensive copy of the converters.
  List<Converter.Factory> converterFactories =
      new ArrayList<>(1 + this.converterFactories.size());
  // Add the built-in converter factory first. This prevents overriding its behavior but also
  // ensures correct behavior when using converters that consume all types.
  converterFactories.add(new BuiltInConverters());
  converterFactories.addAll(this.converterFactories);
  return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
      unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}

1、如果没有传入我们自定义的OkHttpClient，那么便会使用默认的。

2、如果没有设置自定义的回调执行器，那么便会是用默认的platform.defaultCallbackExecutor();点进入可以发现回调是默认在主线程中的：

static class Android extends Platform {
  @Override public Executor defaultCallbackExecutor() {
    return new MainThreadExecutor();
  }
  @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    if (callbackExecutor == null) throw new AssertionError();
    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);
    }
  }
}

3、把我们设置的请求适配器添加进入，然后再添加一个默认的请求适配器。

4、添加进入一个默认的数据转换器，然后再被我们设置的数据转换器添加进去。

二、初始化好Retrofit后，再来看这一句：

service = retrofit.create(ApiService.class);

ApiService是一个接口，里面方法如下：

@GET
Observable<ResponseBody> doGet(@Url String url, @HeaderMap Map<String, String> headers, @QueryMap Map<String, String> map);

这个create方法可以说是核心，它运用的是动态代理。

@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
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);
          }
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
          ServiceMethod<Object, Object> serviceMethod =
              (ServiceMethod<Object, Object>) loadServiceMethod(method);
          OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.adapt(okHttpCall);
        }
      });
}

1、首先检测这是否是一个接口，只有接口才能对它进行动态代理。

2、是否需要对接口里面的方法进行初始化预加载，是的话便进行，这个与下面的有点重复，直接讲下面的。

3、return后面的语句便是动态代理的地方，它会代理接口的所有方法，也就是说，当我们调用ApiService的方法的时候，会被拦截，然后走到inoke这个方法做我们自己的操作。

关于动态代理，后面会单独讲。

4、接下来边看invoke方法：

（1）、首先判断该方法是否为Object这个类的方法，如果是，不拦截它，让他走原来的方法。

（2）、platform为Android，platform.isDefaultMethod(method)返回false，不用管它。

（3）、ServiceMethod<Object, Object> serviceMethod =(ServiceMethod<Object, Object>) loadServiceMethod(method);拿到接口的方法，对接口的方法进行解析，比如获取注解，参数之类，构造自己的serviceMethod

（4）、初始化OkHttpCall

（5）、调用serviceMethod.adapt(okHttpCall)进行请求（因为采用的是RxJava，所以这里并不会立即请求，只有被订阅的时候才会，等会会讲）

三、loadServiceMethod(method)方法：

构造自己的serviceMethod 也采用了Builder模式。

进入这个方法后，重点的一句：

result = new ServiceMethod.Builder<>(this, method).build();

先看：

Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;
  this.method = method;
  this.methodAnnotations = method.getAnnotations();
  this.parameterTypes = method.getGenericParameterTypes();
  this.parameterAnnotationsArray = method.getParameterAnnotations();
}

注：我们这里以前面定义的方法来讲解：

@GET
Observable<ResponseBody> doGet(@Url String url, @HeaderMap Map<String, String> headers, @QueryMap Map<String, String> map);

1、持有retrofit与原始的method对象。

2、获取方法上的注解，获取到的为：

3、获取参数类型，获取到的为：

4、获取参数上面的的注解，获取到的为：

再看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();
  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }
  if (httpMethod == null) {
    throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
  }
  if (!hasBody) {
    if (isMultipart) {
      throw methodError(
          "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
    }
    if (isFormEncoded) {
      throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
          + "request body (e.g., @POST).");
    }
  }
  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];
    if (Utils.hasUnresolvableType(parameterType)) {
      throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
          parameterType);
    }
    Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
    if (parameterAnnotations == null) {
      throw parameterError(p, "No Retrofit annotation found.");
    }
    parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
  }
  if (relativeUrl == null && !gotUrl) {
    throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
  }
  if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
    throw methodError("Non-body HTTP method cannot contain @Body.");
  }
  if (isFormEncoded && !gotField) {
    throw methodError("Form-encoded method must contain at least one @Field.");
  }
  if (isMultipart && !gotPart) {
    throw methodError("Multipart method must contain at least one @Part.");
  }
  return new ServiceMethod<>(this);
}

1、首先获取请求适配器。

2、创建请求结果的转换器。

3、对方法上的注解进行解析。

4、构造ParameterHandler数组。

5、对一些异常的判断。

四、我们接下来对每一步进行讲解。

1、首先获取请求适配器：

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);
  }
  if (returnType == void.class) {
    throw methodError("Service methods cannot return void.");
  }
  Annotation[] annotations = method.getAnnotations();
  try {
    //noinspection unchecked
    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);
  }
}

（1）、获取方法的返回类型，返回类型不能是void

（2）、获取方法上的注解。

（3）、调用retrofit.callAdapter(returnType, annotations)方法获取请求的适配器。（我们之前设置的请求适配器都在retrofit对象中）

里面关键的一步为：

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

skipPast为null，所以start为0；
遍历我们之前设置给它的请求适配器，根据返回类型与方法上的注解去找，找到了便返回。（我们这里获取到的callAdapter为RxJava2CallAdapter）

2、创建请求结果的转换器：

responseConverter = createResponseConverter()

这个与获取请求的适配器的过程是类似的，因此这里就略过了。

3、解析方法上的注解：parseMethodAnnotation(annotation)，我们用的是GET，所以下面会调用：

parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);

我们这里value是空的，所以它只走了下面这些就返回了。

if (this.httpMethod != null) {
        throw methodError("Only one HTTP method is allowed. Found: %s and %s.",
            this.httpMethod, httpMethod);
      }
      this.httpMethod = httpMethod;
      this.hasBody = hasBody;

      if (value.isEmpty()) {
        return;
      }

4、构造ParameterHandler数组

int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
  Type parameterType = parameterTypes[p];
  if (Utils.hasUnresolvableType(parameterType)) {
    throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
        parameterType);
  }
  Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
  if (parameterAnnotations == null) {
    throw parameterError(p, "No Retrofit annotation found.");
  }
  parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}

主要是这一个方法：

parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);

p为序号，parameterType为方法的参数类型，parameterAnnotations为参数的注解。

里面就不细讲了，这里最终得到的是：

对于一些异常的判断就不多讲了，比如：

不能有多个带@Url注解的参数。

不能同时使用@Path与@Url注解。

被@QueryMap标注的参数类型必须是Map

@QueryMap注解的参数的key必须是String

至此，我们的ServiceMethod便构造完了。

五、我们回到代理的那个方法里面，还差两句没有解析：

OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.adapt(okHttpCall);

主要看serviceMethod.adapt(okHttpCall)

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

这里的callAdapter是RxJava2CallAdapter。

于是我们来到它的adapter方法：

@Override public Object adapt(Call<R> call) {
  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;
}

首先我们看isAsync，这里为false，为什么呢？我们创建adapter的时候是这样的：

RxJava2CallAdapterFactory.create()

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

第二个参数便是isAsync

1、所以我们创建的responseObservable为CallExecuteObservable<>(call)，（同步执行的类）

2、我们创建一个Observable<?> observable，这里创建的是BodyObservable<>(responseObservable)，将刚刚创建的responseObservable

传进去。

3、最终将该observable传出去。

service = retrofit.create(ApiService.class);
public interface ApiService {
    @GET
    Observable<ResponseBody> doGet(@Url String url, @HeaderMap Map<String, String> headers, @QueryMap Map<String, String> map);
}
service.doGet(url, header, params?.params)

也就是说，当我们调用service.doGet的时候，会走到代理的invoke方法，然后返回一个Observable

而该Observable只有在被订阅的时候才会执行，而且我们用的是同步，所以还需要在外面自己切换到子线程执行。

当被订阅的时候，该BodyObservable会调用subscribeActual：

BodyObservable(Observable<Response<T>> upstream) {
  this.upstream = upstream;
}
@Override protected void subscribeActual(Observer<? super T> observer) {
  upstream.subscribe(new BodyObserver<T>(observer));
}

而这个upstream便是刚刚传进去的responseObservable，调用subscribe方法，最终会执行到responseObservable的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();
  observer.onSubscribe(new CallDisposable(call));
  boolean terminated = false;
  try {
    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));
      }
    }
  }
}

我们主要看Response<T> response = call.execute();call便是我们传进来的自定义的OkHttpCall

在call.execute()里面：

.
.
.
call = rawCall;
if (call == null) {
  try {
    call = rawCall = createRawCall();
  } catch (IOException | RuntimeException | Error e) {
    throwIfFatal(e); //  Do not assign a fatal error to creationFailure.
    creationFailure = e;
    throw e;
  }
}
.
.
.
return parseResponse(call.execute());

createRawCall()获取okhttp3.Call，call.execute()便是okhttp的网络请求了。

我们主要看怎么获取okhttp3.Call，以及对请求结果的解析parseResponse方法。

private okhttp3.Call createRawCall() throws IOException {
  okhttp3.Call call = serviceMethod.toCall(args);
  if (call == null) {
    throw new NullPointerException("Call.Factory returned null.");
  }
  return call;
}

ServiceMethod里面：

/** Builds an HTTP request from method arguments. */
okhttp3.Call toCall(@Nullable Object... args) throws IOException {
  RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
      contentType, hasBody, isFormEncoded, isMultipart);
  @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
  ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;
  int argumentCount = args != null ? args.length : 0;
  if (argumentCount != handlers.length) {
    throw new IllegalArgumentException("Argument count (" + argumentCount
        + ") doesn't match expected count (" + handlers.length + ")");
  }
  for (int p = 0; p < argumentCount; p++) {
    handlers[p].apply(requestBuilder, args[p]);
  }
  return callFactory.newCall(requestBuilder.build());
}

方法主要是构造了request然后使用okhttp3.Call.Factory创建okhttp3.Call，而我们之前在构建ServiceMothod的构造的ParameterHandler<Object>[] handlers便参与了request的构建，主要是将之前解析到的参数，比如路径，头部信息等添加到request里面。

再看一下请求结果的解析parseResponse方法：

重点语句：

T body = serviceMethod.toResponse(catchingBody);

在看serviceMethod里面的toResponse方法：

/** Builds a method return value from an HTTP response body. */
R toResponse(ResponseBody body) throws IOException {
  return responseConverter.convert(body);
}

这里便用到了我们之前设置的数据转换器，对结果进行转换。

以上便是大概的过程了。

转载请标明：https://www.cnblogs.com/tangZH/p/13723480.html