Rxjava2.0教程(一)

来源：互联网发布：js监听离开当前页面编辑：程序博客网时间：2024/06/11 22:36

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

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

io.reactivex.rxjava2:rxjava:2.0.4io.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: main07-23 12:27:53.351 2809-3899/com.example E/RXActivity: subscribe: RxCachedThreadScheduler-107-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: main07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 6   accept: main07-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: main07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 6   accept: main07-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: 107-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 307-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 107-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 307-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 107-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: 207-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 307-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 407-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:  main07-23 12:59:00.121 5924-5924/com.example E/RXActivity: 1  accept:  main07-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());            }        });

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

阅读全文

1 0