RxJava 实战操作

最新推荐文章于 2025-08-16 10:23:48 发布
原创 最新推荐文章于 2025-08-16 10:23:48 发布 · 420 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#RxJava #Android

RxJava实际运用

RxJava+Retrofit网络请求

api.getBanner()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new SingleObserver<BannerBean>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            textView.setText("loading...");
            disposables.add(d);
        }

        @Override
        public void onSuccess(@NonNull BannerBean bannerBean) {
            textView.setText(bannerBean.toString());
        }

        @Override
        public void onError(@NonNull Throwable e) {
            textView.setText(e.getMessage());
        }
    });

串行执行

StringBuffer buffer = new StringBuffer();
api.getBanner()
    .flatMap(new Function<BannerBean, SingleSource<ArticleBean>>() {
        @Override
        public SingleSource<ArticleBean> apply(BannerBean bannerBean) throws Throwable {
            buffer.append(bannerBean).append("\n\n");
            return api.getArticleList(1);
        }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new SingleObserver<ArticleBean>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            textView.setText("loading...");
        }

        @Override
        public void onSuccess(@NonNull ArticleBean articleBean) {
            buffer.append(articleBean);
            textView.setText(buffer.toString());
        }

        @Override
        public void onError(@NonNull Throwable e) {
            textView.setText(e.getMessage());
        }
    });

并行执行

api.getBanner().zipWith(
    api.getArticleList(1),
    new BiFunction<BannerBean, ArticleBean, String>() {
        @Override
        public String apply(BannerBean bannerBean, ArticleBean articleBean) throws Throwable {
            StringBuffer buffer = new StringBuffer();
            buffer.append(bannerBean).append("\n\n").append(articleBean);
            return buffer.toString();
        }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new SingleObserver<String>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            disposables.add(d);
            textView.setText("loading...");
        }

        @Override
        public void onSuccess(@NonNull String o) {
            textView.setText(o);
        }

        @Override
        public void onError(@NonNull Throwable e) {
            textView.setText(e.getMessage());
        }
    });

轮询

定义实体类

public class Translation {
    public int status;
    public Content content;

    public static class Content {
        public String form;
        public String to;
        public String vendor;
        public String out;
        public int errNo;
    }

    public String show() {
        return content.out;
    }
}

定义网络请求类

public interface ApiService {
    @GET("ajax.php?a=fy&f=auto&t=auto&w=goodmorning")
    Observable<Translation> getCall();
}

...
    
public class HttpService {
    private static final String BASE_URL = "http://fy.iciba.com/";
    private ApiService apiService;

    private static class Wrapper {
        static HttpService httpService = new HttpService();
    }

    private HttpService() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
        apiService = retrofit.create(ApiService.class);
    }

    public static HttpService getInstance() {
        return Wrapper.httpService;
    }

    public Observable<Translation> getCall() {
        return apiService.getCall();
    }
}

轮询操作：

/*
参数1：第一次延迟时间
参数2：间隔时间
参数3：时间单位
 */
Observable.interval(2, 1, TimeUnit.SECONDS)
        /*
        在next之前调用
         */
        .doOnNext(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e(TAG, "第" + aLong + "次轮询");
                Observable<Translation> call = HttpService.getInstance().getCall()
                call.subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Observer<Translation>() {
                            @Override
                            public void onSubscribe(Disposable d) {
                            }
                            @Override
                            public void onNext(Translation result) {
                                Log.e(TAG, result.show());
                            }
                            @Override
                            public void onError(Throwable e) {
                                Log.e(TAG, "请求失败");
                            }
                            @Override
                            public void onComplete() {
                            }
                        });
            }
        })
        .subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(Long aLong) {
            }
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "对Error事件作出响应");
            }
            @Override
            public void onComplete() {
                Log.e(TAG, "对Complete事件作出响应");
            }
        });

输出信息：

在这里插入图片描述

有条件轮询

.repeat()和[.retry()之间区别：在于什么样的终止事件会触发重订阅。

当**.repeat()接收到.onCompleted()**事件后触发重订阅。

当**.retry()接收到.onError()**事件后触发重订阅。

Observable<Translation> call = HttpService.getInstance().getCall();
call.repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
    @Override
    public ObservableSource<?> apply(Observable<Object> objectObservable) throws Exception {
        return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Object o) throws Exception {
                if (i > 3) {
                    return Observable.error(new Throwable("轮询结束"));
                }
                return Observable.just(1).delay(2000, TimeUnit.MILLISECONDS);
            }
        });
    }
})
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Observer<Translation>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Translation result) {
            // e.接收服务器返回的数据
            Log.e(TAG, result.show());
            i++;
        }

        @Override
        public void onError(Throwable e) {
            Log.d(TAG, e.toString());
        }

        @Override
        public void onComplete() {
        }
    });

网络请求出错重连

Observable<Translation> call = HttpService.getInstance().getCall();
call.retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
    @Override
    public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {
        return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Throwable throwable) throws Exception {
                Log.e(TAG, "发生异常： " + throwable.toString());
                if (throwable instanceof IOException) {
                    Log.e(TAG, "属于io异常");
                    if (currentRetryCount < maxConnectCount) {
                        currentRetryCount++;
                        Log.e(TAG, "重试次数：" + currentRetryCount);
                        waitRetryTime = 1000 + currentRetryCount * 1000;
                        Log.e(TAG, "等待时间：" + waitRetryTime);
                        return Observable.just(1).delay(waitRetryTime, TimeUnit.MILLISECONDS);
                    } else {
                        return Observable.error(new Throwable("充实次数超过最大次数" + currentRetryCount));
                    }
                } else {
                    return Observable.error(new Throwable(("发生了非网络异常")));
                }
            }
        });
    }
}).subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Observer<Translation>() {
        @Override
        public void onSubscribe(Disposable d) {
        }

        @Override
        public void onNext(Translation result) {
            Log.e(TAG, result.show());
        }

        @Override
        public void onError(Throwable e) {
            // 获取停止重试的信息
            Log.e(TAG, e.toString());
        }

        @Override
        public void onComplete() {

        }
    });

输出信息：

发生异常： java.net.UnknownHostException: Unable to resolve host "fy.iciba.com": No address associated with hostname
属于io异常
重试次数：1
等待时间：2000
发生异常： java.net.UnknownHostException: Unable to resolve host "fy.iciba.com": No address associated with hostname
属于io异常
重试次数：2
等待时间：3000
早安

从内存缓存/磁盘读取数据

final String memoryCache = null;
final String diskCache = "磁盘保存的数据";

/**
* 检查内存缓存
*/
Observable<String> memory = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        //判断内存缓存是否有数据
        if (memoryCache != null) {
            //有数据发送
            emitter.onNext(memoryCache);
        } else {
            //没数据结束事件
            emitter.onComplete();
        }
    }
});

/**
* 检查磁盘缓存
*/
Observable<String> disk = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        //判断磁盘是否有数据
        if (diskCache != null) {
            //有数据
            emitter.onNext(diskCache);
        } else {
            //无数据
            emitter.onComplete();
        }
    }
});

/**
* 从网络获取数据
*/
Observable<String> network = Observable.just("从网络获取数据");

Observable.concat(memory, disk, network)
    .firstElement() // 只发送第一个有效数据
    .subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            Log.e(TAG, "accept: " + s);
        }
    });

输出信息：

accept: 磁盘保存的数据
RxJava实战：解决移动开发中的常见问题
移动开发前沿的博客
06-14 599
在移动开发中，我们经常会遇到各种各样的问题，比如网络请求、数据处理、界面更新等，这些操作往往需要进行异步处理，以避免阻塞主线程，影响用户体验。RxJava作为一种强大的响应式编程库，为我们提供了一种优雅的方式来处理这些异步操作。本文的目的就是介绍RxJava在移动开发中的实战应用，帮助开发者解决常见的问题。范围涵盖RxJava的核心概念、原理、具体操作步骤以及实际应用场景等方面。本文将首先介绍RxJava的核心概念和它们之间的关系，通过生活中的例子让大家更好地理解。
掌握 RxJava 采样操作符，优化移动开发数据获取
移动开发前沿的博客
05-19 997
在移动应用开发中，高效处理数据流是提升应用性能的关键挑战之一。RxJava采样操作符提供了一种优雅的解决方案，能够在不丢失重要数据的前提下，有效控制数据发射频率。本文旨在全面解析RxJava采样操作符家族(sample、throttleLast、throttleFirst、throttleLatest、debounce等)，帮助开发者理解其内部机制并掌握实际应用技巧。文章首先介绍采样操作符的核心概念，然后深入分析其实现原理和数学基础，接着通过实际案例展示应用场景，最后讨论相关工具和未来发展趋势。
Android开发面试之RxJava，【工作感悟】
09-10 321
Exceptions.throwIfFatal(ex); parent.onError(ex); } } 先是创建`CreateEmitter`类型的发射器，把下游的observer传给发射器，注意此处的发射器是实现了`Disposable`接口，所以紧接着会把发射器通过下游的观察者的`onSubscribe`方法传给下游观察者，注意此处传的是`Disposable`对象。接着会给上游的`ObservableOnSubscribe`添加订阅，并且把下游的observer给上游的`...
Rxjava实战
johnhuster的专栏
04-03 737
转载自：https://www.jianshu.com/p/64aa976a46be 想写好一篇文章确实不容易，感谢那些大牛们能够分享自己的所见所得。关于rxjava的原理以及观察者模式等理论性的内容我就不在这里献丑了，网上有很多很优秀的博客。回头我添加几篇到这里，大家可以看一看，这篇文章只是简单的通过例子告诉大家rxjava的基本使用方法，如果有任何的批评、建议或者疑问可以评论，第一时间给予答...
RxJavaDemoApp: Android上的RxJava实战教程
gitblog_00007的博客
05-21 376
RxJavaDemoApp: Android上的RxJava实战教程 项目概述 RxJavaDemoApp 是一个专为Android开发者设计的开源项目，它集成了超过100个RxJava的示例代码片段。此项目由JoaoMotondon维护，并已全面转换为Kotlin语言。旨在通过一个应用程序内部提供丰富的RxJava应用实例，帮助开发者理解和应用RxJava的各种操作符、错误处理、背压管理、热O...
RxJava实战技巧大全
热门推荐
Floating Cat
09-30 1万+
这几天一直看《激荡三十年》，感觉非常不错。这篇文章本身并不想写，总觉得没什么含量,后面写着写着，发现其中的有些点还是非常有意思的，因此这篇文章的重点在rxjava使用场景说明及rxjava内存优化上。rxjava的使用场景更多的取决于我们所面临的业务以及当前rxjava的一些操作符是否提供了对业务的支持，而对于内存优化上，则是要求我们尽可能快的解除订阅关系。
RxJava 实例
xiaowang_lj的博客
10-20 656
三种方式：Observable.create、Observable.just、Observable.fromArray@Override}});}使用observer或者subscriber@Override}@Override}@Override}@Override}};特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别。
Android RxJava 组合操作符实战：优雅处理多数据源
最新发布
android开发者的专栏
08-16 769
RxJava的组合操作符为Android开发中复杂的数据流协调问题提供了优雅的解决方案。简单合并使用merge()或concat()数据关联使用zip()或竞速场景使用amb()避免内存泄漏配合管理订阅线程控制合理使用observeOn最佳实践建议对于网络请求组合，优先考虑zip确保数据完整性UI事件组合使用实现实时响应长时间运行的任务使用避免旧数据覆盖在Fragment/Activity销毁时及时清理订阅。
9章 RxJava混合实战
点击置顶文章查看博客目录（全站式导航）
12-27 715
本篇文章已授权微信公众号 YYGeeker 独家发布转载请标明出处 优快云学院课程地址 RxJava2从入门到精通-初级篇:https://edu.youkuaiyun.com/course/detail/10036 RxJava2从入门到精通-中级篇:https://edu.youkuaiyun.com/course/detail/10037 RxJava2从入门到精通-进阶篇:https://edu.csdn....
响应式拿手好道-RxJava-RxAndroid实战指南
w风雨无阻w的专栏
05-21 958
总的来说，掌握了RxJava/RxAndroid这一宝贵的响应式编程利器，必将使我们在移动开发的道路上阔步前行，逐步解锁高阶异步编程的大门。当然，这绝非止步之路，Kotlin协程等新兴技术的涌现，也将给响应式编程领域注入新的活力。保持开放的学习心态，我们定能驾驭更多先进工具，创造出更卓越的作品。
AndroidRxJava实战讲解：优雅实现网络请求轮询
01-27
2.RxJava如此受欢迎的原因，在于其提供了丰富&功能强大的操作符，几乎能完成所有的功能需求3.今天，我将为大家带来Rxjava创建操作符的常见开发应用场景：轮询需求 ，并结合Retrofit与RxJava实现，希望大家会喜欢。 1...
RxJava实战读书笔记
10-11
### RxJava实战读书笔记知识点梳理 #### 一、RxJava基础概念 - **RxJava**：是一种用于处理异步数据流的库，基于响应式扩展（Reactive Extensions）的概念，提供了一种强大的处理异步操作的方式。 - **Observable*...
Android 仿抖音列表
xiangxiongfly
09-20 9919
当下抖音非常火热，是不是也很心动做一个类似的app吗？ 那我们就用RecyclerView实现这个功能吧，关于内存的回收利用就交给RecyclerView就好了。 首先我们先说3个和视频播放暂停相关的接口 public interface OnViewPagerListener { /** * 初始化 */ void onInitComplete(View v...
Android 沉浸式总结
xiangxiongfly
09-18 9789
fitsSystemWindows 是 Android 系统中处理系统窗口区域适配的关键属性，用于控制视图如何与系统栏（状态栏/导航栏）交互
Android 防止系统字体变化、显示大小变化影响App
xiangxiongfly
10-21 6214
Android 防止系统字体变化、显示大小变化影响App
Android ActivityResultContract使用
xiangxiongfly
10-07 5180
文章目录Android Activity Results API使用startActivityForResult问题自定义ActivityResultContract定义协议注册协议跳转系统内置ActivityResultContractStartActivityFoResultRequestPermissionRequestMultiplePermissionsTakePicturePreviewPickContact源码下载 Android Activity Results API使用 startAct
Android 处理软键盘遮挡问题
xiangxiongfly
04-15 4817
文章目录Android 处理软键盘遮挡问题方式一：使用scrollTo方式二：使用NestedScrollView Android 处理软键盘遮挡问题 需要达到的效果： 方式一：使用scrollTo 当软键盘弹起时，通过scrollTo滚动出被遮挡的地方。 监听软键盘状态工具类 public class SoftKeyboardListener { private static int lastVisibleHeight = 0; public interface OnSoftKeyb
Android Gson TypeAdaper 和 JsonSerializer/JsonDeserializer 总结
xiangxiongfly
04-25 4077
在Gson中，TypeAdapter 和 JsonSerializer 是两个用于定制序列化和反序列化过程的接口。 JsonSerializer则是Gson中的默认实现，它提供了一种简单的序列化和反序列化方式，可以将Java对象转换为JSON字符串或将JSON字符串转换为Java对象。 TypeAdapter是Gson提供的一个抽象类，用于接管某种类型的序列化和反序列化过程，包含两个重要方法：write(JsonWriter out, T value) 和 read(JsonReader in)。
Android 内存被异常回收后直接重启APP
xiangxiongfly
09-21 4062
做Android开发的小朋友一定会遇到程序退到后台，遇到内存被回收，导致数据为空，这时候启动APP就会出现空指针问题。 那么，我们该怎么解决这个问题呢？其实很简单，当内存被回收后，我们可以直接重启APP，重新走一遍APP启动的流程，这样数据就会重新加载一遍，避免了数据为空的问题。 首先，我们先定义一个AppStatusManager管理生命周期类 /** * APP状态跟踪器常量码 */ pu...
Java RxJava库操作符实战与示例
Java的RxJava库操作符是其强大功能的核心组件，它在Android开发中的应用主要体现在异步处理和事件驱动编程上。RxJava通过一系列操作符提供了一种简洁的方式来处理数据流，使得代码更为易读和维护。本篇文章将深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值