Android开发Jetpack组件LiveData使用讲解

LiveData概述

LiveData 是一种可观察的数据存储器类： 与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期；这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者

如果观察者（由 Observer 类表示）的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于活跃状态； LiveData 只会将更新通知给活跃的观察者，为观察 LiveData 对象而注册的非活跃观察者不会收到更改通知

你可以注册与实现 LifecycleOwner 接口的对象配对的观察者； 有了这种关系，当相应的 Lifecycle 对象的状态变为 DESTROYED 时，便可移除此观察者；这对于 Activity 和 Fragment 特别有用，因为它们可以放心地观察 LiveData 对象而不必担心泄露（当 Activity 和 Fragment 的生命周期被销毁时，系统会立即退订它们）

LiveData优势

LiveData 遵循观察者模式； 当生命周期状态发生变化时，LiveData 会通知 Observer 对象。您可以整合代码以在这些 Observer 对象中更新界面。观察者可以在每次发生更改时更新界面，而不是在每次应用数据发生更改时更新界面

不会发生内存泄露

观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理 不会因 Activity 停止而导致崩溃

如果观察者的生命周期处于非活跃状态（如返回栈中的 Activity），则它不会接收任何 LiveData 事件

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

界面组件只是观察相关数据，不会停止或恢复观察。LiveData 将自动管理所有这些操作，因为它在观察时可以感知相关的生命周期状态变化

数据始终保持最新状态

如果生命周期变为非活跃状态，它会在再次变为活跃状态时接收最新的数据。例如，曾经在后台的 Activity 会在返回前台后立即接收最新的数据

适当的配置更改

如果由于配置更改（如设备旋转）而重新创建了 Activity 或 Fragment，它会立即接收最新的可用数据

共享资源

您可以使用单例模式扩展 LiveData 对象以封装系统服务，以便在应用中共享它们； LiveData 对象连接到系统服务一次，然后需要相应资源的任何观察者只需观察 LiveData 对象

LiveData使用

首先需要引入LiveData库, 因为依赖有传递作用，所以我们依赖下面这一个就可以了

    implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"

LiveData一般情况下要结合ViewModel使用，ViewModel后面会单独篇幅介绍，这里为了演示方便就直接在Activity中使用LiveData了

1 LiveData基本使用

class TestActivity : AppCompatActivity() {
   private val TAG by lazy {
       TestActivity::class.java.simpleName
   }
   private val data = MutableLiveData<String>()
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
       data.observe(this, Observer {
           Log.i(TAG, "value: ${lifecycle.currentState} + $it ")
       })
   }
   fun onTest(view: View) {
       data.postValue("LiveData")
   }
   //打印信息
   TestActivity: value: LiveData
}

LiveData是一个抽象类，MutableLiveData是它的实现类； 首先声明一个MutableLiveData对象，然后调用data.observer(lifecycleOwner, observer), 第一个参数是lifecycleOwner, 在Lifecycle原理篇中详细提到它，它是和生命周期紧密相关的一个类，这里也就是将LiveData组件和生命周期绑定，第二个参数是一个回调，当有数据更新的时候会调用它。然后当点击按钮执行onTest方法的时候，就会更新MutableLiveData数值，导致回调被调用，模拟数据更新

2 Transformations.map()

class TestActivity : AppCompatActivity() {
  private val data = MutableLiveData<String>()
  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_main)
      data.observe(this, Observer {
          Log.d(TAG, "Changed1:$it")
      })
      val transformedLiveData: LiveData<String> = Transformations.map(data) {
          "$it+map"
      }
      transformedLiveData.observe(this, Observer {
          Log.d(TAG, "Changed2:$it")
      })
  }
  fun onTest(view: View) {
      data.postValue("LiveData")
  }
}

//打印如下
TestActivity：Changed1:LiveData
TestActivity：Changed2:LiveData+map

上述代码使用Transformations.map(data)将LiveData中存储的值做了更改，并最终被观察者回调打印

3 Transformations.switchMap()

class TestActivity : AppCompatActivity() {
   private lateinit var data1: MutableLiveData<String>
   private lateinit var data2: MutableLiveData<String>
   private lateinit var switchData: MutableLiveData<Boolean>
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
       data1 = MutableLiveData()
       data2 = MutableLiveData()
       switchData = MutableLiveData()
       val transformedLiveData: LiveData<String> = Transformations.switchMap(switchData) {
           if (it) {
               Log.i(TAG, "----------true---data1--")
               data1
           } else {
               Log.i(TAG, "----------false---data2--")
               data2
           }
       }
       transformedLiveData.observe(this, Observer {
           Log.d(TAG, "onChanged:$it")
       })
   }
   fun onTest(view: View) {
       switchData.postValue(true)
       data1.postValue("data1")
       data2.postValue("data2")
   }
}

    //打印信息如下
    TestActivity: ----------true---data1--
    TestActivity: onChanged:data1

Transformations.switchMap()和Transformations.map()很相似，它可以根据需要自由的切换监听，和Transformations.map()的差别在于其方法内部需要返回一个LiveData对象

4 MediatorLiveData.addSource()合并数据

class TestActivity : AppCompatActivity() {
   private val data1 = MutableLiveData<String>()
   private val data2 = MutableLiveData<String>()
   private val mediatorLiveData = MediatorLiveData<String>()
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
       mediatorLiveData.addSource(data1) {
           Log.d(TAG, "onChanged1:$it")
           mediatorLiveData.value = it
       }
       mediatorLiveData.addSource(data2) {
           Log.d(TAG, "onChanged2:$it")
           mediatorLiveData.value = it
       }
       mediatorLiveData.observe(this, Observer {
           Log.d(TAG, "onChanged:$it")
       })
   }
   fun onTest(view: View) {
       data1.postValue("data1")
   }
}

    //打印信息如下
    TestActivity：onChanged1:data1
    TestActivity：onChanged:data1

mediatorLiveData.addSource添加了两个LiveData对象，它内部可以存储多个LiveData数据集，监听多个数据的变化，如当点击执行onTest时候data1数据发生变化时候，会监听到变化的结果，同理如果data2数据源发生变化的时候，也会被监听到

来源：https://blog.csdn.net/m0_70748845/article/details/126089347