Uno, introducción a RxJava
Rxjava es una biblioteca de terceros que se utilizará en muchos proyectos. En el proyecto, Rxjava + retrofit es útil para el desarrollo de proyectos, por lo que comprender el principio de esta biblioteca de terceros puede resolver muchos problemas ocultos.
2. Análisis de procesos
Eventualmente se formará una cadena de observadores, y cada objeto observador tiene sus propios programadores de hilos para cambiar de hilo.
OkHttpCall encapsula las operaciones relacionadas con okhttp3.
Analice el proceso en 5 pasos:
Paso 1: Configure RxJava2CallAdapter
en retrofit.addCallApdapterFactory (RxJava2CallAdapterFactory.create ()), y agregue RxJava2CallAdapterFactory a la variable private final List <CallAdapter.Factories <> adapter () ;
En, la clase de adaptación de generación RxJava2CallAdapter
se utilizará más adelante. Esta clase llamará adapt (Call call) para generar el objeto Observable del observable . Este es un modo puente típico.
Paso 2: En la
función de creación de objeto de proxy dinámico del objeto de proxy dinámico, la clase de proxy dinámico debe implementar la interfaz InvocationHandler. Cuando llamamos a un método a través del objeto proxy, la llamada de este método se reenviará a la interfaz de InvocationHandler invocar método para realizar la llamada. Echemos un vistazo al único método de invocación de método de la interfaz InvocationHandler, es decir, cuando service.getSearchBook () se llame más tarde, irá a este método de invocación.
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.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;
}
Entre ellos, SerivceMethod.callAdapter.adapt (okHttpCall), proceso de generación: En
ServiceMethod.Builder (). Build (), llame retroift.callAdatper () para generar el objeto callAdapter.
En la actualización, callAdapter vuelve a llamar a nextCallAdapter. En él, el objeto RxJava2CallAdapterFactory se saca de la variable adapterFactories, y se llama a get () para generar RxJava2CallAdapter.
Finalmente, serviceMethod.callAdapter.adapt (okHttpCallAdapter.adapt (okHttpCallAdapter.adapt (okHttpCall).
En la función RxJava2CallAdapter:
@Override public <R> Object adapt(Call<R> call) {
Observable<Response<R>> 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;
}
Observable se generará BodyObservable <> (responseObservable); donde Observable <Response> responseObservable = new CallObservable <> (llamada); es decir, la variable Observable <Response> aguas arriba del BodyObservable,
por lo que el objeto generado en el segundo paso es el
tercer paso del BodyObservable : Generar ObservableSubscribeOn
observable.subscribeOn (Schedulers.io ())
public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
Coloque BodyObservable e IoScheduler en ObservableSubscribeOn,
donde la fuente de ObservableSource es BodyObservable
Paso 4: Genere ObservableObserveOn
observeOn (AndroidSchedulers.mainThread ())
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}
Coloque ObservableSubscribeOn y HandlerScheduler
en ObservableObserveOn observable, donde la fuente ObservableSource es un objeto ObservableSubscribeOn, formando un modo de cadena de responsabilidad del observable, correspondiente a cada Programador para realizar el cambio entre hilos, y la interfaz Disposable, para realizar interrupciones, etc.
Paso 5: Cree un observador y conéctese a la
suscripción observada (observador) a
través del suscriptor ; este observador es un observador y comienza a procesar cada evento a través de la suscripción.