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 对象

  1. 创建 LiveData 实例以持有特定类型的数据。这通常在您的 ViewModel 类中完成。
  2. 创建 Observer 对象，它定义了 onChanged() 方法，该方法控制当 LiveData 对象持有的数据更改时发生的情况。您通常在 UI 控制器中创建 Observer 对象，例如 Activity 或 Fragment。

  3. 使用 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

博客

视频