RxJava RxAndroid 入门使用用法 参照博文自己领悟使用解析

最新推荐文章于 2024-02-21 12:57:19 发布
最新推荐文章于 2024-02-21 12:57:19 发布
阅读量1.1k 收藏
点赞数
分类专栏： android Android 架构
本文为博主原创文章，未经博主允许不得转载。安卓五千源码下载--https://blog.csdn.net/wuqilianga/article/details/89185887
本文链接：https://blog.csdn.net/wuqilianga/article/details/62423661
版权


原创：转载请注明出处！！http://blog.csdn.net/wuqilianga/article/details/62423661


首先


RxJava 个人觉得太过于抽象了，不去多操练，多使用，多摸索，多巩固是学会了就忘，一看还是不懂，再看懵懂的感觉

这个是个好东西，能简化代码，加快编程提交代码的进度，也能很好地理解响应性编程的好处


首先这个东西我个人理解的方式是这样


由 两个东西  +  一个关系组成

第一个东西：发送端

第二个东西：接收端

一个关系 ： 订阅关系


其中

发送端（Observable） --  发送前执行器（doOnSubscribe） --  发送器（just、from、OnSubscribe....） 

   -- 作用环境（subscribeOn【指定发送器作用环境】；observeOn【指定下一个接收器作用环境】）


发送的途中  --  转换发送端(lift / compose) --转换分解发送数据(map,flatMap)---转换分解集体发送端()  --    作用环境(同发送端一样)


接收端（Subscriber）---接收器 （onNext/onError/onComplete/call.......） --    作用环境(同发送端一样)


下边是学习操作参考例子：

package com.xxx.swiperefreshlayoutdemo.rxjava;

import com.xxx.swiperefreshlayoutdemo.okhttp_gson_pager.Okhttp_Gson_Pager_Data;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Observable.Operator;
import rx.Scheduler;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
 * Created by xxx on 2017/3/15.
 */

public class RxJavaMain {

    private static  String TAG = RxJavaMain.class.getSimpleName();

    private static void method1() {
        //这是发送端
        Observable<Okhttp_Gson_Pager_Data> mOb = Observable.create(
                //发送器
                new OnSubscribe<Okhttp_Gson_Pager_Data>(){
            @Override
            public void call(Subscriber<? super Okhttp_Gson_Pager_Data> subscriber) {
                subscriber.onNext(getData());
                subscriber.onCompleted();
            }
        });

        //这是接收端
        Subscriber<Okhttp_Gson_Pager_Data> mSb = new Subscriber<Okhttp_Gson_Pager_Data>() {
            //接收器
            @Override
            public void onCompleted() {
                System.out.println("hello 我是er结尾的接收端onCompleted方法！");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("hello 我是er结尾的接收端onError方法！");
            }

            @Override
            public void onNext(Okhttp_Gson_Pager_Data obj) {
                System.out.println("hello 我是er结尾的接收端onNext方法！" + " 发送端发送的数据：" + obj.getError().getErr_code());
            }
        };

        //建立联系
        mOb.subscribe(mSb);
    }

    private static Okhttp_Gson_Pager_Data getData(){
        Okhttp_Gson_Pager_Data obj = new Okhttp_Gson_Pager_Data();
        Okhttp_Gson_Pager_Data.ErrorBean err = new Okhttp_Gson_Pager_Data.ErrorBean();
        err.setErr_code(10001);
        obj.setError(err);
        //errorInfoSend ();
        return obj;
    }

    private static void errorInfoSend (){
        int i = 0;
        i /= i;
    }

    private static void method2() {
        //这是发送端
        Observable<Okhttp_Gson_Pager_Data> mOb = Observable.just(getData());

        //这是接收端
        Action1<Okhttp_Gson_Pager_Data> onNextAction = new Action1<Okhttp_Gson_Pager_Data>() {
            @Override
            public void call(Okhttp_Gson_Pager_Data obj) {
                System.out.println("hello 我是Action1的接收端call方法！" + " 发送端发送的数据：" + obj.getError().getErr_code());
            }
        };
        Action1<Throwable> onErrorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable e) {
                System.out.println("Action1<Throwable> onErrorAction --call(Throwable e) ：");
                e.printStackTrace();
            }
        };
        Action0 onCompleteAction = new Action0() {
            @Override
            public void call() {
                System.out.println("Action0 onCompleteAction --  call() ：");
            }
        };

        //建立联系
        mOb.subscribe(onNextAction,onErrorAction,onCompleteAction);
    }

    private static void method3() {
        //发送端
        Observable
                //发送数据
                .just(getData())
                //map是个输出类型转换函数
                .map(new Func1<Okhttp_Gson_Pager_Data, Integer>() {
                    @Override
                    public Integer call(Okhttp_Gson_Pager_Data okhttp_gson_pager_data) {
                        return okhttp_gson_pager_data.getError().getErr_code();
                    }
                })
                //map是个输出类型转换函数
                .map(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return integer + "";
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.println("hello 我是Action1的接收端call方法！" + " 发送端发送的数据：" + s);
                    }
                });
    }

    /**lift 方法复杂版*/
    private static void method4(){
        //发送器
        OnSubscribe mObOnSub = new OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello！-- Observable.OnSubscribe mObOnSub = new Observable.OnSubscribe<String>--");
            }
        };

        //原始发送端
        Observable<String> originObservable =  Observable.create(mObOnSub);

        Operator operator = new Operator<Integer,String>(){
            @Override
            public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) {
                return new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        subscriber.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        subscriber.onError(e);
                    }

                    @Override
                    public void onNext(String s) {
                        int value = Integer.valueOf(s);
                        subscriber.onNext(value);
                    }
                };
            }
        };

        //目标发送端
        Observable targetObservable = originObservable.lift(operator);

        targetObservable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer obj) {
                System.out.println(obj);
            }
        });
    }

    /***
     * 将String类型的值转化为Integer类型的值乘以2并返回
     * lift 简单版
     */
    private static void method5() {
        //发送端
        Observable
                //发送器
                .just("123")
                //转换发送端
                .lift(new Operator<Integer, String>() {
                    @Override
                    public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) {
                        return new Subscriber<String>() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(String s) {
                                int value = Integer.valueOf(s);
                                value *= 2;
                                subscriber.onNext(value);
                            }
                        };
                    }
                })
                //转换发送器
                .lift(new Operator<Integer, Integer>() {
                    @Override
                    public Subscriber<? super Integer> call(final Subscriber<? super Integer> subscriber) {
                        return new Subscriber<Integer>() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(Integer integer) {
                                integer *= 100;
                                subscriber.onNext(integer);
                            }
                        };
                    }
                })
                //转换输出类型器
                .map(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return integer + "";
                    }
                })
                //接收端
                .subscribe(new Action1<String>() {
                    //接收器
                    @Override
                    public void call(String obj) {
                        System.out.println("最后一个接收器 - onNext: 返回结果:" + obj);
                    }
                });
    }

    private static Observable<String> liftAll(Observable observable) {
        return observable
                //转换发送端1
                .lift(new Operator<String, String>() {
                    @Override
                    public Subscriber<? super String> call(final Subscriber<? super String> subscriber) {
                        return new Subscriber<String>() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(String s) {
                                subscriber.onNext(Integer.valueOf(s) * 5 + "");
                            }
                        };
                    }
                })
                //转换发送端2
                .lift(new Operator<String, String>() {
                    @Override
                    public Subscriber<? super String> call(final Subscriber<? super String> subscriber) {
                        return new Subscriber<String>() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(String s) {
                                subscriber.onNext(Integer.valueOf(s) * 5 + "");
                            }
                        };
                    }
                })
                //转换发送端3
                .lift(new Operator<String, String>() {
                    @Override
                    public Subscriber<? super String> call(final Subscriber<? super String> subscriber) {
                        return new Subscriber<String>() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(String s) {
                                subscriber.onNext(Integer.valueOf(s) * 5 + "");
                            }
                        };
                    }
                })
                //转换发送端4
                .lift(new Operator<String, String>() {
                    @Override
                    public Subscriber<? super String> call(final Subscriber<? super String> subscriber) {
                        return new Subscriber<String>() {
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(String s) {
                                subscriber.onNext(Integer.valueOf(s) * 5 + "");
                            }
                        };
                    }
                });
    }

    /**
     * 升级版liftall使用
     */
    private static void  method6() {
        liftAll(Observable.just("123")).subscribe(new Action1() {
            @Override
            public void call(Object obj) {
                System.out.println("最后一个接收器 - onNext: 返回结果:" + obj);
            }
        });
    }

    /**
     **
     */
    private static class LiftAllTransformer implements Observable.Transformer<Integer,String>{
        @Override
        public Observable<String> call(Observable<Integer> integerObservable) {
            return liftAll(integerObservable);
        }
    }

    /**
     ** compose 包装多次lift操作，进行发送端转换器集合复用器
     */
    private static void method7() {
        //发送端转换器 包装器
        Observable.Transformer liftAll = new LiftAllTransformer();
        //发送端
        Observable
                //发送器
                .just("123")
                //发送端转换器 包装器
                .compose(liftAll)
                //建立订阅关系
                .subscribe(
                        //接收端
                        new Action1() {
                            //接收器
                            @Override
                            public void call(Object obj) {
                                System.out.println("最后一个接收器 - onNext: 返回结果:" + obj);
                            }
                        });
    }

    /**
     ** Scheduler 线程使用
     * subscribeOn(Schedulers.xxxx()) 作用于前边的发送器，在数据开始发送的时候，就已经产生作用环境
     * .observeOn(AndroidSchedulers.mainThread() / Schedulers.xxxx()) 产生影响在接收端（Subscriber )的接收器前边
     */
    private static void method8() {
        //发送端
        Observable
                //数组发送器
                .from(new Integer[]{1,2,3,4})
                //发送器 在IO线程发送，比较耗时的操作都在发送器操作
                //.subscribeOn(Schedulers.io())
                //下一个接收器  可以在一个新的线程中使用
                //.observeOn(Schedulers.newThread())
                //转换分解器 分解成一个个发送端
                .flatMap(new Func1<Integer, Observable<String>>() {
                    //分解转换过后，返回一个发送端
                    @Override
                    public Observable<String> call(Integer integer) {
                        return Observable.just(integer + "");
                    }
                })
                //下一个接收器  在IO线程中使用
                //.observeOn(Schedulers.io())
                .map(new Func1<String, Integer>() {
                    @Override
                    public Integer call(String s) {
                        return Integer.valueOf(s);
                    }
                })
                //下一个接收器  在主线程线程中使用，也即是UI可以更新的线程
                //.observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer obj) {
                        System.out.println("最后一个接收器打印所有结果 - onNext: 返回结果:" + obj);
                    }
                });
    }

    /**
     ** doOnSubscribe 这个方法发生在发送器（OnSubscribe、just、from）方法之前
     * 作用，可以进行设置进度条的UI操作（android 端操作页面的需求）
     */
    private static void method9() {
        //发送端
        Observable
                //发送器
                .just("123")
                //发送前执行器
                .doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        System.out.println("发送器前执行器的结果:" + "hello，my first excute method doOnSubscribe!");
                    }
                })
                //上一个数据发送器，工作的环境
                //.subscribeOn(AndroidSchedulers.mainThread())
                //建立关系
                .subscribe(
                        //接收端
                        new Action1<String>() {
                            //接收器
                    @Override
                    public void call(String s) {
                        System.out.println("最后一个接收器 - onNext: 返回结果:" + s);
                    }
                });
    }

    public static void main(String args[]) {
//        method1();
//        method2();
//        method3();
//        method4();
//        method5();
//        method6();
//        method7();
//        method8();
        method9();
    }
}



学习参考博文：http://gank.io/post/560e15be2dca930e00da1083#toc_12


当富网络
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxAndroid使用初探；简洁、优雅、高效
测试0901-1
01-16 682
引言 RxAndroid是一个开发库、是一种代码风格、也是一种思维方式。 正如标题所言，RxAndroid的特点是简洁、优雅、高效，它的优点是多线程切换简单、数据变换容易、代码简洁可读性好、第三方支持丰富易于开发；缺点是学习成本较高、出错难以排查。 用途与优势 ·起源...
Android Rxjava框架的原理和使用
m0_70749039的博客
03-26 1182
本文主要是对RxJava使用及Android常见使用场景进行总结，掌握这些还远远不够，RxJava还有许多强大的功能，诸如从磁盘/内存中获取缓存数据，背压策略，联想搜索优化等等。后面在项目开发中遇到相关场景再进行总结，更新。本文若有不当之处，请批评指正。
【Android】RXAndroid
健忘的鱼的博客
11-30 5299
RXAndroid 起源于RXJava，体现了响应式的编程规范，可以方便地处理异步数据流，强调对数据的观察与处理的流程 一、使用 导入依赖 implementation 'io.reactivex.rxjava3:rxandroid:3.0.0' implementation 'io.reactivex.rxjava3:rxjava:3.0.0' GitHub地址：RxAndroid 核心API Observable被观察者，事件由被观察者发出 Observer 观察者，事件由观察者接收 Subs.
rxandroid 基础知识
my_friend_ship的专栏
02-25 882
概述 在Android 中, 使用 rxandroid , rxandroid和rxJava的关系是,rxandroid包 依赖rxJava包,在其功能上增加了一些Android特有功能,项目中如果不需要指定rxJava包的版本,只需引入rxandroid包即可,如果需要更改 rxandroid包中默认的rxJava包版本 , 在项目中引入指定的rxJava包即可. 比如: implementation 'io.reactivex.rxjava2:rxjava:2.2.21' //会替换 r...
RxAndroid使用详解
最新发布
halong99的专栏
02-21 377
接着，我们订阅了subject，并指定了两个调度器：Schedulers.io()用于在IO线程执行异步任务（例如网络请求），AndroidSchedulers.mainThread()用于在主线程更新UI。最后，在subscribe方法中，我们定义了三个Lambda表达式，分别处理发射的数据（onNext），错误情况（onError），以及完成情况（onComplete）。() -> { /* 处理完成 */ } // onComplete：处理完成情况。// 订阅subject，处理异步任务。
重拾Android之路(五)RxJava和RxAndroid
牛谱乐的博客
06-30 1436
现在RxJava和RxAndroid越来越火爆，自己在业余时间也学习了一下，感觉确实很好用，之前 为了完成页面刷新，数据请求，组件信息传递的时候，要使用handler，真的是逻辑思路很强，稍微不注意，就各种错误一大堆。这下有了RxJava和RxAndroid，真的爽。 RxJava 网上有很多给RxJava做定义的，很多人说的比较官方，而我是比较笨的那种人，所以看了很久也没有看懂，不过...
RxAndroid的基础使用
Dimanche的博客
09-11 976
作为一个android开发者，在开发应用的过程中避免不了异步这个问题。android系统为我们提供了Handler这个类帮助我们进行线程间的通信和切换，但是GitHub上也有很多其他非常优秀的开源框架来帮助我们进行异步处理，比如今天学习的RxAndroid。 简介 GitHub传送门：https://github.com/ReactiveX/RxAndroid RxAndroid是一套观察者模式、...
高度解析使用模数转换器的数据采集系统设计
01-20
使用模数转换器 （ADC） 的数据采集系统会经历同样的现象，原因在于这些系统对一个连续的时间信号进行了不连续的“抓拍”。在这篇博文中，我将简要介绍ADC应用领域中的混叠到底是什么样子的。什么是混叠？根据那...
Android中碎片的使用方法详解
08-25
主要介绍了Android中碎片的使用方法详解,其实碎片很简单,但是网上胡乱充数的博文太多了,以至于我们有时候觉得比较乱,今天就来简单讲解一下碎片的使用,需要的朋友可以参考下
Android开发丶使用RxJava来完成自动轮播图
09-08
轮播图也是一个很常见的功能了，通常都置于App首页，每隔几秒就会切换下一张图片，等轮播完毕，则又会从第一张周而复始。这篇博文对该功能的实现做下归纳和整理。
php中的curl使用入门教程和常见用法实例
10-26
起先cURL是做为一种命令行工具设计出来的，比较幸运的是，php也支持cURL了。通过cURL这个利器，我们能在php程序中自由地发送HTTP请求到某个url来...在这篇博文中，我将简述下，在php中具体怎么使用cURL来处理一些事情。
安卓PreferenceScreen使用详细Demo
12-11
安卓PreferenceScreen使用详细Demo，本Demo对应博文https://blog.csdn.net/qXing123456789/article/details/84962172
RxAndroid介绍
DerWeltraum
02-13 935
RxAndroid RxAndroid是RxJava的一个针对Android平台的扩展。它包含了一些能够简化Android开发的工具。 首先，AndroidSchedulers提供了针对Android的线程系统的调度器。需要在UI线程中运行某些代码？很简单，只需要使用AndroidSchedulers.mainThread(): retrofitService
RxJava/RxAndroid 详解——从基础到实现原理
Kern_的专栏
04-14 1049
[RxJava的github地址：https://github.com/ReactiveX/RxJava](https://github.com/ReactiveX/RxJava) [RxAndroid的github地址：https://github.com/ReactiveX/RxAndroid](https://github.com/ReactiveX/RxAndroid)
RxAndroid： 基础介绍（一）
珠穆朗玛小王子的博客
06-16 2671
前言在找工作的时候看到过有面试要求会RxJava + Retrofit，当时也没有太在意，正好新的工作中用的就是这个，也慢慢体会了一下，的确是不错，他的优点就是逻辑清晰，对象的加工和线程的切换都是傻瓜操作，不得不说他火的有道理。正文概念性的东西就不说了，RxAndroid是RxJava在Android平台的一个版本，实现的功能几乎都是一样的。我在使用的都是都是2.0版本，跟低版本使用方法是有区别的，
OKHttp+RxJava+RxAndroid MVP详解
听海的博客
06-06 1839
Android开发中常用的技术架构有三种，MVC，MVP，MVVM。具体讲解1. MVC M：Model：模型层主要用来获取数据，数据的来源包括接口获取，数据库获取，SharedPreferences获取等等途径。并将其解析成Bean对象回调给Controller层。 V：View：视图层主要用来绘制各个视图，即Activity/Fragment对应的布局XML文件。 C：Controller：控制层主要接收Model层的回调，控制View层的显示。
RxJava 线程切换，AndroidSchedulers 源码分析（三）
Deaht_Huimie的博客
11-19 1153
RxJava线程类型有以下几种： Schedulers.io() 用于网络请求、访问数据库等耗时操作，线程数量无限制 Schedulers.newThread() 创建新的线程，需要慎用，用在长时间运行在后台不会频繁创建和销毁 Schedulers.computation() 大量数据和图片处理，线程有最大值的限制 Schedulers.immediate() 当前线程，可以理解为默认的是这...
详细解析 RxAndroid 的使用方式
weixin_30733003的博客
03-24 194
RxAndroid是RxJava的扩展, 优雅地处理异步请求. RxAndroid配合Lambda表达式, 精简处理回调, 使程序更具有可读性. Rx作为Android最优秀的开源库之一, 极大地提高生产力, 我们需要掌握. 本文由浅入深, 介绍一些常见的使用方法, 并附有源码. 更多:http://www.wangchenlong.org/ 本文代码的GitHub下载地址. ...
android——rxjava的使用
wy313622821的博客
01-11 1239
本文介绍项目开发中使用到rxjava的情形，以及详细的代码。RxJava是一个基于Java语言的Reactive Extensions库，它用于实现异步编程和流式处理，通过将事件和数据流以数据序列的形式进行处理，提高了代码的可读性和可维护性。
charmm在Linux中的使用方法,科学网—Gromacs中添加CHARMM力场 - 贾壮的博文
06-03
Charmm是一款分子模拟软件，Linux系统下的使用方法如下： 1. 下载Charmm软件并解压缩到指定目录中。 2. 在终端中进入Charmm的安装目录，并执行以下命令进行编译： ``` ./install.com gnu ``` 编译完成后，在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值