LiveData 概览 Android Jetpack 的一部分。
LiveData
是一个可观察的数据持有者类。与常规可观察对象不同,LiveData 具有生命周期感知能力,这意味着它尊重其他应用组件(如 Activity、Fragment 或 Service)的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
如果观察者的生命周期处于 STARTED
或 RESUMED
状态,LiveData 会认为该观察者(由 Observer
类表示)处于活跃状态。LiveData 只会通知活跃的观察者有关更新。注册以观察 LiveData
对象的非活跃观察者不会收到更改通知。
您可以注册一个观察者,并将其与一个实现 LifecycleOwner
接口的对象配对。当相应的 Lifecycle
对象的状态变为 DESTROYED
时,此关系允许移除观察者。这对于 Activity 和 Fragment 尤其有用,因为它们可以安全地观察 LiveData
对象,而不必担心内存泄漏——Activity 和 Fragment 在其生命周期被销毁时会立即取消订阅。
有关如何使用 LiveData 的更多信息,请参阅使用 LiveData 对象。
使用 LiveData 的优势
使用 LiveData 具有以下优势
- 确保界面与数据状态匹配
- LiveData 遵循观察者模式。当底层数据发生变化时,LiveData 会通知
Observer
对象。您可以整合代码,以在这些Observer
对象中更新界面。这样,您就不必在应用数据每次更改时都更新界面,因为观察者会为您完成此操作。 - 无内存泄漏
- 观察者绑定到
Lifecycle
对象,并在其关联的生命周期被销毁时自行清理。 - 不会因 Activity 停止而崩溃
- 如果观察者的生命周期不活跃,例如 Activity 在返回堆栈中,则它不会收到任何 LiveData 事件。
- 无需手动处理生命周期
- 界面组件只需观察相关数据,无需停止或恢复观察。LiveData 会自动管理这一切,因为它在观察时会感知相关的生命周期状态变化。
- 始终保持数据最新
- 如果生命周期变为不活跃状态,它会在再次活跃时收到最新数据。例如,处于后台的 Activity 在返回前台后会立即收到最新数据。
- 正确的配置更改
- 如果 Activity 或 Fragment 因配置更改(如设备旋转)而重新创建,它会立即收到最新的可用数据。
- 共享资源
- 您可以使用单例模式扩展
LiveData
对象,以包装系统服务,使其可在应用中共享。LiveData
对象只需连接到系统服务一次,然后任何需要该资源的观察者都可以观察LiveData
对象。有关更多信息,请参阅扩展 LiveData。
使用 LiveData 对象
请按照以下步骤使用 LiveData
对象
- 创建
LiveData
实例以持有特定类型的数据。这通常在您的ViewModel
类中完成。 - 创建
Observer
对象,它定义了onChanged()
方法,该方法控制当LiveData
对象持有的数据更改时发生的情况。您通常在 UI 控制器中创建Observer
对象,例如 Activity 或 Fragment。 使用
observe()
方法将Observer
对象附加到LiveData
对象。observe()
方法接受一个LifecycleOwner
对象。这将Observer
对象订阅到LiveData
对象,以便在发生更改时收到通知。您通常在 UI 控制器中附加Observer
对象,例如 Activity 或 Fragment。
当您更新 LiveData
对象中存储的值时,只要附加的 LifecycleOwner
处于活跃状态,它就会触发所有已注册的观察者。
LiveData 允许 UI 控制器观察者订阅更新。当 LiveData
对象持有的数据发生变化时,UI 会自动响应并更新。
创建 LiveData 对象
LiveData 是一个包装器,可用于任何数据,包括实现 Collections
的对象,例如 List
。 LiveData
对象通常存储在 ViewModel
对象中,并通过 getter 方法访问,如以下示例所示
Kotlin
class NameViewModel : ViewModel() { // Create a LiveData with a String val currentName: MutableLiveData<String> by lazy { MutableLiveData<String>() } // Rest of the ViewModel... }
Java
public class NameViewModel extends ViewModel { // Create a LiveData with a String private MutableLiveData<String> currentName; public MutableLiveData<String> getCurrentName() { if (currentName == null) { currentName = new MutableLiveData<String>(); } return currentName; } // Rest of the ViewModel... }
最初,LiveData
对象中的数据未设置。
您可以在ViewModel 指南中阅读有关 ViewModel
类的更多优点和用法。
观察 LiveData 对象
在大多数情况下,应用组件的 onCreate()
方法是开始观察 LiveData
对象的正确位置,原因如下
- 确保系统不会从 Activity 或 Fragment 的
onResume()
方法进行冗余调用。 - 确保 Activity 或 Fragment 在变为活跃状态时立即拥有可显示的数据。一旦应用组件处于
STARTED
状态,它就会从其正在观察的LiveData
对象中接收最新值。这仅在要观察的LiveData
对象已设置时发生。
通常,LiveData 仅在数据更改时向活跃观察者传递更新。此行为的一个例外是,观察者在从不活跃状态变为活跃状态时也会收到更新。此外,如果观察者第二次从不活跃状态变为活跃状态,则仅当值自上次活跃以来发生更改时才会收到更新。
以下示例代码演示了如何开始观察 LiveData
对象
Kotlin
class NameActivity : AppCompatActivity() { // Use the 'by viewModels()' Kotlin property delegate // from the activity-ktx artifact private val model: NameViewModel by viewModels() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Other code to setup the activity... // Create the observer which updates the UI. val nameObserver = Observer<String> { newName -> // Update the UI, in this case, a TextView. nameTextView.text = newName } // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer. model.currentName.observe(this, nameObserver) } }
Java
public class NameActivity extends AppCompatActivity { private NameViewModel model; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Other code to setup the activity... // Get the ViewModel. model = new ViewModelProvider(this).get(NameViewModel.class); // Create the observer which updates the UI. final Observer<String> nameObserver = new Observer<String>() { @Override public void onChanged(@Nullable final String newName) { // Update the UI, in this case, a TextView. nameTextView.setText(newName); } }; // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer. model.getCurrentName().observe(this, nameObserver); } }
在调用 observe()
并将 nameObserver
作为参数传入后, onChanged()
会立即调用,提供存储在 mCurrentName
中的最新值。如果 LiveData
对象尚未在 mCurrentName
中设置值,则不会调用 onChanged()
。
更新 LiveData 对象
LiveData 没有公开可用的方法来更新存储的数据。 MutableLiveData
类公开了 setValue(T)
和 postValue(T)
方法,如果您需要编辑 LiveData
对象中存储的值,则必须使用这些方法。通常, MutableLiveData
在 ViewModel
中使用,然后 ViewModel
只向观察者公开不可变的 LiveData
对象。
建立观察者关系后,您可以更新 LiveData
对象的值,如以下示例所示,当用户轻触按钮时,它会触发所有观察者
Kotlin
button.setOnClickListener { val anotherName = "John Doe" model.currentName.setValue(anotherName) }
Java
button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { String anotherName = "John Doe"; model.getCurrentName().setValue(anotherName); } });
在该示例中调用 setValue(T)
会导致观察者以值 John Doe
调用其 onChanged()
方法。该示例显示了按钮按下,但 setValue()
或 postValue()
可以因各种原因被调用以更新 mName
,包括响应网络请求或数据库加载完成;在所有情况下,调用 setValue()
或 postValue()
都会触发观察者并更新界面。
将 LiveData 与 Room 结合使用
Room 持久性库支持可观察查询,这些查询返回 LiveData
对象。可观察查询作为数据访问对象 (DAO) 的一部分编写。
当数据库更新时,Room 会生成所有必要的代码来更新 LiveData
对象。生成的代码在需要时在后台线程上异步运行查询。此模式对于使界面中显示的数据与数据库中存储的数据保持同步非常有用。您可以在Room 持久性库指南中阅读有关 Room 和 DAO 的更多信息。
将协程与 LiveData 结合使用
LiveData
包含对 Kotlin 协程的支持。有关更多信息,请参阅将 Kotlin 协程与 Android 架构组件结合使用。
应用架构中的 LiveData
LiveData
具有生命周期感知能力,遵循 Activity 和 Fragment 等实体的生命周期。使用 LiveData
在这些生命周期所有者与其他具有不同生命周期的对象(例如 ViewModel
对象)之间进行通信。 ViewModel
的主要职责是加载和管理与 UI 相关的数据,这使其成为持有 LiveData
对象的理想选择。在 ViewModel
中创建 LiveData
对象,并使用它们将状态公开给 UI 层。
Activity 和 Fragment 不应持有 LiveData
实例,因为它们的职责是显示数据,而不是持有状态。此外,让 Activity 和 Fragment 不持有数据可使编写单元测试变得更容易。
在数据层类中操作 LiveData
对象可能很诱人,但 LiveData
并非设计用于处理异步数据流。尽管您可以使用 LiveData
转换和 MediatorLiveData
来实现此目的,但这种方法有缺点:组合数据流的能力非常有限,并且所有 LiveData
对象(包括通过转换创建的对象)都在主线程上被观察。下面的代码示例说明了在 Repository
中持有 LiveData
如何阻塞主线程
Kotlin
class UserRepository { // DON'T DO THIS! LiveData objects should not live in the repository. fun getUsers(): LiveData<List<User>> { ... } fun getNewPremiumUsers(): LiveData<List<User>> { return getUsers().map { users -> // This is an expensive call being made on the main thread and may // cause noticeable jank in the UI! users .filter { user -> user.isPremium } .filter { user -> val lastSyncedTime = dao.getLastSyncedTime() user.timeCreated > lastSyncedTime } } }
Java
class UserRepository { // DON'T DO THIS! LiveData objects should not live in the repository. LiveData<List<User>> getUsers() { ... } LiveData<List<User>> getNewPremiumUsers() { return Transformations.map(getUsers(), // This is an expensive call being made on the main thread and may cause // noticeable jank in the UI! users -> users.stream() .filter(User::isPremium) .filter(user -> user.getTimeCreated() > dao.getLastSyncedTime()) .collect(Collectors.toList())); } }
如果需要在应用的其他层中使用数据流,请考虑使用 Kotlin Flows,然后使用 asLiveData()
在 ViewModel
中将其转换为 LiveData
。在此 Codelab 中了解有关将 Kotlin Flow
与 LiveData
结合使用的更多信息。对于使用 Java 构建的代码库,请考虑结合回调或 RxJava
使用 Executors。
扩展 LiveData
LiveData 认为观察者处于活跃状态,如果观察者的生命周期处于 STARTED
或 RESUMED
状态。以下示例代码演示了如何扩展 LiveData
类
Kotlin
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) } }
Java
public class StockLiveData extends LiveData<BigDecimal> { private StockManager stockManager; private SimplePriceListener listener = new SimplePriceListener() { @Override public void onPriceChanged(BigDecimal price) { setValue(price); } }; public StockLiveData(String symbol) { stockManager = new StockManager(symbol); } @Override protected void onActive() { stockManager.requestPriceUpdates(listener); } @Override protected void onInactive() { stockManager.removeUpdates(listener); } }
本示例中价格监听器的实现包括以下重要方法
- 当
LiveData
对象具有活跃观察者时,会调用onActive()
方法。这意味着您需要从该方法开始观察股票价格更新。 - 当
LiveData
对象没有任何活跃观察者时,会调用onInactive()
方法。由于没有观察者在监听,因此没有理由保持与StockManager
服务的连接。 setValue(T)
方法会更新LiveData
实例的值,并通知任何活跃观察者有关更改。
您可以按如下方式使用 StockLiveData
类
Kotlin
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. }) } }
Java
public class MyFragment extends Fragment { @Override public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); LiveData<BigDecimal> myPriceListener = ...; myPriceListener.observe(getViewLifecycleOwner(), price -> { // Update the UI. }); } }
observe()
方法将与 Fragment 视图关联的 LifecycleOwner
作为第一个参数传递。这样做表示此观察者绑定到与所有者关联的 Lifecycle
对象,这意味着
- 如果
Lifecycle
对象未处于活跃状态,则即使值发生变化,也不会调用观察者。 - 在
Lifecycle
对象被销毁后,观察者会自动移除。
LiveData
对象具有生命周期感知能力,这意味着您可以在多个 Activity、Fragment 和 Service 之间共享它们。为了简化示例,您可以按如下方式将 LiveData
类实现为单例
Kotlin
class StockLiveData(symbol: String) : LiveData<BigDecimal>() { private val stockManager: StockManager = StockManager(symbol) private val listener = { price: BigDecimal -> value = price } override fun onActive() { stockManager.requestPriceUpdates(listener) } override fun onInactive() { stockManager.removeUpdates(listener) } companion object { private lateinit var sInstance: StockLiveData @MainThread fun get(symbol: String): StockLiveData { sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol) return sInstance } } }
Java
public class StockLiveData extends LiveData<BigDecimal> { private static StockLiveData sInstance; private StockManager stockManager; private SimplePriceListener listener = new SimplePriceListener() { @Override public void onPriceChanged(BigDecimal price) { setValue(price); } }; @MainThread public static StockLiveData get(String symbol) { if (sInstance == null) { sInstance = new StockLiveData(symbol); } return sInstance; } private StockLiveData(String symbol) { stockManager = new StockManager(symbol); } @Override protected void onActive() { stockManager.requestPriceUpdates(listener); } @Override protected void onInactive() { stockManager.removeUpdates(listener); } }
您可以在 Fragment 中按如下方式使用它
Kotlin
class MyFragment : Fragment() { override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) StockLiveData.get(symbol).observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? -> // Update the UI. }) }
Java
public class MyFragment extends Fragment { @Override public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> { // Update the UI. }); } }
多个 Fragment 和 Activity 可以观察 MyPriceListener
实例。LiveData 仅在其中一个或多个可见且活跃时才连接到系统服务。
转换 LiveData
您可能希望在将存储在 LiveData
对象中的值分派给观察者之前对其进行更改,或者您可能需要根据另一个 LiveData
实例的值返回不同的 LiveData
实例。 Lifecycle
软件包提供了 Transformations
类,其中包含支持这些场景的辅助方法。
Transformations.map()
- 对存储在
LiveData
对象中的值应用函数,并将结果向下游传播。
Kotlin
val userLiveData: LiveData<User> = UserLiveData() val userName: LiveData<String> = userLiveData.map { user -> "${user.name} ${user.lastName}" }
Java
LiveData<User> userLiveData = ...; LiveData<String> userName = Transformations.map(userLiveData, user -> { user.name + " " + user.lastName });
Transformations.switchMap()
- 类似于
map()
,对存储在LiveData
对象中的值应用函数,并解包和向下游分派结果。传递给switchMap()
的函数必须返回一个LiveData
对象,如以下示例所示
Kotlin
private fun getUser(id: String): LiveData<User> { ... } val userId: LiveData<String> = ... val user = userId.switchMap { id -> getUser(id) }
Java
private LiveData<User> getUser(String id) { ...; } LiveData<String> userId = ...; LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );
您可以使用转换方法在观察者的生命周期中传递信息。除非观察者正在观察返回的 LiveData
对象,否则不会计算转换。由于转换是惰性计算的,因此生命周期相关的行为会隐式向下传递,而无需额外的显式调用或依赖。
如果您认为在 ViewModel
对象内部需要一个 Lifecycle
对象,那么转换可能是一个更好的解决方案。例如,假设您有一个 UI 组件,它接受地址并返回该地址的邮政编码。您可以按如下示例代码所示为该组件实现简单的 ViewModel
Kotlin
class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() { private fun getPostalCode(address: String): LiveData<String> { // DON'T DO THIS return repository.getPostCode(address) } }
Java
class MyViewModel extends ViewModel { private final PostalCodeRepository repository; public MyViewModel(PostalCodeRepository repository) { this.repository = repository; } private LiveData<String> getPostalCode(String address) { // DON'T DO THIS return repository.getPostCode(address); } }
UI 组件随后需要每次调用 getPostalCode()
时都从之前的 LiveData
对象取消注册,并注册到新实例。此外,如果 UI 组件重新创建,它会触发对 repository.getPostCode()
方法的另一次调用,而不是使用之前调用的结果。
相反,您可以将邮政编码查找实现为地址输入的转换,如以下示例所示
Kotlin
class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() { private val addressInput = MutableLiveData<String>() val postalCode: LiveData<String> = addressInput.switchMap { address -> repository.getPostCode(address) } private fun setInput(address: String) { addressInput.value = address } }
Java
class MyViewModel extends ViewModel { private final PostalCodeRepository repository; private final MutableLiveData<String> addressInput = new MutableLiveData(); public final LiveData<String> postalCode = Transformations.switchMap(addressInput, (address) -> { return repository.getPostCode(address); }); public MyViewModel(PostalCodeRepository repository) { this.repository = repository } private void setInput(String address) { addressInput.setValue(address); } }
在这种情况下,postalCode
字段被定义为 addressInput
的转换。只要您的应用有一个与 postalCode
字段关联的活跃观察者,每当 addressInput
发生变化时,该字段的值就会重新计算并检索。
此机制允许应用的较低层创建按需惰性计算的 LiveData
对象。 ViewModel
对象可以轻松获取对 LiveData
对象的引用,然后在它们之上定义转换规则。
创建新转换
您的应用中可能有十几种不同的特定转换很有用,但它们并非默认提供。要实现您自己的转换,您可以使用 MediatorLiveData
类,该类监听其他 LiveData
对象并处理它们发出的事件。 MediatorLiveData
正确地将其状态传播到源 LiveData
对象。要了解有关此模式的更多信息,请参阅 Transformations
类的参考文档。
合并多个 LiveData 源
MediatorLiveData
是 LiveData
的子类,它允许您合并多个 LiveData 源。每当任何原始 LiveData 源对象发生更改时, MediatorLiveData
对象的观察者就会被触发。
例如,如果您的界面中有一个 LiveData
对象,它可以从本地数据库或网络更新,那么您可以将以下源添加到 MediatorLiveData
对象
- 一个与数据库中存储的数据关联的
LiveData
对象。 - 一个与从网络访问的数据关联的
LiveData
对象。
您的 Activity 只需观察 MediatorLiveData
对象即可接收来自两个源的更新。有关详细示例,请参阅应用架构指南的附录:公开网络状态部分。
其他资源
要了解有关 LiveData
类的更多信息,请查阅以下资源。
示例
- Sunflower,一个演示架构组件最佳实践的演示应用
Codelabs
- 带视图的 Android Room (Java) (Kotlin)
- 使用 Kotlin Flow 和 LiveData 学习高级协程
博客
- ViewModels 和 LiveData:模式 + 反模式
- ViewModel 之外的 LiveData — 使用 Transformations 和 MediatorLiveData 的响应式模式
- 带有 SnackBar、导航和其他事件的 LiveData(SingleLiveEvent 案例)
视频
为您推荐
- 注意:当 JavaScript 关闭时显示链接文本
- 将 Kotlin 协程与生命周期感知组件结合使用
- 使用生命周期感知组件处理生命周期
- 测试您的 Paging 实现