响应式编程--Android Rxjava的使用（一）

最新推荐文章于 2024-04-02 13:47:50 发布

zh175578809

最新推荐文章于 2024-04-02 13:47:50 发布

阅读量720

点赞数

分类专栏： Android 文章标签： android

本文链接：https://blog.csdn.net/zh175578809/article/details/73929992

版权

Android 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

RxJava作为一个响应式编程库，在Android开发者中非常的受欢迎，越来越多的人开始接触并使用，作为一个Android开发的菜鸟，仔细研究了一下RxJava的知识，在此将一些学习的过程和心得记录一下

首先介绍一下RxJava相关的概念

ReactiveX

ReactiveX 是一个专注于异步编程与控制可观察数据（或者事件）流的API。它组合了观察者模式，迭代器模式和函数式编程的优秀思想。

RxJava

RxJava 是 ReactiveX 在 Java 上的开源的实现。在Github上对此的解释是：

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

翻译过来的大概意思是：一个在 Java VM 上使用可观察序列组成的异步的、基于事件的程序库

这句话比较抽象，简单来说就是一个用于异步操作的类库。对Android线程了解的人都知道，Android的绘制和事件响应都是在主线程中的，为了保证界面能够快速及时的响应用户操作，很多耗时操作，比如读写文件、请求网络，都会在子线程中去执行。在没有RxJava之前，一般都会使用AsyncTask、Thread来实现，有了RxJava以后，实现起来就会变得简单的多

本博客将会分别介绍RxJava1.x和RxJava2.0两个版本上的使用及不同点

RxJava1.x

RxJava使用的是通用的观察者模式，RxJava中两个主要的类：Observable（被观察者）和 Subscriber（订阅者）。在 RxJava 上，一个 Observable 是一个发出数据流或者事件的类，Subscriber 是一个对这些发出的 items （数据流或者事件）进行处理（采取行动）的类

现在，着手实现一个简单的Observable和Subscriber的创建和订阅

使用RxJava需要引入类库，Github上的链接

RxJava: https://github.com/ReactiveX/RxJava

如果需要进行Android App的开发，同时需要引入类库RxAndroid

RxAndroid: https://github.com/ReactiveX/RxAndroid

首先，实现一个Observable，即被观察者，它决定什么时候触发事件以及触发怎样的事件

Observable observable = Observable.create(new OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                // TODO Auto-generated method stub
                subscriber.onNext(0);
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onCompleted();
            }
        });

create()方法传入了一个OnSubscribe对象作为参数。OnSubscribe对象会被存储在返回的Observable对象中，当Observable被订阅的时候，OnSubscribe的call()方法会被调用，事件序列就会依照设定依次触发。被观察者可以发送三种事件：onNext()、onError()、onComplete()。被观察者发送的事件会在观察者中处理，这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式

接下来实现一个Observer，即观察者，它决定事件触发的时候有怎样的行为

Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onNext(Integer integer) {
                // TODO Auto-generated method stub
                Log.i(TAG, integer.toString());
            }

            @Override
            public void onError(Throwable e) {
                // TODO Auto-generated method stub
                Log.i(TAG, e.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete()");
            }
        };

Observer是一个接口，RxJava还内置了一个实现Observer的抽象类：Subscriber。Subscriber对Observer接口进行了扩展，但他们的基本使用方式是完全一样的

Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                // TODO Auto-generated method stub
                Log.i(TAG, integer.toString());
            }

            @Override
            public void onError(Throwable e) {
                // TODO Auto-generated method stub
                Log.i(TAG, e.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete()");
            }
        };

最后，使用subscribe()方法实现订阅，被观察者就会向观察者发送事件

observable.subscribe(observer);
//observable.subscribe(subscriber);

输出结果：

0
1
2
onComplete

上游的被观察者发送的事件遵循以下规则：

1、上游可以发送无限个onNext，下游也可以接收无限个onNext

2、当上游发送了一个onComplete后，上游onComplete之后的事件会继续发送，而下游收到onComplete事件之后不再继续接收事件

3、当上游发送了一个onError后，上游onError之后的事件会继续发送，而下游收到onError事件之后将不再继续接收事件

4、上游可以不发送onComplete或onError

5、onComplete和onError必须唯一并且互斥，即onComplete和onError只能发送一个，不能两个都发送

上述代码使用的是create()方法来创建事件队列，create()是RxJava最基本的创建事件队列的方法，下面是几种其他创建事件队列的方法

just()方法：队列中的事件会被依次发送给观察者

Observable.just("Hello", "Hi", "RxJava").subscribe(new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                // TODO Auto-generated method stub
                Log.i(TAG, s);
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

from(T[]) / from(Iterable

Observable.from(array).subscribe(new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                // TODO Auto-generated method stub
                Log.i(TAG, s);
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

defer()：有观察者订阅时才创建Observable，这种方式可以保证Observable的状态是最新的

        str = "Test";
        Observable observable1 = Observable.just(str);

        Observable observable2 = Observable.defer(new Func0<Observable<String>>() {

            @Override
            public Observable<String> call() {
                // TODO Auto-generated method stub
                return Observable.just(str);
            }

        });

        str = "Change str";

        observable1.subscribe(new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                // TODO Auto-generated method stub
                Log.i(TAG, s);
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

        observable2.subscribe(new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                // TODO Auto-generated method stub
                Log.i(TAG, s);
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

输出结果：

Test
Change str

interval()：创建一个按固定时间间隔发射整数序列的Observable

Observable.interval(1, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @Override
            public void onNext(Long aLong) {
                // TODO Auto-generated method stub
                Log.i(TAG, aLong.toString());
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

range()：创建一个发射特定序列的Observable，第一个参数为起始值，第二个为发送的个数，如果为0则不发送，如果为负数抛出异常

Observable.range(0, 1000).subscribe(new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                // TODO Auto-generated method stub
                Log.i(TAG, aLong.toString());
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

timer()：创建一个Observable，它在一个给定的延迟后发射一个特殊的值，等同于Handler的postDelayed()

Observable.timer(1, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @Override
            public void onNext(Long aLong) {
                // TODO Auto-generated method stub
                Log.i(TAG, aLong.toString());
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

repeat()：创建一个重复发射特定数据的Observable

String[] array = {"Hello", "Hi", "RxJava"};
Observable.from(array).repeat().subscribe(new Subscriber<String>() {
            @Override
            public void onNext(String str) {
                // TODO Auto-generated method stub
                Log.i(TAG, str);
            }

            @Override
            public void onError(Throwable throwable) {
                // TODO Auto-generated method stub
                Log.i(TAG, throwable.toString());
            }

            @Override
            public void onCompleted() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        });

subscribe()还支持不完整的回调，RxJava会自动根据定义创建出Subscriber

Action0 onCompleteAction = new Action0() {

            @Override
            public void call() {
                // TODO Auto-generated method stub
                Log.i(TAG, "onComplete");
            }
        };

        Action1<String> onNextAction = new Action1<String>() {
            public void call(String str) {
                Log.i(TAG, str);
            };
        };

        Action1<Throwable> onErrorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable e) {
                // TODO Auto-generated method stub
                Log.i(TAG, e.toString());
            }
        };

Action0是RxJava的一个接口，它只有一个方法call()，这个方法没有参数，也没有返回值，所以可以被定义为onComplete()方法。Action1也是一个接口，它同样只有一个方法call(T param)，这个方法也没有返回值，但有一个参数，与Action0同理，可以被定义为onNext()和onError()方法。

observable.subscribe(onNextAction);
observable.subscribe(onNextAction, onErrorAction);
observable.subscribe(onNextAction, onErrorAction, onCompleteAction);

zh175578809

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
响应式编程--Android Rxjava的使用（一）

RxJava作为一个响应式编程库，在Android开发者中非常的受欢迎，越来越多的人开始接触并使用，作为一个Android开发的菜鸟，仔细研究了一下RxJava的知识，在此将一些学习的过程和心得记录一下首先介绍一下RxJava相关的概念ReactiveXReactiveX 是一个专注于异步编程与控制可观察数据（或者事件）流的API。它组合了观察者模式，迭代器模式和函数式编程的优秀思想。RxJavaR
复制链接

扫一扫

专栏目录