LiveData 概览   属于 Android Jetpack

LiveData 是一个可观测的数据持有者类。与普通的可观测对象不同,LiveData 具有生命周期感知能力,这意味着它会遵从其他应用组件(如 activity、fragment 或 service)的生命周期。这种感知能力确保 LiveData 只会更新处于活跃生命周期状态的应用组件观察者。

LiveData 认为观察者(由 Observer 类表示)处于活跃状态,前提是其生命周期处于 STARTEDRESUMED 状态。LiveData 只会通知活跃的观察者有关更新的信息。未处于活跃状态但注册了观察 LiveData 对象的观察者不会收到变更通知。

您可以将观察者注册到实现了 LifecycleOwner 接口的对象。这种关系允许在相应的 Lifecycle 对象的状态变为 DESTROYED 时移除观察者。这对 activity 和 fragment 特别有用,因为它们可以安全地观察 LiveData 对象,而无需担心内存泄漏——activity 和 fragment 在生命周期被销毁时会立即取消订阅。

如需详细了解如何使用 LiveData,请参阅使用 LiveData 对象

使用 LiveData 的优势

使用 LiveData 提供以下优势

确保您的 UI 与数据状态匹配
LiveData 遵循观察者模式。当底层数据发生变化时,LiveData 会通知 Observer 对象。您可以整合您的代码,在这些 Observer 对象中更新 UI。这样,您就不必在应用数据每次更改时都更新 UI,因为观察者会为您完成此操作。
没有内存泄漏
观察者与 Lifecycle 对象绑定,并在其关联的生命周期被销毁时自行清理。
不会因 activity 停止而崩溃
如果观察者的生命周期处于非活跃状态(例如,activity 在返回栈中),则它不会收到任何 LiveData 事件。
不再需要手动处理生命周期
UI 组件只需观察相关数据,而无需停止或恢复观察。LiveData 知道观察期间相关的生命周期状态变化,因此会自动管理这一切。
数据始终最新
如果生命周期变为非活跃状态,它在再次变为活跃状态时会收到最新数据。例如,处于后台的 activity 在返回前台后会立即收到最新数据。
正确处理配置变更
如果 activity 或 fragment 因配置变更(例如设备旋转)而被重新创建,它会立即收到最新的可用数据。
共享资源
您可以使用单例模式扩展 LiveData 对象,以封装系统服务,以便在您的应用中共享它们。LiveData 对象会一次连接到系统服务,然后任何需要该资源的观察者都可以只观察 LiveData 对象。如需详细了解,请参阅扩展 LiveData

使用 LiveData 对象

按照以下步骤使用 LiveData 对象

  1. 创建 LiveData 的实例,以持有某种类型的数据。这通常在您的 ViewModel 类中完成。
  2. 创建一个 Observer 对象,该对象定义 onChanged() 方法,用于控制当 LiveData 对象持有的数据发生变化时会发生什么。您通常在 UI 控制器(例如 activity 或 fragment)中创建一个 Observer 对象。
  3. 使用 observe() 方法将 Observer 对象附加到 LiveData 对象。 observe() 方法接受一个 LifecycleOwner 对象。这将 Observer 对象订阅到 LiveData 对象,以便在发生更改时收到通知。您通常在 UI 控制器(例如 activity 或 fragment)中附加 Observer 对象。

当您更新 LiveData 对象中存储的值时,只要附加的 LifecycleOwner 处于活跃状态,它就会触发所有已注册的观察者。

LiveData 允许 UI 控制器观察者订阅更新。当 LiveData 对象持有的数据发生变化时,UI 会自动做出响应并更新。

创建 LiveData 对象

LiveData 是一种包装器,可用于任何数据,包括实现 Collections 的对象,例如 ListLiveData 对象通常存储在 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 对象中的值,则必须使用这些方法。通常,MutableLiveDataViewModel 中使用,然后 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) 会导致观察者调用其 onChanged() 方法,并将值设置为 John Doe。示例展示了按钮按下操作,但 setValue()postValue() 可以出于多种原因调用来更新 mName,包括响应网络请求或数据库加载完成;在所有情况下,调用 setValue()postValue() 都会触发观察者并更新 UI。

将 LiveData 与 Room 一起使用

Room 持久性库支持可观察查询,这些查询返回 LiveData 对象。可观察查询作为数据访问对象 (DAO) 的一部分编写。

当数据库更新时,Room 会生成所有必要的代码来更新 LiveData 对象。生成的代码在需要时在后台线程上异步运行查询。这种模式对于使 UI 中显示的数据与数据库中存储的数据保持同步非常有用。您可以在Room 持久性库指南中详细了解 Room 和 DAO。

在 LiveData 中使用协程

LiveData 包含对 Kotlin 协程的支持。如需了解详细信息,请参阅将 Kotlin 协程与 Android Architecture Components 结合使用

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 Flow,然后在 ViewModel 中使用 asLiveData() 将它们转换为 LiveData。通过此 Codelab 了解如何在 LiveData 中使用 Kotlin Flow。对于使用 Java 构建的代码库,请考虑结合使用回调或 RxJavaExecutors

扩展 LiveData

如果观察者的生命周期处于 STARTEDRESUMED 状态,LiveData 会认为观察者处于活跃状态。以下示例代码演示了如何扩展 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 源

MediatorLiveDataLiveData 的子类,允许您合并多个 LiveData 源。当任何原始 LiveData 源对象发生变化时,MediatorLiveData 对象的观察者就会被触发。

例如,如果您的 UI 中有一个可以从本地数据库或网络更新的 LiveData 对象,那么您可以将以下源添加到 MediatorLiveData 对象

  • 与数据库中存储的数据关联的 LiveData 对象。
  • 与从网络访问的数据关联的 LiveData 对象。

您的 activity 只需观察 MediatorLiveData 对象即可接收来自两个源的更新。有关详细示例,请参阅应用架构指南附录:暴露网络状态部分。

其他资源

要详细了解 LiveData 类,请参考以下资源。

示例

  • Sunflower,一个演示 Architecture Components 最佳实践的示例应用

Codelabs

博客

视频