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 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  Observable toObservable (Class eventType) {
        return bus.ofType(eventType);
//        这里感谢小鄧子的提醒: ofType = filter + cast
//        return bus.filter(new Func1() {
//            @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() {
                     @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了，那是不是体积更小了。

至于用哪个，还是看个人喜好吧。。。