欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Jetpack 组件 LiveData + viewModel 使用分析

程序员文章站 2022-06-07 15:14:11
...

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 String
    private 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;
    
    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(saveInstanceState);
        
        //Get the ViewModel
        model = ViewModelProviders.of(this).get(NameViewModel.class);
        
        final Observer<String> nameObserver = new Observer<String>{
            @Override
            public 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(){
	@Override
	public 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() {   
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        } 
    };   
    public StockLiveData(String symbol) {
        stockManager = new StockManager(symbol);
    }    
    
    @Override    
    protected void onActive() {  
        stockManager.requestPriceUpdates(listener);
    }   
    @Override
    protected 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);
    } 
    
    @Override
    protected 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 this
        return 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 监听

    @MainThread
    public 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 {
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
            //生命为STARTED 时 监听liveData 对象的数据变化
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            //当生命周期为 DESTROYED 自动取消监听
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

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

    @MainThread
    public void observeForever(@NonNull Observer<? super T> observer) {
        assertMainThread("observeForever");
        //和 observe  不同在于 此处的观察者 为 AlwaysActiveObserver
        AlwaysActiveObserver 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);
        }

        @Override
        boolean shouldBeActive() {
            return true; //一直返回的是true
        }
    }

当注册监听之后通过 setValue 进行触发(observe):

    @MainThread
    protected 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的生命周期

Jetpack 组件 LiveData + viewModel 使用分析

7.3、ViewModel 的用途

  • 在fragment 间共享数据

  • 用ViewModel 替换加载器

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

Jetpack 组件 LiveData + viewModel 使用分析

  • 使用liveData

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

Jetpack 组件 LiveData + viewModel 使用分析

  • 在ViewModel中使用协同程序

7.3、ViewModel 源码分析

7.3.1、ViewModelProviders:

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

   
	@NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return of(activity, null);
    }
	
    @NonNull
    @MainThread
    public 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
        @MainThread
        public <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 来创建ViewModel
            if (mFactory instanceof KeyedFactory) {
                viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
            } else {
                viewModel = (mFactory).create(modelClass);
            }
            mViewModelStore.put(key, viewModel);
            //noinspection unchecked
            return (T) viewModel;
        }
    

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

7.3.4、ViewModelStoreOwner :

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

ComponentActivity:

    @NonNull
    @Override
    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) {
                //创建了一个ViewModelStore
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }
  getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    if (!isChangingConfigurations()) {
                        //清楚viewModelStore
                        getViewModelStore().clear();
                    }
                }
            }
        });

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