Android开发 之——利用RxBus实现数据更新

以前我们要想在activity或fragment之间传递信息，我们会通过onActvityResult接收信息。但是这样有一个缺点，一个是代码量太大，重复率太高。二是有时候传递的数据需要经过几个界面的跳转。加入从A->B->C，C界面修改了某些信息，同时，想在A界面进行界面的刷新。那么通过onActvityResult的话很难操作。还有就是，加入从A->B，B传递信息给A界面。以往通过onActvityResult，我们需要在B界面关闭的时候，A界面才能拿到数据，再进行局部刷新，这样的话，A界面很可能会闪烁（数据刷新）。这样的话用户体验感就很差了。那么现在，我们可以怎么做呢。

首先，大家最好先了解一下Rxjava，下面是简单的介绍：

RxJava 是 ReactiveX 在 Java 上的开源的实现。Observable（观察者） 和 Subscriber（订阅者）是两个主要的类。在 RxJava 上，一个 Observable 是一个发出数据流或者事件的类，Subscriber 是一个对这些发出的 items （数据流或者事件）进行处理（采取行动）的类。一个 Observable 的标准流发出一个或多个 item，然后成功完成或者出错。一个 Observable 可以有多个 Subscribers，并且通过 Observable 发出的每一个 item，该 item 将会被发送到 Subscriber.onNext() 方法来进行处理。一旦 Observable 不再发出 items，它将会调用 Subscriber.onCompleted() 方法，或如果有一个出错的话 Observable 会调用 Subscriber.onError() 方法。

首先，附上rxjava/rxandroid的链接，或者直接到github搜索查看最新版本链接 rxBus的使用必须依赖 rxJava 和 exAndroid

compile 'io.reactivex:rxjava:1.1.0'compile 'io.reactivex:rxandroid:1.1.0'

废话不多说，直接附上RxBus的代码
public class RxBus {    private static volatile RxBus defaultInstance;    private final Subject<Object, Object> bus;    // PublishSubject只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者    public RxBus() {        bus = new SerializedSubject<>(PublishSubject.create());    }    // 单例RxBus    public static RxBus getDefault() {        if (defaultInstance == null) {            synchronized (RxBus.class) {                if (defaultInstance == null) {                    defaultInstance = new RxBus();                }            }        }        return defaultInstance ;    }    // 发送一个新的事件    public void post (Object o) {        bus.onNext(o);    }    // 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者    public <T> Observable<T> toObservable (Class<T> eventType) {        return bus.ofType(eventType);//        这里感谢小鄧子的提醒: ofType = filter + cast//        return bus.filter(new Func1<Object, Boolean>() {//            @Override//            public Boolean call(Object o) {//                return eventType.isInstance(o);//            }//        }) .cast(eventType);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
代码很简单，先创建一个单例的Rxbus对象，然后可以通过post发出一个事件，发起者作为一个被观察者。或者通过toObservable观察一个事件。
这里解释一下rxjava一般来说有三种动作:onNext,onComplete,OnError.分别对应接下来的动作，还有完成时的动作，出错时的动作。
public Observable toObservable (Class eventType) 
这里通过泛型传入一个对象，然后对这个对象进行观察。
那现在可以通过代码来介绍一下如何发起一个事
public class User {    private String username;    private String password;    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }    public User(String username, String password) {        this.username = username;        this.password = password;    }}User user = new User("潘锐杰","123456");RxBus.getDefault().post(user);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
首先，我们要新建一个User对象，作为我们所要发出去的数据。 
然后new出一个对象，通过RxBus.getDefault().post();将数据发出去，那么此时，对这个事件订阅的，就会接收到一个通知。其实rxjava就是观察者模式的一个实现。
那么，我们看看怎么接收到数据，代码如下：
RxBus.getDefault().toObservable(InvitationMessage.class)                //在io线程进行订阅，可以执行一些耗时操作                .subscribeOn(Schedulers.io())                //在主线程进行观察，可做UI更新操作                .observeOn(AndroidSchedulers.mainThread())                //观察的对象                .subscribe(user->{                    //获取到了一个对象，user                 Toast.makeText(this,user.getUsername(),Toast.LENGTH_SHORT).show();                });
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
观察对象的时候我使用了lambda表达式进行简写，这是JAVA8的新特性，有兴趣的可以去了解一下，还有一些操作符，如map，flatmap，filter，zip等操作，这里就不做演示了。
这里的代码效果和上面的代码是一样的，如果使用了java8的朋友，在new Action1() 这里按一下ALT+ENTER，就可以进行简化代码。
 RxBus.getDefault().toObservable(InvitationMessage.class)                //在io线程进行订阅，可以执行一些耗时操作                .subscribeOn(Schedulers.io())                 //在主线程进行观察，可做UI更新操作                 .observeOn(AndroidSchedulers.mainThread())                 //观察的对象                .subscribe(new Action1<User>() {                     @Override                     public void call(User user) {                Toast.makeText(this,user.getUsername(),Toast.LENGTH_SHORT).show();                     }                 });
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
有人说，那这样的话，rxbus跟eventBus做的东西不就一样了吗？那直接用eventBus不就好了。
Rx：函数响应式编程，EventBus：事件总线 
RxJava 主要做异步、网络的数据处理，强大之处就是数据的处理了，而对于处理完后的数据处理是一样的都是观察者模式来通知 ，通过操作符可以执行链式调用，代码清晰。 
结合retrofit2，做网络请求的话，可以让网络请求变的十分优雅，当然，使用RxJava那就不用导入eventbus了，那是不是体积更小了。
至于用哪个，还是看个人喜好吧。。。