Android Jetpack—— LiveData解析

最新推荐文章于 2024-04-22 00:59:43 发布

安卓老猴子

最新推荐文章于 2024-04-22 00:59:43 发布

阅读量115

点赞数

文章标签： android jetpack android

本文链接：https://blog.csdn.net/star_nwe/article/details/132921800

版权

LiveData概览

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

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

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

1、使用LiveData的优势

使用LiveData具有以下优势：

确保界面符合数据状态

LiveData遵循观察者模式。当底层数据发生变化时，LiveData会通知Observer对象。您可以整合代码以Observer对象中更新界面。这样一来，您无需在每次应用数据发生变化时更新界面，因为观察者会替您完成更新。

不会发生内存泄露

观察者会绑定到Lifecycle对象，并在其关联的生命周期遭到销毁后进行自我清理。

不会因Activity停止导致崩溃

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

不需要手动处理生命周期

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

数据始终保持最新状态

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

适当的配置更改

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

共享资源

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

2、使用LiveData对象

请按照以下步骤使用LiveData对象：

创建LiveData的实例以存储某种类型的数据。这通常在ViewModel类中完成。
创建可定义onChanged()方法的Observer对象，该方法可以控制当LiveData对象存储的数据更改时会发生什么。通常情况下，您可以在界面控制器（如activity或fragment）中创建Observer对象。
使用observer方法将Observer对象附加到LiveData对象。observer()方法会采用LifecycleOwner对象。这样会使Observer对象订阅LiveData对象，以使其受到有关更改的通知。通常情况下，您可以在界面控制器（如activity或fragment）中附加Observer对象。

注意：您可以使用observeForever(Onserver)方法在没有关联的LifecycleOwner对象的情况下注册一个观察者。在这种情况下，观察者会被视为始终处于活跃状态，因此它始终会收到关于修改通知。您可以通过调用removeObserver(Observer)方法来移除这些观察者。

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

LiveData允许界面控制器观察订阅更新。当LiveData对象存储的数据发生更改时，界面会自动更新以做出响应。

2.1、创建LiveData对象

LiveData是一种可用于任何数据的封装容器，其中包括可实现Collections的对象，如List。LiveData对象通常存储在ViewModel对象中，并可通过getter方法进行访问，如一下示例中所示：

class NameViewModel: ViewModel() {
    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }
    
    // Rest of the ViewModel...
}

最初，LiveData对象中的数据并未经过设置。

注意：请确保用于更新界面的LiveData对象存储在ViewModel对象中，而不是将其存储在activity或fragment中，原因如下：
1. 避免Activity和Fragment过于庞大。现在，这些界面控制器负责显示数据，但不负责存储数据状态。
2. 将LiveData实例与特定的Activity或Fragment实例分离开，并使LiveData对象在配置更改后继续存在。

2.2、观察LiveData对象

在大多数情况下，应用组件的onCreate()方法是开始观察LiveData对象的正确着手点，原因如下：

确保系统不会从Activity或Fragment的onResume()方法进行冗余调用。
确保activity或fragment变为活跃状态后具有可以立即显示的数据。一旦应用组件处于STARTED状态，就会从它正在观察的LiveData对象接收最新值。只有在设置了要观察的LiveData对象接受最新值。只有在设置了要观察的LiveData对象时，才会发生这种情况。

通常，LiveData仅在数据发生更改时才发送更新，并且仅发送给活跃观察者。此行为的一种例外情况是，观察者从非活跃状态更改为活跃状态时也会受到更新。此外，如果观察者第二次从非活跃状态改为活跃状态，则只有在自上次变为活跃状态以来值发生了改变时，它才会受到更新。

以下示例代码说明了如何开始观察LiveData对象：

class NameActivity: AppCompatActivity() {
    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artiface
    private val model: NameViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstance)
        
        // Other code to setup the activity...
        
        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, int 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)
    }
}

在传递nameObserver参数的情况下调用observer()后，系统会立即调用onChanged()，从而提供mCurrentName中存储的最新值。如果LiveData对象尚未在mCurrentName中设置值，系统不会调用onChanged()。

2.3、更新LiveData对象

LiveData没有公开可用的方法来更新存储的数据。MutableLiveData类将公开setValue(T)和postValue(T)方法，如果您需要修改存储在LiveData对象中的值，则必须使用这些方法。通常情况下只会在ViewModel中使用MutableLiveData，然后ViewModel只会向观察者公开不可变的LiveData对象。

设置观察者关系后，您可以更新LiveData对象的值（如以下示例中所示），这样当用户点按某个按钮时会触发所有观察者：

button.setOnClickListener {
    val anotherName = "John Doe"
    model.currentName.setValue(anotherName)
}

在本示例中调用setValue(T)导致观察者使用值John Doe调用其onChanged()方法。本示例中演示的是按下按钮的方法，但也可以出于各种各样的原因调用setValue()或postValue()来更新mName，这些原因包括相应网络请求或数据库加载完成。在所有情况下，调用setValue()或postValue()都会触发观察者并更新界面。

注意：您必须调用setValue(T)方法一以从主线程更新LiveData对象。如果在工作器线程中执行，您可以改用postValue(T)方法来更新LiveData对象。

2.4、将LiveData与Room一起使用

Room持久性库支持返回LiveData对象的可观察查询。可观察查询属于数据库访问对象（DAO）的一部分。

当数据库更新时，Room会生成更新LiveData对象所需的所有代码。早需要时，生成的代码会在后台线程上异步运行查询。此模式有助于使界面中显示的数据与存储在数据库中的数据保持同步。

3、应用架构中的LiveData

LiveData具有生命周期感知能力，遵循activity和fragment等实体的生命周期。您可以使用LiveData在这些声明周期所有者和声明周期不同的其他对象（例如ViewModel对象）之间传递数据。ViewModel的主要责任是加载和管理与界面相关的数据，因此非常适合作用于保留LiveData对象的备选方案。您可以在ViewModel中创建LiveData对象，然后使用这些对象向界面层公开状态。

activity和fragment不应保留LiveData实例，因为它们的用途是显示数据，而不是保持状态。此外，如果activity和fragment无需保留数据，还可以简化单元测试的编写。

您可能会想在数据层类中使用LiveData对象，但LiveData并不适合用于处理异步数据流。虽然您可以使用LiveData转换和MediatorLiveData来实现此目的，但此方法的缺点在于：用于组合数据流的功能非常有限，并且所有LiveData对象（包括通过转换创建的对象）都会在主线程中观察到。下方是一段示例代码，展示了在Respository中保留LiveData如何阻塞主线程：

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 { user ->
            // This is an expensive call being made on the main thread and may
            // cause noticeable jank in the UI!
            users
                .filter { user ->
                    user.isPermium
                }
            .filter { user ->
                val lastSyncedTime = dao.getLastSyncedTime()
                user.timeCreated > lastSyncedTime
            }
        }
    }
}

如果您需要在应用的其他层中使用数据流，请考虑使用Kotlin Flow，然后使用asLiveData()在ViewModel中将Kotlin Flow转换成LiveData。

4、扩展LiveData

如果观察者的额生命周期处于STARTED或RESUMED状态，LiveData会认为观察者处于活跃状态。以下示例代码说明了如何扩展LiveData类：

class StockLiveData(symbol: String): LiveData<BigDecimal>() {
    private val stockManager = StockManager(symbol)
    
    private val listener = { price: BitDecimal ->
        value = price
    }
    
    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }
    
    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }
}

本示例中的价格监听器实现包括以下重要方法：

当LiveData对象具有活跃观察者时，会调用onActive()方法。这意味着，您需要从此方法开始观察股价更新。
当LiveData对象没有任何活跃观察者时，会调用onInactive()方法。由于没有观察者在监听，因此没有理由与StockManager服务保持连接。
setValue(T)方法将更新LiveData示例的值，并将更改告知活跃观察者。

您可以使用StockLiveData类，如下所示：

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

observe()方法将与Fragment视图关联的LifecycleOwner作为第一个参数传递。这样做表示此观察者已绑定到与所有者关联的Lifecycle对象，这意味着：

如果Lifecycle对象未处于活跃状态，那么即使值发生更改，也不会调用观察者。
销毁Lifecycle对象后，会自动移除观察者。

LiveData对象具有生命周期感知能力，这一事实意味着您可以在多个activity、fragment和service之间共享这些对象。为使示例保持简单，您可以将LiveData类实现为一个单例，如下所示：

class StockLiveData(symbol: String): LiveData<BitDecimal>() {
    private val stockManager: StockManager = StockManager(symbol)
    
    private val listener = { prive: 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
        }
    }
}

并且您可以在Fragment中使用它，如下所示：

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

多个fragment和activity可以观察MyPriceListener实例。仅当一个或多项系统服务可见且处于活跃状态时，LiveData才会连接到该服务。

5、转换LiveData

您可能希望在将LiveData对象分派给观察者之前对存储在其中的值进行更改，或者您可能需要根据另一个实例的值返回不同的LiveData实例。Lifecycle软件包会提供Transformations类，该类包括可应对这些情况的辅助程序方法。

Transformations.map() ：对存储在LiveData对象中的值应用函数，并将结果传到下游。

val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = userLiveData.map {
    user -> "${user.name} ${user.lastName}"
}

Transformations.switchMap() ：与map()类似，对存储在LiveData对象中的值应用函数，并将结果解封和分派到下游。传递给switchMap()的函数必须返回LiveData对象，如以下示例中所示：

private fun getUser(id: String): LiveData<User> {
    ...
}
val userId: LiveData<String> = ...
val user = userId.switchMap { id -> getUser(id) }

您可以使用转换方法在观察者的生命周期内传送信息。除非观察者正在观察返回的LiveData对象，否则不会计算转换。因为转换时以延迟的方式计算，所以与生命周期相关的行为会隐式传递下去，而不需要额外的显示调用或依赖项。

如果您认为ViewModel对象中需要有Lifecycle对象，那么进行转换或许是更好的解决方案。例如，假设您有一个界面组件，该组件接受地址并返回该地址的邮政编码。您可以为此组件实现简单的ViewModel，如以下示例代码所示：

class MyViewModel(private val repository: PostalCodeRepository): ViewModel() {
    private fun getPostalCode(address: String): LiveData<String> {
        // DON'T DO THIS
        return repository.getPostCode(addredd)
    }
}

然后，该界面组件需要取消注册先前的LiveData对象，并在每次调用getPostalCode()时注册到新的实例。此外，如果重新创建了该界面组件，它会再出发一次对repository.getPostCode()方法的调用，而不是使用先前调用所得的结果。

您也可以将邮政编码查询实现为地址输入的转换，如以下示例中所示：

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

在这种情况下，postalCode字段定义为addressInput的转换。只要您的应用具有与postalCode字段关联的活跃观察者，就会在每次addressInput发生更改时重新计算并检索该字段的值。

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

5.1、创建新的转换

有十几种不同的特定转换在您的应用中可能很有用，但默认情况下不提供它们。如需实现您自己的转换，您可以使用MediatorLiveData类，该类可以监听其他LiveData对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData对象。

6、合并多个LiveData源

MediatorLiveData是LiveData的子类，允许您合并多个LiveData源。只要任何原始的LiveData源对象发生更改，就会出发MediatorLiveData对象的观察者。

例如，如果界面中有可以从本地数据库或网络更新的LiveData对象，则可以向MediatorLiveData对象添加以下源：

与存储在数据库中的数据关联的LiveData对象。
与从网络访问的数据关联的LiveData对象。您的 Activity 只需观察 MediatorLiveData 对象即可从这两个源接收更新。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

欢迎大家一键三连支持，若需要文中资料，直接扫描文末CSDN官方认证微信卡片免费领取↓↓↓（文末还有ChatGPT机器人小福利哦，大家千万不要错过）

PS:群里还设有ChatGPT机器人，可以解答大家在工作上或者是技术上的问题

安卓老猴子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android Jetpack—— LiveData解析

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

扫一扫