一、引言
在 Android 开发中，数据的变化需要及时反映到界面上是一个常见的需求。然而，传统的方式可能会导致代码复杂、难以维护，并且容易出现内存泄漏等问题。Jetpack 组件中的 LiveData 为我们提供了一种优雅的解决方案，它是一种可观察的数据持有者类，具有生命周期感知能力，能够确保数据更新时只在合适的生命周期状态下通知观察者，从而避免了内存泄漏和空指针异常等问题。本文将详细介绍 LiveData 的使用方法，并深入剖析其源码原理。
二、LiveData 基本使用
2.1 添加依赖
要使用 LiveData，需要在项目的 build.gradle 文件中添加以下依赖：
implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.6.1'
2.2 创建 LiveData 对象
LiveData 是一个抽象类，通常使用它的子类 MutableLiveData 来创建可修改的 LiveData 对象。以下是一个简单的示例：
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class MyViewModel : ViewModel() {
// 创建一个 MutableLiveData 对象，用于存储整数类型的数据
val currentNumber: MutableLiveData<Int> by lazy {
MutableLiveData<Int>().also {
it.value = 0
}
}
// 增加数字的方法
fun incrementNumber() {
currentNumber.value = (currentNumber.value ?: 0) + 1
}
}
在这个示例中，我们创建了一个 MyViewModel 类，其中包含一个 MutableLiveData 类型的 currentNumber 对象，并提供了一个方法 incrementNumber 来更新该对象的值。
2.3 观察 LiveData 对象
在 Activity 或 Fragment 中，我们可以通过 observe 方法来观察 LiveData 对象的变化，并在数据更新时执行相应的操作。以下是在 Activity 中观察 currentNumber 的示例：
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider
import com.example.livedatademo.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
private lateinit var viewModel: MyViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
// 获取 ViewModel 实例
viewModel = ViewModelProvider(this).get(MyViewModel::class.java)
// 观察 LiveData 对象
viewModel.currentNumber.observe(this) { newNumber ->
// 当数据更新时，更新界面显示
binding.numberTextView.text = newNumber.toString()
}
// 设置按钮点击事件，调用 ViewModel 中的方法更新数据
binding.incrementButton.setOnClickListener {
viewModel.incrementNumber()
}
}
}
在 MainActivity 中，我们通过 observe 方法观察 currentNumber 的变化，当 currentNumber 的值发生改变时，会触发 lambda 表达式中的代码，更新界面上的文本显示。
2.4 其他使用场景
转换 LiveData
LiveData 提供了一些转换方法，如 map 和 switchMap，用于对 LiveData 中的数据进行转换。以下是使用 map 方法的示例：
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Transformations
import androidx.lifecycle.ViewModel
class MyViewModel : ViewModel() {
private val _inputData = MutableLiveData<String>()
val outputData: LiveData<String> = Transformations.map(_inputData) { input ->
// 对输入数据进行转换
"Transformed: $input"
}
fun setInputData(input: String) {
_inputData.value = input
}
}
在这个示例中，我们使用 Transformations.map 方法将 _inputData 中的数据进行转换，并将转换后的结果存储在 outputData 中。
合并 LiveData
可以使用 MediatorLiveData 来合并多个 LiveData 对象，当其中任何一个 LiveData 对象的数据发生变化时，MediatorLiveData 都会收到通知。以下是一个简单的示例：
import androidx.lifecycle.MediatorLiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class MyViewModel : ViewModel() {
private val _source1 = MutableLiveData<String>()
private val _source2 = MutableLiveData<String>()
val mergedData: MediatorLiveData<String> = MediatorLiveData<String>().apply {
// 添加第一个数据源
addSource(_source1) { value ->
value?.let {
this.value = "Source 1: $it"
}
}
// 添加第二个数据源
addSource(_source2) { value ->
value?.let {
this.value = "Source 2: $it"
}
}
}
fun setSource1Data(data: String) {
_source1.value = data
}
fun setSource2Data(data: String) {
_source2.value = data
}
}
在这个示例中，MediatorLiveData 合并了 _source1 和 _source2 两个 LiveData 对象，当其中任何一个数据源的数据发生变化时，mergedData 都会更新。
三、LiveData 源码原理解析
3.1 LiveData 核心类结构
LiveData 主要涉及以下几个核心类：
LiveData：抽象类，定义了 LiveData 的基本行为和接口。MutableLiveData：LiveData的子类，提供了setValue和postValue方法用于更新数据。Observer：观察者接口，用于定义数据更新时的回调方法。LifecycleBoundObserver：实现了Observer接口，并且具有生命周期感知能力，确保只在合适的生命周期状态下通知观察者。
3.2 数据更新机制
setValue 方法
setValue 方法用于在主线程中更新 LiveData 的值，并通知所有活跃的观察者。以下是 setValue 方法的源码：
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
在 setValue 方法中，首先会检查当前线程是否为主线程，然后更新数据的版本号和数据值，最后调用 dispatchingValue 方法来通知观察者。
postValue 方法
postValue 方法用于在非主线程中更新 LiveData 的值，它会将更新操作发送到主线程中执行。以下是 postValue 方法的源码：
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
在 postValue 方法中，会将新的值存储在 mPendingData 中，并通过 ArchTaskExecutor 将 mPostValueRunnable 发送到主线程中执行。在 mPostValueRunnable 中，会调用 setValue 方法来更新数据并通知观察者。
3.3 观察者注册与通知机制
observe 方法
observe 方法用于注册一个具有生命周期感知能力的观察者。以下是 observe 方法的源码：
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// 如果 LifecycleOwner 已经销毁，直接返回
return;
}
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(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);
}
在 observe 方法中，首先会检查当前线程是否为主线程，然后检查 LifecycleOwner 的状态。如果 LifecycleOwner 已经销毁，则直接返回。接着会创建一个 LifecycleBoundObserver 对象，并将其存储在 mObservers 中。最后，将 LifecycleBoundObserver 注册到 LifecycleOwner 的生命周期中。
dispatchingValue 方法
dispatchingValue 方法用于通知观察者数据更新。以下是 dispatchingValue 方法的源码：
private 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;
}
在 dispatchingValue 方法中，会遍历所有的观察者，并调用 considerNotify 方法来通知它们数据更新。
considerNotify 方法
considerNotify 方法用于检查观察者的生命周期状态，并在合适的状态下通知观察者。以下是 considerNotify 方法的源码：
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
// 调用观察者的 onChanged 方法通知数据更新
observer.mObserver.onChanged((T) mData);
}
在 considerNotify 方法中，会检查观察者的活跃状态和版本号，如果观察者不活跃或者版本号已经是最新的，则不会通知观察者。否则，会调用观察者的 onChanged 方法通知数据更新。
四、总结
LiveData 是 Jetpack 组件中一个非常实用的工具，它通过生命周期感知能力和数据更新通知机制，为开发者提供了一种简洁、安全的方式来处理数据和界面的交互。通过 setValue 和 postValue 方法可以更新数据，通过 observe 方法可以注册观察者。在源码层面，LiveData 通过 LifecycleBoundObserver 实现了生命周期感知，确保只在合适的生命周期状态下通知观察者。合理使用 LiveData 可以提高代码的可维护性和稳定性，避免内存泄漏和空指针异常等问题。在实际开发中，结合 ViewModel 等其他 Jetpack 组件，可以构建出更加高效、健壮的 Android 应用。
