Rxjava2.0教程(一)

最新推荐文章于 2021-02-08 14:57:33 发布

kieCool

最新推荐文章于 2021-02-08 14:57:33 发布

阅读量562

点赞数 1

分类专栏：移动开发文章标签： rxjava

本文链接：https://blog.youkuaiyun.com/kieCool/article/details/75873744

版权

移动开发专栏收录该内容

6 篇文章

订阅专栏

RxJava的目的就是一个异步操作，在使用中不需要我们去开线程，不需要我们去管理线程，通过rxjava简单的链式调用就能完成复杂的功能，代码逻辑简单，结构清晰，阅读性极强。

要应用RxJava，需要在项目中引入依赖：

io.reactivex.rxjava2:rxjava:2.0.4
io.reactivex.rxjava2:rxjava:2.0.4

rxjava是基于观察者模式，下面是观察者模式各个角色：

Observable：在观察者模式中称为“被观察者”；
Observer：观察者模式中的“观察者”，接受数据；
subscribe：订阅，观察者与被观察者建立联系；

Single 和SingleObserver ，Subscriber与 Flowable ，Maybe 与 MaybeObserveOn，Completable和CompletableObserver等，这些都是rxjava提供的观察者和被观察者使用类。

创建型操作符

create 操作符是所有创建型操作符的根,也就是说其他创建型的操作符最后都是通过create操作符来创建Observable

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                Log.e(TAG, "subscribe: " + Thread.currentThread().getName());

                e.onNext(100 + "");
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).


                subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onNext(String value) {
                        Log.e(TAG, value + " onNext: " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError: " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: " + Thread.currentThread().getName());
                    }
                });

结果是

07-23 12:27:53.341 2809-2809/com.example E/RXActivity: onSubscribe: main
07-23 12:27:53.351 2809-3899/com.example E/RXActivity: subscribe: RxCachedThreadScheduler-1
07-23 12:27:53.381 2809-2809/com.example E/RXActivity: 100 onNext: main

just操作符

Observable.just(3, 6, 7).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())


                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, integer + "   accept: " + Thread.currentThread().getName());
                    }
                });

07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 3   accept: main
07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 6   accept: main
07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 7   accept: main

from 操作符

  Observable.fromArray(3, 6, 7).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())


                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, integer + "   accept: " + Thread.currentThread().getName());
                    }
                });

07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 3   accept: main
07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 6   accept: main
07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 7   accept: main

repeat操作符重复执行

 Observable.just(1,3).repeat(3)
                .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "accept: " + integer );
            }
        });

07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 1
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 3
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 1
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 3
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 1
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 3

defer 使用defer可以延迟被订阅者的生成，也就是被订阅者是在订阅发生时才生成

Observable mObservable =

                Observable.defer(new Callable<ObservableSource<? extends String>>() {
                    @Override
                    public ObservableSource<? extends String> call() throws Exception {
                        return Observable.just(s);
                    }

                });
        s = "bbbb";
        mObservable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, s + "  accept:  " + Thread.currentThread().getName());
            }
        });

07-23 12:47:30.251 18092-18092/com.example E/RXActivity: bbbb  accept:  main

range 创建一个发射指定范围的整数序列的Observable，第一个参数是从哪个数开始，第二个参数是连续的n个值

Observable.range(2,4)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "accept: " + integer );
                    }
                });

07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 2
07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 3
07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 4
07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 5

interval 操作符既可以延迟执行一段逻辑，也可以间隔执行一段逻辑，timer也可以只是过时了

 Observable.interval(2, 1, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, aLong + "  accept:  " + Thread.currentThread().getName());

                    }
                });

07-23 12:58:59.121 5924-5924/com.example E/RXActivity: 0  accept:  main
07-23 12:59:00.121 5924-5924/com.example E/RXActivity: 1  accept:  main
07-23 12:59:01.121 5924-5924/com.example E/RXActivity: 2  accept:  main

delay 延时执行

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1000);
            }
        }).delay(1000, TimeUnit.MILLISECONDS).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, integer + "  accept:  " + Thread.currentThread().getName());
            }
        });

如果您还想了解更多，可以添加公众号：