小白装逼:使用rxjava代替eventBus

接着之前说的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的使用

###订阅事件

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直接实现一个订阅者订阅多个事件…

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