LiveData 源码解析（2.4.1 版本）

本文主要是介绍LiveData 源码解析（2.4.1 版本），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1、LiveData 简介

• Android Jetpack 库中的一员，是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
• 官方文档

2、LiveData 配置与基本用法

2.1 依赖引入与配置

• 正常情况下无需单独引入 LiveData 相关库，因为androidx.appcompat:appcompat:1.4.1会自带 Lifecycle、LiveData、ViewModel 等依赖库。
• 如果想单独引入 LiveData 或者其其它相关扩展库可如下操作：

// 模块的 build.gradle
// LiveData
implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.4.1'
// 可选：对 LiveData 的 ReactiveStreams 支持
implementation 'androidx.lifecycle:lifecycle-reactivestreams-ktx:2.4.1'
// 可选 - LiveData 的测试助手
testImplementation 'androidx.arch.core:core-testing:2.1.0'// 只有 Lifecycles（不带 ViewModel 或 LiveData）
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.1'
// 注释处理器
kapt 'androidx.lifecycle:lifecycle-compiler:2.4.1'
// 替换 - 如果使用 Java8，请使用此注释处理器，而不是 lifecycle-compiler 注释处理器
implementation 'androidx.lifecycle:lifecycle-common-java8:2.4.1'
// 可选 - 在 Service 中实现 LifecycleOwner 的助手
implementation 'androidx.lifecycle:lifecycle-service:2.4.1'
// 可选 - ProcessLifecycleOwner 给整个 App 前后台切换提供生命周期监听
implementation 'androidx.lifecycle:lifecycle-process:2.4.1'// ViewModel
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.1'
// 用于 Compose 的 ViewModel 实用程序
implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.4.1'
// ViewModel 的已保存状态模块
implementation 'androidx.lifecycle:lifecycle-viewmodel-savedstate:2.4.1'

2.2 基本用法

2.2.1 LiveData 简单使用

class TestModel : ViewModel() {private val _helloLiveData: MutableLiveData<String> by lazy {MutableLiveData<String>()}val helloLiveData = _helloLiveDatafun updateMessage(message: String) {_helloLiveData.postValue(message)}
}class MainActivity : AppCompatActivity() {private val mViewModel: TestModel by viewModels()override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)// 指定源数据类型为Stringval helloLiveData = MutableLiveData<String>()helloLiveData.observe(this) { message ->Log.d("MainActivity", "onChanged:$message")}// 更新源数据，限定在主线程helloLiveData.setValue("Hello LiveData")// 更新源数组，主线程和子线程都可helloLiveData.postValue("Hello LiveData")// LiveData + ViewModelmViewModel.helloLiveData.observe(this) { message ->Log.d("TestModel", "onChanged:$message")}mViewModel.helloLiveData.postValue("Hello LiveData And ViewModel")}
}

2.2.2 LiveData 扩展

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {private val stockManager = StockManager(symbol)private val listener = { price: BigDecimal ->value = price}override fun onActive() {stockManager.requestPriceUpdates(listener)}override fun onInactive() {stockManager.removeUpdates(listener)}
}public class MyFragment : Fragment() {override fun onViewCreated(view: View, savedInstanceState: Bundle?) {super.onViewCreated(view, savedInstanceState)val myPriceListener: LiveData<BigDecimal> = ...myPriceListener.observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->// Update the UI.})}
}

2.2.3 LiveData map() 转换

val mutableLiveData = MutableLiveData<String>()
mutableLiveData.observe(this) {Log.d("MainActivity", "onChanged1: $it")
}
// LiveData 返回值实例转换
val transformedLiveData = Transformations.map(mutableLiveData) { name ->"${name}，This is LiveData map()"
}
transformedLiveData.observe(this) {Log.d("MainActivity", "onChange2: $it")
}
mutableLiveData.postValue("Hello LiveData ")// 打印结果
MainActivity: onChanged1: Hello LiveData 
MainActivity: onChange2: Hello LiveData ，This is LiveData map()

2.2.4 LiveData switchMap() 转换

val mutableLiveData1 = MutableLiveData<String>()
val mutableLiveData2 = MutableLiveData<String>()
val liveDataSwitch = MutableLiveData<Boolean>()
val transformedLiveData: LiveData<String> = Transformations.switchMap(liveDataSwitch) {if (it) mutableLiveData1 else mutableLiveData2
}
transformedLiveData.observe(this){Log.d("MainActivity","onChanged: $it")
}
liveDataSwitch.postValue(false)
mutableLiveData1.postValue("LiveData1 postValue")
mutableLiveData2.postValue("LiveData2 postValue")// 打印结果
MainActivity: onChanged: LiveData2 postValue

2.2.5 LiveData 合并多个源（MediatorLiveData）

• 通过 MediatorLiveData 的 addSource 将两个 MutableLiveData 合并到一起，这样当任何一个 MutableLiveData 数据发生变化时，MediatorLiveData 都可以感知到。

val mutableLiveData1 = MutableLiveData<String>()
val mutableLiveData2 = MutableLiveData<String>()
val mediatorLiveData = MediatorLiveData<Boolean>()
mediatorLiveData.addSource(mutableLiveData1){Log.d("MainActivity","onChange1: $it")
}
mediatorLiveData.addSource(mutableLiveData2){Log.d("MainActivity","onChange2: $it")
}
mediatorLiveData.observe(this){Log.d("MainActivity","onChanged3: $it")
}
mutableLiveData1.postValue("LiveData1 postValue")
mutableLiveData2.postValue("LiveData2 postValue")
Thread.sleep(300)
mutableLiveData1.postValue("change LiveData1 data")// 打印结果
MainActivity: onChange1: change LiveData1 data
MainActivity: onChange2: LiveData2 postValue

3、源码解析

3.1 LiveData 核心方法

方法名	作用
observe(LifecycleOwner owner, Observer observer)	注册和宿主生命周期关联的观察者
observeForever(Observer observer)	注册观察者，不会反注册，需自行维护
setValue(T data)	发送数据，没有活跃的观察者时不分发，且只能在主线程
postValue(T data)	和 setValue() 方法一样，且不受线程环境限制
onActive()	当且仅当有一个活跃的观察者时会触发
onInactive()	不存在活跃的观察者时会触发

3.2 LiveData 注册观察者

• LivaData 通过 observer(LifecycleOwner owner, Observer observer) 或者 observeForever(Observer observer) 方法来注册观察者。
• observer(LifecycleOwner owner, Observer observer)：受宿主生命周期影响。
• observeForever(Observer observer)：不受宿主生命周期影响。

// LiveData.java
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {assertMainThread("observe");// 当前绑定的组件（activity 或 fragment）状态为为 DESTROYED 的时候，则会忽视当前的订阅请求if (owner.getLifecycle().getCurrentState() == DESTROYED) {// ignorereturn;}// 创建生命周期感知的观察者包装类LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);// 如果指定的键尚未与某个值关联，则将其与给定的值关联ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);// 对应观察者只能与一个 owner 绑定，负责抛出异常if (existing != null && !existing.isAttachedTo(owner)) {throw new IllegalArgumentException("Cannot add the same observer"+ " with different lifecycles");}if (existing != null) {return;}// 添加一个 LifecycleObserver，它将在 LifecycleOwner 更改状态时得到通知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);
}

3.3 LiveData 事件分发

// LiveData
public abstract class LiveData<T> {...private abstract class ObserverWrapper {final Observer<? super T> mObserver;boolean mActive;int mLastVersion = START_VERSION;ObserverWrapper(Observer<? super T> observer) {mObserver = observer;}abstract boolean shouldBeActive();boolean isAttachedTo(LifecycleOwner owner) {return false;}void detachObserver() {}void activeStateChanged(boolean newActive) {// 活跃状态未发生改变，不会处理if (newActive == mActive) {return;}// immediately set active state, so we'd never dispatch anything to inactive// ownermActive = newActive;changeActiveCounter(mActive ? 1 : -1);if (mActive) {// 观察者变为活跃，进行数据分发dispatchingValue(this);}}}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 abstract class ObserverWrapper {final Observer<? super T> mObserver;boolean mActive;int mLastVersion = START_VERSION;ObserverWrapper(Observer<? super T> observer) {mObserver = observer;}abstract boolean shouldBeActive();boolean isAttachedTo(LifecycleOwner owner) {return false;}void detachObserver() {}void activeStateChanged(boolean newActive) {// 活跃状态未发生改变，不会处理if (newActive == mActive) {return;}// immediately set active state, so we'd never dispatch anything to inactive// ownermActive = newActive;changeActiveCounter(mActive ? 1 : -1);if (mActive) {// 观察者变为活跃，进行数据分发dispatchingValue(this);}}}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) {// 观察者非活跃，直接r eturnreturn;}// 观察者状态活跃，但是当前变为了不可见状态，再调用 activeStateChanged 方法，并传入 false，其内部会再次判断if (!observer.shouldBeActive()) {observer.activeStateChanged(false);return;}// 如果数据版本已经是最新的了，那么直接返回if (observer.mLastVersion >= mVersion) {return;}// 修改数据版本observer.mLastVersion = mVersion;// 回调真正的 mObserver 的 onChanged() 方法observer.mObserver.onChanged((T) mData);}...
}

3.4 LiveData 事件更新

// LiveData.java
protected void postValue(T value) {boolean postTask;// 用于判断是否要更新synchronized (mDataLock) {// 加锁解决多个子线程同时调用问题postTask = mPendingData == NOT_SET;mPendingData = value;// 将数据存入 mPendingData}if (!postTask) {return;}// 通过线程池分发到主线程去处理ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}@MainThread
protected void setValue(T value) {assertMainThread("setValue");// 检查是否在主线程mVersion++;// 默认值是 -1，每次更新数据都会自增mData = value;// 更新的数据赋值给 mData// 调用 dispatchingValue() 方法并传入 null，将数据分发给所有观察者// 注意：dispatchingValue 如果传入 null 则是所有的观察者，如果是具体的 ObserverWrapper 对象，则通知到具体的 ObserverdispatchingValue(null);
}

4、LiveData 总结

• 注册观察者：LiveData 调用 observer() 方法，将其 lifecycleOwner 和 observer 对象封装成一个 LifecycleBoundObserver 对象，并以 observer 为 key，LifecycleBoundObserver 为 value 添加到一个 Map 集合中，最终再调用 Lifecycle 的 addObserver() 方法将 LifecycleBoundObserver 传递进去。
• 事件分发：当回调 LifecycleBoundObserver 的 onStateChanged() 方法，仅当宿主的状态最多为 resumed 活跃状态时，才会分发最新数据到每个观察者，并且最终回调到 Observer 的 onChange() 方法中进行回到。
• 事件更新：当 LiveData 调用 postValue() 方法更新数据时，会通过 ArchTaskExecutor 线程池分发到主线程去处理，然后在 Runnalbel 中调用 setValue() 方法，最终通过 LiveData 的 dispatchingValue(null) 方法去同事所有的观察者。

5、LiveData 相关问题

5.1 LiveData 数据倒灌？

• LiveData 的设计原则：在页面重建时，LiveData 自动推送最后一次数据，不必重新去向后台请求。
• 常见的页面重建场景有：屏幕旋转、系统语言切换、内存不足，应用在后台被系统杀死之后用户再重新进入应用等情况。
• Activity 等页面重建后，LiveData 调用 observe()，方法内会 new 一个新的 LifecycleBoundObserver 对象，该对象继承 ObserverWrapper 类，ObserverWrapper 类初始化会重新初始化 int mLastVersion = START_VERSION，并将 mLastVersion 赋值为 -1，因为 observer.mLasterVersion < mVersion ，considerNotify() 方法中的判断失效，重新分发事件，导致数据倒灌。
• 官方解决方法：

public class SingleLiveEvent<T> extends MutableLiveData<T> {private static final String TAG = "SingleLiveEvent";private final AtomicBoolean mPending = new AtomicBoolean(false);@MainThreadpublic void observe(LifecycleOwner owner, final Observer<T> observer) {if (hasActiveObservers()) {Log.w(TAG, "Multiple observers registered but only one will be notified of changes.");}// Observe the internal MutableLiveDatasuper.observe(owner, new Observer<T>() {@Overridepublic void onChanged(@Nullable T t) {if (mPending.compareAndSet(true, false)) {observer.onChanged(t);}}});}@MainThreadpublic void setValue(@Nullable T t) {mPending.set(true);super.setValue(t);}/*** Used for cases where T is Void, to make calls cleaner.*/@MainThreadpublic void call() {setValue(null);}
}

5.2 LiveData#postValue(xxx) 数据丢失？

• 调用 postValue() 方法时，其实只是将值暂存到 mPendingData 变量中，然后往主线程抛一个 Runnable，接着 setValue(xxx) 方法将暂存的值设置进去，回调观察者，但是如果在这个 Runnable 真正执行前多次 postValue()，只会改变暂存值 mPendingData，通过 postTask 的检测不会再往主线程抛 Runnable。

5.3 LiveData 如何感知生命周期？

• LiveData#observer() 方法会传入 LifecycleOwner 对象（以 Fragment 为例）。LifecycleOwner 是一个接口，内部的 getLifecycle() 方法会返回一个 Lifecycle 对象。Fragment 实现了该接口，并返回 LifecycleRegistry 对象，当 Fragemnt 的生命周期发生变化时，会调用 LifecycleRegistry.handleLifecycleEvent(0 方法传入相应的生命周期，最后会调用到 onStateChanged() 将生命周期分发给添加进来的观察者。
• 而这个观察者其实就是在 LiveData.observer() 方法中创建的 LifecycleBoundObserver 对象。在 LifecycleBoundObserver.onStateChanged() 方法中会调用 activeStateChanged() -> dispatchingValue() -> 遍历所有的观察者调用 considerNotify() -> Observer.onChanged() -> 执行相应的操作。

这篇关于LiveData 源码解析（2.4.1 版本）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---