LiveDataBus的简单使用

这里简单的介绍LiveDataBus的使用，下面是LiveData的优点：

LiveData优点	解释
UI和十几数据保持一致	LiveData采用观察者模式，数据发生时获得通知，更新UI
避免内存泄漏	观察者绑定到组件的生命周期上，当被绑定的组件销毁（destroy）时，观察者会立刻自动清理自身的数据
不会因为Activity处于Stop状态时引起奔溃	当Activity处于后台状态时，不会接受到LiveData的任何事件
不需要解决生命周期带来的问题	LiveData可以感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化
实时数据刷	当组件处于活跃状态或者从不活跃状态到活跃状态时总是能收到最新的数据
解决Configuration Change问题	在屏幕发生旋转或者被回收再次启动，立刻就能收到最新的数据

看一下LiveDataBus的整体架构（画的不好看，莫笑）：

接下来看一下LiveDataBus的使用（先看有BUG的），新建一个LiveDataBus1类（这里我直接贴出代码）：

public final class LiveDataBus1 {

    private final Map<String, MutableLiveData<Object>> bus;

    private LiveDataBus1() {
        bus = new HashMap<>();
    }

    private static class SingletonHolder {
        private static final LiveDataBus1 DATA_BUS = new LiveDataBus1();
    }

    public static LiveDataBus1 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);
    }
}

然后在MainActivty中使用，用一个按钮发送消息，同时启动一个新界面：

@Override
    public void onClick(View view) {
        LiveDataBus1.get().getChannel("nice").setValue("Hello Android!");
        Intent intent = new Intent(this,TestActivity.class);
        startActivity(intent);
    }

在新的界面的onCreate中注册订阅，然后添加一个TextView控件显示接收消息内容：

 LiveDataBus1.get().getChannel("nice",String.class).observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                txtTest.setText(s);
            }
        });

启动项目，点击按钮，跳到新界面后发现TextView控件立马就显示内容了，这不是想要的结果。

第2种效果，新建一个LiveDataBus类，我直接贴出代码：

public 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 androidx.lifecycle.Observer<T> {

        private androidx.lifecycle.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<? super T> observer) {
            super.observe(owner, observer);
            try {
                hook(observer);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        @Override
        public void observeForever(@NonNull Observer<? super T> observer) {
            if (!observerMap.containsKey(observer)) {
                observerMap.put(observer, new ObserverWrapper(observer));
            }
            super.observeForever(observerMap.get(observer));
        }

        @Override
        public void removeObserver(@NonNull Observer<? super T> observer) {
            Observer realObserver = null;
            if (observerMap.containsKey(observer)) {
                realObserver = observerMap.remove(observer);
            } else {
                realObserver = observer;
            }
            super.removeObserver(realObserver);
        }

        private void hook(@NonNull Observer<? super 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);
        }
    }
}

同样是在MainAct按钮中发送消息，跳转到新页面，这里我就直贴出发送消息的代码：
 LiveDataBus.get().with("test").setValue("Hello Android!"); 

然后在新新界面中添加一个Button控件，然后先把注册订阅放在Button的点击事件中：

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

做完以上操作后，点击MainActivity的Button跳到新界面，再然后点击新界面的Button控件，TextView控件的值就改变了，LiveDataBus的简单使用就说到这里了。