RxJava2在Android中的使用之一 ----- 创建Observable

前言

既然RxJava是基于观察者模式，那么就需要我们操作观察者(Observer)和被观察者(Observable)，那么怎么创建Observable便是第一步。

创建Observable操作符

• just()：创建一个直接发射数据的Observable
• from()：从一个数组或列表中转换成Observable
• create()：创建一个Observable
• defer()：当订阅者订阅时才创建Observable，为每一个订阅创建一个新的Observable
• range()：创建一个指定范围的序列Observable
• interval()：创建一个按照规定时间间隔发射数据的Observable
• timer()：延时发射数据的Observable
• empty()：直接完成的Observable
• error()：直接发射错误的Observable
• never()：不发射数据的Observable

just()

    // 发射数据
    Observable.just("abc")
              .subscribe({
               JLog.d("onNext:$it")
              }, {
                  JLog.d("onError:$it")
              }, {
                  JLog.d("onComplete")
              }, {
                  JLog.d("onSubscribe")
              })

打印：

 onSubscribe
 onNext:abc
 onComplete

当然，你可以使用Just发射一组数据：

Observable.just("1", "2", "3", "4", "5")
          .subscribe({
               JLog.d("onNext:$it")
           }, {
               JLog.e("onError:$it")
           }, {
               JLog.d("onComplete")
           }, {
               JLog.d("onSubscribe")
           })

打印：

    onSubscribe
    onNext:1
    onNext:2
    onNext:3
    onNext:4
    onNext:5
    onComplete

From()

当你使用Just发射一组数据时，你会发现它和From很相似：

Observable.fromArray("a", "b", "c")
          .subscribe({
              JLog.d(it)
          })
val items = arrayListOf("1", "2", "3")
Observable.fromIterable(items)
        .subscribe({
            JLog.d(it)
        })

打印：

    a
    b
    c
    1
    2
    3

create()

Observable.create(ObservableOnSubscribe<Int> {
          try
          {
              if (!it.isDisposed)
              {
                  for (i in 0..5)
                  {
                      it.onNext(i)
                  }
                  it.onComplete()
              }
          } catch (e: Exception)
          {
              it.onError(e)
          }
      }).subscribe({
          JLog.d("onNext->$it")
      }, {
          JLog.e("onError->$it")
      }, {
          JLog.d("onComplete")
      }, {
          JLog.d("onSubscribe")
      })      

打印：

    onSubscribe
    onNext->0
    onNext->1
    onNext->2
    onNext->3
    onNext->4
    onNext->5
    onComplete     

Defer()

defer操作符，直到有订阅者订阅它的时候，它才会创建一个Observable，以确保获取的数据是最新的

 var a = 1
 val defer = Observable.defer {
     Observable.just(a)
 }
 val just = Observable.just(a)
 a++
 just.subscribe({ JLog.d("just:" + it.toString()) })
 defer.subscribe({
     JLog.d("defer:" + it.toString())
 })

我在a=1的时候用defer和just分别创建了一个Observable，在a++之后才消费他们，首先看一下结果：

just:1
defer:2

可以看到，just在创建的时候发射数据已经确定，而defer在有订阅的时候才会创建Observable，保证了a是最新值

Timer()

延时操作符，默认在computation调度器上执行，会在延时一段时间后发射数据

Observable.timer(2, TimeUnit.SECONDS)
         .subscribe(object : Observer<Long>
          {
              override fun onComplete()
              {
              }

              override fun onSubscribe(d: Disposable)
              {
                  JLog.d("onSubscribe")
              }

              override fun onNext(t: Long)
              {
                  JLog.d("onNext")
                  JLog.d("onNext发射结果:$t")
              }

              override fun onError(e: Throwable)
              {
                  JLog.e(e.toString())
              }
          })

打印结果：

10-15 17:40:22.734 19180-19180/com.jzd.jutils.app D/JLog: onSubscribe
10-15 17:40:24.735 19180-19627/com.jzd.jutils.app D/JLog: onNext
            onNext发射结果:0

timer在延时2s后反射了一个0

Interval()

间隔操作符，默认在computation调度器上执行，会在固定时间间隔后发射数据

 Observable.interval(1, TimeUnit.SECONDS)
           .subscribe({ JLog.d(it.toString()) })

打印结果

10-15 17:44:15.022 21811-21902/com.jzd.jutils.app D/JLog: 0
10-15 17:44:16.021 21811-21902/com.jzd.jutils.app D/JLog: 1
10-15 17:44:17.021 21811-21902/com.jzd.jutils.app D/JLog: 2
10-15 17:44:18.021 21811-21902/com.jzd.jutils.app D/JLog: 3
10-15 17:44:19.021 21811-21902/com.jzd.jutils.app D/JLog: 4
10-15 17:44:20.021 21811-21902/com.jzd.jutils.app D/JLog: 5

interval也有3个参数的创建方法interval(long initialDelay, long period, TimeUnit unit)先指定延时时间，然后再轮询发送。。。不过，如果你第一次用interval，你会发现这样写，interval创建的发射器根本停不下来啊，有木有~坑爹啊。所以正确的操作方式应该是这样的：

Observable.intervalRange(10, 5, 1, 1, TimeUnit.SECONDS)
          .subscribe({ JLog.d(it.toString()) })

对应的方法就是intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)

Repeat

Repeat操作符可以配合创建操作符使用，在创建时配置重复策略
使用repeat重复发射一组数据

Observable.just("1", "2", "3")
           .repeat(2)
           .subscribe({ JLog.d(it) })

打印

    1
    2
    3
    1
    2
    3

使用repeatWhen

Observable.just("1")
           .repeatWhen { Observable.timer(3, TimeUnit.SECONDS) }.subscribe({ JLog.d(it) })
JLog.d("---------------------------")

打印

10-15 19:49:01.646 5814-5814/com.jzd.jutils.app D/JLog: 1
    ---------------------------
10-15 19:49:04.646 5814-6133/com.jzd.jutils.app D/JLog: 1

可以看到3秒后重复发送了一次数据
使用repeatUntil

var count = 0
Observable.just("测试")
        .repeatUntil { count >= 5 }
        .subscribe({
            JLog.d("第${count++}次：$it")
        })

打印结果：

第0次：测试
第1次：测试
第2次：测试
第3次：测试
第4次：测试

可以看到，repeatUntil(BooleanSupplier stop)中，当getAsBoolean返回false时会重复发射数据，当返回true时，会终止发射数据。
常用的创建操作符基本介绍完了，使用这些操作符，我们就可以愉快的创建各式各样的Observable了。