LiveDataBus的簡單使用

這裏簡單的介紹LiveDataBus的使用，下面是LiveData的優勢：

LiveData優勢	解釋
UI和十幾數據保持一致	LiveData採用觀察者模式，數據發生時得到通知，更新UI
避免內存泄漏	觀察者綁定到組件的生命週期上，當被綁定的組件銷燬（destroy）時，觀察者會馬上自動清理自身的數據
不會由於Activity處於Stop狀態時引發奔潰	當Activity處於後臺狀態時，不會接受到LiveData的任何事件
不須要解決生命週期帶來的問題	LiveData能夠感知被綁定的組件的生命週期，只有在活躍狀態纔會通知數據變化
實時數據刷	當組件處於活躍狀態或者從不活躍狀態到活躍狀態時老是能收到最新的數據
解決Configuration Change問題	在屏幕發生旋轉或者被回收再次啓動，馬上就能收到最新的數據

 

看一下LiveDataBus的總體架構（畫的很差看，莫笑）：

接下來看一下LiveDataBus的使用（先看有BUG的），新建一個LiveDataBus1類（這裏我直接貼出代碼）：

 1 public final class LiveDataBus1 {
 2 
 3     private final Map<String, MutableLiveData<Object>> bus;
 4 
 5     private LiveDataBus1() {
 6         bus = new HashMap<>();
 7     }
 8 
 9     private static class SingletonHolder {
10         private static final LiveDataBus1 DATA_BUS = new LiveDataBus1();
11     }
12 
13     public static LiveDataBus1 get() {
14         return SingletonHolder.DATA_BUS;
15     }
16 
17     public <T> MutableLiveData<T> getChannel(String target, Class<T> type) {
18         if (!bus.containsKey(target)) {
19             bus.put(target, new MutableLiveData<>());
20         }
21         return (MutableLiveData<T>) bus.get(target);
22     }
23 
24     public MutableLiveData<Object> getChannel(String target) {
25         return getChannel(target, Object.class);
26     }
27 }

而後在MainActivty中使用，用一個按鈕發送消息，同時啓動一個新界面：

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

在新的界面的onCreate中註冊訂閱，而後添加一個TextView控件顯示接收消息內容：

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

啓動項目，點擊按鈕，跳到新界面後發現TextView控件立馬就顯示內容了，這不是想要的結果。

第2種效果，新建一個LiveDataBus類，我直接貼出代碼：

  1 public class LiveDataBus {
  2 
  3     private final Map<String,BusMutableLiveData<Object>> bus;
  4 
  5     private LiveDataBus(){
  6         bus = new HashMap<>();
  7     }
  8 
  9     private static class SingletonHolder{
 10         private static final LiveDataBus DEFAULT_BUS = new LiveDataBus();
 11     }
 12 
 13     public static LiveDataBus get(){
 14         return SingletonHolder.DEFAULT_BUS;
 15     }
 16 
 17     public <T> MutableLiveData<T> with(String key,Class<T> type){
 18         if(!bus.containsKey(key)) {
 19             bus.put(key, new BusMutableLiveData<>());
 20         }
 21         return (MutableLiveData<T>) bus.get(key);
 22     }
 23 
 24     public MutableLiveData<Object> with(String key){
 25         return with(key,Object.class);
 26     }
 27 
 28     private static class ObserverWrapper<T> implements androidx.lifecycle.Observer<T> {
 29 
 30         private androidx.lifecycle.Observer<T> observer;
 31 
 32         public ObserverWrapper(Observer<T> observer) {
 33             this.observer = observer;
 34         }
 35 
 36         @Override
 37         public void onChanged(@Nullable T t) {
 38             if (observer != null) {
 39                 if (isCallOnObserve()) {
 40                     return;
 41                 }
 42                 observer.onChanged(t);
 43             }
 44         }
 45 
 46         private boolean isCallOnObserve() {
 47             StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
 48             if (stackTrace != null && stackTrace.length > 0) {
 49                 for (StackTraceElement element : stackTrace) {
 50                     if ("android.arch.lifecycle.LiveData".equals(element.getClassName()) &&
 51                             "observeForever".equals(element.getMethodName())) {
 52                         return true;
 53                     }
 54                 }
 55             }
 56             return false;
 57         }
 58     }
 59 
 60     private static class BusMutableLiveData<T> extends MutableLiveData<T> {
 61 
 62         private Map<Observer, Observer> observerMap = new HashMap<>();
 63 
 64         @Override
 65         public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
 66             super.observe(owner, observer);
 67             try {
 68                 hook(observer);
 69             } catch (Exception e) {
 70                 e.printStackTrace();
 71             }
 72         }
 73 
 74         @Override
 75         public void observeForever(@NonNull Observer<? super T> observer) {
 76             if (!observerMap.containsKey(observer)) {
 77                 observerMap.put(observer, new ObserverWrapper(observer));
 78             }
 79             super.observeForever(observerMap.get(observer));
 80         }
 81 
 82         @Override
 83         public void removeObserver(@NonNull Observer<? super T> observer) {
 84             Observer realObserver = null;
 85             if (observerMap.containsKey(observer)) {
 86                 realObserver = observerMap.remove(observer);
 87             } else {
 88                 realObserver = observer;
 89             }
 90             super.removeObserver(realObserver);
 91         }
 92 
 93         private void hook(@NonNull Observer<? super T> observer) throws Exception {
 94             //get wrapper's version
 95             Class<LiveData> classLiveData = LiveData.class;
 96             Field fieldObservers = classLiveData.getDeclaredField("mObservers");
 97             fieldObservers.setAccessible(true);
 98             Object objectObservers = fieldObservers.get(this);
 99             Class<?> classObservers = objectObservers.getClass();
100             Method methodGet = classObservers.getDeclaredMethod("get", Object.class);
101             methodGet.setAccessible(true);
102             Object objectWrapperEntry = methodGet.invoke(objectObservers, observer);
103             Object objectWrapper = null;
104             if (objectWrapperEntry instanceof Map.Entry) {
105                 objectWrapper = ((Map.Entry) objectWrapperEntry).getValue();
106             }
107             if (objectWrapper == null) {
108                 throw new NullPointerException("Wrapper can not be bull!");
109             }
110             Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass();
111             Field fieldLastVersion = classObserverWrapper.getDeclaredField("mLastVersion");
112             fieldLastVersion.setAccessible(true);
113             //get livedata's version
114             Field fieldVersion = classLiveData.getDeclaredField("mVersion");
115             fieldVersion.setAccessible(true);
116             Object objectVersion = fieldVersion.get(this);
117             //set wrapper's version
118             fieldLastVersion.set(objectWrapper, objectVersion);
119         }
120     }
121 }

一樣是在MainAct按鈕中發送消息，跳轉到新頁面，這裏我就直貼出發送消息的代碼：
 1 LiveDataBus.get().with("test").setValue("Hello Android!"); 

而後在新新界面中添加一個Button控件，而後先把註冊訂閱放在Button的點擊事件中：

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

作完以上操做後，點擊MainActivity的Button跳到新界面，再而後點擊新界面的Button控件，TextView控件的值就改變了，LiveDataBus的簡單使用就說到這裏了。