十一、RxJava简析

RxJava有4个角色Observable、Observer、Subscriber和Suject，Observable和 Observer 通过subscribe方法实现订阅关系，Observable就可以在需要的时候通知Observer。

RxJava的使用

1，创建Observer（观察者）

它决定事件触发的时候有怎样的行为。

Subscriber subscriber = new Subscriber(){
    @Override
    public void onCompleted(){//事件队列完结，当不再有新的onNext触发时调用作为完成标志
    }
    @Override
    public void onError(){//在事件处理过程中出现异常时会触发同时队列终止
    }
    @Override
    public void onNext(){//将要处理的事件添加到事件队列
    }
    @Override
    public void onstart(){//在事件还未发送前调用可以做一些准备工作
    }
}

Observer是一个接口，Subscriber是在Observer上进行了扩展，也可以使用Observer创建观察者

Observer observer = new Observer(){
    @Override
    public void onCompleted(){}
    @Override
    public void onError(){}
    @Override
    public void onNext(){}
}

2，创建Observable（被观察者）

它决定了什么时候触发事件以及触发怎样的事件

Observable observable = Observable.create(new Observable.OnSubscribe(){
    @Override
    public void call(Subscriber subscriber){
    subscriber.onNext("123")//调用方法将事件添加到队列
    subscriber.onNext("456")
    subscriber.onCompleted()
    }
})

//简化写法利用just和from实现

Observable observable = Observable.just("123","456")//依次调用onNext方法和onCompleted方法。
String[] words = {"123","456"}
Observable observable = Observable.from(words)//依次调用onNext方法和onCompleted方法。

3，Subscribe（订阅）

将观察者和被观察者进行关联observable.subscribe(subscriber)

RxJava的Subject

Subject 既可以是一个 Observer 也可以是一个 Observerable，它是连接 Observer 和Observerable的桥梁。 因此，Subject可以被理解为Subject=Observable+Observer
1，PublishSubject：只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者，因此为了防止数据丢失可以在所有观察者都订阅完成后在发送数据。
2，BehaviorSubject：当Observer订阅BehaviorSubject时，它开始发射原始Observable最近发射的数据。如果此时还没有收到 任何数据，它会发射一个默认值，然后继续发射其他任何来自原始Observable的数据。如果原始的 Observable因为发生了一个错误而终止，BehaviorSubject将不会发射任何数据，但是会向Observer传递一个 异常通知。
3，ReplySubject：不管Observer何时订阅ReplaySubject，ReplaySubject均会发射所有来自原始Observable的数据给 Observer。不同类型的ReplaySubject用于限定Replay的范围，例如设定Buffer的具体大小，或者设定具体的时间范围。如果使用ReplaySubject作为Observer，注意不要在多个线程中调用onNext、onComplete 和onError方法。这可能会导致顺序错乱，并且违反了Observer规则。
4，AsyncSubject：当Observable完成时，AsyncSubject只会发射来自原始Observable的最后一个数据。如果原始的 Observable 因为发生了错误而终止，AsyncSubject 将不会发射任何数据，但是会向Observer传递一个异常通知。

RxJava操作符

包括defer、range、interval、start、repeat、timer

创建操作符

1，interval
创建一个按固定时间间隔发送整数序列的Observable，相当于定时器

Observable.interval(6,TimeUnit.SECONDS)//间隔6秒发送
                  .subscribe(new Action1(){
                  @Override
                  public void call(Long mLong){
                      //TODO
                      } 
                  })

2，range
创建发射指定范围整数序列的Observable，可以用于代替for循环，第一个参数为起始值且不小于0，第二个参数为终值，左闭右开。

Observable.range(0,8)
                  .subscribe((new Action1(){
                  @Override
                  public void call(Integer integer){
                      //TODO
                      } 
                  })

3，repeat
创建一个N次重复发射特定数据的Observable

Observable.range(0,8)
                   .repeat(3)//重复执行三次0-7循环
                  .subscribe((new Action1(){
                  @Override
                  public void call(Integer integer){
                      //TODO
                      } 
                  })

变换操作符

包括map、flatMap、cast、concatMap、flatMapIterable、buffer、groupBy
1，map
通过指定一个Func对象，将Obserable转换为一个新的Observable对象并发射，观察者将接收到新的Observable处理。例如利用map来处理域名更换：

final String Host = "http://baidu.com/"
Observable.just("image").map(new Func1(){
    @Override
    public String call(String s){
      return Host+s
    }
}).subscribe(new Action1(){
                  @Override
                  public void call(String s){
                      //TODO
                      } 
                  })

2，flatMap、cast
flatMap操作符将Observable发射的数据集合变换为Observable集合，然后将这些Observable发射的数据平坦的放入一个单独的Observable，cast操作符的作用是强制将Observable发射的所有数据转换为指定的类型。例如在多个请求接口前添加host：

final String Host="http://baidu.com"
Lsit list = new ArrayList<>()
list.add("image1")
list.add("image2")
list.add("image3")
//利用flatMap将list转换为Observable集合并再放入一个单独的Observable中发射，交叉执行不保证发射顺序。
Observable.from(list).flatMap(new Func1>(){
    @Override
    public Observable call(String s){
    return Observable.just(Host+s)
    }
//cast将Observable的数据转换为String类型
}).cast(String.class).subscribe(new Action1(){
                  @Override
                  public void call(String s){
                      //TODO
                      } 
                  })

3，concatMap
concatMap与flatMap操作符一致，解决了flatMap的交叉问题，提供了一种能够把发射值连续在一起的函数，而不合并他们。
4，flatMapIterable
可以将数据包装成Iterable，我们在Iterable中对数据进行处理。

Observable.just(1,2,3).flatMapIterable(new Func1>(){
    @Override
    publc Iterable call(Integer s){
    List mList = new ArrayList()
    mList.add(s+1)//对每个数都进行+1，输出为2，3，4
    return mList
    }
}).subscribe(new Action1(){
                  @Override
                  public void call(Integer integer){
                      //TODO
                      } 
                  }

5，buffer
将原Observable变换为一个新的Observable，新的Observable每次发射一组列表值而不是一个一个发射。和其类似的有window操作符，window操作符发射的是Observable而不是数据列表

Observable.just(1,2,3,4,5,6)
                  .buffer(3)//缓存容量为3,输出为两组每组3个数分别输出
                  .subscribe(new Action1>(){
                  @Override
                  public void call(List integers){
                      //TODO
                      } 
                  })

6，groupBy
用于元素分组，将原Observable变换为一个发射Observable的新的分组后的Observable，每一个新的Observable都是发射一组指定数据。

Observable> groupObservable 
= Observable.just(obj1,obj2,obj3)
                     .groupBy(new Func1){
                     @Override
                     public String call(Object obj){
                      return obj.value//用于确定分组的参数
                     }
                     }
//对分组后的数据输出
Observable.concat(groupObservable).subscribe(new Action1