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。

相关文章

Agent开发核心技术解析以及现代Agent架构设计

Agent开发核心技术解析以及现代Agent架构设计

《Agent开发核心技术解析以及现代Agent架构设计》在人工智能领域,Agent并非一个全新的概念,但在大模型时代,它被赋予了全新的生命力,简单来说,Agent是一个能够自主感知环境、理解任务、制定... 目录一、回归本源：到底什么是Agent？二、核心链路拆解：Agent的"大脑"与"四肢"1. 规划模
阅读更多...
MySQL字符串转数值的方法全解析

MySQL字符串转数值的方法全解析

《MySQL字符串转数值的方法全解析》在MySQL开发中,字符串与数值的转换是高频操作,本文从隐式转换原理、显式转换方法、典型场景案例、风险防控四个维度系统梳理,助您精准掌握这一核心技能,需要的朋友可... 目录一、隐式转换：自动但需警惕的&ld编程quo;双刃剑”二、显式转换：三大核心方法详解三、典型场景
阅读更多...
SQL 注入攻击(SQL Injection)原理、利用方式与防御策略深度解析

SQL 注入攻击(SQL Injection)原理、利用方式与防御策略深度解析

《SQL注入攻击(SQLInjection)原理、利用方式与防御策略深度解析》本文将从SQL注入的基本原理、攻击方式、常见利用手法,到企业级防御方案进行全面讲解,以帮助开发者和安全人员更系统地理解... 目录一、前言二、SQL 注入攻击的基本概念三、SQL 注入常见类型分析1. 基于错误回显的注入（Erro
阅读更多...
C++ 多态性实战之何时使用 virtual 和 override的问题解析

C++ 多态性实战之何时使用 virtual 和 override的问题解析

《C++多态性实战之何时使用virtual和override的问题解析》在面向对象编程中,多态是一个核心概念,很多开发者在遇到override编译错误时,不清楚是否需要将基类函数声明为virt... 目录C++ 多态性实战：何时使用 virtual 和 override？引言问题场景判断是否需要多态的三个关
阅读更多...
Python包管理工具uv下载python版本慢问题解决办法

Python包管理工具uv下载python版本慢问题解决办法

《Python包管理工具uv下载python版本慢问题解决办法》uv是一个非常快的Python包和项目管理器,用Rust编写,使用热缓存安装Trio的依赖项的速度对比,：本文主要介绍Python包... 目录发现问题对于 MACOS / linux 用户 (zsh/bash):对于 Windows 用户:总
阅读更多...
Springboot主配置文件解析

Springboot主配置文件解析

《Springboot主配置文件解析》SpringBoot主配置文件application.yml支持多种核心值类型,包括字符串、数字、布尔值等,文章详细介绍了Profile环境配置和加载位置,本文... 目录Profile环境配置配置文件加载位置Springboot主配置文件 application.ym
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...
一文解析C#中的StringSplitOptions枚举

一文解析C#中的StringSplitOptions枚举

《一文解析C#中的StringSplitOptions枚举》StringSplitOptions是C#中的一个枚举类型,用于控制string.Split()方法分割字符串时的行为,核心作用是处理分割后... 目录C#的StringSplitOptions枚举1.StringSplitOptions枚举的常用
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2