LiveData 源码解析（2.4.1 版本）

2024-05-28 12:58
文章标签 源码 2.4 解析 版本 livedata

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

文章目录

      • 1、LiveData 简介
      • 2、LiveData 配置与基本用法
        • 2.1 依赖引入与配置
        • 2.2 基本用法
          • 2.2.1 LiveData 简单使用
          • 2.2.2 LiveData 扩展
          • 2.2.3 LiveData map() 转换
          • 2.2.4 LiveData switchMap() 转换
          • 2.2.5 LiveData 合并多个源（MediatorLiveData）
      • 3、源码解析
        • 3.1 LiveData 核心方法
        • 3.2 LiveData 注册观察者
        • 3.3 LiveData 事件分发
        • 3.4 LiveData 事件更新
      • 4、LiveData 总结
      • 5、LiveData 相关问题
        • 5.1 LiveData 数据倒灌？
        • 5.2 LiveData#postValue(xxx) 数据丢失？
        • 5.3 LiveData 如何感知生命周期？

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、源码解析

LiveData 流程时序图

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 版本）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1010633。

相关文章

使用Jackson进行JSON生成与解析的新手指南

使用Jackson进行JSON生成与解析的新手指南

《使用Jackson进行JSON生成与解析的新手指南》这篇文章主要为大家详细介绍了如何使用Jackson进行JSON生成与解析处理,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1. 核心依赖2. 基础用法2.1 对象转 jsON（序列化）2.2 JSON 转对象（反序列化）3.
阅读更多...
Springboot @Autowired和@Resource的区别解析

Springboot @Autowired和@Resource的区别解析

《Springboot@Autowired和@Resource的区别解析》@Resource是JDK提供的注解,只是Spring在实现上提供了这个注解的功能支持,本文给大家介绍Springboot@... 目录【一】定义【1】@Autowired【2】@Resource【二】区别【1】包含的属性不同【2】@
阅读更多...
SpringCloud动态配置注解@RefreshScope与@Component的深度解析

SpringCloud动态配置注解@RefreshScope与@Component的深度解析

《SpringCloud动态配置注解@RefreshScope与@Component的深度解析》在现代微服务架构中,动态配置管理是一个关键需求,本文将为大家介绍SpringCloud中相关的注解@Re... 目录引言1. @RefreshScope 的作用与原理1.1 什么是 @RefreshScope1.
阅读更多...
Java并发编程必备之Synchronized关键字深入解析

Java并发编程必备之Synchronized关键字深入解析

《Java并发编程必备之Synchronized关键字深入解析》本文我们深入探索了Java中的Synchronized关键字,包括其互斥性和可重入性的特性,文章详细介绍了Synchronized的三种... 目录一、前言二、Synchronized关键字2.1 Synchronized的特性1. 互斥2.
阅读更多...
Linux卸载自带jdk并安装新jdk版本的图文教程

Linux卸载自带jdk并安装新jdk版本的图文教程

《Linux卸载自带jdk并安装新jdk版本的图文教程》在Linux系统中,有时需要卸载预装的OpenJDK并安装特定版本的JDK,例如JDK1.8,所以本文给大家详细介绍了Linux卸载自带jdk并... 目录Ⅰ、卸载自带jdkⅡ、安装新版jdkⅠ、卸载自带jdk1、输入命令查看旧jdkrpm -qa
阅读更多...
Tomcat版本与Java版本的关系及说明

Tomcat版本与Java版本的关系及说明

《Tomcat版本与Java版本的关系及说明》：本文主要介绍Tomcat版本与Java版本的关系及说明,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Tomcat版本与Java版本的关系Tomcat历史版本对应的Java版本Tomcat支持哪些版本的pythonJ
阅读更多...
Python实现无痛修改第三方库源码的方法详解

Python实现无痛修改第三方库源码的方法详解

《Python实现无痛修改第三方库源码的方法详解》很多时候,我们下载的第三方库是不会有需求不满足的情况,但也有极少的情况,第三方库没有兼顾到需求,本文将介绍几个修改源码的操作,大家可以根据需求进行选择... 目录需求不符合模拟示例 1. 修改源文件2. 继承修改3. 猴子补丁4. 追踪局部变量需求不符合很
阅读更多...
Java的IO模型、Netty原理解析

Java的IO模型、Netty原理解析

《Java的IO模型、Netty原理解析》Java的I/O是以流的方式进行数据输入输出的,Java的类库涉及很多领域的IO内容：标准的输入输出,文件的操作、网络上的数据传输流、字符串流、对象流等,这篇... 目录1.什么是IO2.同步与异步、阻塞与非阻塞3.三种IO模型BIO（blocking I/O）NI
阅读更多...
Python 中的异步与同步深度解析(实践记录)

Python 中的异步与同步深度解析(实践记录)

《Python中的异步与同步深度解析(实践记录)》在Python编程世界里,异步和同步的概念是理解程序执行流程和性能优化的关键,这篇文章将带你深入了解它们的差异,以及阻塞和非阻塞的特性,同时通过实际... 目录python中的异步与同步：深度解析与实践异步与同步的定义异步同步阻塞与非阻塞的概念阻塞非阻塞同步
阅读更多...
IDEA中Git版本回退的两种实现方案

IDEA中Git版本回退的两种实现方案

《IDEA中Git版本回退的两种实现方案》作为开发者,代码版本回退是日常高频操作,IntelliJIDEA集成了强大的Git工具链,但面对reset和revert两种核心回退方案,许多开发者仍存在选择... 目录一、版本回退前置知识二、Reset方案：整体改写历史1、IDEA图形化操作（推荐）1.1、查看提
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2