深入浅出RxJava2.0_02[新特性]

来源：互联网发布：模拟退火算法伪代码编辑：程序博客网时间：2024/06/07 02:08

1.观察者与被观察者升级

如果想在安卓中使用RxJava2.0，可以直接在github上搜索RxAndroid.添加依赖脚本如下：

compile 'io.reactivex.rxjava2:rxandroid:2.0.1'compile 'io.reactivex.rxjava2:rxjava:2.0.1'

如果你使用的是之前RxJava1.0版本的话，需要添加依赖：

compile 'io.reactivex:rxandroid:1.2.1'compile 'io.reactivex:rxjava:1.1.6'

本次更新，观察者模式还是RxJava2.0版本的核心，只不过技术上做了一些改进。比如，你在RxJava1.0使用基本的观察者模式，代码框架应该是这样的：

Observable    .create(new Observable.OnSubscribe<Integer>() {        @Override        public void call(Subscriber<? super Integer> subscriber) {            subscriber.onNext(1);            subscriber.onNext(2);            subscriber.onCompleted();        }    })    .subscribe(new Observer<Integer>() {        @Override        public void onCompleted() {            Log.i(TAG, "onCompleted");        }        @Override        public void onError(Throwable e) {            Log.i(TAG, "onError: " + e);        }        @Override        public void onNext(Integer value) {            Log.i(TAG, "onNext: " + value);        }    });

上面的代码涉及到两个对象：Observable(被观察者)&Observer(观察者)。当然观察者我们也可以使用Subscriber来代替。因为：

public abstract class Subscriber<T> implements Observer<T>, Subscription {    ...}

而在RxJava2.0中，Observable(被观察者)&Observer(观察者)模型的代码稍稍做了改动，对比修改的代码如下：

Observable    //内部的Observable.OnSubscribe对象已经变成ObservableOnSubscribe    .create(new ObservableOnSubscribe<Integer>() {        //Subscriber参数已经变成ObservableEmitter 实际上操作是一样的        @Override        public void subscribe(ObservableEmitter<Integer> e) throws Exception {            e.onNext(1);            e.onNext(2);            e.onComplete();        }    })    //这里的订阅再也找不到Subscriber类了，只能使用Observer    .subscribe(new Observer<Integer>() {        @Override        public void onSubscribe(Disposable d) {        }        @Override        public void onNext(Integer value) {            Log.i(TAG, "onNext: "+value);        }        @Override        public void onError(Throwable e) {        }        @Override        public void onComplete() {        }    });

在RxJava2.0中，Observable(被观察者)&Observer(观察者)模型对背压的支持不够好，上一节我们已经谈过了。为了让代码更好的支持背压，我们对该模式使用新的对象来代替，这就是Flowable(被观察者)&Subscriber(观察者)。

示例代码如下：

Flowable    .create(new FlowableOnSubscribe<String>() {        @Override        public void subscribe(FlowableEmitter<String> e) throws Exception {            for (int i = 0; i < 1000; i++) {                e.onNext(i+"");            }            e.onComplete();        }    }, BackpressureStrategy.BUFFER)//设置背压模式策略    .subscribe(new Subscriber<String>() {        public Subscription sub;        //Subscription是一个新的接口 可以让观察者主动请求被观察者发送数据 也可以取消请求        //它提供了2个方法:s.request(n);/s.cancel();        @Override        public void onSubscribe(Subscription s) {            Log.i(TAG, "onSubscribe: ");            sub=s;            s.request(2);        }        @Override        public void onNext(String s) {            Log.i(TAG, "onNext: "+s);            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            sub.request(2);        }        @Override        public void onError(Throwable t) {        }        @Override        public void onComplete() {            Log.i(TAG, "onComplete ");        }    });

输出如下：

03-17 15:15:48.244 3753-3753/? I/IT520: onSubscribe: 03-17 15:15:48.244 3753-3753/? I/IT520: onNext: 003-17 15:15:49.244 3753-3753/? I/IT520: onNext: 1 03-17 15:15:48.244 3753-3753/? I/IT520: onNext: ..03-17 15:15:49.244 3753-3753/? I/IT520: onNext: ..

上面的代码一开始订阅的时候回调观察者的onSubscribe()，在该方法中，我们先往被观察者请求2条数据。接下来onNext()则会被调用到，当onNext()被调用后，我们先处理完被观察者发送过来的数据然后继续使用Subscription再次请求数据。

2.其他特殊的被观察者

还记得在RxJava1.0中的Single对象吗，它是一个只能发送成功/失败信息的被观察者，而且只能发送一个。对应的升级版本中，有个新的模型代替：Single/SingleObserver。

此外，还有一个模型也只能发送1个结果数据，那就是Maybe/MaybeObserver。示例代码如下：

Maybe    .create(new MaybeOnSubscribe<Boolean>() {        @Override        public void subscribe(MaybeEmitter<Boolean> e) throws Exception {            boolean isLogin=true;            //只能调用e.onError();或者e.onSuccess();            e.onSuccess(isLogin);        }    })    .subscribeOn(Schedulers.io())    .observeOn(AndroidSchedulers.mainThread())    .subscribe(new MaybeObserver<Boolean>() {        @Override        public void onSubscribe(Disposable d) {            //可以调用该对象的dispose取消订阅            //d.dispose();        }        @Override        public void onSuccess(Boolean value) {            Log.i(TAG, "onSuccess: "+value);        }        @Override        public void onError(Throwable e) {        }        @Override        public void onComplete() {        }    });

3.Action接口的升级

RxJava1.0 —>RxJava2.0
Action0 —>Action
Action1 —>Consumer
Action2 —>BiConsumer

示例代码如下：

Observable    .just("Hello Android")    .subscribe(new Consumer<String>() {        @Override        public void accept(String s) throws Exception { //onNext            Log.i(TAG, "accept: "+s);            throw new NullPointerException("mock exception !");        }    }, new Consumer<Throwable>() {  //onError        @Override        public void accept(Throwable throwable) throws Exception {            Log.i(TAG, "accept: "+throwable);        }    }, new Action() { //onComplete        @Override        public void run() throws Exception {        }    });

打印如下：

03-17 15:52:05.594 4064-4064/? I/IT520: accept: Hello Android03-17 15:52:05.594 4064-4064/? I/IT520: accept: java.lang.NullPointerException: mock exception !

不知道你注意到没有。在onNext()方法中支持了抛出异常的处理。完全不需要再次去try/catch，这里更支持Lambda表达式。

4.FuncN接口的升级

Func接口对象内部定义的是，带有一个返回值的方法，而参数可以是1个或者多个。而在RxJava2.0中抛弃了Func3…Func9。而Func1/Func2用如下接口对象代替：

RxJava1.0 —>RxJava2.0
Func1 —>Function
Func2 —>BiFunction

示例代码如下：

Flowable    .just(1)    //Func1--->Function    .map(new Function<Integer, Object>() {        @Override        public Object apply(Integer integer) throws Exception {            return null;        }    })    .subscribe(new Consumer<Object>() {        @Override        public void accept(Object o) throws Exception {        }    });

5.取消发送null对象

在RxJava1.0中，我们是可以发送null对象的。示例代码如下：

Observable    .create(new Observable.OnSubscribe<Integer>() {        @Override        public void call(Subscriber<? super Integer> subscriber) {            subscriber.onNext(null);        }    })    .subscribe(new Observer<Integer>() {        @Override        public void onCompleted() {            Log.i(TAG, "onCompleted");        }        @Override        public void onError(Throwable e) {            Log.i(TAG, "onError: " + e);        }        @Override        public void onNext(Integer value) {            Log.i(TAG, "onNext: " + value);        }    });

而在RxJava2.0之后，已经取消null的发送，代码如下：

Observable    .create(new ObservableOnSubscribe<Object>() {        @Override        public void subscribe(ObservableEmitter<Object> e) throws Exception {            e.onNext(null);            e.onNext("Hello Android !");        }    })    .subscribe(new Consumer<Object>() {        @Override        public void accept(Object o) throws Exception {            Log.i(TAG, "accept: " + o);        }    }, new Consumer<Throwable>() {        @Override        public void accept(Throwable throwable) throws Exception {            //onNext called with null. Null values are generally not allowed in 2.x operators and sources.            Log.i(TAG, "accept: "+throwable);        }    });

打印的提示已经说了在2.0版本中不需要发送null值。

0 0