一、LiveData
LiveData是17年GoogleIO大会上提出来的一个新技术。相对于通信总线类型的框架EventBus和RxBus来说，它更简单，更简洁、更解耦。
它具有以下优点：
UI和实时数据保持一致
因为LiveData采用的是观察者模式，这样一来就可以再数据发生改变时获得通知，更新UI
避免内存泄漏
观察者被绑定到组件的生命周期上，当被绑定的组件销毁（Destory）时，观察者会立刻自动清理自身的数据。
不会再产生由于Activity处于stop状态而引起的崩溃
当Activity处于后台状态时，是不会收到LiveData的任何事件的
不需要再解决生命周期带来的问题
LiveData可以感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化
实时数据刷新
当组件处于活跃状态或者从不活跃状态到活跃状态时总是能收到最新的数据
解决Confinguration Change问题
在屏幕发生旋转或者被回收再次启动，立刻就能收到最新的数据
二、简要分析运用方式：
当 LiveData 所持有的数据改变时，它会通知相应的界面代码进行更新。
同时，LiveData 持有界面代码 Lifecycle （生命周期组件）的引用，这意味着它会在界面代码（LifecycleOwner）的生命周期处于 started 或 resumed 时作出相应更新，而在 LifecycleOwner 被销毁时停止更新。
另外ViewModel的优点也很明显，为Activity 、Fragment存储数据，直到完全销毁。尤其是屏幕旋转的场景，常用的方法都是通过onSaveInstanceState()保存数据，再在onCreate()中恢复。
既然LiveData 在线程中传递事件这么优秀，那么我们应用到项目总的话，就可以集成到一块。这样就诞生了LiveDataBus。
三、LiveDataBus优点：
LiveDataBus的实现及其简单
相对EventBus复杂的实现，LiveDataBus只需要一个类就可以实现
LiveDataBus可以减小APK包的大小
LiveDataBus只依赖Android官方组件LiveData，本身实现只一个类。EventBus 57Kb、RxJava 2.2M
LiveDataBus 依赖方支持更好
LiveDataBus只依赖Android官方组件LiveData，相比RxBus依赖的RxJava和RxAndroid，依赖方支持更好
LiveDataBus具有生命周期感知
LiveDataBus具有生命周期感知，在Android系统中使用调用者不需要调用反注册，相比EventBus和RxBus使用更为方便，并且没有内存泄漏风险。
四、代码展示：
以上我们已经知道了，LiveData订阅消息和发送消息的方式。
那么应用到项目中时，使用Map将这些LiveData保存记录下来，这样各个页面的调用存取都可以写到同一个Map中，就形成总线机制。
订阅消息
1、observe 生命周期感知，不需要手动取消订阅
LiveDataBus.get().with("key_name", String.class)
.observe(this, new Observer<String>() {
@Override
public void onChanged(@Nullable String s) {
}
});
2、observeForever 需要手动取消订阅
LiveDataBus.get().with("key_name", String.class).observeForever(observer);
LiveDataBus.get().with("key_name", String.class).removeObserver(observer);
发送消息
1、setValue 在主线程发送消息
LiveDataBus.get().with("key_name").setValue(value);
2、postValue 在后台线程发送消息，订阅者会在主线程收到消息
LiveDataBus.get().with("key_name").postValue(value);
Sticky模式
支持在注册订阅者的时候设置Sticky模式，这样订阅者可以接收到订阅之前发送的消息
observeSticky 生命周期感知，不需要手动取消订阅，Sticky模式
LiveDataBus.get()
.with("sticky_key", String.class)
.observeSticky(this, new Observer<String>() {
@Override
public void onChanged(@Nullable String s) {
}
});
observeStickyForever 需要手动取消订阅，Sticky模式
LiveDataBus.get().with("sticky_key", String.class).observeStickyForever(observer);
LiveDataBus.get().with("sticky_key", String.class).removeObserver(observer);
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 synchronized <T> BusMutableLiveData<T> with(String key, Class<T> type) {
if (!bus.containsKey(key)) {
bus.put(key, new BusMutableLiveData<>());
}
return (BusMutableLiveData<T>) bus.get(key);
}
public BusMutableLiveData<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;
}
}
public static class BusMutableLiveData<T> extends MutableLiveData<T> {
private class PostValueTask implements Runnable {
private Object newValue;
public PostValueTask(@NonNull Object newValue) {
this.newValue = newValue;
}
@Override
public void run() {
setValue((T) newValue);
}
}
private Map<Observer, Observer> observerMap = new HashMap<>();
private Handler mainHandler = new Handler(Looper.getMainLooper());
@Override
public void postValue(T value) {
mainHandler.post(new PostValueTask(value));
}
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
super.observe(owner, observer);
try {
hook(observer);
} catch (Exception e) {
e.printStackTrace();
}
}
public void observeSticky(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
super.observe(owner, observer);
}
@Override
public void observeForever(@NonNull Observer<T> observer) {
if (!observerMap.containsKey(observer)) {
observerMap.put(observer, new ObserverWrapper(observer));
}
super.observeForever(observerMap.get(observer));
}
public void observeStickyForever(@NonNull Observer<T> observer) {
super.observeForever(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);
}
}
}
注：
在BusMutableLiveData类中，hook函数利用反射机制重新给wrapper的version赋值了。跟踪源码可知：这么操作的意义是为了在Activity未创建时，不接收发布消息者发布过来的消息。（例：网络请求后使用LiveData向AActivity发送消息，但是AActivity还未创建，这样一旦AActivity创建后onResume函数调用，View会跟着数据变化。但如果我不想AActivity创建后View有所改变呢，就使用调用hook函数的observe去订阅就可以了）
