RxJava

一、RxJava简介

1.RxJava

Reactive Extensions for the JVM，基于JVM的Rx。
Reactive Extensions(Rx)原来是由微软提出的一个综合了异步和基于事件驱动编程的库。

RxJava的核心就是异步数据流和响应式编程:
1把所有的事件(数据)看成一条河流，它可以被观察、过滤或操作，也可以和另外一条河流汇合成一条新的河流。
2一旦事件产生或发生变化，就可以触发观察这些事件的角色(观察者/订阅者)做出响应处理。

2.RxJava优势及适用场景

RxJava当然是优秀而且强大的，有以下优势:
1具备响应式编程该有的特性。
2为异步而生，无需手动创建线程，并具备线程切换能力。
3支持链式调用，保证代码的简洁性。
4各种操作符，功能非常强大，满足各种业务需求。
5简化了异常的处理。
RxJava适用场景:网络请求、数据库读写、文件读写、定时任务等各种耗时操作需要通过异步来完成的操作都可以使用RxJava。

3.RxJava几个重要概念

观察者:Observer，观察事件变化并处理的主要角色。消费者(Consumer)也可以理解成―种特殊的观察者。
被观察者:触发事件并决定什么时候发送事件的主要角色。(异常和完成也是一种事件)
1Observable、Flowable、Single、Completable、Maybe都是被观察者。
2Flowable是支持背压的一种被观察者。
3Single、Completable、Maybe是简化版的Observable。
4几种被观察者通过toObservable/toFlowable/toSingle/toCompletable/toMaybe相互转换。
订阅(subscribe):观察者和被观察者建立关联的操作。

二、RxJava实操

1.导库

注：查找对应库的地址：https://mvnrepository.com/

    // https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxjava
    implementation 'io.reactivex.rxjava2:rxjava:2.2.21'
    // https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxandroid
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

2.create — 被观察者与观察者

    private void createOperatorTest() {
        Observable.create(new ObservableOnSubscribe<Object>() { //被观察者

            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
                //事件产生的地方
                emitter.onNext("Observable test_01");
                emitter.onNext("Observable test_02");
                emitter.onNext("Observable test_03");
                //emitter.onError(new Throwable("Manual Error!"));
                emitter.onComplete();
            }
        }).subscribe(new Observer<Object>() { //观察者
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("Observer onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                System.out.println("Observer onNext o: " + o);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("Observer onError: " + e.toString());
            }

            @Override
            public void onComplete() {
                System.out.println("Observer onComplete");
            }
        });
    }

执行结果：

注：onError与onComplete方法互斥，如果被观察者两个事件都包含，两个事件都会被执行，但是观察者只能观察到先执行的那个事件。

3.create — 被观察者与消费者

    private void createOperatorTest() {
        Observable.create(new ObservableOnSubscribe<Object>() { //被观察者

            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
                //事件产生的地方
                emitter.onNext("Observable test_01");
                emitter.onNext("Observable test_02");
                emitter.onNext("Observable test_03");
//                emitter.onComplete();
                emitter.onError(new Throwable("Manual Error!"));
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println("Consumer o: " + o);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                System.out.println("Consumer<Throwable> throwable："+throwable.toString());
            }
        });
    }

执行结果：

3.just — 被观察者与观察者

Just操作符最多能传10个参数。

    private void justOperatorTest(){
        Observable.just("msg_01", "msg_02", "msg_03")
                .subscribe(new Observer<Object>() { //观察者
                    @Override
                    public void onSubscribe(Disposable d) {
                        System.out.println("Observer onSubscribe");
                    }

                    @Override
                    public void onNext(Object o) {
                        System.out.println("Observer onNext o: " + o);
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("Observer onError: " + e.toString());
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("Observer onComplete");
                    }
                });
    }

执行结果：

4.from

public static Observable fromArray(T… items)；
fromArray方法不限制传入参数的个数，just方法内部也是使用的fromArray。

Observable.fromArray("msg_01", "msg_02", "msg_03", "msg_04", "msg_05", "msg_06", "msg_07", "msg_08", "msg_09", "msg_10", "msg_11")
                .subscribe(myObserver);

执行结果：

public static Observable fromIterable(Iterable<? extends T> source)；
可以传入实现了Iterable接口的类型值。

		ArrayList<String> list = new ArrayList<>();
        list.add("msg_01");
        list.add("msg_02");
        list.add("msg_03");
        Observable.fromIterable(list)
                .subscribe(myObserver);

5.map

map: 对被观察者传入的事件进行处理，返回一个新的被观察者。

        Observable.just("msg_01", "msg_02")
                .map(new Function<String, Object>() {
                    @Override
                    public Object apply(String s) throws Exception {
                        System.out.println("Function apply " + s);
                        return "fun_msg";
                    }
                }).subscribe(myObserver);

6.flatMap

多线程无序

        Observable.just("msg_01", "msg_02")
                .flatMap(new Function<String, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(String s) throws Exception {
                        System.out.println("Function apply " + s);
                        return Observable.just("apply_msg_01", "apply_msg_02");
                    }
                }).subscribe(myObserver);

7.concatMap

有序

        Observable.just("msg_01", "msg_02")
                .concatMap(new Function<String, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(String s) throws Exception {
                        System.out.println("Function apply " + s);
                        return Observable.just("apply_msg_01", "apply_msg_02");
                    }
                }).subscribe(myObserver);

8.buffer

        Observable.just("msg_01", "msg_02", "msg_03",
                "msg_04", "msg_05", "msg_06", "msg_07")
                .buffer(3).subscribe(myObserver);