RxJava学习1

最新推荐文章于 2024-04-03 20:01:33 发布

喝了小酒的猴子

最新推荐文章于 2024-04-03 20:01:33 发布

阅读量313

点赞数 1

分类专栏： Android

本文链接：https://blog.csdn.net/aaadaaaada/article/details/81605662

版权

Android 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

八.RxJava提供了多个函数式接口，用于实现简便式的观察者模式

九.执行总日志:

补充:

观察者和被观察者各方法的调用顺序

观察者 Observer的subscribe()具备多个重载的方法

可采用 Disposable.dispose() 切断观察者与被观察者之间的连接

一.RxJava是什么?

RxJava 是一个基于事件流、实现异步操作的库

二.RxJava的作用?

实现异步操作,类似于Android中的AsyncTask,Handler

三.RxJava的优势:

基于事件流的链式调用,使得代码的逻辑清晰,并且在程序逻辑性复杂度提高的情况下 * 依然能够保持逻辑的清晰

四.RxJava的4个角色:

1.被观察者（Observable）产生事件

2.观察者（Observer）处理事件

3.订阅（Subscribe）连接观察者金额被观察者的"信差"

4.事件（Event）具体的事情

五.举一个生活中的例子:

张三给李四写了一封信,让信差王五送去

张三(被观察者) Observable
写信(事件) Event
信差王五(订阅)送信 Subscribe
李四(观察者)看信 Observer

六.RxJava的使用方法:

创建被观察者Observable
创建观察者Observer
通过订阅连接被观察者和观察者

首先要添加依赖:

    compile 'io.reactivex.rxjava2:rxjava:2.0.1'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

1.创建被观察者Observable

        /**1.创建被观察者Observable**/
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(final ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
                //e.onError(null);
            }
        });

创建被观察者的其他方法

        /**创建被观察者的其他方法**/
        // 方法1
        Observable.just(1, 2, 3);
        //将会依次调用
        //onNext(1);
        //onNext(2);
        //onNext(3);
        //onComplete();
        //方法2
        Integer[] words = {1, 2, 3};
        //List<String> words = new ArrayList<>();
        Observable.fromArray(words);
        //将会依次调用
        //onNext(1);
        //onNext(2);
        //onNext(3);
        //onComplete();

2.创建观察者Observer

创建观察者Observer,有两种方式:
2.1 采用Observer 接口
2.2 采用Subscriber 抽象类

//2.1 采用Observer 接口
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(final Disposable d) {
                //观察者接收事件前，默认最先调用复写 onSubscribe（）
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(final Integer value) {
                //被观察者调用e.onNext(1);时该方法响应
                Log.d(TAG, "对Next事件作出响应" + value);
            }

            @Override
            public void onError(final Throwable e) {
                //被观察者调用e.onError(null);时该方法响应
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                //被观察者调用e.onError(null);时该方法响应
                Log.d(TAG, "对Complete事件作出响应");
            }
        };

        //2.2 采用Subscriber 抽象类
        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(final Subscription d) {
               // 观察者接收事件前，默认最先调用复写 onSubscribe（）
                Log.d(TAG, "--------");
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(final Integer value) {
                //被观察者调用e.onNext(1);时该方法响应
                Log.d(TAG, "对Next事件作出响应" + value);
            }

            @Override
            public void onError(final Throwable e) {
                //被观察者调用e.onError(null);时该方法响应
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                //被观察者调用e.onComplete();时该方法响应
                Log.d(TAG, "对Complete事件作出响应");
            }

        };

2种方法的区别

相同点：二者基本使用方式完全一致（实质上，在RxJava的 subscribe 过程中，Observer总是会先被转换成Subscriber再使用）
不同点：Subscriber抽象类对 Observer 接口进行了扩展，新增了两个方法：
1. onStart()：在还未响应事件前调用，用于做一些初始化工作
2. unsubscribe()：用于取消订阅。在该方法被调用后，观察者将不再接收 & 响应事件
调用该方法前，先使用 isUnsubscribed() 判断状态，确定被观察者Observable是否还持有观察者Subscriber的引用，如果引用不能及时释放，就会出现内存泄露

3.通过订阅连接被观察者和观察者

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

七.RxJava基于事件流的链式调用

实际开发中一般都是这样使用

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull final ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "--------");
                Log.d(TAG, "开始采用subscribe连接");
            }
            // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件"+ value +"作出响应"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }

        });

八.RxJava提供了多个函数式接口，用于实现简便式的观察者模式

比如这里使用了Consumer

        Observable.just("hello","大","胸","弟").subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull final String s) throws Exception {
                Log.d(TAG, "--------");
                Log.d(TAG, s);
            }
        });

九.执行总日志:

补充:

观察者和被观察者各方法的调用顺序

* 观察者的onSubscribe
* 被观察者的subscribe
* 观察者的onNext
* 观察者的onComplete

观察者 Observer的subscribe()具备多个重载的方法

/** public final Disposable subscribe() {}
// 表示观察者不对被观察者发送的事件作出任何响应（但被观察者还是可以继续发送事件）

public final Disposable subscribe(Consumer<? super T> onNext) {}
// 表示观察者只对被观察者发送的Next事件作出响应
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {}
// 表示观察者只对被观察者发送的Next事件 & Error事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
// 表示观察者只对被观察者发送的Next事件、Error事件、Complete事件 & onSubscribe事件作出响应

public final void subscribe(Observer<? super T> observer) {}
// 表示观察者对被观察者发送的任何事件都作出响应。
**/

可采用 Disposable.dispose() 切断观察者与被观察者之间的连接

        Observer<Integer> observer = new Observer<Integer>() {
           private Disposable mDisposable;
            @Override
            public void onSubscribe(@NonNull final Disposable d) {
                mDisposable = d;
            }

            @Override
            public void onNext(@NonNull final Integer integer) {
                if (integer == 2) {
                    mDisposable.dispose();
                    Log.d(TAG,"已经切断了连接==" + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(@NonNull final Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

Demo下载地址:

RxJavaStudy1

本篇博客主要学习了以下博客:

Android Rxjava：这是一篇清晰 & 易懂的Rxjava 入门教程

喝了小酒的猴子

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava学习1

目录一.RxJava是什么?二.RxJava的作用?三.RxJava的优势:四.RxJava的4个角色:五.举一个生活中的例子:六.RxJava的使用方法:1.创建被观察者Observable2.创建观察者Observer3.通过订阅连接被观察者和观察者七.RxJava基于事件流的链式调用八.RxJava提供了多个函数式接口，用于实现简便式的观察者模式...
复制链接

扫一扫