多模块数据混乱？LiveData总线污染的三种防御架构设计

public class LiveDataBus {

    private final HashMap<String, MutableLiveData<Object>> eventMap = new HashMap<>();

    public MutableLiveData<Object> with(String key) {

        return eventMap.getOrDefault(key, new MutableLiveData<>());

    }  
}  

object ModuleLiveDataBus {

    // 三级Key结构：模块名_子域_事件名

    privateval busMap = ConcurrentHashMap<String, MutableLiveData<*>>()  
    funbuildKey(module: String, domain: String, event: String): String {

        return"
${module}_$
{domain}_$event"

    }  
    @Suppress("UNCHECKED_CAST")

    fun<T>getChannel(module: String, domain: String, event: String): MutableLiveData<T> {

        val key = buildKey(module, domain, event)

        return busMap.getOrPut(key) { SafeMutableLiveData<T>() } as MutableLiveData<T>

    }  
}  

class AutoCleanObserverextendsLifecycleBoundObserver {

    privatefinal WeakReference<Context> moduleContext;  
    @Override

    publicvoidonStateChanged(@NonNull LifecycleOwner source, Lifecycle.Event event) {

        if (event == Lifecycle.Event.ON_DESTROY) {

            // 模块Context销毁时自动解除订阅

            if (moduleContext.get() == null || moduleContext.get().isDestroyed()) {

                liveData.removeObserver(this);

            }

        }

        super.onStateChanged(source, event);

    }  
}  

public classSafeMutableLiveData<T> extendsMutableLiveData<T> {

    privatefinalAtomicLongeventVersion=newAtomicLong(0);

    privatefinal Map<Observer<? super T>, Long> observerVersions = newConcurrentHashMap<>();  
    @Override

    publicvoidobserve(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {

        super.observe(owner, newObserver<T>() {

            @Override

            publicvoidonChanged(T t) {

                longcurrentVersion= eventVersion.get();

                if (observerVersions.getOrDefault(observer, -1L) < currentVersion) {

                    observer.onChanged(t);

                    observerVersions.put(observer, currentVersion);

                }

            }

        });

    }  
    @Override

    publicvoidsetValue(T value) {

        eventVersion.incrementAndGet();

        super.setValue(value);

    }  
}  

// 基于APT的编译期隔离方案  
@ModuleEvent(module = "user", domain = "profile")
publicclassUserProfileEvent {

    @EventKey("update")

    publicstaticfinal MutableLiveData<User> UPDATE = newSafeMutableLiveData<>();  
}  
// 编译后生成隔离代码  
publicfinalclassUserProfileEventWrapper {

    publicstatic MutableLiveData<User> getUpdateChannel() {

        return ModuleLiveDataBus.getChannel("user", "profile", "update");

    }  
}  

inline fun <reified T> receiveEvent(key: String): LiveData<T> {

    return liveDataBus.with(key).filter { it is T } as LiveData<T>  
}