LiveDataBus
项目开发中所能使用到的组建通信方式？
Intent
Handler
Broadcast
Interface
AIDL
已有的组建通信框架：
Rxjava
优点：效率高，无内存泄漏，具有生命周期
缺点：基于Rxjava,学习成本太大，而且依赖的包有2.2M，会对我们的apk产生一定的负担
EventBus
优点：使用简单，能达到项目基本需求
缺点：混淆问题，无法感知生命周期，很难追踪到发布者
LiveDataBus
使用简单
代码量少
官方提供了很稳定的并且会一直维护的可依赖包
能感知组件的生命周期
不会存在内存泄漏
Android框架组件之Lifecycle:
具有生命感知的，不但能够监听Activity、Fragment的生命周期，还能够回调相应的方法，同时他能够实时的获取当前Activity、Fragment的状态
LiveData
是一个数据持有类，持有数据并且这个数据能被观察者监听，而且它是和lifecycle绑定的，具有生命周期感知的，解决内存泄漏和引用问题。
Hook
可以用在事件传送的过程中截获并监听事件的传输，将自身的代码与系统方法进行融入。这样，当这些方法被调用时，也就可以执行我们自己的代码，这也就是面向对象的编程思想（AOP）
其实就是通过反射获取到Hook点，然后在Hook点执行我们要插入的方法或者改变原本的逻辑的参数，然后再接着执行它原本要执行的逻辑。
以下内容来源于
https://www.cnblogs.com/meituantech/p/9376449.html
发布/订阅模式
订阅发布模式定义了一种“一对多”的依赖关系，让多个订阅者对象同时监听某一个主题对象。这个主题对象在自身状态变化时，会通知所有订阅者对象，使它们能够自动更新自己的状态。
从EventBus说起
EventBus是一个Android事件发布/订阅框架，通过解耦发布者和订阅者简化Android事件传递。EventBus可以代替Android传统的Intent、Handler、Broadcast或接口回调，在Fragment、Activity、Service线程之间传递数据，执行方法。
EventBus最大的特点就是简洁、解耦。在没有EventBus之前我们通常用广播来实现监听，或者自定义接口函数回调，有的场景我们也可以直接用Intent携带简单数据，或者在线程之间通过Handler处理消息传递。但无论是广播还是Handler机制远远不能满足我们高效的开发。EventBus简化了应用程序内各组件间、组件与后台线程间的通信。EventBus一经推出，便受到广大开发者的推崇。
现在看来，EventBus给Android开发者世界带来了一种新的框架和思想，就是消息的发布和订阅。这种思想在其后很多框架中都得到了应用。
RxBus的出现
RxBus不是一个库，而是一个文件，实现只有短短30行代码。RxBus本身不需要过多分析，它的强大完全来自于它基于的RxJava技术。响应式编程（Reactive Programming）技术这几年特别火，RxJava是它在Java上的实作。RxJava天生就是发布/订阅模式，而且很容易处理线程切换。所以，RxBus凭借区区30行代码，就敢挑战EventBus“江湖老大”的地位。
RxBus原理
在RxJava中有个Subject类，它继承Observable类，同时实现了Observer接口，因此Subject可以同时担当订阅者和被订阅者的角色，我们使用Subject的子类PublishSubject来创建一个Subject对象（PublishSubject只有被订阅后才会把接收到的事件立刻发送给订阅者），在需要接收事件的地方，订阅该Subject对象，之后如果Subject对象接收到事件，则会发射给该订阅者，此时Subject对象充当被订阅者的角色。
完成了订阅，在需要发送事件的地方将事件发送给之前被订阅的Subject对象，则此时Subject对象作为订阅者接收事件，然后会立刻将事件转发给订阅该Subject对象的订阅者，以便订阅者处理相应事件，到这里就完成了事件的发送与处理。
最后就是取消订阅的操作了，RxJava中，订阅操作会返回一个Subscription对象，以便在合适的时机取消订阅，防止内存泄漏，如果一个类产生多个Subscription对象，我们可以用一个CompositeSubscription存储起来，以进行批量的取消订阅。
RxBus有很多实现，如：
AndroidKnife/RxBus（https://github.com/AndroidKnife/RxBus）
Blankj/RxBus（https://github.com/Blankj/RxBus）
其实正如前面所说的，RxBus的原理是如此简单，我们自己都可以写出一个RxBus的实现：
基于RxJava1的RxBus实现：
publicfinalclassRxBus{
privatefinalSubject bus;
privateRxBus(){
bus =newSerializedSubject<>(PublishSubject.create());
}
privatestaticclassSingletonHolder{
privatestaticfinalRxBus defaultRxBus =newRxBus();
}
publicstaticRxBusgetInstance(){
returnSingletonHolder.defaultRxBus;
}
/*
* 发送
*/
publicvoidpost(Object o){
bus.onNext(o);
}
/*
* 是否有Observable订阅
*/
publicbooleanhasObservable(){
returnbus.hasObservers();
}
/*
* 转换为特定类型的Obserbale
*/
publicObservable
returnbus.ofType(type);
}
}
基于RxJava2的RxBus实现：
publicfinalclassRxBus2{
private final Subject
private RxBus2() {
// toSerialized method made bus thread safe
bus = PublishSubject.create().toSerialized();
}
publicstaticRxBus2getInstance(){
return Holder.BUS;
}
privatestaticclassHolder{
private static final RxBus2 BUS = new RxBus2();
}
publicvoidpost(Objectobj){
bus.onNext(obj);
}
publicObservabletoObservable(Class tClass){
return bus.ofType(tClass);
}
publicObservabletoObservable(){
return bus;
}
publicbooleanhasObservers(){
return bus.hasObservers();
}
}
LiveData是Android Architecture Components提出的框架。LiveData是一个可以被观察的数据持有类，它可以感知并遵循Activity、Fragment或Service等组件的生命周期。正是由于LiveData对组件生命周期可感知特点，因此可以做到仅在组件处于生命周期的激活状态时才更新UI数据。
LiveData需要一个观察者对象，一般是Observer类的具体实现。当观察者的生命周期处于STARTED或RESUMED状态时，LiveData会通知观察者数据变化；在观察者处于其他状态时，即使LiveData的数据变化了，也不会通知。
LiveData的优点
UI和实时数据保持一致，因为LiveData采用的是观察者模式，这样一来就可以在数据发生改变时获得通知，更新UI。
避免内存泄漏，观察者被绑定到组件的生命周期上，当被绑定的组件销毁（destroy）时，观察者会立刻自动清理自身的数据。
不会再产生由于Activity处于stop状态而引起的崩溃，例如：当Activity处于后台状态时，是不会收到LiveData的任何事件的。
不需要再解决生命周期带来的问题，LiveData可以感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化。
实时数据刷新，当组件处于活跃状态或者从不活跃状态到活跃状态时总是能收到最新的数据。
解决Configuration Change问题，在屏幕发生旋转或者被回收再次启动，立刻就能收到最新的数据。
谈一谈Android Architecture Components
Android Architecture Components的核心是Lifecycle、LiveData、ViewModel 以及 Room，通过它可以非常优雅的让数据与界面进行交互，并做一些持久化的操作，高度解耦，自动管理生命周期，而且不用担心内存泄漏的问题。
Room
一个强大的SQLite对象映射库。
ViewModel
一类对象，它用于为UI组件提供数据，在设备配置发生变更时依旧可以存活。
LiveData一个可感知生命周期、可被观察的数据容器，它可以存储数据，还会在数据发生改变时进行提醒。
Lifecycle
包含LifeCycleOwer和LifecycleObserver，分别是生命周期所有者和生命周期感知者。
Android Architecture Components的特点
数据驱动型编程
变化的永远是数据，界面无需更改。
感知生命周期，防止内存泄漏
高度解耦
数据，界面高度分离。
数据持久化
数据、ViewModel不与 UI的生命周期挂钩，不会因为界面的重建而销毁。
重点：为什么使用LiveData构建数据通信总线LiveDataBus
LiveDataBus原理图
LiveDataBus的实现
第一个实现：
publicfinalclassLiveDataBus{
privatefinalMap> bus;
privateLiveDataBus(){
bus =newHashMap<>();
}
privatestaticclassSingletonHolder{
privatestaticfinalLiveDataBus DATA_BUS =newLiveDataBus();
}
publicstaticLiveDataBusget(){
returnSingletonHolder.DATA_BUS;
}
publicMutableLiveData
if(!bus.containsKey(target)) {
bus.put(target,newMutableLiveData<>());
}
return(MutableLiveData) bus.get(target);
}
publicMutableLiveDatagetChannel(String target){
returngetChannel(target, Object.class);
}
}
短短二十行代码，就实现了一个通信总线的全部功能，并且还具有生命周期感知功能，并且使用起来也及其简单：
注册订阅：
LiveDataBus.get().getChannel("key_test", Boolean.class)
.observe(this,new Observer() {
@Override
publicvoidonChanged(@NullableBoolean aBoolean) {
}
});
发送消息：
LiveDataBus.get().getChannel("key_test").setValue(true);
我们发送了一个名为"key_test"，值为true的事件。
这个时候订阅者就会收到消息，并作相应的处理，非常简单。
问题出现
对于LiveDataBus的第一版实现，我们发现，在使用这个LiveDataBus的过程中，订阅者会收到订阅之前发布的消息。对于一个消息总线来说，这是不可接受的。无论EventBus或者RxBus，订阅方都不会收到订阅之前发出的消息。对于一个消息总线，LiveDataBus必须要解决这个问题。
问题分析
怎么解决这个问题呢？先分析下原因：
当LifeCircleOwner的状态发生变化的时候，会调用LiveData.ObserverWrapper的activeStateChanged函数，如果这个时候ObserverWrapper的状态是active，就会调用LiveData的dispatchingValue。
在LiveData的dispatchingValue中，又会调用LiveData的considerNotify方法。
在LiveData的considerNotify方法中，红框中的逻辑是关键，如果ObserverWrapper的mLastVersion小于LiveData的mVersion，就会去回调mObserver的onChanged方法。而每个新的订阅者，其version都是-1，LiveData一旦设置过其version是大于-1的（每次LiveData设置值都会使其version加1），这样就会导致LiveDataBus每注册一个新的订阅者，这个订阅者立刻会收到一个回调，即使这个设置的动作发生在订阅之前。
问题原因总结
对于这个问题，总结一下发生的核心原因。对于LiveData，其初始的version是-1，当我们调用了其setValue或者postValue，其vesion会+1；对于每一个观察者的封装ObserverWrapper，其初始version也为-1，也就是说，每一个新注册的观察者，其version为-1；当LiveData设置这个ObserverWrapper的时候，如果LiveData的version大于ObserverWrapper的version，LiveData就会强制把当前value推送给Observer。
如何解决这个问题
明白了问题产生的原因之后，我们来看看怎么才能解决这个问题。很显然，根据之前的分析，只需要在注册一个新的订阅者的时候把Wrapper的version设置成跟LiveData的version一致即可。
那么怎么实现呢，看看LiveData的observe方法，他会在步骤1创建一个LifecycleBoundObserver，LifecycleBoundObserver是ObserverWrapper的派生类。然后会在步骤2把这个LifecycleBoundObserver放入一个私有Map容器mObservers中。无论ObserverWrapper还是LifecycleBoundObserver都是私有的或者包可见的，所以无法通过继承的方式更改LifecycleBoundObserver的version。
那么能不能从Map容器mObservers中取到LifecycleBoundObserver，然后再更改version呢？答案是肯定的，通过查看SafeIterableMap的源码我们发现有一个protected的get方法。因此，在调用observe的时候，我们可以通过反射拿到LifecycleBoundObserver，再把LifecycleBoundObserver的version设置成和LiveData一致即可。
对于非生命周期感知的observeForever方法来说，实现的思路是一致的，但是具体的实现略有不同。observeForever的时候，生成的wrapper不是LifecycleBoundObserver，而是AlwaysActiveObserver（步骤1），而且我们也没有机会在observeForever调用完成之后再去更改AlwaysActiveObserver的version，因为在observeForever方法体内，步骤3的语句，回调就发生了。
那么对于observeForever，如何解决这个问题呢？既然是在调用内回调的，那么我们可以写一个ObserverWrapper，把真正的回调给包装起来。把ObserverWrapper传给observeForever，那么在回调的时候我们去检查调用栈，如果回调是observeForever方法引起的，那么就不回调真正的订阅者。
LiveDataBus最终实现
publicfinalclassLiveDataBus{
privatefinalMap> bus;
privateLiveDataBus(){
bus =newHashMap<>();
}
privatestaticclassSingletonHolder{
privatestaticfinalLiveDataBus DEFAULT_BUS =newLiveDataBus();
}
publicstaticLiveDataBusget(){
returnSingletonHolder.DEFAULT_BUS;
}
publicMutableLiveData
if(!bus.containsKey(key)) {
bus.put(key,newBusMutableLiveData<>());
}
return(MutableLiveData) bus.get(key);
}
publicMutableLiveDatawith(String key){
returnwith(key, Object.class);
}
privatestaticclassObserverWrapperimplementsObserver{
privateObserver observer;
publicObserverWrapper(Observer
this.observer = observer;
}
@Override
publicvoidonChanged(@Nullable T t){
if(observer !=null) {
if(isCallOnObserve()) {
return;
}
observer.onChanged(t);
}
}
privatebooleanisCallOnObserve(){
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())) {
returntrue;
}
}
}
returnfalse;
}
}
privatestaticclassBusMutableLiveDataextendsMutableLiveData{
privateMap observerMap =newHashMap<>();
@Override
publicvoidobserve(@NonNull LifecycleOwner owner, @NonNull Observer
super.observe(owner, observer);
try{
hook(observer);
}catch(Exception e) {
e.printStackTrace();
}
}
@Override
publicvoidobserveForever(@NonNull Observer
if(!observerMap.containsKey(observer)) {
observerMap.put(observer,newObserverWrapper(observer));
}
super.observeForever(observerMap.get(observer));
}
@Override
publicvoidremoveObserver(@NonNull Observer
Observer realObserver =null;
if(observerMap.containsKey(observer)) {
realObserver = observerMap.remove(observer);
}else{
realObserver = observer;
}
super.removeObserver(realObserver);
}
privatevoidhook(@NonNull Observer
//get wrapper's version
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() {
@Override
publicvoidonChanged(@NullableString s) {
}
});
发送消息：
LiveDataBus.get().with("key_test").setValue(s);
源码说明
LiveDataBus的源码可以直接拷贝使用，也可以前往作者的GitHub仓库查看下载：
https://github.com/JeremyLiao/LiveDataBus
总结
本文提供了一个新的消息总线框架——LiveDataBus。订阅者可以订阅某个消息通道的消息，发布者可以把消息发布到消息通道上。利用LiveDataBus，不仅可以实现消息总线功能，而且对于订阅者，他们不需要关心何时取消订阅，极大减少了因为忘记取消订阅造成的内存泄漏风险。