Jetpack学习之ViewModel、Lifecycles、LiveData

小蚂蚁 发表于 2021-10-18 10:24:55

Jetpack学习之ViewModel、Lifecycles、LiveData
声明：本学习笔记基于郭霖大大的《第一行代码第3版》并结合官方文档、网络资源以及个人理解整理而成，欢迎大家讨论指正
Jetpack简介
主要组成
Jetpack是一个开发工具集，能够协助开发者编写出更简洁的代码，简化开发过程，并且这些组件有一个很好的特点，他们大部分不依赖与任何Android系统版本，这意味着这些组件通常是定义在AndroidX库当中，并且拥有非常好的向下兼容性。
Jetpack全家桶包含内容非常多，主要可分为基础、架构、行为、界面 4个部分，本次学习主要聚焦于对架构的学习，其中很多组件更是专门为MVVM架构量身打造的。
使用前准备
Jetpack中组件通常都是以AndroidX库的形式发布的，所以常用的Jetpack组件会在创建Android项目时被自动包含进去，使用者个可以根据官方文档的说明，在app/build.gradle根据需要添加依赖
dependencies {
   def lifecycle_version = "2.4.0-rc01"
   def arch_version = "2.1.0"

   // ViewModel
   implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
   // LiveData
   implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
   // Lifecycles only (without ViewModel or LiveData)
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

   // Saved state module for ViewModel
   implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

   // Annotation processor
   kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
   // alternately - if using Java8, use the following instead of lifecycle-compiler
   implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

   // optional - helpers for implementing LifecycleOwner in a Service
   implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

   // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
   implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

   // optional - ReactiveStreams support for LiveData
   implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

   // optional - Test helpers for LiveData
   testImplementation "androidx.arch.core:core-testing:$arch_version"
}

示例准备
还有一个简单的，包含了一堆按钮的布局文件activity_main.xml，可以提前写进进去了
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<TextView
   android:id="@+id/infoText"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:textSize="32sp"/>

<Button
   android:id="@+id/plusOneBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Plus One"/>

<Button
   android:id="@+id/clearBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Clear"/>

<Button
   android:id="@+id/getUserBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Get User"/>

<Button
   android:id="@+id/addDataBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Add Data"/>

<Button
   android:id="@+id/updateDataBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Update Data"/>

<Button
   android:id="@+id/deleteDataBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Delete Data"/>

<Button
   android:id="@+id/queryDataBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Query Data"/>

<Button
   android:id="@+id/doWorkBtn"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Do Work"/>

</LinearLayout>
ViewModel
简介
Jetpack最重要的组件之一，可以帮任务太重的Activity分担一部分工作，用于专门存放界面相关数据，即界面上能看到的数据，其相关变量都应该存放在ViewModel中，而不是Activity，从而减轻Activity工作。
重要特性
手机横竖屏旋转时，Activity会被重新创建，存放在Activity中的数据也会丢失，而ViewModel不会因为屏幕旋转而重新创建，只有当Activity退出时才会跟着Activity一起销毁，所以非常适合存放界面上的变量。
生命周期示意图
https://img2020.cnblogs.com/blog/2274699/202110/2274699-20211017224749178-1860899315.svg
基本用法
通常来讲，比较好的编程规范是要给每个Activity和Fragment都创建一个对应的ViewModel，这里以创建一个简单的计数器为例

[*]为MainActivity创建一个对应的MainViewModel类继承自ViewModel
import androidx.lifecycle.ViewModel
class MainViewModel: ViewModel() {
//计数器变量
var counter = 0
}

[*]在MainActivity中获取MainViewModel并调用
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.LayoutInflater
import androidx.lifecycle.ViewModelProvider
import com.example.jetpacktest.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

val binding: ActivityMainBinding by lazy{
   ActivityMainBinding.inflate(LayoutInflater.from(this))
}

lateinit var viewModel: MainViewModel
override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(binding.root)
   //注意：ViewModelProviders.of已弃用
   //注意：绝对不可以直接去创建ViewModel实例
   viewModel = ViewModelProvider(this)
//调用
   binding.plusOneBtn.setOnClickListener {
         viewModel.counter++
         refreshCounter()
   }
}

//刷新函数
private fun refreshCounter() {
   binding.infoText.text = viewModel.counter.toString()
}

}
记住绝对不可以直接去创建ViewModel实例，一定要通过ViewModelProvider(ViewModelStoreOwner)构造函数来获取，具体语法规则为为viewModel = ViewModelProvider(<你的Activity或Fragment实例>)[<你的ViewModel>::class.java]
之所以要这样写是因为每次旋转屏幕都会重新调用onCreate()方法，若每次都创建新的实例就无法保存数据了。用上述方法，onCreate方法被再次调用，它会返回一个与确切的与MainActivity相关联的预先存在的ViewModel，这就是保存数据的原因。
悲报：
在2019.08..07的版本更新中弃用了 ViewModelProviders.of()。您可以将 Fragment 或 FragmentActivity 传递给新的ViewModelProvider(ViewModelStoreOwner) 构造函数，以实现相同的功能。
向ViewModel传递参数
来看看需要通过构造函数传递参数的情况，主要借助ViewModelProvider.Factory实现，并且还能实现退出程序后重新打开仍然保留数据的功能

[*]修改MainViewModel代码，添加构造函数
class MainViewModel(countReserved: Int): ViewModel() {
var counter = countReserved
}

[*]新建一个MainViewModelFactory类实现ViewModelProvider.Factory接口
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider

class MainViewModelFactory(private val countReserved: Int): ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
   //创建MainViewModel实例
   return MainViewModel(countReserved) as T
}
}
构造器中接受了countReserved参数，并要求实现create()方法，并在里面创建MainViewModel实例，因为该方法的执行时机与Activity的生命周期无关，所以不会产生此前的问题。
[*]修改MainActivity
class MainActivity : AppCompatActivity() {
...
lateinit var viewModel: MainViewModel
lateinit var sp: SharedPreferences

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(binding.root)

   sp = getPreferences(Context.MODE_PRIVATE)
   val countReserved = sp.getInt("count_reservde",0)

   viewModel = ViewModelProvider(
         this, MainViewModelFactory(countReserved))
   ...
   binding.clearBtn.setOnClickListener {
         viewModel.counter= 0
         refreshCounter()
   }
   refreshCounter()
}

override fun onPause() {
   super.onPause()
   //对计数进行保存
   sp.edit {
         putInt("count_reservde",viewModel.counter)
   }
}

...
}
在onCreate()方法中，我们先获取SharedPreferences的实例，用于关闭程序后保存数据。然后读取之前保存的计数值，如果没有读到就以0为默认值。要注意在ViewModelProvider()方法中多传入了一个参数，是将读取到的计数值传给了 MainViewModelFactory，这有这样才能将计数值传递给MainViewModel的构造函数。
Lifecycles
简介
Lifecycles用于感知Activity的生命周期（在非Activity类也可），下面是手写Lifecycle监听器的两步方法
基本用法

[*]新建一个MyObserver类实现LifecycleObserver接口
import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class MyObserver : LifecycleObserver{ //其实这是一个空方法接口，只需要实现声明即可
//利用注解功能，会在Activity的OnStart()触发时执行
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun activityStart() {
   Log.d("MyObserver","activityStart")
}

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun activityStop() {
   Log.d("MyObserver","activityStop")
}

}
利用注解功能传入相应得生命周期时间，需要注意的是除了熟悉的六种外还多了一种ON_ANY类型，可以表示以匹配Activity的任何生命周期回调
[*]借助LifecycleOwner获取通知，在MainActivity中增加一行代码，MyObserver就能自动感应Activity的生命周期了
override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(binding.root)
   ...
//增加一行
   lifecycle.addObserver(MyObserver())
...
}
首先我们要了解LifecycleOwner的语法结构是：LifecycleOwner.lifecycle.addObserver(MyObserver())，而只要你的Activity是继承自AppCompatActivity，或者你的Fragment继承自androidx.fragment.app.Fragment的，那么它们本身就是一个LifecycleOwner实例，在AndroidX库中已经自动帮我们实现了，所以上示代码才可以这样写。
[*]若是想要主动获取当前生命周期状态，只需在MyObserver的构造函数中传入Lifecycle对象，相应修改MainActivity即可
class MyObserver(val lifecycle: Lifecycle) : LifecycleObserver{ //其实这是一个空方法接口，只需要实现声明即可
...
}
lifecycle.addObserver(MyObserver(lifecycle))

生命周期对应状态示意图
LiveData
简介
LiveData是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
之前示例代码的缺陷：
一直都是在Activity中操作，每次加一先给ViewModel 中的计数加一，然后再调用其获取，，而并不是ViewModel 主动通知返回给Activity，在多线程任务中容易或渠道错误的数据
解决方法:
把Activity传给ViewModel ？那绝对不行，根据上示ViewModel 生命周期示意图，ViewModel 的生命周期是长于Activity的，若把Activity实例传给ViewModel ，很可能导致Activity无法释放从而造成内存泄露，这是一种非常错误的做法！正解当然就是用LiveData啦
基本用法
MutableLiveData是一种可变的LiveData，主要是3种读写数据的方法

[*]getValue()用于获取LiveData中包含的数据
[*]setValue()用于在主线程中给LiveData设置数据
[*]postValue()用于在非主线程中给LiveData设置数据
一般在Kotlin中会采用语法糖写法，如下例

[*]修改上面写过的MainViewModel代码
class MainViewModel(countReserved: Int): ViewModel() {

var counter = MutableLiveData<Int>()

init {//初始化之前保存的数据
   counter.value = countReserved
}

fun plusOne() {
   val count = counter.value ?:0
   counter.value = count + 1
}

fun clear() {
   counter.value = 0
}

}
这里counter变量修改为一个MutableLiveData对象，泛型指定为Int表示整形数据。init结构体给counter设置数据，这样之前保存的数据可以在初始化时得以恢复。新增两个函数分别用于“加1”和“清零”操作，由于LiveData的getvalue方法可能为空，所以这里用一个?:操作符，当获取到的数据为空时就用0为默认计数。
[*]修改MainActivity
override fun onCreate(savedInstanceState: Bundle?) {
...
   binding.plusOneBtn.setOnClickListener {
//          viewModel.counter++
//          refreshCounter()
         viewModel.plusOne()
   }

   binding.clearBtn.setOnClickListener {
//          viewModel.counter = 0
//          refreshCounter()
         viewModel.clear()
   }

   viewModel.counter.observe(this, Observer { count ->
         binding.infoText.text = count.toString()
   })

}

override fun onPause() {
   super.onPause()
   sp.edit {
         putInt("count_reservde", viewModel.counter.value ?: 0)
   }
}
在两个按钮对应的事件中都换成了对应的方法plusOne()和clear()，在onPause()方法中也相应修改了写法，中间是最关键的修改地方：这里调用了viewModel.counter的observe()方法，需要传入两个参数，一是LifecycleOwner，在上文提到Activity本身也是LifecycleOwner，所以直接传入this，第二个参数是Observer接口，当counter中包含的数据发生变化时，就会回调到这里，我们也能借此更新到界面上。
修改后的好处：不用担心ViewModel 开启线程执行耗时逻辑，同时也应注意此时是运行在主线程中，若要在子线程修改LiveData值则要注意一定要调用postValue()方法
[*]以上就是LiveData的基础用法了，但还不算最规范的，主要问题在于我们把counter这个可变的LiveData暴露给了外部，这样即使是在ViewModel 外面也能为counter设置数据，从而破坏ViewModel 的封装性并存在一定风险。所以比较推荐的做法是，永远只暴露不可变的LiveData给外部。这样在非ViewModel中就只能观察LiveData的数据变化而不能设置LiveData数据：
class MainViewModel(countReserved: Int): ViewModel() {
// var counter = MutableLiveData<Int>()
// init { counter.value = countReserved }
// fun plusOne() {
//    val count = counter.value ?:0
//    counter.value = count + 1
// }
// fun clear() { counter.value = 0}

val counter : LiveData<Int>
   get() = _counter

private val _counter = MutableLiveData<Int>()

init {
   _counter.value = countReserved
}

fun plusOne() {
   val count = _counter.value ?:0
   _counter.value = count + 1
}

fun clear() {
   _counter.value = 0
}

}
相比原来，counter变量全部变为了_counter变量，并添加了private修饰符对外部不可见，然后重新定义一个counter变量声明为不可变的LiveData，并在它的get()属性方法中返回_counter变量，这样做当外部调用counter变量时，实际上获得的是_counter的实例，并无法给counter设置数据，从而保证了封装性，这也是官方的推荐写法，非常规范
map和switchMap
LiveData的两种转换方法：map()和switchMap()



https://www.cnblogs.com/Gnocihz/p/15418636.html

页: [1]

CodeAE代码之家-专为程序员打造的技术家园！-网站地图

Jetpack学习之ViewModel、Lifecycles、LiveData