Jetpack 组件 LiveData + viewModel 使用分析

Jetpack 组件 LiveData + viewModel 使用分析

1、LiveData 简介

LiveData 是一个可观察对象的持有者，与常规的可观察对象不同，liveData 是生命周期感知的，这意味着它尊重其他应该用程序组件（如 activity，fragment ，service）这种意识确保LiveData只更新处于活动生命周期状态的应用程序组件观察者

LiveData 认为一个观察者的生命周期处于启动或恢复状态，那么这个观察者（由观察类表示）就处于活动状态

LiveData 只向活动的观察者通知更新。注册来监听liveData对象的非活动观察者不会收到关于更改的通知

您可以注册一个与实现LifeCycleOwner 接口的对象配对的观察者。当相应的生命周期对象的状态更改为销毁时，这种关系允许删除观察者。这对于活动和片段特别有用，因为他们可以安全地观察LiveData对象，而不用担心内存泄漏——当activity 和fragment 的生命周期被破坏时，他们会立即取消订阅

2、使用LiveData 的优点

1、确保UI 和 数据状态匹配

LiveData 遵循观察者模式。当生命周期状态发生改变时，LiveData 通知观察者对象。您可以合并代码来更新这些观察者对象中的UI，你的观察者可以在每次应用数据改变时更新UI，而不是每次应用数据改变时都更新UI

2、没有内存泄漏

观察者绑定到生命周期对象，并在其关联的生命周期被销毁后进行清理

3、没有因为停止活动而导致的崩溃

如果观察者的生命周期是不活动的，例如在后台栈中的活动，那么它不会接收任何liveData事件

4、不需要手动的生命周期处理

UI 组件只观察相关数据，不停止或继续观察。LiveData 会自动管理所有这些，因为 他在观察的同时会知道相关的生命周期状态变化

5、总是最新的数据

如果一个生命周期变为不活动的，它将在再次激活时接收最新的数据。例如，位于后台的活动在返回到前台后立即接收最新的数据。

6、适当的配置更改

如果某个活动或片段由于配置更改(如设备旋转)而重新创建，它将立即接收最新的可用数据。

7、共享资源

你可以使用单例模式来扩展LiveData对象来包装系统服务，这样它们就可以在你的应用程序中被共享。LiveData对象连接到系统服务一次，然后任何需要该资源的观察者都可以观看LiveData对象。有关更多信息，请参见Extend LiveData。

3、使用LiveData 对象

按照以下步骤处理LiveData对象:

1、创建一个LiveData实例来保存特定类型的数据。这通常在ViewModel类中完成。

2、创建一个定义onChanged()方法的观察者对象，该方法控制LiveData对象持有的数据更改时发生的情况。您通常在UI控制器中创建一个观察者对象，例如一个activity或fragment。

3、使用observe()方法将观察者对象附加到LiveData对象。方法获取一个LifecycleOwner对象。这订阅了LiveData对象的观察者对象，以便在发生更改时通知它。通常将观察者对象附加到UI控制器中，如 Activity或Fragment。

注意：您可以使用observeForever(observer)方法注册一个没有关联LifecycleOwner对象的观察者。在这种情况下，观察者被认为总是处于活动状态，因此总是被通知修改。您可以删除这些调用removeObserver(观察者)方法的观察者。

当您更新LiveData对象中存储的值时，只要附加的LifecycleOwner处于活动状态，它就会触发所有注册的观察者。

LiveData允许UI控制器观察者订阅更新。当LiveData对象持有的数据发生更改时，UI将自动更新。

1、创建LiveData 对象

LiveData是一个可以与任何数据(包括实现集合的对象，如List)一起使用的包装器。LiveData对象通常存储在ViewModel对象中，并通过getter方法进行访问，如下面的示例所示:

public class NameViewModel extends ViewModel{
    //create a LiveData with a Stringprivate MutableLiveData<String> currentName;public MutableLiveData<String> getCurrentName(){
    if(currentName == null){
    currentName = new MutableLiveData<String>();}return currentName;}
}

最初，并不设置LiveData对象中的数据。

注意:确保在ViewModel对象中存储更新UI的LiveData对象，而不是activity或fragment，原因如下:

以避免膨胀的活动和碎片。现在这些UI控制器负责显示数据而不是保存数据状态。

将LiveData实例与特定的活动或片段实例解耦，并允许LiveData对象在配置更改后仍然存在。

您可以在ViewModel指南中了解更多关于ViewModel类的好处和用法。

2、观察LiveData 数据

在大多数情况下，应用程序组件的onCreate()方法是开始观察LiveData对象的合适位置，原因如下:

以确保系统不会从活动或fragment的onResume()方法发出冗余调用。

以确保活动或片段具有数据，可以在活动开始时立即显示这些数据。只要应用程序组件处于启动状态，它就会从它所观察的LiveData对象接收最新的值。只有在设置了要观察的LiveData对象时才会发生这种情况。

通常，LiveData只在数据发生更改时才提交更新，并且只向活动的观察者提交更新。这种行为的一个例外是，当观察者从非活动状态更改为活动状态时，他们也会收到更新。而且，如果观察者第二次从非活动状态变为活动状态，那么它只会在上一次活动之后值发生变化时才会收到更新。

下面的示例代码演示了如何开始观察LiveData对象:

public class NameActivity extends AppCompatActivity{
    private NameViewModel model;@Overrideprotected void onCreate(Bundle savedInstanceState){
    super.onCreate(saveInstanceState);//Get the ViewModelmodel = ViewModelProviders.of(this).get(NameViewModel.class);final Observer<String> nameObserver = new Observer<String>{
    @Overridepublic void onChanged(@NUllable final String newName){
    nameTextView.setText(newName);}}model.getCurrentName().observe(this,nameObserver);}
}

使用作为参数传递的nameObserver调用了observe()之后，立即调用onChanged()，提供存储在mCurrentName中的最新值。如果LiveData对象没有在mCurrentName中设置值，则不会调用onChanged()。

3、更新LiveData对象

LiveData没有公开可用的方法来更新存储的数据。MutableLiveData类公开setValue(T)和postValue(T)方法，如果需要编辑存储在LiveData对象中的值，则必须使用这些方法。通常在ViewModel中使用MutableLiveData，然后ViewModel只向观察者公开不可变的LiveData对象。

建立观察者关系之后，可以更新LiveData对象的值，如下面的示例所示，当用户点击按钮时，将触发所有观察者:

button.setOnClickListener(new OnClickListener(){
    @Overridepublic void onClick(View v){
    String anotherName = "John Doe";model.getCurrentName.setValue(anotherName);}
})

在示例中调用setValue(T)会导致观察者使用值John Doe调用它们的onChanged()方法。该示例显示一个按钮按下，但是可以调用setValue()或postValue()来更新mName，原因有很多，包括响应网络请求或完成数据库加载;在所有情况下，对setValue()或postValue()的调用都会触发观察者并更新UI。

注意:您必须调用setValue(T)方法来从主线程更新LiveData对象。如果代码在工作线程中执行，您可以使用postValue(T)方法来更新LiveData对象。

4、LiveData 和 Room 一起使用

Room 持久性库支持返回LiveData对象的可见查询。可观察查询是作为数据库访问对象(DAO)的一部分编写的。

当数据库更新时，Room生成更新LiveData对象所需的所有代码。生成的代码在需要时在后台线程上异步运行查询。此模式对于保持UI中显示的数据与数据库中存储的数据同步非常有用。您可以在Room persistent library指南中阅读关于Room和DAOs的更多信息。

与LiveData一起使用协同程序

LiveData包括对Kotlin协同程序的支持。有关更多信息，请参见使用带有Android体系结构组件的Kotlin协程。## 扩展LiveData

如果观察者的生命周期处于启动或恢复状态，LiveData认为观察者处于活动状态，下面的示例代码演示了如何扩展LiveData类:

public class StockLiveData extends LiveData<BigDecimal> {
      private StockManager stockManager;   private SimplePriceListener listener = new SimplePriceListener() {
       @Overridepublic void onPriceChanged(BigDecimal price) {
    setValue(price);} };   public StockLiveData(String symbol) {
    stockManager = new StockManager(symbol);}    @Override    protected void onActive() {
      stockManager.requestPriceUpdates(listener);}   @Overrideprotected void onInactive() {
     stockManager.removeUpdates(listener);}
}

当LiveData对象有一个活动的观察者时，将调用onActive()方法。这意味着您需要开始观察来自此方法的股票价格更新。

当LiveData对象没有任何活动的观察者时，将调用onInactive()方法。因为没有观察者在听，所以没有理由保持与StockManager服务的连接。

setValue(T)方法更新LiveData实例的值，并将更改通知任何活动的观察者。

你可以使用StockLiveData类如下:

public class MyFragment extends Fragment {
      @Override public void onActivityCreated(Bundle savedInstanceState) {
       super.onActivityCreated(savedInstanceState);    LiveData<BigDecimal> myPriceListener = ...;   myPriceListener.observe(this, price -> {
           // Update the UI. });}
}

方法observe()将fragment(它是LifecycleOwner的一个实例)作为第一个参数传递。这样做表示这个观察者被绑定到与所有者相关联的生命周期对象，意思是:

如果生命周期对象没有处于活动状态，那么即使值发生变化也不会调用观察者。

在生命周期对象被销毁后，观察者被自动删除。

LiveData对象是生命周期感知的，这意味着您可以在多个活动、片段和服务之间共享它们。为了保持示例的简单性，可以将LiveData类实现为单例，如下所示:

public class StockLiveData extends LiveData<BigDecimal> {
     private static StockLiveData sInstance; private StockManager stockManager; private SimplePriceListener listener = new SimplePriceListener() {
     @Override  public void onPriceChanged(BigDecimal price) {
        setValue(price);   }   };  @MainThread   public static StockLiveData get(String symbol) {
       if (sInstance == null) {
         sInstance = new StockLiveData(symbol);}        return sInstance; }  private StockLiveData(String symbol) {
     stockManager = new StockManager(symbol);} @Overrideprotected void onActive() {
        stockManager.requestPriceUpdates(listener);  }  @Override  protected void onInactive() {
         stockManager.removeUpdates(listener);   }
}

你可以在fragment 使用它:

public class MyFragment extends Fragment {
     @Override public void onActivityCreated(Bundle savedInstanceState) {
       StockLiveData.get(symbol).observe(this, price -> {
     // Update the UI. }); }
}

多个Fragment和actvity 可以观察MyPriceListener实例。LiveData仅在其中一个或多个服务可见且处于活动状态时才连接到系统服务。

5、变换LiveData

您可能希望在将LiveData对象发送给观察者之前对其存储的值进行更改，或者您可能需要根据另一个LiveData实例的值返回另一个LiveData实例。生命周期包提供转换类，该类包含支持这些场景的辅助方法。

[Transformations.map()](https://developer.android.google.cn/reference/androidx/lifecycle/Transformations.html#map(android.arch.lifecycle.LiveData, android.arch.core.util.Function))

将函数应用于存储在LiveData对象中的值，并将结果向下传播

LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
        user.name + " " + user.lastName});

[Transformations.switchMap()](https://developer.android.google.cn/reference/androidx/lifecycle/Transformations.html#switchMap(android.arch.lifecycle.LiveData, android.arch.core.util.Function>))

与map()类似，将函数应用于LiveData对象中存储的值，并将结果解包并分发到下游。传递给switchMap()的函数必须返回LiveData对象，如下例所示:

private LiveData<User> getUser(String id) {
    ...;
}LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );

您可以使用转换方法来在观察者的生命周期中传递信息。除非观察者正在查看返回的LiveData对象，否则不会计算转换。因为转换是延迟计算的，所以与生命周期相关的行为是隐式传递的，不需要额外的显式调用或依赖关系。

如果您认为在ViewModel对象中需要一个生命周期对象，那么转换可能是更好的解决方案。例如，假设您有一个UI组件，它接受一个地址并返回该地址的邮政编码。你可以为这个组件实现朴素的ViewModel，如下面的示例代码所示:

class MyViewModel extends ViewModel{
    private final PostalCodeRepository repository;public MyViewModel(PostalCodeRepository respository){
    this.repository = respository;}private ListData<String> getPostalCode(String address){
    //don't do thisreturn repository.getPostCode(address);}}

然后，UI组件需要从先前的LiveData对象注销，并在每次调用getPostalCode()时注册到新实例。此外，如果重新创建了UI组件，它将触发对储存库. getpostcode()方法的另一个调用，而不是使用前一个调用的结果。

相反，您可以将邮政编码查找实现为地址输入的转换，如下面的示例所示:

class MyViewModel extends ViewModel{
    private final PostalCodeRepository repository;private final MutableLiveData<String> addressInput = new MutableLiveData();public final LiveData<String> postalCode = Transformations.switchMap(addressInput,(address) -> {
    return repository.getPostCode(address);})public MyViewModel(PostalCodeRepository repository){
    this.repository = repository;}private void setInput(String address){
    addressInput.setValue(address);}}

在本例中，postalCode字段被定义为addressInput的转换。只要您的应用程序有一个与postalCode字段关联的活动观察者，每当addressInput发生更改时，就会重新计算和检索字段的值。

这种机制允许应用程序的低层创建按需延迟计算的LiveData对象。ViewModel对象可以很容易地获得对LiveData对象的引用，然后在其上定义转换规则。

4、创建新的转换

在你的应用程序中有许多不同的转换可能是有用的，但它们不是默认提供的。要实现自己的转换，可以使用MediatorLiveData类，它侦听其他LiveData对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData对象。要了解关于此模式的更多信息，请参阅转换类的参考文档。

5、合并多个LiveData 源

MediatorLiveData是LiveData的一个子类，它允许您合并多个LiveData源。当任何原始LiveData源对象发生更改时，就会触发MediatorLiveData对象的观察者。

例如，如果您的UI中有一个可以从本地数据库或网络更新的LiveData对象，那么您可以将以下源添加到MediatorLiveData对象:

与数据库中存储的数据相关联的LiveData对象。

与从网络访问的数据相关联的LiveData对象。

您的活动只需要观察MediatorLiveData对象就可以接收来自两个源的更新。有关详细示例，请参见App架构指南的附录:暴露网络状态部分。

6、LiveData 源码分析

6.1、jar 包结构

androidx.lifecycle:lifecycle-livedata-core:

• LiveData
• MutableLiveData
• Observer

androidx.lifecycle:lifecycle-livedata:

• ComputableLiveData
• MediatorLiveData
• Transformations

6.1.1、具体类分析

LiveData：

LiveData是一个数据持有者类，可以在给定的生命周期内被观察到 包含了两种 注册方法 observe 方法以及 observeForever 方法

observe ：

在生命周期内 进行监听 如果生命周期 为 STARTED 时一直进行监听，该监听在生命周期结束时自动取消监听，不需要remove 监听

    @MainThreadpublic void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    assertMainThread("observe");if (owner.getLifecycle().getCurrentState() == DESTROYED) {
    //如果 lifeRecycle destory 直接返回不做任何处理return;}//绑定了 LifeRecycle 组件LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);// 用 SafeIterableMap 来维护 observer 用来进行状态分发ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);if (existing != null && !existing.isAttachedTo(owner)) {
    throw new IllegalArgumentException("Cannot add the same observer"+ " with different lifecycles");}if (existing != null) {
    return;}owner.getLifecycle().addObserver(wrapper);}

LifecycleBoundObserver 实际上是一个 LifecycleObserver ：

 class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
    @NonNullfinal LifecycleOwner mOwner;LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
    super(observer);mOwner = owner;}@Overrideboolean shouldBeActive() {
    //生命为STARTED 时 监听liveData 对象的数据变化return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);}@Overridepublic void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
    //当生命周期为 DESTROYED 自动取消监听if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
    removeObserver(mObserver);return;}activeStateChanged(shouldBeActive());}@Overrideboolean isAttachedTo(LifecycleOwner owner) {
    return mOwner == owner;}@Overridevoid detachObserver() {
    mOwner.getLifecycle().removeObserver(this);}}

observeForever ：在生命周期内 一直进行监听，该监听在生命周期结束时需要手动 removeObserver

    @MainThreadpublic void observeForever(@NonNull Observer<? super T> observer) {assertMainThread("observeForever");//和 observe  不同在于 此处的观察者 为 AlwaysActiveObserverAlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {throw new IllegalArgumentException("Cannot add the same observer"+ " with different lifecycles");}if (existing != null) {return;}wrapper.activeStateChanged(true);}

AlwaysActiveObserver：

    private class AlwaysActiveObserver extends ObserverWrapper {
    AlwaysActiveObserver(Observer<? super T> observer) {
    super(observer);}@Overrideboolean shouldBeActive() {
    return true; //一直返回的是true}}

当注册监听之后通过 setValue 进行触发（observe）：

    @MainThreadprotected void setValue(T value) {
    assertMainThread("setValue");mVersion++;mData = value;//分发状态变化dispatchingValue(null);}

@SuppressWarnings("WeakerAccess") /* synthetic access */void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
    mDispatchInvalidated = true;return;}mDispatchingValue = true;do {
    mDispatchInvalidated = false;if (initiator != null) {
    considerNotify(initiator);initiator = null;} else {
    for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
    //通知considerNotify(iterator.next().getValue());if (mDispatchInvalidated) {
    break;}}}} while (mDispatchInvalidated);mDispatchingValue = false;}

    private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
    return;}//对应 LifecycleBoundObserver.shouldBeActive() 方法 if (!observer.shouldBeActive()) {
    observer.activeStateChanged(false);return;}// mVersion 在 setValue 方法中进行了 ++ （mVersion++;）if (observer.mLastVersion >= mVersion) {
      return;}observer.mLastVersion = mVersion;//触发onChage 方法observer.mObserver.onChanged((T) mData);}

通过observeForever注册 Observer 方法内部和 observe 类似 observeForever 没有添加到LifeRecycle 中，故生命周期状态需要手动去 处理

MutableLiveData：

ComputableLiveData：

MediatorLiveData:

Transformations:

这几个类的解析以及综合流程我们下一章节 进行分析

7、LiveData 与 ViewModel 结合使用

7.1、 ViewModel 简介

ViewModel类被设计成以生命周期的方式存储和管理ui相关的数据。ViewModel类允许数据在配置更改(如屏幕旋转)后仍然存在。Android框架管理UI控制器的生命周期，比如acitivity和fragment。框架可能决定销毁或重新创建一个UI控制器，以响应某些用户操作或设备事件，这些操作或事件完全超出了您的控制。

如果系统破坏或重新创建一个UI控制器，那么您存储在其中的任何与UI相关的临时数据都将丢失。例如，您的应用程序可能在其某个活动中包含一个用户列表。当为配置更改重新创建活动时，新活动必须重新获取用户列表。对于简单数据,activity可以使用仅有()方法并恢复其包的数据在onCreate(),但这种方法只适用于少量的数据可以序列化反序列化,而不是潜在的大量数据的用户列表或位图。

另一个问题是UI控制器经常需要进行异步调用，这可能需要一些时间才能返回。UI控制器需要管理这些调用，并确保系统在销毁后对其进行清理，以避免潜在的内存泄漏。这种管理需要大量的维护，并且在为了配置更改而重新创建对象的情况下，这是对资源的浪费，因为对象可能不得不重新发出它已经发出的调用。

activikty和fragment等UI控制器主要用于显示UI数据、响应用户操作或处理操作系统通信(如权限请求)。要求UI控制器也负责从数据库或网络加载数据会使类膨胀。将过多的责任分配给UI控制器可能会导致单个类试图自己处理应用程序的所有工作，而不是将工作委托给其他类。以这种方式将过多的责任分配给UI控制器也会使测试变得更加困难。

将视图数据所有权从UI控制器逻辑中分离出来更简单、更有效。

7.2、ViewModel的生命周期

7.3、ViewModel 的用途

• 在fragment 间共享数据

• 用ViewModel 替换加载器

  • 在使用加载器的一种常见方法中，应用程序可能使用一个指针加载器来观察数据库的内容。当数据库中的一个值发生变化时，加载器会自动触发数据的重新加载，并更新用户界面:

• 使用liveData

  ViewModel与Room和LiveData一起工作，以取代加载器。ViewModel确保数据在设备配置更改后仍然存在。当数据库发生更改时，Room会通知LiveData，而LiveData又会用修改后的数据更新您的UI。

• 在ViewModel中使用协同程序

7.3、ViewModel 源码分析

7.3.1、ViewModelProviders：

ViewModelProviders ：一个工具类，封装了 ViewModelStore 的一些方法 ，该类提供的方法创建了一个 ViewModelProvider 对象

   @NonNull@MainThreadpublic static ViewModelProvider of(@NonNull FragmentActivity activity) {
    return of(activity, null);}@NonNull@MainThreadpublic static ViewModelProvider of(@NonNull Fragment fragment) {
    return of(fragment, null);}

创建一个ViewModelProvider 对象

7.3.2、ViewModelProvider：

interface Factory:

• create(@NonNull Class modelClass)

  用来创建一个ViewModel 对象

KeyedFactory implements Factory

• Factory 的实现类 为生成的每一个 modelView 指定了一个key 值，生成的对象必须是 modelView 的子类

get(@NonNull Class modelClass) ：

• 获取viewModle 的核心方法，在activity 或者 fragemnt 中创建一个viewModel 或者返回一个存在的viewModel,该viewModel 作用于整个生命周期，所有viewModel 是通过一个 hashMap 进行维护

   @NonNull@MainThreadpublic <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        ViewModel viewModel = mViewModelStore.get(key);// 一个对象是本身类的一个对象if (modelClass.isInstance(viewModel)) {
        //如果该viewModel存在 返回 return (T) viewModel;  } else {
        if (viewModel != null) {
        // TODO: log a warning.}}//如果没有指定Factory 使用默认的 AndroidViewModelFactory 来创建ViewModelif (mFactory instanceof KeyedFactory) {
        viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);} else {
        viewModel = (mFactory).create(modelClass);}mViewModelStore.put(key, viewModel);//noinspection uncheckedreturn (T) viewModel;}
  

  vviewModelProvider 和 viewModelProviders 这两个类代码很简单功能也很简单 仅仅是创建了一个 通过了Factory 创建了viewModel 放到一个Map 中进行维护，有没有注意到 维护 viewModel 中的map 没有被创建，那么它是在哪被创建的呢？ 在 lifecycle-viewmodel 包中还有一个接口呢 ViewModelStoreOwner

7.3.4、ViewModelStoreOwner ：

该接口只有一个 getViewModelStore 方法，该接口在 ComponentActivity 中实现了，创建了一个viewModel 对象，该对象在该类的 构造方法中使用到了

ComponentActivity:

    @NonNull@Overridepublic 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 NonConfigurationInstancesmViewModelStore = nc.viewModelStore;}if (mViewModelStore == null) {
    //创建了一个ViewModelStoremViewModelStore = new ViewModelStore();}}return mViewModelStore;}

  getLifecycle().addObserver(new LifecycleEventObserver() {
    @Overridepublic void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event) {
    if (event == Lifecycle.Event.ON_DESTROY) {
    if (!isChangingConfigurations()) {
    //清楚viewModelStoregetViewModelStore().clear();}}}});

当 生命周期结束是 viewModelStore 中的 viewModel 被清空，这里有一个问题，viewModel对象放进 viewModelStore 中如何被监听数据的变化呢 ？ 这里就需要jetPack 另外一个组件了 LiveData 也可以自定义实现 、结合RxJava 进行处理