RxJava学习(七)

一.概述

前面我们已经大概了解了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  Java
04-28 12:22:37.157 30923-30923/com.example.rxjavademo I/System.out: =====flapMap  Android
04-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
            }
        });

最后给出源码下载地址

点此下载源码