上一篇文章讲到了Android架构组件之LiveData(Android 架构组件(二): LiveData),现在我们再来看看另一个成员ViewModel。
ViewModel是什么?
ViewModel,从字面上理解的话,我们也能想到它肯定是跟视图(View)以及数据(Model)相关的。正像它字面意思一样,它是负责准备和管理和UI组件(Fragment/Activity)相关的数据类,也就是说ViewModel是用来管理UI相关的数据的。同时ViewModel还可以用来负责UI组件间的通信,这一点后面我们会有例子说明。
为什么需要ViewModel?
在看过前面两篇介绍Lifecycle和LiveData的内容后,这个问题的基本就不用回答了。既然ViewModel是用来管理和UI组件有关的数据的,而LiveData又是这些数据的持有类,所以在使用LiveData的时候,就自然想到要使用ViewModel了。另外从ViewModel的定义,我们也能看到ViewModel还可以用于UI组件间的通信,回想下当初面试官问你Fragment之间怎么通信的问题,掌握ViewModel后就多了一种高逼格的回答了。
ViewModel基本使用
前面在讲解LiveData时,我们已经使用了ViewModel,所以它的基本使用,在这里就不在赘述了,忘了的同学可以重新去翻一翻Android架构组件(二)——LiveData。我们主要看下ViewModel的生命周期,以及它用于组件间通信的使用。
ViewModel生命周期
我们看看ViewModel的生命周期,在官方文档中,用下面这张图来描述ViewModel的生命周期。
上图是用Activity作为例子,左侧表示Activity的生命周期状态,右侧绿色部分表示ViewModel的生命周期范围。当屏幕旋转的时候,Activity会被recreate,Activity会经过几个生命周期方法,但是这个时候ViewModel还是之前的对象,并没有被重新创建,只有当Activity的finish()方法被调用时,ViewModel.onCleared()方法会被调用,对象才会被销毁。这张图很好的描述了是当Activity被recreate时,ViewModel的生命周期。
另外,有个注意的地方:在ViewModel中不要持有Activity的引用。为什么要注意这一点呢?从上面的图我们看到,当Activity被recreate时,ViewModel对象并没有被销毁,如果Model持有Activity的引用时就可能会导致内存泄漏。那如果你要使用到Context对象怎么办呢,那就使用ViewModel的子类AndroidViewModel吧。
用于组件间通信
下面我们看下ViewModel用于Fragment之间通信的例子。
/** * Created by shymanzhu on 2017/12/26. */ public class CommunicateViewModel extends ViewModel { private static final String TAG = "CommunicateViewModel"; private MutableLiveData<String> mNameLiveData; public LiveData<String> getName(){ if (mNameLiveData == null) { mNameLiveData = new MutableLiveData<>(); } return mNameLiveData; } public void setName(String name){ if (mNameLiveData != null) { Log.d(TAG, "setName: " + name); mNameLiveData.setValue(name); } } @Override protected void onCleared() { super.onCleared(); mNameLiveData = null; } } |
/** * Created by shymanzhu on 2017/12/26. */ public class FragmentOne extends Fragment { private CommunicateViewModel mCommunicateViewModel; public static FragmentOne getInstance(){ return new FragmentOne(); } @Override public void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); mCommunicateViewModel = ViewModelProviders.of(getActivity()).get(CommunicateViewModel.class); } @Nullable @Override public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_one, container, false); ButterKnife.bind(this, view); return view; } @OnClick(R.id.btn_set_name) void onViewClicked(View v){ switch (v.getId()){ case R.id.btn_set_name: mCommunicateViewModel.setName("Jane"); break; } } } |
/** * Created by shymanzhu on 2017/12/26. */ public class FragmentTwo extends Fragment { @BindView(R.id.tv_name) TextView mTvName; private CommunicateViewModel mCommunicateViewModel; public static FragmentTwo getInstance(){ return new FragmentTwo(); } @Override public void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); mCommunicateViewModel = ViewModelProviders.of(getActivity()).get(CommunicateViewModel.class); mCommunicateViewModel.getName().observe(this, name -> mTvName.setText(name)); } @Nullable @Override public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_two, container, false); ButterKnife.bind(this, view); return view; } } |
代码逻辑很简单,首先定义一个CommunicateViewModel类,继承自ViewModel。然后定义两个Fragment:FragmentOne和FragmentTwo。在FragmentOne中改变CommunicateViewModel中LiveData保存的数据,然后在FragmentTwo中会收到数据改变的通知。这样一个过程就完成了FragmentOne和FragmentTwo之间的一次简单的通信。至于其中的原理,相信看过LiveData这篇文章话,这都不是问题了。在上面的例子中有个小陷阱:在初始化mCommunicateViewModel时,ViewModelProviders.of()方法传入的是Activity对象,如果你改成Fragment对象,那FragmentTwo里就只能傻等了,永远不会收到数据改变的通知。因为如果传给方法ViewModelProviders.of()的对象不同时,最终得到的就不是同一个ViewModel对象,这一点也可以通过打印两个Fragment中的mCommunicateViewModel验证。
实现原理
在讲ViewModel的原理时,我们还是延续前面的传统,先理清ViewModel相关的类图,然后理清ViewModel使用的时序图,最后就是根据时序图分析源码。
类图
废话不多说,直接上ViewModel相关的类图:
-
ViewModelProviders是ViewModel工具类,该类提供了通过Fragment和Activity得到ViewModel的方法,而具体实现又是有ViewModelProvider实现的。ViewModelProvider是实现ViewModel创建、获取的工具类。在ViewModelProvider中定义了一个创建ViewModel的接口类——Factory。ViewModelProvider中有个ViewModelStore对象,用于存储ViewModel对象。
-
ViewModelStore是存储ViewModel的类,具体实现是通过HashMap来保存ViewModle对象。
-
ViewModel是个抽象类,里面只定义了一个onCleared()方法,该方法在ViewModel不在被使用时调用。ViewModel有一个子类AndroidViewModel,这个类是便于要在ViewModel中使用Context对象,因为我们前面提到是不能在ViewModel中持有Activity的引用。
-
ViewModelStores是ViewModelStore的工厂方法类,它会关联HolderFragment,HolderFragment有个嵌套类——HolderFragmentManager。
类图要说明的内容就是以上几点了,对于UML类图中的关联、聚合、组合的关系,个人觉得比较难区分,在这里找到了一个比较好的回答What is the difference between association, aggregation and composition?
时序图
在使用ViewModel的例子中,也许你会察觉得到一个ViewModel对象需要的步骤有点多啊,怎么不直接new一个出来呢?在你看到ViewModel的类图关系后,你应该就能明白了,因为是会缓存ViewModel对象的。下面以在Fragment中得到ViewModel对象为例看下整个过程的时序图。
时序图看起来比较复杂,但是它只描述了两个过程:
- 得到ViewModel对象。
- HolderFragment被销毁时,ViewModel收到onCleared()通知。
读者朋友们可以根据这个时序结合源码看下具体的实现,这个也是我们下面要讲的内容——源码分析。
源码分析
根据上面时序图中的内容,我们从两个方面着手研究下ViewModel相关源码。
获取ViewModel对象
得到ViweModel对象,首先是通过ViewModelProviders.of()方法得到ViewModelProvider对象,然后调用ViewModelProvider.get()方法得到ViewModel对象。
一、得到ViewModelProvider对象
直接看ViewModelProviders类的具体实现
public class ViewModelProviders { @SuppressLint("StaticFieldLeak") private static DefaultFactory sDefaultFactory; private static void initializeFactoryIfNeeded(Application application) { if (sDefaultFactory == null) { sDefaultFactory = new DefaultFactory(application); } } private static Application checkApplication(Activity activity) { Application application = activity.getApplication(); if (application == null) { throw new IllegalStateException("Your activity/fragment is not yet attached to " + "Application. You can't request ViewModel before onCreate call."); } return application; } private static Activity checkActivity(Fragment fragment) { Activity activity = fragment.getActivity(); if (activity == null) { throw new IllegalStateException("Can't create ViewModelProvider for detached fragment"); } return activity; } @MainThread public static ViewModelProvider of(@NonNull Fragment fragment) { initializeFactoryIfNeeded(checkApplication(checkActivity(fragment))); return new ViewModelProvider(ViewModelStores.of(fragment), sDefaultFactory); } @MainThread public static ViewModelProvider of(@NonNull FragmentActivity activity) { initializeFactoryIfNeeded(checkApplication(activity)); return new ViewModelProvider(ViewModelStores.of(activity), sDefaultFactory); } @MainThread public static ViewModelProvider of(@NonNull Fragment fragment, @NonNull Factory factory) { checkApplication(checkActivity(fragment)); return new ViewModelProvider(ViewModelStores.of(fragment), factory); } @MainThread public static ViewModelProvider of(@NonNull FragmentActivity activity, @NonNull Factory factory) { checkApplication(activity); return new ViewModelProvider(ViewModelStores.of(activity), factory); } @SuppressWarnings("WeakerAccess") public static class DefaultFactory extends ViewModelProvider.NewInstanceFactory { private Application mApplication; /** * Creates a {@code DefaultFactory} * * @param application an application to pass in {@link AndroidViewModel} */ public DefaultFactory(@NonNull Application application) { mApplication = application; } @NonNull @Override public <T extends ViewModel> T create(@NonNull Class<T> modelClass) { if (AndroidViewModel.class.isAssignableFrom(modelClass)) { //noinspection TryWithIdenticalCatches 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); } } } |
ViewModelProviders提供了四个of()方法,四个方法功能类似,其中of(FragmentActivity activity, Factory factory)和of(Fragment fragment, Factory factory)提供了自定义创建ViewModel的方法。我们在时序图中使用of(Fragment fragment)最为研究对象,这里我们也从该方法开始研究,在该方法中主要有两个步骤。
1,判断是否需要初始化默认的Factory
这一过程很简单:通过调用initializeFactoryIfNeeded()方法判断是否需要初始化mDefaultFactory变量。在此之前又会判断Fragment的是否Attached to Activity,Activity的Application对象是否为空。
2,创建一个ViewModelProvider对象。
创建ViewModel对象看似很简单,一行代码搞定new ViewModelProvider(ViewModelStores.of(fragment), sDefaultFactory)
。但是里面的里面的逻辑比较深,我们慢慢把它抽丝剥茧,看看有多深。
先看看ViewModelStores.of()方法
@MainThread public static ViewModelStore of(@NonNull Fragment fragment) { return holderFragmentFor(fragment).getViewModelStore(); } |
又是一行代码,holderFragmentFor()是HolderFragment的静态方法,HolderFragment继承自Fragment。我们先看holderFragment()方法的具体实现
/** * @hide */ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) public static HolderFragment holderFragmentFor(Fragment fragment) { return sHolderFragmentManager.holderFragmentFor(fragment); } public ViewModelStore getViewModelStore() { return mViewModelStore; //返回ViewModelStore对象 } |
额,holderFragmentFor()又是一行代码,继续看HolderFragmentManager.holderFragmentFor()方法的具体实现
HolderFragment holderFragmentFor(Fragment parentFragment) { FragmentManager fm = parentFragment.getChildFragmentManager(); HolderFragment holder = findHolderFragment(fm); // 在activity和back stack中查找parentFragment if (holder != null) { return holder; } holder = mNotCommittedFragmentHolders.get(parentFragment); if (holder != null) { return holder; } // 注册Fragment生命周期回调 parentFragment.getFragmentManager() .registerFragmentLifecycleCallbacks(mParentDestroyedCallback, false); holder = createHolderFragment(fm); //创建HolderFragment对象。 mNotCommittedFragmentHolders.put(parentFragment, holder); return holder; } private FragmentLifecycleCallbacks mParentDestroyedCallback = new FragmentLifecycleCallbacks() { @Override public void onFragmentDestroyed(FragmentManager fm, Fragment parentFragment) { super.onFragmentDestroyed(fm, parentFragment); HolderFragment fragment = mNotCommittedFragmentHolders.remove( parentFragment); if (fragment != null) { Log.e(LOG_TAG, "Failed to save a ViewModel for " + parentFragment); } } }; private static HolderFragment createHolderFragment(FragmentManager fragmentManager) { HolderFragment holder = new HolderFragment(); // 创建HolderFragment对象 fragmentManager.beginTransaction().add(holder, HOLDER_TAG).commitAllowingStateLoss(); return holder; } public HolderFragment() { //这个是关键,这就使得Activity被recreate时,Fragment的onDestroy()和onCreate()不会被调用 setRetainInstance(true); } |
在createHolderFragment()方法中,你也许发现调用FragmentTransaction.add()方法并没有传一个定义在layout文件中的id进去,而且你去看HolderFragment并没有重写Fragment.onCreateView()方法。这个有点反常,这是为什么呢? 这个疑惑可以从HolderFragment()构造方法中得到解答。在构造方法中调用了setRetainInstance(true)方法,该方法会使得HolderFragment所在的Activity被recreate时,HolderFragment不会被recreate,自然它就不会走onDestroy()、onCreate()方法。为什么不让HolderFragment被recreate呢?这里先卖个关子,等到在讲时序图中步骤二时我们再讲。
到此为止,我们已经得到了ViewStore对象,前面我们在创建ViewModelProvider对象是通过这行代码实现的new ViewModelProvider(ViewModelStores.of(fragment), sDefaultFactory)
现在再看下ViewModelProvider的构造方法
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) { mFactory = factory; this.mViewModelStore = store; // 这个ViewStore对象实际上是HolderFragment中的ViewStore对象。 } |
二、得到ViewModel对象
在上面我们已经得到了ViewModelProvider对象,现在就可以通过ViewModelProvider.get()方法得到ViewModel对象,继续看下该方法的具体实现
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) { String canonicalName = modelClass.getCanonicalName(); if (canonicalName == null) { throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels"); } return get(DEFAULT_KEY + ":" + canonicalName, modelClass); } @MainThread public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) { ViewModel viewModel = mViewModelStore.get(key); //从缓存中查找是否有已有ViewModel对象。 if (modelClass.isInstance(viewModel)) { //noinspection unchecked return (T) viewModel; } else { //noinspection StatementWithEmptyBody if (viewModel != null) { // TODO: log a warning. } } viewModel = mFactory.create(modelClass); //创建ViewModel对象,然后缓存起来。 mViewModelStore.put(key, viewModel); //noinspection unchecked return (T) viewModel; } |
ViewModelProvider.get()方法比较简单,该说的都在注释中写明了。最后我们看下ViewModelStore类的具体实现
public class ViewModelStore { private final HashMap<String, ViewModel> mMap = new HashMap<>(); final void put(String key, ViewModel viewModel) { ViewModel oldViewModel = mMap.get(key); if (oldViewModel != null) { oldViewModel.onCleared(); } mMap.put(key, viewModel); } final ViewModel get(String key) { return mMap.get(key); } /** * Clears internal storage and notifies ViewModels that they are no longer used. */ public final void clear() { for (ViewModel vm : mMap.values()) { vm.onCleared(); } mMap.clear(); } } |
ViewModelStore是缓存ViewModel的类,put()、get()方法用于存取ViewModel对象,另外提供了clear()方法用于清空缓存的ViewModel对象,在该方法中会调用ViewModel.onCleared()方法通知ViewModel对象不再被使用。
####ViewModel收到onCleared()通知。
在前面我们提到,在HolderFragment的构造方法中调用了setRetainInstance(true);
目的是为了在其所在的Activity被recreate时,HolderFragment不会被recreate,为什么要这么做呢(之前面卖的关子),那就要看下它的onDestroy()方法了。
@Override public void onDestroy() { super.onDestroy(); mViewModelStore.clear(); } |
在onDestroy()方法中调用了ViewModelStore.clear()方法,我们知道在该方法中会调用ViewModel的onCleared()方法。在你看了HolderFragment源码后,或许你会有个疑问,mViewModelStore保存的ViewModel对象是在哪里添加的呢? 细心的话,你会发现在ViewModelProvider的构造方法中,已经将HolderFragment中的ViwModelStore对象mViewModelStore的引用传递给了ViewModelProvider中的mViewModelStore,而在ViewModelProvider.get()方法中会向mViewModelStore添加ViewModel对象。
总结
总结,额….还是由你们来完成,抛一个问题来作为总结吧:为什么ViewModel的生命周期比使用它的Activity/Fragment的生命周期更长呢? 如果你有认真看完这篇文章,我相信这个问题是难不倒你,如果没想到,那就多看几遍吧。最后,提供一张图来帮助你想这个问题。