Skip to content

Update How-To-Use-RxJava.md #28

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 18, 2016
Merged

Update How-To-Use-RxJava.md #28

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
62 changes: 31 additions & 31 deletions topics/How-To-Use-RxJava.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,8 @@

* [RxGroovy 示例](https://github.com/ReactiveX/RxGroovy/tree/1.x/src/examples/groovy/rx/lang/groovy/examples)
* [RxClojure 示例](https://github.com/ReactiveX/RxClojure/tree/0.x/src/examples/clojure/rx/lang/clojure/examples)
* [RxScala 示例](https://github.com/ReactiveX/RxScala/tree/0.x/examples/src/main/scala)

* [RxScala 示例](https://github.com/ReactiveX/RxScala/tree/0.x/examples/src/main/scala)
下面的示例从一个字符串列表创建一个Observable，然后使用一个方法订阅这个Observable。

### Java
Expand Down Expand Up @@ -76,16 +76,16 @@ Hello George!
```

# 如何使用RxJava

要使用RxJava，首先你需要创建Observable（它们发射数据序列），使用Observable操作符变换那些Observables，获取严格符合你要求的数据，然后观察并处理对这些数据序列（通过实现观察者或订阅者，然后订阅变换后的Observable）。

## 创建Observables

要创建Observable，你可以手动实现Observable的行为，也可以传递一个函数给[`create( )`](../operators/Create.md)，还可以使用这些 [创建操作符](../operators/Creating-Observables.md) 将一个已有的数据结构转换为Observable。

### 已有的数据结构创建Observable

你可以使用[`just( )`](../operators/Just.md) 和[`from( )`](../operators/From.md) 方法将对象，列表，对象属猪转换为发射那些对象的Observable：
你可以使用[`just( )`](../operators/Just.md) 和[`from( )`](../operators/From.md) 方法将对象，列表，对象属性转换为发射那些对象的Observable：

```java
Observable<String> o = Observable.from("a", "b", "c");
Expand All @@ -95,7 +95,7 @@ Observable<Integer> o = Observable.from(list);

Observable<String> o = Observable.just("one object");
```

转换后的Observable每发射一项数据，会同步地调用任何订阅者的[`onNext()`](../Observables.md#回调方法)方法，最后会调用订阅者的[`onCompleted()`](../Observables.md#回调方法)方法。

### 使用`create( )`创建一个Observable
Expand All @@ -105,7 +105,7 @@ Observable<String> o = Observable.just("one object");
#### 同步的Observable示例

```groovy
/**
/**
* 这个例子展示了一个自定义的Observable，当有订阅时他会阻塞当前线程。
*/
def customObservableBlocking() {
Expand All @@ -128,9 +128,9 @@ customObservableBlocking().subscribe { println(it) }

#### 异步的Observable示例

The following example uses Groovy to create an Observable that emits 75 strings.
The following example uses Groovy to create an Observable that emits 75 strings.
下面的例子使用`Groovy`创建了一个发射75个字符串的Observable。

为了让它更清楚，例子很详细，使用静态类型和匿名内部类`Func1`：

```groovy
Expand Down Expand Up @@ -158,7 +158,7 @@ def customObservableNonBlocking() {
// To see output:
customObservableNonBlocking().subscribe { println(it) }
```

这是一个用`Clojure`写的例子，使用Future（而不是直接用线程），实现很简洁：

```clojure
Expand All @@ -181,7 +181,7 @@ customObservableNonBlocking().subscribe { println(it) }
; To see output
(.subscribe (customObservableNonBlocking) #(println %))
```

这个例子从维基百科网站抓取文章，每抓取一篇会调用一次`onNext`：

```clojure
Expand All @@ -203,7 +203,7 @@ customObservableNonBlocking().subscribe { println(it) }
(-> (fetchWikipediaArticleAsynchronously ["Tiger" "Elephant"])
(.subscribe #(println "--- Article ---\n" (subs (:body %) 0 125) "...")))
```

回到`Groovy`，同样是从维基百科抓取文章，这儿使用闭包代替匿名内部类：

```groovy
Expand Down Expand Up @@ -248,18 +248,18 @@ fetchWikipediaArticleAsynchronously("Tiger", "Elephant")

Note that all of the above examples ignore error handling, for brevity. See below for examples that include error handling.

More information can be found on the [[Observable]] and [[Creating Observables|Creating-Observables]] pages.

注意：为了简洁，上面的所有例子都忽略了错误处理，查看下面包含错误处理的例子。

More information can be found on the [[Observable]] and [[Creating Observables|Creating-Observables]] pages.
注意：为了简洁，上面的所有例子都忽略了错误处理，查看下面包含错误处理的例子。
更多的信息可以在这里找到：[`Observable`](Observables.md) 和 [`Creating Observables`](../operators/Creating-Observables.md)。

## 使用变换操作

RxJava让你可以链式使用`操作符`用来转换和组合多个Observables。

The following example, in Groovy, uses a previously defined, asynchronous Observable that emits 75 items, skips over the first 10 of these ([`skip(10)`](http://reactivex.io/documentation/operators/skip.html)), then takes the next 5 ([`take(5)`](http://reactivex.io/documentation/operators/take.html)), and transforms them ([`map(...)`](http://reactivex.io/documentation/operators/map.html)) before subscribing and printing the items:

The following example, in Groovy, uses a previously defined, asynchronous Observable that emits 75 items, skips over the first 10 of these ([`skip(10)`](http://reactivex.io/documentation/operators/skip.html)), then takes the next 5 ([`take(5)`](http://reactivex.io/documentation/operators/take.html)), and transforms them ([`map(...)`](http://reactivex.io/documentation/operators/map.html)) before subscribing and printing the items:
下面是一个`Groovy`的例子，使用之前的定义，它会异步发射75个字符串，跳过最开始的10个（([`skip(10)`](../operators/Skip.md)），然后获取接下来的5个（[`take(5)`](../operators/Taks.md)），在订阅之前使用[`map()`](../operators/Map.md)转换它们，然后打印结果字符串。

```groovy
Expand All @@ -283,11 +283,11 @@ onNext => value_12_xform
onNext => value_13_xform
onNext => value_14_xform
```

这里有一个图例解释了转换过程：

<img src="../images/operators/Composition.1.png" width="640" height="536" />

这一个例子使用`Clojure`，使用了三个异步的Observable，其中一个依赖另一个，使用[`zip`](../operators/Zip.md)组合这三个发射的数据项为一个单个数据项，最后使用[`map()`](../operators/Map.md)转换这个结果：

```clojure
Expand Down Expand Up @@ -331,13 +331,13 @@ onNext => value_14_xform
:director David Fincher, :duration 3365},
:user-id 12345, :language es-us, :bookmark 0}
```

这里有一个图例解释了这个过程：

<img src="../images/operators/Composition.2.png" width="640" height="742" />

The following example, in Groovy, comes from [Ben Christensen’s QCon presentation on the evolution of the Netflix API](https://speakerdeck.com/benjchristensen/evolution-of-the-netflix-api-qcon-sf-2013). It combines two Observables with the [`merge`](http://reactivex.io/documentation/operators/merge.html) operator, then uses the [`reduce`](http://reactivex.io/documentation/operators/reduce.html) operator to construct a single item out of the resulting sequence, then transforms that item with [`map`](http://reactivex.io/documentation/operators/map.html) before emitting it:

The following example, in Groovy, comes from [Ben Christensen’s QCon presentation on the evolution of the Netflix API](https://speakerdeck.com/benjchristensen/evolution-of-the-netflix-api-qcon-sf-2013). It combines two Observables with the [`merge`](http://reactivex.io/documentation/operators/merge.html) operator, then uses the [`reduce`](http://reactivex.io/documentation/operators/reduce.html) operator to construct a single item out of the resulting sequence, then transforms that item with [`map`](http://reactivex.io/documentation/operators/map.html) before emitting it:
下面的例子使用`Groovy`，来自这里 [Ben Christensen’s QCon presentation on the evolution of the Netflix API](https://speakerdeck.com/benjchristensen/evolution-of-the-netflix-api-qcon-sf-2013)，它使用[`merge`](../operators/Merge.md)操作结合两个Observables，使用[`reduce`](../operators/Reduce.md)操作符从结果序列构建一个单独的结果数据项，然后在发射之前，使用[`map()`](../operators/Map.md)变换那个结果。

```groovy
Expand All @@ -350,13 +350,13 @@ public Observable getVideoSummary(APIVideo video) {
.map({ [(video.id.toString() : it] }))
}
```

这里也有一个图例解释[`reduce`](../operators/Reduce.md)从多个Observable的结果构建一个单一结构的过程：

<img src="../images/operators/Composition.3.png" width="640" height="640" />
<img src="../images/operators/Composition.3.png" width="640" height="640" />

## 错误处理

这里是另一个版本的维基百科的例子，包含错误处理代码：

```groovy
Expand Down Expand Up @@ -386,7 +386,7 @@ def fetchWikipediaArticleAsynchronouslyWithErrorHandling(String... wikipediaArti
});
}
```

下面的例子使用`Groovy`，注意错误发生时现在是如何调用[`onError(Throwable t)`](Observables.md#回调函数)的，下面的代码传递给[`subscribe()`](../operators/Subscribe.md)第二个方法用户处理`onError`通知：

```groovy
Expand All @@ -396,7 +396,7 @@ fetchWikipediaArticleAsynchronouslyWithErrorHandling("Tiger", "NonExistentTitle"
{ println "--- Error ---\n" + it.getMessage() })
```


查看 [`错误处理操作符`](../operators/Error-Handling-Operators.md) 这一夜了解更多RxJava中的错误处理技术，包括使用 [`onErrorResumeNext()`和`onErrorReturn()`](../operators/Catch.md)等方法，它们让你可以从错误中恢复。

这里是一个`Groovy`的例子：
Expand All @@ -406,4 +406,4 @@ myModifiedObservable = myObservable.onErrorResumeNext({ t ->
Throwable myThrowable = myCustomizedThrowableCreator(t);
return (Observable.error(myThrowable));
});
```
```