本篇文章已授權微信公眾號 YYGeeker 獨家釋出轉載請標明出處
CSDN學院課程地址
- RxJava2從入門到精通-初級篇:edu.csdn.net/course/deta…
- RxJava2從入門到精通-中級篇:edu.csdn.net/course/deta…
- RxJava2從入門到精通-進階篇:edu.csdn.net/course/deta…
- RxJava2從入門到精通-原始碼分析篇:edu.csdn.net/course/deta…
9. RxJava混合開發
9.1 RxJava與Retrofit
新增Retrofit的依賴
//retrofit
implementation 'com.squareup.retrofit2:retrofit:2.2.0'
implementation 'com.squareup.retrofit2:converter-gson:2.2.0'
//rx+retrofit
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.2.0'
複製程式碼Retrofit是主流的網路框架，RxJava和Retrofit的使用已經成為主流的搭配，RxJava可以通過Retrofit在網路請求後，對網路請求的資料進行操作，也可以配合gson庫進行解析。
public interface ApiService {
@GET("/getUserInfo.php")
Observable<Main2Activity.UserInfo> getUserInfo(@Query("username") String username, @Query("password") String password);
@GET("/getVipInfo.php")
Observable<Main2Activity.VipInfo> getVipInfo(@Query("uid") String uid);
}
public void retrofit(View view) {
//構建Retrofit
apiService = new Retrofit.Builder()
.baseUrl("http://172.26.83.19/")
//rx與Gson混用
.addConverterFactory(GsonConverterFactory.create())
//rx與retrofit混用
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build()
.create(ApiService.class);
//構建RxJava
UserParam param = new UserParam("hensen", "123456");
//傳送param引數
Observable.just(param)
.flatMap(new Function<UserParam, ObservableSource<UserInfo>>() {
@Override
public ObservableSource<UserInfo> apply(@NonNull UserParam userParam) throws Exception {
return apiService.getUserInfo(userParam.param1, userParam.param2);
}
})
.flatMap(new Function<UserInfo, ObservableSource<VipInfo>>() {
@Override
public ObservableSource<VipInfo> apply(@NonNull UserInfo userInfo) throws Exception {
return apiService.getVipInfo(userInfo.uid);
}
})
.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<VipInfo>() {
@Override
public void accept(@NonNull VipInfo vipInfo) throws Exception {
textView.setText("會員等級：" + vipInfo.vipLevel + "--會員積分：" + vipInfo.vipScore);
}
});
}
class UserInfo {
public String success;
public String uid;
public String username;
public String password;
public String nikename;
}
class VipInfo {
public String success;
public String uid;
public String vipLevel;
public String vipScore;
}
class UserParam {
public String param1;
public String param2;
public UserParam(String param1, String param2) {
this.param1 = param1;
this.param2 = param2;
}
}
複製程式碼9.2 RxJava與RxBinding
新增RxBinding的依賴
implementation 'com.jakewharton.rxbinding2:rxbinding:2.1.1'
複製程式碼RxBinding是結合RxJava進行繫結View事件的輔助框架。這裡舉例繫結EditText文字變化的監聽事件，當EditText文字變化迅速時，我們不應當在每次變化的時候去訪問後臺請求，而是等到使用者敲完字之後停下來的半秒才去請求後臺
RxTextView.textChanges(editText)
//當你敲完字之後停下來的半秒就會執行下面語句
.debounce(500, TimeUnit.MILLISECONDS)
//下面這兩個都是資料轉換
//flatMap：當同時多個網路請求訪問的時候，前面的網路資料會覆蓋後面的網路資料
//switchMap：當同時多個網路請求訪問的時候，會以最後一個傳送請求為準，前面網路資料會被最後一個覆蓋
.switchMap(new Function<CharSequence, ObservableSource<List<String>>>() {
@Override
public ObservableSource<List<String>> apply(@NonNull CharSequence charSequence) throws Exception {
//網路操作，獲取我們需要的資料
List<String> list = new ArrayList<String>();
list.add("輸入文字變化時，請求網路次數："+ ++i);
return Observable.just(list);
}
})
//網路請求是在子執行緒的
.subscribeOn(Schedulers.io())
//介面更新在主執行緒
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<List<String>>() {
@Override
public void accept(@NonNull List<String> strings) throws Exception {
//介面更新
textView2.setText(strings.toString());
}
});
複製程式碼9.3 RxJava與RxLifecycle
新增RxLifecycle的依賴
//rxlifecycle
implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle:2.2.1'
複製程式碼RxLifecycle是結合RxJava繫結Activity或者Fragment的生命週期的輔助框架，可以幫助開發者在繫結的生命週期中自動釋放事件流，從而避免記憶體洩漏。這裡舉例繫結Activity的onPause事件，當點選按鈕時跳轉到另一個Activity時，onPause會被執行，則這個事件將會被釋放，介面將不會再更新對應的文案。RxLifeCycle的使用需要將Activity繼承自RxActivity或是RxFragment等，這些是由RxLifeCycle建立好的並監聽生命週期的元件。通過compose()實現生命週期的繫結
public void rxlifecycle() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
for (int j = 0; j < 20; j++) {
Thread.sleep(2000);
emitter.onNext("rxlifecycle " + j);
}
}
})
.compose(this.bindUntilEvent(ActivityEvent.PAUSE))
//網路請求是在子執行緒的
.subscribeOn(Schedulers.io())
//介面更新在主執行緒
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Object>() {
@Override
public void accept(@NonNull Object strings) throws Exception {
//介面更新
textView3.setText(strings.toString());
}
});
}
public void rxlifeCycle(View view) {
startActivity(new Intent(this, Main3Activity.class));
}
複製程式碼9.4 RxJava與Mvp
RxJava與Mvp是在Mvp架構模式下的P層進行資料的處理，其主要的核心思想還是Mvp，而RxJava在這裡只是在P層做資料的處理，並將處理完的資料在V層進行相對應的UI操作。這裡的Mvp採用當前專案實戰中的真實案例，開發者並不需要關心Mvp層之間的關係，因為這裡已經封裝好了對Mvp的關係繫結，而且對P層也封裝了相對應的生命週期回撥，M層的資料模型處理在這裡並沒有用到實體物件，所以被忽略使用
9.4.1 封裝基礎層
1、V層
只要實現V層的介面，就表示你是V層的一部分
public interface MvpView {
}
複製程式碼2、P層
P層持有V層的例項，且帶有一套P層自己的生命週期，具體是通過Activity生命週期進行回撥的
public abstract class MvpPresenter<T extends MvpView> {
public static final String TAG = "MvpPresenter";
public T mView;
public void attach(T view) {
mView = view;
}
/**
* 對應 activity/fragment onCreate
*/
protected void onCreate(Bundle savedInstanceState) {
Log.i(TAG, "onCreate");
}
/**
* 對應 activity/fragment onStart
*/
protected void onStart() {
Log.i(TAG, "onStart");
}
/**
* 對應 activity/fragment onResume
*/
protected void onResume() {
Log.i(TAG, "onResume");
}
/**
* 對應 activity/fragment onPause
*/
protected void onPause() {
Log.i(TAG, "onPause");
}
/**
* 對應 activity/fragment onStop
*/
protected void onStop() {
Log.i(TAG, "onStop");
}
/**
* 對應 activity/fragment onDestroy
*/
protected void onDestroy() {
Log.i(TAG, "onDestroy");
if (mView != null) {
mView = null;
}
}
}
複製程式碼3、封裝Activity層
Activity持有P層的例項，且回撥P層的生命週期，對外提供建立P層的抽象方法
public abstract class MvpActivity<P extends MvpPresenter> extends AppCompatActivity implements MvpView {
protected P presenter;
protected abstract P createPresenter();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_mvp);
presenter = createPresenter();
if (presenter != null) {
presenter.attach(this);
presenter.onCreate(savedInstanceState);
}
}
@Override
protected void onStart() {
super.onStart();
if (presenter != null) {
presenter.onStart();
}
}
@Override
protected void onResume() {
super.onResume();
if (presenter != null) {
presenter.onResume();
}
}
@Override
protected void onPause() {
super.onPause();
if (presenter != null) {
presenter.onPause();
}
}
@Override
protected void onStop() {
super.onStop();
if (presenter != null) {
presenter.onStop();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (presenter != null) {
presenter.onDestroy();
}
}
}
複製程式碼9.4.2 封裝抽象層
1、V層
V層只需要宣告出需要實現的方法
interface CustomView extends MvpView {
void onLoading(String text);
void onRefreshData(String text);
void onError(String text);
void onComplete(String text);
}
複製程式碼2、P層
P層只需要宣告出需要處理的方法
public abstract class CustomPresenter extends MvpPresenter<CustomView> {
public CustomPresenter() {
super();
}
abstract void loadData();
}
複製程式碼9.4.3 實現抽象層
1、Activity層
繼承封裝好的Activity，並實現抽象層的方法，在這裡做P層的建立和V層的處理
public class RealView extends MvpActivity<RealPresenter> implements CustomView {
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_real_view);
textView = findViewById(R.id.textView);
}
@Override
protected RealPresenter createPresenter() {
return new RealPresenter();
}
@Override
public void onLoading(String text) {
textView.append(text);
}
@Override
public void onRefreshData(String text) {
textView.append(text);
}
@Override
public void onError(String text) {
textView.append(text);
}
@Override
public void onComplete(String text) {
textView.append(text);
}
//按鈕點選事件
public void bt_get_data(View view) {
presenter.loadData();
}
}
複製程式碼2、P層
P層真正的使用RxJava進行資料的處理，並將處理後的資料在UI上更新
public class RealPresenter extends CustomPresenter {
@Override
void loadData() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("俊俊俊很帥");
e.onNext("你值得擁有");
e.onNext("取消關注");
e.onNext("但還是要保持微笑");
e.onComplete();
}
})
.subscribeOn(Schedulers.io())
//將觀察者切換到主執行緒 需要在Android環境下執行
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
mView.onLoading("正在載入中...... \n");
}
@Override
public void onNext(String s) {
try {
Thread.sleep(200); //模擬網路訪問
} catch (InterruptedException e) {
e.printStackTrace();
}
mView.onRefreshData("從網路上獲取資料：" + s + "\n");
}
@Override
public void onError(Throwable t) {
mView.onError(t.getMessage());
}
@Override
public void onComplete() {
mView.onComplete("載入完成...... \n");
}
}
);
}
}
複製程式碼9.5 小結
1、RxJava與Retrofit
由於每個人的專案中不一定有使用Retrofit，但是一定有RxJava，你可以通過對專案中的網路請求進行RxJava上的封裝，也能達到和RxJava與Retrofit同樣的效果，我司就是這麼做的
2、RxJava與RxBinding
RxBinding簡化了我們與View的繫結事件，從RxBinding的RxView原始碼中，不難發現其實現的原理就是自定義操作符，可以翻翻RxView的原始碼，模仿自定義操作符的程式碼，在自己的專案中去發揮你的想象力，相信在後面的開發，你也能自定義出一套自己的框架
3、RxJava與RxLifecycle
RxLifecycle簡化了我們對Android生命週期的處理，但是比較可惜的是需要繼承自RxLifecycle提供的RxActivity或RxFragment等，很多專案都是以前的，並沒有這個前提，那麼可以選擇重構RxActivity，或者在原先的Activity中監聽生命週期方法，通過回撥來管理RxJava的釋放工作
4、RxJava與Mvp
RxJava在Mvp的模式的使用下，作用顯得更加客觀，因為在P層需要對M層和V層進行處理，不僅要從工作執行緒去獲取M層的資料，還要在UI執行緒中對V層進行更新，在RxJava中的處理顯得遊刃有餘