ViewModel正确使用姿势
看了网上很多对于ViewModel的讲解，对比了官方的使用，自觉有点官方译文科普的意思，即使看很多，仍旧没有醍醐灌顶的感觉，于是，深入源码分析后，便想将对于ViewModel的使用以及定位做一些简单的记录，如与编者有不一样的看法，希望在评论区一起讨论。文章旨在抛砖引玉，并无教学之意。
对于ViewModel的官方介绍：
ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。ViewModel类让数据可在发生屏幕旋转等配置更改后继续留存。
从介绍来看，仿佛ViewModel有自己的生命周期？看到有些文章也是这样描述，提到：ViewModel会维护自己的生命周期。那么，它真的会维护自己的生命周期吗？
问题一：ViewModel生命周期？
首先，ViewModel是如何创建的？
class MainViewModel : ViewModel() {}
class MainActivity : ComponentActivity() {
private val model: MainViewModel by viewModels()
}
我通过官方给的委托函数进行了ViewModel的初始化，直接跟进去查看ViewModel的创建，可以找到关键的创建语句，
ViewModelProvider(store, factory).get(MainViewModel::class.java)
直接跟到get方珐的实现
public T get(@NonNull Class modelClass) {
String canonicalName = modelClass.getCanonicalName();
……略过
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
public T get(@NonNull String key, @NonNull Class modelClass) {
ViewModel viewModel = mViewModelStore.get(key);
if (modelClass.isInstance(viewModel)) {
if (mFactory instanceof OnRequeryFactory) {
((OnRequeryFactory) mFactory).onRequery(viewModel);
}
return (T) viewModel;
} else {
if (viewModel != null) {
}
}
if (mFactory instanceof KeyedFactory) {
//走到这里,记住create方法
viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
} else {
viewModel = mFactory.create(modelClass);
}
//请记住这个东西
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
那么可以看出来ViewModelProvider的两个参数
- mViewModelStore ：ViewModel的复用有关
- Factory ：与创建有关
先不管复用规则，找到当前创建ViewModel的Factory，找到委托方法的factory可以看到
public inline fun ComponentActivity.viewModels(
noinline factoryProducer: (() -> Factory)? = null
): Lazy {
val factoryPromise = factoryProducer ?: {
defaultViewModelProviderFactory
}
return ViewModelLazy(VM::class, { viewModelStore }, factoryPromise)
}
找到ComponentActivity的默认Factory->SavedStateViewModelFactory
@NonNull
@Override
public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
if (mDefaultFactory == null) {
mDefaultFactory = new SavedStateViewModelFactory(
getApplication(),
this,
getIntent() != null ? getIntent().getExtras() : null);
}
return mDefaultFactory;
}
//顺便看一下它的构造方法
public SavedStateViewModelFactory(@Nullable Application application,
@NonNull SavedStateRegistryOwner owner,
@Nullable Bundle defaultArgs) {
mSavedStateRegistry = owner.getSavedStateRegistry();
mLifecycle = owner.getLifecycle();
mDefaultArgs = defaultArgs;
mApplication = application;
//这里很关键
mFactory = application != null
? ViewModelProvider.AndroidViewModelFactory.getInstance(application)
: ViewModelProvider.NewInstanceFactory.getInstance();
}
可以看到，在创建SavedStateViewModelFactory的同时，又看到了两个Factory。
暂且不管，追一下这个默认的Factory是如何执行Create方法的
public T create(@NonNull String key, @NonNull Class modelClass) {
boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);
Constructor constructor;
if (isAndroidViewModel && mApplication != null) {
constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);
} else {
constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);
}
//这句注释很有意思，留神。
// doesn't need SavedStateHandle
if (constructor == null) {
return mFactory.create(modelClass);
}
SavedStateHandleController controller = SavedStateHandleController.create(
mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
try {
T viewmodel;
if (isAndroidViewModel && mApplication != null) {
viewmodel = constructor.newInstance(mApplication, controller.getHandle());
} else {
viewmodel = constructor.newInstance(controller.getHandle());
}
return viewmodel;
}
这段代码是在寻找ViewModel的构造器，可以看到这段代码的最后是要调用ViewModel的两个带参构造函数。
这里是个疑点，为什么要传递参数呢?为什么会固定有一个参数？
先保留疑问，继续看可以发现，我创建的ViewModel走了在SavedStateViewModelFactory构造函数中创建的Factory，这里发现AndroidViewModelFactory派生自NewInstanceFactory，再看一下AndroidViewModelFactory的create函数是如何实现的
public T create(@NonNull Class modelClass) {
if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
return modelClass.getConstructor(Application.class).newInstance(mApplication);
}
return super.create(modelClass);
}
}
发现AndroidViewModelFactory会判断AndroidViewModel是不是modelClass超类或超接口，如果是，则直接调用构造函数的Application参数方法，
如果不是
public T create(@NonNull Class modelClass) {
return modelClass.newInstance();
}
直接创建。
那么ViewModel就创建完毕了，emm...等等，我不是要找它的生命周期吗？为什么没有看到有关生命周期的代码？
难道奥秘都在刚才遗忘的mViewModelStore中？看一下它的代码
public class ViewModelStore {
private final HashMap mMap = new HashMap<>();
final void put(String key, ViewModel viewModel) {
ViewModel oldViewModel = mMap.put(key, viewModel);
if (oldViewModel != null) {
oldViewModel.onCleared();
}
}
final ViewModel get(String key) {
return mMap.get(key);
}
Set keys() {
return new HashSet<>(mMap.keySet());
}
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
这。。。不就是个容器吗？它在哪里创建的？再回顾一下委托函数
public inline fun ComponentActivity.viewModels(
noinline factoryProducer: (() -> Factory)? = null
): Lazy {
val factoryPromise = factoryProducer ?: {
defaultViewModelProviderFactory
}
return ViewModelLazy(VM::class, { viewModelStore }, factoryPromise)
}
哦，可以看到在我注册的Activity中有一个viewModelStore,那么它是如何创建的？
public ViewModelStore getViewModelStore() {
if (getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the "
+ "Application instance. You can't request ViewModel before onCreate call.");
}
ensureViewModelStore();
return mViewModelStore;
}
void ensureViewModelStore() {
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
}
这里的getLastNonConfigurationInstance()只需要知道，这个是一种界面恢复与保存的API，跟它一样的有我们熟知的onSaveInstanceState / onRestoreInstanceState，如果你感兴趣可以查阅资料，不过这个Api在新的Sdk中已经不建议使用了，这里一会我们继续谈。
所以说，ViewModelStore保存了每个ViewModel的实例，在页面重构时做了处理。让每个界面的ViewModelStore不会因为重构而消失。那么，它怎样才能消失呢？难道ViewModel会一直存在吗？
当然不是，ViewModelStore明明有clear()方法，那么它的调用时机是怎样的呢？
查找了下，第一个正是我当前想要知道的，它对应的代码如下
public ComponentActivity() {
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
mContextAwareHelper.clearAvailableContext();
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
}
所以，在创建ComponentActivity的时候注册了监听当生命周期到ON_DESTORY的时候并且不是更改配置，就清空Store。
分析完毕。
结论：ViewModel并没有自己的生命周期，官方所谓的能在界面变动时不丢失数据，也是因为ViewModel的容器在对应的逻辑做了保存处理。
问题二：既然如此，那么我可不可以制作一个由我控制生命周期的ViewModel呢？
当然可以
class AppViewModelStore : ViewModelStoreOwner , LifecycleEventObserver{
var store: ViewModelStore = ViewModelStore()
override fun getViewModelStore(): ViewModelStore {
return store
}
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
//在Life走到ON_PAUSE清理。举例说明，不建议使用。
if (event == Lifecycle.Event.ON_PAUSE) {
store.clear()
}
}
}
//使用
ViewModelProvider(AppViewModelStore()).get(MainViewModel::class.java)
问题三：我可不可以创建一个自定义参数的ViewModel呢？
分析源码可以知道，store负责ViewModel保存与销毁，Factory负责创建，所以直接重写Factory即可。
class MyVMFactory : ViewModelProvider.Factory {
override fun create(modelClass: Class): T {
return MainViewModel(参数) as T
}
}
//使用
ViewModelProvider(AppViewModelStore(),MyVMFactory()).get(MainViewModel::class.java)
只需要像源码那样创建就可以，只要把握ViewModelStore的保存与销毁即可。
到这里，不免有点失落，viewModel就这？
google真的只是帮开发者做了这些吗？就当我准备结束的时候，突然想起，在分析ViewModel生命周期中的一段注释
/**
* Use this instead of {#onRetainNonConfigurationInstance()}.
* Retrieve later with {#getLastCustomNonConfigurationInstance()}.
*
* @deprecated Use a { androidx.lifecycle.ViewModel} to store non config state.
*/
是的，在getLastCustomNonConfigurationInstance()方法与onRetainNonConfigurationInstance()方法上的注释，让我用ViewModel去做配置项的东西，相当于，onSaveInstanceState与onRestoreInstanceState，可以用ViewModel直接配置。
看到这句话你明白了吗？
我举一个开发中的例子：
当用户的手机在后台很久之后，系统会回收应用的资源，导致一些数据丢失，打开应用会丢失数据或者崩溃，因此很多的开发者会把一部分数据做本地持久化处理，没有持久化处理的数据需要用onSaveInstanceState与onRestoreInstanceState进行保存与恢复。然后项目的代码变成了这样
override fun onSaveInstanceState(outState: Bundle) {
outState.putBoolean("MBoolean", true)
outState.putInt("MInt", 1)
outState.putString("MString", "save Info")
```
省略
```
super.onSaveInstanceState(outState)
}
override fun onRestoreInstanceState(savedInstanceState: Bundle) {
savedInstanceState.getBoolean("MBoolean", true)
savedInstanceState.getInt("MInt", 1)
savedInstanceState.getString("MString", "save Info")
```
省略
```
super.onRestoreInstanceState(savedInstanceState)
}
是的，这样不容易维护，大量的代码让人摸不着头脑，因此很多应用都统一让用户重新加载。
那么用ViewModel怎么解决了这个问题呢？
class MainViewModel(private val savedStateHandle: SavedStateHandle) : ViewModel() {
fun getType(){
```
业务逻辑
```
savedStateHandle.get("sKey")
}
fun putMessage(){
```
业务逻辑
```
savedStateHandle["sKey"] = "save info"
}
}
只需要在ViewModel的构造器中添加SavedStateHandle参数即可。
它的创建是在我的第一个疑惑点，在分析Factory的创建代码中对于构造器的选择。
当一次业务代码完成后即可选择是否要将业务内容保存下来，当系统因内存不足回收应用数据后，应用仍然能第一时间回到当前界面。对于开发者来说，只需要选择保存与回调的数据。
具体代码请参考
SavedStateViewModelFactory.java
public T create(@NonNull String key, @NonNull Class modelClass) {
……省略
SavedStateHandleController controller = SavedStateHandleController.create(
mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
……
}
因篇幅问题，不做详细分析。
其实这些东西就是在开发者文档中的一些用法，只是我从一个点走过了全程，在我没有阅读文档情况下，我发现了这些用法，于是便去文档中进行查找。地址在这里
最后
我突然想到，如果这样那ViewModel的构造函数岂不是无法自定义了？并且自定义ViewModelStore也不能用了？
但是，反过来想想，Google也没有说ViewModel支持这些做法，而且，我的一些想法明显是在破坏ViewModel自身的设计。难怪Google由最初的教大家自定义Factory传递参数到只字不提。
结论
- ViewModel生命周期？
ViewModel本身没有生命周期，装载ViewModel的容器ViewModelStore有生命周期。 - 我可不可以制作一个由我控制生命周期的ViewModel呢？
可以，但是创建了之后将失去ViewModel的意义。 - 我可不可以创建一个自定义参数的ViewModel呢？
可以，但是创建了之后将失去ViewModel的优点。 - ViewModel到底是什么？
正确使用它是有生命的容器
错误使用它是数据容器。
作者：仓鼠说他不会飞
链接：https://www.jianshu.com/p/33602a74af37
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。