Notas de análisis del código fuente de RxJava2 (2)
Notas de análisis de código fuente de RxJava2 (3) cambio de hilo
Veamos la llamada más simple
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Object> emitter) throws Exception {
System.out.println(" 被观察者 subscribe ");
emitter.onNext("onNext");
// onError 和 onComple 其中一个被调用就代表结束
// 另一个不会被调用，下面源码中会分析
emitter.onError(new NullPointerException());
emitter.onComplete();
}
}).subscribe(new Observer<Object>() {
@Override
public void onComplete() {
System.out.println(" onComplete ");
}
@Override
public void onError(@NonNull Throwable e) {
System.out.println(" onError " + e);
}
@Override
public void onNext(@NonNull Object object) {
System.out.println(" onNext ");
}
@Override
public void onSubscribe(@NonNull Disposable d) {
// 此方法是第一个被回调的，在其他回调方法之前
System.out.println(" 观察者onSubscribe ");
}
});
Imprimir registro (puede ver que después de que se ejecuta onError en el registro, onComplete no genera el registro)
Lo anterior es simplemente para crear un observador y luego registrar al suscriptor para recibir la devolución de llamada.
Observable.create ( el espectador ) .subscribe ( espectador );
1 Primer vistazo a Observable.create ( observado )
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
//省略其他代码，只留主要代码
return new ObservableCreate<T>(source);
} ↓
↓
↓ Mira ObservableCreate
↓
↓
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
//...后面先省略
//...Observable.create está aquí, obtenemos un objeto ObservableCreate que hereda Observable. Se implementa el método abstracto subscribeActual en Observable.
2 Vuelva a mirar. Suscribirse ( observador );
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
//观察者对象被subscribe进来以后执行了这个方法
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}Luego haga clic en subscribeActual (observer); encontrado
protected abstract void subscribeActual(Observer<? super T> observer);¿Por qué es un método abstracto? Porque la implementación específica se implementa en Observable.create ( observable ); luego regresaremos al objeto ObservableCreate obtenido por Observable.create ( observado ) arriba para ver cómo se implementa el método subscribeActual.
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
// 1 subscribe方法传进的观察者被传到了这里
// 2 Emitter是发射，发射器的意思，就是发射数据用的；并将subscribe方法传进的观察者
// 传到这个发射器里面
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
// 3 此处就是执行subscribe方法中观察者的onSubscribe方法，所以会先打印这个日志
observer.onSubscribe(parent);
try {
// 4 这个source就是create的时候传进的被观察者，执行subscribe方法
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}En la figura anterior, 4 source.subscribe (parent); en realidad se ejecuta
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Object> emitter) throws
Exception {
System.out.println(" 被观察者 subscribe ");
emitter.onNext("onNext");
// onError 和 onComple 其中一个被调用就代表结束
// 另一个不会被调用，下面源码中会分析
emitter.onError(new NullPointerException());
emitter.onComplete();
}
}而emitter接着就会执行 onNext....及后面的方法。emitter其实就是上上图中2
CreateEmitter<T> parent = new CreateEmitter<T>(observer);Haga clic para echar un vistazo
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
//CreateEmitter 是ObservableCreate中的一个内部类
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
//接收到subscribe传进来的观察者赋值给全局observer
//后面就是使用它调用onNext,onError,onComplete方法
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
if (!isDisposed()) {
//这里执行其实就是调用subscribe绑定的观察者的onNext
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (!isDisposed()) {
try {
//这里执行其实就是调用subscribe绑定的观察者的onError
observer.onError(t);
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
//这里执行其实就是调用subscribe绑定的观察者的onComplete
observer.onComplete();
} finally {
dispose();
}
}
}
//其他省略
}Una devolución de llamada tan completa funcionará.
para resumir:
Adicionalmente:
Entre ellos, la ejecución de onComplete y onError ejecutará un finalmente dentro del método dispose (), y antes de que ejecuten el juicio if (! IsDisposed ()),
Después de que se ejecute uno de ellos, el estado de disposición cambiará, por lo que el otro no se ejecutará.
De esta forma, onComplete y oneError solo ejecutarán uno de ellos, pero no ambos
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}