9章 RxJava混合实战-白红宇

本篇文章已授权微信公众号 YYGeeker 独家发布转载请标明出处

CSDN学院课程地址

RxJava2从入门到精通-初级篇:

RxJava2从入门到精通-中级篇:

RxJava2从入门到精通-进阶篇:

RxJava2从入门到精通-源码分析篇:

9. RxJava混合开发

9.1 RxJava与Retrofit

添加Retrofit的依赖

//retrofitimplementation 'com.squareup.retrofit2:retrofit:2.2.0'implementation 'com.squareup.retrofit2:converter-gson:2.2.0'//rx+retrofitimplementation 'com.squareup.retrofit2:adapter-rxjava2:2.2.0'复制代码

Retrofit是主流的网络框架，RxJava和Retrofit的使用已经成为主流的搭配，RxJava可以通过Retrofit在网络请求后，对网络请求的数据进行操作，也可以配合gson库进行解析。

public interface ApiService {    @GET("/getUserInfo.php")    Observable
    
      getUserInfo(@Query("username") String username, @Query("password") String password);    @GET("/getVipInfo.php")    Observable
     
       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
      
       >() {                @Override                public ObservableSource
       
         apply(@NonNull UserParam userParam) throws Exception {                    return apiService.getUserInfo(userParam.param1, userParam.param2);                }            })            .flatMap(new Function
        
         >() {                @Override                public ObservableSource
         
           apply(@NonNull UserInfo userInfo) throws Exception { return apiService.getVipInfo(userInfo.uid); } }) .subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()) .subscribe(new Consumer
          
           () { @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
    
     >>() {            @Override            public ObservableSource
     
      
       > apply(@NonNull CharSequence charSequence) throws Exception {                //网络操作，获取我们需要的数据                List
       
         list = new ArrayList
        
         ();                list.add("输入文本变化时，请求网络次数："+ ++i);                return Observable.just(list);            }        })        //网络请求是在子线程的        .subscribeOn(Schedulers.io())        //界面更新在主线程        .observeOn(AndroidSchedulers.mainThread())        .subscribe(new Consumer
         
          
           >() { @Override public void accept(@NonNull List
           
             strings) throws Exception { //界面更新 textView2.setText(strings.toString()); } });复制代码

9.3 RxJava与RxLifecycle

添加RxLifecycle的依赖

//rxlifecycleimplementation '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
    
     () {        @Override        public void subscribe(ObservableEmitter
     
       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

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
    
      {    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 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
    
      {    public CustomPresenter() {        super();    }    abstract void loadData();}复制代码

9.4.3 实现抽象层

1、Activity层

继承封装好的Activity，并实现抽象层的方法，在这里做P层的创建和V层的处理

public class RealView extends MvpActivity
    
      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
    
     () {            @Override            public void subscribe(ObservableEmitter
     
       e) throws Exception {                e.onNext("俊俊俊很帅");                e.onNext("你值得拥有");                e.onNext("取消关注");                e.onNext("但还是要保持微笑");                e.onComplete();            }        })                .subscribeOn(Schedulers.io())                //将观察者切换到主线程  需要在Android环境下运行                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Observer
      
       () {                               @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中的处理显得游刃有余