Android开发Jetpack组件ViewModel使用讲解

目录
  • 前言
  • ViewModel概述
  • ViewModel使用
  • ViewModel源码

前言

学习ViewModel之前首先我们得简单了解下MVP和MVVM,因为ViewModel是MVVM中的一个元素

MVP MVVM

在MVP中View想要调用Model数据层,需要经过中间层Presenter, 这样就实现了View和Model的解耦,这也是MVP和MVC的差别; 但是如果一个Activity中有太多交互,那么我们的View接口数量就会很庞大达到十几个也不足为奇,并且在View层调用了Presenter之后,会反过来调用View层,这样显得繁琐;而MVVM的出现就解决了这个问题

说到MVVM的话,我们放上Google的架构图

MVVM中的VM指的就是ViewModel; 从上图为没看到,因为ViewModel中持有了LiveData,而LiveData是一个可观察的数据类型,在LiveData原理篇中,我们做了详细的分析;在View层中,将被观察的数据LiveData订阅,并提供了一个观察者Observer,当数据发生变化的时候,就会回调Observer中的onChanged()方法,从而更新UI, 这个过程是系统源码帮我们处理的,所以就没有上面Presenter中调用View的那一步了

ViewModel概述

应用的某个 Activity 中可能包含用户列表,因配置更改而重新创建 Activity 后,新 Activity 必须重新提取用户列表; 对于简单的数据,Activity 可以使用onSaveInstanceState() 方法从 onCreate() 中的捆绑包恢复其数据,但此方法仅适合可以序列化再反序列化的少量数据,而不适合数量可能较大的数据,如用户列表或位图,使用ViewModel可以解决这个问题

另外,界面控制器经常需要进行异步调用,这些调用可能需要一些时间才能返回结果; 界面控制器需要管理这些调用,并确保系统在其销毁后清理这些调用以避免潜在的内存泄露;此项管理需要大量的维护工作,并且在因配置更改而重新创建对象的情况下,会造成资源的浪费,因为对象可能需要重新发出已经发出过的调用,使用ViewModel可以解决这个问题

诸如 Activity 和 Fragment 之类的界面控制器主要用于显示界面数据、对用户操作做出响应或处理操作系统通信(如权限请求); 如果要求界面控制器也负责从数据库或网络加载数据,那么会使类越发膨胀。为界面控制器分配过多的责任可能会导致单个类尝试自己处理应用的所有工作,而不是将工作委托给其他类;以这种方式为界面控制器分配过多的责任也会大大增加测试的难度

ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。ViewModel 类让数据可在发生屏幕旋转等配置更改后继续存在

ViewModel使用

ViewModel的使用比较简单,我们想要使用使用的话直接继承ViewModel或者继承AndroidViewModel即可; AndroidViewModel源码如下,他们俩的区别,是AndroidViewModel中多了一个Application的成员变量以及以Application为参数的构造方法,如果你需要Application的话,就直接继承AndroidViewModel即可

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

这里以我写的一个Demo为例,这个Demo可以在Github上找到,链接如下JetPack Demo,这个Demo用到了所有Jetpack的组件,是学习Jetpack的辅助资料,需要的小伙伴可以下载和star。我们自定义一个AppsViewModel如下:

class AppsViewModel(appsRepository: AppsRepository) : ViewModel() {
 val apps: LiveData<List<AppEntity>> = appsRepository.loadApps()
}

因为我们这里传入了一个参数,所以需要定义一个Factory,代码如下:

	class AppsViewModelFactory(private val repository: AppsRepository) : ViewModelProvider.Factory {
    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        return AppsViewModel(repository) as T
    }
}

接下来就是使用了:

class AppsListFragment : Fragment() {
    private lateinit var viewModel: AppsViewModel
    //-----1-----
    private val viewModel: AppsViewModel by viewModels {
    	FactoryProvider.providerAppsFactory(requireContext())
	}
	override fun onActivityCreated(savedInstanceState: Bundle?) {
		  //-----2-----
  		  viewModel = ViewModelProviders.of(this,FactoryProvider.providerAppsFactory(requireContext()))
		        .get(AppsViewModel::class.java)
		  //-----3-----
		  viewModel.apps.observe(viewLifecycleOwner, Observer {
		  		//Update UI
		  })
	}
}

我们先声明了一个变量viewModel,我们可以通过注释1处的 by viewModels提供一个自定义的Factory,但是需要添加一个依赖:implementation "androidx.fragment:fragment-ktx:1.2.2;或者采用注释2的方式直接使用ViewModelProviders.of(fragment,factory).get(class)的形式获取实例。 然后就直接使用了,在注释3处使用viewmodel.apps.observe将其加入生命周期观察中,如果数据发生变化就会调用Observer的回调,从而更新UI

ViewModel源码

上面我们采用ViewModelProviders.of(...).get(class)方法获取ViewModel,我们就从这里开始源码开始分析,我们先看下这个类的源码:

@Deprecated
public class ViewModelProviders {
    @Deprecated
    public ViewModelProviders() {
    }
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull Fragment fragment) {
        return new ViewModelProvider(fragment);
    }
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return new ViewModelProvider(activity);
    }
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) {
        if (factory == null) {
            factory = fragment.getDefaultViewModelProviderFactory();
        }
        return new ViewModelProvider(fragment.getViewModelStore(), factory);
    }
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        if (factory == null) {
            factory = activity.getDefaultViewModelProviderFactory();
        }
        return new ViewModelProvider(activity.getViewModelStore(), factory);
    }
    @SuppressWarnings("WeakerAccess")
    @Deprecated
    public static class DefaultFactory extends ViewModelProvider.AndroidViewModelFactory {
        @Deprecated
        public DefaultFactory(@NonNull Application application) {
            super(application);
        }
    }
}

我们看到此类中提供了四个方法,其实着四个都以一样,我们以第四个为例分析;第一个参数是Activity,第二个参数是一个Factory,默认情况下我们是不需要传入Factory这个参数的。如果不传入的话,我们跟进构造方法就能看到默认是用NewInstanceFactory来作为Factory的,看到内部的create方法通过反射生成了一个ViewModel,实例源码如下:

public static class NewInstanceFactory implements Factory {
    private static NewInstanceFactory sInstance;
    /**
     * Retrieve a singleton instance of NewInstanceFactory.
     *
     * @return A valid {@link NewInstanceFactory}
     */
    @NonNull
    static NewInstanceFactory getInstance() {
        if (sInstance == null) {
            sInstance = new NewInstanceFactory();
        }
        return sInstance;
    }
    @SuppressWarnings("ClassNewInstance")
    @NonNull
    @Override
    public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
        //noinspection TryWithIdenticalCatches
        try {
            return modelClass.newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException("Cannot create an instance of " + modelClass, e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Cannot create an instance of " + modelClass, e);
        }
    }
}
  • 如果传入Factory参数的话,就会用我们自定义的Factory作来生成ViewModel。
  • of方法调用结束返回的是ViewModelProvider, 然后调用的是get方法,我们看下这个类的部分源码:
public class ViewModelProvider {
	private static final String DEFAULT_KEY ="androidx.lifecycle.ViewModelProvider.DefaultKey";
    private final Factory mFactory;
    private final ViewModelStore mViewModelStore;
    //-----1-----
	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;
	 }
	 public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
        String canonicalName = modelClass.getCanonicalName();
        if (canonicalName == null) {
            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
        }
        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
    }
    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        ViewModel viewModel = mViewModelStore.get(key);
        if (modelClass.isInstance(viewModel)) {
            if (mFactory instanceof OnRequeryFactory) {
                ((OnRequeryFactory) mFactory).onRequery(viewModel);
            }
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
        } else {
            viewModel = (mFactory).create(modelClass);
        }
        mViewModelStore.put(key, viewModel);
        return (T) viewModel;
    }
}

上面截取的部分源码其实是ViewModelProvider最重要的方法了,我们先看此类中有两个重要的成员变量,其中一个是mFactory, 注释1处看到如果我们没有传入factory的话,默认实现的是NewInstanceFactory, 印证了我们之前的说法。还有一个是ViewModelStore, 它是怎么来的呢?因为ComponentActivity中实现了接口ViewModelStoreOwner,在ViewModelProvider的构造方法中调用owner.getViewModelStore(),这个owner就是ComponentActivity自身,然后获取到了ViewModelStore这个变量,实际调用的源码如下:

@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.");
    }
    //-----1-----
    if (mViewModelStore == null) {
        NonConfigurationInstances nc =
                (NonConfigurationInstances) getLastNonConfigurationInstance();
        if (nc != null) {
            // Restore the ViewModelStore from NonConfigurationInstances
            mViewModelStore = nc.viewModelStore;
        }
        if (mViewModelStore == null) {
            mViewModelStore = new ViewModelStore();
        }
    }
    return mViewModelStore;
}

在注释1处,判断如果mViewModelStore == null的话,就会调取getLastNonConfigurationInstance尝试获取,如果获取到了就将获取到的赋值给mViewModelStore返回。这里就涉及到一个重要的知识点了,为什么说ViewModel在横竖屏切换的时候能够持久的保存数据,不需要像之前一样调用onSaveInstanceState? 因为在Activity被销毁的时候,还会调用另外一个方法onRetainNonConfigurationInstance, 我们看它在ComponentActivity中的源码实现:

public final Object onRetainNonConfigurationInstance() {
    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;
    }
	//----1-----
    NonConfigurationInstances nci = new NonConfigurationInstances();
    nci.custom = custom;
    nci.viewModelStore = viewModelStore;
    return nci;
}

我们看到在注释1的地方将我们之前存在的viewModelStore存储到NonConfigurationInstances中了,然后在调用getViewModelStore的时候调用getLastNonConfigurationInstance这样就保证了Activity销毁之前和之后的viewModelStore是同一个,那它里面存储的ViewModel值也就是同样的了。所以ViewModel的生命周期可以用下图来概括:

接下来我们分析get方法:

private static final String DEFAULT_KEY =
        "androidx.lifecycle.ViewModelProvider.DefaultKey"
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
    String canonicalName = modelClass.getCanonicalName();
    if (canonicalName == null) {
        throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
    }
    return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}

首先获取类的全称的字符串名字,和DEFAULT_KEY拼凑成一个Key,然后调用get的重载方法如下:

public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
    ViewModel viewModel = mViewModelStore.get(key);
	//-----1-----
    if (modelClass.isInstance(viewModel)) {
        if (mFactory instanceof OnRequeryFactory) {
            ((OnRequeryFactory) mFactory).onRequery(viewModel);
        }
        return (T) viewModel;
    } else {
        //noinspection StatementWithEmptyBody
        if (viewModel != null) {
            // TODO: log a warning.
        }
    }
    if (mFactory instanceof KeyedFactory) {
        viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
    } else {
    	//-----2-----
        viewModel = (mFactory).create(modelClass);
    }
    mViewModelStore.put(key, viewModel);
    return (T) viewModel;
}

注释1处判断我们的modelClass是不是属于ViewModel类型的,并且判断mFactory的类型是否属于OnRequeryFactory类型,如果是的话,就返回值; 在注释2处使用Factory通过反射创建一个viewModel, 然后将其存入mViewModelStore中。我们看下ViewModelStore的源码:

public class ViewModelStore {
    private final HashMap<String, ViewModel> mMap = new HashMap<>();
    final void put(String key, ViewModel viewModel) {
        ViewModel oldViewModel = mMap.put(key, viewModel);
        if (oldViewModel != null) {
            oldViewModel.onCleared();
        }
    }
    final ViewModel get(String key) {
        return mMap.get(key);
    }
    Set<String> keys() {
        return new HashSet<>(mMap.keySet());
    }
    /**
     *  Clears internal storage and notifies ViewModels that they are no longer used.
     */
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.clear();
        }
        mMap.clear();
    }
}

ViewModelStore的源码很简单,内部持有了一个HashMap对象,用来存放ViewModel。ViewModel的创建到此就结束了。然后就是使用的问题, 使用如下

override fun onActivityCreated(savedInstanceState: Bundle?) {
	viewModel = ViewModelProviders.of(this,FactoryProvider.providerAppsFactory(requireContext()))
		        .get(AppsViewModel::class.java)
	viewModel.apps.observe(viewLifecycleOwner, Observer {
		  		//Update UI
    })
}

ViewModel的使用涉及到LiveData和Lifecycle部分,这里就不再多说了

到此这篇关于Android开发Jetpack组件ViewModel使用讲解的文章就介绍到这了,更多相关Android Jetpack组件ViewModel内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Android Jetpack库剖析之ViewModel组件篇

    前言 今天让我们一起去探究一下ViewModel的实现原理,描述的不对或不足还请海涵,仅作为参考 ViewModel简介 ViewModel是一个可感知Activity或Fragment生命周期的一个架构组件,当视图销毁,数据也会被清除,所以它的本质就是用来存储与视图相关的数据,让视图显示控制与数据分离,即使界面配置发生改变数据也不会被销毁,通常配合LiveData使用 ViewModel用法 class MainActivity : AppCompatActivity() { override

  • Android Jetpack架构组件 ViewModel详解

    前言 前面两篇文章我们已经学习了Lifecycle和DataBind,本篇文章我们来学习Jetpack系列中比较重要的ViewModel,Jetpack的很多很多组件都是搭配使用的,所以单独的知识点可能会有些"无意义"但却是我们项目实战的基础! ViewModel的使用 ViewModel类旨在以注重生命周期的方式存储和管理界面相关的数据.ViewModel类让数据可在发生屏幕旋转等配置更改后继续存在.这句话很好理解,还记得我们在讲解Lifecycle的时候 举的例子吗,我们还是使用那

  • Android Jetpack架构中ViewModel接口暴露的不合理探究

    目录 暴露 Mutable 状态 暴露 Suspend 方法 在 Jetpack 架构规范中, ViewModel 与 View 之间应该遵循单向数据流的通信方式,Events 永远从 View 流向 VM ,而 State 从 VM 流向 View. 如果 ViewModel 对 View 暴露了不适当的接口类型,则会破坏单向数据流的形成.不适当的接口类型常见于以下两点: 暴露 Mutable 状态 暴露 Suspend 方法 暴露 Mutable 状态 ViewModel 对外暴露的数据状态

  • Android开发Jetpack组件ViewModel使用讲解

    目录 前言 ViewModel概述 ViewModel使用 ViewModel源码 前言 学习ViewModel之前首先我们得简单了解下MVP和MVVM,因为ViewModel是MVVM中的一个元素 MVP MVVM 在MVP中View想要调用Model数据层,需要经过中间层Presenter, 这样就实现了View和Model的解耦,这也是MVP和MVC的差别: 但是如果一个Activity中有太多交互,那么我们的View接口数量就会很庞大达到十几个也不足为奇,并且在View层调用了Prese

  • Android开发Jetpack组件Room使用讲解

    目录 简介 Room使用步骤 1 添加依赖 2 创建Entity实体类 3 声明Dao对象 4 声明Database对象 5 获取数据 6 最终使用 简介 Room 是 Google 官方推出的数据库 ORM 框架.ORM 是指 Object Relational Mapping,即对象关系映射,也就是将关系型数据库映射为面向对象的语言.使用 ORM 框架,我们就可以用面向对象的思想操作关系型数据库,不再需要编写 SQL 语句. Room使用步骤 1 添加依赖 build.gradle {app

  • Android开发Jetpack组件LiveData使用讲解

    目录 LiveData概述 LiveData优势 共享资源 LiveData使用 1 LiveData基本使用 2 Transformations.map() 3 Transformations.switchMap() 4 MediatorLiveData.addSource()合并数据 LiveData概述 LiveData 是一种可观察的数据存储器类: 与常规的可观察类不同,LiveData 具有生命周期感知能力,意指它遵循其他应用组件(如 Activity.Fragment 或 Servi

  • Android开发Jetpack组件DataBinding用例详解

    目录 简介 使用方式 1. build.gradle 中添加 kapt,并启用dataBinding 2.修改布局文件,添加 layout 和 data 标签 3.使用 DataBindingUtil 绑定布局 4.布局的 data 标签中添加数据变量,并使用其参数 5.BindingAdapter的使用 简介 DataBinding 是 Jetpack 组件之一,适用于 MVVM 模式开发,也是Google官方推荐使用的组件之一.使用DataBinding可以很容易的达到视图与逻辑分离,直接在

  • Android开发Jetpack组件Lifecycle使用篇

    目录 1.为什么需要Lifecycle 2.如何使用Lifecycle 2.1 依赖Lifecycle库 2.2 Lifecycle基本用法 3.Lifecycle应用举例 3.1 Activity中使用 3.2 MVP中使用 4.自定义LifecycleOwner 1.为什么需要Lifecycle 在应用开发中,处理Activity或者Fragment组件的生命周期相关代码是必不可免的: 官方文档中举了一个例子,这里简化一下,在Activity中写一个监听,在Activity的不同生命周期方法

  • Android开发Jetpack组件WorkManager用例详解

    目录 一.简介 二.导入 三.基本使用 3.1 定义后台任务 3.2 配置任务运行条件 3.2.1 只需执行一次的任务 3.2.2 周期性执行的任务 3.3 将任务传给 WorkManager 四.高级配置 4.1 设置任务延迟执行 4.2 给任务添加标签 4.3 取消任务 4.3.1 根据标签取消任务 4.3.2 根据 request 的 id 取消任务 4.3.3 取消所有任务 4.4 任务重试 4.5 监听任务结果 4.6 传递数据 4.7 链式任务 一.简介 WorkManager 用于

  • Android开发Jetpack组件Lifecycle原理篇

    目录 前言 1.Lifecycle的生命周期状态事件和状态 2.Lifecycle如何观察Activity和Fragment的生命周期 前言 在上一篇文章中,我们学习了如何去使用Lifecycle: 当然之会使用是不够的,还需要了解它的原理,这是成为优秀工程师必备的:这篇文章就来学习Lifecycle的基本原理 1.Lifecycle的生命周期状态事件和状态 **Lifecycle使用两个枚举来跟踪其关联组件的生命周期状态,这两个枚举分别是Event和State:**State指的是Lifecy

  • Android开发Jetpack组件Room用例讲解

    目录 一.简介 二.导入 三.使用 3.1 创建 Entity 类 3.2 创建 Dao 类 3.3 创建 Database 抽象类 3.4 测试 四.数据库升级 4.1 简单升级 4.2 规范升级 4.2.1 新增一张表 4.2.2 修改一张表 4.3 测试 一.简介 Room 是 Google 官方推出的数据库 ORM 框架.ORM 是指 Object Relational Mapping,即对象关系映射,也就是将关系型数据库映射为面向对象的语言.使用 ORM 框架,我们就可以用面向对象的思

  • Android Jetpack组件ViewModel基本用法详解

    目录 引言 一.概述与作用 二.基本用法 小结 引言 天道好轮回,终于星期五,但是还是忙碌了一天.在项目中,我遇到了一个问题,起因则是无法实时去获取信息来更新UI界面,因为我需要知道我是否获取到了实时信息,我想到的办法有三,利用Handler收发消息在子线程与主线程切换从而更新信息,其二则是利用在页面重绘的时候(一般是页面变动如跳转下个页面和将应用切至后台),其三就是利用Jetpack中最重要的组件之一ViewModel,最后我还是选择了ViewModel,因为感觉更方便. 其实想到的前面两个方

  • Kotlin Jetpack组件ViewModel使用详解

    目录 1.ViewModel的出现 2.ViewModel的使用 基本步骤 ViewModel的作用 1.ViewModel的出现 ViewModel应该是Jetpack中最重要的组件之一了.在以前,Activity要负责逻辑处理,又要控制UI展示,还要处理网络回调,导致大型项目难以维护.于是,ViewModel来帮助Activity分担一部分工作,ViewModel就专门用于存放和界面相关的工作. 2.ViewModel的使用 基本步骤 在app/build.gradel文件添加依赖 depe

随机推荐