Android开发框架MVC-MVP-MVVM-MVI的演变Demo

  

Android框架的历史演变

记得最开始入门Android的时候，还未流行MVP，都是MVC一把梭，后面工作了就是使用了MVP，当时学习的时候好难理解它的回调。

到目前主流的MVVM，其实就是MVP的升级版，再到最新的MVI使用意图传输，隔离各层级的直接调用。我算是经历了Android框架变迁的全过程。

这里记录一下各框架的简单Demo用例。

一. MVC框架

经典MVC分为：

Model 模型层 ： 数据和网络

View 视图层 ： 视图的展示

Controller 控制层 ： 逻辑控制，调用模型驱动视图

一般我们是把一个xml看作一个View层, Activity看作一个Control层 , Model层则是由相关的数据操作类。

Model层：

class OtherModel : BaseRepository() {
    /**
     * 使用扩展方法，请求网络
     */
    suspend inline fun getIndustry(): OkResult<List<Industry>> {
        return extRequestHttp {
            DemoRetrofit.apiService.getIndustry(
                Constants.NETWORK_CONTENT_TYPE,
                Constants.NETWORK_ACCEPT_V1
            )
        }
    }
}

Controller层：

class MVCActivity : AbsActivity() {
    private val mOtherModel: OtherModel by lazy { OtherModel() }
    override fun setContentView() {
        setContentView(R.layout.activity_demo14_1)
    }
    override fun init() {
        val btnGetData = findViewById<Button>(R.id.btn_get_data)
        btnGetData.click {
            requestIndustry()
        }
    }
    private fun requestIndustry() {
        //MVC中Activity就是Controller,直接调用接口，获取数据之后直接操作xml控件刷新
        lifecycleScope.launch {
            //开始Loading
            LoadingDialogManager.get().showLoading(this@MVCActivity)
            val result = mOtherModel.getIndustry()
            result.checkSuccess {
                //处理成功的信息
                toast("list:$it")
                //doSth...
            }
            LoadingDialogManager.get().dismissLoading()
        }
    }
}

XML就是View层，获取到信息展示到XML中。

这样分工其实也是很明确的，但是一旦逻辑过多，会导致Activity太臃肿。Activcity中又是Model又是View，耦合性太强，记得那时候一个Activity中上千行代码都是平平常常。

为了解决这个问题，大家开始使用MVP架构。

二. MVP框架

MVP框架的出现，各个模块权责分明，各干各的活，降低了耦合，减少Activity的臃肿。

Model层：还是MVC那个Model。
View层：接口定义由Activity实，用于操作相应的UI。
Presenter层：用于Model和View的桥梁，负责Model与View的交互

那更复杂的一点的，就是其中加入Contract契约类，把指定页面的Presenter和View等关联起来，方便维护。

View接口定义：

interface IDemoView {
    fun showLoading()
    fun hideLoading()
    fun getIndustrySuccess(list: List<Industry>?)
    fun getIndustryFailed(msg: String?)
}

Presenter的实现：

class DemoPresenter(private val view: IDemoView) {
    private val mOtherModel: OtherModel by lazy { OtherModel() }
    //获取行业数据
    fun requestIndustry(lifecycleScope: LifecycleCoroutineScope) {
        lifecycleScope.launch {
            //开始Loading
            view.showLoading()
            val result = mOtherModel.getIndustry()
            result.checkResult({
                //处理成功的信息
                toast("list:$it")
                view.getIndustrySuccess(it)
            }, {
                //失败
                view.getIndustryFailed(it)
            })
            view.hideLoading()
        }
    }
}

Activity的实现：

class MVPActivity : AbsActivity(), IDemoView {
    private lateinit var mPresenter: DemoPresenter
    override fun setContentView() {
        setContentView(R.layout.activity_demo14_1)
    }
    override fun init() {
        //创建Presenter
        mPresenter = DemoPresenter(this)
        val btnGetData = findViewById<Button>(R.id.btn_get_data)
        btnGetData.click {
            //通过Presenter调用接口
            mPresenter.requestIndustry(lifecycleScope)
        }
    }
    //回调再次触发
    override fun showLoading() {
        LoadingDialogManager.get().showLoading(this)
    }
    override fun hideLoading() {
        LoadingDialogManager.get().dismissLoading()
    }
    override fun getIndustrySuccess(list: List<Industry>?) {
        //popupIndustryData
    }
    override fun getIndustryFailed(msg: String?) {
        //showErrorMessage
    }
}

当时MVP框架是火遍一时，当时面试要不会这个，那都不好意思说是做安卓的。

虽然它有一些缺点，比如太复杂，每次都要写重复的View，修改麻烦，回调地狱，数据交互体验不佳，无法感知生命周期，重建页面无法自动恢复数据，耦合还是有很多，等等。但是在当时没有替代品的选择下，它是当之无愧的王。

但是当谷歌出了Jetpack，当ViewModel+LiveData+Lifecycles的出现给了我们新的选择 MVVM框架开始出现并迅猛发展。

三. MVVM框架

这里先说一点有争议的点。 有些人认为，只要用上ViewModel+LiveData这些就算MVVM框架 Model+View+ViewModel嘛。 有些人认为，MVVM的意思是数据驱动，最大的亮点是数据绑定，使用DataBinding的才算MVVM。 其实这个也没有官方的定义，世上本无框架，用的人多了才出现框架名字，约定俗成的东西，你想怎么定义就怎么定义，那我姑且称为前者为半MVVM后者为MVVM吧

3.1 半MVVM框架

其实可以理解为MVP的升级版，去掉了View的接口回调，保存了ViewModel的特性

Model层：还是MVC那个Model。
View层：Activity，用于操作相应的UI。
ViewModel：还是MVP那个Presenter，只是用ViewModel实现。

ViewModel实现: 可以看到代码确实相比MVP少了很多

class DemoViewModel @ViewModelInject constructor(
    private val mRepository: Demo5Repository,
    @Assisted val savedState: SavedStateHandle
) : BaseViewModel() {
    val liveData = MutableLiveData<List<Industry>?>()
    //获取行业数据
    fun requestIndustry() {
        viewModelScope.launch {
            //开始Loading
            loadStartLoading()
            val result = mRepository.getIndustry()
            result.checkResult({
                //处理成功的信息
                toast("list:$it")
                liveData.value = it
            }, {
                //失败
                liveData.value = null
            })
            loadHideProgress()
        }
    }
}

Activity的实现：

@AndroidEntryPoint
class MVVMActivity : BaseVMActivity<DemoViewModel>() {
    override fun getLayoutIdRes(): Int = R.layout.activity_demo14_1
    override fun init() {
        //自动注入ViewModel，调用接口通过LiveData回调
        mViewModel.requestIndustry()
    }
    override fun startObserve() {
        //获取到网络数据之后改变xml对应的值
        mViewModel.liveData.observe(this) {
            it?.let {
                // popopIndustryData
            }
        }
    }
}

3.2 带DataBinding的MVVM框架

特别是现在kotlin那种直接拿id使用的插件已经被官方标记为过时，还不赶紧用DataBinding或ViewBinding？

ViewModel实现:

class DemoViewModel @ViewModelInject constructor(
    private val mRepository: Demo5Repository,
    @Assisted val savedState: SavedStateHandle
) : BaseViewModel() {
    val liveData = MutableLiveData<List<Industry>?>()
    //获取行业数据
    fun requestIndustry() {
        viewModelScope.launch {
            //开始Loading
            loadStartLoading()
            val result = mRepository.getIndustry()
            result.checkResult({
                //处理成功的信息
                toast("list:$it")
                liveData.value = it
            }, {
                //失败
                liveData.value = null
            })
            loadHideProgress()
        }
    }
}

Repository的实现：其实和Model差不多的意思，数据仓库而已，下面的一些注解是用到了Hilt依赖注入，不用直接new对象也是可以的，不要在意一些细节。

@Singleton
class Demo5Repository @Inject constructor() : BaseRepository() {
    suspend inline fun getIndustry(): OkResult<List<Industry>> {
        return extRequestHttp {
            DemoRetrofit.apiService.getIndustry(
                Constants.NETWORK_CONTENT_TYPE,
                Constants.NETWORK_ACCEPT_V1
            )
        }
    }
}

Activity的实现： 内部做了一些基类的封装，事件处理封装为对象，viewmodel和事件对象在xml中做了引用

@AndroidEntryPoint
class MVVM2Activity : BaseVDBActivity<DemoViewModel, ActivityDemo142Binding>() {
    private val clickProxy: ClickProxy by lazy { ClickProxy() }
    override fun getDataBindingConfig(): DataBindingConfig {
        return DataBindingConfig(R.layout.activity_demo14_2, BR.viewModel, mViewModel)
            .addBindingParams(BR.click, clickProxy)
    }
    override fun init() {
    }
    override fun startObserve() {
    }
    /**
     * DataBinding事件处理
     */
    inner class ClickProxy {
        fun getData() {
            //MVVM直接调用网络请求，结果在xml中自动显示
            mViewModel.requestIndustry()
        }
    }
}

Xml的实现： 注意引用指向的包名要写对，写对了可以直接跳转过去的。

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:binding="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">
    <data>
        <variable
            name="viewModel"
            type="com.guadou.kt_demo.demo.demo14_mvi.mvvm1.DemoViewModel" />
        <variable
            name="click"
            type="com.guadou.kt_demo.demo.demo14_mvi.mvvm2.MVVM2Activity.ClickProxy" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/picture_color_blue"
        android:orientation="vertical">
        <com.guadou.lib_baselib.view.titlebar.StatusbarGrayView
            android:id="@+id/status_view"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="获取数据"
            binding:clicks="@{click.getData}" />
        <TextView
            android:id="@+id/tv_message"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{viewModel.liveData.toString()}" />
    </LinearLayout>
</layout>

这样就完成了一个基于数据驱动的DataBinding的MVVM。 如果上面一些代码如果看不太明白，后面我可能会出DataBinding的封装并开源。

截止到发稿日期为止，目前市面上最流行的还是MVVM框架，此框架唯一的槽点可能就是Databinding的不好调试吧，一旦出问题，有时候报错信息莫名其妙的，没有指向XML中某个数据或语法的错误，需要对DataBinding有一定的了解。 不过AS现在貌似越来越智能了，报错信息都还指向蛮清晰的。MVVM完全可用的。

四. MVI框架

由于是出来没多久，具体是不是叫MVI框架这个名字还不确定，大家都这么叫，姑且就叫MVI吧。伴随Compose出现的框架，主流用于Compose应用。

MVI框架是由Model View Intent组成的。可以算上MVVM的升级版，在之前我们都是通过在Activity中直接调用ViewModel的方法，现在改为发出操作指令，由ViewModel解析指令，调用对应的方法，回调给Activity。

比如一个DemoActivity需要获取行业数据，学校数据，等。那么就可以把数据和操作都封装成指定的对象。

    //当前页面所需的数据与状态
    data class Demo14ViewState(
        val industrys: List<Industry> = emptyList(),
        val schools: List<SchoolBean> = emptyList(),
        var isChanged: Boolean = false
    ) : BaseViewState()
    //当前页面需要的事件定义
    sealed class DemoAction {
        object RequestIndustry : DemoAction()
        object RequestSchool : DemoAction()
        object RequestAllData : DemoAction()
        data class UpdateChanged(val isChange: Boolean) : DemoAction()
    }

Activity调用相关的接口就不是直接调用ViewModel的方法，而是：

   override fun init() {
        //发送Intent指令，具体的实现由ViewModel实现
        mViewModel.dispatch(Damo14ViewModel.DemoAction.RequestAllData)
    }

那么ViewModel就需要解析指令：

    //Action分发入口
    fun dispatch(action: DemoAction) {
        when (action) {
            is DemoAction.RequestIndustry -> requestIndustry()
            is DemoAction.RequestSchool -> requestSchool()
            is DemoAction.RequestAllData -> getTotalData()
            is DemoAction.UpdateChanged -> changeData(action.isChange)
        }
    }
    //获取行业数据
    private fun requestIndustry() {
      //xxx
    }

完整的代码如下：

ViewModel的实现：

class Damo14ViewModel @ViewModelInject constructor(
    private val mRepository: Demo5Repository,
    @Assisted val savedState: SavedStateHandle
) : BaseViewModel() {
    private val _viewStates: MutableLiveData<Demo14ViewState> = MutableLiveData(Demo14ViewState())
    //只需要暴露一个LiveData，包括页面所有状态
    val viewStates: LiveData<Demo14ViewState> = _viewStates
    //Action分发入口
    fun dispatch(action: DemoAction) {
        when (action) {
            is DemoAction.RequestIndustry -> requestIndustry()
            is DemoAction.RequestSchool -> requestSchool()
            is DemoAction.RequestAllData -> getTotalData()
            is DemoAction.UpdateChanged -> changeData(action.isChange)
        }
    }
    //获取行业数据
    private fun requestIndustry() {
        viewModelScope.launch {
            //开始Loading
            loadStartLoading()
            val result = mRepository.getIndustry()
            result.checkSuccess {
                _viewStates.setState {
                    copy(industrys = it ?: emptyList())
                }
            }
            loadHideProgress()
        }
    }
    //获取学校数据
    private fun requestSchool() {
        viewModelScope.launch {
            //开始Loading
            loadStartLoading()
            val result = mRepository.getSchool()
            result.checkSuccess {
                _viewStates.setState {
                    copy(schools = it ?: emptyList())
                }
            }
            loadHideProgress()
        }
    }
    //获取全部数据
    private fun getTotalData() {
        //默认执行在主线程的协程-必须用（可选择默认执行在IO线程的协程）
        launchOnUI {
            //开始Loading
            loadStartProgress()
            val industryResult = async {
                mRepository.getIndustry()
            }
            val schoolResult = async {
                mRepository.getSchool()
            }
            //一起处理数据
            val industry = industryResult.await()
            val school = schoolResult.await()
            //如果都成功了才一起返回
            if (industry is OkResult.Success && school is OkResult.Success) {
                loadHideProgress()
                //设置多种LiveData
                _viewStates.setState {
                    copy(industrys = industry.data ?: emptyList(), schools = school.data ?: emptyList())
                }
            }
        }
    }
    //改变状态
    private fun changeData(isChanged: Boolean) {
        _viewStates.setState {
            copy(isChanged = isChanged)
        }
    }
    //当前页面所需的数据与状态
    data class Demo14ViewState(
        val industrys: List<Industry> = emptyList(),
        val schools: List<SchoolBean> = emptyList(),
        var isChanged: Boolean = false
    ) : BaseViewState()
    //如果想再度封装，也可以把回调的结果封装成类似Action的对象，由页面判断回调的是哪一种类型，进行相关的操作
    //这样就不需要使用LiveData回调了，LiveData就只是作为保存数据的功能，由DemoEvent回调
//    sealed class DemoEvent {
//        object PopBack : DemoEvent()
//        data class ErrorMessage(val message: String) : DemoEvent()
//    }
    //当前页面需要的事件定义
    sealed class DemoAction {
        object RequestIndustry : DemoAction()
        object RequestSchool : DemoAction()
        object RequestAllData : DemoAction()
        data class UpdateChanged(val isChange: Boolean) : DemoAction()
    }
}

Activity的实现：

@AndroidEntryPoint
class Demo14Activity : BaseVDBActivity<Damo14ViewModel, ActivityDemo14Binding>() {
    private val clickProxy: ClickProxy by lazy { ClickProxy() }
    companion object {
        fun startInstance() {
            commContext().let {
                it.startActivity(Intent(it, Demo14Activity::class.java).apply {
                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                })
            }
        }
    }
    override fun getDataBindingConfig(): DataBindingConfig {
        return DataBindingConfig(R.layout.activity_demo14)
            .addBindingParams(BR.click, clickProxy)
    }
    @SuppressLint("SetTextI18n")
    override fun startObserve() {
        //监听两者数据变化
        mViewModel.viewStates.observeState(
            this,
            Damo14ViewModel.Demo14ViewState::industrys,
            Damo14ViewModel.Demo14ViewState::schools
        ) { industry, school ->
            YYLogUtils.w("industry: $industry ; school: $school")
        }
        //只监听changed的变换
        mViewModel.viewStates.observeState(this, Damo14ViewModel.Demo14ViewState::isChanged) {
            if (it) {
                val industry = mViewModel.viewStates.value?.industrys
                val school = mViewModel.viewStates.value?.schools
                mBinding.tvMessage.text = "industry: $industry ; school: $school"
            }
        }
    }
    override fun init() {
        //发送Intent指令，具体的实现由ViewModel实现
        mViewModel.dispatch(Damo14ViewModel.DemoAction.RequestAllData)
    }
    /**
     * DataBinding事件处理
     */
    inner class ClickProxy {
        fun getData() {
            //发送Intent指令，具体的实现由ViewModel实现
//            mViewModel.dispatch(Damo14ViewModel.DemoAction.RequestIndustry)
//            mViewModel.dispatch(Damo14ViewModel.DemoAction.RequestSchool)
            mViewModel.dispatch(Damo14ViewModel.DemoAction.UpdateChanged(true))
        }
    }
}

注意，有些MVI的写法是回调给Activity的方式也是用对象封装如我注释的代码：

    //如果想再度封装，也可以把回调的结果封装成类似Action的对象，由页面判断回调的是哪一种类型，进行相关的操作
    //这样就不需要使用LiveData回调了，LiveData就只是作为保存数据的功能，由DemoEvent回调
//    sealed class DemoEvent {
//        object PopBack : DemoEvent()
//        data class ErrorMessage(val message: String) : DemoEvent()
//    }

也可以使用LiveData返回，我这里使用扩展方法observeState方法来监听，这样可以保证只有你监听的对象发生了变化才会收到回调。这个扩展方法在MVVM框架也能使用。

扩展方法如下：

import androidx.lifecycle.*
import kotlin.reflect.KProperty1
/**
 * @auther Newki
 * @date 2022/2/10
 * @description LiveData的扩展 支持MVI模式 订阅单个LiveData实现监听不同的操作与数据
 */
//监听一个属性
fun <T, A> LiveData<T>.observeState(
    lifecycleOwner: LifecycleOwner,
    prop1: KProperty1<T, A>,
    action: (A) -> Unit
) {
    this.map {
        StateTuple1(prop1.get(it))
    }.distinctUntilChanged().observe(lifecycleOwner) { (a) ->
        action.invoke(a)
    }
}
//监听两个属性
fun <T, A, B> LiveData<T>.observeState(
    lifecycleOwner: LifecycleOwner,
    prop1: KProperty1<T, A>,
    prop2: KProperty1<T, B>,
    action: (A, B) -> Unit
) {
    this.map {
        StateTuple2(prop1.get(it), prop2.get(it))
    }.distinctUntilChanged().observe(lifecycleOwner) { (a, b) ->
        action.invoke(a, b)
    }
}
//监听三个属性
fun <T, A, B, C> LiveData<T>.observeState(
    lifecycleOwner: LifecycleOwner,
    prop1: KProperty1<T, A>,
    prop2: KProperty1<T, B>,
    prop3: KProperty1<T, C>,
    action: (A, B, C) -> Unit
) {
    this.map {
        StateTuple3(prop1.get(it), prop2.get(it), prop3.get(it))
    }.distinctUntilChanged().observe(lifecycleOwner) { (a, b, c) ->
        action.invoke(a, b, c)
    }
}
internal data class StateTuple1<A>(val a: A)
internal data class StateTuple2<A, B>(val a: A, val b: B)
internal data class StateTuple3<A, B, C>(val a: A, val b: B, val c: C)
//更新State
fun <T> MutableLiveData<T>.setState(reducer: T.() -> T) {
    this.value = this.value?.reducer()
}

太干了，一张图都没上，最后总结一下：

世界上本无框架，用的人多了就成了框架，适合自己的才是好的。不是一定说出了最新框架我就要用最新的框架，理解之后再使用才能得心应手。

个人目前平时开发中用的也是MVVM框架。后期会出一些MVVM的封装和用法开源。

以上就是Android开发框架MVC-MVP-MVVM-MVI的演变Demo的详细内容，更多关于Android框架MVC MVP MVVM MVI的资料请关注编程学习网其它相关文章！

相关文章
移动开发最新文章
热门教程
© 2023-2024 沃梦达编程网 版权所有并保留所有权 ICP备案号：粤ICP备14083021号 SiteMap 本站部分内容来源互联网,如果有图片或者内容侵犯您的权益请联系我们删除！