小白装逼:使用rxjava代替eventBus

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_38713396/article/details/76770387

接着之前说的rxjava代替eventBus的,现在大部分的项目都有使用retrofit+rxjava,所以为了方便,直接使用rxjava来代替eventbus事件总线.虽然这样有些不足的地方,但也是一个不错的方案….

导入包

    compile 'io.reactivex:rxandroid:1.1.0'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.0.1'

或者

  compile 'io.reactivex.rxjava2:rxjava:2.0.1'
  compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

配置

public class RxBus {
    private static volatile RxBus mDefaultInstance;//单例
    private final Subject<Object, Object> mBus;

    private final Map<Class<?>, Object> mStickyEventMap;//这里是为了给每一类事件做标记

    public RxBus() {
        mBus = new SerializedSubject<>(PublishSubject.create());//使用publishSubject(可以先订阅后出发其onNext等方法的subJect)创建一个线程安全的SerializedSubject
        mStickyEventMap = new ConcurrentHashMap<>();//这里使用线程安全的map
    }

    public static RxBus getDefault() {//获取单例
        if (mDefaultInstance == null) {
            synchronized (RxBus.class) {
                if (mDefaultInstance == null) {
                    mDefaultInstance = new RxBus();
                }
            }
        }
        return mDefaultInstance;
    }

    /**
     * 发送事件
     */
    public void post(Object event) {
        mBus.onNext(event);
    }

    /**
     * 发送一个新Sticky事件
     */
    public void postSticky(Object event) {
        synchronized (mStickyEventMap) {
            mStickyEventMap.put(event.getClass(), event);
        }
        post(event);
    }


    /**
     * 判断是否有订阅者
     */
    public boolean hasObservers() {
        return mBus.hasObservers();
    }

    /**
     * 重新设置订阅者
     */
    public void reset() {
        mDefaultInstance = null;
    }


    /**
     * 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
     */
    public <T> Observable<T> toObservable(Class<T> eventType) {
        return mBus.ofType(eventType);
    }

    /**
     * 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
     */
    public <T> Observable<T> toObservableSticky(final Class<T> eventType) {
        synchronized (mStickyEventMap) {
            Observable<T> observable = mBus.ofType(eventType);//获取发布者(被观察者)的Observable
            final Object event = mStickyEventMap.get(eventType);//获取存储的eventType事件类型

            if (event != null) {
                return observable.mergeWith(Observable.just(eventType.cast(event)));
                //mergeWith是结合俩个observable,just是将内容原样发射,cast为强制转换为当前类型;
                // 综合为:获取原事件总线的事件并将新的与其结合后一同放入事件总线
            } else {
                return observable;
            }
        }
    }

    /**
     * 根据eventType获取Sticky事件
     */
    public <T> T getStickyEvent(Class<T> eventType) {
        synchronized (mStickyEventMap) {
            return eventType.cast(mStickyEventMap.get(eventType));
        }
    }

    /**
     * 移除指定eventType的Sticky事件
     */
    public <T> T removeStickyEvent(Class<T> eventType) {
        synchronized (mStickyEventMap) {
            return eventType.cast(mStickyEventMap.remove(eventType));
        }
    }

    /**
     * 移除所有的Sticky事件
     */
    public void removeAllStickyEvents() {
        synchronized (mStickyEventMap) {
            mStickyEventMap.clear();
        }
    }
}

建立一个统一事件类型类(一个用于存储传递数据的类,这里只存储一个字符串,可以传递更多信息)

public class EventSticky {
    public String event;

    public EventSticky(String event) {
        this.event = event;
    }

    @Override
    public String toString() {
        return "EventSticky{" +
                "event='" + event + '\'' +
                '}';
    }
}

rxjava的使用

这里的使用方式有两种:
1.直接使用post/toObservable,这方式在管理订阅者上有些不好,若使用此方式,可以将RxBus中Sticky的代码删除;;
2.使用postSticky/toObservableSticky,这方式在上述代码中有对订阅者的管理(推荐);;

(方式1与2基本一样,只是调用方法和取消订阅不同)

订阅事件

private Subscription mRxSubSticky;//这里使用Subscription 来管理订阅者

private void subscribeEventSticky() {
                if (mRxSubSticky != null && !mRxSubSticky.isUnsubscribed()) {
                        RxSubscriptions.remove(mRxSubSticky);//这里为解除订阅者
                } else {
                        EventSticky s = RxBus.getDefault().getStickyEvent(EventSticky.class);//这里是测试获取到的事件
                        Log.i("FFF", "获取到StickyEvent--->" + s);

                        mRxSubSticky = RxBus.getDefault().toObservableSticky(EventSticky.class)
                                .subscribe(new RxBusSubscriber<EventSticky>() {
                                        @Override
                                        protected void onEvent(EventSticky eventSticky) {
                                                Log.e("FFF", "onNext--Sticky-->" + eventSticky.event);
                                            if("img_head".equals(eventSticky.event)){
                                                Log.w("---rxtest---",eventSticky.event);
                                            }
                                                if("getNewOrder".equals(eventSticky.event)){
                                                      Log.i("---接收发来的事件---",eventSticky.event);
                                                }
                                                if ("doneOrder".equals(eventSticky.event)){
                                                      Log.i("---接收发来的事件---",eventSticky.event);
                                                }
                                                if ("order".equals(eventSticky.event)){
                                                      Log.i("---接收发来的事件---",eventSticky.event);

                                                }
                                                if("img_head".equals(eventSticky.event)){

                                                }


                                        }
                                });
                        RxSubscriptions.add(mRxSubSticky);

                }
        }

发起事件

 RxBus.getDefault().postSticky(new EventSticky("getNewOrder"));

解除订阅

RxSubscriptions.remove(mRxSubSticky);
RxBus.getDefault().removeAllStickyEvents();

结尾吐槽

以上是本人项目中接触到的rxjava代替eventBus的方法,就是在订阅事件的时候,处理的多一些,其他的还是很好用的.和eventBus比较的话,rxjava适用于一个订阅者订阅一个事件,因为如果要订阅多个事件的话就要注册多次,而eventBus直接实现一个订阅者订阅多个事件…..

以上内容,纯属个人理解,如有错误,请指出纠正,若有雷同,你肯定在做梦~~~~

展开阅读全文

没有更多推荐了,返回首页