Android Jetpack架构组件之ViewModel入门到精通

要想获得食物，就必须一直寻找，只有这样，才有机会。不要气馁，就算找不到肥羊，至少能找到一只兔子——《狼道》

前言
一、简介
（1）ViewModel是什么
（2）ViewModel有什么用
（3）有什么优点
二、基本使用
（1）添加依赖
（2）继承ViewModel
（3）使用方式
三、源码分析
四、总结
五、内容推荐
六、项目参考

前言

——这篇主要是梳理一下Jetpack架构组件之一的ViewModel，并结合楼主所学做个总结。面向那些还不认识ViewModel的同学们。看完这篇可以快速了解它，并轻松使用。也想请教前辈们指点文章中的错误或不足的地方。本篇只针对ViewModel，不会拓展额外的知识如MVVM,若想了解更多关于Jetpack组件知识可以看楼主写的Jetpack专栏。

一、简介

（1）ViewModel是什么

——ViewModel 是google推出的Jetpack架构组件之一，设计成以生命周期的方式存储和管理UI相关的数据。

举个列子来消化一下：

——当发生横竖屏切换或其他意外导致Activity重启时，里面的临时数据将会丢失。以前可以利用onSaveInstanceState()保存简单的数据并在onCreate()中恢复，但只适用于少量可以序列化反序列化的数据，并不能适用于任何情况。这时就可以使用ViewModel来管理这些数据。当然ViewModel并不只 只有这个作用。

那ViewModel为什么可以管理这些数据呢？

主要还是因为ViewModel的生命周期比Activtiy生命周期来的更长。如：

这就要求我们在onCreate()方法时就启动ViewModel。

从图中可以看出当Activity意外重启时，ViewModel也一直存活，所以把数据存交给ViewModel管理后就不会意外丢失数据。

（2）ViewModel有什么用

  1. 可以存储和管理因Activity意外重启（如：屏幕切换）丢失的数据。
  2. 可以管理Acitvity中使用的异步调用，或监听事件因Activity销毁而没有及时清理造成的内存泄漏。
  3. 可以将Activity中有关数据获取的操作移到ViewModel里面，实现视图与数据相互分离，更容易维护。
  4. 可以在Fragment之间共享数据。

（3）有什么优点

针对用法，可以得出以下优点：

  1. 存储和管理数据
  2. 避免内存泄漏
  3. 解耦
  4. 共享数据

​二、基本使用

（1）添加依赖

可以使用androidx的appcompat，里面包含许多的依赖，包括viewodel。

implementation 'androidx.appcompat:appcompat:1.0.0'

当然也可以添加自己熟悉的版本，每个版本使用方式都有稍微差别：

    implementation 'androidx.lifecycle:lifecycle-viewmodel:2.1.0'

楼主这边要分析的是官网上的例子，所以添加的依赖是：

implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0'

这个依赖主要作用是在使用ViewModel的基础上多封装了一个ViewModelProviders类。

（2）继承ViewModel

因为ViewModel是个抽象类，所以需要声明一个类来继承它。

public class MyViewModel extends ViewModel {
    private String name ="张三";
    private String data ="网络数据";
    //获取用户名字
    public String getUserName(){
        return name;
    }
    //获取数据
    public String loadData(){
        //加载网络数据的逻辑
        return data;
    }
}

其实这边获取网络数据的时候可以配合LiveData一起使用，因为加载网络数据都会有一点的延迟。并能立即就得到数据，所以使用liveData的话，当有数据回调的时候，可以通知UI更新。但这边只单纯介绍ViewModel，就不详细说明了。想要了解LiveData 请看《Android Jetpack架构组件之LiveData》

（3）使用方式

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyViewModel viewModel = ViewModelProviders.of(this).get(MyViewModel.class);
        Log.e(TAG, "onCreate: "+viewModel.getUserName() );
        Log.e(TAG, "onCreate: "+viewModel.loadData() );
    }
}

通过ViewModelProviders获取到MyViewModel的实例，就可以使用里面的方法了。

注意：ViewModel绝对不能引用视图、生命周期或任何可能包含对活动上下文的引用的类。

这里就不展示太复杂的代码了，一切从简。主要目的是想让大家一眼就能明白它是什么，如何实现的，用最少的时间，掌握知识。

再通过分析源码来了解它。

三、源码分析

通过使用步骤来分析一下源码实现过程。

(1)ViewModelProviders.of(this).get(MyViewModel.class)

首先是调用了ViewModelProviders的of（）方法：源码如下

    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return of(activity, null);
    }

    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        //获取Application实例
        Application application = checkApplication(activity);
        /**
         * 若没有自定义Factor'y的情况下默认使用viewModel提供的AndrodiViewModelFactory
         * of该方法也是androidx.lifecycle:lifecycle-extensions依赖给我们封装好
         * 若不添加上面依赖的情况下 使用的时候需要手动加入该factory
         */
        if (factory == null) {
            //详细看 》2
            factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
        }
        //详细看 》3
        return new ViewModelProvider(activity.getViewModelStore(), factory);
    }

（2）ViewModelProvider.AndroidViewModelFactory.getInstance(application)

/**
* AndroidViewModelFactory 是ViewModelProvider的一个静态内部类
* 继承NewInstanceFactory类并重写了create方法
* 主要是判断ViewModel是不是继承与AndroidVeiwMode，
* 如果是通过传入application实例,使继承于AndroidViewMode的实例可以拿到application
* 区别：
* 继承ViewModel拿不到Application实例而继承于AndroidViewMode可以拿到Application实例
* 所以AndroidViewModelFactory作用：是封装了一层可以得到Application实例的viewmodel
*/
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
        private static AndroidViewModelFactory sInstance;
        /**
         * 使用单例模式 获取AndroidViewModelFactory实例
         */
        @NonNull
        public static AndroidViewModelFactory getInstance(@NonNull Application application) {
            if (sInstance == null) {
                sInstance = new AndroidViewModelFactory(application);
            }
            return sInstance;
        }
        private Application mApplication;
        public AndroidViewModelFactory(@NonNull Application application) {
            mApplication = application;
        }

        @NonNull
        @Override
        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
            if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
                //noinspection TryWithIdenticalCatches
                try {
                    return modelClass.getConstructor(Application.class).newInstance(mApplication);
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                } catch (InstantiationException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                } catch (InvocationTargetException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                }
            }
            return super.create(modelClass);
        }
    }
/**
 * AndroidViewModelFactory 继承了 NewInstanceFactory类 并重写了create方法
 * NewInstanceFactory 主要作用是通过create方法利用反射创建一个类的实例
 */
public static class NewInstanceFactory implements Factory {

        @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);
            }
        }
    }

（3）new ViewModelProvider(activity.getViewModelStore(), factory)

    /**
    * 创建了ViewModelProvider实例，这样就可以使用ViewModelProvider里面的方法
    */
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
        mFactory = factory;
        mViewModelStore = store;
    }

（4）getViewModelStore（）

   /**
    * 当配置发生更改时一般会造成数据丢失 而NonConfigurationInstances实例则可以在
    * 配置发生变化时保存一些数据和状态，在oncreate方法恢复使数据不会丢失。 
    * 当配置发生变化的时候它保存了ViewModelStore。
    * 所以这里先从NonConfigurationInstance实例中获取ViewModelStore
    * 否则就新建一个ViewModelStore
    */
 @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) {
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }

/**
 * ViewModelStore 用于缓存ViewModel的一个操作类
 */
public class ViewModelStore {
    //用于存储ViewModel的集合
    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();
    }
}

（5）ViewModelProviders.of(this).get(MyViewModel.class)

——of方法拿到了ViewModelProvider实例就可以使用get方法，这时把自定义的ViewModel类传进去

     @NonNull
    @MainThread
    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);
    }

    /**
    * 获取ViewModel实例
    */
    @NonNull
    @MainThread
    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        //从集合中获取ViewModel并检测是不是已经实例化,如果存在就不要新建
        ViewModel viewModel = mViewModelStore.get(key);

        if (modelClass.isInstance(viewModel)) {
            //noinspection unchecked
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }
        //通过of()方法得到的Factory实例，调用create方法。利用反射获取到ViewModel的实例
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
        } else {
            viewModel = (mFactory).create(modelClass);
        }
        //保存viewModel实例
        mViewModelStore.put(key, viewModel);
        //noinspection unchecked
        return (T) viewModel;
    }

其实主要还是利用了反射得到了ViewModel的实例。我们才可以使用ViewModel里面的方法。

那么什么是反射呢？ 这里简单介绍一下：

反射机制：反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

优点：可以实现动态创建对象和编译，体现出很大的灵活性

缺点：对性能有影响，此类操作总是慢于直接执行相同的操作

（6）最后说一下VierModel是如何销毁的

    /**
    * 在FragmentActivity的onDestroy方法中调用了mViewModelStore.clear()
    */
     @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mViewModelStore != null && !isChangingConfigurations()) {
            mViewModelStore.clear();
        }
        mFragments.dispatchDestroy();
    }

    /**
     * 先遍历ViewModel实例 调用各自的clear() 
     * 再清除集合中的ViewModel实例
     */
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.clear();
        }
        mMap.clear();
    }
    /**
    * 清除一些标记 并调用onCleared()
    */
    @MainThread
    final void clear() {
        mCleared = true;
        // Since clear() is final, this method is still called on mock objects
        // and in those cases, mBagOfTags is null. It'll always be empty though
        // because setTagIfAbsent and getTag are not final so we can skip
        // clearing it
        if (mBagOfTags != null) {
            synchronized (mBagOfTags) {
                for (Object value : mBagOfTags.values()) {
                    // see comment for the similar call in setTagIfAbsent
                    closeWithRuntimeException(value);
                }
            }
        }
        onCleared();
    }
    //通过继承ViewModel 可以重写该方法。 该方法会在ViewMode被销毁前调用
    protected void onCleared() {
    }

四、总结

通过源码分析ViewModel有三个重要的类：ViewModel 、ViewModelProvider 、 ViewModelStore

  • ViewModel ：负责准备和管理数据的类，该抽象类其实是声明一些通用方法

  • ViewModelProvider ：ViewModel 的核心类，主要是利用反射实例化出ViewModel 对象。利用工厂模式生产出具体的ViewModel 实例。

  • ViewModelStore：缓存ViewModel实例的一些操作（存储、获取、清除）

核心原理简单通俗描述如下：

  1. ViewModel类存储了Actvity的UI数据

  2. ViewModelStore又存储了ViewModel实例

  3. 在配置发生变化的时候在FragmentActivity.onRetainNonConfigurationInstance()方法中利用NonConfigurationInstances保存了ViewModelStore实例

  4. 并在FragmentActivtiy.oncreate（）方法中恢复了ViewModelStore。也就是保存了ViewModel。所以数据才不会在配置更改时丢失

  5. 最后在FragmentActivtiy.onDestroy()方法中清除存储在ViewModelStore中的ViewModel对象。

五、内容推荐

六、项目参考

自己整理的一个工具演示项目，有兴趣可以看下

Github / apk下载体验地址

若您发现文章中存在错误或不足的地方，希望您能指出！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,214评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,307评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,543评论 0赞 341
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,221评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,224评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,007评论 1赞 284
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,313评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,956评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,441评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,925评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,018评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,685评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,234评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,240评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,464评论 1赞 261
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,467评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,762评论 2赞 345

推荐阅读更多精彩内容