Rxjava操作符

Rxjava 操作符{
    创建操作符{
        create{
            创建一个被观察者{
            Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                    observableEmitter.onNext("I");
                    observableEmitter.onComplete();
                }});
            }
        }
        just{ 创建一个被观察者 并发送事件，事件不超过10个以上  
            observable.just("1","2","3").subscribe(observer);
        }
        fromArray{ 发送事件超过10个，或者传入数组
            observable.fromArray("1","......10").subscribe(observer);
            String array[] = {"1","2","3"};
            observable.fromArray(array).subscribe(observer);
        }
        fromCallable{}
        fromFuture{}
        fromIterable{ 用于可以迭代的对象 如List
            List<String> list = new ArrayList<>();
            list.add("1");list.add("2");list.add("3");
            observable.fromIterable(list).subscribe(observer);
        }
        timer{到指定时间后就会发送一个0L的值给观察者
            Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
                @Override
                public void onSubscribe(Disposable disposable) { System.out.println("onSubscribe"); }
                @Override
                public void onNext(Long aLong) { System.out.println("onNext: "+aLong); }
                @Override
                public void onError(Throwable throwable) { }
                @Override
                public void onComplete() { System.out.println("onComplete"); }
            });
        }
        interval{  每隔多长时间执行一次onNext，并持续+1传入0L++
            Observable.interval(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
                @Override
                public void onSubscribe(Disposable disposable) { System.out.println("onSubscribe"); }
                @Override
                public void onNext(Long aLong) { System.out.println("onNext: "+aLong*2); }
                @Override
                public void onError(Throwable throwable) { }
                @Override
                public void onComplete() { System.out.println("onComplete"); }
            });
            Thread.sleep(50000);
        }
        intervalRange{ 
            从9开始，传入5个数，初始延迟2s，onNext延迟1s
            Observable.intervalRange(9,5,2,1,TimeUnit.SECONDS).subscribe(new Observer<Long>() {
                @Override
                public void onSubscribe(Disposable disposable) { System.out.println("onSubscribe"); }
                @Override
                public void onNext(Long aLong) { System.out.println("onNext: "+aLong); }
                @Override
                public void onError(Throwable throwable) { }
                @Override
                public void onComplete() { System.out.println("onComplete"); }
            });
            Thread.sleep(50000);
        }
        range{
            // 从9开始，传入3个数，9\10\11
            Observable.range(9,3).subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable disposable) { System.out.println("onSubscribe"); }
                @Override
                public void onNext(Integer integer) { System.out.println("onNext: "+integer); }
                @Override
                public void onError(Throwable throwable) { }
                @Override
                public void onComplete() { System.out.println("onComplete"); }
            });
            Thread.sleep(50000);
        }
        rangeLong{同range 事件值为long}
        empty{直接发送onComplete}
        never{不发送事件}
        error{发送onError() 时间}
    }
    转换操作符{
        map{ 转换被观察者发送的数据类型
            Observable.just(1,2,3).map(new Function<Integer, String>() {
                @Override
                public String apply(Integer integer) throws Exception {
                    return integer.toString();
                }
            }).subscribe(observer);
        }
        flatMap{ 将事件序列中的元素进行整合加工，返回一个新的观察者
            Observable.just(12,345,6789).flatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    List<String> list = new ArrayList<>();
                    for (String s : integer.toString().split(""))
                        list.add(s);
                    return Observable.fromIterable(list);
                }
            }).subscribe(observer);
        }
        concatMap{ 和flatMap 基本一致 只不过发出来的事件是有序的
            Observable.just(12,345,6789).concatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    List<String> list = new ArrayList<>();
                    for (String s : integer.toString().split(""))
                        list.add(s);
                    return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
                }
            }).subscribe(observer);
            Observable.just(12,345,6789).flatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    List<String> list = new ArrayList<>();
                    for (String s : integer.toString().split(""))
                        list.add(s);
                    return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
                }
            }).subscribe(observer);
            Thread.sleep(50);
        }
        buffer{ 将需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区一并发送  
                参数一：一次传入缓冲区多少，参数二：一次跳过多少传入
            Observable.just("1","2","3","4","5","6","7").buffer(2,1).subscribe(new Observer<List<String>>() {
                    @Override
                    public void onSubscribe(Disposable disposable) { }
                    @Override
                    public void onNext(List<String> strings) { System.out.println(strings); }
                    @Override public void onError(Throwable throwable) { }
                    @Override public void onComplete() { }
                });
            }
        groupBy{ 将发送的数据进行分组， 每组都会返回一个被观察者
            Observable.just(1,2,3,4,5).groupBy(new Function<Integer, String>() {
                @Override
                public String apply(Integer integer) throws Exception { return integer%2+""; }
            }).subscribe(new Observer<GroupedObservable<String, Integer>>() {
                @Override
                public void onSubscribe(Disposable disposable) { System.out.println("onSubscribe"); }
                @Override
                public void onNext(GroupedObservable<String, Integer> stringIntegerGroupedObservable) {
                    stringIntegerGroupedObservable.subscribe(new Observer<Integer>() {
                        @Override
                        public void onSubscribe(Disposable disposable) { System.out.println("onSub"); }
                        @Override
                        public void onNext(Integer integer) { System.out.println(integer); }
                        @Override
                        public void onError(Throwable throwable) { }
                        @Override
                        public void onComplete() { System.out.println("onComplete"); }
                    });
                }
                @Override
                public void onError(Throwable throwable) { }
                @Override
                public void onComplete() { System.out.println("onComplete"); }
            });

        }
        scan{ 将数据以一定的逻辑聚合起来
            // 输出1,12,123,1234
            Observable.just("1", "2", "3", "4").scan(new BiFunction<String, String, String>() {
                @Override
                public String apply(String s, String s2) throws Exception {
                    return s + s2;
                }
            }).subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println(s);
                }
            });
        }
        window{
            // 几个一组执行
            Observable.just("1", "2", "3", "4","5").window(2).subscribe(new Observer<Observable<String>>() {
                @Override
                public void onSubscribe(Disposable disposable) { }
                @Override
                public void onNext(Observable<String> stringObservable) { stringObservable.subscribe(observer); }
                @Override
                public void onError(Throwable throwable) { }
                @Override
                public void onComplete() { }
            });
        }


    }
    组合操作符{
        concat{
            // 多个观察者组合在一起，按顺序发送最多4个
            Observable.concat(Observable.just(1,2),Observable.just(3,4)).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        concatArray{
            同 concat  可以超过4个
        }
        merge{
            和concat一样，但是是并行发送
        }
        concatArrayDelayError{
            concat和merge当有一个Observable发送onError时候就会全部停止发送，而DelayError则会等所有Observable都发完才执行Error
        }
        mergeArrayDelayError{
            concat和merge当有一个Observable发送onError时候就会全部停止发送，而DelayError则会等所有Observable都发完才执行Error
        }
        zip{
            // 将两个Observable拉链起来，以最短的为主   结果：13 24
            Observable.zip(Observable.just(1, 2), Observable.just("3", "4", "6"), new BiFunction<Integer, String, String>() {
                @Override
                public String apply(Integer integer, String s) throws Exception {
                    return integer + s;
                }
            }).subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println(s);
                }
            });
            TimeUnit.SECONDS.sleep(3000);
        }
        combineLatest{
            和zip类似，只是不是一个一个拉链，是按最后的时间拉链 结果： 23 24 26
             Observable.combineLatest(Observable.just(1, 2), Observable.just("3", "4", "6"), new BiFunction<Integer, String, String>() {
                @Override
                public String apply(Integer integer, String s) throws Exception {
                    return integer + s;
                }
            }).subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println(s);
                }
            });
            TimeUnit.SECONDS.sleep(3000);
        }
        combineLatestDelayError{
            发送onError时不结束
        }
        reduce{// 和scan类似，只是会将所有聚合完成之后才发送  结果：10
              Observable.just(1,2,3,4).reduce(new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) throws Exception {
                    return integer+integer2;
                }
            }).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        collect{// 将发送的数据整合到数据结构中
            Observable.just(1,2,3,4).collect(new Callable<ArrayList<Integer>>() {
                @Override
                public ArrayList<Integer> call() throws Exception {
                    return new ArrayList<>();
                }
            }, new BiConsumer<ArrayList<Integer>, Integer>() {
                @Override
                public void accept(ArrayList<Integer> integers, Integer integer) throws Exception {
                    integers.add(integer);
                }
            }).subscribe(new Consumer<ArrayList<Integer>>() {
                @Override
                public void accept(ArrayList<Integer> integers) throws Exception {
                    System.out.println(integers);
                }
            });
        }
        startWith{
            // 追加一个事件  5 1 2 3 4
            Observable.just(1,2,3,4).startWith(5).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        startWithArray{ // 追加多个事件
            Observable.just(1,2,3,4).startWithArray(5).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        count{
            // 返回的是Long类型的事件个数
            Observable.just(1,2,3,4).count().subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    System.out.println(aLong);
                }
            });
        }
    }
    功能操作符{
        delay{//onNext前延迟2
            Observable.just("1","2").delay(2,TimeUnit.SECONDS).subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println(s);
                }
            });
        }
        doEach{ // 每次事件发送前执行  注意 onComplete 事件  doOnEach会多执行一次
            Observable.fromArray("1","2").doOnEach(new Consumer<Notification<String>>() {
                @Override
                public void accept(Notification<String> stringNotification) throws Exception {
                    System.out.println("doOnEach: " + stringNotification.getValue());
                }
            }).subscribe(System.out::println);
        }
        doOnNext{
            用法同上，每次onNext执行前执行
        }
        doAfterNext{
            用法同上，每次onNext执行后执行
        }
        doOnComplete{
           用法同上，每次onComplete执行前执行
            Observable.fromArray("1","2").doOnComplete(new Action() {
                @Override
                public void run() throws Exception {
                    System.out.println("fromArray");
                }
            }).subscribe(System.out::println);
        }
        doOnError{
            用法同上，每次Error执行前执行
        }
        doOnSubscribe{
            用法同上，每次onSubscribe之前执行
        }
        doOnDispose{
            用法同上，当调用Dispose的dispose()方法之前回调执行
        }
        doOnLifecycle{ // 不懂
            在回调 onSubscribe 之前回调该方法的第一个参数的回调方法，可以使用该回调方法决定是否取第二个参数的回调方法的作用与 doOnDispose() 一样
        }
        doOnTerminate{
            在 onError 或者 onComplete 发送之前回调
        }
        doAfterTerminate{
            在 onError 或者 onComplete 发送之后回调
        }
        doFinally{
            和 doAfterTerminate() 的区别就是在于取消订阅，如果取消订阅之后 doAfterTerminate() 就不会被回调，而 doFinally() 无论怎么样都会被回调，且都会在事件序列的最后
        }
        onErrorReturn{
            当接受到一个 onError() 事件之后回调，返回的值会回调 onNext() 方法，并正常结束该事件序列
        }
        onErrorResumeNext{
            当接收到 onError() 事件时，返回一个新的 Observable，并正常结束事件序列
        }
        onExceptionResumeNext{
            与 onErrorResumeNext() 作用基本一致，但是这个方法只能捕捉 Exception
        }
        retry{// onError后 会再重复发送两次直到失败【再一次onError】
            Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
                    observableEmitter.onNext(1);
                    observableEmitter.onNext(2);
                    observableEmitter.onError(new Exception("404"));
                }
            }).retry(2).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        retryUntil{// 到什么事件为止一直发送
            Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
                    observableEmitter.onNext(1);
                    observableEmitter.onError(new Exception("404"));
                }
            }).retryUntil(new BooleanSupplier() {
                int i=0;
                @Override
                public boolean getAsBoolean() throws Exception {
                    i++;
                    if(i==6) {
                        return true;
                    }
                    return false;
                }
            }).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        retryWhen{// 需要查资料  未看到 just(1,2,3) 向下游流动 只看到重试了三次
            Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
                    observableEmitter.onNext(1);
                    observableEmitter.onError(new Exception("404"));
                }
            }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                @Override
                public ObservableSource<Integer> apply(Observable<Throwable> throwableObservable) throws Exception {
                    return Observable.just(1,2,3); 
                }
            }).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        repeat{// 重复发送事件，但是只在一个 OnSubscribe里面执行3次
            Observable.just("1","2").repeat(3).subscribe(System.out::println);
        }
        repeatWhen{
            与repeat类似
        }
        {
            subscribeOn 用于指定 subscribe() 时所发生的线程
        }
        observeOn{
            observeOn 方法用于指定下游 Observer 回调发生的线程
        }
        subscribeOn 与 observeOn{
            1.简单地说，subscribeOn() 指定的就是发射事件的线程，observerOn 指定的就是订阅者接收事件的线程。
            2.多次指定发射事件的线程只有第一次指定的有效，也就是说多次调用 subscribeOn() 只有第一次的有效，其余的会被忽略。
            3.但多次指定订阅者接收线程是可以的，也就是说每调用一次 observerOn()，下游的线程就会切换一次。

            内置线程选项
            1.Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作；
            2.Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作；
            3.Schedulers.newThread() 代表一个常规的新线程；
            4.AndroidSchedulers.mainThread() 代表Android的主线程

        }

    }
    过滤操作符{
        filter{
             // 过滤符，为false则过滤掉
            Observable.just(1,2,3).filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    return integer >= 2;
                }
            }).subscribe(System.out::println);
        }
        ofType{// 类型过滤
            Observable.just(1, 2, "I").ofType(Integer.class).subscribe(System.out::println);
        }
        skip{// 跳过
            Observable.just(1, 2, 3).skip(2).subscribe(System.out::println);
        }
        distinct{// 去重
            Observable.just(1,2,3,1,2).distinct().subscribe(System.out::println);
        }
        distinctUntilChanged{// 去除连续的重复 结果：1212
            Observable.just(1,2,2,1,2).distinctUntilChanged().subscribe(System.out::println);
        }
        take{// 拿前3个
            Observable.just(1,2,3,4).take(3).subscribe(System.out::println);
        }
        debounce{
            // 两个事件事件间隔小于设定值，则前一个不会被发送，这里只发送2
            Observable.create(new ObservableOnSubscribe < Integer > () {
                @Override
                public void subscribe(ObservableEmitter < Integer > e) throws Exception {
                    e.onNext(1);
                    Thread.sleep(900);
                    e.onNext(2);
                }
            }).debounce(1, TimeUnit.SECONDS).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);
                }
            });
        }
        firstElement{
            // 取第一个
        }
        lastElement{取最后一个}
        elementAt{// 取指定下标
             Observable.just(0,1,2,3,4).elementAt(3).subscribe(System.out::println);
        }
        elementAtOrError{// 取指定下标或报错  两个貌似只取一个
            Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
                    observableEmitter.onNext(0);
                    observableEmitter.onNext(1);
                    observableEmitter.onError(new Throwable("ERROR"));
                    observableEmitter.onNext(2);
                    observableEmitter.onNext(3);
                }
            }).elementAtOrError(1).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("accept: " + integer);
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    System.out.println("throwable: " + throwable);
                }
            });
        }
    }
    条件操作符{
        all{
            // 看所有元素是否满足某个事件，都满足返回true吗，否则false
            Observable.just(1, 2, 3, 4) .all(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    if(integer > 0)
                        return true;
                    return false;
                }
            }).subscribe(new Consumer<Boolean>() {
                @Override
                public void accept(Boolean aBoolean) throws Exception {
                    System.out.println(aBoolean);
                }
            });
        }
        takeWhile{
            可以设置条件，当某个数据满足条件时就会发送该数据，反之则不发送
        }
        skipWhile{
            可以设置条件，当某个数据满足条件时不发送该数据，反之则发送
        }
        takeUntil{
            可以设置条件，当事件满足此条件时，下一次的事件就不会被发送了
        }
        skipUntil{
            当 skipUntil() 中的 Observable 发送事件了，原来的 Observable 才会发送事件给观察者
        }
        sequenceEqual{
            判断两个Observable发送的数据是否一样
        }
        contains{
            判断事件序列中是否含有某个元素，如果有则返回 true，如果没有则返回 false
        }
        isEmpty{
            判断事件序列是否为空
        }
        amb{
            amb() 要传入一个 Observable 集合，但是只会发送最先发送事件的 Observable 中的事件，其余 Observable 将会被丢弃
        }
        defaultIfEmpty{
            // 如果观察者只发送一个 onComplete() 事件，则可以利用这个方法发送一个值。
            Observable.create(new ObservableOnSubscribe < Integer > () {
                @Override
                public void subscribe(ObservableEmitter < Integer > e) throws Exception {
                    e.onComplete();
                }
            }).defaultIfEmpty(666).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println(integer);//666即为这个值
                }
            });
        }
    }
}

硬抄于：
————————————————
版权声明：本文为CSDN博主「因你太美」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_35611780/article/details/92797393

建议:
1.学习操作符可以找一些有图的博文。
2.RxJava 中有三个抽象的流概念：链式构建流、subscribeActual订阅流、观察回调流。【建议学会，有这方面的好文麻烦贴在评论里面。非常感谢！】

Observable ( 被观察者 ) / Observer ( 观察者 )
Flowable （被观察者）/ Subscriber （观察者）  支持背压 

简化版订阅方法
Consumer 即消费者，用于接收单个值，
BiConsumer 则是接收两个值，
Function 用于变换对象，
Predicate 用于判断


1，上游可以发送无限个onNext, 下游也可以接收无限个onNext.
2，当上游发送了一个onComplete后,上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
3，当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
4，上游可以不发送onComplete或onError.
5，最为关键的是onComplete和onError必须唯一并且互斥,即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError,反之亦然，发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.


Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
                i++;
                if (i == 2) {
                    Log.d(TAG, "dispose");
					// 调用将切断 上下游直接的联系  不在接收上游的 事件
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }

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

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


背压是指在【异步场景】中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。

Observable在哪个线程发事件, Observer就在哪个线程接收事件

subscribeOn() 指定的是Observable发送事件的线程, observeOn() 指定的是Observer接收事件的线程.
多次指定Observable的线程只有第一次指定的有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.
多次指定Observer的线程是可以的, 也就是说每调用一次observeOn() , Observer的线程就会切换一次

subscribeOn 作用于该操作符之前的 Observable 的创建操符作以及 doOnSubscribe 操作符



Rxjava优势及适用场景{
    优势{
        1.响应式
        2.异步
        3.支持链式调用
        4.操作符众多
        5.简化了异步处理
    }
    适用场景{
        网络请求 数据库读写 文件读写 定时任务   【各种耗时操作】
    }
}


Observable（被观察者、通过其创建可观察序列：create()方法、通过subscribe注册一个观察者） Flowable(支持背压) Sngle Comletable Maybe(结果为 true false 时适用){
    转换方式  toObservable() toFlowable() toSngle() toComletable() toMaybe()
}
Observer（观察者接受数据，subscribe方法参数） Consumer一种特殊的观察者
Disposable（接口：dispose()方法和isDisposed()方法，用于取消订阅和获取当前订阅状态）
ObservableOnSubscribe（当订阅时触发调用，向订阅者发送数据用的接口）
Emitter（即，onNext()、onError()、onComplete）