RxJava初见之创建操作

RXJava

RXJava好处

流行框架，流处理，逻辑清晰，网络处理方便，不再使用Handler，异步操作，简洁，哪怕是逻辑上面复杂，代码程度上面也能够做到简洁，与Retrofit2.0完美结合，多操作符。

RXJava相关依赖

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

RXJava的使用

基本概念

RxJava基于的是观察者模式，类似订阅-发布，也类似Android的View的一些Listener监听
主要是有下面三个概念
1. Observable 被观察者
2. Observer 观察者，是一个接口
3. Subscriber 观察者，继承自Observer，一般使用这个
观察者与被观察之间是通过subscribe()方法联系起来。与一般的逻辑相反的是，这里是Observable.subscribe(Observer/Subscriber)

简单使用

1. 建Observable对象

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello RxJava");
                subscriber.onNext("hi");
                subscriber.onCompleted();
            }
        });

2 创建Subscriber

    Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }
            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.getMessage());
            }
            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        };

3 两者关联起来

observable.subscribe(subscriber);

4 运行结果

hello RxJava
hi
onCompleted

创建操作详细

create

 Observable.create(OnSubscribe)

OnSubcribe是一个了是Listener之类的东西，暂时不管，只是知道他有一个call方法，可以通过该call方法回调Subscriber的onNext，onComplete，onError方法。

just

他可以接收1~9个参数，例子如下

  Observable.just("A","B","C").subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        });

他会依次调用Subscriber的onNext，onNext,onComplete/onError，这里会打印

A
B
C
onCompleted

他的OnSubscribe类型是：

OnSubscribeFromArray-->数组

from

接收一个Iterable对象(集合List)或者是数组对象，或者是一个线程的Future，例子如下

        Observable.from(new String[]{"A","B","C","D"}).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {

            }
        });

他的 OnSubscribe类型是：

OnSubscribeFromIterable -->Iterable
OnSubscribeFromArray -->数组
ToObservableFuture --> Future

从这里可以看出，just是最终的实现是调用了from操作符。

Defer

直到有订阅者倍subscribe的时候才会创建

 str = "Hello，RxJava";
        Observable<String> observable = Observable.defer(new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                return Observable.just(str);
            }
        });
        str = "hi，RxJava";
        observable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        });

输出的结果是：

hi，RxJava

当你使用别的操作符去生成observable的时候发现会是“Hello，RxJava”
他的OnSubscribe类型是

OnSubscribeDefer --> 泛型

Interval

固定时间间隔发送整数序列的Observable，类似一个计数器，例子

         Observable.interval(1, TimeUnit.SECONDS,Schedulers.io()).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Log.i(TAG, String.valueOf(aLong));
            }
        });

需要注意的是：在Android，在UI线程中去使用，需要制定interval的调度器
参数说明

//第一个参数是延时多久开始，第二个参数是每隔多久计时，第三个参数是计时类型，比如TimeUnit .SECONDS,TimeUnit.HOURS等，第四个是调度器，其他重载的方法类似
Observable<Long> interval(long initialDelay, long period, TimeUnit unit,Schedulers scheduler)

range

创建一个特定序列的Observable，例子

 Observable.range(10, 5).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.i(TAG, integer.toString());
            }
        });

当然你也可以知道调度器。其中，第一个是start，第二个参数是count，比如例子的意思就是从10开始，生产5个连续的int，就是10,11,12,13,14

OnSubscribeRange --> start ,end

repeat

重复发送使用一个Observable，例子

 Observable.range(10, 2).repeat(4).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.i(TAG, integer.toString());
            }
        });

他默认是在一个新线程去运行的，需要注意的是repeat不是一个static方法，他是操作在一个Observable之上的。

timer

用于延迟多久之后开始某动作，例子

    Observable.timer(2,TimeUnit.SECONDS, Schedulers.newThread()).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Log.i(TAG, aLong.toString());
            }
        });

empty ,never,error

用来处理特殊情况的Observable

        Observable.empty(); //用来发送不发射任何数据的但是正常结束的Observable
        Observable.never();// 不发射数据也不终止
        Observable.error(new Throwable());// 发射一个错误

他的使用就是你需要返回一个Observable对象，但是这个对象又不能为空，又不能去处理事情的时候就可以使用。