RxJava 到底是什么？
異步徘层。
RxJava 的好處？
簡潔行您。隨著程序邏輯越來越復(fù)雜她倘，它依然保持簡潔。
進(jìn)入主題
基本實(shí)現(xiàn)
- 創(chuàng)建Observer
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!");
}
};
例子：
由指定的一個(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();
}
});
2).創(chuàng)建Observable
RxJava 使用 create() 方法來創(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)了由被觀察者向觀察者的事件傳遞摇零，即觀察者模式
RxJava 還提供了一些方法用來快捷創(chuàng)建事件隊(duì)列，例如：
1桶蝎、 ————just(T...): 將傳入的參數(shù)依次發(fā)送出來驻仅。
Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 將會(huì)依次調(diào)用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();
2、————from(T[]) / from(Iterable<? extends T>) : 將傳入的數(shù)組或 Iterable 拆分成具體對(duì)象后登渣，依次發(fā)送出來
String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 將會(huì)依次調(diào)用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();
3).Subscribe (訂閱)
建了 Observable 和 Observer 之后噪服，再用 subscribe() 方法將它們聯(lián)結(jié)起來，整條鏈子就可以工作了
observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);
Observable.subscribe(Subscriber) 的內(nèi)部實(shí)現(xiàn)是這樣的（僅核心代碼）：
public Subscription subscribe(Subscriber subscriber) {
subscriber.onStart();
onSubscribe.call(subscriber);
return subscriber;
}
可以看到胜茧，subscriber() 做了3件事：
1): 調(diào)用 Subscriber.onStart() 粘优。這個(gè)方法在前面已經(jīng)介紹過，是一個(gè)可選的準(zhǔn)備方法。
2): 調(diào)用 Observable 中的 OnSubscribe.call(Subscriber) 敬飒。在這里邪铲，事件發(fā)送的邏輯開始運(yùn)行。從這也可以看出无拗，在 RxJava 中带到， Observable 并不是在創(chuàng)建的時(shí)候就立即開始發(fā)送事件，而是在它被訂閱的時(shí)候英染，即當(dāng) subscribe() 方法執(zhí)行的時(shí)候揽惹。 (訂閱的時(shí)候才開始發(fā)送事件)。
3): 將傳入的 Subscriber 作為 Subscription 返回四康。這是為了方便 unsubscribe().
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 來定義 onNext()
observable.subscribe(onNextAction);
// 自動(dòng)創(chuàng)建 Subscriber 疯溺，并使用 onNextAction 和 onErrorAction 來定義 onNext() 和 onError()
observable.subscribe(onNextAction, onErrorAction);
// 自動(dòng)創(chuàng)建 Subscriber ，并使用 onNextAction哎垦、 onErrorAction 和 onCompletedAction 來定義 onNext()囱嫩、 onError() 和 onCompleted()
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
Observer 和 Subscriber 具有相同的角色，而且 Observer 在 subscribe() 過程中最終會(huì)被轉(zhuǎn)換成 Subscriber 對(duì)象
Action0 是 RxJava 的一個(gè)接口漏设，它只有一個(gè)方法 call()墨闲，這個(gè)方法是無參無返回值的；由于 onCompleted() 方法也是無參無返回值的郑口，因此 Action0 可以被當(dāng)成一個(gè)包裝對(duì)象鸳碧，將 onCompleted() 的內(nèi)容打包起來將自己作為一個(gè)參數(shù)傳入 subscribe() 以實(shí)現(xiàn)不完整定義的回調(diào)，這樣其實(shí)也可以看做將 onCompleted() 方法作為參數(shù)傳進(jìn)了 subscribe()
Action1 也是一個(gè)接口犬性，它同樣只有一個(gè)方法 call(T param)瞻离，這個(gè)方法也無返回值，但有一個(gè)參數(shù)乒裆；與 Action0 同理琐脏，由于 onNext(T obj) 和 onError(Throwable error) 也是單參數(shù)無返回值的，因此 Action1 可以將 onNext(obj) 和 onError(error) 打包起來傳入 subscribe() 以實(shí)現(xiàn)不完整定義的回調(diào)
例子：
將字符串?dāng)?shù)組 names 中的所有字符串依次打印出來：
String[] names = ...;
Observable.from(names)
.subscribe(new Action1<String>() {
@Override
public void call(String name) {
Log.d(tag, name);
}
});
分水嶺
- 在 RxJava 的默認(rèn)規(guī)則中缸兔，事件的發(fā)出和消費(fèi)都是在同一個(gè)線程的日裙。 觀察者模式本身的目的就是『后臺(tái)處理，前臺(tái)回調(diào)』的異步機(jī)制惰蜜，因此昂拂，則需要用到 RxJava 的另一個(gè)概念： Scheduler ，來實(shí)現(xiàn)異步抛猖。
- 在不指定線程的情況下格侯， RxJava 遵循的是線程不變的原則鼻听，即：在哪個(gè)線程調(diào)用 subscribe()，就在哪個(gè)線程生產(chǎn)事件联四；在哪個(gè)線程生產(chǎn)事件撑碴，就在哪個(gè)線程消費(fèi)事件。
Scheduler
Scheduler （線程控制）
RxJava 已經(jīng)內(nèi)置了幾個(gè) Scheduler：
Schedulers.immediate() 默認(rèn)的朝墩，直接在當(dāng)前線程運(yùn)行醉拓。
Schedulers.newThread() 啟用新線程，在新線程工作收苏。
Schedulers.io() I/O操作（讀寫文件亿卤，讀寫數(shù)據(jù)庫，網(wǎng)絡(luò)信息交互等）鹿霸、和newThread（）最大的區(qū)別是：io() 的內(nèi)部實(shí)現(xiàn)是一個(gè)無數(shù)量上限的線程池排吴，可以重用空閑的線程。
AndroidSchedulers.mainThread() Android專用的懦鼠，指定的操作在Android的主線程運(yùn)行钻哩。
使用方法：
subscribeOn() 指定subscribe() 所發(fā)生的線程，即 Observable.OnSubcribe 被激活時(shí)所處的線程肛冶，或者叫事件產(chǎn)生的線程街氢。
observerOn() 指定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() 之前寫上兩句subscribeOn(Scheduler.io()) 和observeOn(AndroidSchedulers.mainThread()) 的使用方式非常常見虱颗，它適用于多數(shù)的 『后臺(tái)線程取數(shù)據(jù)沥匈，主線程顯示』的程序策略。
再看下面這個(gè)：
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(Schedulers.io()) // 指定 subscribe() 發(fā)生在 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è)定在了主線程。
理解記憶過程
observerOn() 指定的是觀察者（警察）的線程
subscribeOn() 指定的是被觀察者（小偷）的線程
比如上面的加載圖片的例子畦粮，在創(chuàng)建警察的時(shí)候散址，newObserver<Drawable>()乖阵，就定義好了，警察該干的事预麸，就是setImageDrawable(drawable)瞪浸，設(shè)置圖片，所以上述例子就是吏祸，指定了警察在主線程設(shè)置圖片对蒲。而，在定義小偷的時(shí)候犁罩，Observable.create齐蔽，就定了小偷會(huì)干什么事，就是獲得加載圖片的資源床估，那么上訴例子就是含滴，指定了小偷在IO線程，加載圖片.
這樣丐巫，一抽像一下理解谈况，就加深理解多了。
變換
所謂變換递胧，就是將事件序列中的對(duì)象或整個(gè)序列進(jìn)行加工處理碑韵，轉(zhuǎn)換成不同的事件或事件序列
map
例子1
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);
}
});
Func1,它和 Action1 非常相似，也是 RxJava 的一個(gè)接口缎脾，用于包裝含有一個(gè)參數(shù)的方法祝闻。 Func1 和 Action 的區(qū)別在于， Func1 包裝的是有返回值的方法遗菠。
可以看到联喘，map() 方法將參數(shù)中的 String 對(duì)象轉(zhuǎn)換成一個(gè) Bitmap 對(duì)象后返回，而在經(jīng)過 map() 方法后辙纬，事件的參數(shù)類型也由 String 轉(zhuǎn)為了 Bitmap豁遭。
它不僅可以針對(duì)事件對(duì)象，還可以針對(duì)整個(gè)事件隊(duì)列贺拣。
flatMap
首先假設(shè)這么一種需求：假設(shè)有一個(gè)數(shù)據(jù)結(jié)構(gòu)『學(xué)生』蓖谢，現(xiàn)在需要打印出一組學(xué)生的名字。實(shí)現(xiàn)方式很簡單
private Students s1 = new Students("趙日天");
private Students s2 = new Students("陳鐵柱");
private Students s3 = new Students("王尼瑪");
private ArrayList<Students> list = new ArrayList<MainActivity.Students>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
list.add(s1);
list.add(s2);
list.add(s3);
Observable.from(list).map(new Func1<Students, String>() {
@Override
public String call(Students stu) {
// TODO Auto-generated method stub
return stu.getName();
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println("Students name is :" + s);
}
});
}
class Students {
private String name;
public Students(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
運(yùn)行結(jié)果：
那么再假設(shè)：如果要打印出每個(gè)學(xué)生所需要修的所有課程的名稱呢譬涡？（需求的區(qū)別在于闪幽，每個(gè)學(xué)生只有一個(gè)名字，但卻有多個(gè)課程涡匀。）首先可以這樣實(shí)現(xiàn)
private List<Course> courseList = new ArrayList<MainActivity.Course>();
private Course c1 = new Course("紅Buff");
private Course c2 = new Course("藍(lán)Buff");
private Course c3 = new Course("火龍");
private Students s1;
private Students s2;
private Students s3;
private ArrayList<Students> list = new ArrayList<MainActivity.Students>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
courseList.add(c1);
courseList.add(c2);
courseList.add(c3);
s1 = new Students("趙日天", courseList);
s2 = new Students("陳鐵柱", courseList);
s3 = new Students("王尼瑪", courseList);
list.add(s1);
list.add(s2);
list.add(s3);
Observable.from(list).subscribe(new Subscriber<Students>() {
@Override
public void onCompleted() {
// TODO Auto-generated method stub
}
@Override
public void onError(Throwable arg0) {
// TODO Auto-generated method stub
}
@Override
public void onNext(Students student) {
// TODO Auto-generated method stub
List<Course> courses = student.getCourseList();
for (int i = 0; i < courses.size(); i++) {
Course course = courses.get(i);
System.out.println("Student " + student.getName()
+ "Course name is :" + course.getcourseName());
}
}
});
}
// 模擬學(xué)生結(jié)構(gòu)
class Students {
private String name;
private List<Course> courseList;
public Students(String name, List<Course> courseList) {
this.name = name;
this.courseList = courseList;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Course> getCourseList() {
return courseList;
}
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
}
// 模擬課程數(shù)據(jù)結(jié)構(gòu)
class Course {
private String courseName;
public Course(String courseName) {
this.courseName = courseName;
}
public String getcourseName() {
return courseName;
}
public void setcourseName(String name) {
this.courseName = name;
}
}
運(yùn)行結(jié)果：
代碼很簡單沟使。但是，如果不想在 Subscriber 中使用 for 循環(huán)呢渊跋，而是希望 Subscriber 中直接傳入單個(gè)的 Course 對(duì)象呢腊嗡？因?yàn)閙ap() 是一對(duì)一的轉(zhuǎn)化着倾，而現(xiàn)在的要求是一對(duì)多的轉(zhuǎn)化。那怎么才能把一個(gè) Student 轉(zhuǎn)化成多個(gè) Course 呢燕少？
這個(gè)時(shí)候卡者，就需要用 flatMap() 了
flatMap
private List<Course> courseList = new ArrayList<MainActivity.Course>();
private Course c1 = new Course("紅Buff");
private Course c2 = new Course("藍(lán)Buff");
private Course c3 = new Course("火龍");
private Students s1;
private Students s2;
private Students s3;
private ArrayList<Students> list = new ArrayList<MainActivity.Students>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
courseList.add(c1);
courseList.add(c2);
courseList.add(c3);
s1 = new Students("趙日天", courseList);
s2 = new Students("陳鐵柱", courseList);
s3 = new Students("王尼瑪", courseList);
list.add(s1);
list.add(s2);
list.add(s3);
Observable.from(list)
.flatMap(new Func1<Students, Observable<Course>>() {
@Override
public Observable<Course> call(Students stu) {
// TODO Auto-generated method stub
System.out.println("學(xué)生" + stu.getName() + "的課程如下：");
return Observable.from(stu.getCourseList());
}
}).subscribe(new Action1<Course>() {
@Override
public void call(Course cou) {
System.out.println(cou.getcourseName());
}
});
}
// 模擬學(xué)生結(jié)構(gòu)
class Students {
private String name;
private List<Course> courseList;
public Students(String name, List<Course> courseList) {
this.name = name;
this.courseList = courseList;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Course> getCourseList() {
return courseList;
}
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
}
// 模擬課程數(shù)據(jù)結(jié)構(gòu)
class Course {
private String courseName;
public Course(String courseName) {
this.courseName = courseName;
}
public String getcourseName() {
return courseName;
}
public void setcourseName(String name) {
this.courseName = name;
}
}
運(yùn)行結(jié)果：
可以看出， flatMap() 和 map() 有一個(gè)相同點(diǎn)：它也是把傳入的參數(shù)轉(zhuǎn)化之后返回另一個(gè)對(duì)象客们。但需要注意崇决，和 map() 不同的是， flatMap() 中返回的是個(gè) Observable 對(duì)象底挫，并且這個(gè) Observable 對(duì)象并不是被直接發(fā)送到了 Subscriber 的回調(diào)方法中恒傻。
flatMap() 的原理
- 使用傳入的事件對(duì)象創(chuàng)建一個(gè) Observable 對(duì)象；
- 并不發(fā)送這個(gè) Observable, 而是將它激活建邓，于是它開始發(fā)送事件盈厘；
- 每一個(gè)創(chuàng)建出來的 Observable 發(fā)送的事件，都被匯入同一個(gè) Observable,而這個(gè) Observable 負(fù)責(zé)將這些事件統(tǒng)一交給 Subscriber 的回調(diào)方法官边。
個(gè)人理解
特工（被觀察者）的能力是給他傳入一堆學(xué)生沸手，他先自己查到這個(gè)學(xué)生的全部課程，由于每個(gè)學(xué)生的課程都很多注簿，所以不能直接讓監(jiān)視他的上級(jí)知道契吉，他自己有一個(gè)情報(bào)小組，把課程給到情報(bào)小組诡渴，然后整理好情報(bào)捐晶，最后由情報(bào)小組統(tǒng)一再給到時(shí)刻關(guān)注監(jiān)視他的上級(jí)（觀察者）。在該事件中妄辩，特工把事件拆成了兩級(jí)惑灵，通過一組新創(chuàng)建的 Observable 將初始的對(duì)象『鋪平』之后通過統(tǒng)一路徑分發(fā)了下去。也就是恩袱，把每一個(gè)學(xué)生的每一項(xiàng)課程泣棋，鋪平后胶哲，按順序的列好告訴上級(jí)畔塔。
說點(diǎn)什么吧
終于到這了，說句實(shí)話鸯屿，扔物線的那篇文章是真的棒澈吨，我看了三遍才能看得懂，第一遍看的時(shí)候寄摆，整個(gè)人都是懵逼狀態(tài)的谅辣，天啊，這什么啊
可是婶恼，必須硬著頭皮看下去啊桑阶，看第二遍的時(shí)候柏副，就感覺很舒服了，看到運(yùn)行結(jié)果的時(shí)候蚣录，真的棒棒大割择。(⊙o⊙)…
看完這個(gè)，結(jié)合了基于Retrofit/RxJava/mvp+..來一發(fā)Demo先：
https://github.com/GitHuborz/MvpDemo-RetrofitRxJvaDemo
該工程包括 ：
1萎河、MvpDemo （一個(gè)簡單的MVP架構(gòu)的demo）
2荔泳、RetrofitRxJavaDemo (一個(gè)使用RxJava + Retrofit 的小demo)
MVP是看鴻洋大大的這個(gè)，理解造輪子的虐杯。 ：http://blog.csdn.net/lmj623565791/article/details/46596109
至于RxJava 和 Retrofit 玛歌，看的是拋物線的文章，還有別的一些擎椰。這里有Fork了一個(gè)挺好的搜集支子，不過，個(gè)人認(rèn)為确憨，有很多選擇看就好了译荞，有些不一定好。 ：https://github.com/GitHuborz/Awesome-RxJava
最近的計(jì)劃是休弃，學(xué)完這些后吞歼，寫一個(gè)用Gank.io的接口，基于 RxJava+Retrofit+MVP+OkHttp塔猾，當(dāng)然也要使用時(shí)下流行許久了的Rv+MD等等的一個(gè)妹子APP篙骡。（哈哈）
總之，一步一步實(shí)現(xiàn)吧丈甸，Go~
想看妹子糯俗，請(qǐng)看下回分解~
