Android之MVVM架构之ViewModel + LiveData + DataBinding
前言
很早前写过一篇MVVM架构的文章，当时写的很粗糙，一直想抽空补全一下，自己对MVVM的理解，写一篇让新手都能够容易掌握的文章。
众所周知，Google已经开始倾向MVI架构，但是作为一个开发者，在开发中，只有存在合适的架构，所以关于MVI架构，希望以后有真正的了解再来写一写自己的见解。
基本使用
刚学习MVVM，这张架构图是非常重要的
-
简单的说一下
ViewModel：关联层，将Model和View进行绑定，只做和业务逻辑相关的工作，不涉及任何和UI相关的操作，不持有控件的引用，不更新UI。
View：视图层，只做和UI相关的工作，不涉及任何业务逻辑，不涉及操作数据，不处理数据。UI和数据严格的分开。
Model：模型层，保存数据的状态，比如数据存储、网络请求。同时还与View存在一定的耦合，可以通过观察 -
启用方式
//添加ViewModel的引用
implementation 'androidx.appcompat:appcompat:1.0.2'
implementation 'androidx.lifecycle:lifecycle-viewmodel:2.2.0'
//启用DataBinding
buildFeatures {
dataBinding true
}
- 自定义的VM类只要继承引用的第三方库中的ViewModel抽象类即可
class MyViewModel: VideModel{
}
- 然后我们就可以在activity/fragment中实例化它
viewModel = ViewModelProviders.of(this).get(MyViewModel::class.java)
// 这里需要提到一下在旧版本的APIVIewModelProviders已经被添加了Deprecated标签，也就是已经不推荐使用了
viewModel = ViewModelProvider(this).get(MyViewModel::class.java)
ViewModel的优势在于生命周期和数据的持久化，这就是为什么我们需要在activity/fragment去使用它。其次就是异步回调，不会造成内存泄漏问题，对View层和Model层的完全解耦，这就是ViewModel在整个MVVM架构中的重要性了。
ViewModel生命周期
Google官方给的生命周期图
- 生命周期长于Activity。不难发现，ViewModel的生命周期，贯穿整个被绑定的Activity的生命周期，也就是说，既然Activity因为系统配置变更销毁重建，比如旋转屏幕等，ViewModel对象依旧会被保留，并关联到新的Activity。只有当Activity正常销毁时，ViewModel对象才会调用onCleared()进行清除。
- 开头说过，众多开发模式当中，他们的区别大同小异，都是为了实现解耦。而我们知道，在MVP的Presenter中，需要持有View的接口对象，来回调结果给界面。而ViewModel是不需要持有UI层的引用，由于ViewModel贯穿了Activity的整个完整的生命周期，甚至比Activity生命周期要长，这就导致，如果让ViewModel持有Activity的引用时，容易造成内存泄漏等问题。
Tip:当ViewModel一定需要context引用，有没有什么办法呢？ 其实是有的， ViewModel抽象类有一个实现类AndroidViewModel(Application)，它接收的对象是application。
这是一个登录界面使用ViewModel的例子
仔细看会发现，实战当中，其实就是在mainViewModel定义了两个属性，用来缓存account 和 pwd，但是这两个数据却能持久化在这里面。为什么呢？因为当你旋转屏幕的时候，你会发现输入框的值依旧存在。我们知道在做横竖屏切换的时候，activity会被重新创建，此时如果我们数据是放在activity当中，数据就已经被销毁了。
LiveData
LiveData数据变化感知，也就是说当我们对一个对象多次赋值的时候，可以通过LiveData去操作，监听对象改变，然后处理相应的业务逻辑。
ViewModel.kt
public MutableLiveData<String> account = new MutableLiveData<>();
public MutableLiveData<String> pwd = new MutableLiveData<>();
account.setValue("admin")
pwd.setValue("123456")
这里使用的是MutableLiveData，表示值的内容可变动，而LiveData是不可变的。<>中的是泛型，你可以直接将一个对象放进去，当对象的内容有改动时，通知改变就可以了。
MainActivity.kt
viewModel.account.observe(this, {
tvAccount.text = it
})
viewModel.pwd.observe(this, {
tvPwd.text = it
})
我们可以看到，在viewModel中通过对MutableLiveData对象调用它的setValue，在Activity中，就可以通过MutableLiveData的observe监听到数据的变化，从而处理相应的逻辑。（例子代码中是通过TextView进行显示）
在上述例子中，可以看到我们使用的是setValue()的方式，还有一种方式是postValue()，需要注意一点，setValue()的方式只允许在主线程中使用，而postValue可以在任何线程中使用，并且如果在主线程执行发布之前，多次调用此方法，则只会分派最后一个值。
DataBinding
Android的DataBinding已经内置了，因此只需要在app模块的build.gradle中开启就可以使用了。
dataBinding {
enabled = true
}
Databinding顾名思义就是数据绑定，接下来会通过几个例子讲一下不同的绑定方式。
单向绑定
布局文件，当我们启动了DataBinding，在定义布局的根节点，通过AS的提示快捷按键，就可以显示添加data binding。
activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools">
<!--绑定数据-->
<data>
<variable
name="user"
type="com.example.User" />
</data>
<LinearLayout>
<TextView
android:id="@+id/tv_account"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.account}" />
<TextView
android:id="@+id/tv_pwd"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.pwd}" />
</LinearLayout>
</layout>
最好进入Activity，在onCreate方法中，添加绑定
override fun onCreate(Bundle saveInstanceState) {
val dataBinding = DataBindingUtil.setContentView(this, R.layou.activity_main)
user = User("admin", "123456")
dataBinding.setUser(user)
/**
我们可以通过手动赋值，比如外界输入等方式，给user赋值，在界面上就能及时显示修改的数据
user.setAccount("study")
user.setPwd("666")
**/
}
双向绑定
DataBinding的双向绑定其主要的差别就是在布局文件中使用中，用@={viewModel.user.account}将数据直接赋值给数据源
<!--绑定数据-->
<data>
<variable
name="viewModel"
type="com.example.viewmodels.MainViewModel" />
</data>
<TextView
android:id="@+id/tv_account"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{viewModel.user.account}" />
<TextView
android:id="@+id/tv_pwd"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{viewModel.user.pwd}"/>
<EditText
android:id="@+id/et_account"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="@color/white"
android:text="@={viewModel.user.account}"
android:hint="账号" />
<EditText
android:id="@+id/et_pwd"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="@color/white"
android:text="@={viewModel.user.pwd}"
android:hint="密码"
android:inputType="textPassword" />
这里需要注意几点：
第一是数据源，这里绑定的是viewModel，也就是MainViewModel中的数据都可以拿到。
第二就是响应的地方，通过这种方式去显示ViewModel中对象的变量数据在空间上，也就是两个TextView。
第三个地方，也就是双向绑定的意义，就是UI改变数据源。我们知道当输入框输入数据时，text属性值会改变为输入的数据，而@={viewModel.user.account}就是将输入的数据直接赋值给数据源。这样我们就不需要在Activity中再去处理EditText的内容了，减少了耦合。
而实际开发过程中，我们需要用到双向绑定的地方还是比较少的，相对于单项绑定。
如何在dialog或者自定义View中使用
我们知道ViewModel能在Activity和Fragment里使用，因此也能作为媒介使得Activity和Fragment进行交互。那么需要在View里使用呢？
假如我有一个自定义view或者dialog，它包含一堆数据和状态，能否使用ViewModel去管理数据呢？
先来看看ViewModel的源码，为什么说到ViewModel创建不建议通过new，而是ViewModelProvider的方式。
// ViewModelProvider.java
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
// 注释 6， 通过ViewModelStore 拥有者的 getDefaultViewModelProviderFactory方法获取工厂对象
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: ViewModelProvider.NewInstanceFactory.getInstance());
}
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull ViewModelProvider.Factory factory) {
//注释7， 保存工厂 Factory和 缓存对象，ViewModelStore
mFactory = factory;
mViewModelStore = store;
}
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) {
//注释 9， 从缓存 mViewModelStore中取 ViewModel的对象
// Key值是 “androidx.lifecycle.ViewModelProvider.DefaultKey” + 类名
ViewModel viewModel = mViewModelStore.get(key);
if (modelClass.isInstance(viewModel)) {
......
// 是响应类的对象则直接返回
return (T) viewModel;
}
......
......
//注释 10， 缓存中没有 ViewModel对象，用工厂创建，并存入缓存
viewModel = (mFactory).create(modelClass);
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
从源码可以看出，ViewModel对象是通过工厂模式进行创建的，并且保存了Factory和缓存对象，当我们通过ViewModelProvider(this).get()方法获取ViewModel对象时，会优先通过缓存获取。
在看看注释6处的getDefaultViewModelProviderFactory()方法
// ComponentActivity.java
public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
......
if (mDefaultFactory == null) {
mDefaultFactory = new SavedStateViewModelFactory(
//注释 11， 获取了 Application对象，创建SavedStateViewModelFactory对象
getApplication(),
this,
getIntent() != null ? getIntent().getExtras() : null);
}
return mDefaultFactory;
}
// SavedStateViewModelFactory.java
public SavedStateViewModelFactory(@NonNull Application application,
@NonNull SavedStateRegistryOwner owner,
@Nullable Bundle defaultArgs) {
mSavedStateRegistry = owner.getSavedStateRegistry();
mLifecycle = owner.getLifecycle();
mDefaultArgs = defaultArgs;
mApplication = application;
//注释 12， 创建 AndroidViewModelFactory工厂
mFactory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
public <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {
......
// 注释 13，通过 AndroidViewModelFactory创建 ViewModel对象
return mFactory.create(modelClass);
......
}
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
private static ViewModelProvider.AndroidViewModelFactory sInstance;
@NonNull
public static ViewModelProvider.AndroidViewModelFactory getInstance(@NonNull Application application) {
// 注释14， 单例模式创建工厂实例
if (sInstance == null) {
sInstance = new ViewModelProvider.AndroidViewModelFactory(application);
}
return sInstance;
}
private Application mApplication;
// 传入 Application对象
public AndroidViewModelFactory(@NonNull Application application) {
mApplication = application;
}
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
try {
//注释 15， 工厂方法设计模式创建 ViewModel对象，持有 Application的引用
return modelClass.getConstructor(Application.class).newInstance(mApplication);
}
......
}
return super.create(modelClass);
}
}
能看出AndroidViewModelFactory这个工厂，用单例模式创建了该工厂对象，然后使用工厂方法设计模式创建了ViewModel对象，ViewModel创建时传入的时Application参数，这里能够知道ViewModel对象最终持有的，并不是Activity的引用，而是Application的引用，也就是说，为什么ViewModel不容易造成内存泄漏的问题了。
到了这里，为什么不推荐使用new 去创建ViewModel也就迎刃而解了。
自定义view中，如果需要使用ViewModel，虽然官方不建议使用new ViewModel的方式，但是我们还是可以取巧，通过这种方式在view当中去使用它。- -！