9章 RxJava混合實戰

Hensen發表於2019-05-13

本篇文章已授權微信公眾號 YYGeeker 獨家釋出轉載請標明出處

CSDN學院課程地址

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中的處理顯得遊刃有餘

相關文章