9章 RxJava混合实战

最新推荐文章于 2023-07-02 13:36:15 发布
最新推荐文章于 2023-07-02 13:36:15 发布
阅读量168 收藏
点赞数
原文链接：https://juejin.im/post/5cd8e40fe51d456e8240dda3
版权

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

转载于:https://juejin.im/post/5cd8e40fe51d456e8240dda3

weixin_33851604
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Rxjava源码分析&实践（五）【实践环节：Rxjava整体框架的实现】
itbird的专栏
12-29 534
上一章节，我们从简单的Rxjava使用入手，深入学习探索了Rxjava原理，也知道了Rxjava最重要的几个功能，，接下来我们就一步一步的结合源码+实践，来实现这些核心功能。本节，我们一起来实现Rxjava的响应式编程的功能，其实就是借助观察者模式实现一对一的通知功能。老办法，在实现一个功能之前，那么我们先去基于自己已有的知识体系，去分解、猜想功能实现的原理，然后再一步一步的去实现它，过程中，对比Rxjava源码，可以进行一一比对，看自己想的，和框架本身有何异同。
RxJava实战读书笔记
10-11
RxJava实战的读书笔记 按照章节整理的核心知识点，便于自己理解和记忆
Rxjava具体方法详解
SingleShu的博客
02-07 2537
原文是简书一位猿友写的。写的很实在，不错，值得收藏。http://www.jianshu.com/p/64aa976a46be 想写好一篇文章确实不容易，感谢那些大牛们能够分享自己的所见所得。关于rxjava的原理以及观察者模式等理论性的内容我就不在这里献丑了，网上有很多很优秀的博客。回头我添加几篇到这里，大家可以看一看，这篇文章只是简单的通过例子告诉大家rxjava的基本使用方法，如果有任
RxJava 2.0 全体系梳理(持续更新ing)
化身孤岛的瓜
07-02 1513
只有观察者订阅了，才开始执行发射数据的代码。并且Cold Observable和Observer只能是一对一的关系。当有多个不同的订阅者时，消息是重新完整发送的，也就是说，对于Cold Observeable来说，有多个Observer存在的时候，各自的事件是独立的。多个订阅的sunbscribe（或者说观察者）事件各自独立。Hot Observable 无论有没有观察者订阅，事件始终都会发生。当Hot Observable有多个订阅者时，Hot Observable与订阅者们的关系是一对多的关系。
RxJava 实例
xiaowang_lj的博客
10-20 532
三种方式：Observable.create、Observable.just、Observable.fromArray@Override}});}使用observer或者subscriber@Override}@Override}@Override}@Override}};特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别。
RxJava2从入门到精通-进阶篇
11-08
适合所有初中级工程师，从RxJava的每个知识点进行讲解，并在每个知识点中都带有文字说明和代码例子说明。通过这次系统化的学习，您将可以完整的学习到RxJava家族的所有特性和常用的操作符，掌握操作符的使用，掌握RxJava与Rx其他第三方库的使用。可以用三句简单的话进行概括面试加分利器 = 加大录取机会加快工作效率 = 早点下班回家系统化的学习 = 能力全面提升
AndroidRxJava实战讲解：优雅实现网络请求轮询
02-25
1.Rxjava，由于其基于事件流的链式调用、逻辑简洁&使用简单的特点，深受各大Android开发者的欢迎。2.RxJava如此受欢迎的原因，在于其提供了丰富&功能强大的操作符，几乎能完成所有的功能需求3.今天，我将为大家带来...
RxJava 教程 PDF
02-14
RxJava 开发教程含相关简单例子
RxJava2配置及使用详解
08-30
主要介绍了RxJava2配置及使用详解,RxJava2.0是一个非常棒的流式编程,有兴趣的可以了解一下
Retrofit实战开发30讲
08-08
Retrofit和OkHttp一样都是Jake Wharton大神的杰作，他们都是网络通讯框架，只不过Retrofit是对OkHttp的进一步封装，使其调用更加简单方便，读书要读经典，学框架也要学经典，之所以能成为经典，因为它经受住了历史的考验，得到了人们的广泛认可，我们不但要学会用，还要学习它的工作原理，学习框架所体现出来的优秀的设计思想，设计原则，以及脱离框架类似功能的实现方法，本课程共分为六个章节，由易到难，循序渐进，所有的知识点都是自己在多年的Android实战开发中总结出来的精华，涉及到了Retrofit开发中的方方面面，从服务端搭建到客户端验证一整套流程演示给大家，避免了很多教程只讲客户端的使用不讲服务端搭建，要么使用公共的服务端api资源给大家演示，而导致对服务端的实现逻辑一无所知的尴尬，因为服务端和客户端这是一个完整的整体，他们是缺一不可的，这也是本教程的最大特色，希望大家能够喜欢。
超详细的Rxjava文档（包括Rxjava1,Rxjava2,中文官方文档，实战实例，博客详文等）
03-31
超详细的Rxjava文档（包括Rxjava1,Rxjava2,中文官方文档，实战实例，博客详文等多个pdf）
RxJava中文PDF文档
04-27
RxJava的官方文档翻译，这是PDF版本
RxJava与Retrofit结合使用案例
11-09
前段时间花了点时间学了一下RxJava和Retrofit2，后面在实践中被没有用到，今天一看，呃，都基本上忘掉了。 在这里总结记录一下。
Java 9 新特性概述
vincent_wen0766的博客
03-05 296
Java 9 正式发布于 2017 年 9 月 21 日。作为 Java8 之后 3 年半才发布的新版本，Java 9 带来了很多重大的变化。其中最重要的改动是 Java 平台模块系统的引入。除此之外，还有一些新的特性 Java 平台模块系统 Java 平台模块系统，也就是 Project Jigsaw，把模块化开发实践引入到了 Java 平台中。在引入了模块系统之后，JDK 被重新组织成 94 个模块。Java 应用可以通过新增的 jlink 工具，创建出只包含所依赖的 JDK 模块的自定义运行时
Android实战——RxJava2+Retrofit+RxBinding解锁各种新姿势
热门推荐
点击置顶文章查看博客目录（全站式导航）
04-03 1万+
RxJava2+Retrofit+RxBinding解锁各种新姿势 本篇文章内容包含以下内容 前言 RxJava2的基本介绍 RxJava2观察者模式的介绍 RxJava2观察者模式的使用 RxJava2的基本使用 模拟发送验证码 RxJava2与Retrofit的使用 模拟用户登陆获取用户数据 合并本地与服务器购物车列表 RxJava2与
Retrofit+Rxjava+Mvp实战
L_xiaole的博客
08-10 2914
很久没写博客了，这段时间项目刚上线，闲来无事正好把项目里面遇到的一些问题整理一下，做个笔记。 如题，这次我要说的是我的项目架构：Retrofit+Rxjava+Mvp，提到这三个关键词想必大家都不陌生，Retrofit是当下比较流行的网络请求库，它采用注解的形式简化了用户对网络请求的参数、类型、Url等信息的操作，现在已经发展到Retrofit2---Retrofit2详解 Rxjava就更不...
Elasticsearch初识与简单案例.pdf
04-29
Elasticsearch是一个基于Lucene的分布式全文搜索引擎，提供灵活且高效的搜索和分析功能。通过HTTP请求和客户端库，用户可以索引和搜索文档，执行复杂查询，进行数据分析，并享受高亮显示等特性。其高级功能如复合查询、聚合分析、滚动搜索等，使其适用于各种数据处理和分析场景。Elasticsearch还具有强大的监控和日志功能，确保集群稳定运行。总之，Elasticsearch是企业级搜索和分析的理想选择。
Python基于LSTM模型对全国的空气质量数据进行可视化分析预测源代码
最新发布
04-29
介绍 对全国2019年1月至2023年12月的空气质量数据进行分析，绘制时间序列图，展示每月/每季度的平均AQI变化趋势。绘制不同省份和城市的平均AQI热力图。分析不同污染物的浓度分布和趋势。绘制空气质量等级分布图。 需求说明 对空气质量数据进行数据分析，并使用LSTM模型进行预测。 安装教程 pip install jupyter pip install numpy pandas matplotlib seaborn 使用说明 在项目路径下打开终端输入jupyter notebook就行
android rxjava
11-11
Android中的RxJava是一个流行的响应式编程库，它使得异步数据流的处理变得更加简单和高效。RxJava基于观察者模式，可以轻松地处理异步操作、事件和数据流，提供了丰富的操作符和线程调度的支持，使得代码更加清晰和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值