探究Jetpack(二)之LiveData

目录

  • LiveData的基本用法
  • 比较安全的LiveData使用方法
  • map和switchMap
    • map
    • switchMap

LiveData是Jetpack提供的一种响应式编程组件,它可以包含任何类型的数据,并在数据发生变化的时候通知给观察者
LiveData特别适合与ViewModel结合在一起使用,虽然它也可以单独用在别的地方,但是在绝大多数情况下,它是使用在ViewModel当中的

LiveData的基本用法

之前编写的那个计数器虽然功能非常简单,但其实是存在问题的。目前的逻辑是,当每次点击“Plus One”按钮时,都会先给ViewModel中的计数加1,然后立即获取最新的计数
这种方式在单线程模式下确实可以正常工作,但如果ViewModel的内部开启了线程去执行一些耗时逻辑,那么在点击按钮后就立即去获取最新的数据,得到的肯定还是之前的数据

而这个问题的解决方案也是显而易见的,就是使用LiveData。正如前面所描述的一样,LiveData可以包含任何类型的数据,并在数据发生变化的时候通知给观察者
也就是说,如果将计数器的计数使用LiveData来包装,然后在Activity中去观察它,就可以主动将数据变化通知给Activity了

修改MainViewModel中的代码,如下所示:

class MainViewModel(countReserved: Int) : ViewModel() {

	 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变量修改成了一个MutableLiveData对象,并指定它的泛型为Int,表示它包含的是整型数据
MutableLiveData是一种可变的LiveData,它的用法很简单,主要有3种读写数据的方法,分别是getValue()、setValue()和postValue()方法

  • getValue()方法用于获取LiveData中包含的数据
  • setValue()方法用于给LiveData设置数据,但是只能在主线程中调用
  • postValue()方法用于在非主线程中给LiveData设置数据

而上述代码其实就是调用getValue()和setValue()方法对应的语法糖写法
可以看到,这里在init结构体中给counter设置数据,这样之前保存的计数值就可以在初始化的时候得到恢复
接下来我们新增了plusOne()和clear()这两个方法,分别用于给计数加1以及将计数清零。plusOne()方法中的逻辑是先获取counter中包含的数据,然后给它加1,再重新设置到counter当中
注意调用LiveData的getValue()方法所获得的数据是可能为空的,因此这里使用了一个?:操作符,当获取到的数据为空时,就用0来作为默认计数

修改MainActivity.xml的代码

class MainActivity : AppCompatActivity() {
	 ...
	 override fun onCreate(savedInstanceState: Bundle?) {
		 ...
		 plusOneBtn.setOnClickListener {
		 	viewModel.plusOne()
		 }
		 clearBtn.setOnClickListener {
		 	viewModel.clear()
		 }
		 viewModel.counter.observe(this) { count ->
		 	infoText.text = count.toString()
		 }
	 }
	 
	 override fun onPause() {
		 super.onPause()
		 sp.edit {
		 	putInt("count_reserved", viewModel.counter.value ?: 0)
		 }
	 }
}

在“Plus One”按钮的点击事件中应该去调用MainViewModel的plusOne()方法,而在“Clear”按钮的点击事件中应该去调用MainViewModel的clear()方法
另外,在onPause()方法中,将获取当前计数的写法改造了一下,这部分内容还是很好理解的
接下来到最关键的地方了,这里调用了viewModel.counter的observe()方法来观察数据的变化。经过对MainViewModel的改造,现在counter变量已经变成了一个LiveData对象,任何LiveData对象都可以调用它的observe()方法来观察数据的变化
observe()方法接收两个参数:第一个参数是一个LifecycleOwner对象,Activity本身就是一个LifecycleOwner对象,因此直接传this就好;第二个参数是一个Observer接口,当counter中包含的数据发生变化时,就会回调到这里,因此在这里将最新的计数更新到界面上即可

重新运行一下程序,计数器功能同样是可以正常工作的。不同的是,现在的代码更科学,也更合理,而且不用担心ViewModel的内部会不会开启线程执行耗时逻辑
不过需要注意的是,如果需要在子线程中给LiveData设置数据,一定要调用postValue()方法,而不能再使用setValue()方法,否则会发生崩溃

比较安全的LiveData使用方法

以上就是LiveData的基本用法。虽说现在的写法可以正常工作,但其实这仍然不是最规范的LiveData用法,主要的问题就在于把counter这个可变的LiveData暴露给了外部。这样即使是在ViewModel的外面也是可以给counter设置数据的,从而破坏了ViewModel数据的封装性,同时也可能带来一定的风险

比较推荐的做法是,永远只暴露不可变的LiveData给外部。这样在非ViewModel中就只能观察LiveData的数据变化,而不能给LiveData设置数据
修改MainViewModel来实现这样的功能:

class MainViewModel(countReserved: Int) : ViewModel() {

	 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变量对于外部就是不可见的了
然后又新定义了一个counter变量,将它的类型声明为不可变的LiveData,并在它的get()属性方法中返回_counter变量
这样,当外部调用counter变量时,实际上获得的就是_counter的实例,但是无法给counter设置数据,从而保证了ViewModel的数据封装性

map和switchMap

LiveData的基本用法虽说可以满足大部分的开发需求,但是当项目变得复杂之后,可能会出现一些更加特殊的需求
LiveData为了能够应对各种不同的需求场景,提供了两种转换方法:map()和switchMap()方法

map

map()方法:这个方法的作用是将实际包含数据的LiveData和仅用于观察数据的LiveData进行转换

比如说有一个User类,User中包含用户的姓名和年龄,定义如下:

data class User(var firstName: String, var lastName: String, var age: Int)

如果MainActivity中明确只会显示用户的姓名,而完全不关心用户的年龄,那么这个时候还将整个User类型的LiveData暴露给外部,就显得不那么合适了
而map()方法就是专门用于解决这种问题的,它可以将User类型的LiveData自由地转型成任意其他类型的LiveData
可以在ViewModel中创建一个相应的LiveData来包含User类型的数据

class MainViewModel(countReserved: Int) : ViewModel() {
	 private val userLiveData = MutableLiveData<User>()

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

这里调用了Transformations的map()方法来对LiveData的数据类型进行转换
map()方法接收两个参数:第一个参数是原始的LiveData对象;第二个参数是一个转换函数,在转换函数里编写具体的转换逻辑即可
这里的逻辑也很简单,就是将User对象转换成一个只包含用户姓名的字符串
另外,还将userLiveData声明成了private,以保证数据的封装性。外部使用的时候只要观察userName这个LiveData就可以了
当userLiveData的数据发生变化时,map()方法会监听到变化并执行转换函数中的逻辑,然后再将转换之后的数据通知给userName的观察者

switchMap

switchMap()的使用场景非常固定,但是可能比map()方法要更加常用
前面所了解的所有内容都有一个前提:LiveData对象的实例都是在ViewModel中创建的。然而在实际的项目中,不可能一直是这种理想情况,很有可能ViewModel中的某个LiveData对象是调用另外的方法获取的

下面就来模拟一下这种情况,新建一个Repository单例类,代码如下所示:

object Repository {
	 fun getUser(userId: String): LiveData<User> {
		 val liveData = MutableLiveData<User>()
		 liveData.value = User(userId, userId, 0)
		 return liveData
	 }
}

这里在Repository类中添加了一个getUser()方法,这个方法接收一个userId参数
按照正常的编程逻辑,应该根据传入的userId参数去服务器请求或者到数据库中查找相应的User对象,但是这里只是模拟示例,因此每次将传入的userId当作用户姓名来创建一个新的User对象即可
需要注意的是,getUser()方法返回的是一个包含User数据的LiveData对象,而且每次调用getUser()方法都会返回一个新的LiveData实例

然后在MainViewModel中也定义一个getUser()方法,并且让它调用Repository的getUser()方法来获取LiveData对象:

class MainViewModel(countReserved: Int) : ViewModel() {
	 ...
	 fun getUser(userId: String): LiveData<User> {
	 	return Repository.getUser(userId)
	 }
}

因为每次调用getUser()方法返回的都是一个新的LiveData实例,而使用前面调用viewModel.counter的observe()方法来观察数据变化的写法,会一直观察老的LiveData实例,从而根本无法观察到数据的变化
这个时候,switchMap()方法就可以派上用场了
正如前面所说,它的使用场景非常固定:如果ViewModel中的某个LiveData对象是调用另外的方法获取的,那么就可以借助switchMap()方法,将这个LiveData对象转换成另外一个可观察的LiveData对象

修改MainViewModel中的代码,如下所示:

class MainViewModel(countReserved: Int) : ViewModel() {
	 ...
	 private val userIdLiveData = MutableLiveData<String>()
	 
	 val user: LiveData<User> = Transformations.switchMap(userIdLiveData) { userId ->
	 	Repository.getUser(userId)
	 }
	 
	 fun getUser(userId: String) {
	 	userIdLiveData.value = userId
	 }
}

这里定义了一个新的userIdLiveData对象,用来观察userId的数据变化,然后调用了Transformations的switchMap()方法,用来对另一个可观察的LiveData对象进行转换
switchMap()方法同样接收两个参数:第一个参数传入新增的userIdLiveData,switchMap()方法会对它进行观察;第二个参数是一个转换函数,注意,必须在这个转换函数中返回一个LiveData对象,因为switchMap()方法的工作原理就是要将转换函数中返回的LiveData对象转换成另一个可观察的LiveData对象
那么很显然,只需要在转换函数中调用Repository的getUser()方法来得到LiveData对象,并将它返回就可以

再来梳理一遍它的整体工作流程

  • 当外部调用MainViewModel的getUser()方法来获取用户数据时,并不会发起任何请求或者函数调用,只会将传入的userId值设置到userIdLiveData当中
  • 一旦userIdLiveData的数据发生变化,那么观察userIdLiveData的switchMap()方法就会执行,并且调用我们编写的转换函数
  • 然后在转换函数中调用Repository.getUser()方法获取真正的用户数据
  • 同时,switchMap()方法会将Repository.getUser()方法返回的LiveData对象转换成一个可观察的LiveData对象,对于Activity而言,只要去观察这个LiveData对象就可以了

下面来测试一下,修改activity_main.xml文件,在里面新增一个“Get User”按钮
然后修改MainActivity中的代码,如下所示:

class MainActivity : AppCompatActivity() {
	 ...
	 override fun onCreate(savedInstanceState: Bundle?) {
		 ...
		 getUserBtn.setOnClickListener {
			 val userId = (0..10000).random().toString()
			 getUser(userId)
		 }
		 user.observe(this) { user ->
            activityMainBinding.infoText.text = user.firstName
        }
	 }
	 ...
}

在“Get User”按钮的点击事件中使用随机函数生成了一个userId,然后调用MainViewModel的getUser()方法来获取用户数据,但是这个方法现在不会有任何返回值了
等数据获取完成之后,可观察LiveData对象的observe()方法将会得到通知,在这里将获取的用户名显示到界面上

运行程序,并一直点击“Get User”按钮,会发现界面上的数字会一直在变。这是因为我们传入的userId值是随机的,同时也说明switchMap()方法确实已经正常工作了

探究Jetpack(二)之LiveData_第1张图片

你可能感兴趣的:(Android,android)