如何使用RxJava

Hello World:

如下hello world 的例子是用Java,Groovy、等语言实现的。从字符串列表中创建一个Observable 并且用一个打印每个被这个Observable发射的String的函数来订阅它。

你可以找到额外的例子在每个 language adaptor 文件夹下。

• RxGroovy examples
• RxClojure examples
• RxScala examples

Java

public static void hello(String... names) {
    Observable.from(names).subscribe(new Action1() {

        @Override
        public void call(String s) {
            System.out.println("Hello " + s + "!");
        }

    });
}
hello("Ben", "George");
Hello Ben!
Hello George!

Groovy

def hello(String[] names) {
    Observable.from(names).subscribe { println "Hello ${it}!" }
}
hello("Ben", "George")
Hello Ben!
Hello George!

如何用RxJava来设计

为了使用你创建Observables(发射数据项),转换这些Observables 通过不同的方式去获取你感兴趣的确切的数据条目，接着观测并且对这些感兴趣的条目序列做出反应（通过实现Observers或者Subscribers ，接着将它们订阅到所产生的转换后的Observables）

创建Observables

为了创建一个Observable， 你可以通过传入一个展示Observable的行为的函数来手动的实现Observable的行为或者你可以将现有的数据结构转换为一个Observable通过使用 some of the Observable operators that are designed for this purpose.（一些Observable操作符）

创建一个Observable从已有的数据结构:

你可以使用just()或者from()函数来将对象，列表或者数组转换为可发射这些对象的Observables：

Observable o = Observable.from("a", "b", "c");

def list = [5, 6, 7, 8]
Observable o = Observable.from(list);

Observable o = Observable.just("one object");

这些被转换的Observables 将同步的调用订阅他们的Subscriber的onNext()函数为每个被这些Observable发射的item，接着将会调用subscriber的onCompleted()函数。

创建一个Observable通过create()函数

通过设计你自己的Observable且用create() 函数来实现它，你可以实现异步i/o ，计算操作甚至无限的数据流。

同步Observable例子:

/**
 * This example shows a custom Observable that blocks 
 * when subscribed to (does not spawn an extra thread).
 */
def customObservableBlocking() {
    return Observable.create { aSubscriber ->
        50.times { i ->
            if (!aSubscriber.unsubscribed) {
                aSubscriber.onNext("value_${i}")
            }
        }
        // after sending all values we complete the sequence
        if (!aSubscriber.unsubscribed) {
            aSubscriber.onCompleted()
        }
    }
}

// To see output:
customObservableBlocking().subscribe { println(it) }

异步的Observable 例子:

如下的例子使用Groovy去创建一个发射75个字符串的Observable

以使示例更加清晰,它被写的很啰嗦，带有静态类型和Fun1匿名内部类的实现：

/**
 * This example shows a custom Observable that does not block
 * when subscribed to as it spawns a separate thread.
 */
def customObservableNonBlocking() {
    return Observable.create({ subscriber ->
        Thread.start {
            for (i in 0..<75) {
                if (subscriber.unsubscribed) {
                    return
                }
                subscriber.onNext("value_${i}")
            }
            // after sending all values we complete the sequence
            if (!subscriber.unsubscribed) {
                subscriber.onCompleted()
            }
        }
    } as Observable.OnSubscribe)
}

// To see output:
customObservableNonBlocking().subscribe { println(it) }

这是用Clojure同样的实现

(defn customObservableNonBlocking []
  "This example shows a custom Observable that does not block 
   when subscribed to as it spawns a separate thread.
   
  returns Observable"
  (Observable/create 
    (fn [subscriber]
      (let [f (future 
                (doseq [x (range 50)] (-> subscriber (.onNext (str "value_" x))))
                ; after sending all values we complete the sequence
                (-> subscriber .onCompleted))
        ))
      ))

如下是一个从WiKipedia获取文章的例子每一篇都调用onNext函数.

(defn fetchWikipediaArticleAsynchronously [wikipediaArticleNames]
  "Fetch a list of Wikipedia articles asynchronously.
  
   return Observable of HTML"
  (Observable/create 
    (fn [subscriber]
      (let [f (future
                (doseq [articleName wikipediaArticleNames]
                  (-> subscriber (.onNext (http/get (str "http://en.wikipedia.org/wiki/" articleName)))))
                ; after sending response to onnext we complete the sequence
                (-> subscriber .onCompleted))
        ))))

(-> (fetchWikipediaArticleAsynchronously ["Tiger" "Elephant"]) 
  (.subscribe #(println "--- Article ---\n" (subs (:body %) 0 125) "...")))

回到Groovy，同样的功能 但是使用闭包而不是匿名内部类:

/*
 * Fetch a list of Wikipedia articles asynchronously.
 */
def fetchWikipediaArticleAsynchronously(String... wikipediaArticleNames) {
    return Observable.create { subscriber ->
        Thread.start {
            for (articleName in wikipediaArticleNames) {
                if (subscriber.unsubscribed) {
                    return
                }
                subscriber.onNext(new URL("http://en.wikipedia.org/wiki/${articleName}").text)
            }
            if (!subscriber.unsubscribed) {
                subscriber.onCompleted()
            }
        }
        return subscriber
    }
}

fetchWikipediaArticleAsynchronously("Tiger", "Elephant")
    .subscribe { println "--- Article ---\n${it.substring(0, 125)}" }

结果：

--- Article ---
 


 ...
--- Article ---