我從去年開(kāi)始使用 RxJava ，到現(xiàn)在一年多了胯舷。今年加入了 Flipboard 后怒允，看到 Flipboard 的 Android 項(xiàng)目也在使用 RxJava ，并且使用的場(chǎng)景越來(lái)越多 眯亦。而最近這幾個(gè)月，我也發(fā)現(xiàn)國(guó)內(nèi)越來(lái)越多的人開(kāi)始提及 RxJava 般码。有人說(shuō)『RxJava 真是太好用了』，有人說(shuō)『RxJava 真是太難用了』乱顾，另外更多的人表示：我真的百度了也谷歌了板祝，但我還是想問(wèn)： RxJava 到底是什么？
鑒于 RxJava 目前這種既火爆又神秘的現(xiàn)狀走净，而我又在一年的使用過(guò)程中對(duì) RxJava 有了一些理解券时，我決定寫(xiě)下這篇文章來(lái)對(duì) RxJava 做一個(gè)相對(duì)詳細(xì)的孤里、針對(duì) Android 開(kāi)發(fā)者的介紹。
這篇文章的目的有兩個(gè)： 1. 給對(duì) RxJava 感興趣的人一些入門(mén)的指引 2. 給正在使用 RxJava 但仍然心存疑惑的人一些更深入的解析
RxJava 到底是什么
RxJava 好在哪
API 介紹和原理簡(jiǎn)析1. 概念：擴(kuò)展的觀察者模式觀察者模式
RxJava 的觀察者模式
2. 基本實(shí)現(xiàn)1) 創(chuàng)建 Observer
2) 創(chuàng)建 Observable
3) Subscribe (訂閱)
4) 場(chǎng)景示例a. 打印字符串?dāng)?shù)組
b. 由 id 取得圖片并顯示
3. 線程控制 —— Scheduler (一)1) Scheduler 的 API (一)
2) Scheduler 的原理 (一)
4. 變換1) API
2) 變換的原理：lift()
3) compose: 對(duì) Observable 整體的變換
5. 線程控制：Scheduler (二)1) Scheduler 的 API (二)
2) Scheduler 的原理（二）
3) 延伸：doOnSubscribe()
RxJava 的適用場(chǎng)景和使用方式1. 與 Retrofit 的結(jié)合
2. RxBinding
3. 各種異步操作
4. RxBus
最后關(guān)于作者：
為什么寫(xiě)這個(gè)橘洞？
在正文開(kāi)始之前的最后捌袜，放上 GitHub
鏈接和引入依賴的 gradle
代碼： Github： https://github.com/ReactiveX/RxJava https://github.com/ReactiveX/RxAndroid 引入依賴： compile 'io.reactivex:rxjava:1.0.14'
compile 'io.reactivex:rxandroid:1.0.1'
（版本號(hào)是文章發(fā)布時(shí)的最新穩(wěn)定版）
另外，感謝 RxJava 核心成員流火楓林的技術(shù)支持和內(nèi)測(cè)讀者代碼家炸枣、鮑永章虏等、drakeet、馬琳适肠、有時(shí)放縱霍衫、程序亦非猿、大頭鬼侯养、XZoomEye敦跌、席德雨、TCahead逛揩、Tiiime柠傍、Ailurus、宅學(xué)長(zhǎng)辩稽、妖孽惧笛、大大大大大臣哥、NicodeLee的幫助搂誉，以及周伯通招聘的贊助徐紧。
RxJava 到底是什么
一個(gè)詞：異步。
RxJava 在 GitHub 主頁(yè)上的自我介紹是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一個(gè)在 Java VM 上使用可觀測(cè)的序列來(lái)組成異步的炭懊、基于事件的程序的庫(kù)）并级。這就是 RxJava ，概括得非常精準(zhǔn)侮腹。
然而嘲碧，對(duì)于初學(xué)者來(lái)說(shuō)，這太難看懂了父阻。因?yàn)樗且粋€(gè)『總結(jié)』愈涩，而初學(xué)者更需要一個(gè)『引言』。
其實(shí)加矛， RxJava 的本質(zhì)可以壓縮為異步這一個(gè)詞履婉。說(shuō)到根上，它就是一個(gè)實(shí)現(xiàn)異步操作的庫(kù)斟览，而別的定語(yǔ)都是基于這之上的毁腿。
RxJava 好在哪
換句話說(shuō)，『同樣是做異步，為什么人們用它已烤，而不用現(xiàn)成的 AsyncTask / Handler / XXX / ... 鸠窗？』
一個(gè)詞：簡(jiǎn)潔。
異步操作很關(guān)鍵的一點(diǎn)是程序的簡(jiǎn)潔性胯究，因?yàn)樵谡{(diào)度過(guò)程比較復(fù)雜的情況下稍计，異步代碼經(jīng)常會(huì)既難寫(xiě)也難被讀懂。 Android 創(chuàng)造的AsyncTask
和Handler
裕循，其實(shí)都是為了讓異步代碼更加簡(jiǎn)潔臣嚣。RxJava 的優(yōu)勢(shì)也是簡(jiǎn)潔，但它的簡(jiǎn)潔的與眾不同之處在于费韭，隨著程序邏輯變得越來(lái)越復(fù)雜茧球，它依然能夠保持簡(jiǎn)潔。
[圖片上傳中星持。抢埋。。（2）]
假設(shè)有這樣一個(gè)需求：界面上有一個(gè)自定義的視圖 imageCollectorView
督暂，它的作用是顯示多張圖片揪垄，并能使用 addImage(Bitmap)
方法來(lái)任意增加顯示的圖片。現(xiàn)在需要程序?qū)⒁粋€(gè)給出的目錄數(shù)組 File[] folders
中每個(gè)目錄下的 png 圖片都加載出來(lái)并顯示在imageCollectorView
中逻翁。需要注意的是饥努，由于讀取圖片的這一過(guò)程較為耗時(shí)，需要放在后臺(tái)執(zhí)行八回，而圖片的顯示則必須在 UI 線程執(zhí)行酷愧。常用的實(shí)現(xiàn)方式有多種，我這里貼出其中一種：
new Thread() {
@Override
public void run() {
super.run();
for (File folder : folders) {
File[] files = folder.listFiles();
for (File file : files) {
if (file.getName().endsWith(".png")) {
final Bitmap bitmap = getBitmapFromFile(file);
getActivity().runOnUiThread(new Runnable() {
@Override
public void run() {
imageCollectorView.addImage(bitmap);
} });
}
}
} }}.start();
而如果使用 RxJava 缠诅，實(shí)現(xiàn)方式是這樣的：
Observable.from(folders) . flatMap(new Func1<File, Observable<File>>() {
@Override
public Observable<File> call(File file) {
return Observable.from(file.listFiles());
} }) .filter(new Func1<File, Boolean>() {
@Override
public Boolean call(File file) {
return file.getName().endsWith(".png"); } }) .map(new Func1<File, Bitmap>() {
@Override
public Bitmap call(File file) {
return getBitmapFromFile(file); } }) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Action1<Bitmap>() {
@Override public void call(Bitmap bitmap) { imageCollectorView.addImage(bitmap); } });
那位說(shuō)話了：『你這代碼明明變多了叭茉 ！簡(jiǎn)潔個(gè)毛肮芤士败！』大兄弟你消消氣，我說(shuō)的是邏輯的簡(jiǎn)潔褥伴，不是單純的代碼量少（邏輯簡(jiǎn)潔才是提升讀寫(xiě)代碼速度的必殺技對(duì)不谅将？）。觀察一下你會(huì)發(fā)現(xiàn)重慢， RxJava 的這個(gè)實(shí)現(xiàn)饥臂，是一條從上到下的鏈?zhǔn)秸{(diào)用，沒(méi)有任何嵌套似踱，這在邏輯的簡(jiǎn)潔性上是具有優(yōu)勢(shì)的隅熙。當(dāng)需求變得復(fù)雜時(shí)志衣，這種優(yōu)勢(shì)將更加明顯（試想如果還要求只選取前 10 張圖片，常規(guī)方式要怎么辦猛们？如果有更多這樣那樣的要求呢？再試想狞洋，在這一大堆需求實(shí)現(xiàn)完兩個(gè)月之后需要改功能弯淘，當(dāng)你翻回這里看到自己當(dāng)初寫(xiě)下的那一片迷之縮進(jìn)，你能保證自己將迅速看懂吉懊，而不是對(duì)著代碼重新捋一遍思路庐橙？）。
另外借嗽，如果你的 IDE 是 Android Studio 态鳖，其實(shí)每次打開(kāi)某個(gè) Java 文件的時(shí)候，你會(huì)看到被自動(dòng) Lambda 化的預(yù)覽恶导，這將讓你更加清晰地看到程序邏輯：
Observable.from(folders) .flatMap((Func1) (folder) -> { Observable.from(file.listFiles()) }) .filter((Func1) (file) -> { file.getName().endsWith(".png") }) .map((Func1) (file) -> { getBitmapFromFile(file) }) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe((Action1) (bitmap) -> { imageCollectorView.addImage(bitmap) });
如果你習(xí)慣使用 Retrolambda 浆竭，你也可以直接把代碼寫(xiě)成上面這種簡(jiǎn)潔的形式。而如果你看到這里還不知道什么是 Retrolambda 惨寿，我不建議你現(xiàn)在就去學(xué)習(xí)它邦泄。原因有兩點(diǎn)：1. Lambda 是把雙刃劍，它讓你的代碼簡(jiǎn)潔的同時(shí)裂垦，降低了代碼的可讀性顺囊，因此同時(shí)學(xué)習(xí) RxJava 和 Retrolambda 可能會(huì)讓你忽略 RxJava 的一些技術(shù)細(xì)節(jié)；2. Retrolambda 是 Java 6/7 對(duì) Lambda 表達(dá)式的非官方兼容方案蕉拢，它的向后兼容性和穩(wěn)定性是無(wú)法保障的特碳，因此對(duì)于企業(yè)項(xiàng)目，使用 Retrolambda 是有風(fēng)險(xiǎn)的晕换。所以午乓，與很多 RxJava 的推廣者不同，我并不推薦在學(xué)習(xí) RxJava 的同時(shí)一起學(xué)習(xí) Retrolambda届巩。事實(shí)上硅瞧，我個(gè)人雖然很欣賞 Retrolambda，但我從來(lái)不用它恕汇。
在Flipboard 的 Android 代碼中腕唧，有一段邏輯非常復(fù)雜，包含了多次內(nèi)存操作瘾英、本地文件操作和網(wǎng)絡(luò)操作枣接，對(duì)象分分合合蓄氧，線程間相互配合相互等待宪塔，一會(huì)兒排成人字惨缆，一會(huì)兒排成一字。如果使用常規(guī)的方法來(lái)實(shí)現(xiàn)婴程，肯定是要寫(xiě)得欲仙欲死，然而在使用 RxJava 的情況下酒唉，依然只是一條鏈?zhǔn)秸{(diào)用就完成了墙基。它很長(zhǎng)，但很清晰添谊。
所以财喳， RxJava 好在哪？就好在簡(jiǎn)潔斩狱，好在那把什么復(fù)雜邏輯都能穿成一條線的簡(jiǎn)潔耳高。
API 介紹和原理簡(jiǎn)析
這個(gè)我就做不到一個(gè)詞說(shuō)明了……因?yàn)檫@一節(jié)的主要內(nèi)容就是一步步地說(shuō)明 RxJava 到底怎樣做到了異步，怎樣做到了簡(jiǎn)潔所踊。
- 概念：擴(kuò)展的觀察者模式
RxJava 的異步實(shí)現(xiàn)泌枪，是通過(guò)一種擴(kuò)展的觀察者模式來(lái)實(shí)現(xiàn)的。
觀察者模式
先簡(jiǎn)述一下觀察者模式秕岛，已經(jīng)熟悉的可以跳過(guò)這一段碌燕。
觀察者模式面向的需求是：A 對(duì)象（觀察者）對(duì) B 對(duì)象（被觀察者）的某種變化高度敏感，需要在 B 變化的一瞬間做出反應(yīng)瓣蛀。舉個(gè)例子陆蟆，新聞里喜聞樂(lè)見(jiàn)的警察抓小偷，警察需要在小偷伸手作案的時(shí)候?qū)嵤┳ゲ锻镌觥Ｔ谶@個(gè)例子里叠殷，警察是觀察者，小偷是被觀察者诈皿，警察需要時(shí)刻盯著小偷的一舉一動(dòng)林束，才能保證不會(huì)漏過(guò)任何瞬間。程序的觀察者模式和這種真正的『觀察』略有不同稽亏，觀察者不需要時(shí)刻盯著被觀察者（例如 A 不需要每過(guò) 2ms 就檢查一次 B 的狀態(tài)）壶冒，而是采用注冊(cè)(Register)或者稱為訂閱(Subscribe)的方式，告訴被觀察者：我需要你的某某狀態(tài)截歉，你要在它變化的時(shí)候通知我胖腾。 Android 開(kāi)發(fā)中一個(gè)比較典型的例子是點(diǎn)擊監(jiān)聽(tīng)器 OnClickListener
。對(duì)設(shè)置OnClickListener
來(lái)說(shuō)瘪松， View
是被觀察者咸作， OnClickListener
是觀察者，二者通過(guò) setOnClickListener()
方法達(dá)成訂閱關(guān)系宵睦。訂閱之后用戶點(diǎn)擊按鈕的瞬間记罚，Android Framework 就會(huì)將點(diǎn)擊事件發(fā)送給已經(jīng)注冊(cè)的 OnClickListener
。采取這樣被動(dòng)的觀察方式壳嚎，既省去了反復(fù)檢索狀態(tài)的資源消耗桐智，也能夠得到最高的反饋速度末早。當(dāng)然，這也得益于我們可以隨意定制自己程序中的觀察者和被觀察者说庭，而警察叔叔明顯無(wú)法要求小偷『你在作案的時(shí)候務(wù)必通知我』然磷。
OnClickListener 的模式大致如下圖：
如圖所示，通過(guò) setOnClickListener()
方法刊驴，Button
持有 OnClickListener
的引用（這一過(guò)程沒(méi)有在圖上畫(huà)出）样屠；當(dāng)用戶點(diǎn)擊時(shí)，Button
自動(dòng)調(diào)用 OnClickListener
的 onClick()
方法缺脉。另外，如果把這張圖中的概念抽象出來(lái)（Button
-> 被觀察者悦穿、OnClickListener
-> 觀察者攻礼、setOnClickListener()
-> 訂閱，onClick()
-> 事件）栗柒，就由專用的觀察者模式（例如只用于監(jiān)聽(tīng)控件點(diǎn)擊）轉(zhuǎn)變成了通用的觀察者模式礁扮。如下圖：
而 RxJava 作為一個(gè)工具庫(kù)，使用的就是通用形式的觀察者模式瞬沦。
RxJava 的觀察者模式
RxJava 有四個(gè)基本概念：Observable
(可觀察者太伊，即被觀察者)、 Observer
(觀察者)逛钻、 subscribe
(訂閱)僚焦、事件。Observable
和 Observer
通過(guò) subscribe()
方法實(shí)現(xiàn)訂閱關(guān)系曙痘，從而 Observable
可以在需要的時(shí)候發(fā)出事件來(lái)通知 Observer
芳悲。
與傳統(tǒng)觀察者模式不同， RxJava 的事件回調(diào)方法除了普通事件 onNext()
（相當(dāng)于 onClick()
/ onEvent()
）之外边坤，還定義了兩個(gè)特殊的事件：onCompleted()
和 onError()
名扛。
onCompleted()
: 事件隊(duì)列完結(jié)。RxJava 不僅把每個(gè)事件單獨(dú)處理茧痒，還會(huì)把它們看做一個(gè)隊(duì)列肮韧。RxJava 規(guī)定，當(dāng)不會(huì)再有新的onNext()
發(fā)出時(shí)旺订，需要觸發(fā) onCompleted()
方法作為標(biāo)志弄企。
onError()
: 事件隊(duì)列異常。在事件處理過(guò)程中出異常時(shí)耸峭，onError()
會(huì)被觸發(fā)桩蓉，同時(shí)隊(duì)列自動(dòng)終止，不允許再有事件發(fā)出劳闹。
在一個(gè)正確運(yùn)行的事件序列中, onCompleted()
和 onError()
有且只有一個(gè)院究，并且是事件序列中的最后一個(gè)洽瞬。需要注意的是，onCompleted()
和 onError()
二者也是互斥的业汰，即在隊(duì)列中調(diào)用了其中一個(gè)伙窃，就不應(yīng)該再調(diào)用另一個(gè)。
RxJava 的觀察者模式大致如下圖：
- 基本實(shí)現(xiàn)
基于以上的概念样漆， RxJava 的基本實(shí)現(xiàn)主要有三點(diǎn)：
- 創(chuàng)建 Observer
Observer 即觀察者为障，它決定事件觸發(fā)的時(shí)候?qū)⒂性鯓拥男袨椤?RxJava 中的 Observer
接口的實(shí)現(xiàn)方式：
Observer<String> observer = new Observer<String>() { @Override public void onNext(String s) { Log.d(tag, "Item: " + s); } @Override public void onCompleted() { Log.d(tag, "Completed!"); } @Override public void onError(Throwable e) { Log.d(tag, "Error!"); }};
除了 Observer
接口之外，RxJava 還內(nèi)置了一個(gè)實(shí)現(xiàn)了 Observer
的抽象類：Subscriber
放祟。 Subscriber
對(duì) Observer
接口進(jìn)行了一些擴(kuò)展鳍怨，但他們的基本使用方式是完全一樣的：
Subscriber<String> subscriber = new Subscriber<String>() { @Override public void onNext(String s) { Log.d(tag, "Item: " + s); } @Override public void onCompleted() { Log.d(tag, "Completed!"); } @Override public void onError(Throwable e) { Log.d(tag, "Error!"); }};
不僅基本使用方式一樣，實(shí)質(zhì)上跪妥，在 RxJava 的 subscribe 過(guò)程中鞋喇，Observer
也總是會(huì)先被轉(zhuǎn)換成一個(gè) Subscriber
再使用。所以如果你只想使用基本功能眉撵，選擇 Observer
和 Subscriber
是完全一樣的侦香。它們的區(qū)別對(duì)于使用者來(lái)說(shuō)主要有兩點(diǎn)：
onStart()
: 這是 Subscriber
增加的方法。它會(huì)在 subscribe 剛開(kāi)始纽疟，而事件還未發(fā)送之前被調(diào)用罐韩，可以用于做一些準(zhǔn)備工作，例如數(shù)據(jù)的清零或重置污朽。這是一個(gè)可選方法散吵，默認(rèn)情況下它的實(shí)現(xiàn)為空。需要注意的是蟆肆，如果對(duì)準(zhǔn)備工作的線程有要求（例如彈出一個(gè)顯示進(jìn)度的對(duì)話框错蝴，這必須在主線程執(zhí)行）， onStart()
就不適用了颓芭，因?yàn)樗偸窃?subscribe 所發(fā)生的線程被調(diào)用顷锰，而不能指定線程。要在指定的線程來(lái)做準(zhǔn)備工作亡问，可以使用 doOnSubscribe()
方法官紫，具體可以在后面的文中看到。
unsubscribe()
: 這是 Subscriber
所實(shí)現(xiàn)的另一個(gè)接口 Subscription
的方法州藕，用于取消訂閱束世。在這個(gè)方法被調(diào)用后，Subscriber
將不再接收事件床玻。一般在這個(gè)方法調(diào)用前毁涉，可以使用 isUnsubscribed()
先判斷一下?tīng)顟B(tài)。 unsubscribe()
這個(gè)方法很重要锈死，因?yàn)樵趕ubscribe()
之后贫堰， Observable
會(huì)持有 Subscriber
的引用穆壕，這個(gè)引用如果不能及時(shí)被釋放，將有內(nèi)存泄露的風(fēng)險(xiǎn)其屏。所以最好保持一個(gè)原則：要在不再使用的時(shí)候盡快在合適的地方（例如 onPause()
onStop()
等方法中）調(diào)用 unsubscribe()
來(lái)解除引用關(guān)系喇勋，以避免內(nèi)存泄露的發(fā)生。
- 創(chuàng)建 Observable
Observable 即被觀察者偎行，它決定什么時(shí)候觸發(fā)事件以及觸發(fā)怎樣的事件川背。 RxJava 使用 create()
方法來(lái)創(chuàng)建一個(gè) Observable ，并為它定義事件觸發(fā)規(guī)則：
Observable observable = Observable.create(new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("Hello"); subscriber.onNext("Hi"); subscriber.onNext("Aloha"); subscriber.onCompleted(); }});
可以看到蛤袒，這里傳入了一個(gè) OnSubscribe
對(duì)象作為參數(shù)熄云。OnSubscribe
會(huì)被存儲(chǔ)在返回的 Observable
對(duì)象中，它的作用相當(dāng)于一個(gè)計(jì)劃表妙真，當(dāng) Observable
被訂閱的時(shí)候皱碘，OnSubscribe
的 call()
方法會(huì)自動(dòng)被調(diào)用，事件序列就會(huì)依照設(shè)定依次觸發(fā)（對(duì)于上面的代碼隐孽，就是觀察者Subscriber
將會(huì)被調(diào)用三次 onNext()
和一次 onCompleted()
）。這樣健蕊，由被觀察者調(diào)用了觀察者的回調(diào)方法菱阵，就實(shí)現(xiàn)了由被觀察者向觀察者的事件傳遞，即觀察者模式缩功。
這個(gè)例子很簡(jiǎn)單：事件的內(nèi)容是字符串晴及，而不是一些復(fù)雜的對(duì)象；事件的內(nèi)容是已經(jīng)定好了的嫡锌，而不像有的觀察者模式一樣是待確定的（例如網(wǎng)絡(luò)請(qǐng)求的結(jié)果在請(qǐng)求返回之前是未知的）虑稼；所有事件在一瞬間被全部發(fā)送出去，而不是夾雜一些確定或不確定的時(shí)間間隔或者經(jīng)過(guò)某種觸發(fā)器來(lái)觸發(fā)的势木≈刖耄總之，這個(gè)例子看起來(lái)毫無(wú)實(shí)用價(jià)值啦桌。但這是為了便于說(shuō)明溯壶，實(shí)質(zhì)上只要你想，各種各樣的事件發(fā)送規(guī)則你都可以自己來(lái)寫(xiě)甫男。至于具體怎么做且改，后面都會(huì)講到，但現(xiàn)在不行板驳。只有把基礎(chǔ)原理先說(shuō)明白了又跛，上層的運(yùn)用才能更容易說(shuō)清楚。
create()
方法是 RxJava 最基本的創(chuàng)造事件序列的方法若治】叮基于這個(gè)方法感混， RxJava 還提供了一些方法用來(lái)快捷創(chuàng)建事件隊(duì)列，例如：
just(T...)
: 將傳入的參數(shù)依次發(fā)送出來(lái)菌仁。
Observable observable = Observable.just("Hello", "Hi", "Aloha");// 將會(huì)依次調(diào)用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();
from(T[])
/ from(Iterable<? extends T>)
: 將傳入的數(shù)組或 Iterable
拆分成具體對(duì)象后浩习，依次發(fā)送出來(lái)。
String[] words = {"Hello", "Hi", "Aloha"};Observable observable = Observable.from(words);// 將會(huì)依次調(diào)用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();
上面 just(T...)
的例子和 from(T[])
的例子济丘，都和之前的 create(OnSubscribe)
的例子是等價(jià)的谱秽。
- Subscribe (訂閱)
創(chuàng)建了 Observable
和 Observer
之后，再用 subscribe()
方法將它們聯(lián)結(jié)起來(lái)摹迷，整條鏈子就可以工作了疟赊。代碼形式很簡(jiǎn)單：
observable.subscribe(observer);// 或者：observable.subscribe(subscriber);
有人可能會(huì)注意到， subscribe()
這個(gè)方法有點(diǎn)怪：它看起來(lái)是『observalbe
訂閱了 observer
/ subscriber
』而不是『observer
/subscriber
訂閱了 observalbe
』峡碉，這看起來(lái)就像『雜志訂閱了讀者』一樣顛倒了對(duì)象關(guān)系近哟。這讓人讀起來(lái)有點(diǎn)別扭，不過(guò)如果把 API 設(shè)計(jì)成observer.subscribe(observable)
/ subscriber.subscribe(observable)
鲫寄，雖然更加符合思維邏輯吉执，但對(duì)流式 API 的設(shè)計(jì)就造成影響了，比較起來(lái)明顯是得不償失的地来。
Observable.subscribe(Subscriber)
的內(nèi)部實(shí)現(xiàn)是這樣的（僅核心代碼）：
// 注意：這不是 subscribe() 的源碼戳玫，而是將源碼中與性能、兼容性未斑、擴(kuò)展性有關(guān)的代碼剔除后的核心代碼咕宿。// 如果需要看源碼，可以去 RxJava 的 GitHub 倉(cāng)庫(kù)下載蜡秽。public Subscription subscribe(Subscriber subscriber) { subscriber.onStart(); onSubscribe.call(subscriber); return subscriber;}
可以看到府阀，subscriber()
做了3件事：
調(diào)用 Subscriber.onStart()
。這個(gè)方法在前面已經(jīng)介紹過(guò)芽突，是一個(gè)可選的準(zhǔn)備方法试浙。
調(diào)用 Observable
中的 OnSubscribe.call(Subscriber)
。在這里寞蚌，事件發(fā)送的邏輯開(kāi)始運(yùn)行川队。從這也可以看出，在 RxJava 中睬澡，Observable
并不是在創(chuàng)建的時(shí)候就立即開(kāi)始發(fā)送事件固额，而是在它被訂閱的時(shí)候，即當(dāng) subscribe()
方法執(zhí)行的時(shí)候煞聪。
將傳入的 Subscriber
作為 Subscription
返回斗躏。這是為了方便 unsubscribe()
.
整個(gè)過(guò)程中對(duì)象間的關(guān)系如下圖：
或者可以看動(dòng)圖：
除了 subscribe(Observer)
和 subscribe(Subscriber)
，subscribe()
還支持不完整定義的回調(diào)昔脯，RxJava 會(huì)自動(dòng)根據(jù)定義創(chuàng)建出Subscriber
啄糙。形式如下：
Action1<String> onNextAction = new Action1<String>() { // onNext()
@Override public void call(String s) { Log.d(tag, s); }};Action1<Throwable> onErrorAction = new Action1<Throwable>() {
// onError() @Override public void call(Throwable throwable) {
// Error handling }};Action0 onCompletedAction = new Action0() {
// onCompleted() @Override public void call() { Log.d(tag, "completed"); }};
// 自動(dòng)創(chuàng)建 Subscriber 笛臣，并使用 onNextAction 來(lái)定義 onNext()observable.subscribe(onNextAction);// 自動(dòng)創(chuàng)建 Subscriber ，并使用 onNextAction 和 onErrorAction 來(lái)定義 onNext() 和 onError()observable.subscribe(onNextAction, onErrorAction);// 自動(dòng)創(chuàng)建 Subscriber 隧饼，并使用 onNextAction沈堡、 onErrorAction 和 onCompletedAction 來(lái)定義 onNext()、 onError() 和 onCompleted()observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
簡(jiǎn)單解釋一下這段代碼中出現(xiàn)的 Action1
和 Action0
燕雁。 Action0
是 RxJava 的一個(gè)接口诞丽，它只有一個(gè)方法 call()
，這個(gè)方法是無(wú)參無(wú)返回值的拐格；由于 onCompleted()
方法也是無(wú)參無(wú)返回值的僧免，因此 Action0
可以被當(dāng)成一個(gè)包裝對(duì)象，將 onCompleted()
的內(nèi)容打包起來(lái)將自己作為一個(gè)參數(shù)傳入 subscribe()
以實(shí)現(xiàn)不完整定義的回調(diào)捏浊。這樣其實(shí)也可以看做將 onCompleted()
方法作為參數(shù)傳進(jìn)了 subscribe()
懂衩，相當(dāng)于其他某些語(yǔ)言中的『閉包』。 Action1
也是一個(gè)接口金踪，它同樣只有一個(gè)方法 call(T param)
浊洞，這個(gè)方法也無(wú)返回值，但有一個(gè)參數(shù)胡岔；與 Action0
同理法希，由于 onNext(T obj)
和 onError(Throwable error)
也是單參數(shù)無(wú)返回值的，因此 Action1
可以將 onNext(obj)
和 onError(error)
打包起來(lái)傳入 subscribe()
以實(shí)現(xiàn)不完整定義的回調(diào)姐军。事實(shí)上，雖然 Action0
和 Action1
在 API 中使用最廣泛尖淘，但 RxJava 是提供了多個(gè) ActionX
形式的接口 (例如 Action2
, Action3
) 的奕锌，它們可以被用以包裝不同的無(wú)返回值的方法。
注：正如前面所提到的村生，Observer
和 Subscriber
具有相同的角色惊暴，而且 Observer
在 subscribe()
過(guò)程中最終會(huì)被轉(zhuǎn)換成 Subscriber
對(duì)象，因此趁桃，從這里開(kāi)始辽话，后面的描述我將用 Subscriber
來(lái)代替 Observer
，這樣更加嚴(yán)謹(jǐn)卫病。
- 場(chǎng)景示例
下面舉兩個(gè)例子：
為了把原理用更清晰的方式表述出來(lái)油啤，本文中挑選的都是功能盡可能簡(jiǎn)單的例子，以至于有些示例代碼看起來(lái)會(huì)有『畫(huà)蛇添足』『明明不用 RxJava 可以更簡(jiǎn)便地解決問(wèn)題』的感覺(jué)蟀苛。當(dāng)你看到這種情況益咬，不要覺(jué)得是因?yàn)?RxJava 太啰嗦，而是因?yàn)樵谶^(guò)早的時(shí)候舉出真實(shí)場(chǎng)景的例子并不利于原理的解析帜平，因此我刻意挑選了簡(jiǎn)單的情景幽告。
a. 打印字符串?dāng)?shù)組
將字符串?dāng)?shù)組 names
中的所有字符串依次打印出來(lái)：
String[] names = ...;Observable.from(names) .subscribe(new Action1<String>() { @Override public void call(String name) { Log.d(tag, name); } });
b. 由 id 取得圖片并顯示
由指定的一個(gè) drawable 文件 id drawableRes
取得圖片梅鹦，并顯示在 ImageView
中，并在出現(xiàn)異常的時(shí)候打印 Toast 報(bào)錯(cuò)：
int drawableRes = ...;ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
@Override
public void call(Subscriber<? super Drawable> subscriber) {
Drawable drawable = getTheme().getDrawable(drawableRes));
subscriber.onNext(drawable); subscriber.onCompleted(); }}).subscribe(new Observer<Drawable>() { @Override
public void onNext(Drawable drawable) {
imageView.setImageDrawable(drawable); }
@Override
public void onCompleted() { }
@Override
public void onError(Throwable e) {
Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show(); }});
正如上面兩個(gè)例子這樣冗锁，創(chuàng)建出 Observable
和 Subscriber
齐唆，再用 subscribe()
將它們串起來(lái)，一次 RxJava 的基本使用就完成了冻河。非常簡(jiǎn)單箍邮。
然而，
在 RxJava 的默認(rèn)規(guī)則中芋绸，事件的發(fā)出和消費(fèi)都是在同一個(gè)線程的媒殉。也就是說(shuō)，如果只用上面的方法摔敛，實(shí)現(xiàn)出來(lái)的只是一個(gè)同步的觀察者模式廷蓉。觀察者模式本身的目的就是『后臺(tái)處理，前臺(tái)回調(diào)』的異步機(jī)制马昙，因此異步對(duì)于 RxJava 是至關(guān)重要的桃犬。而要實(shí)現(xiàn)異步，則需要用到 RxJava 的另一個(gè)概念： Scheduler
行楞。
- 線程控制 —— Scheduler (一)
在不指定線程的情況下攒暇， RxJava 遵循的是線程不變的原則，即：在哪個(gè)線程調(diào)用 subscribe()
子房，就在哪個(gè)線程生產(chǎn)事件形用；在哪個(gè)線程生產(chǎn)事件，就在哪個(gè)線程消費(fèi)事件证杭。如果需要切換線程田度，就需要用到 Scheduler
（調(diào)度器）。
- Scheduler 的 API (一)
在RxJava 中解愤，Scheduler
——調(diào)度器镇饺，相當(dāng)于線程控制器，RxJava 通過(guò)它來(lái)指定每一段代碼應(yīng)該運(yùn)行在什么樣的線程送讲。RxJava 已經(jīng)內(nèi)置了幾個(gè) Scheduler
奸笤，它們已經(jīng)適合大多數(shù)的使用場(chǎng)景：
Schedulers.immediate()
: 直接在當(dāng)前線程運(yùn)行，相當(dāng)于不指定線程哼鬓。這是默認(rèn)的 Scheduler
监右。
Schedulers.newThread()
: 總是啟用新線程，并在新線程執(zhí)行操作异希。
Schedulers.io()
: I/O 操作（讀寫(xiě)文件秸侣、讀寫(xiě)數(shù)據(jù)庫(kù)、網(wǎng)絡(luò)信息交互等）所使用的 Scheduler
。行為模式和 newThread()
差不多味榛，區(qū)別在于 io()
的內(nèi)部實(shí)現(xiàn)是是用一個(gè)無(wú)數(shù)量上限的線程池椭坚，可以重用空閑的線程，因此多數(shù)情況下 io()
比 newThread()
更有效率搏色。不要把計(jì)算工作放在 io()
中善茎，可以避免創(chuàng)建不必要的線程。
Schedulers.computation()
: 計(jì)算所使用的 Scheduler
频轿。這個(gè)計(jì)算指的是 CPU 密集型計(jì)算垂涯，即不會(huì)被 I/O 等操作限制性能的操作，例如圖形的計(jì)算航邢。這個(gè) Scheduler
使用的固定的線程池耕赘，大小為 CPU 核數(shù)。不要把 I/O 操作放在 computation()
中膳殷，否則 I/O 操作的等待時(shí)間會(huì)浪費(fèi) CPU操骡。
另外， Android 還有一個(gè)專用的 AndroidSchedulers.mainThread()
赚窃，它指定的操作將在 Android 主線程運(yùn)行册招。
有了這幾個(gè) Scheduler
，就可以使用 subscribeOn()
和 observeOn()
兩個(gè)方法來(lái)對(duì)線程進(jìn)行控制了勒极。 * subscribeOn()
: 指定 subscribe()
所發(fā)生的線程是掰，即 Observable.OnSubscribe
被激活時(shí)所處的線程∪枘洌或者叫做事件產(chǎn)生的線程键痛。 * observeOn()
: 指定 Subscriber
所運(yùn)行在的線程∝移撸或者叫做事件消費(fèi)的線程絮短。
文字?jǐn)⑹隹倸w難理解，上代碼：
Observable.just(1, 2, 3, 4) .subscribeOn(Schedulers.io()) // 指定 subscribe() 發(fā)生在 IO 線程 .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回調(diào)發(fā)生在主線程 .subscribe(new Action1<Integer>() { @Override public void call(Integer number) { Log.d(tag, "number:" + number); } });
上面這段代碼中乐尊，由于 subscribeOn(Schedulers.io())
的指定戚丸，被創(chuàng)建的事件的內(nèi)容 1
划址、2
扔嵌、3
、4
將會(huì)在 IO 線程發(fā)出夺颤；而由于observeOn(AndroidScheculers.mainThread()
) 的指定痢缎，因此 subscriber
數(shù)字的打印將發(fā)生在主線程 。事實(shí)上世澜，這種在 subscribe()
之前寫(xiě)上兩句 subscribeOn(Scheduler.io())
和 observeOn(AndroidSchedulers.mainThread())
的使用方式非常常見(jiàn)独旷，它適用于多數(shù)的 『后臺(tái)線程取數(shù)據(jù)，主線程顯示』的程序策略。
而前面提到的由圖片 id 取得圖片并顯示的例子嵌洼，如果也加上這兩句：
int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
@Override
public void call(Subscriber<? super Drawable> subscriber) {
Drawable drawable = getTheme().getDrawable(drawableRes));
subscriber.onNext(drawable); subscriber.onCompleted(); }}).subscribeOn(
// 指定 subscribe() 發(fā)生在 IO 線程
Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
// 指定 Subscriber 的回調(diào)發(fā)生在主線程
.subscribe(new Observer<Drawable>() {
@Override
public void onNext(Drawable drawable) {
imageView.setImageDrawable(drawable); }
@Override
public void onCompleted() { }
@Override public void onError(Throwable e) {
Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show(); }});
那么案疲，加載圖片將會(huì)發(fā)生在 IO 線程，而設(shè)置圖片則被設(shè)定在了主線程麻养。這就意味著褐啡，即使加載圖片耗費(fèi)了幾十甚至幾百毫秒的時(shí)間，也不會(huì)造成絲毫界面的卡頓鳖昌。
- Scheduler 的原理 (一)
RxJava 的 Scheduler API 很方便备畦，也很神奇（加了一句話就把線程切換了，怎么做到的许昨？而且 subscribe()
不是最外層直接調(diào)用的方法嗎懂盐，它竟然也能被指定線程？）糕档。然而 Scheduler 的原理需要放在后面講莉恼，因?yàn)樗脑硎且韵乱还?jié)《變換》的原理作為基礎(chǔ)的。
好吧這一節(jié)其實(shí)我屁也沒(méi)說(shuō)翼岁，只是為了讓你安心类垫，讓你知道我不是忘了講原理，而是把它放在了更合適的地方琅坡。
- 變換
終于要到牛逼的地方了悉患，不管你激動(dòng)不激動(dòng)，反正我是激動(dòng)了榆俺。
RxJava 提供了對(duì)事件序列進(jìn)行變換的支持售躁，這是它的核心功能之一，也是大多數(shù)人說(shuō)『RxJava 真是太好用了』的最大原因茴晋。所謂變換陪捷，就是將事件序列中的對(duì)象或整個(gè)序列進(jìn)行加工處理，轉(zhuǎn)換成不同的事件或事件序列诺擅。概念說(shuō)著總是模糊難懂的市袖，來(lái)看 API。
- API
首先看一個(gè) map()
的例子：
Observable.just("images/logo.png") // 輸入類型 String .map(new Func1<String, Bitmap>() { @Override public Bitmap call(String filePath) { // 參數(shù)類型 String return getBitmapFromPath(filePath); // 返回類型 Bitmap } }) .subscribe(new Action1<Bitmap>() { @Override public void call(Bitmap bitmap) { // 參數(shù)類型 Bitmap showBitmap(bitmap); } });
這里出現(xiàn)了一個(gè)叫做 Func1
的類烁涌。它和 Action1
非常相似苍碟，也是 RxJava 的一個(gè)接口，用于包裝含有一個(gè)參數(shù)的方法撮执。 Func1
和 Action
的區(qū)別在于续捂， Func1
包裝的是有返回值的方法槐臀。另外痹籍，和 ActionX
一樣鼎天， FuncX
也有多個(gè)颜凯，用于不同參數(shù)個(gè)數(shù)的方法。FuncX
和 ActionX
的區(qū)別在 FuncX
包裝的是有返回值的方法仗扬。
可以看到症概，map()
方法將參數(shù)中的 String
對(duì)象轉(zhuǎn)換成一個(gè) Bitmap
對(duì)象后返回，而在經(jīng)過(guò) map()
方法后早芭，事件的參數(shù)類型也由 String
轉(zhuǎn)為了 Bitmap
穴豫。這種直接變換對(duì)象并返回的，是最常見(jiàn)的也最容易理解的變換逼友。不過(guò) RxJava 的變換遠(yuǎn)不止這樣精肃，它不僅可以針對(duì)事件對(duì)象，還可以針對(duì)整個(gè)事件隊(duì)列帜乞，這使得 RxJava 變得非常靈活司抱。我列舉幾個(gè)常用的變換：
map()
: 事件對(duì)象的直接變換，具體功能上面已經(jīng)介紹過(guò)黎烈。它是 RxJava 最常用的變換习柠。 map()
的示意圖：
flatMap()
: 這是一個(gè)很有用但非常難理解的變換，因此我決定花多些篇幅來(lái)介紹它照棋。 首先假設(shè)這么一種需求：假設(shè)有一個(gè)數(shù)據(jù)結(jié)構(gòu)『學(xué)生』资溃，現(xiàn)在需要打印出一組學(xué)生的名字。實(shí)現(xiàn)方式很簡(jiǎn)單：
Student[] students = ...;
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onNext(String name) { Log.d(tag, name); } ...};
Observable.from(students) .map(new Func1<Student, String>() {
@Override
public String call(Student student) { return student.getName(); } }) .subscribe(subscriber);
很簡(jiǎn)單烈炭。那么再假設(shè)：如果要打印出每個(gè)學(xué)生所需要修的所有課程的名稱呢溶锭？（需求的區(qū)別在于，每個(gè)學(xué)生只有一個(gè)名字符隙，但卻有多個(gè)課程趴捅。）首先可以這樣實(shí)現(xiàn)：
Student[] students = ...;
Subscriber<Student> subscriber = new Subscriber<Student>() {
@Override public void onNext(Student student) {
List<Course> courses = student.getCourses();
for (int i = 0; i < courses.size(); i++) {
Course course = courses.get(i);
Log.d(tag, course.getName()); } } ...};
Observable.from(students) .subscribe(subscriber);
依然很簡(jiǎn)單。那么如果我不想在 Subscriber
中使用 for 循環(huán)霹疫，而是希望 Subscriber
中直接傳入單個(gè)的 Course
對(duì)象呢（這對(duì)于代碼復(fù)用很重要）拱绑？用 map()
顯然是不行的，因?yàn)?map()
是一對(duì)一的轉(zhuǎn)化丽蝎，而我現(xiàn)在的要求是一對(duì)多的轉(zhuǎn)化猎拨。那怎么才能把一個(gè) Student 轉(zhuǎn)化成多個(gè) Course 呢？
這個(gè)時(shí)候屠阻，就需要用 flatMap()
了：
Student[] students = ...;
Subscriber<Course> subscriber = new Subscriber<Course>() {
@Override
public void onNext(Course course) {
Log.d(tag, course.getName()); } ...};
Observable.from(students) .flatMap(new Func1<Student, Observable<Course>>() {
@Override
public Observable<Course> call(Student student) {
return Observable.from(student.getCourses()); } }) .subscribe(subscriber);
從上面的代碼可以看出红省， flatMap()
和 map()
有一個(gè)相同點(diǎn)：它也是把傳入的參數(shù)轉(zhuǎn)化之后返回另一個(gè)對(duì)象。但需要注意栏笆，和 map()
不同的是类腮， flatMap()
中返回的是個(gè) Observable
對(duì)象臊泰，并且這個(gè) Observable
對(duì)象并不是被直接發(fā)送到了 Subscriber
的回調(diào)方法中蛉加。flatMap()
的原理是這樣的：1. 使用傳入的事件對(duì)象創(chuàng)建一個(gè) Observable
對(duì)象蚜枢；2. 并不發(fā)送這個(gè) Observable
, 而是將它激活，于是它開(kāi)始發(fā)送事件针饥；3. 每一個(gè)創(chuàng)建出來(lái)的 Observable
發(fā)送的事件厂抽，都被匯入同一個(gè) Observable
，而這個(gè) Observable
負(fù)責(zé)將這些事件統(tǒng)一交給Subscriber
的回調(diào)方法丁眼。這三個(gè)步驟筷凤，把事件拆成了兩級(jí)，通過(guò)一組新創(chuàng)建的 Observable
將初始的對(duì)象『鋪平』之后通過(guò)統(tǒng)一路徑分發(fā)了下去苞七。而這個(gè)『鋪平』就是 flatMap()
所謂的 flat藐守。
flatMap()
示意圖：
擴(kuò)展：由于可以在嵌套的 Observable
中添加異步代碼， flatMap()
也常用于嵌套的異步操作蹂风，例如嵌套的網(wǎng)絡(luò)請(qǐng)求卢厂。示例代碼（Retrofit + RxJava）：
networkClient.token() // 返回 Observable<String>，在訂閱時(shí)請(qǐng)求 token惠啄，并在響應(yīng)后發(fā)送 token .flatMap(new Func1<String, Observable<Messages>>() { @Override public Observable<Messages> call(String token) { // 返回 Observable<Messages>慎恒，在訂閱時(shí)請(qǐng)求消息列表，并在響應(yīng)后發(fā)送請(qǐng)求到的消息列表 return networkClient.messages(); } }) .subscribe(new Action1<Messages>() { @Override public void call(Messages messages) { // 處理顯示消息列表 showMessages(messages); } });
傳統(tǒng)的嵌套請(qǐng)求需要使用嵌套的 Callback 來(lái)實(shí)現(xiàn)撵渡。而通過(guò) flatMap()
融柬，可以把嵌套的請(qǐng)求寫(xiě)在一條鏈中，從而保持程序邏輯的清晰趋距。
throttleFirst()
: 在每次事件觸發(fā)后的一定時(shí)間間隔內(nèi)丟棄新的事件粒氧。常用作去抖動(dòng)過(guò)濾，例如按鈕的點(diǎn)擊監(jiān)聽(tīng)器：RxView.clickEvents(button) // RxBinding 代碼节腐，后面的文章有解釋 .throttleFirst(500, TimeUnit.MILLISECONDS) // 設(shè)置防抖間隔為 500ms .subscribe(subscriber);
媽媽再也不怕我的用戶手抖點(diǎn)開(kāi)兩個(gè)重復(fù)的界面啦靠欢。
此外， RxJava 還提供很多便捷的方法來(lái)實(shí)現(xiàn)事件序列的變換铜跑，這里就不一一舉例了门怪。
- 變換的原理：lift()
這些變換雖然功能各有不同，但實(shí)質(zhì)上都是針對(duì)事件序列的處理和再發(fā)送锅纺。而在 RxJava 的內(nèi)部掷空，它們是基于同一個(gè)基礎(chǔ)的變換方法：lift(Operator)
。首先看一下 lift()
的內(nèi)部實(shí)現(xiàn)（僅核心代碼）：
// 注意：這不是 lift() 的源碼囤锉，而是將源碼中與性能坦弟、兼容性、擴(kuò)展性有關(guān)的代碼剔除后的核心代碼官地。// 如果需要看源碼酿傍，可以去 RxJava 的 GitHub 倉(cāng)庫(kù)下載。
public <R> Observable<R> lift(Operator<? extends R, ? super T> operator) {
return Observable.create(new OnSubscribe<R>() {
@Override
public void call(Subscriber subscriber) {
Subscriber newSubscriber = operator.call(subscriber);
newSubscriber.onStart();
onSubscribe.call(newSubscriber);
} });}
這段代碼很有意思：它生成了一個(gè)新的 Observable
并返回驱入，而且創(chuàng)建新 Observable
所用的參數(shù) OnSubscribe
的回調(diào)方法 call()
中的實(shí)現(xiàn)竟然看起來(lái)和前面講過(guò)的 Observable.subscribe()
一樣赤炒！然而它們并不一樣喲~不一樣的地方關(guān)鍵就在于第二行onSubscribe.call(subscriber)
中的 onSubscribe
所指代的對(duì)象不同（高能預(yù)警：接下來(lái)的幾句話可能會(huì)導(dǎo)致身體的嚴(yán)重不適）——
subscribe()
中這句話的 onSubscribe
指的是 Observable
中的 onSubscribe
對(duì)象氯析，這個(gè)沒(méi)有問(wèn)題，但是 lift()
之后的情況就復(fù)雜了點(diǎn)莺褒。
當(dāng)含有 lift()
時(shí)： 1.lift()
創(chuàng)建了一個(gè) Observable
后掩缓，加上之前的原始 Observable
，已經(jīng)有兩個(gè) Observable
了遵岩； 2.而同樣地你辣，新 Observable
里的新 OnSubscribe
加上之前的原始 Observable
中的原始 OnSubscribe
，也就有了兩個(gè) OnSubscribe
尘执； 3.當(dāng)用戶調(diào)用經(jīng)過(guò) lift()
后的 Observable
的 subscribe()
的時(shí)候舍哄，使用的是 lift()
所返回的新的 Observable
，于是它所觸發(fā)的onSubscribe.call(subscriber)
誊锭，也是用的新 Observable
中的新 OnSubscribe
蠢熄，即在 lift()
中生成的那個(gè) OnSubscribe
； 4.而這個(gè)新 OnSubscribe
的 call()
方法中的 onSubscribe
炉旷，就是指的原始 Observable
中的原始 OnSubscribe
签孔，在這個(gè) call()
方法里，新 OnSubscribe
利用 operator.call(subscriber)
生成了一個(gè)新的 Subscriber
（Operator
就是在這里窘行，通過(guò)自己的 call()
方法將新 Subscriber
和原始 Subscriber
進(jìn)行關(guān)聯(lián)饥追，并插入自己的『變換』代碼以實(shí)現(xiàn)變換），然后利用這個(gè)新 Subscriber
向原始Observable
進(jìn)行訂閱罐盔。 這樣就實(shí)現(xiàn)了 lift()
過(guò)程但绕，有點(diǎn)像一種代理機(jī)制，通過(guò)事件攔截和處理實(shí)現(xiàn)事件序列的變換惶看。
精簡(jiǎn)掉細(xì)節(jié)的話捏顺，也可以這么說(shuō)：在 Observable
執(zhí)行了 lift(Operator)
方法之后，會(huì)返回一個(gè)新的 Observable
纬黎，這個(gè)新的 Observable
會(huì)像一個(gè)代理一樣幅骄，負(fù)責(zé)接收原始的 Observable
發(fā)出的事件，并在處理后發(fā)送給 Subscriber
本今。
如果你更喜歡具象思維拆座，可以看圖：
或者可以看動(dòng)圖：
兩次和多次的 lift()
同理，如下圖：
舉一個(gè)具體的 Operator
的實(shí)現(xiàn)冠息。下面這是一個(gè)將事件中的 Integer
對(duì)象轉(zhuǎn)換成 String
的例子挪凑，僅供參考：
observable.lift(
new Observable.Operator<String, Integer>() {
@Override
public Subscriber<? super Integer> call(
final Subscriber<? super String> subscriber) {
// 將事件序列中的 Integer 對(duì)象轉(zhuǎn)換為 String 對(duì)象
return new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) { subscriber.onNext("" + integer); }
@Override
public void onCompleted() {
subscriber.onCompleted(); }
@Override
public void onError(Throwable e) {
subscriber.onError(e); } }; }});
講述 lift()
的原理只是為了讓你更好地了解 RxJava ，從而可以更好地使用它逛艰。然而不管你是否理解了 lift()
的原理躏碳，RxJava 都不建議開(kāi)發(fā)者自定義 Operator
來(lái)直接使用 lift()
，而是建議盡量使用已有的 lift()
包裝方法（如 map()
flatMap()
等）進(jìn)行組合來(lái)實(shí)現(xiàn)需求散怖，因?yàn)橹苯邮褂?lift() 非常容易發(fā)生一些難以發(fā)現(xiàn)的錯(cuò)誤菇绵。
- compose: 對(duì) Observable 整體的變換
除了 lift()
之外肄渗， Observable
還有一個(gè)變換方法叫做 compose(Transformer)
。它和 lift()
的區(qū)別在于脸甘， lift()
是針對(duì)事件項(xiàng)和事件序列的，而 compose()
是針對(duì) Observable
自身進(jìn)行變換偏灿。舉個(gè)例子丹诀，假設(shè)在程序中有多個(gè) Observable
，并且他們都需要應(yīng)用一組相同的 lift()
變換翁垂。你可以這么寫(xiě)：
observable1 .lift1() .lift2() .lift3() .lift4() .subscribe(subscriber1);observable2 .lift1() .lift2() .lift3() .lift4() .subscribe(subscriber2);observable3 .lift1() .lift2() .lift3() .lift4() .subscribe(subscriber3);observable4 .lift1() .lift2() .lift3() .lift4() .subscribe(subscriber1);
你覺(jué)得這樣太不軟件工程了铆遭，于是你改成了這樣：
private Observable liftAll(Observable observable) { return observable .lift1() .lift2() .lift3() .lift4();}...liftAll(observable1).subscribe(subscriber1);liftAll(observable2).subscribe(subscriber2);liftAll(observable3).subscribe(subscriber3);liftAll(observable4).subscribe(subscriber4);
可讀性、可維護(hù)性都提高了沿猜∶度伲可是 Observable
被一個(gè)方法包起來(lái)，這種方式對(duì)于 Observale
的靈活性似乎還是增添了那么點(diǎn)限制啼肩。怎么辦橄妆？這個(gè)時(shí)候，就應(yīng)該用 compose()
來(lái)解決了：
public class LiftAllTransformer implements Observable.Transformer<Integer, String> {
@Override
public Observable<String> call(Observable<Integer> observable) {
return observable .lift1() .lift2() .lift3() .lift4(); }}...Transformer liftAll = new LiftAllTransformer();
observable1.compose(liftAll).subscribe(subscriber1);
observable2.compose(liftAll).subscribe(subscriber2);
observable3.compose(liftAll).subscribe(subscriber3);
observable4.compose(liftAll).subscribe(subscriber4);
像上面這樣祈坠，使用 compose()
方法害碾，Observable
可以利用傳入的 Transformer
對(duì)象的 call
方法直接對(duì)自身進(jìn)行處理，也就不必被包在方法的里面了赦拘。
compose()
的原理比較簡(jiǎn)單慌随，不附圖嘍。
- 線程控制：Scheduler (二)
除了靈活的變換躺同，RxJava 另一個(gè)牛逼的地方阁猜，就是線程的自由控制。
- Scheduler 的 API (二)
前面講到了蹋艺，可以利用 subscribeOn()
結(jié)合 observeOn()
來(lái)實(shí)現(xiàn)線程控制剃袍，讓事件的產(chǎn)生和消費(fèi)發(fā)生在不同的線程∩咏鳎可是在了解了 map()
flatMap()
等變換方法后笛园，有些好事的（其實(shí)就是當(dāng)初剛接觸 RxJava 時(shí)的我）就問(wèn)了：能不能多切換幾次線程？
答案是：能侍芝。因?yàn)?observeOn()
指定的是 Subscriber
的線程研铆，而這個(gè) Subscriber
并不是（嚴(yán)格說(shuō)應(yīng)該為『不一定是』，但這里不妨理解為『不是』）subscribe()
參數(shù)中的 Subscriber
州叠，而是 observeOn()
執(zhí)行時(shí)的當(dāng)前 Observable
所對(duì)應(yīng)的 Subscriber
棵红，即它的直接下級(jí) Subscriber
。換句話說(shuō)咧栗，observeOn()
指定的是它之后的操作所在的線程逆甜。因此如果有多次切換線程的需求虱肄，只要在每個(gè)想要切換線程的位置調(diào)用一次 observeOn()
即可。上代碼：
Observable.just(1, 2, 3, 4) // IO 線程交煞，由 subscribeOn() 指定 .subscribeOn(Schedulers.io()) .observeOn(Schedulers.newThread()) .map(mapOperator) // 新線程咏窿，由 observeOn() 指定 .observeOn(Schedulers.io()) .map(mapOperator2) // IO 線程，由 observeOn() 指定 .observeOn(AndroidSchedulers.mainThread) .subscribe(subscriber); // Android 主線程素征，由 observeOn() 指定
如上集嵌，通過(guò) observeOn()
的多次調(diào)用，程序?qū)崿F(xiàn)了線程的多次切換御毅。
不過(guò)根欧，不同于 observeOn()
， subscribeOn()
的位置放在哪里都可以端蛆，但它是只能調(diào)用一次的凤粗。
又有好事的（其實(shí)還是當(dāng)初的我）問(wèn)了：如果我非要調(diào)用多次 subscribeOn()
呢？會(huì)有什么效果今豆？
這個(gè)問(wèn)題先放著嫌拣，我們還是從 RxJava 線程控制的原理說(shuō)起吧。
- Scheduler 的原理（二）
其實(shí)呆躲， subscribeOn()
和 observeOn()
的內(nèi)部實(shí)現(xiàn)亭罪，也是用的 lift()
。具體看圖（不同顏色的箭頭表示不同的線程）：
subscribeOn()
原理圖：
observeOn()
原理圖：
從圖中可以看出歼秽，subscribeOn()
和 observeOn()
都做了線程切換的工作（圖中的 "schedule..." 部位）应役。不同的是， subscribeOn()
的線程切換發(fā)生在 OnSubscribe
中燥筷，即在它通知上一級(jí) OnSubscribe
時(shí)箩祥，這時(shí)事件還沒(méi)有開(kāi)始發(fā)送，因此 subscribeOn()
的線程控制可以從事件發(fā)出的開(kāi)端就造成影響肆氓；而 observeOn()
的線程切換則發(fā)生在它內(nèi)建的 Subscriber
中袍祖，即發(fā)生在它即將給下一級(jí) Subscriber
發(fā)送事件時(shí)，因此 observeOn()
控制的是它后面的線程谢揪。
最后蕉陋，我用一張圖來(lái)解釋當(dāng)多個(gè) subscribeOn()
和 observeOn()
混合使用時(shí)，線程調(diào)度是怎么發(fā)生的（由于圖中對(duì)象較多拨扶，相對(duì)于上面的圖對(duì)結(jié)構(gòu)做了一些簡(jiǎn)化調(diào)整）：
圖中共有 5 處含有對(duì)事件的操作凳鬓。由圖中可以看出，①和②兩處受第一個(gè) subscribeOn()
影響患民，運(yùn)行在紅色線程缩举；③和④處受第一個(gè)observeOn()
的影響，運(yùn)行在綠色線程；⑤處受第二個(gè) onserveOn()
影響仅孩，運(yùn)行在紫色線程托猩；而第二個(gè) subscribeOn()
，由于在通知過(guò)程中線程就被第一個(gè) subscribeOn()
截?cái)嗔赡剑虼藢?duì)整個(gè)流程并沒(méi)有任何影響京腥。這里也就回答了前面的問(wèn)題：當(dāng)使用了多個(gè) subscribeOn()
的時(shí)候，只有第一個(gè) subscribeOn()
起作用溅蛉。
- 延伸：doOnSubscribe()
然而公浪，雖然超過(guò)一個(gè)的 subscribeOn()
對(duì)事件處理的流程沒(méi)有影響，但在流程之前卻是可以利用的温艇。
在前面講 Subscriber
的時(shí)候因悲，提到過(guò) Subscriber
的 onStart()
可以用作流程開(kāi)始前的初始化堕汞。然而 onStart()
由于在 subscribe()
發(fā)生時(shí)就被調(diào)用了勺爱，因此不能指定線程，而是只能執(zhí)行在 subscribe()
被調(diào)用時(shí)的線程讯检。這就導(dǎo)致如果 onStart()
中含有對(duì)線程有要求的代碼（例如在界面上顯示一個(gè) ProgressBar琐鲁，這必須在主線程執(zhí)行），將會(huì)有線程非法的風(fēng)險(xiǎn)人灼，因?yàn)橛袝r(shí)你無(wú)法預(yù)測(cè) subscribe()
將會(huì)在什么線程執(zhí)行围段。
而與 Subscriber.onStart()
相對(duì)應(yīng)的，有一個(gè)方法 Observable.doOnSubscribe()
投放。它和 Subscriber.onStart()
同樣是在 subscribe()
調(diào)用后而且在事件發(fā)送前執(zhí)行奈泪，但區(qū)別在于它可以指定線程。默認(rèn)情況下灸芳， doOnSubscribe()
執(zhí)行在 subscribe()
發(fā)生的線程涝桅；而如果在 doOnSubscribe()
之后有 subscribeOn()
的話，它將執(zhí)行在離它最近的 subscribeOn()
所指定的線程烙样。
示例代碼：
Observable.create(onSubscribe) .subscribeOn(Schedulers.io()) .doOnSubscribe(new Action0() {
@Override public void call() {
progressBar.setVisibility(View.VISIBLE); // 需要在主線程執(zhí)行 } }) .subscribeOn(AndroidSchedulers.mainThread()) // 指定主線程 .observeOn(AndroidSchedulers.mainThread())
.subscribe(subscriber);
如上冯遂，在 doOnSubscribe()
的后面跟一個(gè) subscribeOn()
，就能指定準(zhǔn)備工作的線程了谒获。
RxJava 的適用場(chǎng)景和使用方式
- 與 Retrofit 的結(jié)合
Retrofit 是 Square 的一個(gè)著名的網(wǎng)絡(luò)請(qǐng)求庫(kù)蛤肌。沒(méi)有用過(guò) Retrofit 的可以選擇跳過(guò)這一小節(jié)也沒(méi)關(guān)系，我舉的每種場(chǎng)景都只是個(gè)例子批狱，而且例子之間并無(wú)前后關(guān)聯(lián)裸准，只是個(gè)拋磚引玉的作用，所以你跳過(guò)這里看別的場(chǎng)景也可以的赔硫。
Retrofit 除了提供了傳統(tǒng)的 Callback
形式的 API狼速，還有 RxJava 版本的 Observable
形式 API。下面我用對(duì)比的方式來(lái)介紹 Retrofit 的 RxJava 版 API 和傳統(tǒng)版本的區(qū)別。
以獲取一個(gè) User
對(duì)象的接口作為例子向胡。使用Retrofit 的傳統(tǒng) API恼蓬，你可以用這樣的方式來(lái)定義請(qǐng)求：
@GET("/user")public void getUser(@Query("userId") String userId, Callback<User> callback);
在程序的構(gòu)建過(guò)程中， Retrofit 會(huì)把自動(dòng)把方法實(shí)現(xiàn)并生成代碼僵芹，然后開(kāi)發(fā)者就可以利用下面的方法來(lái)獲取特定用戶并處理響應(yīng)：
getUser(userId, new Callback<User>() {
@Override
public void success(User user) {
userView.setUser(user); }
@Override
public void failure(RetrofitError error) {
// Error handling ... }};
而使用 RxJava 形式的 API处硬，定義同樣的請(qǐng)求是這樣的：
@GET("/user")public Observable<User> getUser(@Query("userId") String userId);
使用的時(shí)候是這樣的：
getUser(userId) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<User>() { @Override public void onNext(User user) {
userView.setUser(user); }
@Override
public void onCompleted() { }
@Override
public void onError(Throwable error) { // Error handling ... } });
看到區(qū)別了嗎？
當(dāng) RxJava 形式的時(shí)候拇派，Retrofit 把請(qǐng)求封裝進(jìn) Observable
荷辕，在請(qǐng)求結(jié)束后調(diào)用 onNext()
或在請(qǐng)求失敗后調(diào)用 onError()
。
對(duì)比來(lái)看件豌， Callback
形式和 Observable
形式長(zhǎng)得不太一樣疮方，但本質(zhì)都差不多，而且在細(xì)節(jié)上 Observable
形式似乎還比 Callback
形式要差點(diǎn)茧彤。那 Retrofit 為什么還要提供 RxJava 的支持呢骡显？
因?yàn)樗糜冒≡啵倪@個(gè)例子看不出來(lái)是因?yàn)檫@只是最簡(jiǎn)單的情況惫谤。而一旦情景復(fù)雜起來(lái)， Callback
形式馬上就會(huì)開(kāi)始讓人頭疼珠洗。比如：
假設(shè)這么一種情況：你的程序取到的 User
并不應(yīng)該直接顯示溜歪，而是需要先與數(shù)據(jù)庫(kù)中的數(shù)據(jù)進(jìn)行比對(duì)和修正后再顯示。使用 Callback
方式大概可以這么寫(xiě)：
getUser(userId, new Callback<User>() { @Override public void success(User user) { processUser(user); // 嘗試修正 User 數(shù)據(jù) userView.setUser(user); } @Override public void failure(RetrofitError error) { // Error handling ... }};
有問(wèn)題嗎许蓖？
很簡(jiǎn)便蝴猪，但不要這樣做。為什么膊爪？因?yàn)檫@樣做會(huì)影響性能自阱。數(shù)據(jù)庫(kù)的操作很重，一次讀寫(xiě)操作花費(fèi) 10~20ms 是很常見(jiàn)的蚁飒，這樣的耗時(shí)很容易造成界面的卡頓动壤。所以通常情況下，如果可以的話一定要避免在主線程中處理數(shù)據(jù)庫(kù)淮逻。所以為了提升性能琼懊，這段代碼可以優(yōu)化一下：
getUser(userId, new Callback<User>() {
@Override public void success(User user) { new Thread() {
@Override public void run() { processUser(user);
// 嘗試修正 User 數(shù)據(jù)
runOnUiThread(new Runnable() {
// 切回 UI 線程
@Override
public void run() { userView.setUser(user); } }); }).start(); }
@Override public void failure(RetrofitError error) { // Error handling ... }};
性能問(wèn)題解決，但……這代碼實(shí)在是太亂了爬早，迷之縮進(jìn)昂哒伞！雜亂的代碼往往不僅僅是美觀問(wèn)題筛严，因?yàn)榇a越亂往往就越難讀懂醉旦，而如果項(xiàng)目中充斥著雜亂的代碼，無(wú)疑會(huì)降低代碼的可讀性，造成團(tuán)隊(duì)開(kāi)發(fā)效率的降低和出錯(cuò)率的升高车胡。
這時(shí)候檬输，如果用 RxJava 的形式，就好辦多了匈棘。 RxJava 形式的代碼是這樣的：
getUser(userId) .doOnNext(new Action1<User>() {
@Override public void call(User user) { processUser(user); }) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<User>() {
@Override
public void onNext(User user) {
userView.setUser(user); }
@Override
public void onCompleted() { }
@Override
public void onError(Throwable error) {
// Error handling ... } });
后臺(tái)代碼和前臺(tái)代碼全都寫(xiě)在一條鏈中丧慈，明顯清晰了很多。
再舉一個(gè)例子：假設(shè) /user
接口并不能直接訪問(wèn)主卫，而需要填入一個(gè)在線獲取的 token
逃默，代碼應(yīng)該怎么寫(xiě)？
Callback
方式簇搅，可以使用嵌套的 Callback
：
@GET("/token")public void getToken(Callback<String> callback);
@GET("/user")public void getUser(@Query("token") String token, @Query("userId") String userId, Callback<User> callback);...getToken(new Callback<String>() {
@Override
public void success(String token) {
getUser(token, userId, new Callback<User>() {
@Override
public void success(User user) {
userView.setUser(user); }
@Override
public void failure(RetrofitError error) {
// Error handling ... } }; }
@Override
public void failure(RetrofitError error) { // Error handling ... }});
倒是沒(méi)有什么性能問(wèn)題完域，可是迷之縮進(jìn)毀一生，你懂我也懂瘩将，做過(guò)大項(xiàng)目的人應(yīng)該更懂吟税。
而使用 RxJava 的話，代碼是這樣的：
@GET("/token")public Observable<String> getToken();@GET("/user")public Observable<User> getUser(@Query("token") String token, @Query("userId") String userId);...getToken() .flatMap(new Func1<String, Observable<User>>() {
@Override
public Observable<User> onNext(String token) {
return getUser(token, userId); }) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<User>() {
@Override
public void onNext(User user) {
userView.setUser(user); }
@Override
public void onCompleted() { }
@Override
public void onError(Throwable error) { // Error handling ... } });
用一個(gè) flatMap()
就搞定了邏輯鸟蟹，依然是一條鏈乌妙∈雇茫看著就很爽建钥，是吧？
2016/03/31 更新虐沥，加上我寫(xiě)的一個(gè) Sample 項(xiàng)目： rengwuxian RxJava Samples
好熊经，Retrofit 部分就到這里。
- RxBinding
RxBinding 是 Jake Wharton 的一個(gè)開(kāi)源庫(kù)欲险，它提供了一套在 Android 平臺(tái)上的基于 RxJava 的 Binding API镐依。所謂 Binding，就是類似設(shè)置OnClickListener
天试、設(shè)置 TextWatcher
這樣的注冊(cè)綁定對(duì)象的 API槐壳。
舉個(gè)設(shè)置點(diǎn)擊監(jiān)聽(tīng)的例子。使用 RxBinding
喜每，可以把事件監(jiān)聽(tīng)用這樣的方法來(lái)設(shè)置：
Button button = ...;RxView.clickEvents(button) // 以 Observable 形式來(lái)反饋點(diǎn)擊事件 .subscribe(new Action1<ViewClickEvent>() {
@Override public void call(ViewClickEvent event) { // Click handling } });
看起來(lái)除了形式變了沒(méi)什么區(qū)別务唐，實(shí)質(zhì)上也是這樣。甚至如果你看一下它的源碼带兜，你會(huì)發(fā)現(xiàn)它連實(shí)現(xiàn)都沒(méi)什么驚喜：它的內(nèi)部是直接用一個(gè)包裹著的 setOnClickListener()
來(lái)實(shí)現(xiàn)的枫笛。然而，僅僅這一個(gè)形式的改變刚照，卻恰好就是 RxBinding
的目的：擴(kuò)展性刑巧。通過(guò) RxBinding
把點(diǎn)擊監(jiān)聽(tīng)轉(zhuǎn)換成 Observable
之后，就有了對(duì)它進(jìn)行擴(kuò)展的可能。擴(kuò)展的方式有很多啊楚，根據(jù)需求而定吠冤。一個(gè)例子是前面提到過(guò)的throttleFirst()
，用于去抖動(dòng)恭理，也就是消除手抖導(dǎo)致的快速連環(huán)點(diǎn)擊：
RxView.clickEvents(button) .throttleFirst(500, TimeUnit.MILLISECONDS) .subscribe(clickAction);
如果想對(duì) RxBinding
有更多了解咨演，可以去它的 GitHub 項(xiàng)目 下面看看。
- 各種異步操作
前面舉的 Retrofit
和 RxBinding
的例子蚯斯，是兩個(gè)可以提供現(xiàn)成的 Observable
的庫(kù)薄风。而如果你有某些異步操作無(wú)法用這些庫(kù)來(lái)自動(dòng)生成Observable
，也完全可以自己寫(xiě)拍嵌。例如數(shù)據(jù)庫(kù)的讀寫(xiě)遭赂、大圖片的載入、文件壓縮/解壓等各種需要放在后臺(tái)工作的耗時(shí)操作横辆，都可以用 RxJava 來(lái)實(shí)現(xiàn)撇他，有了之前幾章的例子，這里應(yīng)該不用再舉例了狈蚤。 - RxBus
RxBus 名字看起來(lái)像一個(gè)庫(kù)困肩，但它并不是一個(gè)庫(kù)，而是一種模式脆侮，它的思想是使用 RxJava 來(lái)實(shí)現(xiàn)了 EventBus 锌畸，而讓你不再需要使用Otto
或者 GreenRobot 的 EventBus
。至于什么是 RxBus靖避，可以看這篇文章潭枣。順便說(shuō)一句，F(xiàn)lipboard 已經(jīng)用 RxBus 替換掉了 Otto
幻捏，目前為止沒(méi)有不良反應(yīng)盆犁。
最后
對(duì)于 Android 開(kāi)發(fā)者來(lái)說(shuō)， RxJava 是一個(gè)很難上手的庫(kù)篡九，因?yàn)樗鼘?duì)于 Android 開(kāi)發(fā)者來(lái)說(shuō)有太多陌生的概念了谐岁。可是它真的很牛逼榛臼。因此伊佃，我寫(xiě)了這篇《給 Android 開(kāi)發(fā)者的 RxJava 詳解》，希望能給始終搞不明白什么是 RxJava 的人一些入門(mén)的指引讽坏，或者能讓正在使用 RxJava 但仍然心存疑惑的人看到一些更深入的解析锭魔。無(wú)論如何，只要能給各位同為 Android 工程師的你們提供一些幫助路呜，這篇文章的目的就達(dá)到了迷捧。
再次感謝對(duì)這篇文章的產(chǎn)出提供支持的各位： 技術(shù)支持：流火楓林 內(nèi)測(cè)讀者：代碼家织咧、鮑永章、drakeet漠秋、馬琳笙蒙、有時(shí)放縱、程序亦非猿庆锦、大頭鬼捅位、XZoomEye、席德雨搂抒、TCahead艇搀、Tiiime、Ailurus求晶、宅學(xué)長(zhǎng)焰雕、妖孽、大大大大大臣哥芳杏、NicodeLee 贊助方：周伯通招聘 是他們讓我的文章能夠以不那么丑陋的樣子出現(xiàn)在大家面前矩屁。
關(guān)于作者
朱凱（扔物線），Flipboard 北京 Android 工程師爵赵。
微博：扔物線
GitHub：rengwuxian
為什么寫(xiě)這個(gè)吝秕？
與兩三年前的境況不同，中國(guó)現(xiàn)在已經(jīng)不缺初級(jí) Android 工程師空幻，但中級(jí)和高級(jí)工程師嚴(yán)重供不應(yīng)求烁峭。因此我決定從今天開(kāi)始不定期地發(fā)布我的技術(shù)分享，只希望能夠和大家共同提升氛悬，通過(guò)我們的成長(zhǎng)來(lái)解決一點(diǎn)點(diǎn)國(guó)內(nèi)互聯(lián)網(wǎng)公司人才稀缺的困境则剃，也提升各位技術(shù)黨的收入耘柱。所以如捅，不僅要寫(xiě)這篇，我還會(huì)寫(xiě)更多调煎。至于內(nèi)容的定位镜遣，我計(jì)劃只定位真正的干貨，一些邊邊角角的小技巧和炫酷的黑科技應(yīng)該都不會(huì)寫(xiě)士袄，總之希望每篇文章都能幫讀者提升真正的實(shí)力悲关。
2016.04.10：聽(tīng)家家說(shuō)有人在評(píng)論里留言要給本文贊賞，我趕緊機(jī)智地提上褲子跑來(lái)貼上支付寶和微信的二維碼：
作者：扔物線
發(fā)布時(shí)間：2015-10-02 05:27
更新時(shí)間：2016-08-01 09:52
版權(quán)聲明：禁止任何形式的全文轉(zhuǎn)載娄柳，如需合作寓辱，請(qǐng)聯(lián)絡(luò)我
炮友跟帖：689人參與
喜歡妹子還是喜歡干貨？
快速登錄：
**發(fā)表跟貼
新來(lái)的炮友
被頂?shù)呐谟?/p>
○孤獨(dú)小P孩[干貨集中營(yíng)-上海市網(wǎng)友]1天前
RxJava2.0變動(dòng)還是挺多的
0
0
|分享
|回復(fù)
replyTpl" ne-data="1" style="margin: 0px; padding: 0px; width: auto;">
hanzhi911228[干貨集中營(yíng)-四川省成都市網(wǎng)友]2017-05-28 16:31:52
Scheduler(一)上方的一片代碼中赤拒，注釋有//指定 subscribe() 發(fā)生在 IO 線程 這句話應(yīng)該是‘指定Subscriber發(fā)生在IO線程中’吧秫筏？
0
0
|分享
|回復(fù)
replyTpl" ne-data="2" style="margin: 0px; padding: 0px; width: auto;">
有態(tài)度網(wǎng)友06Ph0j[干貨集中營(yíng)-上海市網(wǎng)友]2017-05-27 15:21:43
有態(tài)度網(wǎng)友06Ph0j[干貨集中營(yíng)-上海市網(wǎng)友]1
subscribe（）方法在API中的參數(shù)類型是Observer诱鞠，但在在變換-flatmap的例子中Observable.from(students).subscribe(subscriber)的參數(shù)類型是Subscriber,這個(gè)是不是錯(cuò)啦？
replyTpl" ne-data="3" style="margin: 0px; padding: 0px; width: auto;">
用的RxJava不一樣这敬，作者用的是rxjava1航夺，我用的是rxjava2
0
0
|分享
|回復(fù)
replyTpl" ne-data="4" style="margin: 0px; padding: 0px; width: auto;">
有態(tài)度網(wǎng)友06Pv7H[干貨集中營(yíng)-北京市網(wǎng)友]2017-05-26 15:57:31
看完之后對(duì)RxJava有了一定的了解,我決定更加深入的學(xué)習(xí)RxJava和Retrofit的結(jié)合使用,希望您多寫(xiě)好文,不知道您有沒(méi)有csdn的帳號(hào)啊,想多看看你的文章
2
0
|分享
|回復(fù)
replyTpl" ne-data="5" style="margin: 0px; padding: 0px; width: auto;">
115142415[干貨集中營(yíng)-北京市網(wǎng)友]2017-05-25 17:33:33
寫(xiě)的很深刻，good
0
0
|分享
|回復(fù)
replyTpl" ne-data="6" style="margin: 0px; padding: 0px; width: auto;">
有態(tài)度網(wǎng)友06OSxu[干貨集中營(yíng)-安徽省滁州市網(wǎng)友]2017-05-20 12:34:04
想了一夜才把lift原理弄懂
1
0
|分享
|回復(fù)
replyTpl" ne-data="7" style="margin: 0px; padding: 0px; width: auto;">
f6d9fcb0f1de268fed5e30d...[干貨集中營(yíng)-河北省保定市網(wǎng)友]2017-05-19 14:40:10
f6d9fcb0f1de268fed5e30d...[干貨集中營(yíng)-河北省保定市網(wǎng)友]1
“RxJava 遵循的是線程不變的原則崔涂，即：在哪個(gè)線程調(diào)用 subscribe()阳掐，就在哪個(gè)線程生產(chǎn)事件；在哪個(gè)線程生產(chǎn)事件冷蚂，就在哪個(gè)線程消費(fèi)事件”你用自己的代碼證明了缭保，分號(hào)后面的表述是錯(cuò)誤的：事件產(chǎn)生線程和事件消費(fèi)線程通過(guò)指定，可以不在一個(gè)線程蝙茶。
replyTpl" ne-data="8" style="margin: 0px; padding: 0px; width: auto;">
握草ｄ潭怼！尸闸！忘了看限定“在不指定線程的情況下”元扔，大哥，我錯(cuò)了座掘。我這回復(fù)能都給我刪了么......
4
0
|分享
|回復(fù)
replyTpl" ne-data="9" style="margin: 0px; padding: 0px; width: auto;">
丶彥九卿.[干貨集中營(yíng)-陜西省西安市網(wǎng)友]2017-05-18 15:52:55
可以說(shuō)這篇文章可以說(shuō)是RxJava相關(guān)的神作了
1
0
|分享
|回復(fù)
replyTpl" ne-data="10" style="margin: 0px; padding: 0px; width: auto;">
冬有白夜行[干貨集中營(yíng)-浙江省杭州市網(wǎng)友]2017-05-17 22:22:23
感謝作者说铃，之前看過(guò)兩遍，迷迷糊糊的宦芦，自己下去練習(xí)了一段時(shí)間宙址，再回來(lái)看一遍，很多之前不明白的地方豁然開(kāi)朗调卑。
0
0
|分享
|回復(fù)
replyTpl" ne-data="11" style="margin: 0px; padding: 0px; width: auto;">
有態(tài)度網(wǎng)友06uxc3[干貨集中營(yíng)-北京市網(wǎng)友]2017-05-17 17:14:54
相當(dāng)?shù)牟诲e(cuò) 是我看過(guò)的最適合初學(xué)者最容易看懂的RxJava文章
0
0
|分享
|回復(fù)
replyTpl" ne-data="12" style="margin: 0px; padding: 0px; width: auto;">
+加載更多跟貼
