Jetpack的MVVM实现 - ViewModel的使用及源码分析

概述

这篇我们继续讲 Jetpack，具体讲实现 MVVM架构的 ViewModel。这次的例子会将 ViewModel和 LiveData结合使用，然后分析一下 ViewModel的源码。LiveData将留到下篇文章分析。

上一篇文章MVP基础架构搭建的例子里，用了MVP的架构实现了网络加载的流程。这次我们要把上次 MVP架构升级为这次的MVVM，将上次例子的 Presenter模块和 Model模块去掉，只保留网络加载引擎。然后结合 ViewModel和 LiveData来实现 MVVM。

1、使用

先导入依赖：

    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.2.0'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0'

我们需要知道，ViewModel是一个抽象类，需要我们去实现。所以我们先创建一个实现类：

public class DataViewModel extends ViewModel {
    // LiveData
    private MutableLiveData<String> mLiveData;
    // 网络加载引擎
    private RetrofitRequestInterface retrofit;
    public DataViewModel(){
        // 注释 1， 初始化 LiveData
        mLiveData = new MutableLiveData();
        // 注释 2， 初始化网络引擎
        retrofit = RetrofitInstance.getRetrofitInstance().create(RetrofitRequestInterface.class);
    }
    public LiveData getLiveData(){
        return mLiveData;
    }
    public void getData(String url){
        // 注释 3， 网络请求
        Call<ResponseBody> call = retrofit.getRequest(url);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    String result = response.body().string();
                    // 注释 4， 用 LiveData回调
                    mLiveData.postValue(result);
                } catch (IOException e) {
                    e.printStackTrace();
                    mLiveData.postValue(e.getMessage());
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                mLiveData.postValue(t.getMessage());
            }
        });
    }
}

上面我们创建了一个 ViewModel实现类，这个类的作用与MVP的 Presenter有点类似。上面注释 1和注释 2分别创建 LiveData对象和网络引擎，在注释 3的地方外界调用时执行网络加载，然后在注释 4处用 LiveData回调加载结果。

下面看界面如何调用：

public class MainActivity extends AppCompatActivity {
    private Button getData;
    private DataViewModel mViewModel;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getData = findViewById(R.id.id_get_data);
        init();
    }
    private void init(){
        // 注释5， 工厂设计模式创建 ViewModel对象
        mViewModel = new ViewModelProvider(this).get(DataViewModel.class);
        // 以 LiveData对象设置数据回调 
        mViewModel.getLiveData().observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Toast.makeText(getApplicationContext(), "mag = " + s, Toast.LENGTH_SHORT).show();
            }
        });
        getData.setOnClickListener((View view) -> {
            // 网络请求
            mViewModel.getData("https://www.baidu.com");
        });
    }
}

上面步骤分别是创建了 ViewModel对象、设置数据回调以及执行网络请求。这就是 MVVM的基础实现。Demo： ViewModel

现在我们先抛出两个问题：

1、上面注释 5处为什么使用 ViewModelProvider创建 ViewModel对象，而不直接 new一个？
2、传说 ViewModel可以避免内存泄漏，如何做到的？

下面我们来分析一下 ViewModel的源码。

2、源码分析

先看上面 ViewModelProvider的构造方法和 get() 方法：

// ViewModelProvider.java
    public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
 // 注释 6， 通过ViewModelStore 拥有者的 getDefaultViewModelProviderFactory方法获取工厂对象
        this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
                ? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
                : ViewModelProvider.NewInstanceFactory.getInstance());
    }
    public ViewModelProvider(@NonNull ViewModelStore store, @NonNull ViewModelProvider.Factory factory) {
        //注释7，  保存工厂 Factory和 缓存对象，ViewModelStore
        mFactory = factory;
        mViewModelStore = store;
    }
    public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
        String canonicalName = modelClass.getCanonicalName();,
        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
    }
    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        //注释 9， 从缓存 mViewModelStore中取 ViewModel的对象
        // Key值是 “androidx.lifecycle.ViewModelProvider.DefaultKey” + 类名
        ViewModel viewModel = mViewModelStore.get(key);
        if (modelClass.isInstance(viewModel)) {
            ......
            // 是响应类的对象则直接返回
            return (T) viewModel;
        }
        ......
        ......
        //注释 10， 缓存中没有 ViewModel对象，用工厂创建，并存入缓存
        viewModel = (mFactory).create(modelClass);
        mViewModelStore.put(key, viewModel);
        return (T) viewModel;
    }

上面注释 6和注释 7 处ViewModelProvider重载的构造器里，分别调用了Activity的 getViewModelStore()和 getDefaultViewModelProviderFactory()方法获取或创建了一个 ViewModel的缓存对象 ViewModelStore以及工厂对象 Factory，并保存起来。其中缓存对象 ViewModelStore内部是一个 HashMap，以键值对的形式缓存 ViewModel对象。

再看上面注释 9和注释 10处 get（）的重载方法，ViewModelProvider创建 ViewModel对象前，首先从缓存 ViewModelStore中取，key值是“androidx.lifecycle.ViewModelProvider.DefaultKey” + 类名。当缓存中没有该对象时就用工厂 Factory创建，并存入缓存和返回。

Factory是一个抽象类，实现类对象是从上面注释 6处通过 Activity的 getDefaultViewModelProviderFactory()方法获取的。我们来看看 ComponentActivity的这个方法如何创建工厂实现类的对象：

   // ComponentActivity.java
    public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
        ......
        if (mDefaultFactory == null) {
            mDefaultFactory = new SavedStateViewModelFactory(
                    //注释 11， 获取了 Application对象，创建SavedStateViewModelFactory对象
                    getApplication(),
                    this,
                    getIntent() != null ? getIntent().getExtras() : null);
        }
        return mDefaultFactory;
    }

    // SavedStateViewModelFactory.java
    public SavedStateViewModelFactory(@NonNull Application application,
                                      @NonNull SavedStateRegistryOwner owner,
                                      @Nullable Bundle defaultArgs) {
        mSavedStateRegistry = owner.getSavedStateRegistry();
        mLifecycle = owner.getLifecycle();
        mDefaultArgs = defaultArgs;
        mApplication = application;
        //注释 12， 创建 AndroidViewModelFactory工厂
        mFactory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
    }
    public <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {
        ......
       // 注释 13，通过 AndroidViewModelFactory创建 ViewModel对象
        return mFactory.create(modelClass);
        ......
    }

上面注释 11处，ComponentActivity获取了 Application对象，创建了 Factory的子类 SavedStateViewModelFactory的对象。然后注释 12处SavedStateViewModelFactory又以 application作为参数创建了 Factory的另一实现类 AndroidViewModelFactory的对象，并用该对象创建 ViewModel对象。

下面重点看看 AndroidViewModelFactory这个工厂：

    public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
        private static ViewModelProvider.AndroidViewModelFactory sInstance;
        @NonNull
        public static ViewModelProvider.AndroidViewModelFactory getInstance(@NonNull Application application) {
            // 注释14， 单例模式创建工厂实例
            if (sInstance == null) {
                sInstance = new ViewModelProvider.AndroidViewModelFactory(application);
            }
            return sInstance;
        }
        private Application mApplication;
        // 传入 Application对象
        public AndroidViewModelFactory(@NonNull Application application) {
            mApplication = application;
        }
        @NonNull
        @Override
        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
            if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
                try {
                    //注释 15， 工厂方法设计模式创建 ViewModel对象，持有 Application的引用
                    return modelClass.getConstructor(Application.class).newInstance(mApplication);
                }
                ......
            }
            return super.create(modelClass);
        }
    }

上面 AndroidViewModelFactory 这个工厂，注释14处用单例模式创建了该工厂对象，然后在注释 15处用工厂方法设计模式创建 ViewModel对象。有一点值得注意的是，ViewModel创建时传入的是 mApplication参数。也就是说 ViewModel对象最终并不持有 Activity的引用，而是持有了 Application的引用。

经过上面的分析，我们现在应该可以回答上面的两个问题了：

1、ViewModel对象使用了 ViewModelProvider获取而不直接 new，是因为 ViewModelProvider有缓存机制，内部用HashMap以键值对的形式缓存 ViewModel对象。当缓存中没有相应对象时才用工厂去创建。

2、ViewModel对象并不持有 Activity的引用，而是持有了 Application的引用。这是避免 Activity内存泄漏的一种方式。

Jetpack的MVVM实现 - ViewModel的使用及源码分析

概述

1、使用

2、源码分析

推荐阅读更多精彩内容