RxJava初体验

末蓝、 2023-10-16 22:34 27阅读 0赞

## 参考文章 ##

[http://www.cnblogs.com/halzhang/p/4458095.html][http_www.cnblogs.com_halzhang_p_4458095.html]  
[http://www.tuicool.com/articles/MjyaUfq][http_www.tuicool.com_articles_MjyaUfq]  
[http://www.tuicool.com/articles/VrQRvur][http_www.tuicool.com_articles_VrQRvur]  
[http://blog.csdn.net/lzyzsd/article/details/41833541][http_blog.csdn.net_lzyzsd_article_details_41833541]

#### RxJava的Guihub地址 ####

[https://github.com/ReactiveX/RxJava][https_github.com_ReactiveX_RxJava]

## 添加依赖 ##

首先，需要在Android Studio中添加依赖

dependencies {
        compile 'io.reactivex:rxjava:1.0.15'
    }

## 响应式编程 ##

响应式编程的主要组成部分是observable, operator和susbscriber。一般响应式编程的信息流 : Observable -> Operator 1 -> Operator 2 -> Operator 3 -> Subscriber。  
因为subscriber通常在主线程中执行，因此设计上要求其代码尽可能简单，只对事件进行响应，而修改事件的工作全部由operator执行。

### Observable (被观察者，事件源) ###

消息的发送是有固定模式的。Observable可以发送任意数量的消息（包括空消息），当消息被成功处理或者出错时，流程结束。Observable会调用它的每个Subscriber的Subscriber.onNext()函数，并最终以Subscriber.onComplete()或者Subscriber.onError()结束。

### Subscriber （观察者） ###

Subscriber有3个需要实现的方法

#### onNext:当顺利执行时执行 ####

#### onCompleted:当执行完毕时 ####

*  你能够知道什么时候订阅者已经接收了全部的数据。

#### onError:当出现错误时执行 ####

*  只要有异常发生onError()一定会被调用  
    极大的简化了错误处理。只需要在一个地方处理错误即可以。
 *  操作符不需要处理异常  
    将异常处理交给订阅者来做，Observerable的操作符调用链中一旦有一个抛出了异常，就会直接执行onError()方法。

## Operators(操作符) ##

Operators可以在最终的Subscriber和Observable之间进行修改数据  
以下列出基本的操作符

### **create** ###

#### 作用 ####

创建一个基础的Observable对象，可执行onNext，onCompleted操作。

#### 调用 ####

此时，onNext，onCompleted必须主动调用，否则不会生效。而onStart等重写的方法，是会被主动调用的，无需自己调用。

#### 代码 ####

##### 创建一个Observable（被观察者，事件源） #####

Observable observable = Observable.create(new    Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    subscriber.onNext("hello world!");
                    subscriber.onCompleted();
                }
     });

##### 然后需要创建一个Subscribers（观察者） #####

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onStart() {
                super.onStart();
                Log.i(TAG, "start");
            }
    
            @Override
            public void onCompleted() {
                Log.i(TAG, "completed");
            }
    
            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "error:" + e.getMessage());
            }
    
            @Override
            public void onNext(String s) {
                Log.i(TAG, "s:" + s);
            }
        };

##### 关联Observable和Subscriber #####

我们可以使用subscribe方法很方便的进行关联，进行关联后就会进行执行。

observable.subscribe(subscriber);

##### 输出结果 #####

start
    s:hello world!
    completed

### **just** ###

#### 作用 ####

创建只发出一个事件就结束的Observable对象，可传递多个参数，将按照参数的顺序遍历执行。

#### 调用 ####

此时，Observable将自动调用onNext和OnonCompleted

#### 代码 ####

修改Observable 的代码，将其改为使用just

Observable observable = Observable.just("hello world!");

#### 输出结果 ####

start
    s:hello world!
    completed

什么？没发现什么变化？那再来增加一个参数

Observable observable = Observable.just("hello world!", "good job!");

#### 输出结果 ####

start
    s:hello world!
    s:good job!
    Completed

just，可以接受多个参数，并逐个输出，并且可以极大化的简化代码。

### **from** ###

#### 作用 ####

接收一个数组或集合或可变参数数组，然后逐个遍历输出。

#### 调用 ####

此时，Observable将自动调用onNext和OnonCompleted

#### 代码 ####

改变Observable 的代码，将其改为使用from

List list = new ArrayList();
        list.add("hello world!");
        list.add("good job!");
        Observable observable = Observable.from(list);

#### 输出结果 ####

start
    s:hello world!
    s:good job!
    Completed

在输入的参数是一个集合、数组或可变参数时，就可以使用from，非常方便!

### **subscribe方法** ###

#### 作用 ####

关联Subscriber 和Observable，进行关联后就会被执行。

observable.subscribe(subscriber);

从上面的代码中我们可以知道，subscribe方法可以关联Subscriber 和Observable，但如果有时并不想把这subscriber的三个实现方法都实现时，我们就可以使用subscribe的另一个重载了。

observable.subscribe(onNextAction, onErrorAction, onCompleteAction);

比如，我们不关心OnComplete和OnError，只想使用onNext，那么就可以使用

observable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "s:" + s);
            }
        });

#### 输出结果 ####

s:hello world!
    s:good job!

### **map** ###

#### 作用 ####

用于改变Observable对象，返回一个新的Observable对象

#### 代码 ####

在Observable和Subscriber之间增加以下代码

observable = observable.map(new Func1() {
            @Override
            public Object call(Object o) {
                return o + " 增加的数据~";
            }
        });

#### 输出结果 ####

start
    s:hello world! 增加的数据~
    s:good job! 增加的数据~
    completed

并且，map还可以改变返回的Observable的泛型类型，比如，我们现在想要返回参数的hashcode，就可以这样干

observable = observable.map(new Func1() {
            @Override
            public Object call(Object o) {
                return o.hashCode();
            }
    });

但是我们最后的Subscriber是String类型的泛型，当然也可以将Subscriber的泛型修改为 Object类型，然后在call方法中toString，但Subscriber方法做得事情越少越好，所以，我们再添加一个map

observable = observable.map(new Func1() {
            @Override
            public Object call(Object o) {
                return o.toString();
            }
        });

#### 输出结果 ####

start
    s:-217287203
    s:1318599047
    completed

### **flatMap** ###

#### 作用 ####

和Map的作用相同:用于改变Observable对象，返回一个新的Observable对象，区别在于map的返回值后会自动包装一层Observable，而flatmap返回值不会自动包装Observable

#### 比如 ####

//都是从Observable<String>转为Observable<String>，其中的区别
        observable = Observable.just("hello world!").map(new Func1() {
            @Override
            public Object call(Object o) { //o 是 String类型
                return o+"增加的数据"; //会自动包装Observable，此处直接返回String对象
            }
        });
    
        observable = Observable.just("hello world!").flatMap(new Func1() {
            @Override
            public Object call(Object o) { // o 是 String类型
                return Observable.just(o+""增加的数据""); //不会自动包装Observable，此处需自己返回一个Observable<String>对象
            }
        });

#### 意义 ####

如果输入是一个Observable<List>、Observable<数组>等，就显得非常有用了，直接可以输出为Observable<String>

#### 代码 ####

//修改Observable 的代码，将其改为使用flatMap，(通过Observable.just(list)可以得到一个Observable<List>对象)
    
     observable = Observable.just(list).flatMap(new Func1<List, Observable<?>>() {
            @Override
            public Observable<?> call(List list) {
                return Observable.from(list);
            }
        });

#### 输出结果 ####

start
     s:hello world!
    s:good job!
    completed

### **filter** ###

#### 作用 ####

过滤指定的数据

#### 代码 ####

增加list的数据

list.add(null);
        list.add("4");

我们修改Observable的代码，将其改为使用filter

observable = observable.filter(new Func1() {
            @Override
            public Object call(Object o) {
                return o != null;
            }
        });

#### 输出结果 ####

start
    s:hello world!
    s:good job!
    s:4
     completed

### **take** ###

#### 作用 ####

输出最多指定数量的结果

#### 代码 ####

增加take的代码，指定其只输出一个

observable = observable.take(1);

#### 输出结果 ####

start
    s:hello world!
    completed

这篇文章这样的写法只是为了理解起来比较方便，但真正要用起来代码还是太臃肿了，有关RxJava中多线程的使用、链式调用、lambda表达式的使用将在下篇文章中使用。

[相关代码在这里][Link 1]

[http_www.cnblogs.com_halzhang_p_4458095.html]: http://www.cnblogs.com/halzhang/p/4458095.html
[http_www.tuicool.com_articles_MjyaUfq]: http://www.tuicool.com/articles/MjyaUfq
[http_www.tuicool.com_articles_VrQRvur]: http://www.tuicool.com/articles/VrQRvur
[http_blog.csdn.net_lzyzsd_article_details_41833541]: http://blog.csdn.net/lzyzsd/article/details/41833541
[https_github.com_ReactiveX_RxJava]: https://github.com/ReactiveX/RxJava
[Link 1]: http://download.csdn.net/detail/ethanco/9259087