if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
这是发射器中onComplete
的定义,dispose
方法是控制是否还能发送数据,其实这里的 CreateEmitter
它是一个AtomicReference<Disposable>
原子类包装Disposable的实现类,而我们dispose
方法正是将该原子类添加了常量的DISPOSED
,而在onNext方法中通过判断isDisposed
是否为false才能继续发送数据。而isDisposed
什么时候为false呢?当AtomicReference<Disposable>
中的包装对象不是DISPOSED
。所以我们的onComplete
是用来控制不能发送数据的。
您可以通过如下代码测试:
emitter.onNext(1);
emitter.onNext(2);
emitter.onComplete();
emitter.onNext(3);
看看下游的observer是否还能收到3的数据。
小总结
onComplete
是用来控制不能发送数据的,也就是不能onNext
了,包括onError也是不能再发送onNext
数据了,该方法中也是调用了dispose
方法。
RxJava中map、flatMap的区别,你还用过其他哪些操作符?
map和flatMap是我们经常用的转换操作,我们先看看map如何使用:
Observable createObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
});
Observable mapObservable = createObservable.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Throwable {
return String.valueOf(integer + 1);
}
});
Observer observer = new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.d(TAG, “onSubscribe:” + d.getClass().getName());
}
@Override
public void onNext(@NonNull String string) {
Log.d(TAG, "onNext: " + string);
}
@Override
public void onError(@NonNull Throwable e) {
Log.d(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, “onComplete”);
}
};
mapObservable.subscribe(observer);
}
通过createObservable
的map操作生成了一个mapObservable
的被观察者,最终通过mapObservable
与observer
形成订阅关系,而map操作需要一个Function的接口,第一个泛型是入参类型,第二个泛型是出参的类型,也就是apply的返回值,这里定义map的出参类型是String类型。 我们再来看下flatMap如何使用:
Observable flatMapObservable = mapObservable.flatMap(new Function<String, ObservableSource>() {
@Override
public ObservableSource apply(String s) throws Throwable {
return Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
emitter.onNext(Integer.valueOf(s)+1);
emitter.onComplete();
}
});
}
});
flatMapObservable.subscribe(observer);
在上面的mapObservable基础上通过flatMap返回flatMapObservable,最后通过flatMapObservable订阅observer。flatMap的Function第二个泛型是ObservableSource类型的,Observable的父类是ObservableSource类型,因此第二个参数返回Observable也可以。
从上面可以看出map是通过原始数据类型返回另外一种数据类型,而flatMap是通过原始数据类型返回另外一种被观察者。
关于面试也有问flatMap和concatMap的区别,下面我通过一个例子来演示他们的区别:
Observable createObservable = Observable.just(“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”);
Observable flatMapObservable = createObservable.flatMap(new Function<String, ObservableSource>() {
@Override
public ObservableSource apply(String s) throws Throwable {
if (s.equals(“2”)) {
return Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
emitter.onNext(Integer.valueOf(s) + 1);
emitter.onComplete();
}
}).delay(500, TimeUnit.MILLISECONDS);
} else {
return Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
emitter.onNext(Integer.valueOf(s) + 1);
emitter.onComplete();
}
});
}
}
});
Observable observeOnObservable = flatMapObservable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
Observer observer = new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.d(TAG, “onSubscribe:” + d.getClass().getName());
}
@Override
public void onNext(@NonNull Integer string) {
Log.d(TAG, "onNext: " + string);
}
@Override
public void onError(@NonNull Throwable e) {
Log.d(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, “onComplete”);
}
};
observeOnObservable.subscribe(observer);
在上面flatMap
操作过程中为了演示flatMap
和concatMap
的区别,在数据为2的时候让返回的observable
延迟500毫秒,我们看到的结果如下:
上面例子中3是由2的发射数据发射过来的,而正好数据为2的时候让延迟了500毫秒,那如果换成concatMap结果是按照发射数据的顺序来返回的。
concatMap和flatMap的功能是一样的, 将一个发射数据的Observable变换为多个Observables,然后将它们发射的数据放进一个单独的Observable。只不过最后合并ObservablesflatMap采用的merge,而concatMap采用的是连接(concat)。总之一句一话,他们的区别在于:concatMap是有序的,flatMap是无序的,concatMap最终输出的顺序与原序列保持一致,而flatMap则不一定,有可能出现交错。
关于其他的操作符比如merge、concat、zip都是合并,interval是周期执行,timer是延迟发送数据。如果要学习更多的操作符请猛戳官网
Maybe、Observer、Single、Flowable、Completable几种观察者的区别,以及他们在什么场景用?
其实想知道它们的区别,我们直接看对应的Observer的方法有哪些:
- Maybe
Maybe从字面意思是可能的意思,看下MaybeObserver
接口:
public interface MaybeObserver<@NonNull T> {
void onSubscribe(@NonNull Disposable d);
void onSuccess(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
它没有onNext方法,也就是说不能发多条数据,如果回调到onSuccess
再不能发消息了,如果直接回调onComplete
相当于没发数据,也就是说Maybe可能不发送数据,如果发送数据只会发送单条数据。
- Observer
这个不用多说了,它是能发送多条数据的,直到发送onError
或onComplete
才不会再发送数据了,当然它也是可以不发送数据的,直接发送onError
或onComplete
。
- Single
public interface SingleObserver<@NonNull T> {
void onSubscribe(@NonNull Disposable d);
void onSuccess(@NonNull T t);
void onError(@NonNull Throwable e);
}
single也是发送单条数据,单是它要么成功要么失败。
- Flowable
Flowable没有FlowableObserver接口,它是由FlowableSubscriber代表观察者,Flowable在后面被压的时候讲,我们只要知道它是被压策略的一个被观察者。
- Completable
public interface CompletableObserver {
void onSubscribe(@NonNull Disposable d);
void onComplete();
void onError(@NonNull Throwable e);
}
Completable不发送数据,只会发送成功或失败的事件,当然这个用得很少。
小总结
从上面各个对应的observer接口来看,如果只想发一条数据,或者不发数据就用Maybe,如果想法多条数据或者不发数据就用Observable,如果只发一条数据或者失败就用Single,如果想用背压策略使用Flowable,如果不发数据就用Completable。
RxJava切换线程是怎么回事?
大家都知道RxJava切换线程使用subscribeOn
指定被观察者的在哪个线程执行,使用observeOn
指定观察者在哪个线程执行,通常我们写法如下:
subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
subscribeOn(Schedulers.io())
subscribeOn会返回一个ObservableSubscribeOn
,它是一个Observable,根据前面介绍的订阅流程,我们直接看ObservableSubscribeOn
的subscribeActual
操作:
@Override
public void subscribeActual(final Observer<? super T> observer) {
//创建了内部的Observer,其实这里类似上面介绍的Observable.create创建的发射器,只不过发射器是Emitter
final SubscribeOnObserver parent = new SubscribeOnObserver<>(observer);
//给下游的observer添加订阅的监听
observer.onSubscribe(parent);
//给SubscribeOnObserver设置disposable对象
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
创建了SubscribeOnObserver
对象,它是Observer
类型的,其实类似上面介绍的Observable.create
创建的发射器,只不过发射器是Emitter
类型。接着给下游的observer
添加订阅的监听,最后是给SubscribeOnObserver
设置disposable
对象,还记得在observable.create
最后一步是给上游的ObservableOnSubscribe
添加订阅吗,那我们看看此处是如果给上游的observable
添加订阅的,首先scheduler是Schedulers.io()
,最终它是一个IoScheduler
对象,里面是通过CachedWorkerPool
内部类创建了线程池,创建线程池如下:
evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
而scheduler.scheduleDirect(new SubscribeTask(parent))中的SubscribeTask是一个Runnable,所以最终通过线程池执行SubscribeTask的run方法:
到了最后还是通过线程池执行Runnable
来添加上游Observable
的订阅,并且把当前创建的SubscribeOnObserver
传给了上游的observable
,这个跟我们上面介绍Observable.create
中给上游的ObservableOnSubscribe
添加订阅是一样的。
小总结
subscribeOn实际是创建了ObservableSubscribeOn的Observable,它的订阅方法里面创建了
SubscribeOnObserver
,通过线程池执行Runnable来达到上游Observable的订阅在子线程中执行,这就是为什么subscribeOn能控制observable在哪个线程中执行的原因。
observeOn(AndroidSchedulers.mainThread())
同样如此observeOn也会有对应的observable,它是ObservableObserveOn
,我们直接看它订阅的方法:
同样如此,可以看到先是拿到AndroidSchedulers中的worker,它是HandlerWorker
类型,按道理说应该给下游的observer添加订阅监听啊,怎么没有呢,看官别急,我们继续看ObserveOnObserver
的订阅方法:
我们的重点不在下游的observer订阅监听这,在ObserveOnObserver的onNext方法中,会调用schedule方法,最终是通过HandlerWorker
的schedule执行ObserveOnObserver,因为ObserveOnObserver也是一个runnable实现类,HandlerWorker中的schedule方法是通过主线程的Handler给主线程发送了一个Message,所以我们回到ObserveOnObserver的run方法,在run方法中会执行下游的onNext、onError等方法,所以这就是为什么observeOn能让observer能在主线程中执行。
小总结
observeOn实际是创建了ObservableObserveOn的Observable,它的订阅方法里面创建了
ObserveOnObserver
,而ObserveOnObserver
是实现了Runnable接口,把它包装成message给主线程的Handler发送一条消息,而ObserveOnObserver
的run方法中会给下游的Observer发送数据。所以这就是observeOn能让observer在哪个线程中执行。
RxJava的subscribeOn只有第一次生效?
如果你理解了订阅的过程,其实该问题很好理解,subscribeOn是规定上游的observable在哪个线程中执行,如果我们执行多次的subscribeOn的话,从下游的observer到上游的observable的订阅过程,最开始调用的subscribeOn返回的observable会把后面执行的subscribeOn返回的observable给覆盖了,因此我们感官的是只有第一次的subscribeOn能生效。
那如何才能知道它实际在里面生效了呢,我们可以通过doOnSubscribe
来监听切实发生线程切换了。
RxJava的observeOn多次调用哪个有效?
上面分析了observeOn是指定下游的observer在哪个线程中执行,所以这个更好理解,看observeOn下一个observer是哪一个,所以多次调用observeOn肯定是最后一个observeOn控制有效。
RxJava1.0、RxJava2.0、RxJava3.0有什么区别?
RxJava2.0相比于RxJava1.0
-
添加背压的策略Flowable
-
添加Observer的变体consumer
-
ActionN 和 FuncN 改名(Action0 改名成Action,Action1改名成Consumer,而Action2改名成了BiConsumer,而Action3 - Action9都不再使用了,ActionN变成了Consumer<Object[]> 。Func改名成Function,Func2改名成BiFunction,Func3 - Func9 改名成 Function3 - Function9,FuncN 由 Function<Object[], R> 取代。)
-
Observable.OnSubscribe 变成 ObservableOnSubscribe
-
ObservableOnSubscribe 中使用 ObservableEmitter 发射数据给 Observer,在RxJava中使用Subscriber发射数据。
-
Subscription 改名为 Disposable
RxJava3.0相比与RxJava2.0
-
提供Java 8 lambda友好的API
-
删除Maybe.toSingle(T)
-
删除Flowable.subscribe(4 args)
-
删除Observable.subscribe(4 args)
-
删除Single.toCompletable()
你以为完了吗,还有背压没介绍呢,好吧,由于篇幅原因,把背压放到下一篇单独来讲了。
- 该篇介绍了Observable的订阅过程,其实我们只要把订阅过程理解为当前的Observable向下游的Observer添加订阅监听,向上游的Observable添加订阅,发送数据的是从上游的Observable向下游的Observer发送数据。
- 介绍了发射器发送了onComplete事件后再不能发送onNext事件的原因,介绍了map、flatMap以及concatMap的区别,以及简单的介绍了其他的关键字。
- 介绍了Maybe、Single、Flowable、Completable几种观察者的区别,以及他们在什么场景用。
- 介绍了RxJava切换线程通过subscribeOn控制上游的Observable订阅发生的线程,observeOn控制下游的observer接收数据发生的线程,以及为什么RxJava的subscribeOn只有第一次生效,RxJava的observeOn多次调用离observer最近的一个才生效。
- 介绍了RxJava2.0相比于RxJava1.0有哪些变动,RxJava3.0相比与RxJava2.0有哪些变动。
最后
在这我分享一份自己收录整理的Android 核心知识笔记+架构视频+面试文档,还有 高级架构技术进阶脑图、Android开发面试专题等一些高级进阶架构资料,我平常在闲暇的时刻,还会将这些精品资料拿出来反复翻阅。
总之是想通过学习资料和方法能够帮助大家学习提升进阶,也节省大家在网上搜索资料的时间来学习,也可以分享给身边好友一起学习,如果你有需要的话,可以私信我【666】或点击【Github地址】进行查看获取!!!
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
最后
在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。
附上:我们之前因为秋招收集的二十套一二线互联网公司Android面试真题(含BAT、小米、华为、美团、滴滴)和我自己整理Android复习笔记(包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。)
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!**
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
最后
在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。
附上:我们之前因为秋招收集的二十套一二线互联网公司Android面试真题(含BAT、小米、华为、美团、滴滴)和我自己整理Android复习笔记(包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。)
[外链图片转存中…(img-SdwZGCld-1712717400600)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!