Android Jetpack架构组件之ViewModel入门到

作者: 斌林诚上 | 来源:发表于2019-12-01 17:03 被阅读0次

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

前言
一、简介
（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有什么用

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

（3）有什么优点

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

存储和管理数据
避免内存泄漏
解耦
共享数据

二、基本使用

（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实例的一些操作（存储、获取、清除）

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

ViewModel类存储了Actvity的UI数据
ViewModelStore又存储了ViewModel实例
在配置发生变化的时候在FragmentActivity.onRetainNonConfigurationInstance()方法中利用NonConfigurationInstances保存了ViewModelStore实例
并在FragmentActivtiy.oncreate（）方法中恢复了ViewModelStore。也就是保存了ViewModel。所以数据才不会在配置更改时丢失
最后在FragmentActivtiy.onDestroy()方法中清除存储在ViewModelStore中的ViewModel对象。

五、内容推荐

六、项目参考

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

Github / apk下载体验地址

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

Android Jetpack架构组件之ViewModel入门到

前言

一、简介

（1）ViewModel是什么

（2）ViewModel有什么用

（3）有什么优点

二、基本使用

（1）添加依赖

（2）继承ViewModel

（3）使用方式

三、源码分析

四、总结

五、内容推荐

六、项目参考

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android开发

Android进阶之路

Android-Jetpack

Android技术知识

Android Jetpack架构组件之ViewModel入门到

前言

一、简介

（1）ViewModel是什么

（2）ViewModel有什么用

（3）有什么优点

​二、基本使用

（1）添加依赖

（2）继承ViewModel

（3）使用方式

三、源码分析

四、总结

五、内容推荐

六、项目参考

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android开发

Android进阶之路

Android-Jetpack

Android技术知识

二、基本使用