Jetpack系列-ViewModel的使用及原理浅析_viewmodel by，鸿蒙开发自学技巧

最新推荐文章于 2024-07-08 03:08:31 发布

kOS0ym

最新推荐文章于 2024-07-08 03:08:31 发布

阅读量760

点赞数 13

分类专栏：程序员文章标签： harmonyos 华为

本文链接：https://blog.csdn.net/kOS0ym/article/details/137710773

版权

程序员专栏收录该内容

184 篇文章 0 订阅

订阅专栏

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数HarmonyOS鸿蒙开发工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

htt

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上HarmonyOS鸿蒙开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

class DemoFragment : Fragment() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // jetpack fragment也实现了ViewModelStoreOwner接口，因此也可以用于获取和管理viewmodel
        val selfViewModel = ViewModelProvider(this).get(FragmentViewModel::class.java)
    }
    
    override fun onAttach(context: Context) {
        super.onAttach(context)
        // 可以获取到Activity或者其它Fragment的ViewModel，只需要在构造ViewModelProvider
        // 时传递了对应的ViewModelStoreOwner。这个实例和DemoActivity
        // 中获取到的是同一个实例，因此你可以通过这个实例实现和Activity的通信。
        val parentViewModel = ViewModelProvider(requireActivity())
            .get(DemoViewModel::class.java)
    }
}

SavedStateHandle

SavedStateHandle主要用于在进程销毁-重建过程中恢复数据，它可以将数据持久化到存储中，并在重建后恢复数据。

class DemoViewModel(val savedState: SavedStateHandle) : ViewModel() {
    // 可以使用getLiveData将要获取的数据转为LiveData
    private val _savedData = savedState.getLiveData<String>(DATA_KEY)
    val savedData: LiveData<String> = _savedData  

    fun saveData(data: String) {
        savedState[DATA_KEY] = data
    }

    fun readData(): String? {
        // 也可以直接获取
        return savedState[DATA_KEY]
    }

    companion object {
        private const val DATA_KEY = "data"
    }
}

AndroidViewModel

有时候ViewModel中可能会需要使用到Android Context（获取文本、颜色等资源），此时可以使用AndroidViewModel，它提供了一个getApplication()方法，可以很方便的获取上下文实例。使用方式如下：

class DemoViewModel(application: Application) 
    : AndroidViewModel(application) { 
    fun getString() = application.getString(R.string.hint_txt)
}

带参数的ViewModel

前面几个小节我们都假定了使用androidx的组件作为ViewModelStoreOwner来构造ViewModelProvider。这些androidx的组件会帮助我们自动提供ViewModel所依赖的SavedStateHandle和Application 。

然而，当我们使用自定义ViewModelStoreOwner时，或者想向ViewModel传递其它类型的参数时，就需要自定义ViewModeProvider.Factory了。

假如我们有如下ViewModel，它需要接收一个Repository作为参数：

class MyViewModel(
    private val myRepository: MyRepository
) : ViewModel() { }

为了实例化MyViewModel，我们需要再定义一个Factory，然后在create方法中获取依赖对象，构造ViewModel实例：

val factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(
        modelClass: Class<T>,
        extras: CreationExtras
    ): T {
        val repo = MyRepository(extras[MY_URL])
        return MyViewModel(repo) as T
    }
}

上面的CreationExtras用于从外界向ViewModel构造过程传递参数，它在ViewModelProvider构造时与factory实例一起传递给ViewModelProvider：

val extras = MutableCreationExtras().apply {
    this[MY_URL] = "https://..."
}
val viewModel = ViewModelProvider(this, factory, extras)
    .get(MyViewModel::class.java)

原理分析

ViewModel的获取过程

ViewModelProvider的构造

顾名思义，ViewModelProvider就是用于提供ViewModel实例的类，它在构造时需要接受三个参数：

public open class ViewModelProvider
constructor(
    private val store: ViewModelStore,
    private val factory: Factory,
    private val defaultCreationExtras: CreationExtras = CreationExtras.Empty,
)

ViewModelStore：用于存储ViewModel实例的类，内部持有一个HashMap保存实例，ViewModelProvider会将创建好的ViewModel实例保存到ViewModelStore中，之后再需要此类ViewModel的实例时就直接从中读取。
ViewModelProvider.Factory：前文已经提到，这是用于创建ViewModel实例的工厂，ViewModelProvider当需要ViewModel的实例又在ViewModelStore中没有找到对应实例时就会调用工厂的create方法创建。
CreationExtras：前文也已提到，它用于在创建ViewModel实例时从外界向构造过程传递参数，内部持有一个MutableMap，以key-value的形式存储和查找参数。

虽然ViewModelProvider需要三个参数来构造，但在实际使用中我们往往只在构造时传递了一个ViewModelStoreOwner，ViewModelStoreOwner很好理解，可以用来提供ViewModelStore，而剩下两个参数，框架则提供了一系列的默认规则。

public constructor(
    owner: ViewModelStoreOwner
) : this(owner.viewModelStore, defaultFactory(owner), defaultCreationExtras(owner))

ViewModelStore的获取

通常情况下ViewModelStore由ViewModelStoreOwner提供，ViewModelStoreOwner是一个接口，里面只声明了一个getViewModelStore函数。androidx里的ComponentActivity、Fragment、FragmentViewLifecycleOwner等都实现了这个接口，下面我们看一看ComponentActivity中是如何实现的：

public ViewModelStore getViewModelStore() {
    ensureViewModelStore();
    return mViewModelStore;
}

void ensureViewModelStore() {
    if (mViewModelStore == null) {
        NonConfigurationInstances nc = (NonConfigurationInstances) getLastNonConfigurationInstance();
        // 这里会尝获取配置变更前保存的实例，这是ViewModel在配置变更后仍能保持数据的关键
        if (nc != null) {
            mViewModelStore = nc.viewModelStore;
        }
        if (mViewModelStore == null) {
            mViewModelStore = new ViewModelStore();
        }
    }
}

默认工厂和及构造参数

defaultFactory, defaultCreationExtras用于提供默认的ViewModelProvider.Factory与CreationExtras。

internal fun defaultFactory(owner: ViewModelStoreOwner): Factory =
    if (owner is HasDefaultViewModelProviderFactory)
        owner.defaultViewModelProviderFactory 
    else instance

internal fun defaultCreationExtras(owner: ViewModelStoreOwner): CreationExtras =
    if (owner is HasDefaultViewModelProviderFactory) {
        owner.defaultViewModelCreationExtras
    else CreationExtras.Empty

可以看到，两个方法首先都尝试将ViewModelStoreOwner实例转为HasDefaultViewModelProviderFactory，然后从中获取对应的默认值。如果没获取到，则返回ViewModelProvider自己提供的默认值。

先来看下ViewModelProvider提供的默认值：

public open class NewInstanceFactory : Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return try {
            modelClass.newInstance()
        } catch (...) {
            ...
        }
    }
    public companion object {
        private var sInstance: NewInstanceFactory? = null
        public val instance: NewInstanceFactory get() {
            if (sInstance == null) sInstance = NewInstanceFactory()
            return sInstance!!
        }
    }
}

可以看到，这个工厂通过直接调用Class的newInstance方法直接创建实例，这种情况下ViewModel必需要提供无参构造函数。

接下来我们看HasDefaultViewModelProviderFactory，这也是一个接口，里面声明了getDefaultViewModelProviderFactory与getDefaultViewModelCreationExtras两个方法，分别用于获取默认的工厂实例与默认的构造参数。androidx中的ComponentActivity与Fragment也实现了这个接口，以ComponentActivity中的实现为例：

public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
    if (mDefaultFactory == null) {
        mDefaultFactory = new SavedStateViewModelFactory(
            getApplication(),
            this,
            getIntent() != null ? getIntent().getExtras() : null);
    }
    return mDefaultFactory;
}

public CreationExtras getDefaultViewModelCreationExtras() {
    MutableCreationExtras extras = new MutableCreationExtras();
    if (getApplication() != null) {
        extras.set(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY, getApplication());
    }
    extras.set(SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY, this);
    extras.set(SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY, this);
    if (getIntent() != null && getIntent().getExtras() != null) {
        extras.set(SavedStateHandleSupport.DEFAULT_ARGS_KEY, getIntent().getExtras());
    }
    return extras;
}

ComponentActivity会提供一个SavedStateViewModelFactory实例，并且会提供一个预置了一些内容的CreationExtras实例，里面有Application实例、SavedStateRegistryOwner 的实例、ViewModelStoreOwner的实例，以及Intent中extras参数bundle。

然后是SavedStateViewModelFactory，我们直接看create方法：

override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
    val key = extras[ViewModelProvider.NewInstanceFactory.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) {
        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)
        }
        val viewModel = if (isAndroidViewModel && application != null) {
            newInstance(modelClass, constructor, application, extras.createSavedStateHandle())
        } else {
            newInstance(modelClass, constructor, extras.createSavedStateHandle())
        }
        viewModel
    } else {
        // 这里是为了兼容旧版本
        ...
    }
}

除开旧版本的兼容逻辑，上面的代码根据是否使用SavedStateHandle分为两类：当不使用SavedStateHandle时，将ViewModel的构造请求发送给内部的AndroidViewModelFactory实例来处理；当使用SavedStateHandle时，则自己调用createSavedStateHandle方法创建SavedStateHandle实例，然后创建对应的ViewModel实例。关于SavedStateHandle的分析见后文。

获取ViewModel

回到开始，我们通过调用ViewModelProvider实例的get方法来获取ViewModel实例：

public open operator fun <T : ViewModel> get(modelClass: Class<T>): T {
    val canonicalName = modelClass.canonicalName
        ?: throw IllegalArgumentException("Local and anonymous classes can not be ViewModels")
    return get("${ViewModelProvider.AndroidViewModelFactory.DEFAULT_KEY}:$canonicalName", modelClass)
}

public open operator fun <T : ViewModel> get(key: String, modelClass: Class<T>): T {
    val viewModel = store[key]
    if (modelClass.isInstance(viewModel)) {
        (factory as? ViewModelProvider.OnRequeryFactory)?.onRequery(viewModel)
        return viewModel as T
    } else {
        if (viewModel != null) { }
    }
    val extras = MutableCreationExtras(defaultCreationExtras)
    extras[ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY] = key
    return try {
        factory.create(modelClass, extras)
    } catch (e: AbstractMethodError) {
        factory.create(modelClass)
    }.also { store.put(key, it) }
}

获取实例需要两个参数：key和要获取的ViewModel所属类的Class对象，ViewModelProvider会从ViewModelStore中根据key查找是否有现成的实例，有就直接使用，没有就调用Factory的create创建一个。

生命周期管理的实现

ViewModel的作用域会被限定为实例化时使用的ViewModelStoreOwner，ViewModelStoreOwner结束生命周期时，ViewModel就会自动回调onCleared方法用于清理依赖生命周期的工作或者对象。

class MyViewModel(
    private val coroutineScope: CoroutineScope =
        CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
) : ViewModel() {
    override fun onCleared() {
        coroutineScope.cancel()
    }
}

在2.5及更高版本的lifecycle库中，ViewModel提供了更多的支持：

ViewModel可以接受多个Closeable对象，ViewModel会在清除时自动调用这些对象的close方法。
ViewModel提供了addCloseable、setTagIfAbsent等方法，这些方法允许在任意时刻添加Closeable对象到ViewModel中，这些对象同样会被自动清除。

下面还是以ComponentActivity为例看一下清理过程的实现：

public ComponentActivity() {
    Lifecycle lifecycle = getLifecycle ();
    ...
    getLifecycle().addObserver(new LifecycleEventObserver () {
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (event == Lifecycle.Event.ON_DESTROY) {
                // Clear out the available context
                mContextAwareHelper.clearAvailableContext();
                // And clear the ViewModelStore
                if (!isChangingConfigurations()) {
                    getViewModelStore().clear();
                }
            }
        }
    });
}

ComponentActivity会在构造时设置一个lifecycle监听，当activity onDestroy且并非配置改变引起的调用时，执行ViewModelStore的clear方法清空所有的ViewModel，在清空前，会调用每个ViewModel的clear方法。

// ViewModelStore
public final void clear() {
    for (ViewModel vm : mMap.values()) {
        vm.clear();
    }
    mMap.clear();
}
// ViewModel
final void clear() {
    mCleared = true;
    if (mBagOfTags != null) {
        synchronized (mBagOfTags) {
            for (Object value : mBagOfTags.values()) {
                closeWithRuntimeException(value);
            }
        }
    }
    // We need the same null check here
    if (mCloseables != null) {
        synchronized (mCloseables) {
            for (Closeable closeable : mCloseables) {
                closeWithRuntimeException(closeable);
            }
        }
    }
    onCleared();
}

在ViewModel的clear方法中，对所有保存的Closeable执行close，然后调用onCleared。

再看看ktx中的viewModelScope：

public val ViewModel.viewModelScope: CoroutineScope
    get() {
        val scope: CoroutineScope? = this.getTag(JOB_KEY)
        if (scope != null) return scope
        return setTagIfAbsent(
            JOB_KEY,
            CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
        )
    }

internal class CloseableCoroutineScope(context: CoroutineContext) : Closeable, CoroutineScope {
    override val coroutineContext: CoroutineContext = context

    override fun close() {
        coroutineContext.cancel()
    }
}

其本质也是提供了一个实现Closeable接口的CoroutineScope，然后通过setTagIfAbsent设置给ViewModel。

配置变更后仍保持数据的原理

前面在分析ViewModelStore的获取时，我们知道ComponentActivity在初始化ViewModelStore时，会先调用getLastNonConfigurationInstance，尝试恢复配置未变更前保存的ViewModelStore。与之对应的也有配置变更时保存ViewModelStore的逻辑：

public final Object onRetainNonConfigurationInstance() {
    // Maintain backward compatibility.
    Object custom = onRetainCustomNonConfigurationInstance();
    ViewModelStore viewModelStore = mViewModelStore;
    if (viewModelStore == null) {
        // No one called getViewModelStore(), so see if there was an existing
        // ViewModelStore from our last NonConfigurationInstance
        NonConfigurationInstances nc =
            (NonConfigurationInstances) getLastNonConfigurationInstance();
        if (nc != null) {
            viewModelStore = nc.viewModelStore;
        }
    }
    if (viewModelStore == null && custom == null) return null;
    NonConfigurationInstances nci = new NonConfigurationInstances();
    nci.custom = custom;
    nci.viewModelStore = viewModelStore;
    return nci;
}

onRetainNonConfigurationInstance会在Activity配置发生变更（如横竖屏切换）需要重建时，它会将返回的Object直接保存到ActivityClientRecord中:

// ActivityThread
void performDestroyActivity(ActivityClientRecord r, boolean finishing,
     int configChanges, boolean getNonConfigInstance, String reason
) {
    ...
    if (getNonConfigInstance) {
        try {
            r.lastNonConfigurationInstances = r.activity.retainNonConfigurationInstances();
        } catch (Exception e) {
odelStore = viewModelStore;
    return nci;
}

onRetainNonConfigurationInstance会在Activity配置发生变更（如横竖屏切换）需要重建时，它会将返回的Object直接保存到ActivityClientRecord中:

// ActivityThread
void performDestroyActivity(ActivityClientRecord r, boolean finishing,
     int configChanges, boolean getNonConfigInstance, String reason
) {
    ...
    if (getNonConfigInstance) {
        try {
            r.lastNonConfigurationInstances = r.activity.retainNonConfigurationInstances();
        } catch (Exception e) {

kOS0ym

关注

13
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
Jetpack系列-ViewModel的使用及原理浅析_viewmodel by，鸿蒙开发自学技巧

有时候ViewModel中可能会需要使用到Android Context（获取文本、颜色等资源），此时可以使用AndroidViewModel，它提供了一个getApplication()方法，可以很方便的获取上下文实例。实例，里面有Application实例、SavedStateRegistryOwner 的实例、ViewModelStoreOwner的实例，以及Intent中extras参数bundle。androidx中的。中根据key查找是否有现成的实例，有就直接使用，没有就调用Factory的。
复制链接

扫一扫