Android~LiveData原理

• 减少内存泄漏；

• 当Activity停止时不会引发奔溃，不需要解决生命周期带来的问题；

• 组件和数据相关的内容能够实时更新到UI；

• 对于横竖屏切换时不需要做额外的处理来保存数据，解决了Configuration Change问题。

LiveData源码分析

在分析源码前，我们需要大概知道，LiveData内部保存了LifecycleOwner和Observer，利用LifecycleOwner感知并处理声明中期的变化，Observer在数据改变时遍历所有观察者并回调方法。因为LiveData并不复杂离开了LifecycleOwner、Observer，LiveData可能啥都不是。接下来我按照正常的调用顺序来分析源码。

new MutableLiveData<>()

首先LiveData是抽象类不能直接初始化，我们需要使用MutableLiveData创建。我们直接去看它的父类的构造函数，两种实现，带参数的是用外部传进来的引用并且mVersion+1；不带参的，NOT_SET由LiveData自己内部创建，mVersion为-1。

static final Object NOT_SET = new Object();

public LiveData(T value) {

mData = value;

mVersion = START_VERSION + 1;

}

public LiveData() {

mData = NOT_SET;

mVersion = START_VERSION;

}

setValue & postValue

通过断言，setValue只能在主线程中调用，更新mVersion复制操作，然后dispatchingValue分发Value。dispatchingValue中则是通过mDispatchingValue、mDispatchInvalidated标记判断是否进行分发，最后遍历mObservers并调用considerNotify，在considerNotify中做真正的分发逻辑。

@MainThread

protected void setValue(T value) {

assertMainThread(“setValue”);

mVersion++;

mData = value;

dispatchingValue(null);

}

private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =

new SafeIterableMap<>();

void dispatchingValue(@Nullable ObserverWrapper initiator) {

if (mDispatchingValue) {

mDispatchInvalidated = true;

return;

}

mDispatchingValue = true;

do {

mDispatchInvalidated = false;

if (initiator != null) {

considerNotify(initiator);

initiator = null;

} else {

for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =

mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {

considerNotify(iterator.next().getValue());

if (mDispatchInvalidated) {

break;

}

}

}

} while (mDispatchInvalidated);

mDispatchingValue = false;

}

private void considerNotify(ObserverWrapper observer) {

if (!observer.mActive) {

return;

}

// Check latest state b4 dispatch. Maybe it changed state but we didn’t get the event yet.

//

// we still first check observer.active to keep it as the entrance for events. So even if

// the observer moved to an active state, if we’ve not received that event, we better not

// notify for a more predictable notification order.

if (!observer.shouldBeActive()) {

observer.activeStateChanged(false);

return;

}

if (observer.mLastVersion >= mVersion) {

return;

}

observer.mLastVersion = mVersion;

observer.mObserver.onChanged((T) mData);

}

considerNotify

这里的mObservers是一个SafeIterableMap迭代器实现的HashMap容器，它是由ObserverWrapper构成，ObserverWrapper又包含了Observer接口实现。它内部调用ObserverWrapper对象判断，自带的属性mActive和mLastVersion，最终调用mObserver的onChanged，下发到具体的观察者。

postValue用于在异步线程中调用，内部则使用了对象锁，更新mPendingData取出数据最终setValue。

private final Runnable mPostValueRunnable = new Runnable() {

@SuppressWarnings(“unchecked”)

@Override

public void run() {

Object newValue;

synchronized (mDataLock) {

newValue = mPendingData;

mPendingData = NOT_SET;

}

setValue((T) newValue);

}

};

protected void postValue(T value) {

boolean postTask;

synchronized (mDataLock) {

postTask = mPendingData == NOT_SET;

mPendingData = value;

}

if (!postTask) {

return;

}

ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

}

observe

同样也是通过断言控制在主线程中执行，然后判断LifecycleOwner持有者的状态，假如不等于DESTROYED，创建LifecycleBoundObserver生命期范围的观察者，将它放到mObservers容器中，根据存放情况决定owner是否需要wrapper对象。observeForever则是用于观察不需要关联生命期类型的数据，逻辑和obseve类似只是AlwaysActiveObserver不同。

@MainThread

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {

assertMainThread(“observe”);

if (owner.getLifecycle().getCurrentState() == DESTROYED) {

// ignore

return;

}

LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);

ObserverWrapper existing = mObservers.p
utIfAbsent(observer, wrapper);

if (existing != null && !existing.isAttachedTo(owner)) {

throw new IllegalArgumentException(“Cannot add the same observer”

• " with different lifecycles");

}

if (existing != null) {

return;

}

owner.getLifecycle().addObserver(wrapper);

}

@MainThread

public void observeForever(@NonNull Observer<? super T> observer) {

assertMainThread(“observeForever”);

AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);

ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);

if (existing instanceof LiveData.LifecycleBoundObserver) {

throw new IllegalArgumentException(“Cannot add the same observer”

• " with different lifecycles");

}

if (existing != null) {

return;

}

wrapper.activeStateChanged(true);

}

LiveData的粘性事件

粘性事件产生的原因：LiveData天生支持粘性事件，因为它的实现就是这样的。大多数场合我们还是需要用到粘性事件的。如果是多个界面公用同一个ViewModel时，会出现该情况，又比如obser里面还做了一些计算或复杂的业务操作，就会有影响。

正常流程，在注册时没有收到消息。非正常的流程则是，注册之前就有消息被收到，就导致mLastVersion<mVersion，从而触发onChange最终导致了粘性事件。

最后

小编这些年深知大多数初中级Android工程师，想要提升自己，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

如果你需要这些资料， ⬅ 专栏获取
RQXtxm-1719171987790)]

[外链图片转存中…(img-5WH0enT6-1719171987790)]

[外链图片转存中…(img-OLMnMsZC-1719171987791)]

[外链图片转存中…(img-Vlz4LMn0-1719171987791)]

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

如果你需要这些资料， ⬅ 专栏获取