RxJava2（三）Subject和Processor

一， Subject

它既是一个Observable可不断调用onNext发射数据，直到遇到onComplete结束，又是一个Observer可订阅数据。它可以将订阅的数据作为自己的数据发射出去。

包含4种类型：AsyncSubject，BehaviorSubject，ReplaySubject，PublishSubject。

AsyncSubject

观察者/订阅者只会接受到onComplete之前的最后一个数据。

AsyncSubject<Integer> subject = AsyncSubject.create();
        subject.onNext(0);
        subject.onNext(1);
        subject.onNext(2);
        subject.onComplete();
        subject.subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
                Toast.makeText(MainActivity.this, integer, Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete" );
            }
        });
    }

执行结果：onNext: 2

BehaviorSubject

观察者/订阅者会收到订阅之前的最后一个数据，再继续接受之后发射过来的数据，若BehaviorSubject订阅之前未发射过数据，则发射一个默认值。

  BehaviorSubject<Integer> subject = BehaviorSubject.createDefault(9);

        subject.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) {

            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "run: onComplete");
            }
        });
        subject.onNext(0);
        subject.onNext(1);
        subject.onComplete();

输出结果：
accept:9
accept:0
accept:1
run: onComplete

ReplaySubject

1.无论何时订阅，都将发射所有的原始数据给订阅者。

ReplaySubject subject = ReplaySubject.create();

2.缓存n条数据，当订阅时只发送缓存过的数据和之后数据。

 ReplaySubject subject = ReplaySubject.createWithSize(2);
        subject.onNext(0);
        subject.onNext(1);
        subject.onNext(3);
        subject.onNext(4);
        subject.onNext(5);

        subject.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) {

            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "run: onComplete");
            }
        });
        subject.onNext(6);
        subject.onNext(7);
        subject.onComplete();

输出结果：
accept: 4
accept: 5
accept: 6
accept: 7
run: onComplete

PublishSubject

观察者只接受PublishSubject订阅之后的数据。

PublishSubject subject = PublishSubject.create();
        subject.onNext(0);
        subject.onNext(1);

        subject.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) {

            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "run: onComplete");
            }
        });
        subject.onNext(3);
        subject.onNext(4);

输出结果：
accept: 3
accept: 4

二，Processor

Processor和Subject用法一样，只是Processor支持被压。
它也包含4中类型：AsyncProcessor, BehaviorProcessor,ReplayProcessor,PublishProcessor。
用法同Subject一样。