RxJava2.0教程

来源：互联网发布：魔兽世界源码编辑：程序博客网时间：2024/06/03 08:03

这是9篇基础版讲的最好的文章

给初学者的RxJava2.0教程(一)

给初学者的RxJava2.0教程(二)

给初学者的RxJava2.0教程(三)

给初学者的RxJava2.0教程(四)

给初学者的RxJava2.0教程(五)

给初学者的RxJava2.0教程(六)

给初学者的RxJava2.0教程(七)

给初学者的RxJava2.0教程(八)

给初学者的RxJava2.0教程(九)

关于RxJava1中的Subscription的一些误解

上面文章中的知识点

ObservableEmitter： Emitter是发射器的意思，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
Disposable：这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件。

Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                emitter.onNext(1);                emitter.onNext(2);                emitter.onNext(3);                emitter.onNext(4);                emitter.onComplete();            }        }).subscribe(new Observer<Integer>() {            private Disposable mDisposable;            private int i;            @Override            public void onSubscribe(Disposable d) {                Log.d(TAG, "subscribe");                mDisposable = d;            }            @Override            public void onNext(Integer value) {                Log.d(TAG, "onNext: " + value);                i++;                if (i == 2) {                    Log.d(TAG, "dispose ：" + mDisposable.isDisposed());                    mDisposable.dispose();                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());                }            }            @Override            public void onError(Throwable e) {                Log.d(TAG, "error");            }            @Override            public void onComplete() {                Log.d(TAG, "complete");            }        });

打印的结果：

com.example.pioneerchang.demo D/chang-->: subscribecom.example.pioneerchang.demo D/chang-->: onNext: 1com.example.pioneerchang.demo D/chang-->: onNext: 2com.example.pioneerchang.demo D/chang-->: dispose ：falsecom.example.pioneerchang.demo D/chang-->: isDisposed : true

等于2的时候，通过mDisposable.dispose();切断水管，之后下游就收不到了。

Activity中请求网络，如果在请求的过程中Activity已经退出了, 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了, 怎么办呢, 上一节我们说到了Disposable , 说它是个开关, 调用它的dispose()方法时就会切断水管, 使得下游收不到事件, 既然收不到事件, 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它即可.
那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器CompositeDisposable, 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用CompositeDisposable.clear() 即可切断所有的水管。
Map.
map是RxJava中最简单的一个变换操作符了, 它的作用就是对上游发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化。
如代码所示，在上游我们发送的是数字类型, 而在下游我们接收的是String类型。

Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                emitter.onNext(1);                emitter.onNext(2);                emitter.onNext(3);            }        }).map(new Function<Integer, String>() {            @Override            public String apply(Integer integer) throws Exception {                return "This is result " + integer;            }        }).subscribe(new Consumer<String>() {            @Override            public void accept(String s) throws Exception {                Log.d(TAG, s);            }        });

FlatMap.
FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里。
上游每发送一个事件, flatMap都将创建一个新的水管, 然后发送转换之后的新的事件, 下游接收到的就是这些新的水管发送的数据. 这里需要注意的是, flatMap并不保证事件的顺序, 也就是图中所看到的, 并不是事件1就在事件2的前面. 如果需要保证顺序则需要使用concatMap。
代码示例：

 Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                emitter.onNext(1);                emitter.onNext(2);                emitter.onNext(3);            }        }).flatMap(new Function<Integer, ObservableSource<String>>() {            @Override            public ObservableSource<String> apply(Integer integer) throws Exception {                final List<String> list = new ArrayList<>();                for (int i = 0; i < 2; i++) {                    list.add("I am value " + integer);                }                return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);            }        }).subscribe(new Consumer<String>() {            @Override            public void accept(String s) throws Exception {                Log.d(TAG, s);            }        });

log打印

com.example.pioneerchang.demo D/chang-->: I am value 1com.example.pioneerchang.demo D/chang-->: I am value 1com.example.pioneerchang.demo D/chang-->: I am value 3com.example.pioneerchang.demo D/chang-->: I am value 3com.example.pioneerchang.demo D/chang-->: I am value 2com.example.pioneerchang.demo D/chang-->: I am value 2

通过FlatMap实现注册和登录

public interface Api {        @GET        Observable<LoginResponse> login(@Body LoginRequest request);        @GET        Observable<RegisterResponse> register(@Body RegisterRequest request);    }    //可以看到登录和注册返回的都是一个上游Observable,    // 而我们的flatMap操作符的作用就是把一个Observable转换为另一个Observable,因此结果就很显而易见了:    public void register() {        api.register(new RegisterRequest())                //发起注册请求                .subscribeOn(Schedulers.io())                //在IO线程进行网络请求                .observeOn(AndroidSchedulers.mainThread())                //回到主线程去处理请求注册结果                .doOnNext(new Consumer<RegisterResponse>() {                            @Override                            public void accept(RegisterResponse registerResponse) throws Exception {                                //先根据注册的响应结果去做一些操作                            }                        })                .observeOn(Schedulers.io())                //回到IO线程去发起登录请求                .flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {                            @Override                            public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse) throws Exception {                                return api.login(new LoginRequest());                            }                        })                .observeOn(AndroidSchedulers.mainThread())                //回到主线程去处理请求登录的结果                .subscribe(new Consumer<LoginResponse>() {                            @Override                            public void accept(LoginResponse loginResponse) throws Exception {                                Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();                            }                        }, new Consumer<Throwable>() {                            @Override                            public void accept(Throwable throwable) throws Exception {                                Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();                            }                        });    }

Zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                emitter.onNext(1);                emitter.onNext(2);                emitter.onNext(3);                emitter.onNext(4);                emitter.onComplete();            }        });        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {            @Override            public void subscribe(ObservableEmitter<String> emitter) throws Exception {                emitter.onNext("A");                emitter.onNext("B");                emitter.onNext("C");                emitter.onComplete();            }        });        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {            @Override            public String apply(Integer integer, String s) throws Exception {                return integer + s;            }        }).subscribe(new Observer<String>() {            @Override            public void onSubscribe(Disposable d) {                Log.d(TAG, "onSubscribe");            }            @Override            public void onNext(String value) {                Log.d(TAG, value);            }            @Override            public void onError(Throwable e) {                Log.d(TAG, "onError");            }            @Override            public void onComplete() {                Log.d(TAG, "onComplete");            }        });

log输出：

com.example.pioneerchang.demo D/chang-->: onSubscribecom.example.pioneerchang.demo D/chang-->: 1Acom.example.pioneerchang.demo D/chang-->: 2Bcom.example.pioneerchang.demo D/chang-->: 3Ccom.example.pioneerchang.demo D/chang-->: onComplete

应用场景：
比如一个界面需要展示用户的一些信息, 而这些信息分别要从两个服务器接口中获取, 而只有当两个都获取到了之后才能进行展示, 这个时候就可以用Zip了。

sample操作符，这个操作符每隔指定的时间就从上游中取出一个事件发送给下游。虽然上游仍然一直在不停的发事件, 但是我们只是每隔一定时间取一个放进对列里。

Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                for (int i = 0; ; i++) {                    emitter.onNext(i);                }            }        }).subscribeOn(Schedulers.io())                .sample(2, TimeUnit.SECONDS)  //sample取样                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Consumer<Integer>() {                    @Override                    public void accept(Integer integer) throws Exception {                        Log.d(TAG, "" + integer);                    }                });

Flowable里默认有一个大小为128的队列。如果队列存储的事件源超过128，就会报MissingBackpressureException异常。

阅读全文

0 0