RxJava学习1

目录

一.RxJava是什么?

二.RxJava的作用?

三.RxJava的优势:

四.RxJava的4个角色:

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

六.RxJava的使用方法:

1.创建被观察者Observable

2.创建观察者Observer

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

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

八.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的使用方法:

  1. 创建被观察者Observable
  2. 创建观察者Observer
  3. 通过订阅连接被观察者和观察者

首先要添加依赖:

    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);
            }
        });

九.执行总日志:

补充:

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

  1. * 观察者的onSubscribe
  2. * 被观察者的subscribe
  3. * 观察者的onNext
  4. * 观察者的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 入门教程

 

展开阅读全文
博主设置当前文章不允许评论。

没有更多推荐了,返回首页