Android Architecture Components Part4:ViewModel

在Android Architecture Components(AAC)中ViewMode是为界
置更改后继续存在的对象。例如界面的旋转致使界面配置信息改变。

对于为界面提供数据，咱们所知道的也有其余的一些模式，例如MVP的Presenter与MVVM中的ViewModel。那么咱们进行一个假设，若是Activity发生界面旋转，此时上述的提供数据的模式会发生什么呢？

1. 对于Activity的重建，为了提供ui所需的数据，咱们必须从新获取数据(网络或者本地数据库)，若是须要保存数据，也要从新进行保存操做。
2. 在对数据进行操做时，你必需要处理一些可能形成的内存泄露问题。

对于以上问题，ViewModel都可以帮咱们解决。只要Activity没有完全被销毁，使用的都是同一个ViewModel，同时对于它的建立与销毁咱们无需进行维护管理，能很好的保证资源的释放。

下面的这张图可以帮助咱们更好的观察它在Activity中的生命状态

ViewModel贯穿Activity的整个生命周期，只有当Activity完全释放时才会将其销毁。因此它可以更好的帮助咱们实现持久化数据，防止没必要要的数据请求，提升App的性能。

是否是有点好奇了呢，下面咱们来简单介绍它的使用，为何说简单呢？由于真的很简单...

依赖

若是你已经有了解过上篇关于Lifecycle的文章(Android Architecture Components Part3:Lifecycle)，那么能够直接跳过依赖部分，没有的咱们继续。

在使用ViewModel以前，咱们须要在App或者Module的build.gradle中添加以下代码

dependencies {
    def lifecycle_version = "1.1.1"
 
    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"   
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"
}

使用

依赖已经准备完毕，咱们能够直接经过以下代码使用

class ContactsViewModel(application: Application, private val defTitle: String = "Contacts") : AndroidViewModel(application) {
    val message: MutableLiveData<String> by lazy { MutableLiveData<String>() }
    val contactsList: MutableLiveData<List<ContactsModel>> = MutableLiveData()
    ....
    ....
    
    fun getContacts(refresh: Boolean): LiveData<List<ContactsModel>> {
        message.value = ""
        if (refresh) {
            getDataFromRemote()
        } else if (contactsList.value == null || contactsList.value?.size ?: 0 <= 0) {
            message.value = "数据请求中，请稍后！"
            if (mLocalData.isEmpty()) {
                getDataFromLocal()
            }
        }
        return contactsList
    }
    ...
    ...
}

咱们建立ContactsViewModel，让它继承于AndroidViewModel，它是对抽象ViewModel的扩展，使用它时须要传入Application对象，方便一些资源的获取。因为ViewModel的特性是对数据进行持久化，因此它不能持有与Activity相关的引用(Context)，防止内存泄露，所以这里使用与应用生命周期绑定的Application。

在ContactsViewModel中咱们结合MutableLiveData来更好的管理数据的变化更新。

ViewModel建立好了，接下来只剩下在Activity中进行使用。

class ContactsActivity : AppCompatActivity() {
 
    private lateinit var mViewModel: ContactsViewModel
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_contacts_layout)
        setupViewModel()
    }
    
    private fun setupViewModel() {
        mViewModel = ViewModelProviders.of(this)[ContactsViewModel::class.java]
        //active STARTED、RESUMED
        mViewModel.getContacts(true).observe(this,
                Observer {
                    //todo ...
                })
        mViewModel.message.observe(this,
                Observer {
                    //todo ...
                })
    }   
}

实际上咱们只需一行代码就能够获取到ViewModel的实例，经过ViewModelProviders.of()方法传入Activity对象，它会返回一个ViewModelProvider对象，而后咱们再使用它的get()来根据不一样的ViewModel的Class对象来获取到相应的ViewModel实例。

只要Activity对象没有改变，同时都是同一个ViewModel的Class对象，那么咱们不管什么时候获取的都是同一个ViewModel实例。这就实现了在Activity中的ViewModel持久化特性。因为ViewModel是同一个，天然它里面的数据也是同一份。

获得ViewModel后，剩下的就是对数据的操做与响应。这里结合了LiveData因此方便了许多。

LiveData之间已经有详细介绍，如需了解能够查看文章末的连接。

ViewModelProvider

到这里我想你心中可能会有以下几个疑问

1. ViewModel它是如何初始化的，对象是如何实例化的
2. 如何向ViewModel中传递初始化的参数

这两个疑问都将由ViewModelProvider来解决。

咱们回到获取ViewModelProvider的ViewModelProviders.of()方法，进入源码查看。

@NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        Application application = checkApplication(activity);
        if (factory == null) {
            factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
        }
        return new ViewModelProvider(ViewModelStores.of(activity), factory);
    }

咱们也没有发现咱们想要的代码，但咱们发现factory。咱们在获取ViewModel时并无传入factory，因此它会走空判断里面的代码，建立一个默认的factory。那么咱们再进入ViewModelProvider中查看静态内部类AndroidViewModelFactory

public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {

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

咱们只看关键代码，它继承于NewInstanceFactory，其中只有一个方法create()。AndroidViewModelFactory从新实现了create()，在重写的方法中咱们找到了咱们想要的方法调用。在这里它经过Class的getConstructor()方法获取匹配的Constructor对象，而后再经过newInstance()方法来获取匹配的对象实例。这样咱们所须要的ViewModel实例就建立了，第一个疑问就此解决。

至于第二个疑问，细心的话不难发现，上面在调用newInstance()方法时已经传了一个初始化的参数mApplication。因此若是咱们要再传入其它自定义的初始化参数，只需实现咱们本身的create()方法。要自定义create()方法，咱们就要自定义一个factory，继承NewInstanceFactory类。

下面是实现ContactsViewModel在初始化时传入特定的title值

class ContactsFactory(private val application: Application) : ViewModelProvider.NewInstanceFactory() {
 
    companion object {
        @SuppressLint("StaticFieldLeak")
        private var instance: ContactsFactory? = null
 
        fun getInstance(application: Application): ContactsFactory {
            if (instance == null) {
                instance = ContactsFactory(application)
            }
            return instance as ContactsFactory
        }
    }
 
    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(ContactsViewModel::class.java)) {
            return ContactsViewModel(application, "Factory Contacts") as T
        }
        return super.create(modelClass)
    }
}

重点天然是create()方法，经过isAssignableFrom()方法判断须要实例化的类型，因为咱们可以明确到具体的类，因此能够直接使用正常的类实例化操做。已经有了factory，最后在获取ViewModel时传入便可

mViewModel = ViewModelProviders.of(this, ContactsFactory.getInstance(application))[ContactsViewModel::class.java]

ViewModel就是这么简单，但它对数据的持久化却异常突出。是否已经火烧眉毛了呢？赶忙来试试它的特性吧。

总结

最后Android Architecture Components(AAC)系列到此就告一段落了，让咱们来回顾一下AAC。咱们经过Room能够快速方便的实现本地数据存储；结合LiveData来观测数据的更新变化与及时反映到UI层；同时使用Lifecycle来让咱们的组件或数据容器的具有生命感知能力，帮助咱们的减小生命状态的处理与异常错误的发生；最后将界面数据存储到ViewModel中，使得数据达到持久化，减小没必要要的数据请求与资源消耗。

下面的可以初步体现使用AAC后的App项目架构形态

最后感谢你们对AAC架构系列的支持！若是感受不错的话，能够帮忙点赞收藏一下或者关注个人公众号。同时文章中的代码均可以在Github中获取到。使用时请将分支切换到feat_architecture_components

相关文章

Android Architecture Components Part1:Room
Android Architecture Components Part2:LiveData
Android Architecture Components Part3:Lifecycle

关注

私人博客