《彻底搞懂 ViewModel：作用、原理与源码分析》

ViewModel官方介绍

ViewModel 是什么东西??? 实际开发中就稀里糊涂的用了起来,模糊的是知道什么关联生命周期,和解耦什么的,没深入研究过...现在深入研究一下这到底是一个什么东西.

开局三问:

• ViewModel是什么?
• ViewModel做了什么?
• ViewModel怎么用?

1.ViewModel是什么???

`官方说明:`
ViewModel类是一种业务逻辑或屏幕级状态容器。它用于将状态公开给界面，以及封装相关的业务逻辑。 它的主要优点是，它可以缓存状态，并可在配置更改后持久保留相应状态。这意味着在 activity 之间导航时或进行配置更改后（例如旋转屏幕时），界面将无需重新提取数据。(雨里雾里)

`自己总结`
ViewModel是一个绑定在页面`作用域`上的`数据管理容器`,随页面首次创建而创建，在配置变化（如横竖屏旋转）时不会销毁，只有页面真正结束时才会销毁.

`大白话:`

ViewModel 是一个数据管理的容器,伴随页面创建而创建,销毁的时候判断是否是横竖屏,再决定自己是否销毁.

ViewModel 是一个数据管理的容器,伴随页面创建而创建,销毁的时候判断是否是横竖屏,再决定自己是否销毁

注意:

不是关联生命周期,是页面创建创建,页面销毁的时候判断是否是横竖屏,再判断是否销毁

核心理解:

• 数据管理容器
• 横竖屏切换不会销毁
• 跟随页面创建和销毁

关键类

• ViewModelStoreOwner ViewModelStore
• HasDefaultViewModelProviderFactory SavedStateViewModelFactor
• ViewModelProvider ViewModelProviderImpl ViewModelProvider.Factory

角色扮演:

ViewModelStore Vm商店

ViewModelProvider.Factory Vm工厂

ViewModelStoreOwner Vm仓库

ViewModelProvider Vm店员

核心调用逻辑:

用户 → 店员 → 仓库（查）
            ↓
        有 → 直接给用户
            ↓
        没有 → 工厂生产
                 ↓
             放入仓库
                 ↓
             再给用户
             
             
ViewModelProvider(this)[MyViewModel::class.java] 
  ↓
ViewModelStore 查找
  ↓
没有 → Factory.create()
  ↓
存入 ViewModelStore
  ↓
返回 ViewModel
             

关系说明

关系简单说明

Activity/Fragment  实现HasDefaultViewModelProviderFactory,ViewModelStoreOwner
// ViewModelStoreOwner 持有 ViewModelStore
// ViewModelStore 持有 ViewModel( ->mutableMapOf<String, ViewModel>())
// HasDefaultViewModelProviderFactory 创建ViewModel


// 创建ViewModel
Activity ->HasDefaultViewModelProviderFactory->  SavedStateViewModelFactory--(ViewModel)create()

// 创建ViewModelStore 存储 ViewModel
Activity ->ViewModelStoreOwner-->ViewModelStore->mutableMapOf<String, ViewModel>()


val vm = ViewModelProvider(this)[MyViewModel::class.java]
// 创建流程
ViewModelProvider(Activity/Fragment)
-->(ViewModelStoreOwner,HasDefaultViewModelProviderFactory)
-->(ViewModelStore/SavedStateViewModelFactory)->ViewModel

Activity / Fragment  implements ViewModelStoreOwner,HasDefaultViewModelProviderFactory

ViewModelProvider
    ↓（持有）
ViewModelStoreOwner + Factory(Activity / Fragment )
    ↓
ViewModelStore（找缓存）
    ↓（没有才创建）
Factory.create()
    ↓
ViewModel
    ↓
存入 ViewModelStore

现在从 (Activity/Fragment) ViewModelProvider(this)[MyViewModel::class.java] 开始分析

1.1 源码分析

查看源码梳理一下整体的调用流程

1.1 ViewModelProvider 开端创建ViewModel

val vm=ViewModelProvider(this)[MyViewModel::class.java] (Activity/Fragment) 创建Vm流程开始

ViewModelProvider(this)

-->(Activity/Fragment)实现 ViewModelStoreOwner,HasDefaultViewModelProviderFactory

-->ViewModelProviderImpl() 具体实现

1.1.2ViewModelProvider 源码

package androidx.lifecycle

/**
 * ViewModelProvider：核心入口
 *
 * 作用：
 * - 获取 ViewModel
 * - 不存在则创建
 * - 并缓存到 ViewModelStore
 */
public actual open class ViewModelProvider
private constructor(
    private val impl: ViewModelProviderImpl // ⭐ 真正干活的是它
) {

    /**
     * 构造方式1（底层）
     *
     * 传入：
     * - store：存储容器
     * - factory：创建逻辑
     * - extras：额外参数
     */
    public constructor(
        store: ViewModelStore,
        factory: Factory,
        defaultCreationExtras: CreationExtras = CreationExtras.Empty,
    ) : this(ViewModelProviderImpl(store, factory, defaultCreationExtras))

    /**
     * 构造方式2（最常用）
     *
     * 直接传 Activity / Fragment
     *
     * 内部做了：
     * - 拿 ViewModelStore
     * - 拿默认 Factory
     * - 拿默认 Extras
     */
    public constructor(owner: ViewModelStoreOwner) : this(
        store = owner.viewModelStore,
        factory = ViewModelProviders.getDefaultFactory(owner),
        defaultCreationExtras = ViewModelProviders.getDefaultCreationExtras(owner),
    )

    /**
     * 构造方式3（自定义 Factory）
     */
    public constructor(
        owner: ViewModelStoreOwner,
        factory: Factory,
    ) : this(
        store = owner.viewModelStore,
        factory = factory,
        defaultCreationExtras = ViewModelProviders.getDefaultCreationExtras(owner),
    )

    /**
     * 获取 ViewModel（核心入口）
     *
     * ⭐ 实际调用 impl.getViewModel()
     */
    @MainThread
    public actual operator fun <T : ViewModel> get(modelClass: KClass<T>): T =
        impl.getViewModel(modelClass)

    /**
     * Java 兼容版本
     */
    public open operator fun <T : ViewModel> get(modelClass: Class<T>): T =
        get(modelClass.kotlin)

    /**
     * 获取 ViewModel（自定义 key）
     */
    @MainThread
    public actual operator fun <T : ViewModel> get(
        key: String,
        modelClass: KClass<T>
    ): T = impl.getViewModel(modelClass, key)

    public open operator fun <T : ViewModel> get(
        key: String,
        modelClass: Class<T>
    ): T = impl.getViewModel(modelClass.kotlin, key)

    // ==============================
    // Factory（创建逻辑）
    // ==============================

    public actual interface Factory {

        /**
         * 默认 create（旧版）
         */
        public fun <T : ViewModel> create(modelClass: Class<T>): T =
            ViewModelProviders.unsupportedCreateViewModel()

        /**
         * 新版 create（推荐）
         */
        public fun <T : ViewModel> create(
            modelClass: Class<T>,
            extras: CreationExtras
        ): T = create(modelClass)

        /**
         * Kotlin 版本
         */
        public actual fun <T : ViewModel> create(
            modelClass: KClass<T>,
            extras: CreationExtras
        ): T = create(modelClass.java, extras)

        companion object {
            /**
             * 快速创建 Factory（初始化器方式）
             */
            public fun from(vararg initializers: ViewModelInitializer<*>): Factory =
                ViewModelProviders.createInitializerFactory(*initializers)
        }
    }

    // ==============================
    // 默认 Factory（最重要）
    // ==============================

    /**
     * 最基础 Factory：直接反射调用空构造
     */
    public open class NewInstanceFactory : Factory {

        override fun <T : ViewModel> create(modelClass: Class<T>): T =
            JvmViewModelProviders.createViewModel(modelClass) // ⭐ 反射创建

        companion object {
            val instance: NewInstanceFactory
                get() {
                    if (_instance == null) {
                        _instance = NewInstanceFactory()
                    }
                    return _instance!!
                }

            private var _instance: NewInstanceFactory? = null
        }
    }

    /**
     * AndroidViewModel 专用 Factory
     *
     * 支持传入 Application
     */
    public open class AndroidViewModelFactory(
        private val application: Application?
    ) : NewInstanceFactory() {

        override fun <T : ViewModel> create(
            modelClass: Class<T>,
            extras: CreationExtras
        ): T {
            val app = application ?: extras[APPLICATION_KEY]

            if (AndroidViewModel::class.java.isAssignableFrom(modelClass)) {
                // ⭐ 必须有 Application
                return modelClass
                    .getConstructor(Application::class.java)
                    .newInstance(app)
            }

            return super.create(modelClass)
        }

        companion object {
            val APPLICATION_KEY: Key<Application> = CreationExtras.Key()
        }
    }

    // ==============================
    // Companion（创建入口）
    // ==============================

    public actual companion object {

        /**
         * 创建 Provider（传 owner）
         */
        public actual fun create(
            owner: ViewModelStoreOwner,
            factory: Factory,
            extras: CreationExtras,
        ): ViewModelProvider =
            ViewModelProvider(owner.viewModelStore, factory, extras)

        /**
         * 创建 Provider（传 store）
         */
        public actual fun create(
            store: ViewModelStore,
            factory: Factory,
            extras: CreationExtras,
        ): ViewModelProvider =
            ViewModelProvider(store, factory, extras)

        /**
         * ViewModel key（用于 Factory）
         */
        public actual val VIEW_MODEL_KEY: Key<String> =
            CreationExtras.Key()
    }
}

1.1.3 ViewModelProviderImpl 源码

package androidx.lifecycle.viewmodel.internal

import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelStore
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.MutableCreationExtras
import kotlin.reflect.KClass

/**
 * ViewModelProvider 的内部实现类
 *
 * 作用：
 * - 先从 ViewModelStore 中查找 ViewModel
 * - 如果有，直接返回
 * - 如果没有，通过 Factory 创建
 * - 创建后存入 ViewModelStore
 *
 * 也就是说：
 * ViewModelProvider 是外部入口
 * ViewModelProviderImpl 是真正执行"取 / 创建 / 存"的核心类
 */
internal class ViewModelProviderImpl(
    private val store: ViewModelStore,                  // ViewModel 仓库
    private val factory: ViewModelProvider.Factory,     // ViewModel 工厂
    private val defaultExtras: CreationExtras,          // 默认附加参数
) {

    /**
     * 锁对象
     *
     * 用于保证 getViewModel() 的线程安全
     * 避免并发情况下重复创建同一个 ViewModel
     */
    private val lock = SynchronizedObject()

    /**
     * 获取 ViewModel 的核心方法
     *
     * 流程：
     * 1. 根据 modelClass 生成默认 key（如果外部没传 key）
     * 2. 先去 ViewModelStore 中查找
     * 3. 如果已经存在并且类型匹配，直接返回
     * 4. 如果不存在，则准备 CreationExtras
     * 5. 调用 Factory 创建新的 ViewModel
     * 6. 存入 ViewModelStore
     * 7. 返回新的 ViewModel
     */
    @Suppress("UNCHECKED_CAST")
    internal fun <T : ViewModel> getViewModel(
        modelClass: KClass<T>,
        key: String = ViewModelProviders.getDefaultKey(modelClass),
    ): T {
        return synchronized(lock) {

            // 1. 先从仓库中取
            val viewModel = store[key]

            // 2. 如果仓库里已经有，并且类型匹配，直接返回
            if (modelClass.isInstance(viewModel)) {

                // 如果 Factory 支持"重新查询回调"，则触发
                if (factory is ViewModelProvider.OnRequeryFactory) {
                    factory.onRequery(viewModel!!)
                }

                return@synchronized viewModel as T
            }

            // 3. 准备创建 ViewModel 时需要的额外参数
            val modelExtras = MutableCreationExtras(defaultExtras)

            // 把当前 ViewModel 对应的 key 放进去
            modelExtras[ViewModelProvider.VIEW_MODEL_KEY] = key

            // 4. 通过工厂创建新的 ViewModel
            // 5. 创建后放入仓库
            return@synchronized createViewModel(factory, modelClass, modelExtras).also { vm ->
                store.put(key, vm)
            }
        }
    }
}

/**
 * 创建 ViewModel 的实际方法
 *
 * 作用：
 * - 调用 Factory.create(...)
 * - 返回新建的 ViewModel
 *
 * 注意：
 * 这里是 expect，说明不同平台（Android / 其他平台）会有各自 actual 实现
 */
internal expect fun <VM : ViewModel> createViewModel(
    factory: ViewModelProvider.Factory,
    modelClass: KClass<VM>,
    extras: CreationExtras,
): VM

1.2 ViewModelStoreOwner

1.3 ViewModelStore

ViewModelStore 维护了一个 mutableMapOf<String, ViewModel>() 是Vm的容器

package androidx.lifecycle

import androidx.annotation.RestrictTo

/**
 * Class to store `ViewModel`s.
 *
 * Instances of `ViewModelStore` must be retained through configuration changes. If the owner of a
 * `ViewModelStore`, typically a [`ViewModelStoreOwner`], is destroyed and recreated due to a
 * configuration change, the new owner must have the old instance of the `ViewModelStore`.
 *
 * If the owner of a `ViewModelStore` is destroyed and is _not_ going to be recreated, it should
 * call [`clear`] on this `ViewModelStore` so that The `ViewModel`s stored by it are notified that
 * they are no longer needed.
 *
 * Use [`ViewModelStoreOwner.getViewModelStore`] to retrieve a `ViewModelStore` for activities and
 * fragments.
 */

ViewModel。
必须通过配置更改保留 的ViewModelStore实例。如果一个 的所有者 ，通常是"ViewModelStoreOwner" 的所有者ViewModelStore因配置变更而被销毁并重新创建，新所有者必须拥有该 ViewModelStore.
如果 a 的所有者被销毁且不会被重建，它应该调用"清除"ViewModelStore，以便ViewModel通知存储在 a ViewModelStore 的 s 不再需要。
使用 'ViewModelStoreOwner.getViewModelStore' 获取Activity和Fragment的 a ViewModelStore 。
public open class ViewModelStore {

    private val map = mutableMapOf<String, ViewModel>()

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public fun put(key: String, viewModel: ViewModel) {
        val oldViewModel = map.put(key, viewModel)
        oldViewModel?.clear()
    }

    /** Returns the `ViewModel` mapped to the given `key` or null if none exists. */
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public operator fun get(key: String): ViewModel? {
        return map[key]
    }

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public fun keys(): Set<String> {
        return HashSet(map.keys)
    }

    /** Clears internal storage and notifies `ViewModel`s that they are no longer used. */
    public fun clear() {
        for (vm in map.values) {
            vm.clear()
        }
        map.clear()
    }
}

1.4.HasDefaultViewModelProviderFactory和SavedStateViewModelFactory

ComponentActivity 实现 HasDefaultViewModelProviderFactory 和ViewModelStoreOwner

HasDefaultViewModelProviderFactory接口开发获取和创建 ViewModelProvider.Factory

SavedStateViewModelFactory 是ViewModelProvider.Factory 的实现类实现它的具体功能

package androidx.lifecycle

import android.annotation.SuppressLint
import android.app.Application
import android.os.Bundle
import androidx.annotation.RestrictTo
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.getInstance
import androidx.lifecycle.ViewModelProvider.NewInstanceFactory.Companion.instance
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.savedstate.SavedStateRegistry
import androidx.savedstate.SavedStateRegistryOwner
import java.lang.reflect.Constructor
import java.lang.reflect.InvocationTargetException
import kotlin.reflect.KClass

// ViewModelProvider.Factory 实现类 实现了具体功能
public actual class SavedStateViewModelFactory :
    ViewModelProvider.OnRequeryFactory, ViewModelProvider.Factory {
    private var application: Application? = null
    private val factory: ViewModelProvider.Factory
    private var defaultArgs: Bundle? = null
    private var lifecycle: Lifecycle? = null
    private var savedStateRegistry: SavedStateRegistry? = null

    public actual constructor() {
        factory = ViewModelProvider.AndroidViewModelFactory()
    }

   
    public constructor(
        application: Application?,
        owner: SavedStateRegistryOwner,
    ) : this(application, owner, null)

   
    @SuppressLint("LambdaLast")
    public constructor(
        application: Application?,
        owner: SavedStateRegistryOwner,
        defaultArgs: Bundle?,
    ) {
        savedStateRegistry = owner.savedStateRegistry
        lifecycle = owner.lifecycle
        this.defaultArgs = defaultArgs
        this.application = application
        factory =
            if (application != null) getInstance(application)
            else ViewModelProvider.AndroidViewModelFactory()
    }

    actual override fun <T : ViewModel> create(modelClass: KClass<T>, extras: CreationExtras): T {
        return create(modelClass.java, extras)
    }

  // 创建 Vm的核心方法
    override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
        val key =
            extras[ViewModelProvider.VIEW_MODEL_KEY]
                ?: throw IllegalStateException(
                    "VIEW_MODEL_KEY must always be provided by ViewModelProvider"
                )

        return if (
            extras[SAVED_STATE_REGISTRY_OWNER_KEY] != null &&
                extras[VIEW_MODEL_STORE_OWNER_KEY] != null
        ) {
        
        // 特殊的 全局 VM 
            val application = extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY]
            val isAndroidViewModel = AndroidViewModel::class.java.isAssignableFrom(modelClass)
            val constructor: Constructor<T>? =
                if (isAndroidViewModel && application != null) {
                    findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE)
                } else {
                    findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE)
                }
            // doesn't need SavedStateHandle
            if (constructor == null) {
                return factory.create(modelClass, extras)
            }
            // 构造器构造Vm
            val viewModel =
                if (isAndroidViewModel && application != null) {
                    newInstance(
                        modelClass,
                        constructor,
                        application,
                        extras.createSavedStateHandle(),
                    )
                } else {
                    newInstance(modelClass, constructor, extras.createSavedStateHandle())
                }
            viewModel
        } else {
            val viewModel =
                if (lifecycle != null) {
                    create(key, modelClass)
                } else {
                    throw IllegalStateException(
                        "SAVED_STATE_REGISTRY_OWNER_KEY and" +
                            "VIEW_MODEL_STORE_OWNER_KEY must be provided in the creation extras to" +
                            "successfully create a ViewModel."
                    )
                }
            viewModel
        }
    }

    public fun <T : ViewModel> create(key: String, modelClass: Class<T>): T {
        // empty constructor was called.
        val lifecycle =
            lifecycle
                ?: throw UnsupportedOperationException(
                    "SavedStateViewModelFactory constructed with empty constructor supports only " +
                        "calls to create(modelClass: Class<T>, extras: CreationExtras)."
                )
        val isAndroidViewModel = AndroidViewModel::class.java.isAssignableFrom(modelClass)
        val constructor: Constructor<T>? =
            if (isAndroidViewModel && application != null) {
                findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE)
            } else {
                findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE)
            }
        // doesn't need SavedStateHandle
        constructor
            ?: // If you are using a stateful constructor and no application is available, we
            // use an instance factory instead.
            return if (application != null) factory.create(modelClass)
            else instance.create(modelClass)
        val controller =
            LegacySavedStateHandleController.create(
                savedStateRegistry!!,
                lifecycle,
                key,
                defaultArgs,
            )
        val viewModel: T =
            if (isAndroidViewModel && application != null) {
                newInstance(modelClass, constructor, application!!, controller.handle)
            } else {
                newInstance(modelClass, constructor, controller.handle)
            }
        viewModel.addCloseable(
            LegacySavedStateHandleController.TAG_SAVED_STATE_HANDLE_CONTROLLER,
            controller,
        )
        return viewModel
    }

 
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        // ViewModelProvider calls correct create that support same modelClass with different keys
        // If a developer manually calls this method, there is no "key" in picture, so factory
        // simply uses classname internally as as key.
        val canonicalName =
            modelClass.canonicalName
                ?: throw IllegalArgumentException(
                    "Local and anonymous classes can not be ViewModels"
                )
        return create(canonicalName, modelClass)
    }

    /**  */
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    override fun onRequery(viewModel: ViewModel) {
        // needed only for legacy path
        if (lifecycle != null) {
            LegacySavedStateHandleController.attachHandleIfNeeded(
                viewModel,
                savedStateRegistry!!,
                lifecycle!!,
            )
        }
    }
}

internal fun <T : ViewModel?> newInstance(
    modelClass: Class<T>,
    constructor: Constructor<T>,
    vararg params: Any,
): T {
    return try {
        constructor.newInstance(*params)
    } catch (e: IllegalAccessException) {
        throw RuntimeException("Failed to access $modelClass", e)
    } catch (e: InstantiationException) {
        throw RuntimeException("A $modelClass cannot be instantiated.", e)
    } catch (e: InvocationTargetException) {
        throw RuntimeException("An exception happened in constructor of $modelClass", e.cause)
    }
}

private val ANDROID_VIEWMODEL_SIGNATURE =
    listOf<Class<*>>(Application::class.java, SavedStateHandle::class.java)
private val VIEWMODEL_SIGNATURE = listOf<Class<*>>(SavedStateHandle::class.java)

internal fun <T> findMatchingConstructor(
    modelClass: Class<T>,
    signature: List<Class<*>>,
): Constructor<T>? {
    for (constructor in modelClass.constructors) {
        val parameterTypes = constructor.parameterTypes.toList()
        if (signature == parameterTypes) {
            @Suppress("UNCHECKED_CAST")
            return constructor as Constructor<T>
        }
        if (signature.size == parameterTypes.size && parameterTypes.containsAll(signature)) {
            throw UnsupportedOperationException(
                "Class ${modelClass.simpleName} must have parameters in the proper " +
                    "order: $signature"
            )
        }
    }
    return null
}

总结

(Activity/Fragment) 中创建Vm
->val vm=ViewModelProvider(this)[MyViewModel::class.java] 

->(Activity/Fragment )实现了ViewModelStoreOwner,HasDefaultViewModelProviderFactory
->ViewModelStoreOwner->接口抽象了ViewModelStoreOwner的创建
->HasDefaultViewModelProviderFactory接口抽象了`ViewModelProvider.Factory`
->`SavedStateViewModelFactory` 实现了Vm的创建
->`ViewModelProviderImpl`是ViewModelProvider的具体实现

ViewModelProvider持有了ViewModelStore和ViewModelProvider.Factory 通过getViewModel() 获取和创建Vm

internal fun <T : ViewModel> getViewModel(
    modelClass: KClass<T>,
    key: String = ViewModelProviders.getDefaultKey(modelClass),
): T {
    return synchronized(lock) {
        val viewModel = store[key]
        if (modelClass.isInstance(viewModel)) {
            if (factory is ViewModelProvider.OnRequeryFactory) {
                factory.onRequery(viewModel!!)
            }
            return@synchronized viewModel as T
        }

        val modelExtras = MutableCreationExtras(defaultExtras)
        modelExtras[ViewModelProvider.VIEW_MODEL_KEY] = key

        return@synchronized createViewModel(factory, modelClass, modelExtras).also { vm ->
            store.put(key, vm)
        }
    }
}

2:ViewModel 做了什么

ViewModel 拥有什么能力呢???

• 伴随Activity/Fragment 创建销毁而销毁
• 横竖屏切换Vm不销毁
• Activity 中搭配Fragment的时候ViewModel 是共享的
• AndroidViewModel是一个特殊的Vm

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller,
        OnConfigurationChangedProvider,
        OnTrimMemoryProvider,
        OnNewIntentProvider,
        OnMultiWindowModeChangedProvider,
        OnPictureInPictureModeChangedProvider,
        MenuHost,
        FullyDrawnReporterOwner {
			// 销毁的时候销毁VM
		    getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    // Clear out the available context
                    mContextAwareHelper.clearAvailableContext();
                    // And clear the ViewModelStore
                    if (!isChangingConfigurations()) {
                        getViewModelStore().clear();
                    }
                    mReportFullyDrawnExecutor.activityDestroyed();
                }
            }
        });
		
		// 创建 Vm
        getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                ensureViewModelStore();
                getLifecycle().removeObserver(this);
            }
        });
		// 重建的时候 获取保存的 mLastNonConfigurationInstances 获取 viewModelStore
		 final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken,
            IBinder shareableActivityToken, IBinder initialCallerInfoAccessToken) {

       
        mLastNonConfigurationInstances = lastNonConfigurationInstances;
        
    }
		
		// 横竖屏切换执行 保存 viewModelStore
		final override 
		fun onRetainNonConfigurationInstance(): Any? {
        // Maintain backward compatibility.
        val custom = onRetainCustomNonConfigurationInstance()
        var viewModelStore = _viewModelStore
        if (viewModelStore == null) {
            // No one called getViewModelStore(), so see if there was an existing
            // ViewModelStore from our last NonConfigurationInstance
            val nc = lastNonConfigurationInstance as NonConfigurationInstances?
            if (nc != null) {
                viewModelStore = nc.viewModelStore
            }
        }
        if (viewModelStore == null && custom == null) {
            return null
        }
        val nci = NonConfigurationInstances()
        nci.custom = custom
        nci.viewModelStore = viewModelStore
        return nci
    }
		// 创建VM
		void ensureViewModelStore() {
        if (mViewModelStore == null) {
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
                mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                mViewModelStore = new ViewModelStore();
            }
        }
    }
	
	
	}

3:ViewModel怎么用?

Activity/Fragment 中创建

val vm=ViewModelProvider(this)[MyViewModel::class.java]

注意:

• ViewModel 是关联this的生命周期的 Activity和Fragment不同
• AndroidViewModel特殊的Vm持有Application的conetxt
• ViewModel 不能持有 Context（尤其 Activity），是因为它活得比 Activity 久，会导致内存泄漏

总结

ViewModel 本质上是一个页面作用域的数据与状态容器。

它通过 ViewModelStore 缓存，第一次获取时创建，后续优先复用；在横竖屏等配置变化时，Activity/Fragment 会重建，但 ViewModelStore 会被保留，所以 ViewModel 通常不会销毁。只有页面真正结束、不再重建时，ViewModelStore.clear() 才会触发 ViewModel 销毁。

它的核心价值有三个：

1. 保存页面状态，避免配置变化后数据丢失
2. 承载页面业务逻辑，让 UI 和数据处理解耦
3. 在 Activity / Fragment 之间按作用域共享数据

一句话总结就是：

ViewModel 是绑定在 Activity/Fragment 作用域上的页面级状态管理容器，用来存数据、管状态，并在配置变化时复用。