RxJava学习笔记

Rxjava 为的是解决相关之间的统一

响应式编程：

是一种基于异步流概念的编程模式，就是对流进行观测、过滤、操作
RxJava是Java响应式编程的解决方案，全称是Reactive Extensions Java。
RxJava的架构中采用了 观察者模式 代理模式 迭代器模式 建造者模式

RxJava中的角色划分:

Observable 被观察者
Observer 观察者
Subscriber 订阅者
Subject 科目
Observable和Subject是生产者，Observer和Subscriber是消费者

冷热Observable:

热：主动发射，创建时发送数据，这也就有可能后面添加的观察者会收不到消息。
冷：被动发射，等待观察者订阅时才发送消息。

基础Api介绍

Action的含义：

Action—->ActionN 就是个回调接口，call参数个数为N，规定了参数列表。例如 Action1 ->call(T t)

Function的含义:

有返回值的回调，N也是call的参数个数为N

源码分析

基本创建和订阅：

• Observable.create(X):new 一个Obaservable对象，保存OnSubscribe参数
• mObservable.subscribe(X):先将 Observer或者Action封装成对应的代理对象ObserverSubscriber或者ActionSubscriber，然后调用Observable的静态方法Observable.subscribe(subscriber, this)，然后在对subscriber进行封装成其代理类subscriber = new SafeSubscriber(subscriber)，然后将调用onSubscribe的call RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
  Observable.from():
  new OnSubscribeFromIterable(iterable)—>o.setProducer(new IterableProducer(o, it));—>producer.request(toRequest);—>slowPath(n);—>while (e != r){o.onNext(value);}
• 其它api，综合来看核心是包装OnSubcribe的对象的call方法的回调逻辑

Subject

即是观察者，也是被观察者
Subject extends Observable implements Observer
PublishSubject OnNext时，所有的观察者都会收到消息：
step1:PublishSubject.create();
step2:new PublishSubjectState()
step3:static final class PublishSubjectState
extends AtomicReference
implements OnSubscribe, Observer
step4: 重写call中PublishSubjectProducer pp = new PublishSubjectProducer(this, t);
t.add(pp);
step5: state.OnNext()时
for (PublishSubjectProducer pp : get()) {
pp.onNext(t);
}
BehaviorSubject: 订阅时先发送默认
ReplaySubjuect: 缓存消息，新订阅的观察者会订阅时会收到缓存的所有消息
AsyncSubject:发最后一条消息给每个订阅的观察者,使用时是有规则的
AsyncSubject subject = AsyncSubject.create();
subject.subscribe(observer);
subject.onNext(“one”);
subject.onNext(“two”);
subject.onNext(“three”);
subject.onCompleted();
特点一：onNext后接onComplete才能发送消息
特点二: 注册了的观察者，能且只能收到最新onNext的一条消息

常用api

just 发送已知几条数据时，最多10条
repeat 重复发送几次时使用。总消息数=单次数据数*次数
defer 懒加载，当订阅时才会回调
range 范围个数发送，需要两个参数 一个是其实数字，一个是连续几个 例如 range(10,3) 则会发送 10 11 12
interval 轮询操作，适用的场景 多少时间后 每隔多少时间 发送一个消息,没有次数这个概念。
timer 延时操作，多少时间后发送个0信息

过滤
filter 过滤 new OnSubscribeFilter(this, predicate)
—》FilterSubscriber(child, predicate)
—》result = predicate.call(t); if (result) actual.onNext(t);

take 获取当前序列中的前N条数据
核心 OperatorTake
if (!isUnsubscribed() && count++ < limit) { child.onNext(i);

takeLast 获取当前序列的后N条数据

distinct 去重 支持指定过滤规则，默认过滤的key是Object ，本质是指定去重是指定的Key是什么，利用的是Set集合的key重复add会失败的原理。
OperatorDistinct
Set keyMemory = new HashSet();
U key = keySelector.call(t);
if (keyMemory.add(key)) child.onNext(t);
ditinctUntilChanged 去重只发新
first last 取第一个 取最后一个
skip skiplast 不取前几个 不取后几个
elementAt 取第几个
sample(t,unit) 在指定的时间t内，发送最近的一条消息
timeout(t,unit) 超过t发错误
debounce(t,unit) t内没有发射后发最近的

变换
map( Func1) T 转为 R后发射

flatMap(Func1) T 转为 Observable 后发射，允许交叉，也就是转后的Observable顺序不一定与原Observable顺序一致

contactMap(Func1) 与flatMap类似，但是不允许交叉，也就是转后的Observable顺序与原Observable顺序一致

flatMapIterable(Func1) 与flatmap类似，只是它将元数据两两组成Iterable后发射，而不是组成Observable

switchMap(Func1) 与flatmap类似，当原始Observable发射一个新的数据（Observable）时，它将取消订阅并停止监视之前那个数据的Observable产生的Observable，并开始监视当前这一个。

scan(Func2) 累积操作。将数据操作后再返回到原序列发送，例如
mObservable = mObservable.scan(new Func2() {
@Override
public String call(String s, String s2) {
Log.e(TAG,”s->”+s+” s2->”+s2);
return s+s2;
}
});

groupby 分组元素 call返回的值是分组的key，key相同的为一组
Observable《GroupedObservable《String,AppInfo》》 groupedItems = Observable.from(apps)
.groupBy(new Func1《AppInfo,String》(){
@Override
public String call(AppInfo appInfo){
SimpleDateFormat formatter = new SimpleDateFormat(“MM/yyyy”);
return formatter.format(new Date(appInfo.getLastUpdateTime()));
}
});

buffer() 按个数分组发送，也就是将源数据按照指定个数打包成一个集合发送，而不是一个一个的发送
observable.buffer(2).subscribe(new Action1《List《AppInfo》》() {
@Override
public void call(List《AppInfo》 appInfos) {
Log.e(TAG,appInfos.toString());
}
});

cast 类似map，将源数据原转为转为新的类型,改变的是Class,其实就是直接强制类型转换后再发射。

组合
merge 多输入 单输出 就是将两个Observable 合并成一个Observable来发射,串联两个数据源，默认是同步不会交叉,有错误就停止合并了
mergeDelayError 有错跳过
Observable《AppInfo》 observable1 = Observable.from(appInfos);
Observable《AppInfo》 observable2 = Observable.from(appInfos);
Observable《AppInfo》 observableMerge = Observable.merge(observable1,observable2);
observableMerge.subscribe(new Action1《AppInfo》() {
@Override
public void call(AppInfo o) {
Log.e(TAG,o.toString());
}
});

zip 合并数据项，可以自由的将两个数据源进行处理，然后组成一个全新的数据源的Observable 。 如果两个数据源数量不对等，则直到最小的都没有了就停止了。
Observable《AppInfo》 appInfoObservable = Observable.from(appInfos);
List《Long》 items = new ArrayList《》();
items.add(1L);
items.add(2L);
items.add(3L);
items.add(4L);
items.add(5L);
Observable《Long》 longObservable = Observable.from(items);
Observable.zip(appInfoObservable, longObservable, new Func2

调度

Schedulers.io()
自动适应增长或减小的线程池，专用于I/O操作。需要注意频繁大量I/O会创建大量线程，造成内存开销。
Schedulers.io().createWorker().schedule(() -> {
这是一个I/O操作;
});

Schedulers.computation()
默认的调度器，buffer debounce delay interval sample skip等默认的调度器。

Schedulers.immediate()
允许你立即在当前线程执行工作，是timeout timeInterval timestamp默认的调度器

Schedulers.newThread()
为指定任务开启一个新线程
Schedulers.trampoline() 想在当前线程执行任务，但是不是立即的。这个调度器将会把任务加入到队列，然后按照顺序执行队列中的每个任务，repeat retry操作采用的这个调度器

SubcribeOn()
规定了subscriber的call方法执行所在的调度器

ObserveOn()
规定了subcribe是Observer的onNext onError onComplete执行坐在的调度器