打造属于自己的RxBus

最新推荐文章于 2019-07-26 17:49:28 发布
最新推荐文章于 2019-07-26 17:49:28 发布
阅读量334 收藏
点赞数
分类专栏： android学习 Retrofit RxJava RxBus 文章标签： RxBus RxJava

RxBus

通过RxJava实现Rxbus。

相信大家已经非常熟悉EventBus了。最近正在学习Rxjava，如果在项目中已经使用了Rxjava，使用RxBus来代替EventBus应该是不错的选择。

RxJava最核心的两个东西是Observables（被观察者，事件源）和Subscribers（观察者）。Observables发出一系列事件，Subscribers处理这些事件。

RxBus工作原理

直接看代码

Note that it is important to subscribe to the exact same rxBus instance that was used to post the events

采用单例模式来保证rxBus对象一致

public class RxBus {

    private static RxBus rxBus;
    private final Subject<Object, Object> _bus = new SerializedSubject<>(PublishSubject.create());

    private RxBus() {
    }

    public static RxBus getInstance() {
        if (rxBus == null) {
            synchronized (RxBus.class) {
                if (rxBus == null) {
                    rxBus = new RxBus();
                }
            }
        }
        return rxBus;
    }


    public void send(Object o) {
        _bus.onNext(o);
    }

    public Observable<Object> toObserverable() {
        return _bus;
    }
}

Activity中发送事件

public void sendTap(View view){   
         RxBus.getInstance().send(new TapEvent());
}

public void sendOther(View view){
        RxBus.getInstance().send(new OtherEvent());
}

Fragment中接收事件

 RxBus.getInstance().toObserverable()
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        if (o instanceof TapEvent) {
                            textView.setText("tap");
                        } else if (o instanceof OtherEvent) {
                            textView.setText("other");
                        }
                    }
                });

效果


效果图

以上就是使用Rxjava简单实现RxBus的功能，当然这还远远不够

RxBus升级

在具体使用过程中总会碰到各种各样的问题

场景1
我在上一个项目中实现了无限轮播的功能，并且希望轮播图在用户滑动、不可见、以及程序在后台休眠时都停止滚动，这时候就希望EventBus及时的传递这3种状态，为此我需要写slideEvent、visibleEvent、aliveEvent3个类，虽然他们都需要传递一个简单的Boolen值。

解决方案
创建一个Event“管家”
类似key－value的方式，每个事件都有自己的唯一的Code，接收事件时根据Code返回对应的content

public class Events<T> {

    //所有事件的CODE
    public static final int TAP = 1; //点击事件
    public static final int OTHER = 21; //其它事件

    //枚举
    @IntDef({TAP, OTHER})
    @Retention(RetentionPolicy.SOURCE)
    public @interface EventCode {}


    public @Events.EventCode int code;
    public T content;

    public static <O> Events<O> setContent(O t) {
        Events<O> events = new Events<>();
        events.content = t;
        return events;
    }

    public <T> T getContent() {
        return (T) content;
    }

}

场景2
怎么又内存泄漏了？

每个人在开发过程中，或多或少都会碰到内存泄漏的的问题，我一直有一个天真的想法，RxJava那么牛逼，是不是能无声无息地就能解决内存泄漏的问题了，答案是否定的。

我看了不少有关RxJava的文章，都会提到
一定要记得在生命周期结束的地方取消订阅事件，防止RxJava可能会引起的内存泄漏问题。

你可以

@Overrideprotected void onDestroy() { 
        super.onDestroy(); 
        if(!rxSubscription.isUnsubscribed()) {     
            rxSubscription.unsubscribe();
         }
}

又或者

使用CompositeSubscription把 Subscription 收集到一起，方便 Activity（基类） 销毁时取消订阅，防止内存泄漏。

前者可以在任一生命周期阶段取消订阅，缺点是每个acivity/fragment都要重写方法。

后者可以写在BaseActivity（大家都不会陌生），每个activity都能用，缺点是不够灵活。

以上两种方法似乎都欠缺点意思，所幸Rx家族”人丁兴旺“，早已想好了解决方案
RxLifecycle

一、bindToLifecycle()方法
在子类使用Observable中的compose操作符，调用，完成Observable发布的事件和当前的组件绑定，实现生命周期同步。从而实现当前组件生命周期结束时，自动取消对Observable订阅。

 Observable.interval(1, TimeUnit.SECONDS)
        .compose(this.bindToLifecycle())
            .subscribe(new Action1<Long>() { 
                @Override
                public void call(Long num) {
                    Log.i(TAG, "  " +num);
                }
            });

二、bindUntilEvent() 方法
使用ActivityEvent类，其中的CREATE、START、 RESUME、PAUSE、STOP、 DESTROY分别对应生命周期内的方法。使用bindUntilEvent指定在哪个生命周期方法调用时取消订阅。

public enum ActivityEvent {

    CREATE,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY

}
public enum FragmentEvent {

    ATTACH,
    CREATE,
    CREATE_VIEW,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY_VIEW,
    DESTROY,
    DETACH

}

组装零件

public class RxBus {

    private static RxBus rxBus;
    private final Subject<Events<?>, Events<?>> _bus = new SerializedSubject<>(PublishSubject.<Events<?>>create());

    private RxBus(){}

    public static RxBus getInstance(){
        if (rxBus == null){
            synchronized (RxBus.class){
                if (rxBus == null){
                    rxBus = new RxBus();
                }
            }
        }
        return rxBus;
    }

    public void send(Events<?> o) {
        _bus.onNext(o);
    }

    public void send(@Events.EventCode int code, Object content){
        Events<Object> event = new Events<>();
        event.code = code;
        event.content = content;
        send(event);
    }

    public Observable<Events<?>> toObservable() {
        return _bus;
    }

    public static SubscriberBuilder with(FragmentLifecycleProvider provider){
        return new SubscriberBuilder(provider);
    }

    public static SubscriberBuilder with(ActivityLifecycleProvider provider){
        return new SubscriberBuilder(provider);
    }


    public static class SubscriberBuilder{

        private FragmentLifecycleProvider mFragLifecycleProvider;
        private ActivityLifecycleProvider mActLifecycleProvider;
        private FragmentEvent mFragmentEndEvent;
        private ActivityEvent mActivityEndEvent;
        private int event;
        private Action1<? super Events<?>> onNext;
        private Action1<Throwable> onError;

        public SubscriberBuilder(FragmentLifecycleProvider provider) {
            this.mFragLifecycleProvider = provider;
        }

        public SubscriberBuilder(ActivityLifecycleProvider provider){
            this.mActLifecycleProvider = provider;
        }

        public SubscriberBuilder setEvent(@Events.EventCode int event){
            this.event = event;
            return this;
        }

        public SubscriberBuilder setEndEvent(FragmentEvent event){
            this.mFragmentEndEvent = event;
            return this;
        }

        public SubscriberBuilder setEndEvent(ActivityEvent event){
            this.mActivityEndEvent = event;
            return this;
        }

        public SubscriberBuilder onNext(Action1<? super Events<?>> action){
            this.onNext = action;
            return this;
        }

        public SubscriberBuilder onError(Action1<Throwable> action){
            this.onError = action;
            return this;
        }


        public void create(){
            _create();
        }

        public Subscription _create(){
            if (mFragLifecycleProvider!=null){
                return RxBus.getInstance().toObservable()
                        .compose(mFragmentEndEvent == null ? mFragLifecycleProvider.bindToLifecycle() :mFragLifecycleProvider.<Events<?>>bindUntilEvent(mFragmentEndEvent)) // 绑定生命周期
                        .filter(new Func1<Events<?>, Boolean>() {
                            @Override
                            public Boolean call(Events<?> events) {
                                return events.code == event;
                            }
                        })   //过滤 根据code判断返回事件
                        .subscribe(onNext, onError == null ? new Action1<Throwable>() {
                            @Override
                            public void call(Throwable throwable) {
                                throwable.printStackTrace();
                            }
                        } : onError);
            }
            if (mActLifecycleProvider!=null){
                return RxBus.getInstance().toObservable()
                        .compose(mActivityEndEvent == null ? mActLifecycleProvider.bindToLifecycle() :mActLifecycleProvider.<Events<?>>bindUntilEvent(mActivityEndEvent))
                        .filter(new Func1<Events<?>, Boolean>() {
                            @Override
                            public Boolean call(Events<?> events) {
                                return events.code == event;
                            }
                        })
                        .subscribe(onNext, onError == null ? (Action1<Throwable>) new Action1<Throwable>() {
                            @Override
                            public void call(Throwable throwable) {
                                throwable.printStackTrace();
                            }
                        } : onError);
            }
            return null;
        }
    }
}

新BUS上路

依然使用前面的例子

Activity中发送事件

 public void sendTap(View view){
        RxBus.getInstance().send(Events.TAP, "Tap传了一个String");
    }

    public void sendOther(View view){
        RxBus.getInstance().send(Events.OTHER, null);
//        RxBus.getInstance().send(Events.OTHER, new OtherEvent("Cloud", 25));
    }

Fragment中接收事件

fragment需要继承RxLifecycle对应组件

public class BlankFragment extends RxFragment {｝
  RxBus.with(this)
                .setEvent(Events.TAP)
//                .setEndEvent(FragmentEvent.DESTROY_VIEW) //不设置默认与fragment生命周期同步
                .onNext(new Action1<Events<?>>() {
                    @Override
                    public void call(Events<?> events) {
                        String content = events.getContent();
                        textView.setText(content);
                    }
                })
                .create();

        RxBus.with(this)
                .setEvent(Events.OTHER)
                .setEndEvent(FragmentEvent.DESTROY_VIEW) //不设置默认与fragment生命周期同步
                .onNext(new Action1<Events<?>>() {
                    @Override
                    public void call(Events<?> events) {
                        OtherEvent event = events.getContent();
                        textView.setText("Name: "  + event.getName() + ",Age: "+ event.getAge());
                    }
                })
                .onError(new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        textView.setText(throwable.toString());
                    }
                }) // 异常处理，默认捕获异常，不做处理，程序不会crash。
                .create();

效果




normal.gif

完整代码，请移步

参考资料

  • FlowGeek:开源中国Android客户端MVP架构Material Design设计风格版
  • Implementing an Event Bus With RxJava – RxBus：用RxJava实现EventBus
  • http://www.jianshu.com/p/ca090f6e2fe2 ：用RxJava实现事件总线
  • http://www.jianshu.com/p/71ab00a2677b：深入RxBus 支持Sticky事件
  • http://www.jianshu.com/p/0493cc28a811：深入RxBus 异常处理

文／Cloud_Woo（简书作者）
原文链接：http://www.jianshu.com/p/adfc72da6056
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。
liuye066
关注
专栏目录
Android RxBus 的一个坑
weixin_33882452的博客
07-10 775
2019独角兽企业重金招聘Python工程师标准>>> ...
Android之RxBus详解
向着太阳迎着光
11-13 1134
ReactiveX 是一个专注于异步编程与控制可观察数据（或者事件）流的API。它组合了观察者模式，迭代器模式和函数式编程的优秀思想。 实时数据处理是一件普通的现象，有一个高效、干净和可扩展的方式来处理这些情景是重要的。使用 Observables 和 Operators 来熟练操作它们。ReactiveX 提供一个可组合又灵活的 API 来创建和处理数据流，同时简化了异步编程
Android RxBus的实现及简单使用
weixin_30496751的博客
06-18 213
RxJava目前已经很火了，如果你尚未了解请看这里。对于RxJava这里不多做介绍。RxBus并不是一个库，而是一种模式。相信大多数开发者都使用过EventBus，作为事件总线通信库，如果你的项目已经加入RxJava和EventBus，不妨用RxBus代替EventBus，以减少库的依赖。 一、添加RxJava和RxAndroid依赖 //RxJava and RxAndroid ...
RxBus学习之旅－－从入门到提高
sugaryaruan的博客
08-13 4208
在公司的技术分享会上，做了关于RxBus的学习分享，记录如下：一.RxBus与RxJava一次RxJava调用过程可以划分为以下环节： 创建观察内容 （片段1） 数据处理／映射（片段2） 选择线程（片段3） 订阅（片段4，片段5） 完成／错误处理（片段6） 示例代码：Observable // 片段1 .create(new Observabl
RxBus：RxJava的事件总线
02-20
RxBus- / 的事件总线 这是一个事件总线，旨在使您的应用程序有效地进行通信。 我在许多项目中都使用过它，现在我想也许有人会喜欢它，所以我发布了它。 RxBus支持注释（@ produce / @ subscribe），它可以为您提供...
rxbus工具类keyizhijieyong
01-15
在Android开发中，RxBus是一种基于ReactiveX（RxJava）实现的事件总线工具，它用于在应用程序的不同组件之间传递消息。RxBus简化了组件间的通信，避免了传统事件监听器的复杂性，使得代码更加简洁、可测试且易于维护...
Android RxBus
08-02
**Android RxBus** 在Android开发中，事件总线（Event Bus）是一种常见的组件间通信方式，它简化了应用程序中的事件传递，使得组件之间能够松耦合地进行通信。传统上，我们可能会使用 Otto 或 GreenRobot 的 ...
RxJava2实现Rxbus
08-24
**RxJava2实现RxBus** RxJava是一个用于处理异步事件流的库，它将观察者模式和函数式编程的概念结合在一起，为Android开发者提供了一种强大的处理事件和数据流的方式。在Android开发中，RxBus通常被用作一个事件...
RxBus2:这是RxJava2使用的RxBus
04-29
RxBus2 这是RxJava2使用的RxBus 入门 在您的build.gradle ： dependencies { implementation ' com.github.ininmm:library:1.0.0 ' } 用法 发布东西之前需要注册和注销。 建议在onCreate中注册，然后在onDestroy...
Android通用脱壳机FUPK3
08-16
Android代码是开源的，那么通过直接修改Android源码，把运行时的所有dex数据dump出来，不就可以实现一个通用的脱壳机了吗？FUPk3就是基于上面的思路来实现的。FUPK3需要修改Android源码，导出数据接口.不过，最为核心的脱壳操作是在一个so中执行的，脱壳时应用会自动加载该so，这样好处在于可以通过替换这个so来达到动态修bug的效果。 1.代码注入 程序启动后读取配置文件/data/local/tmp/FUpk3.txt,如果命中脱壳的配置就会直接加载so /data/local/tmp/libFupk3.so，进行脱壳。修改Android源码 try {UpkConfig config = new UpkConfig();if (config.load() && config.mTargetPackage.equals(data.info.getPackageName())) {     Fupk upk = new Fupk(config.mTargetPackage);     upk.unpackAfter(10000); }
epe脱壳机epe脱壳机
06-08
脱壳机脱壳机1下载epe脱壳机epe脱壳机epe脱壳机
RxBus和RxManager管理rxJava的生命周期
时年的博客
12-05 2706
首先使用rxjava封装了一个Rxbus public class RxBus { private static final String TAG = RxBus.class.getSimpleName(); private static RxBus instance; public static boolean DEBUG = BuildConfig.LOG_DEBUG
关于RxBus的一些使用心得
月灯雪华
05-18 3547
关于RxBus的一些使用心得前段时间接触了一下RxBus，发现意外的好用，中途也遇到了不少问题，但是总体来说还是愉快地，很多情况下都是由于自己的粗心大意所导致的，从而找了半天，在此自己记录一下吧。首先说下，使用的RxBus是在build.gradle中依赖 compile ‘com.hwangjr.rxbus:rxbus:1.0.3’ github地址是 https://github.com/
Android 使用RxLifecycle解决RxJava内存泄漏
热门推荐
YangLe
07-06 2万+
RxLifecycle GitHub地址RxJava GitHub地址1.为什么会发生内存泄漏使用RxJava发布一个订阅后，当页面被finish，此时订阅逻辑还未完成，如果没有及时取消订阅，就会导致Activity/Fragment无法被回收，从而引发内存泄漏。 写段代码测试一下，定义一个Activity，布局中显示一张图片，这样可以直观的看到此Activity的内存占用情况，然后在Activi
RxBus 一个简易、非反射的Android事件通知库
xuexiangjys的博客
04-18 1474
RxBus 一个简易的Android事件通知库，使用RxJava和Javassist设计，拒绝使用反射，保证性能高效稳定。 该项目是从RxUtil中分离出RxBus相关，并进行功能增强。如果你对RxJava的使用还不满足于RxBus， 你可以移步RxUtil和RxUtil2。 关于我 特征 支持多事件定义。 支持自定义数据携带。 支持全局和局部的事件订...
RxAndroid之app的生命周期管理RxLifecycle
nicolelili1的专栏
08-16 8459
管理Activity（Fragment、dialogFragment）的生命周期需要在build.gradle中加入compile 'com.trello:rxlifecycle-components:0.6.1'
Rxlifecycle绑定网络请求
magicbaby810的博客
06-13 1097
网络框架用的Retrofit+Rxjava+okhttp，调试接口时候，在5.0以下的低端机上快速返回唤起，会抛出nullpointerexception。界面是个fragment，以为是内存不足，activity被销毁，又重建了。就重写了onSaveInstanceState把super.onSaveInstanceState给注掉，防止重建fragment。又试了下，还是会出现这个nullpo...
Android中的RxBus替换掉EventBus
psjx0127的博客
07-26 1465
项目中经常用到Rxjava，听说可以用RxBus来替换掉EventBus第三方库。 RxBus是一种模式，那么为什么要替换掉EventBus呢？ 一，是为了更加熟悉RxJava的相关用法 二，是为了减少程序引用的第三方库 Android中的rxbus简单封装 public class RxBus { //单例创建 private static volatile RxBus rxBus; priva...
我要RxBus的源代码
最新发布
06-02
以下是一个简单的RxBus实现代码，供您参考： 事件类： ```java public class Event { private String message; public Event(String message) { this.message = message; } public String getMessage() { return message; } } ``` RxBus类： ```java public class RxBus { private static RxBus instance; private Subject<Object> bus; private RxBus() { bus = new SerializedSubject<>(PublishSubject.create()); } public static synchronized RxBus getInstance() { if (instance == null) { instance = new RxBus(); } return instance; } public void send(Object event) { bus.onNext(event); } public Observable<Object> toObservable() { return bus; } } ``` 使用方法： 发送事件： ```java RxBus.getInstance().send(new Event("Hello World")); ``` 订阅事件： ```java Disposable disposable = RxBus.getInstance().toObservable() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(event -> { if (event instanceof Event) { Event messageEvent = (Event) event; String message = messageEvent.getMessage(); // TODO 处理事件 } }); ``` 需要注意的是，订阅事件后需要在不需要时取消订阅，以防止内存泄漏： ```java disposable.dispose(); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值