ViewModel 是数据与 UI 分离的中间层，提供了一个将数据转换为 UI 友好型数据的场所。其次，它也提供了多 Fragment 复用相同 ViewModel 的机制。
简单使用
class UserViewModel(): ViewModel() {
val userLiveData = LiveData<User>()
override fun onCleared(){
// clear 工作，例如 Rxjava 里取消订阅
}
}
class UserFragment(): Fragment() {
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
val viewModel = ViewModelProviders.of(this).get(UserViewModel::class.java)
viewModel.userLiveData.observe(viewLifecycleOwner, Observer {
// update ui
})
}
}如果你想在多个 Fragment （同一个 Activity ）里复用这个 UserViewModel , 那么只需要将 ViewModelProviders.of(this) 更换为 ViewModelProviders.of(activity) 即可， 这样 UserViewModel 的生存时间就会和 activity 一致。
注意：这里我使用了 viewLifecycleOwner 而没用使用 lifecycleOwner 。 而 viewLifecycleOwner 是在 androidx 中才存在，这主要是解决 Fragment 中 View 的生命周期与 Fragment 的生命周期不同步的问题。 假设从 FragmentA 跳转到 FragmentB 时, FragmentA 会经历下列生命周期：
onPause -> onStop -> onDestroyView从 FragmentB 返回到 FragmentA 时， FragmentA 又会重新经历下列生命周期：
onCreateView -> onActivityCreated -> onStart -> onResume如果用 Fragment 的生命周期 lifecycleOwner ， 那么将会在FragmentB 返回到 FragmentA 时产生新的 observe 订阅，而旧的订阅并没有被销毁。在之前的版本，可能需要开发者自己去处理重复订阅的问题，而新版 androidx 则提供了 View 的生命周期 viewLifecycleOwner , 开发者可以视需求而采用不同的生命周期。
源码解析
ViewModel 并不是由用户直接通过构造器生成的，而是通过 ViewModelProvider 来获取，这使得使用者不用关心 ViewModel 的生命周期，全部交给框架内部解决。 框架提供了 ViewModelProviders 这个工具方法来提供各种场景下的 ViewModelProvider
// 提供一个将 viewModel 存储 在 Fragment 的 ViewModelProvider
public static ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) {
Application application = checkApplication(checkActivity(fragment));
if (factory == null) {
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(fragment.getViewModelStore(), factory);
}
// 提供一个将 viewModel 存储 在 Activity 的 ViewModelProvider
public static ViewModelProvider of(@NonNull FragmentActivity activity,
@Nullable Factory factory) {
Application application = checkApplication(activity);
if (factory == null) {
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(activity.getViewModelStore(), factory);
}我们可以看出，其关键根据传参是 Fragment 还是 FragmentActivity 而提供不同的 ViewModelStore ：
- 如果是 Fragment , 则 ViewModelStore 依附在 Fragment 上，它提供的 ViewModel 可以存活至 Fragment 销毁。
- 如果是 FragmentActivity ，则 ViewModelStore 依附在 FragmentActivity 上，它提供的 ViewModel 可以存活至 FragmentActivity 销毁。 因此这些 ViewModel 可以在多个 Fragment 中共享。
另外值得一提的是：只有 androidx 中的 Fragment 和 FragmentActivity 才实现了 ViewModelStoreOwner 接口。 所以 androidx 和这之前 support-v4 里的实现并不一样。 旧版本的实现也值得一提，这个我稍后再详细介绍。
public interface ViewModelStoreOwner {
/**
* Returns owned {@link ViewModelStore}
*
* @return a {@code ViewModelStore}
*/
@NonNull
ViewModelStore getViewModelStore();
}
// Fragment 关于 ViewModelStoreOwner 的实现
public class Fragment implements ViewModelStoreOwner, ... {
// 省略其它源码...
// ViewModelStore for storing ViewModels associated with this Fragment
ViewModelStore mViewModelStore;
public ViewModelStore getViewModelStore() {
if (getContext() == null) {
throw new IllegalStateException("Can't access ViewModels from detached fragment");
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
return mViewModelStore;
}
public void onDestroy() {
mCalled = true;
FragmentActivity activity = getActivity();
boolean isChangingConfigurations = activity != null && activity.isChangingConfigurations();
if (mViewModelStore != null && !isChangingConfigurations) {
mViewModelStore.clear();
}
}
}
// FragmentActivity 关于 ViewModelStoreOwner 的实现
public class FragmentActivity extends ComponentActivity implements ViewModelStoreOwner, ... {
private ViewModelStore mViewModelStore;
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.");
}
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
return mViewModelStore;
}
protected void onCreate(@Nullable Bundle savedInstanceState) {
//...
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null && nc.viewModelStore != null && mViewModelStore == null) {
mViewModelStore = nc.viewModelStore;
}
// ...
}
protected void onDestroy() {
super.onDestroy();
if (mViewModelStore != null && !isChangingConfigurations()) {
mViewModelStore.clear();
}
mFragments.dispatchDestroy();
}
}而 ViewModelStore 本身的实现比较容易，基本就是一个 HashMap 来保存 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();
}
}
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 的问题解决了，我们就可以看看 ViewModelProvider 是如何构造 ViewModel 实例并存入 ViewModelFactory 的了。首先看看 ViewModelProvider 里提供的 Factory 接口：
public interface Factory {
/**
* Creates a new instance of the given {@code Class}.
* <p>
*
* @param modelClass a {@code Class} whose instance is requested
* @param <T> The type parameter for the ViewModel.
* @return a newly created ViewModel
*/
@NonNull
<T extends ViewModel> T create(@NonNull Class<T> modelClass);
}通过名字我们就可以看出，这是一个工厂模式的应用，我们可以通过实例出不同的 Factory 来以不同的方式构造 ViewModel ，当然，如果我们没有特殊需求，可以直接使用框架提供的默认 Factory 来构造无参数的 ViewModel 。 如果我们需要传参，则我们需要自己实现 Factory 接口了。
public class ViewModelProvider {
private static final String DEFAULT_KEY = "androidx.lifecycle.ViewModelProvider.DefaultKey";
private final Factory mFactory;
private final ViewModelStore mViewModelStore;
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
String canonicalName = modelClass.getCanonicalName();
//...
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
ViewModel viewModel = mViewModelStore.get(key);
// 如果已经存在，则判断类型是否匹配
if (modelClass.isInstance(viewModel)) {
//noinspection unchecked
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
// 如果不存在，则通过 Factory 创建，并放入 mViewModelStore 中缓存
viewModel = mFactory.create(modelClass);
mViewModelStore.put(key, viewModel);
//noinspection unchecked
return (T) viewModel;
}
}至此，整个 ViewModel 就说得差不多了，使用简单，原理也不是很难，但是功能确实强大。接下来会详细介绍下 ViewModel 1.x 版本时 ViewModelStore 的获取。那个时候， Fragment 和 FragmentActivity 还没有实现 ViewModelStoreOwner 。那我们又如何无感知的让生命周期融入框架中呢？
其实这里用了一个技巧，一个添加到 FragmentManager 的 Fragment 生命周期与 Activity 或者 parent fragment 的生命周期是一致的， 因此可以通过向 Activity 或者 Fragment 添加一个无 View 的 Fragment 来获取其生命周期，再将 ViewModelStore 依附在 这个 Fragment 上。 如果有看过 glide 源码的话，就可以发现其实它也是这么做的，非常成熟的套路，可以学习学习。
ViewModel 1.x 中 ViewModelStore 的获取
public static ViewModelProvider of(@NonNull Fragment fragment) {
//...
return new ViewModelProvider(ViewModelStores.of(fragment), sDefaultFactory);
}
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
//...
return new ViewModelProvider(ViewModelStores.of(activity), sDefaultFactory);
}我们可以看到，其主要其将核心逻辑抽取在了 ViewModelStores 中，接下来我以 FragmentActivity 为例继续追踪源码， Fragment 的逻辑大体相同，只是依赖于 childFragment 而已。
public static ViewModelStore of(@NonNull FragmentActivity activity) {
return holderFragmentFor(activity).getViewModelStore();
}
public static HolderFragment holderFragmentFor(FragmentActivity activity) {
// 移交给 HolderFragmentManager 处理
return sHolderFragmentManager.holderFragmentFor(activity);
}
HolderFragment holderFragmentFor(FragmentActivity activity) {
FragmentManager fm = activity.getSupportFragmentManager();
// 查找 FragmentManager 是否已经存在 HolderFragment
HolderFragment holder = findHolderFragment(fm);
if (holder != null) {
// 已经存在，直接返回
return holder;
}
// 因为 fragment commit 是个异步的过程，所以 FragmentManager 不存在可能是因为 commit 还没执行完成，因此需要在 mNotCommittedActivityHolders 里也存放一份。
holder = mNotCommittedActivityHolders.get(activity);
if (holder != null) {
return holder;
}
if (!mActivityCallbacksIsAdded) {
mActivityCallbacksIsAdded = true;
// 添加 callback, 在 activity 销毁时移除 mNotCommittedActivityHolders 里的缓存， 一个应用只需添加一个 callback 足矣。
activity.getApplication().registerActivityLifecycleCallbacks(mActivityCallbacks);
}
// 不存在，则创建，并存入 mNotCommittedActivityHolders 中
holder = createHolderFragment(fm);
mNotCommittedActivityHolders.put(activity, holder);
return holder;
}
private static HolderFragment createHolderFragment(FragmentManager fragmentManager) {
HolderFragment holder = new HolderFragment();
// 添加 HOLDER_TAG， 便于寻找
fragmentManager.beginTransaction().add(holder, HOLDER_TAG).commitAllowingStateLoss();
return holder;
}
private static HolderFragment findHolderFragment(FragmentManager manager) {
//...
// 通过 HOLDER_TAG 来寻找
Fragment fragmentByTag = manager.findFragmentByTag(HOLDER_TAG);
if (fragmentByTag != null && !(fragmentByTag instanceof HolderFragment)) {
throw new IllegalStateException("Unexpected "
+ "fragment instance was returned by HOLDER_TAG");
}
return (HolderFragment) fragmentByTag;
}这就是之前版本的做法，不过其实也可以通过 lifecycle 去做。有了 lifecycle 之后，这种做法就显得有些浪费了。但不管如何，这种对 Fragment 的应用也是值得称赞的。
查看原文： Android 架构之美 - ViewModel
