【笔记】RxJava学习笔记
蛋疼！刚开始接触RxJava的朋友们一定会有这样的想法。这货有啥用？看了很多文章抨击RxJava所以就不去了解。但是RxJava发展到现在仍然有不少公司在使用一定是有它存在的道理的，不是教程，不是教程，纯粹分享，map和flatMap的部分看了很多解读，总结了一个比较好理解的，希望对同样困惑的朋友有一丢丢的帮助~
1.基本使用
1.1 首先要有一个被观察者对象，用于向观察者发送通知：
Observable observable = Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext("1");
subscriber.onNext("2");
subscriber.onCompleted();
}
});
1.2 然后需要一个观察者对象
Observer observer = new Observer() {
@Override
public void onCompleted() {
Log.d(TAG, "onCompleted: ");
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: ");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}
};
- 除了Observer接口之外，还有一个实现了Observer接口的抽象类Subscriber
public abstract class Subscriber implements Observer
使用上与Observer相同，在subscribe的过程中，Observer也会先转换成subscriber
public final Subscription subscribe(final Observer observer) {
if (observer instanceof Subscriber) {
return subscribe((Subscriber)observer);
}
return subscribe(new Subscriber() {
@Override
public void onCompleted() {
observer.onCompleted();
}
@Override
public void onError(Throwable e) {
observer.onError(e);
}
@Override
public void onNext(T t) {
observer.onNext(t);
}
});
}
- 区别：1. subscriber中增加了一个方法onStart()，这个方法会在subscribe开始，但事件还没有发送之前调用
- unsubscribe():subscriber可以取消订阅，也可以用isUnsubscribe()判断在subscribe之后，被观察者会持有观察者的引用，可以在onPause()或onStop()等方法中解除引用关系，避免内存泄漏。
1.3 最后被观察者产生的事件被观察者订阅
observable.subscribe(observer);
在被观察者产生事件，以及观察者接收到事件并处理的过程中可以做很多事情，比如转换事件类型、合并多个事件、事件延迟发送等。
2.创建操作符
2.1 creat(）
- 使用creat()创建一个被观察者对象
2.2 just()
- 快速创建被观察者对象
- 使用just（）操作符
- 直接发送 传入的事件(最多只能发送十个参数)
Observable.just(1, 2, 3,4)
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe（）
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
2.3 延迟创建
timer（）
- 延迟指定时间后发送一个数值0（Long类型）
- 本质上是延迟指定时间后调用onNext(0)
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer() {
interval()
- 每隔指定时间就发送事件
- 发送的事件序列为从0开始，递增1的整数序列
// 参数说明：
// 参数1 = 第1次延迟时间；
// 参数2 = 间隔时间数字；
// 参数3 = 时间单位；
Observable.interval(3,1,TimeUnit.SECONDS)
3.变换操作符
3.1 map
.map(new Func1()
- 作用：对参数 I 的数据作处理使之达到 O 的要求，可进行类型转换、数据筛选等操作。
- 例如
.
3.2 flatMap
/**
* Returns an Observable that emits items based on applying a function that you supply to each item emitted
* by the source Observable, where that function returns an Observable, and then merging those resulting
* Observables and emitting the results of this merger.
*
* 
*
* - Scheduler:
* - {@code flatMap} does not operate by default on a particular {@link Scheduler}.
*
*
* @param func
* a function that, when applied to an item emitted by the source Observable, returns an
* Observable
* @return an Observable that emits the result of applying the transformation function to each item emitted
* by the source Observable and merging the results of the Observables obtained from this
* transformation
* @see ReactiveX operators documentation: FlatMap
*/
public final Observable flatMap(Func1> func) {
if (getClass() == ScalarSynchronousObservable.class) {
return ((ScalarSynchronousObservable)this).scalarFlatMap(func);
}
return merge(map(func));
}
- flatMap中的 “flat” 可以理解为 “flatten”的过程 。map和flatMap都是将传入的对象转化为另一个对象，但是flatMap中返回的是一个Observable对象，这个Observable对象并不是直接发送到了subscriber的回调方法中进行处理。
- 首先flatMap会根据传入的事件创建Observale对象，但是flatMap并不会发送这个对象，而是“激活”这个Observale开始发送事件，每一个Observale发送的事件最终被汇入同一个Observale中，并交给subscriber的回调方法去处理。把初始的对象“铺平”后再通过一个Observale发送。
具体例子
Func1中传入的I是String类型的对象，目标O是Observable，首先将传入的String对象转换为Observable对象，然后这个Obsercable对象开始发送他的事件，也就是List，最终返回的是一个Observable对象，并将其发送的事件（List）交给subscriber中的回调方法进行处理。
.flatMap(new Func1>>()
4. Zip()
- 当数据有多个来源，例如首页的数据可能有多个请求的接口，每个接口请求数据的响应时间也不同，但我们希望在所有数据接收完毕后再渲染界面，这个时候就可以用zip来合并请求的数据源。
- 事件1 是获取首页广告数据
- 事件2是获取首页轮播图数据
- 通过zip将这两个事件合并起来，当两个数据都请求完成的时候通过subscriber的回调方法进行处理