◾︎简介
ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。
举个例子：在 MVP 中，Activity/Fragment 调用 P 层的异步请求。由于 P 层要持有 Activity/Fragment 的引用用于回调接口，当 Activity/Fragment 销毁后，造成内存泄露。为此，必须做大量的工作去管理异步请求。
而 ViewModel 不持有 Activity/Fragment 的引用，不存在上述问题。ViewModel 的 UI 更新是通过观察者模式（LiveData）实现的。
ViewModel 类让数据可在发生屏幕旋转等配置更改后继续留存。
当屏幕旋转时，为了避免数据丢失，通常会在 onSaveInstanceState() 中保存数据，然后在 onCreate() 的 Bundle 中恢复数据。但是这种方法有限制，数据必须支持序列化和反序列化，而且数据不能太大。
而 ViewModel 在 Activity 销毁重建时，会关联到新的 Activity，不需要手动保存再恢复。ViewModel 保存的数据格式和大小也没有像 Bundle 的限制。
本文代码使用 Kotlin 讲解，若需查看 Java 代码写法，请参考文末 Sample
◾︎添加依赖
ViewModel 一般和 LiveData 一起使用。
def lifecycle_version = "2.3.1"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
◾︎使用
定义 ViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class MyViewModel : ViewModel() {
private val news: MutableLiveData<String> by lazy {
MutableLiveData<String>().also {
fetchNews()
}
}
fun getNews(): LiveData<String> {
return news
}
private fun fetchNews() {
Thread {
Thread.sleep(3000)
news.postValue("Completed!")
}.start()
}
}
使用 ViewModel
import android.os.Bundle
import android.widget.Toast
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val model = ViewModelProvider(this)[MyViewModel::class.java]
model.getNews().observe(this) { msg ->
Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()
}
}
}
以上代码得到的 MyViewModel 实例是默认调用 MyViewModel 的无参构造方法。
我们知道，Android 中经常要用到 Context，如果需要在 ViewModel 中使用 Context，那么就需要调用带 Context 参数的构造方法了。
class MyViewModel(private val context: Context) : ViewModel() {
......
}
要调用有参构造方法，需要自定义 ViewModelProvider.Factory。
class MyViewModelFactory(private val context: Context) : ViewModelProvider.Factory {
override fun <T : ViewModel?> create(modelClass: Class<T>): T {
try {
// 遍历所有构造方法
for (constructor in modelClass.constructors) {
// 找出只有一个 Context 参数的构造方法
if (arrayOf(Context::class.java).contentEquals(constructor.parameterTypes)) {
// 利用此构造方法创建实例
return (constructor as Constructor<T>).newInstance(context)
}
}
return modelClass.newInstance()
} catch (e: InstantiationException) {
throw RuntimeException("Cannot create an instance of $modelClass", e)
} catch (e: IllegalAccessException) {
throw RuntimeException("Cannot create an instance of $modelClass", e)
}
}
}
最后在获取 ViewModel 实例的时候，传入自定义的 ViewModelProvider.Factory 即可。
val model = ViewModelProvider(this, MyViewModelFactory(applicationContext))[MyViewModel::class.java]
仔细观察，会发现 ViewModelProvider 中有定义好的几种 Factory，其中就有 AndroidViewModelFactory，和我们上面自定义的 Factory 一样，可以直接拿来用。
◾︎ViewModel 的生命周期
ViewModel 的生命周期取决于传入 ViewModelProvider 的 ViewModelStoreOwner，也就是 Activity/Fragment。ViewModel 一直存在内存中，直到 Activity 完成时，Fragment 分离时。
所以，屏幕旋转后，ViewModel 依然存在在内存中。屏幕旋转时，ViewModel 的生命周期如下：
◾︎在 Fragment 之间共享数据
比如一个界面左边是列表 Fragment，右边是详细信息 Fragment。点了列表 Fragment 某一项需要把该项的信息传递给详细信息 Fragment。
先定义一个用于共享数据的 ViewModel
class SharedViewModel : ViewModel() {
val selected = MutableLiveData<Item>()
fun select(item: Item) {
selected.value = item
}
}
然后在两个 Fragment 中分别获取 ViewModel
class ListFragment : Fragment() {
private lateinit var itemSelector: Selector
// Use the 'by activityViewModels()' Kotlin property delegate
// from the fragment-ktx artifact
private val model: SharedViewModel by activityViewModels()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
itemSelector.setOnClickListener { item ->
model.select(item)
}
}
}
class DetailFragment : Fragment() {
// Use the 'by activityViewModels()' Kotlin property delegate
// from the fragment-ktx artifact
private val model: SharedViewModel by activityViewModels()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
model.selected.observe(viewLifecycleOwner, Observer<Item> { item ->
// Update the UI
})
}
}
这两个 Fragment 都会检索包含它们的 Activity。这样，当这两个 Fragment 各自获取 ViewModelProvider 时，它们会收到相同的 SharedViewModel 实例。
有了 ViewModel，Activity 不需要执行任何操作就可以实现 Fragment 间的数据共享。而且 Fragment 之间也相互独立，就算其中一个 Fragment 消失了，另一个 Fragment 也照样正常工作。
◾︎Factory
创建 ViewModel 的时候会用到 Factory。
你可能有疑问，上面的例子中哪里用到了？
val model = ViewModelProvider(this)[MyViewModel::class.java]
别急，我们慢慢看源码。
首先看 ViewModelProvider 的构造方法：
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
可以看到指定了默认的 Factory
owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance())
当 owner 也就是例子中的 Activity 实现了 HasDefaultViewModelProviderFactory 接口并覆写了 getDefaultViewModelProviderFactory 方法的时候，返回它。否则返回一个 NewInstanceFactory 实例。
看到没有，虽然没有显示指定 Factory，但是内部使用了默认的 Factory。
Android 默认给开发者提供了两种 Factory。NewInstanceFactory 和 AndroidViewModelFactory
先来看 NewInstanceFactory：
public static class NewInstanceFactory implements Factory {
private static NewInstanceFactory sInstance;
static NewInstanceFactory getInstance() {
if (sInstance == null) {
sInstance = new NewInstanceFactory();
}
return sInstance;
}
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
try {
return modelClass.newInstance();
} catch (InstantiationException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (IllegalAccessException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
}
}
}
重点是 create 方法，它是用来指定创建 ViewModel 的时候使用 ViewModel 的哪个构造方法的。这里的 modelClass.newInstance() 会调用无参构造方法。
再来看 AndroidViewModelFactory：
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
private static AndroidViewModelFactory sInstance;
public static AndroidViewModelFactory getInstance(@NonNull Application application) {
if (sInstance == null) {
sInstance = new AndroidViewModelFactory(application);
}
return sInstance;
}
private Application mApplication;
public AndroidViewModelFactory(@NonNull Application application) {
mApplication = application;
}
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
try {
return modelClass.getConstructor(Application.class).newInstance(mApplication);
} catch (NoSuchMethodException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (IllegalAccessException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (InstantiationException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (InvocationTargetException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
}
}
return super.create(modelClass);
}
}
重点还是来看 create 方法。
当 AndroidViewModel.class.isAssignableFrom(modelClass) 也就是要创建的 ViewModel 继承自 AndroidViewModel 的话，会调用参数是 Application 的构造方法，也就是 AndroidViewModel 中定义的构造方法。
public class AndroidViewModel extends ViewModel {
@SuppressLint("StaticFieldLeak")
private Application mApplication;
public AndroidViewModel(@NonNull Application application) {
mApplication = application;
}
@SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
public <T extends Application> T getApplication() {
return (T) mApplication;
}
}
当 ViewModel 需要用到资源文件的时候，Application 就很有用了。注意：ViewModel 中不能传 Activity，因为 ViewModel 的生命周期比较长。
AndroidViewModelFactory 使用例：
val factory = ViewModelProvider.AndroidViewModelFactory(application)
val model = ViewModelProvider(this, factory)[MyViewModel::class.java]
当然，如果系统的 Factory 不能满足的话，我们也可以自定义 Factory。
比如：
public class MyViewModelFactory(val age: Int): ViewModelProvider.Factory {
override fun <T : ViewModel> create(viewModelClass: Class<T>): T {
return viewModelClass.getConstructor(Int::class.java).newInstance(age)
}
}
这个 Factory 会调用 public MyViewModel(age :Int) 构造方法。
具体使用如下：
val factory = MyViewModelFactory(10)
val model = ViewModelProvider(this, factory)[MyViewModel::class.java]
