RxJava原理和操作符介绍

月色月石

于 2024-06-21 12:43:04 发布

阅读量1.2k

点赞数 48

文章标签： rxjava android java

本文链接：https://blog.csdn.net/m0_46268254/article/details/139834767

版权

1.RxJava 实现原理:

//1.通过 create() 方法创建一个 Observable 对象，并在 subscribe() 方法中定义事件的产生过程。
Observable.create(new ObservableOnSubscribe<Integer>() {

    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
    // 2.Observable 对象通过调用 onNext() 方法来发射事件
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
})
.subscribeOn(Schedulers.io())   //指定被观察者的工作线程，事件产生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) //指定观察者对象的工作线程，事件处理在主线程
 // 3.通过创建一个 Observer 对象， Observer 对象通过回调方法来处理事件。
 // 4.通过调用 subscribe() 方法，将 Observable 对象与 Observer 对象进行订阅关联。即：observable.subscribe(observer);
.subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
    // 订阅时调用
    }

    @Override
    public void onNext(Integer value) {
        // 接收到事件时调用
    }

    @Override
    public void onError(Throwable e) {
        // 发生错误时调用
    }

    @Override
    public void onComplete() {
        // 完成时调用
    }
});

2.Rxjava 常用操作符：

一、功能操作符类：

1.subscribe

将 Observable 对象与 Observer 对象进行订阅关联。

2.subscribeOn(Schedulers.io())

指定被观察者的工作线程，事件产生在 IO 线程

3.observeOn(AndroidSchedulers.mainThread())

指定观察者对象的工作线程，事件处理在主线程

4 doxxx

 mDisposable = IQueryDataInterface.sIQueryDataInterface
            .getItemDates()
            .observeOn(SchedulerManager.MAIN)
            //被观察者每发送一个事件就调用一次
            .doOnEach(new Consumer<Notification<TaskResponse>>() {
                @Override
                public void accept(Notification<TaskResponse> taskResponseNotification) throws Exception {
                    
                }
            })
            //执行next事件前调用
            .doOnNext(new Consumer<TaskResponse>() {
                @Override
                public void accept(TaskResponse taskResponse) throws Exception {
                    
                }
            })
            //执行next事件后调用
            .doAfterNext(new Consumer<TaskResponse>() {
                @Override
                public void accept(TaskResponse taskResponse) throws Exception {
                    
                }
            })
            //被观察者正常发送完后事件调用
            .doOnComplete(new Action() {
                @Override
                public void run() throws Exception {
                    
                }
            })
            //被观察者发送error事件时调用
            .doOnError(new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    
                }
            })
            //订阅时调用
            .doOnSubscribe(new Consumer<Disposable>() {
                @Override
                public void accept(Disposable disposable) throws Exception {
                    
                }
            })
            //不管是正常发送事件还是因为异常终止发送事件，被观察者发送完事件之后调用
            .doAfterTerminate(new Action() {
                @Override
                public void run() throws Exception {
                    
                }
            })
            //最后执行
            .doFinally(new Action() {
                @Override
                public void run() throws Exception {
                    
                }
            })

5. onErrorReturn

用来捕捉被观察者中发送的错误事件并处理，最终返回一个特殊事件然后正常结束

        .onErrorReturn(new Function<Throwable, TaskResponse>() {
                @Override
                public TaskResponse apply(Throwable throwable) throws Exception {
                    Log.d("tag", "错误事件: "+throwable.toString());
                    return new TaskResponse();//返回一个事件
                }
            })

6.repeat

   //不设置发送无数次，设置后当执行完OnComplete后重新发送事件
            //默认在新的线程上工作
            .repeat(2)

7.delay

被观察者延迟指定时间后再发送事件

二、创建类

创建：create
快速创建和发送事件：just，fromArray，fromIterable，never，empty，error
延迟创建：delay，timer，interval，intervalRange，range，rangeLong

1.create

用来创建被观察者

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
});

2.just

用来快速创建被观察者

   Observable.just("hello","Rxjava","!");

相当于

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext("hello");
        emitter.onNext("Rxjava");
        emitter.onNext("!");
    }
});

3.defer

在被观察者订阅的时候才会被创建

    Integer i = 0;
    Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
        @Override
        public ObservableSource<? extends Integer> call() throws Exception {
            return Observable.just(i);
        }
    });

    i = 1;

    observable.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Integer integer) {
            Log.d("TAG", "onNext: i:"+ integer);
            //此时打印出来的integer = 1;
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    });

三、转换操作符

map，flatMap，concatMap，buffer

1.map

 Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onComplete();
        }
    }).map(new Function<Integer, String>() {
        @Override
        public String apply(Integer integer) throws Exception {
            //接受的类型是Integer，返回一个String类型
            String s = integer.toString();
            return s;
        }
    }).subscribe(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() {

        }
    });

2.FlatMap

将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里,注：concatMap和FlatMap一样的作用，只是contactMap是有序的，FlatMap是无序的

四、组合操作符

组合多个被观察者：

按发送顺序：concat、concatArray、
按时间：merge，mergeArray
错误处理：concatDelayError、mergeDelayArray

组合多个事件

按数量：zip
按时间：combinLatest、combinLatestDelayError
合并成一个事件发送：reduce 、collect
发送事件前追加发送事件：startWith、srartWithArray
统计发送事件数量：count

1.concat

组合四个或者四个以下的被观察者，将他们的事件串行发送

Observable.concat(Observable.just(1,2),Observable.just(3,4),Observable.just(5,6))
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Integer integer) {
                //最终打印出来123456
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });

2.startWith && startWithArray

startWith：在被观察者发送事件之前追加发送一个事件或者一个新的被观察者对象
startWithArray：追加发送多个事件

	Observable.just(7,8,9)
            .startWith(Observable.just(4,5,6))
            .startWithArray(1,2,3,4)
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    
                }

                @Override
                public void onNext(Integer integer) {
                //最终打印出来123456789
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            })

3.zip

创建两个被观察者对象

Observable<String> observable1 = Observable.create(emitter -> {
    // 执行第一个网络请求的逻辑
    // ...
    emitter.onNext(result1); // 发送第一个请求的结果
    emitter.onComplete(); // 请求完成
});

Observable<String> observable2 = Observable.create(emitter -> {
    // 执行第二个网络请求的逻辑
    // ...
    emitter.onNext(result2); // 发送第二个请求的结果
    emitter.onComplete(); // 请求完成
});

合并

Observable<String> combinedObservable = Observable.zip(observable1, observable2,
    (result1, result2) -> result1 + result2);

combinedObservable.subscribe(
    result -> {
        // 处理合并后的结果
        // ...
    },
    error -> {
        // 处理错误情况
        // ...
    },
    () -> {
        // 请求完成
    }
);

4.count

 Observable.just(1,2,3,4)
            .count()
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    //被观察者的数量是aLong
                }
            });

五、过滤操作符

根据制定条件过滤：

filter、offype、skip、skipLast、distinct、distinctUntilChange

根据指定事件数量过滤：

take、takelast

根据指定时间过滤

throttleFirst、throttleLast、simple、throttleWithTimeout、debounce

重复发送

firstElement、lastElement、elementAt、elementAtOrError

1.filter：按照条件过滤被观察者的事件

Observable.just(2,4,6,8)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    return integer<5;
                }
            })
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Integer integer) {
                    //结果是2，4
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            })

2.take：指定观察者对象接收的数量

    Observable.just(2,4,6,8)
            .take(1)//指定观察者接受事件的数量为1
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Integer integer) {
                    //结果是2
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });

3.firstElement 只获取事件序列中第一个事件并把它发送给观察者

    Observable.just(2,4,6,8)
            .firstElement()
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    //结果为2
                }
            });

六、条件操作符

all、 contains、isEmpty、amb、takewhile、takeUntil、skipWhile、skipUntil、defaultIfEmpty、squenceEqual

1.all:设置条件，判断每个事件是否符合设置的条件，是返回true,否返回false

Observable.just(2,4,6,8)
            .all(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    return (integer<5);
                }
            })
            .subscribe(new Consumer<Boolean>() {
                @Override
                public void accept(Boolean aBoolean) throws Exception {
                    //不满足条件返回结果是false
                }
            });

2,takeUntil+interval

takeUntil:判断每个事件是否符合设置的条件，只有当符合条件时候被观察者才停止发送事件

 Observable.interval(1, TimeUnit.SECONDS)
            .takeUntil(new Predicate<Long>() {
                @Override
                public boolean test(Long aLong) throws Exception {
                    return aLong > 5;//当大于5时停止发送事件
                }
            })
            .subscribe(new Observer<Long>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Long aLong) {
                    //收到的结果是0,1,2,3,4,5,6,当6>5时， 不再继续发送
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            })

takeUntil+timer

使用timer创造另一个被观察者对象作为判断条件

Observable.interval(1, TimeUnit.SECONDS)
            .takeUntil(Observable.timer(4,TimeUnit.SECONDS))
            .subscribe(new Observer<Long>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Long aLong) {
                    //收到的结果是0,1,2,3,
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });