RxBus

记录学习RxBus过程
RxBus是用RxJava来实现事件总线的

1、在build.gradle(app)中添加依赖

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

2、定义一个事件类

public class Event {
    String str;
    public Event(String str){
        this.str = str;
    }

    public String getStr() {
        return str;
    }
}

3、将RxBus相关操作封装为一个工具类
类中包含普通事件和粘性事件

package com.example.test.utils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import io.reactivex.subjects.PublishSubject;
import io.reactivex.subjects.Subject;

/**
 * 基于RxJava 2.X版本
 */
public class RxBus2 {
    private final Subject<Object> mBus;
    private static volatile RxBus2 instance;
    private final Map<Class<?>, Object> mStickyEventMap;

    private RxBus2() {
        mBus = PublishSubject.create().toSerialized();
        mStickyEventMap = new ConcurrentHashMap<>();
    }

    /**
     * 单例模式，双重检查
     */
    public static RxBus2 getInstance() {
        if (null == instance) {
            synchronized (RxBus2.class) {
                if (null == instance) {
                    instance = new RxBus2();
                }
            }
        }
        return instance;
    }

    /**
     * 将数据添加到订阅
     *
     * @param obj
     */
    public void post(Object obj) {
        //判断当前是否已经添加订阅
        if (mBus.hasObservers()) {
            mBus.onNext(obj);
        }
    }

    /**
     * 传递集合
     *
     * @param obj
     */
    public void post(List<Object> obj) {
        if (mBus.hasObservers()) {
            mBus.onNext(obj);
        }
    }

    /**
     * 注册
     *
     * @param tClass
     * @param consumer
     * @param <T>
     * @return
     */
    public <T> Disposable register(Class<T> tClass, Consumer<T> consumer) {
        return mBus.ofType(tClass)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(consumer);
    }


    private HashMap<String, CompositeDisposable> mSubscriptionMap;

    /**
     * 保存订阅后的disposable
     *
     * @param o
     * @param disposable
     */
    public void addSubscription(Object o, Disposable disposable) {
        if (null == mSubscriptionMap) {
            mSubscriptionMap = new HashMap<>();
        }
        String key = o.getClass().getName();
        if (mSubscriptionMap.get(key) != null) {
            mSubscriptionMap.get(key).add(disposable);
        } else {
            //可以持有多个并提供添加和删除
            CompositeDisposable disposable1s = new CompositeDisposable();
            disposable1s.add(disposable);
            mSubscriptionMap.put(key, disposable1s);
        }
    }

    public void unSubscribe(Object o) {
        if (null == mSubscriptionMap) {
            return;
        }
        String key = o.getClass().getName();
        if (!mSubscriptionMap.containsKey(key)) {
            return;
        }
        if (mSubscriptionMap.get(key) != null) {
            mSubscriptionMap.get(key).dispose();
        }
        mSubscriptionMap.remove(key);
    }
//****************************Sticky相关*******************
    /**
     * 发送一个新Sticky事件
     */
    public void postSticky(Object event) {
        synchronized (mStickyEventMap) {
            mStickyEventMap.put(event.getClass(), event);
        }
        post(event);
    }

    /**
     * 根据传递的 tClass 类型返回特定类型(tClass)的 被观察者
     * @param tClass
     * @param consumer
     * @param <T>
     * @return
     */
    public <T> Disposable registerSticky(final Class<T> tClass, Consumer<T> consumer) {
        synchronized (mStickyEventMap) {
            final Object event = mStickyEventMap.get(tClass);
            if (event != null) {
                return mBus.ofType(tClass)
                        .mergeWith(Observable.create(new ObservableOnSubscribe<T>() {
                            @Override
                            public void subscribe(ObservableEmitter<T> e) throws Exception {
                                e.onNext(tClass.cast(event));
                            }
                        }))
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(consumer);
            } else {
                return mBus.ofType(tClass)
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(consumer);
            }
        }

    }

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

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

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

4、事件发送
在本文中普通事件类和粘性事件类共用了一个Event

 postEvent.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("tt", "点击发送Event按钮");
                //发送事件
                RxBus2.getInstance().post(new Event("接受来自RxBus的消息啦"));

            }
        });

        Button postStickyEvent = findViewById(R.id.postStickyEvent);
        
        postStickyEvent.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("tt", "点击发送StickyEvent按钮");
                //发送粘性事件
                RxBus2.getInstance().postSticky(new Event("接受来自RxBus 粘性事件啦"));
            }
        });

5、注册

 Disposable register = RxBus2.getInstance().register(Event.class, new Consumer<Event>() {
            @Override
            public void accept(Event event) throws Exception {
                Log.d("tangyu","event.getStr == "+event.getStr());
                showView.setText(event.getStr());
            }
        });
        RxBus2.getInstance().addSubscription(this,register);


        Disposable register1 = RxBus2.getInstance().registerSticky(Event.class, new Consumer<Event>() {
            @Override
            public void accept(Event event) throws Exception {
                Log.d("tangyu", "event.getStr == " + event.getStr());
                showStickyView.setText(event.getStr());
            }
        });
        RxBus2.getInstance().addSubscription(this, register1);

6、最后要记得解注册

 @Override
    public void onDestroy() {
        super.onDestroy();
        RxBus2.getInstance().unSubscribe(this);
    }