RxJava学习(七)

来源：互联网发布：局部搜索算法有哪些编辑：程序博客网时间：2024/05/16 07:52

一.概述

前面我们已经大概了解了Obserable的概念，今天我们来看看另外一个东西，叫什么呢?Single

何为Single
我们先看看官方的解释

The Single class implements the Reactive Pattern for a single value response. See {@link Observable} for the * implementation of the Reactive Pattern for a stream or vector of values. * <p> * {@code Single} behaves the same as {@link Observable} except that it can only emit either a single successful * value, or an error (there is no "onComplete" notification as there is for {@link Observable}) * <p> * Like an {@link Observable}, a {@code Single} is lazy, can be either "hot" or "cold", synchronous or * asynchronous.

我给大家大概翻译一下说了些什么东西
Single的作用类似Obserable,但是每次只是发射一个值，onSucces或者onError，而Obserable有onNext,onComplete,onError,同Obserable一样，也可以实现同步和异步操作。

看完了概念，我们直接写一个代码试试

Single基本用法

 Single.just(addValue(1,2)).subscribe(new SingleSubscriber<Integer>() {            @Override            public void onSuccess(Integer value) {                mTextView.setText(value+"");            }            @Override            public void onError(Throwable error) {            }        });    }    public int addValue(int a,int b){        return a+b;    }

这里我们使用了SingleSubscriber来订阅，执行成功后会走onSucess方法，给TextView设置值为3.

这里写图片描述

Single进阶

compose操作符：对结果进行转换

  Single.just(addValue(1,2)).compose(new Single.Transformer<Integer, String>() {            @Override            public Single<String> call(Single<Integer> integerSingle) {                return integerSingle.map(new Func1<Integer, String>() {                    @Override                    public String call(Integer integer) {                        return integer+" android";                    }                });            }        }).subscribe(new SingleSubscriber<String>() {            @Override            public void onSuccess(String value) {                mTextView.setText(value+"");            }            @Override            public void onError(Throwable error) {            }        });    }

这里写图片描述

concat操作符：
用来连接多个Single和Observable发射的数据

Single.concat(Single.just(checkNetwork()), Single.just(checkMemory()), Single.just(doSth()))

仅仅用来连接Single顺序执行的，比如顺序执行检查网络，检查内存，执行任务，注意：如果某个Single调用了onError()会导致被中断。

create操作符

 Single.create(new Single.OnSubscribe<Integer>() {            @Override            public void call(SingleSubscriber<? super Integer> singleSubscriber) {                singleSubscriber.onSuccess(addValue(1, 2));            }        }).subscribeOn(Schedulers.io()).subscribe(new Subscriber<Integer>() {            @Override            public void onCompleted() {            }            @Override            public void onError(Throwable e) {            }            @Override            public void onNext(Integer integer) {                mTextView.setText(integer.intValue() + "");            }        });    }

值得注意的是之前我们使用的just()是一种特殊的create()，它不能指定Schedulers。只能在当前线程中运行，而create()可以指定Schedulers实现异步处理。且just()不管是否被subscribe()订阅均会被调用，而create()如果不被订阅是不会被调用的。所以我们通常可以用just()传递简单参数，而用create()处理复杂异步逻辑。

error操作符
返回一个立即给订阅者发射错误通知的Single，一般用于调试，不常用

// 如人为让concat中断:Single.concat(s1, Single.error(new Throwable("error"), s2)).subscribe();

flatMap操作符
flatMap

  Single.just(1).flatMap(new Func1<Integer, Single<String>>() {            @Override            public Single<String> call(Integer integer) {                return Single.just(integer+"");            }        }).subscribe(new Action1<String>() {//注意这里返回值的区别            @Override            public void call(String s) {            }        });        Single.just(2).map(new Func1<Integer, Single<String>>() {            @Override            public Single call(Integer integer) {                return null;            }        }).subscribe(new Action1<Single<String>>() {//注意这里返回值的区别            @Override            public void call(Single<String> stringSingle) {            }        });    }

一般map()是用于一对一的返回，而flatMap()用于一对0~多的返回。比如我们看下面这个例子:

 static Observable<List<String>> query(){        List<String> list = Arrays.asList("Java", "Android", "Html");        return Observable.just(list);    }

//输入类型是List<String>,使用flatMap则最后输出变为String  query().flatMap(new Func1<List<String>, Observable<String>>() {            @Override            public Observable<String> call(List<String> strings) {                return Observable.from(strings);            }        }).subscribe(new Action1<String>() {            @Override            public void call(String s) {                System.out.println("=====flapMap  "+s);            }        });

04-28 12:22:37.157 30923-30923/com.example.rxjavademo I/System.out: =====flapMap  Java04-28 12:22:37.157 30923-30923/com.example.rxjavademo I/System.out: =====flapMap  Android04-28 12:22:37.157 30923-30923/com.example.rxjavademo I/System.out: =====flapMap  Html

这里传入了一个List,传出了多个String。而且应该多用于Observable，很少用在Single中，即使用也不如map()来的爽快，这里只做了解即可。

flatMapObservable操作符
刚刚说到flatMap()和map()类似，区别在于flatMap可以返回多个值，而map只能返回一个。但在Single中flatMap只能返回Single，几乎等同于map实用性不高。而flatMapObservable就不同了，它支持将Single转化为Observable对象，可以返回多个值。下面这个例子介绍如何将Single转化为Observable。

   Single.just(2).flatMapObservable(new Func1<Integer, Observable<String>>() {            @Override            public Observable<String> call(Integer integer) {                return Observable.just("a","b","c");            }        }).subscribe(new Action1<String>() {            @Override            public void call(String s) {                System.out.println("========result: "+s);//a,b,c            }        });

merge & mergeWith操作符
merge操作符类似于concat，他们的区别见下图
这里写图片描述

这里写图片描述

subscribeOn操作符
用于指定异步任务的线程，常见的有:

Schedulers.computation( )；// 计算线程Schedulers.from(executor);// 自定义Schedulers.immediate();// 当前线程Schedulers.io();// io线程Schedulers.newThread();// 创建新线程Schedulers.trampoline();// 当前线程队列执行

onErrorReturn操作符
相当于try catch中的return，具体意思就是当函数抛出错误的时候给出一个返回值，看代码：

  Single.create(new Single.OnSubscribe<String>() {            @Override            public void call(SingleSubscriber<? super String> singleSubscriber) {                singleSubscriber.onError(new Throwable("x"));            }        }).onErrorReturn(new Func1<Throwable, String>() {            @Override            public String call(Throwable throwable) {                return "e";            }        }).subscribe(new Action1<String>() {            @Override            public void call(String s) {                System.out.println("======result: "+s);//输出e            }        });

observeOn
指定观察者所在线程，常用的是

AndroidSchedulers.mainThread();

timeout操作符
超时操作操作，在指定时间内如果没有调用onSuccess()就判定为失败，且可支持失败的时候调用其他Single()

toSingle操作符
将传入一个参数的Observable转换为Single

 Observable.just(2).toSingle();

zip & zipWith操作符
如果说flatMap()是将一个Single变成多个的操作，那么zip刚刚相反，他可以将多个Single整合为一个

  Single<Integer> s1 = Single.just(1);        Single<Integer> s2 = Single.just(2);        Single.zip(s1, s2, new Func2<Integer, Integer, String>() {            @Override            public String call(Integer integer, Integer integer2) {                return integer+"--"+integer2;            }        }).subscribe(new Action1<String>() {            @Override            public void call(String s) {                System.out.println("========: "+s);//结果是1--2            }        });

最后给出源码下载地址

点此下载源码

0 0