（原创）Jetpack系列（二）：ViewModel+LiveData

前言

Jetpack上一篇讲完了lifecycle
（原创）Jetpack系列：lifecycle
现在我们来讲ViewModel和LiveData
他们一般是配合来使用的
ViewModel用来存储数据
LiveData来监听数据的变化
这样做的好处是把数据的操作放在ViewModel里
Activity页面只负责业务逻辑即可

ViewModel还可以防止瞬态数据丢失
例如横竖屏的时候数据不会丢失

ViewModel的创建方法

关于ViewModel的创建，有以下几种方式：
1：最原始的办法：
先创建ViewModelProvider

var viewModelProvider =
            ViewModelProvider(this, ViewModelProvider.AndroidViewModelFactory(application))

然后创建ViewModel

var myViewModel = viewModelProvider.get(MyViewModel::class.java)

2：在fragment中有以下两种方式，创建属于当前fragment的ViewModel：

@MainThread
public inline fun <reified VM : ViewModel> Fragment.viewModels(
    noinline ownerProducer: () -> ViewModelStoreOwner = { this },
    noinline factoryProducer: (() -> Factory)? = null
): Lazy<VM> = createViewModelLazy(VM::class, { ownerProducer().viewModelStore }, factoryProducer)

@MainThread
public inline fun <reified VM : ViewModel> Fragment.activityViewModels(
    noinline factoryProducer: (() -> Factory)? = null
): Lazy<VM> = createViewModelLazy(
    VM::class, { requireActivity().viewModelStore },
    factoryProducer ?: { requireActivity().defaultViewModelProviderFactory }
)

使用示例：

val viewModel: HomeFragViewModel by viewModels()
val activityViewModel: HomeFragViewModel by activityViewModels()

HomeFragViewModel是你自己ViewModel的类的名字
可以看到这两个方法，一个是和fragment绑定
一个是和fragment所在的Activity绑定
所以一个Activity下的多个fragment就可以通过第二种方式实现数据通信了
内部实现其实是基于这个方法：

@MainThread
public fun <VM : ViewModel> Fragment.createViewModelLazy(
    viewModelClass: KClass<VM>,
    storeProducer: () -> ViewModelStore,
    factoryProducer: (() -> Factory)? = null
)

点进去看，归根结底也是用ViewModelProvider(store, factory).get(viewModelClass.java)的方式去做的

3：Activity里面创建Viewmodel可以这样：

@MainThread
public inline fun <reified VM : ViewModel> ComponentActivity.viewModels(
    noinline factoryProducer: (() -> Factory)? = null
)

点进去看，走的也是ViewModelLazy类里面的ViewModelProvider(store, factory).get(viewModelClass.java)
综上，这两张方式其实只是提供的一个快捷创建方式，
帮我们快速创建和绑定Activity/fragment而已
然后我们再来看下最基础的创建方式：

ViewModelProvider(<你的Activity 或 Fragment 实例>,<创建的factory>).get(<你的ViewModel>::class.java)

ViewModelProvider说明：
ViewModelProvider其实提供了三个构造方法给我们去创建ViewModelProvider市里
然后调用他的get方法通过反射去创建我们的Viewmodel

    public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
        this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
                ? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
                : NewInstanceFactory.getInstance());
    }
    public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
        this(owner.getViewModelStore(), factory);
    }
    public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
        mFactory = factory;
        mViewModelStore = store;
    }

可以看到，owner传入后，其实就是调用它的getViewModelStore方法
第一个和第二个构造方法，最终走的都是第三个构造方法
ViewModelStore就是用来缓存我们的Viewmodel的对象的，在界面销毁时做一个缓存
下次再从缓存里面读。
owner的生命周期结束后，缓存也会消失
而Factory其实是一个接口，我们可以传入不同的实现：

    public interface Factory {
        @NonNull
        <T extends ViewModel> T create(@NonNull Class<T> modelClass);
    }

ViewModelProvider的get()方法，内部其实就是调用我们传入的Factory的create
去反射创建我们的ViewModel示例。
最后做个总结：
1：ViewModelProvider用来创建ViewModel
2：Viewmodel是和owner的生命周期绑定的
3：真正创建ViewModel的是实现了Factory接口的类的create方法
4：Activity/Fragment都封装了一些自己的快捷创建Viewmodel的方法
如viewModels和activityViewModels方法
注意：第二种和第三种方法，其实是对原始方法的封装
使用这两种方法，需要导入：

implementation "androidx.activity:activity-ktx:1.4.0"

自定义ViewModelProvider.Factory

当我们要根据自己的实际需要来创建自己的ViewModel时
比如要求Viewmodel是单例，或者是全局，或者构造方法有参数
就可以自定义Factory，实现create方法即可
如下，我们自定义了一个可以构造方法可以传入参数的ViewNodel：

class UserViewModelFactory(
    private val type: String
) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return modelClass.getConstructor(String::class.java).newInstance(type)
    }
}

系统也提供了很多的Factory实现，大家可以去自行了解

实战小例子

下面我们通过一个小例子来掌握这两个东西。
首先我们创建一个自己的ViewModel类
去继承AndroidViewModel
里面有一个变量num
代码如下

/**
 * viewModel类
 *
 */
class MyViewModel(application: Application) : AndroidViewModel(application) {
    var num:Int=0
}

然后在Activity里写一个btn按钮和一个textview
textview的文字内容使用的就是自定义Viewmodel里的num值
btn按钮点击一下，textview的num属性值就一
代码如下：

class MainActivity : AppCompatActivity() {


    lateinit var viewModelProvider: ViewModelProvider
    lateinit var myViewModel: MyViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        viewModelProvider =
            ViewModelProvider(this, ViewModelProvider.AndroidViewModelFactory(application))
        myViewModel = viewModelProvider.get(myViewModel::class.java)

        mybtn.setOnClickListener {
            mytv1.text = "${++myViewModel.num}"
        }

        mytv1.text = "${myViewModel.num}"

    }
}

上面的ViewModel看起来很简单，无非是数据放在了MyViewModel里
但这不是关键，关键是引入liveData后

现在把代码修改如下：
1、新建一个MyLiveDataViewModel

class MyLiveDataViewModel : ViewModel() {
    private var currentSecond: MutableLiveData<Int>? = null
    fun getCurrSecond(): MutableLiveData<Int> {
        if (currentSecond == null) {
            currentSecond = MutableLiveData()
            currentSecond!!.value = 0
        }
        return currentSecond!!
    }
}

可以看到这里currentSecond返回的是一个MutableLiveData的整型数值
然后在我们的Activity里这样修改

class MainActivity : AppCompatActivity() {


    lateinit var viewModelProvider: ViewModelProvider
    lateinit var myViewModel: MyViewModel
    lateinit var myLiveDataViewModel: MyLiveDataViewModel


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        viewModelProvider =
            ViewModelProvider(this, ViewModelProvider.AndroidViewModelFactory(application))
        myViewModel = viewModelProvider.get(MyViewModel::class.java)

        mybtn.setOnClickListener {
            mytv1.text = "${++myViewModel.num}"
        }

        mytv1.text = "${myViewModel.num}"

        myLiveDataViewModel = viewModelProvider.get(MyLiveDataViewModel::class.java)

        myLiveDataViewModel.getCurrSecond().observe(this, Observer {
            mytv2.text = "${it}"
        })
        startTimer()


    }

    private fun startTimer() {
        Timer().schedule(timerTask {
            //非ui线程，用postValue
            myLiveDataViewModel.getCurrSecond().postValue(myLiveDataViewModel.getCurrSecond().value?.plus(1))
        },1000,1000)
    }
}

这里开起了一个子线程，每一秒钟让MyLiveDataViewModel里的数值加1
利用MutableLiveData的observe方法对数值的变化进行监听
发现数据有改变就去刷新UI
其实就是模拟请求网络数据的过程

这样一来我们就发现了
ViewModel+LiveData
可以实现数据也业务的解耦
把数据的变化放在ViewModel里面
用LiveData对这个变化进行监听
然后进行UI刷新即可
当然
不同的Activity或者Fragment
可以共用一个viewmodel的值
数据有变化，两个Activity或者Fragment界面的值也会一起变化的
LiveData里面其实也做了lifecycle的监听
在页面不显示的时候，是不会去执行UI刷新的
最后，xml代码也放上来吧

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout 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"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">


    <TextView
        android:id="@+id/mytv1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="100dp"
        android:text="Hello World!"
        android:visibility="visible"
        tools:visibility="visible" />

    <Button
        android:id="@+id/mybtn"
        android:layout_width="124dp"
        android:layout_height="91dp"
        android:layout_below="@+id/mytv1"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="100dp"
        android:text="加1" />


    <TextView
        android:id="@+id/mytv2"
        android:layout_width="124dp"
        android:layout_height="91dp"
        android:gravity="center"
        android:layout_below="@+id/mybtn"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="100dp"
        android:text="0" />
</RelativeLayout>

补充：AndroidViewModel和AndroidViewModelFactory

上面例子用的ViewModel继承的是AndroidViewModel
用的是AndroidViewModelFactory来创建AndroidViewModel
注意，AndroidViewModelFactory传入的Context一定要是application里的Context
否则会导致内存泄漏。
因为使用ViewModel的时候，ViewModel不能够持有View、Lifecycle、Acitivity引用，
而且不能够包含任何包含前面内容的类。因为这样很有可能会造成内存泄漏。
那如果需要使用Context对象改怎么办。
这时候我们可以给ViewModel一个Application。Application是一个Context，而且一个应用也只会有Application。
那ViewModel怎么添加Application呢？其实Google还有一个AndroidViewModel。
这是一个包含Application的ViewModel。
下面是一个AndroidViewModel的源码：

public class AndroidViewModel extends ViewModel {
    @SuppressLint("StaticFieldLeak")
    private Application mApplication;
 
    public AndroidViewModel(@NonNull Application application) {
        mApplication = application;
    }
 
    /**
     * Return the application.
     */
    @SuppressWarnings("TypeParameterUnusedInFormals")
    @NonNull
    public <T extends Application> T getApplication() {
        //noinspection unchecked
        return (T) mApplication;
    }
}

可以看到只是在ViewModel的基础上添加了Application。
其实看AndroidViewModelFactory源码就得知
AndroidViewModelFactory传入的Application，最终使用反射，调用了AndroidViewModel的构造方法
把Application传给了AndroidViewModel。如下：

 		@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);
        }

所以我们可以总结：
1：如果我们的ViewModel需要context，可以继承AndroidViewModel，否则继承普通的ViewModel就好
2：继承了AndroidViewModel，就要用AndroidViewModelFactory，
并且传入application里的Context来创建我们自己的的AndroidViewModel。

至此，ViewModel+LiveData就讲到这里了