RxJava的基础知识

1、Observable

一、使用RxJava的三步骤

（1）、创建Observable

             被观察者，使用RxJava需要一个被观察者，决定什么时候触发事件以及触发怎么样的事件，决定异步操作模块的顺序和异步操作模块的次数

（2）、创建Observer

             创建一个处于待命状态的观察者哨兵，可以在未来某个时刻响应Observable的通知，不需要阻塞等待Observable发射数据

（3）、使用subscribe()订阅

             将Observable和Observer连接起来

 Observable
                .just("Hello World")
                .doOnNext((s) -> System.out.println(s + " kruaser"))
                .doOnNext((s) -> System.out.println(s + " kruaser2"))
                .doAfterNext(s -> System.out.println(s + " kruaser3"))
                .doAfterNext(s -> System.out.println(s + " kruaser4"))
                .doOnComplete(() ->
                        System.out.println("done2!")
                )
                .doOnSubscribe((disposable1) ->
                        System.out.println("begin2!")
                )
                .doOnEach((n) -> System.out.println("=>"+n.isOnNext()))
                .subscribe(
                        System.out::println,
                        System.out::println,
                        () -> System.out.println("done!"),
                        (disposable1) ->
                                System.out.println("begin!"));

 

2、5种观察者模式

类型	描述
Observable	能够发射0或n个数据，并以成功或错误事件终止
Flowable	能够发射0或n个数据，并以成功或错误事件终止，可以控制数据源发射速度
Single	只能发射单个数据或错误事件
Completable	从来不发射数据，只处理onComplete和OnError事件
Maybe	能够发射0或者个数据，要么成功，要么失败

 

   // Single 只有onSuccess和onError
        Single.create(emitter -> {
                    // 发射
                    emitter.onSuccess("test");
                    // 不发射
                    emitter.onSuccess("test1");
                }
        ).subscribe(
                // success
                System.out::println,
                // error
                System.err::println);

        // Completable不会发射任何数据
        Disposable subscribe = Completable.create(completableEmitter -> {
            try {
                // 不会发射任何数据
                completableEmitter.onComplete();
            } catch (Exception e) {
                completableEmitter.onError(e);
            }
        })
                // 完成之后的操作
                .andThen(Observable.range(0, 10))
                .subscribe(System.out::println);

        // Maybe
        Maybe.create(completableEmitter -> {
            try {
                // 不会发射任何数据
                completableEmitter.onComplete();
                completableEmitter.onSuccess("test");
                completableEmitter.onSuccess("test1");
            } catch (Exception e) {
                completableEmitter.onError(e);
            }
        }).subscribe(System.out::println);

 

3、Hot和Cold Observable

Hot Observable无论有没有观察者进行订阅，事件始终都会发生,与订阅者么是一对多的关系
Cold Observable是只有观察者订阅了，才开始执行发射数据流的代码,与订阅者是一对一的关系

  /**
     * Cold Observable是只有观察者订阅了，才开始执行发射数据流的代码,与订阅者是一对一的关系
     */
    public void codeObservableDemo() {
        Observable<String> observable = Observable.create(emitter ->
                emitter.onNext("Hello world")
        );

        observable.subscribe((s1) ->
                System.out.println("s1:" + s1)
        );
        observable.subscribe((s2) ->
                System.out.println("s2:" + s2)
        );

    }

    /**
     * Hot Observable无论有没有观察者进行订阅，事件始终都会发生,与订阅者么是一对多的关系
     */
    public void hotObservableDemo() {
        ConnectableObservable<StringBuffer> publish = ConnectableObservable
                .just(new StringBuffer("test"))
                .publish();

        // 线程安全的，共享变量
        publish.subscribe((s) -> System.out.println(s.append("k1").toString()));
        publish.subscribe((s) -> System.out.println(s + " krauser2"));

        // 只有调用了connect才能真正的执行
        publish.connect();
    }

Hot Observable转化成Cold Observable

ConnectableObservable的refCount

Observable的share

Cold Observable转化成Hot Observable

Observable的publish

使用subject/processor（支持back pressure）

   PublishSubject<String> subject = PublishSubject.create();

        // subject作为观察者,订阅目标的Code Observable
        subject.subscribe(s1 ->
                System.out.println("s1:" + s1)
        );
        subject.subscribe(s2 ->
                System.out.println("s2:" + s2)
        );


        Observable<String> observable = Observable.create(emitter ->
                emitter.onNext("Hello world")
        );

        // subject作为被观察者，转发或者发送新的事件
        observable.subscribe(subject);