Jetpack之ViewModel-一一网

ViewModel作为Jetpack组件库首屈一指的高频组件之一，我们有必要去了解他背后的工作原理，才能真正掌握它是如何实现存储数据的。它的出现释放了Activity/Fragment管理数据的压力，ViewModel经常会搭配LiveData一起用于MVVM的开发模式。

1.什么是ViewModel？

具备宿主生命后期感知能力的数据存储组件，可以很方便的监听到UI上的数据变化
使用ViewModel保存的数据，在页面因配置变更导致页面销毁重建之后依然也是存在的。

配置变更主要是指：横竖屏切换、分辨率调整、权限变更、系统字体样式变更…

主要和LiveData与Room组合使用

注意： ViewModel只是用来管理UI的数据的,千万不要让它持有View、Activity或者Fragment的引用(小心内存泄露)。

2.ViewModel的优势

页面配置更改数据不丢失

当设备因配置更改导致Activiy/Fragment重建，ViewModel中的数据并不会因此丢失，配合LiveData可以在页面重建后立马能收到最新保存的数据用以重新渲染页面。

生命周期感应

在ViewModel中难免会做一些网络请求或数据的处理，可以复写onCleared()方法，终止清理一些操作，释放内存，该方法在宿主onDestory时被调用。

数据共享

对于单Activity对Fragment的页面，可以使用ViewModel实现页面之间的数据共享，实际上不同的Activity也可以实现数据共享。

3.ViewModel的用法

使用ViewModel之前需要先添加依赖：

//通常情况下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
//如果想单独使用，可引入下面的依赖
api 'androidx.lifecycler:lifecycle-viewmodel:2.0.0'
复制代码

基本用法

存储的数据只能当页面因为配置变更导致的销毁再重建时刻复用，复用的是ViewModel的实例对象整体

class MyViewModel() : ViewModel() {
    val liveData = MutableLiveData<List<GoodsModel>>()
    fun loadInitData():LiveData<List<GoodsModel>> {
        //from remote
        //为了适配因配置变更而导致的页面重建, 重复利用之前的数据,加快  新页面渲染，不再请求接口
        if(liveData.value==null){
           val remoteData = fetchDataFromRemote()
           liveData.postValue(remoteData)
        }
        return liveData
    }
}

//通过ViewModelProvider来获取viewmodel对象
//如果在单Activity,多Fragment的页面，只需要都传递所在的Activity对象就可以获取到同一个ViewModel实例，从而实现数据共享。。
val viewModel = ViewModelProvider(Activity/Fragment).get(MyViewModel::class.java)

viewModel.loadPageData().observer(this,Observer{
      //渲染列表  
})

复制代码

进阶用法

存储的数据，无论是配置变更，还是因为内存不足，电量不足等系统原因导致页面被回收再重建。都可以复用。即便ViewModel不是同一个实例，它存储的数据也能做到复用。如果页面被正常关闭，这里的数据会被正常清理释放。

需要主动引入依赖savestate组件

api 'androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0'
复制代码

//我们只需要在构造函数上添加SavedStateHandle参数即可。其他不变
  class HiViewModel(val savedState: SavedStateHandle) : ViewModel() {
    private val KEY_HOME_PAGE_DATA="key_home_page_data"
    private val initData = MutableLiveData<List<GoodsModel>>()
    fun loadInitData():LiveData<List<GoodsModel>> {
       if(initData.value==null){
            //1.from memory .
            //加载数据的时候，先从savedState中尝试读取,如果有直接内存复用
            val memoryData =savedState.get<List<GoodsModel>>(KEY_HOME_PAGE_DATA)
            if(memoryData!=null){
             initData.postValue(memoryData)
          }else{
             //2.from remote
             val remoteData = fetchDataFromRemote()
             //然后存储在savedState以备不时之需,数据模型需要使用parceable接口
             //这种写法,即便页面因配置变更，内存不足被回收
             //页面重建后，我们都能第一时间复用之前的数据，从而快速渲染页面
             //这种能力，对于一级页面尤其首页是至为重要的
             savedState.set(KEY_HOME_PAGE_DATA,remoteData)
             initData.postValue(remoteData)
          }
        }
      return initData
    }
  }
复制代码

跨页面不同的（Activity）的数据共享

//让Application实现ViewModelStoreOwner 接口
class MyApp: Application(), ViewModelStoreOwner {
    private val appViewModelStore: ViewModelStore by lazy {
        ViewModelStore()
    }

    override fun getViewModelStore(): ViewModelStore {
        return appViewModelStore
    } 
}

val viewmodel = ViewProvider(application).get(XXViewModel::class.java)

复制代码

4.配置变更ViewModel复用实现原理

上面说到，ViewModel可以实现因配置变更而导致页面销毁重建之后依然可以复用。准确点来说，应该是页面回复重建前后获取到的是同一个Viewmodel实例对象，以至于页面恢复重建后还能接着复用。那么这是为什么呢？

获取ViewModel对象

获取ViewModel实例的方式如下：

ViewModelProvider本质是从传递进去的ViewModelStore来获取实例。如果没有传递，则利用factory去创建一个新的，并存储到ViewModelStore。

//viewModelStore在Activity和Fragment中，可以看具体的实现，Fragment用的是同一个viewModelStore
val viewmodel =  ViewModelProvider(viewModelStore).get(XXViewModel::class.java)
//或者指定factory
val viewmodel =  ViewModelProvider(viewModelStore,factory).get(XXViewModel::class.java) 
复制代码

注意： 在Fragment中传入的ViewModelStoreOwner对象是Fragment和activity，可以进行对比差异

不同的ViewModelFactory创建Viewmodel实例的方式不同

ViewModelProvider获取ViewModel实例源码分析

class ViewModelProvider{
    
  private static final String DEFAULT_KEY ="androidx.lifecycle.ViewModelProvider.DefaultKey";
  private final ViewModelStore mViewModelStore;

  //根据传递的modelClass 构建一个默认的Key
  public <T extends ViewModel> T get(Class<T> modelClass) {
        String canonicalName = modelClass.getCanonicalName();
        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
  }

  //获取viewmodel实例时，也可以自行指定Key
   public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> 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) {
            }
        }
        //通过反射生成新的ViewModel对象
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
        } else {
            viewModel = (mFactory).create(modelClass);
        }
        //创建完成之后保存起来
        mViewModelStore.put(key, viewModel);
        return (T) viewModel;
    }
    
}


public class ViewModelStore {

    private final HashMap<String, ViewModel> mMap = new HashMap<>();

    final void put(String key, ViewModel viewModel) {
        ViewModel oldViewModel = mMap.put(key, viewModel);
        if (oldViewModel != null) {
            oldViewModel.onCleared();
        }
    }
    ...
}
复制代码

ViewModelStore 一个真正用来存储ViewModel实例的集合。本质上是HashMap<String,ViewModel>

//生成ViewModel的工程类
public class SavedStateViewModelFactory{
    
    ...
    
    public <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {
        boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);
        Constructor<T> constructor;
        if (isAndroidViewModel) {
            constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);
        } else {
            constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);
        }
        if (constructor == null) {
            return mFactory.create(modelClass);
        }

        SavedStateHandleController controller = SavedStateHandleController.create(
                mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
        try {
            T viewmodel;
            if (isAndroidViewModel) {
                viewmodel = constructor.newInstance(mApplication, controller.getHandle());
            } else {
                viewmodel = constructor.newInstance(controller.getHandle());
            }
            viewmodel.setTagIfAbsent(TAG_SAVED_STATE_HANDLE_CONTROLLER, controller);
            return viewmodel;
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Failed to access " + modelClass, e);
        } catch (InstantiationException e) {
            throw new RuntimeException("A " + modelClass + " cannot be instantiated.", e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException("An exception happened in constructor of "
                    + modelClass, e.getCause());
        }
    }
    
    ...

}
复制代码

getViewModelStore源码分析

关键点来，想要ViewModel实例对象不随着宿主重建而销毁，那就要保证ViewModelStore实例对象不随着宿主重建而销毁。

class ComponentActivity extends ViewModelStoreOwner{
    
    
    static final class NonConfigurationInstances {
        Object custom;
        ViewModelStore viewModelStore;
    }
    
    
    public ViewModelStore getViewModelStore() {
       if (mViewModelStore == null) {
       //从源码上可以看出，会首先从`NonConfigurationInstances`来获取`ViewModelStore`实例对象，
       //如果不为空那是不是就能做到复用了 ？
       //所以重点在于`ViewModelStore`何时被存储到`NonConfigurationInstances`里面的.
           NonConfigurationInstances nc =
                   (NonConfigurationInstances) getLastNonConfigurationInstance();
           if (nc != null) {
               mViewModelStore = nc.viewModelStore;
           }
           if (mViewModelStore == null) {
               mViewModelStore = new ViewModelStore();
           }
       }
     
       return mViewModelStore;
    }
   }
}
复制代码

getLastNonConfigurationInstance

    //Activity.java
    @Nullable
    public Object getLastNonConfigurationInstance() {
        return mLastNonConfigurationInstances != null
                ? mLastNonConfigurationInstances.activity : null;
    }
复制代码

onRetainNonConfigurationInstance

因系统原因页面被回收时会触发该方法，所以ViewModelStore对象此时会被存储在NonConfigurationInstance中。在页面恢复重建时会再次把这个NonConfigurationInstance 对象传递到新的Activity中实现对象复用。

class ComponentActivity{
    
    public final Object onRetainNonConfigurationInstance() {
          Object custom = onRetainCustomNonConfigurationInstance();
          ViewModelStore viewModelStore = mViewModelStore;
          if (viewModelStore == null) {
              // 如果NonConfigurationInstance保存了viewModelStore，把它取出来
              NonConfigurationInstances nc =
                  (NonConfigurationInstances) getLastNonConfigurationInstance();
              if (nc != null) {
                  viewModelStore = nc.viewModelStore;
              }
          }

          if (viewModelStore == null && custom == null) {
              return null;
          }

          NonConfigurationInstances nci = new NonConfigurationInstances();
          nci.custom = custom; 
          //把viewModelStore放到NonConfigurationInstances中并返回
          nci.viewModelStore = viewModelStore;
          //这样当页面被销毁时ViewModelStore就被保存起来了。
          return nci;
       }
}
复制代码

注意onRetainNonConfigurationInstance的调用是在ActivityThread中的的handleRelaunchActivity->handleRelaunchActivity–retainNonConfigurationInstances

5.ViewModel的清除周期

ViewModel被清除时会执行clear方法

 public ComponentActivity() {
        Lifecycle lifecycle = getLifecycle();
        //noinspection ConstantConditions
        if (lifecycle == null) {
            throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's "
                    + "constructor. Please make sure you are lazily constructing your Lifecycle "
                    + "in the first call to getLifecycle() rather than relying on field "
                    + "initialization.");
        }
        if (Build.VERSION.SDK_INT >= 19) {
            getLifecycle().addObserver(new LifecycleEventObserver() {
                @Override
                public void onStateChanged(@NonNull LifecycleOwner source,
                        @NonNull Lifecycle.Event event) {
                    if (event == Lifecycle.Event.ON_STOP) {
                        Window window = getWindow();
                        final View decor = window != null ? window.peekDecorView() : null;
                        if (decor != null) {
                            decor.cancelPendingInputEvents();
                        }
                    }
                }
            });
        }
        getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    if (!isChangingConfigurations()) {
                        getViewModelStore().clear();  //viewModel被清除
                    }
                }
            }
        });

        if (19 <= SDK_INT && SDK_INT <= 23) {
            getLifecycle().addObserver(new ImmLeaksCleaner(this));
        }
    }
复制代码

6.和onSaveInstanceState的区别

ViewModel和onSaveInstanceState方法有什么区别？

onSavedInstanceState只能存储轻量级的key-value键值对数据，非配置变更导致的页面被回收时才被触发，此时数据存储在ActivityRecord中；
ViewModel可以存放任意Object数据，因配置变更导致的页面被回收才有效。此时存在ActivityTheard#ActivityClientRecord中。

但是，如果是内存不足或者因为电量不足导致页面被回收，这种情况不是配置变更，所以ViewModel就无法实现复用了，那能不能让ViewModel在这种情况下也能实现数据的存储呢？必须可以！SaveState登场！

文章版权归作者所有，未经允许请勿转载。

THE END

Android