Android LiveData 使用指南

最新推荐文章于 2024-06-25 15:06:49 发布
最新推荐文章于 2024-06-25 15:06:49 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： 02 Android 学习 文章标签： LiveData Android 架构组件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benzhujie1245com/article/details/89048457
版权

  本内容主要介绍如何使用 Android 架构组件中的 LiveData。

  Android LiveData 的官方介绍文档：https://developer.android.com/topic/libraries/architecture/livedata

一、简介

  LiveData 是一个可观察的数据持有者类。与常规的 observable 不同（如果您不了解 observable，可以参阅 这里），LiveData 具有生命周期意识，这意味着它遵循其他 App 组件（比如 Activity、Fragment 或 Service）的生命周期。这种意识确保 LiveData 只更新处于活动生命周期的 App 组件观察者（Observer）。

  如果一个 Observer 的生命周期处于 STARTED（对 Activity 来说，onStart() 到 onPause()） 或 RESUMED 状态，那么 LiveData 认为它处于活动状态。LiveData 只通知活动 Observer 更新。不会通知非活动状态的 Observer 更新。

  您可以注册一个与实现 LifecycleOwner 接口的对象配对的 Observer。当对应的 Lifecycle 对象变为 RESTROYED 状态时，这种关系确保 Observer 被移除。这对于 Activity 和 Fragment 非常有用，因为它们可以安全的观察 LiveData，而不用担心内存泄露——当 Activity 和 Fragment 的生命周期为 DESTROYED 时，它们立即被取消订阅。

  总结：当数据发生变化时，自动更新 UI。并且在不再被需要的时候，会自动被销毁。

1.1 添加依赖

  如果想使用 LiveData，需要你的 APP 或者 module 的 build.gradle 中添加依赖。AndroidX 前的版本和 AndroidX 版本使用不同的声明依赖方法：

  • AndroidX 前的版本

    dependencies {
    def lifecycle_version = "1.1.1"
    
	// ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // alternatively - just LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"
}

  • AndroidX 版本

    dependencies {
    def lifecycle_version = "2.0.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    
    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
}

  点击 这里 可以查看最新依赖版本号和依赖声明方法。

二、使用 LiveData 对象

  使用 LiveData 对象的步骤如下：

  1. 创建一个保存特定类型数据的 LiveData 实例。通常在 ViewModel 类中完成。

  2. 创建一个定义了 onChanged() 方法的 Observer 对象。当 LiveData 对象持有的数据发生变化时，将回调onChanged() 方法用于执行相应处理。通常，您应该在 UI controller（例如 Activity 或 Fragment）中创建 Observer 对象。

  3. 使用 observe() 方法将 Observer 对象注册到 LiveData 对象上。observe() 方法还需要一个 LifecycleOwner 对象参数。这将确保当 LiveData 发生改变时，通知 Observer 进行更新。通常，您应该在 UI controller（例如 Activity 和 Fragment）中注册 Observer。

注意：您可以使用 observeForever(Observer) 方法注册一个没有关联 LifecycleOwner 对象的 Observer。在这种情况下，Observer 总是处于活动状态。您可以通过调用 removeObserver(Observer) 方法来移除这些 Observer。

  当您更新存储在 LiveData 中数据时，只要对应的 LifecycleOwner 处于活动状态，那么注册的 Observer 将被触发。

  LiveData 允许 UI controller Observer 订阅更新。当 LiveData 对象保存的数据发生变化时，UI 会自动更新。

2.1 创建 LiveData 对象

  LiveData 是一个包装器，可用于任何数据，包含实现集合（例如 List）的对象。一个 LiveData 对象通常是放在 ViewModel 对象中，通过 getter 方法访问，如下面的示例所示：

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;
    }
}

  最初，没有设置 LiveData 对象中的数据。

注意：请确保将更新 UI 的 LiveData 对象放在 ViewModel 对象中，而不是在 Activity 或 Fragment 中，原因如下：

  • 避免臃肿的 Activity 和 Fragment。UI controller 负责显示数据，而不保存数据状态。

  • 将 LiveData 实例与特定的 Activity 或 Fragment 解耦，以及在配置发生变化后 LiveData 仍然有效。


2.2 观察 LiveData 对象

  通常，在 App 组件的 onCreate() 方法中开始观察 LiveData 对象，原因如下：

  • 确保系统在 Activity 或 Fragment 的 onResume() 方法中进行冗余调用。

  • 确保 Activity 或 Fragment 在变为活动状态时，拥有可显示的数据。一旦 App 组件处于 STARTED 状态，就会从它所观察的 LiveData 对象中接收最新的值。

  通常，只有在数据发生变化时，LiveData 才会通知活动的 Observer 更新。一个例外是，当 Observer 从非活动状态变为活动状态时，也会收到更新。此外，如果 Observer 第二次从非活动状态变为活动状态，则只有在该值自上次变为活动状态以来发生变化时才会接受到更新。

  下面的代码演示了如何开始观察 LiveData 对象：

public class NameActivity extends AppCompatActivity {

    private NameViewModel model;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Get the ViewModel.
        model = ViewModelProviders.of(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);
    }
}

  将 nameObserver 作为参数调用 observe() 后，将立即回调 onChanged()，以提供存储在 mCurrentName 中的最新值。如果 LiveData 对象没有设置值 mCurrentName，将不会调用 onChanged()。

2.3 更新 LiveData 对象

  LiveData 没有提供公用的方法更新存储的数据。MutableLiveData 提供公用方法 setValue(T) 和 postValue(T)，只能使用这两个方法来编辑存储在 LiveData 对象中的值。通常，在 ViewModel 中使用 MutableLiveData，然后 ViewModel 向 Observer 提供不可变的 LiveData 对象。

  在建立观察者关系后，您可以更新 LiveData 对象的值，如下面的例子所示，当用户点击按钮时将处罚所有的 Observer：

button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        String anotherName = "John Doe";
        model.getCurrentName().setValue(anotherName);
    }
});

在示例中，调用 setValue(T) 将导致 Observer 调用 onChanged() 方法。

注意：更新 LiveData 对象时，在主线程中使用 setValue(T)，在工作线程中使用 postValue(T)。


2.4 和 Room 一起使用 LiveData

  Room persistence library 支持返回 LiveData 对象的可观察查询。

  当数据库更新时，Room 产生所有更新 LiveData 对象所需的代码。生成的代码在需要时将在后台线程上执行异步查询。这种模式有利于 UI 上显示的数据与数据库中的数据保持一致。

三、扩展 LiveData

  如果 Observer 的生命周期处于 STARTED 或 RESUMED 状态，那么 LiveData 认为它处于活动状态。下面的实例代码演示了如何扩展 LiveData 类：

public class StockLiveData extends LiveData<BigDecimal> {
    private StockManager stockManager;

    private SimplePriceListener listener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            // 更新 LiveData 实例的值，并通知活动的 Observer 进行更新。
            setValue(price);
        }
    };

    public StockLiveData(String symbol) {
        stockManager = new StockManager(symbol);
    }

    // 当 LiveData 对象有一个活动的 Observer 时，被调用。
    @Override
    protected void onActive() {
        stockManager.requestPriceUpdates(listener);
    }

    // 当 LiveData 对象没有任何活动的 Observer 时，被调用。
    @Override
    protected void onInactive() {
        stockManager.removeUpdates(listener);
    }
}

  您可以按照下面的方法使用 StockLiveData：

public class MyFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        LiveData<BigDecimal> myPriceListener = ...;
        myPriceListener.observe(this, price -> {
            // Update the UI.
        });
    }
}

  observe() 方法接收 MyFragment（其为一个 LifecycleOwner 实例）作为第一个参数。这样做意味着 Observer 绑定到 Lifecycle 对象，即：

  • 如果 Lifecycle 对象处于非活动状态，则即使值发生变化，也不会调用 Observer。
  • Lifecycle 对象被销毁后，Observer 将被自动移除。

  LiveData 对象具有感知生命周期的能力，意味着您可以在多个 Activity、Fragment 和 Service 之间共享它们。为了简洁，您可以使用单例模式实现 LiveData 类，如下所示：

public class StockLiveData extends LiveData<BigDecimal> {
    private static StockLiveData sInstance;
    private StockManager stockManager;
    ...
    @MainThread
    public static StockLiveData get(String symbol) {
        if (sInstance == null) {
            sInstance = new StockLiveData(symbol);
        }
        return sInstance;
    }
    ...
}

  多个 Activity 和 Fragment 能够观察 StockLiveData 实例。只有在它们中至少一个处于可见和活动状态时，LiveData 才会连接到系统服务。

四、转换 LiveData

4.1 使用 Transformations

  您可能希望先修改存储在 LiveData 中的数据后，然后再将其分配给 Observer；或者您可能需要基于另一个 LiveData 的值返回一个不同的 LiveData 实例。Transformations 类可以满足这些需求，其提供以下两个函数：

  • Transformations.map()

    LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});

    当 userLiveData 对象的数据发生变化时，将通知 userName 对象进行更新。

  • Transformations.switchMap()

    private LiveData<User> getUser(String id) {
  ...;
}

LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );

    和使用 map() 一样，当 userId 对象的数据发生变化时，将通知 user 对象进行更新。与 map() 不同的是，switchMap() 的第二个参数需要一个 LiveData 对象；所以当第二参数的 LiveData 对象的数据发生变化时，也会通知 user 对象进行更新。

  在 Observer 的生命周期中，您可以使用转换方法来传递信息。只要当一个 Observer 正在观察这个返回的 LiveData 对象时，这个转换才会执行。因为这个转换是延迟计算的，所以与生命周期相关的行为是隐式传递的，不需要额外的显示调用或依赖项。

  如果您认为在 ViewModel 对象中需要 Lifecycle 对象，则转换可能是更好的解决方案。例如，假设您有一个接受 address 并返回该 address 的 postal code 的 UI 组件。您可以为这个组件实现一个简单的 ViewModel，如下面的代码所示：

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);
    }
}

  在每次调用 getPostalCode() 时，UI 组件都需要先注销注册之前的 LiveData 对象，然后注册新的 LiveData 实例。另外，当 UI 组件被重新创建时，将调用 repository.getPostCode() 方法，而不是使用之前的调用结果。

  相反，您可以将 postal code 查找实现为 address 输入的转换，如下面的代码所示：

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 的转换（Transformation）。只要您的 App 有一个与 postalCode 相关的 Observer，当 addressInput 发生变化时都将重新计算和检索 postalCode 的值。

  这种机制允许低级别的 App 创建按需延迟计算的 LiveData。ViewModel 对象可以轻松获取 LiveData 对象的引用，然后在其上定义转换规则。

4.2 创建新的 Transformations

  您可以使用 MediatorLiveData 类来实现自己的转换。您可以点击 这里 了解更新关系 Transformations 的信息。

五、合并多个 LiveData 源

  MediatorLiveData 是 LiveData 的一个子类，该类允许您合并多个 LiveData 源。当任何原始 LiveData 源对象发生变化时，MediatorLiveData 对象的观察者都将被触发。其提供了以下两个方法：

  • addSource()：添加 LiveData 源，并开始监听给定 LiveData 源。
  • removeSource()：移除 LiveData 源。

六、LiveData 的优点

  使用 LiveData，具有以下优点：

  • 确保 UI 跟数据状态一致

    LiveData 遵循观察者模式。当 Liftcycle 状态发生变化时，LiveData 将通知 Observer 对象。当数据发生变化时，Observer 将更新 UI。

  • 没有内存泄露

    Observer 会与 Lifecycle 对象绑定，从而当这个 Lifecycle 对象被销毁后 Observer 将会自行清理。

  • 不会因为停止 Activity 出现崩溃

    如果 Observer 处于非活动状态（例如，在后台堆栈中的 Activity），将不会收到任何 LiveData 事件。

  • 不需要手动处理生命周期

    UI 组件只需要观察相关数据，而不需要手动停止或回复观察。LiveData 会自动管理这些，因为在观察期间，它能够感知相关的生命周期状态变化。

  • 始终保持最新数据

    如果一个 Lifecycle 从非活动状态变为活动状态时，将接收到最新的数据。例如，当一个 Activity 从后台切换到前台时，将接收到最新的数据。

  • 适当的配置更改

    当一个 Activity 或 Fragment 由于配置更改（例如，屏幕旋转）进行重建时，它将立即接收到最新的可用数据。

  • 共享资源

    您可以使用单例模式扩展一个 LiveData 对象并包装成系统服务，以便在 App 中共享。LiveData 对象连接到系统服务后，任何需要这些资源的 Observer 只需要观察这个 LiveData 对象。

参考

[1] https://developer.android.com/topic/libraries/architecture/livedata
[2] https://www.jianshu.com/p/87aa6464412b
[3] https://www.jianshu.com/p/8c15cadb638f

空杯的境界
关注
专栏目录
android-room-livedata：带有Android Room和LiveData的示例应用
02-18
android-room-livedata 带有Android Room和LiveData的示例应用
Android架构组件-LiveData扩展使用
mrRuby的博客
09-08 375
文章目录前言扩展LiveDataLiveData-MediatorLiveDataTransformations 对LiveData进行转换处理1，map1，switchMap 前言 LiveData的优势以及实现原理已经在上一篇中介绍，那么接下来接触一些扩展用法，从而更能体会该组件的设计意图，方便在业务中进行相应的扩展。 扩展LiveData 以下为股票价格监听StockLiveData，只有观察者生命周期处于STARTED或者RESUMED状态，则LiveData会认为观察者处于活跃状态，再进行相关连接
Android --- LiveData
最新发布
weixin_43244083的博客
06-25 842
是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。如果观察者（由类表示）的生命周期处于或状态，则 LiveData 会认为该观察者处于活跃状态。LiveData 只会将更新通知给活跃的观察者。为观察对象而注册的非活跃观察者不会收到更改通知。您可以注册与实现接口的对象配对的观察者。
Android LiveData 使用详解，kotlin安卓开发教程ppt
m0_66145060的博客
01-22 1100
回想一下，在你的项目中，是不是经常会碰到这样的问题，当网络请求结果回来的时候，你经常需要判断 Activity 或者 Fragment 是否已经 Destroy， 如果不是 destroy，才更新 UI。 而当你如果使用 Livedata 的话，因为它是在 Activity 处于 onStart 或者 onResume 的状态时，他才会进行相应的回调，因而可以很好得处理这个问题，不必写一大堆的 activity.isDestroyed()。接下来，让我们一起来看一下 LiveData 的使用 LiveDa
Architecture Components之LiveData的扩展
Hubert的博客
12-11 1606
最近研究了一下Architecture Components，尝试用这个架构写了一个小demo，发现了一些问题，也有了一些心得，想分享给大家。
Android Jetpack解析之——LiveData
maniuT的博客
09-15 436
LiveData是一种可观察的数据存储器类。与常规的可观察类不同，LiveData具有生命周期感知能力，意指它遵循其他应用组件（如activity、fragment或service）的生命周期。这种感知能力可确保LiveData仅更新处于活跃生命周期状态的应用组件观察者。如果观察者（由Observer类表示）的生命周期处于STARTED或RESUMED状态，则LiveData会认为观察者处于活跃状态。LiveData只会将封信通知给活跃的观察者。
Android官方架构组件指南1
08-08
这个组件包括了ViewModel、LiveData、Lifecycle等关键部分，它们都是Android Architecture Components库的一部分。下面将详细介绍这些组件的功能和用法。 1. ViewModel： ViewModel是Android架构组件中的一个关键类...
中文版Android程序员指南
10-11
此外，可能还会讨论JSON解析、XML解析以及如何处理异步任务，如使用AsyncTask或LiveData。 在权限管理方面，Android从6.0版本引入了运行时权限，这对开发者来说是一项新的挑战。指南会指导如何适配不同的Android...
Android架构组件Room指南
08-28
【Android架构组件Room指南】 Room是Google为Android开发推出的一种数据持久化库，它是Android架构组件(Architecture Components)的一部分，旨在提供一个更简洁、更易于使用的SQLite数据库接口。Room实际上是一个...
Google Android 程序设计指南
03-20
最后，随着版本更新，Android引入了新的特性和API，例如 Material Design 设计风格、LiveData和ViewModel等Jetpack组件、Kotlin语言等，这些都需要开发者持续学习和跟进。 《Google Android程序设计指南》中的源码...
Android ViewModel，Lifecycles和LiveData组件讲解
ChenYiRan123456的博客
01-18 1681
一、ViewModel ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。 ViewModel 类让数据可在发生屏幕旋转等配置更改后继续留存。 简单的说就是，在android中，当Activity重建或销毁时，页面上的数据会丢失。为了保存页面的数据，我们以前通常的做法是在 onSaveInstanceState 中，将数据保存到 bundle 中，再在 onCreate 中将 bundle 中的数据取出来。 而使用 ViewModel，我们就无需再用这种方法保存，因为 ViewMode
Jetpack之LiveData扩展MediatorLiveData
Jason_Lee155的博客
06-30 691
MediatorLiveData在LiveData的基础上，实现了合并多个LiveData的作用。可以监听一个或多个LiveData的变化。同时转化数据。
LiveData的使用及详解
Pyth_MR
08-08 4316
LiveData的使用，关键方法的源码分析。
Android MVVM模式之LiveData详解与使用
01-05 1060
livedata是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
LiveData的简单使用
m0_62787113的博客
02-28 770
LiveData的简单使用
MutableLiveData详解
热门推荐
li6472的博客
09-14 1万+
一 LiveData是干什么的? 1.首先LiveData其实与数据实体类(POJO类)是一样的东西,它负责暂存数据. 2.其次LiveData其实也是一个观察者模式的数据实体类,它可以跟它注册的观察者回调数据是否已经更新. 3.LiveData还能知晓它绑定的Activity或者Fragment的生命周期,它只会给前台活动的activity回调(这个很厉害).这样你可以放心的在它的回调方法里直接将数据添加到View,而不用担心会不会报错.(你也可以不用费心费力判断Fragment是否还存活) 二.
Android从零开始搭建MVVM架构（4）——LiveData
老皮的博客
02-07 2345
Livedata 是 Google 推荐的 Android 架构组件之一，是一个存放可被观察的数据持有类，有生命周期感知功能，解决了android开发者需要去手动处理生命周期的痛点。比如当我们使用 Retrofit+Rxjava处理接口回调数据时，需要考虑activity 或 fragment 生命周期，以解决 onStop 或 onDestory之后回调数据的问题。现在只需要 Retrofit+Livedata 就好，其他的 Livedata 帮你做了。
Android从零开始搭建MVVM架构（3）————LiveData
岩浆李的游鱼
10-09 2995
在真正接触并使用MVVM架构的时候，整个人都不好了。因为个人觉得，MVVM相对于MVC、MVP学习难度比较大，设计的知识点不是一点半点。所以想慢慢记录下自己的成长。如有错误希望指正。 还是那张图AAC(Android Architecture Components) 这篇我们讲LiveData。这里我们只是简单了解和认识MVVM中的LiveData组件 一、LiveData 首先我们把简单...
Jetpack LiveData 使用及原理解析
neuHenry
05-10 870
LiveData 是一种可观察的、粘性的数据存储类。与常规的可观察类不同，LiveData 具有生命周期感知能力，具有生命周期感知的组件，一般指 Activity、Fragment 等，但不局限于此，更泛指实现了 Lifecycle.LifecycleOwner 的组件。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件的观察者。
深度探索Android程序员实战指南
学习使用AsyncTask、Handler、Thread和Runnable，以及现代的协程(Coroutine)和LiveData来处理后台任务。 8. **网络编程**：掌握HTTP请求和响应的基本概念，使用HttpURLConnection、OkHttp或Retrofit库进行网络请求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值