RxJava基础入门

转载请注明链接: https://blog.csdn.net/feather_wch/article/details/88090332

RxJava基础入门

版本号:2019-03-03(21:01)


文章目录

  • RxJava基础入门
    • 依赖添加
    • RxJava的定义
    • RxJava的原理
      • 四个角色
        • 被观察者(Observable)
        • 观察者(Observer)
        • 订阅(Subscribe)
        • 事件(Event)
    • 使用步骤
      • 创建被观察者并产生事件
        • ObservableEmitter
      • 创建观察者并定义响应事件的行为
        • 事件(Next、Complete、Error)
        • Observer接口
        • Subscriber抽象类
        • 两者的区别
      • 通过订阅连接观察者和被观察者
    • 函数式接口
    • Disposable
    • 参考资料

依赖添加

1、在线添加依赖

compile 'io.reactivex.rxjava2:rxandroid:2.1.1'
compile 'io.reactivex.rxjava2:rxjava:2.2.7'

2、离线依赖

compile files('libs/rxjava-2.2.0.jar')
compile files('libs/RxAndroid.jar')

RxJava的定义

1、RxJava的定义

RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库

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

3、Android中RxJava类似于AsyncTask、Handler的作用

RxJava的原理

1、RxJava的原理基于一种扩展的观察者模式

2、流程总结: 被观察者(Observable)通过订阅(Subscribe)按顺序发送事件观察者(Observer)观察者(Observer)按顺序接收事件,并且作出对应的响应动作。

四个角色

被观察者(Observable)

3、被观察者(Observable)用于:产生事件

观察者(Observer)

4、观察者(Observer)用于:接收事件,并给出响应动作

订阅(Subscribe)

5、订阅(Subscribe)用于:连接被观察者和观察者

事件(Event)

6、事件(Event)用于:被观察者和观察者沟通的载体

使用步骤

创建被观察者并产生事件

1、create()创建被观察者

// 1、创建被观察者Obervavle对象
// 2、create()方法用于创造事件序列
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    // 3、定义需要发送的事件
    @Override
    public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onComplete();
        e.onNext(4);
    }
});
  1. onNext(1)用于发送事件
  2. onComplete()会让观察者不再接收到事件。但是事件会继续发送,比如onNext(4)还是会发送出去。

2、just()创建被观察者

  1. 不仅会构建被观察者,还会依次将参数的事件发送出去。
/**=====================================
 * 方法1:just(T...):直接将传入的参数依次发送出来
 *         // 将会依次调用:
 *         // onNext("A");
 *         // onNext("B");
 *         // onNext("C");
 *         // onCompleted();
 *======================================*/
Observable justObservable = Observable.just("A", "B", "C");

3、from()创造被观察者

from()方法RxJava2中没找到,不知道是不是移除了。

/**==============================================
 * 方法2:from(T[]) / from(Iterable) : 将传入的数组 / Iterable 拆分成具体对象后,依次发送出来
 *         // 将会依次调用:
 *         // onNext("A");
 *         // onNext("B");
 *         // onNext("C");
 *         // onCompleted();
 *===========================================*/
String[] words = {"A", "B", "C"};
Observable fromObservable = Observable.from(words);

ObservableEmitter

4、ObservableEmitter是什么?

/**================================================
 * 1. ObservableEmitter继承自Emitter, 是事件发射器
 * 2. 用于定义需要发送的事件
 * 3. 并且用于向观察者发送事件
 * // ObservableEmitter.java
 *===============================================*/
public interface ObservableEmitter<T> extends Emitter<T> {
    void setDisposable(@Nullable Disposable var1);

    void setCancellable(@Nullable Cancellable var1);

    boolean isDisposed();

    @NonNull
    ObservableEmitter<T> serialize();

    boolean tryOnError(@NonNull Throwable var1);
}

创建观察者并定义响应事件的行为

事件(Next、Complete、Error)

5、Next事件

  1. 被观察者可以发送无限个Next事件
  2. 观察者可以接收无限个Next事件
  3. 接收到Next事件后,回调onNext()方法

6、Complete事件

  1. 该事件表示:事件队列完结。
  2. 被观察者onComplete()后发送的事件依然会继续发送
  3. 在事件队列完结后,观察者不再继续接收任何事件(不再回调onNext)

7、Error事件

  1. 该事件表示:事件队列异常。
  2. 被观察者onError()后发送的事件依然会继续发送。
  3. 出现异常事件后,观察者不再继续接收任何事件(不再回调onNext)

8、在事件序列中Complete事件和Next事件两者互斥

Observer接口

9、通过Observer接口,创建观察者。

/**===========================
 * 创建观察者 (Observer )对象
 *   方式1:采用Observer 接口.
 *===========================*/
Observer<Integer> observer = new Observer<Integer>()
{
    // 1. 订阅事件
    @Override
    public void onSubscribe(Disposable d)
    {
        Log.d(TAG, "开始采用subscribe连接");
    }

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

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

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

Subscriber抽象类

10、通过Subscriber抽象类,创建观察者。

/**===========================
 * 创建观察者 (Observer )对象
 *   方式2:采用Subscriber 抽象类.
 *===========================*/
Subscriber<Integer> subscriber = new Subscriber<Integer>()
{
    // 1. 普通事件
    @Override
    public void onNext(Integer value)
    {
        Log.d(TAG, "对Next事件作出响应" + value);
    }

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

    // 3. 事件队列完结
    @Override
    public void onCompleted()
    {
        Log.d(TAG, "对Complete事件作出响应");
    }
};

两者的区别

11、Subscriber抽象类与Observer接口的区别

  1. 相同点:使用方式完全一致
    • 实质上,订阅过程中,Observer总是会先被转换成Subscriber再使用
  2. 不同点:Subscriber抽象类对 Observer 接口进行了扩展,新增了两个方法:
    1. onStart():在还未响应事件前调用,用于做一些初始化工作
    2. unsubscribe():用于取消订阅。在该方法被调用后,观察者将不再接收事件
      * 调用该方法前,先使用 isUnsubscribed() 判断状态

12、被观察者Observable会持有观察者Subscriber的引用,如果引用不能及时释放,就会出现内存泄露

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

13、通过订阅连接观察者和被观察者

observable.subscribe(observer);

14、实际上事件的发送时subscribe后发送。

函数式接口

1、RxJava2.0提供了多个函数式接口,用于便捷实现观察者模式

例如Consumber:

Observable.just("hello").subscribe(new Consumer<String>()
{
    @Override
    public void accept(String s) throws Exception
    {
        Log.d("accept", s);
    }
});

Disposable

1、Disposable的作用

  1. 可用Disposable.dispose()切断观察者与被观察者之间的连接.
  2. 切断之后,观察者不再接收事件,但被观察者还会继续发送Event
  3. isDisposed()返回为false的时候,接收器能正常接收事件,但当其为true的时候,接收器停止了接收。
/**===========================
   * 创建观察者 (Observer )对象
   *   方式1:采用Observer 接口.
   *===========================*/
  Observer<Integer> observer = new Observer<Integer>()
  {

      private Disposable mDisposable;

      // 1. 订阅事件
      @Override
      public void onSubscribe(Disposable d)
      {
          mDisposable = d;
      }

      // 2. 普通事件
      public void onNext(Integer value)
      {
          if(value == 10){
              mDisposable.dispose();
          }
      }
  };

参考资料

  1. Android Rxjava:这是一篇 清晰 & 易懂的Rxjava 入门教程
  2. 这可能是最好的RxJava 2.x 入门教程(二)

你可能感兴趣的:(Android,开源库,rxjava,Android,rxjava,rxandroid)