Android 消息总线的演进之路：用 LiveDataBus 替代 RxBus、EventBus

public final class RxBus {
    private final Subject<Object, Object> bus;
    private RxBus() {        bus = new SerializedSubject<>(PublishSubject.create());    }
    private static class SingletonHolder {        private static final RxBus defaultRxBus = new RxBus();    }
    public static RxBus getInstance() {        return SingletonHolder.defaultRxBus;    }
    /*     * 发送     */    public void post(Object o) {        bus.onNext(o);    }
    /*     * 是否有Observable订阅     */    public boolean hasObservable() {        return bus.hasObservers();    }
    /*     * 转换为特定类型的Obserbale     */    public <T> Observable<T> toObservable(Class<T> type) {        return bus.ofType(type);    }}

public final class RxBus2 {
    private final Subject<Object> bus;
    private RxBus2() {        // toSerialized method made bus thread safe        bus = PublishSubject.create().toSerialized();    }
    public static RxBus2 getInstance() {        return Holder.BUS;    }
    private static class Holder {        private static final RxBus2 BUS = new RxBus2();    }
    public void post(Object obj) {        bus.onNext(obj);    }
    public <T> Observable<T> toObservable(Class<T> tClass) {        return bus.ofType(tClass);    }
    public Observable<Object> toObservable() {        return bus;    }
    public boolean hasObservers() {        return bus.hasObservers();    }}

public final class LiveDataBus {
    private final Map<String, MutableLiveData<Object>> bus;
    private LiveDataBus() {        bus = new HashMap<>();    }
    private static class SingletonHolder {        private static final LiveDataBus DATA_BUS = new LiveDataBus();    }
    public static LiveDataBus get() {        return SingletonHolder.DATA_BUS;    }
    public <T> MutableLiveData<T> getChannel(String target, Class<T> type) {        if (!bus.containsKey(target)) {            bus.put(target, new MutableLiveData<>());        }        return (MutableLiveData<T>) bus.get(target);    }
    public MutableLiveData<Object> getChannel(String target) {        return getChannel(target, Object.class);    }}

LiveDataBus.get().getChannel("key_test", Boolean.class)        .observe(this, new Observer<Boolean>() {            @Override            public void onChanged(@Nullable Boolean aBoolean) {            }        });

LiveDataBus.get().getChannel("key_test").setValue(true);

public final class LiveDataBus {
    private final Map<String, BusMutableLiveData<Object>> bus;
    private LiveDataBus() {        bus = new HashMap<>();    }
    private static class SingletonHolder {        private static final LiveDataBus DEFAULT_BUS = new LiveDataBus();    }
    public static LiveDataBus get() {        return SingletonHolder.DEFAULT_BUS;    }
    public <T> MutableLiveData<T> with(String key, Class<T> type) {        if (!bus.containsKey(key)) {            bus.put(key, new BusMutableLiveData<>());        }        return (MutableLiveData<T>) bus.get(key);    }
    public MutableLiveData<Object> with(String key) {        return with(key, Object.class);    }
    private static class ObserverWrapper<T> implements Observer<T> {
        private Observer<T> observer;
        public ObserverWrapper(Observer<T> observer) {            this.observer = observer;        }
        @Override        public void onChanged(@Nullable T t) {            if (observer != null) {                if (isCallOnObserve()) {                    return;                }                observer.onChanged(t);            }        }
        private boolean isCallOnObserve() {            StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();            if (stackTrace != null && stackTrace.length > 0) {                for (StackTraceElement element : stackTrace) {                    if ("android.arch.lifecycle.LiveData".equals(element.getClassName()) &&                            "observeForever".equals(element.getMethodName())) {                        return true;                    }                }            }            return false;        }    }
    private static class BusMutableLiveData<T> extends MutableLiveData<T> {
        private Map<Observer, Observer> observerMap = new HashMap<>();
        @Override        public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {            super.observe(owner, observer);            try {                hook(observer);            } catch (Exception e) {                e.printStackTrace();            }        }
        @Override        public void observeForever(@NonNull Observer<T> observer) {            if (!observerMap.containsKey(observer)) {                observerMap.put(observer, new ObserverWrapper(observer));            }            super.observeForever(observerMap.get(observer));        }
        @Override        public void removeObserver(@NonNull Observer<T> observer) {            Observer realObserver = null;            if (observerMap.containsKey(observer)) {                realObserver = observerMap.remove(observer);            } else {                realObserver = observer;            }            super.removeObserver(realObserver);        }
        private void hook(@NonNull Observer<T> observer) throws Exception {            //get wrapper's version            Class<LiveData> classLiveData = LiveData.class;            Field fieldObservers = classLiveData.getDeclaredField("mObservers");            fieldObservers.setAccessible(true);            Object objectObservers = fieldObservers.get(this);            Class<?> classObservers = objectObservers.getClass();            Method methodGet = classObservers.getDeclaredMethod("get", Object.class);            methodGet.setAccessible(true);            Object objectWrapperEntry = methodGet.invoke(objectObservers, observer);            Object objectWrapper = null;            if (objectWrapperEntry instanceof Map.Entry) {                objectWrapper = ((Map.Entry) objectWrapperEntry).getValue();            }            if (objectWrapper == null) {                throw new NullPointerException("Wrapper can not be bull!");            }            Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass();            Field fieldLastVersion = classObserverWrapper.getDeclaredField("mLastVersion");            fieldLastVersion.setAccessible(true);            //get livedata's version            Field fieldVersion = classLiveData.getDeclaredField("mVersion");            fieldVersion.setAccessible(true);            Object objectVersion = fieldVersion.get(this);            //set wrapper's version            fieldLastVersion.set(objectWrapper, objectVersion);        }    }}

LiveDataBus.get()        .with("key_test", String.class)        .observe(this, new Observer<String>() {            @Override            public void onChanged(@Nullable String s) {            }        });

LiveDataBus.get().with("key_test").setValue(s);