Android RxJava 源码流程分析

Android RxJava 源码流程分析_第1张图片
2.png

Android RxJava 源码流程分析_第2张图片
1.png

Android RxJava 源码流程分析_第3张图片
3.png

最终会形成一条被观察者链子,每个被观察者对象都有各自的线程Schedulers用来切换线程。
OkHttpCall封装okhttp3相关的操作。
我们分5个步骤来分析流程:
第一步:
在retrofit.addCallApdapterFactory(RxJava2CallAdapterFactory.create()),会把RxJava2CallAdapterFactory加入retrofit中的变量private final List adapterFactories = new ArrayList<>();
中,后面要用到这个生成适配类RxJava2CallAdapter
这个类会调用adapt(Call call)生成被观察者Observable的对象。
这是典型的桥接模式
第二步:
create函数中动态代理对象,动态代理类都必须要实现InvocationHandler这个接口,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法,即后面调用service.getSearchBook()时,会走到这个invoke的方法中。

public  T create(final Class 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 serviceMethod =
              (ServiceMethod) loadServiceMethod(method);
          OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.callAdapter.adapt(okHttpCall);
        }
      });
}
ServiceMethod loadServiceMethod(Method method) {
  ServiceMethod result = serviceMethodCache.get(method);
  if (result != null) return result;

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

其中SerivceMethod.callAdapter.adapt(okHttpCall),生成流程:
ServiceMethod.Builder().build()中,调用retroift.callAdatper()生成callAdapter对象。
在retrofit中,callAdapter又调用nextCallAdapter,在这里面,会从adapterFactories变量中取出RxJava2CallAdapterFactory对象,调用get(),生成RxJava2CallAdapter.
最后serviceMethod.callAdapter.adapt(okHttpCall),会到RxJava2CallAdapter.adapt函数中。
在RxJava2CallAdapter函数中:

@Override public  Object adapt(Call call) {
  Observable> responseObservable = new CallObservable<>(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;
}

会生成被观察者BodyObservable<>(responseObservable);其中Observable> responseObservable = new CallObservable<>(call);即BodyObservable的变量Observable> upstream
这样在第二步中生成的对象就是BodyObservable
第三步:生成被观察者ObservableSubscribeOn:
observable.subscribeOn(Schedulers.io())

public final Observable subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}

就是把BodyObservable和IoScheduler放到ObservableSubscribeOn,
其中ObservableSource source是BodyObservable
第四步:生成被观察者ObservableObserveOn
observeOn(AndroidSchedulers.mainThread())

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    ObjectHelper.verifyPositive(bufferSize, "bufferSize");
    return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
}

把ObservableSubscribeOn 和 HandlerScheduler
放入到被观察者 ObservableObserveOn,其中ObservableSource source是ObservableSubscribeOn对象,形成一条被观察者的责任链模式,对应各个的Schedulers来实现线程之间的切换,以及Disposable的接口,实现中断等。

第五步:创建观察者,通过订阅者连接被观察者。
subscribe(observer);
这个observer是观察者,通过subscribe就开始处理各个事件。

你可能感兴趣的:(Android RxJava 源码流程分析)