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的簡單使用就說到這里了。