RxJava系列_01ObservableEmitter

RxJava源码打算花一周看看, 时间太少了, 不知道一周可以看几个操作符;

按以下的demo来学习一个RxJava的思路;

demo:

 

Observable
        .create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                LogUtils.log(getClass(), "threadName:" + Thread.currentThread().getName());
                e.onNext(1);
                e.onComplete();
            }
        })
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtils.log(getClass(), "onSubscribe()");
            }

            @Override
            public void onNext(Integer value) {
                LogUtils.log(getClass(), "onNext()");
            }

            @Override
            public void onError(Throwable e) {
                LogUtils.log(getClass(), "onError()");
            }

            @Override
            public void onComplete() {
                LogUtils.log(getClass(), "onComplete()");
            }
        });

• 打印结果:

 

04-23 23:58:14.755 3681-3681/com.test V/AndroidTest: ->onSubscribe()
04-23 23:58:14.755 3681-3681/com.test V/AndroidTest: ->subscribe()
04-23 23:58:14.755 3681-3681/com.test V/AndroidTest: ->onNext()
04-23 23:58:14.755 3681-3681/com.test V/AndroidTest: ->onComplete()

ObservableEmitter.onNext, ObservableEmitter.onComplete到底做了哪些事情?

一、Observable.create:

1.1 Observable.create:

 

public abstract class Observable<T> implements ObservableSource<T> {
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        return new ObservableCreate<T>(source);
    }
}

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
}

• 创建ObservableCreate实例, ObservableCreate持有ObservableOnSubscribe的引用;

二、Observable.subscribe:

2.1 Observable.subscribe:

 

public abstract class Observable<T> implements ObservableSource<T> {
    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        subscribeActual(observer);
    }
}

public final class ObservableCreate<T> extends Observable<T> {
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        /**
         * 1. CreateEmitter与Observer互相持有对方的引用, gc如果采用引用计数算法, 解决不了这种情况;
         * 2. 可以看出来, 被观察者持有CreateEmitter的引用, CreateEmitter持有观察者Oberser的引用, 
         *    被观察者Observable通过CreateEmitter.onXXX方法触发观察者Observer对应的onXXX方法;
         */
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        source.subscribe(parent);
    }
}

2.2 CreateEmitter:

 

static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {

    final Observer<? super T> observer;

    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }
}

操作符简单调度的流程

• demo太短, 可能并不能体现这个操作流程的巧妙之处;

如果换成我们自己来写观察者模式, 可能出现的代码是如下方式:

 

public void register() {
    Observable observable = new Observable();
    observable.addObserver(new Observer(1));
    observable.addObserver(new Observer(2));
    observable.addObserver(new Observer(3));
}

public void publish() {
    observable.publish(something);
}

public class Observable {
    public void publish(something) {
        if(succ) {...}
        else {...}
    }
}

• 反观Rxjava, 没有那么多套路, 直接一个链式调用搞定;

作者：冉桓彬
链接：https://www.jianshu.com/p/09e95195534e
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。