9章 RxJava混合实战

本篇文章已授权微信公众号 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中的处理显得游刃有余

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,378评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,356评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,702评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,259评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,263评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,036评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,349评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,979评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,469评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,938评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,059评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,703评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,257评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,262评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,485评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,501评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,792评论 2赞 345

推荐阅读更多精彩内容

  • 2019-04-02 - 草稿
    材料名称:《关于财富与影响力的戳心建议》 标题: 狗头军师的王者荣耀之路 字数: 正文: 001 找到自己的细分...
    莫不静好_e0f4阅读 150评论 0赞 2
  • 感恩转角的遇见
    人生过往就像经历一个个转角，走着走着渐渐的走到终点，给整个一生画上句号。遇见便是经常的事情。偶尔会遇见糟心的事情，...
    田浅言阅读 353评论 2赞 2
  • 春
    煦日暖暖，漫步在鸭绿江畔，看着江鸥与野鸭嬉戏于退了潮的江水边，一切都是温馨的。 春天来了，万物复苏。
    紫妞阅读 185评论 0赞 0
  • 美丽的小区
    在我这里有一个美丽的小区，我拍下了一些照片，我来给大家看看。 这个小区你们有可能不会认为很美丽，但是意识到了就好，...
    云上小树阅读 180评论 0赞 1