Rxjava的学习研究

1.RxJava是什么
RxJava 是一个 基于事件流、实现异步操作 ，是JVM的响应式扩展（ReactiveX），它是通过使用可观察的序列将异步和基于事件的程序组合起来的一个库。

2.RxJava的作用是什么
两个字：异步，实现异步操作,类似于Android中的AsyncTask,Handler

3.RxJava的优势
基于事件流的链式调用,使得代码的逻辑清晰,并且在程序逻辑性复杂度提高的情况下 * 依然能够保持逻辑的清晰

4.相关字段
1.被观察者（Observable） 产生事件
2.观察者（Observer） 处理事件
3.订阅（Subscribe）
4.事件（Event） 具体的事情

5.举例子说明
出版社出版报纸，邮递员寄送报纸
出版社(被观察者) Observable
写信(事件) Event
邮递员(订阅)送信报纸 Subscribe
群众(观察者)看报纸 Observer

6.使用方法
创建被观察者Observable
创建观察者Observer
通过订阅连接被观察者和观察者

7.具体实现
1.添加依赖
compile ‘io.reactivex.rxjava2:rxjava:2.0.1’
compile ‘io.reactivex.rxjava2:rxandroid:2.0.1’
2.创建被观察者Observable

    Observable observable = Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(final ObservableEmitter e) throws Exception {
            e.onNext(1);
            e.onNext(2);
            e.onNext(3);
            e.onComplete();
            //e.onError(null);
        }
    });

3.创建观察者Observer
创建观察者Observer,有两种方式:
采用Observer 接口
采用Subscriber 抽象类
采用Observer 接口
Observer observer = new Observer() {
@Override
public void onSubscribe(final Disposable d) {
//观察者接收事件前，默认最先调用复写 onSubscribe（）
Log.d(TAG, “开始采用subscribe连接”);
}

        @Override
        public void onNext(final Integer value) {
            //被观察者调用e.onNext(1);时该方法响应
            Log.d(TAG, "对Next事件作出响应" + value);
        }

        @Override
        public void onError(final Throwable e) {
            //被观察者调用e.onError(null);时该方法响应
            Log.d(TAG, "对Error事件作出响应");
        }

        @Override
        public void onComplete() {
            //被观察者调用e.onError(null);时该方法响应
            Log.d(TAG, "对Complete事件作出响应");
        }
    };

    //2.2 采用Subscriber 抽象类
    Subscriber subscriber = new Subscriber() {
        @Override
        public void onSubscribe(final Subscription d) {
           // 观察者接收事件前，默认最先调用复写 onSubscribe（）
            Log.d(TAG, "--------");
            Log.d(TAG, "开始采用subscribe连接");
        }

        @Override
        public void onNext(final Integer value) {
            //被观察者调用e.onNext(1);时该方法响应
            Log.d(TAG, "对Next事件作出响应" + value);
        }

        @Override
        public void onError(final Throwable e) {
            //被观察者调用e.onError(null);时该方法响应
            Log.d(TAG, "对Error事件作出响应");
        }

        @Override
        public void onComplete() {
            //被观察者调用e.onComplete();时该方法响应
            Log.d(TAG, "对Complete事件作出响应");
        }

    };

4.通过订阅连接被观察者和观察者
observable.subscribe(observer);

6.操作符
map:是一个比较简单的转换操作符，通过规则将源消息中的 值，转换成我们需要的值
Observable.just(1, 2, 3, 4)
.map(new Function() {
@Override
public String apply(Integer integer) throws Exception {
//将源消息中的integer 值转换成我们需要的 String值
return “The value is " + integer;
}
}).subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
System.out.println(”------------" + s);
}
});

7.flatmap
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
.flatMap(new Function() {
@Override
public ObservableSource apply(Integer integer) throws Exception {
String a = integer + “”;
return Observable.just(a).delay(10, TimeUnit.SECONDS);
}
})
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
System.out.println("+++++++++++++++" + s);
}
});

如上代码，flatMap将integer类型的消息转换成了String类型的消息。这里要注意，flatMap是无序的。
当然flatMap有很多其他变体，（如可以可以出来异常、完成时间的flatMap(Function onNextMapper, Function onErrorMapper, Callable)）等等。这里我只讲最基本的

groupBy
groupby将源Observable拆分成多个GroupedObservable，每个GroupedObservable发射一个Observable中的子序列。
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
.groupBy(new Function() {
@Override
public Integer apply(Integer integer) throws Exception {
//根据原始消息的不同，将源Observable拆分成不同的GroupedObservable。
// 并给下游消息队列(即GroupedObservable)加上不同的 key 值
if (integer % 2 == 0) {
return 2;
} else {
return 1;
}
}
}).subscribe(new Consumer>() {
@Override
public void accept(GroupedObservable integerIntegerGroupedObservable) throws Exception {
//获取消息队列的 key之，采用 key 值来分辨消息队列的种类
int key = integerIntegerGroupedObservable.getKey();
switch (key) {
case 1:
integerIntegerGroupedObservable
.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("---------------" + integer + " is a 奇数" );
}
});
break;
case 2:
integerIntegerGroupedObservable.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("+++++++++++++++" + integer + " is a 偶数" );
}
});
break;
default:
break;
}
}
});
这里有一个 groupby 的变种，groupBy(Function keySelector, Function valueSelector) 其中第二个参数是对消息的值进行的变换。

scan
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
.scan(new BiFunction() {
@Override
public Integer apply(Integer sum, Integer item) throws Exception {
//return值 将作为下次调用此函数的第一个参数值
//注意：这里会先将第一个消息发出给订阅者来处理。
// 然后再将第一个消息的值作为此函数的第一个参数，将第二个消息作为第二个参数来第一次执行这个函数
return sum + item;
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("===========" + integer);
}
});

从代码运行结果看出，scan使得订阅者每次接收到的消息值都和上一次的消息值有关。*注意：*第一次的消息是不变的并会作为apply方法第一次执行的第一个参数。当然我们也可以改变scan返回的消息的数据类型，这时候就要调用scan(final R initialValue, BiFunction accumulator)来设置观察者接收到的第一个消息的初始值 initialValue；
window
Observable.fromArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
.window(3)
.subscribe(new Consumer() {
@Override
public void accept(Observable integerObservable) throws Exception {
System.out.println("==================" + “第” + time + “组”);
time ++;
integerObservable.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("----------" + integer);
}
});
}
});