Android livedata 源码解剖，34岁程序员年薪50w

最新推荐文章于 2024-11-06 15:48:13 发布

2401_84149635

最新推荐文章于 2024-11-06 15:48:13 发布

阅读量246

点赞数 3

分类专栏：程序员文章标签： android

本文链接：https://blog.csdn.net/2401_84149635/article/details/137414576

版权

程序员专栏收录该内容

283 篇文章 0 订阅

订阅专栏

}

// 添加 observer

owner.getLifecycle().addObserver(wrapper);

}

首先，我们先来看一下它的 observe 方法，首先通过 owner.getLifecycle().getCurrentState() 获取状态，判断是否已经被销毁，如果已经被销毁，直接返回。接着用 LifecycleBoundObserver 包装起来。然后从缓存的 mObservers 中读取 observer，如果有，证明已经添加过了。

observe 方法，小结起来就是

判断是否已经销毁，如果销毁，直接移除
用 LifecycleBoundObserver 包装传递进来的 observer
是否已经添加过，添加过，直接返回
将包装后的 LifecycleBoundObserver 添加进去

因此，当 owner 你（Activity 或者 fragment）生命周期变化的时候，会回调 LifecycleBoundObserver 的 onStateChanged 方法，onStateChanged 方法又会回调 observer 的 onChange 方法

LifecycleBoundObserver

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {

@NonNull final LifecycleOwner mOwner;

LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer observer) {

super(observer);

mOwner = owner;

}

@Override

boolean shouldBeActive() {

return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);

}

@Override

public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {

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

removeObserver(mObserver);

return;

}

activeStateChanged(shouldBeActive());

}

@Override

boolean isAttachedTo(LifecycleOwner owner) {

return mOwner == owner;

}

@Override

void detachObserver() {

mOwner.getLifecycle().removeObserver(this);

}

我们来看一下 LifecycleBoundObserver，继承 ObserverWrapper，实现了 GenericLifecycleObserver 接口。而 GenericLifecycleObserver 接口又实现了 LifecycleObserver 接口。它包装了我们外部的 observer，有点类似于代理模式。

GenericLifecycleObserver#onStateChanged

Activity 回调周期变化的时候，会回调 onStateChanged ，会先判断 mOwner.getLifecycle().getCurrentState() 是否已经 destroy 了，如果。已经 destroy，直接移除观察者。这也就是为什么我们不需要手动 remove observer 的原因。

如果不是销毁状态，会调用 activeStateChanged 方法，携带的参数为 shouldBeActive() 返回的值。

而当 lifecycle 的 state 为 started 或者 resume 的时候，shouldBeActive 方法的返回值为 true，即表示激活。

void activeStateChanged(boolean newActive) {

if (newActive == mActive) {

return;

}

// immediately set active state, so we’d never dispatch anything to inactive

// owner

mActive = newActive;

boolean wasInactive = LiveData.this.mActiveCount == 0;

LiveData.this.mActiveCount += mActive ? 1 : -1;

if (wasInactive && mActive) {

onActive();

}

if (LiveData.this.mActiveCount == 0 && !mActive) {

onInactive();

}

if (mActive) {

dispatchingValue(this);

}

activeStateChanged 方法中，，当 newActive 为 true，并且不等于上一次的值，会增加 LiveData 的 mActiveCount 计数。接着可以看到，onActive 会在 mActiveCount 为 1 时触发，onInactive 方法则只会在 mActiveCount 为 0 时触发。即回调 onActive 方法的时候活跃的 observer 恰好为 1，回调 onInactive 方法的时候，没有一个 Observer 处于激活状态。

当 mActive 为 true 时，会促发 dispatchingValue 方法。

dispatchingValue

private void dispatchingValue(@Nullable ObserverWrapper initiator) {

// 如果正在处理，直接返回

if (mDispatchingValue) {

mDispatchInvalidated = true;

return;

}

mDispatchingValue = true;

do {

mDispatchInvalidated = false;

// initiator 不为 null，调用 considerNotify 方法

if (initiator != null) {

considerNotify(initiator);

initiator = null;

} else { // 为 null 的时候，遍历所有的 obsever，进行分发

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

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

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

if (mDispatchInvalidated) {

break;

}

} while (mDispatchInvalidated);

// 分发完成，设置为 false

mDispatchingValue = false;

}

其中 mDispatchingValue, mDispatchInvalidated 只在 dispatchingValue 方法中使用，显然这两个变量是为了防止重复分发相同的内容。当 initiator 不为 null，只处理当前 observer，为 null 的时候，遍历所有的 obsever，进行分发

considerNotify 方法

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;

//noinspection unchecked

// 调用外部的 mObserver 的 onChange 方法

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

}

如果状态不是在活跃中，直接返回，这也就是为什么当我们的 Activity 处于 onPause， onStop， onDestroy 的时候，不会回调 observer 的 onChange 方法的原因。
判断数据是否是最新，如果是最新，返回，不处理
数据不是最新，回调 mObserver.onChanged 方法。并将 mData 传递过去

setValue

@MainThread

protected void setValue(T value) {

assertMainThread(“setValue”);

mVersion++;

mData = value;

dispatchingValue(null);

}

setValue 方法中，首先，断言是主线程，接着 mVersion + 1; 并将 value 赋值给 mData，接着调用 dispatchingValue 方法。dispatchingValue 传递 null，代表处理所有的 observer。

这个时候如果我们依附的 activity 处于 onPause 或者 onStop 的时候，虽然在 dispatchingValue 方法中直接返回，不会调用 observer 的 onChange 方法。但是当所依附的 activity 重新回到前台的时候，会促发 LifecycleBoundObserver onStateChange 方法，onStateChange 又会调用 dispatchingValue 方法，在该方法中，因为 mLastVersion < mVersion。所以会回调 obsever 的 onChange 方法，这也就是 LiveData 设计得比较巧妙的一个地方

同理，当 activity 处于后台的时候，您多次调用 livedata 的 setValue 方法，最终只会回调 livedata observer 的 onChange 方法一次。

postValue

protected void postValue(T value) {

boolean postTask;

// 锁住

synchronized (mDataLock) {

// 当前没有人在处理 post 任务

postTask = mPendingData == NOT_SET;

mPendingData = value;

}

if (!postTask) {

return;

}

AppToolkitTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

}

private final Runnable mPostValueRunnable = new Runnable() {

@Override

public void run() {

Object newValue;

synchronized (mDataLock) {

newValue = mPendingData;

// 处理完毕之后将 mPendingData 置为 NOT_SET

mPendingData = NOT_SET;

}

//noinspection unchecked

setValue((T) newValue);

}

};

首先，采用同步机制，通过 postTask = mPendingData == NOT_SET 有没有人在处理任务。 true，没人在处理任务， false ，有人在处理任务，有人在处理任务的话，直接返回
调用 AppToolkitTaskExecutor.getInstance().postToMainThread 到主线程执行 mPostValueRunnable 任务。

@MainThread

public void observeForever(@NonNull Observer observer) {

AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);

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

if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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