Android框架——RxJava异步开发框架

介绍

RxJava是ReactiveX的Java实现，通过这个框架我们可以很方便的进行数据的异步获取，并对数据进行分步转换。

RxJava基本使用

引入依赖

    implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.3'

创建观察者

首先创建一个观察者，它可以在数据发生改变的时候调用相应的回调函数。

			Subscriber subscriber = new Subscriber<String>() {
   
            @Override
            public void onSubscribe(Subscription s) {
   
                
            }

            @Override
            public void onNext(String s) {
   

            }

            @Override
            public void onError(Throwable t) {
   

            }

            @Override
            public void onComplete() {
   

            }
        };
        	//也可以用Observer创建观察者
	        Observer<String> observer = new Observer<String>() {
   
            @Override
            public void onSubscribe(Disposable d) {
   
                
            }

            @Override
            public void onNext(String s) {
   

            }

            @Override
            public void onError(Throwable e) {
   

            }

            @Override
            public void onComplete() {
   

            }
        };

创建被观察者

接下来创建被观察者，它需要一个ObservableOnSubscribe类型的参数。当Observable对象的subscribe方法被调用时，会调用到ObservableOnSubscribe里的subscribe回调方法，通过对emitter操作，开始向观察者发送事件。

		Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
   
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
   
                emitter.onNext("发送第一个消息");
                emitter.onNext("发送第二个消息");
                emitter.onComplete();
            }
        });
        //也可以这样写，这一行和上面的效果是一样的
        Observable<String> observable2 = Observable.just("发送第一个消息","发送第二个消息");

当Observable的subscribe方法被调用时，会依次发送onNext,onNext,onComplete方法。

关联观察者和被观察者

这里不保存变量了，直接在被观察者的订阅函数里新建并添加一个观察者。

	Observable.create(new ObservableOnSubscribe<String>() {
   
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
   
                emitter.onNext("发送第一个消息");
                emitter.onNext("发送第二个消息");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
   
            @Override
            public void onSubscribe(Disposable d) {
   
            }

            @Override
            public void onNext(String s) {
   
                System.out.println("我收到了："+s);
            }

            @Override
            public void onError(Throwable e) {
   
                e.printStackTrace();
            }

            @Override
            public void onComplete() {
   
                System.out.println("已接收全部事件");
            }
        });

被观察者中通过Emitter发送的事件都会按顺序被观察者接收并调用回调方法。

RxJava常见操作符

RxJava为我们提供了许多操作符，种类有创建操作符，变换操作符，过滤操作符，组合操作符，错误处理操作符，辅助操作符，条件和布尔操作符，算术聚合操作符，连接操作符等，以下将介绍一下常用的操作符。

创建操作符

1.interval
可以使用interval操作符起到定时器的作用，每隔一定时间发送一个事件。

Observable.interval(3, TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
   
    @Override
    public void accept(Long aLong) throws Exception {
   
        System.out.println(aLong+"");
    }
});

2.range
range操作符可以发射有序的整数序列，代替for循环，第一个参数不小于0，第二个参数为终值，左闭右开。

 Observable.range(0,5).subscribe(new Consumer<Integer>() {
   
     @Override
     public void accept(Integer integer) throws Exception {
   
         
     }
 });

3.repeat
可以把发送指定数据的过程重复N次。

        Observable.range(0,3).repeat(2).subscribe(new Consumer<Integer>() {
   
            @Override
            public void accept(Integer integer) throws Exception {
   
                
            }
        });

这个调用会发送 0，1，2 两次，发送顺序为0,1,2,0,1,2。

变换操作符

1.map
map操作符可以将事件发送的数据映射成其他数据，例如给数据添加额外的信息，或获取它的某个字段，或包装等等。它的匿名内部类中声明的两个类型分别是处理前和处理后的数据类型。

        Observable.just("人").map(new Function<String, String>() {
   

            @Override
            public String apply(String s) throws Exception {
   
                return "好"+s;
            }
        });

事件的数据就从"人"变成了"好人"。
2.flatMap
这个操作符大概意思就是从发送数组事件展开成一个个单独的事件，具体没搞懂。

Observable.fromArray(1,2,3).flatMap(new Function<Integer, ObservableSource<String>>() {
   
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
   
                return Observable.just(integer+"已处理");
            }
        }).subscribe(