基于RxJava2实现的RxBus

基于Rxjava2编写，代码注释很多，直接上代码

首先我们先介绍怎么使用，然后上源码

源码地址

订阅事件

 2个观察者订阅同一个事件，TAG是事件对应的key值

        rxManager = new RxManager();

        rxManager.on(TAG, new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "integer1:" + integer);
            }
        });

        rxManager.on(TAG, new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "integer2:" + integer);
            }
        });

注册事件

RxBus.getInstance().post(TAG,+num);

 

activity 销毁，记得解除所有订阅

    @Override
    protected void onDestroy() {
        super.onDestroy();
        rxManager.clear();
    }

代码详情

/**
 * Created by caiyuk on 2019/1/10.
 */
public class RxManager {

    private RxBus mRxBus = RxBus.getInstance();
    /**
     * 管理上下游订阅关系
     */
    private CompositeDisposable mCompositeDisposable = new CompositeDisposable();
    /**
     * 管理Rxbus订阅
     */
    private Map<String, Observable<?>> mObservableMap = new HashMap<>();

    /**
     * 注入事件监听
     *
     * @param eventName
     * @param consumer
     * @param <T>
     */
    public <T> void on(@NonNull String eventName, @NonNull Consumer<T> consumer) {
        Observable<T> observable = mRxBus.register(eventName);
        mObservableMap.put(eventName,observable);
        mCompositeDisposable.add(observable.observeOn(AndroidSchedulers.mainThread()).subscribe(consumer, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                throwable.printStackTrace();
            }
        }));

    }

    /**
     * 收集这个Disposable，便于终断上下游事件
     *
     * @param m
     */
    public void add(@NonNull Disposable m) {
        /*订阅管理*/
        mCompositeDisposable.add(m);
    }

    /**
     * 生命周期结束，取消订阅和所有Rxbus观察
     */
    public void clear() {
        mCompositeDisposable.dispose();//切断订阅事件
        for (Map.Entry<String, Observable<?>> entry : mObservableMap.entrySet()) {
            // 移除rxbus观察
            mRxBus.unRegister(entry.getKey(), entry.getValue());
        }
    }

}

 

/**
 * Created by caiyuk on 2019/1/10.
 */
public class RxBus {

    private static RxBus mRxBus;
    /**
     * String -> 事件key值
     * List<Subject> -> 集合中的观察者都在观察这个事件
     */
    private ConcurrentHashMap<String, List<Subject>> mSubjectMapper = new ConcurrentHashMap();

    private RxBus() {
    }

    public static RxBus getInstance() {

        if (mRxBus == null) {
            synchronized (RxBus.class) {
                if (mRxBus == null) {
                    mRxBus = new RxBus();
                }
            }
        }
        return mRxBus;
    }

    /**
     * 注册事件源
     *
     * @param tag
     * @param <T>
     * @return
     */
    public <T> Observable<T> register(@NonNull String tag) {

        List<Subject> subjectList = mSubjectMapper.get(tag);

        if (subjectList == null) {
            subjectList = new ArrayList<>();
            mSubjectMapper.put(tag, subjectList);
        }
        Subject<T> subject = PublishSubject.create();
        subjectList.add(subject);
        return subject;
    }

    /**
     * 解绑事件
     *
     * @param tag
     */
    public void unRegister(@NonNull String tag) {

        List<Subject> subjectList = mSubjectMapper.get(tag);
        if (subjectList != null) {
            subjectList.clear();
            mSubjectMapper.remove(tag);
        }
    }

    /**
     * 解绑指定观察者
     *
     * @param tag
     * @param observable
     */
    public void unRegister(@NonNull String tag, @NonNull Observable<?> observable) {

        if (observable == null) {
            return;
        }
        List<Subject> subjectList = mSubjectMapper.get(tag);
        if (!isEmpty(subjectList) && subjectList.contains(observable)) {
            subjectList.remove(observable);
            if (isEmpty(subjectList)) {
                mSubjectMapper.remove(tag);
            }
        }
    }

    /**
     * 触发事件
     *
     * @param tag     事件对应的key值
     * @param content 要传递出去的对象
     */
    public void post(@NonNull String tag, Object content) {

        List<Subject> subjects = mSubjectMapper.get(tag);
        if (!isEmpty(subjects)) {
            for (Subject subjuct : subjects) {
                subjuct.onNext(content);
            }
        }

    }


    private boolean isEmpty(Collection<Subject> collection) {
        return null == collection || collection.isEmpty();
    }
}