RxJava操作符（一） __创建操作

ReactiveX

在github ReactiveX官网上，就一句话介绍ReactiveX：Reactive Extensions for Async Programming，翻译过来就是可异步的响应式编程。ReactiveX是Reactive Extensions的缩写，我们一般写为Rx系列[RxJava/RxPHP/RxPython/RxSwift….],最初是LINQ的扩展，有微软的架构师Erik Mejier领导的团队开发，12年开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更简单方便的处理异步的数据流。

那么到底什么是ReactiveX，按照它爹微软的定义是，Rx仅仅是一个函数库，让开发者可以利用科观察序列和LINQ风格的查询查询操作符来编写异步和基于事件的程序。在Rx中，Observable表示异步的数据流，用LINQ操作符查询异步数据流，用Schedulers参数化异步数据流的并发处理，Rx可以这么定义：Rx=Observables + LINQ + Schedulers ;

Observable && Observer

在ReactiveX中，一个观察者(Observer)订阅一个可观察对象(Observable).观察者（Observer）对Observable发射的数据或数据序列做出相应。这种模式可以极大地简化并发操作。因为Rx是使用典型的观察者模式，观察者（Observer）一直在检测Observable的动向，可以随时相应Observable的通知，不需要阻塞等待Observable的发射数据。
对于Observable和Observer的详细内容，可以查看ReactiveX的相关文档，有非常详细说明。本文主要是说明Rx的操作符。

创建Observable的方式

just

创建一个指定值的Observable， 如果，Just存在9个重载函数：

具体用法如下：

        //创建可观察对象        Observable<String> observable = Observable.just("Tom","Jerry");             //创建观察者        Observer<String> observer = new Observer<String>() {            @Override            public void onCompleted() {                print("onCompleted");            }            @Override            public void onError(Throwable arg0) {                print("onError:" + arg0 );            }            @Override            public void onNext(String arg0) {                print(arg0);            }        };        //可观察者订阅        observable.subscribe(observer);

结果为：

from

先看from函数的各项重载函数

可以看出，from函数可以接受array，Future, Iterable等等，那么它的作用就是其他种类的对象和数据类型转换为Observable对象。

定义一个获取Observer方法：

    private <T> rx.Observer<T> getObserver() {        return new Observer<T>() {            @Override            public void onCompleted() {                print("onCompleted");            }            @Override            public void onError(Throwable arg0) {                print("onError:" + arg0 );            }            @Override            public void onNext(T arg0) {                print(arg0);            }        };    }

现在使用from方法：

        String[] array = {"one","two","three","four","five"};        Observable<String> observable = Observable.from(array);        observable.subscribe(getObserver());

得到结果为：

当然可以使用Fature参数：

        Future<String> task = new FutureTask<String>(new Callable<String>() {            @Override            public String call() throws Exception {                return "hello world";            }        }){            @Override            public String get() throws InterruptedException, ExecutionException {                return "hello world....";            }        };        Observable.from(task).subscribe(getObserver());

Repeat

通过repeat名字就知道，创建一个发射重复多次的数据的Observable，重载函数为：

repeat():

        Observable<String> observable = Observable.just("repeat").repeat();        observable.subscribe(getObserver());

会无限次发生just中的数据：

repeat(n)： n >= 0 时，重复n次数据；n<0时，直接报错

Observable<String> observable = Observable.just("repeat").repeat(5);observable.subscribe(getObserver());

结果如图：

repeat(scheduler):在其他的程序调度器中运行：

Observable<String> observable = Observable.just("repeat").repeat(4,new EventLoopsScheduler());observable.subscribe(getObserver());

结果为：

Create

使用函数从头开始创建一个Observable。

需要传递一个观察者对象作为参数的函数，编写这个函数让它的行为表现为一个Observable–恰当的调用观察者的onNext,onError和onCompleted方法。

在传递给create方法中检查观察者是否inUnsubscibed状态，以便在没有观察者的时候，让你的Observable停止发射数据或进行昂贵的运算。

Observable.create(new OnSubscribe<String>() {            @Override            public void call(Subscriber<? super String> observer) {                try {                    if(!observer.isUnsubscribed()) {                        for(int i = 0 ; i < 5 ; i++) {                            observer.onNext(i + "");                        }                        observer.onCompleted();                    }                }catch(Exception e) {                    e.printStackTrace();                }            }        }).subscribe(getObserver()) ;

结果为：

Defer

直到有观察者订阅时才创建Observable，并为每一个观察者创建一个新的Observable。
看下面代码：

//定义当前时间long currentTime = System.currentTimeMillis() ;Observable<Integer> observable =                 Observable.defer(new Func0<Observable<Integer>>() {            @Override            public Observable<Integer> call() {                //计算执行时间距离当前时间 差值                int time = (int) (System.currentTimeMillis() - currentTime) ;                //打印每次执行的Observable                Observable<Integer> target = Observable.just(time);                System.out.println("the target is " + target);                return target;            }        });        //系统延迟3秒        Thread.sleep(3000);        observable.subscribe(getObserver()) ;        observable.subscribe(getObserver()) ;        //System.in.read() ;    }

上图设计的代码中，系统休眠3秒之后再订阅Observer，检查是否在订阅之后，才开始创建Observable，答案是肯定的：

Range

创建一个发射特定递增的整数序列的Observable：

Observable.range(4, 10).subscribe(getObserver()) ;

结果为：

可见range中第一个参数start为起始值，第二个参数count为发射数据的个数

Interval

创建一个按固定时间间隔无限发射从0递增序列的Observable：

@Test    public void intervalFunction()  throws Exception{        Observable.interval(2, TimeUnit.SECONDS).subscribe(getObserver());        //由于创建的是Java项目，很显然interval操作符不是在主线程中执行，那么此时我们需要阻塞主线程才能看到Observable发射线程打印的结果。        System.in.read() ;    }

结果为：

Timer —– Deprecated

创建一个Observable，它在一个给定的延迟后发射一个特殊的值，可以看出Interval操作符可以完成此类操作，Timer操作符已经处于过时的了。

    @Test    public void timerFunction() throws Exception {        //第一个5表示Observable第一次发射延迟为5秒        //第二个2表示Observable第n(n>=2)次发射延迟2秒        Observable.timer(5, 2, TimeUnit.SECONDS).subscribe(getObserver());        System.in.read() ;    }

结果为

empty && error && Never

empty:创建一个什么都不做直接通知完成[onCompleted]的Observable;
error:创建一个什么都不做直接通知错误[onError]的Observable；
Never:创建一个什么都不做的Observable
empty：

Observable.empty().subscribe(getObserver());

结果为：

error：

Observable.error(new RuntimeException()).subscribe(getObserver());

结果为：

never：

Observable.never().subscribe(getObserver());

结果当然是什么都没有了。

好了，今天的create操作符就记录在这里了，下次再接再厉吧。

资料：
http://reactivex.io/documentation/operators.html#creating

https://mcxiaoke.gitbooks.io/rxdocs/content/operators/Creating-Observables.html

所有代码：