• Android MVC、MVP、MVVM、MVI架构对比及示例

    随着Android应用开发技术的不断成熟，应用功能越来越丰富，迭代速度要求的越来越高，应用的开发架构也在不断演进、优化，从MVC、MVP到MVVM，到如今的MVI。谷歌官方也在不断推广、优化适合Android平台的开发架构，并推出了一系列的组件如Jetpack来支撑其架构的演进。

    但不管架构如何演进，其本质目的就是尽量解耦各模块、各业务之间的依赖，消除样板代码，让开发人员专注于业务开发，快速、高效、高质量完成应用的开发。

    所以在了解各架构之前，我们还是要先回顾一下面向对象六大原则

    面向对象六大原则

    单一职责原则 Single Responsibility Principle

    一个类中应该是一组相关性很高的函数、数据的封装

    开闭原则 Open Close Principle

    软件中的对象（类、模块、函数等）应该对于扩展是开发的，但是对于修改是封闭的。

    里氏替换原则 Liskov Substitution Principle

    所有引用基类的地方必须能透明地使用其子类地对象。

    依赖倒置原则 Dependence Inversion Principle

    指代了一种特定的解耦形式，使得高层次的模块不依赖于低层次的模块的实现细节的目的，依赖模块被颠倒了。

    1.  高层模块不应该依赖低层模块，两者都应该依赖其抽象
    2.  抽象不应该依赖细节
    3.  细节应该依赖抽象

    在java语音中，抽象就是指接口或抽象类，细节就是实现类，高层模块就是调用端，低层模块就是具体实现类
    依赖倒置：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。

    接口隔离原则 Interface Segregation Principe

    客户端不应该依赖它不需要的接口。
    类间的依赖关系应该建立在最小的接口上。

    迪米特原则 Law of Demeter

    一个对象应该对其他对象有最少的了解。

    MVC

    视图层（View）：对应于XML布局文件和java代码动态添加、删除view的部分

    控制层（Controller）：主要负责业务逻辑，在android中由Activity、Fragment、Service等承担，同时因为XML视图功能太弱，所以Activity/Fragment等既要负责视图的显示，还要加入控制逻辑，业务处理等，承担了太多的功能。

    模型层（Model）：主要负责网络请求，数据库处理，I/O的操作，即页面的数据来源 

    存在问题：

    1. Activity/Fragment同时负责View与Controller层的工作，违背了单一职责原则
    2. Model层与View层存在耦合，存在互相依赖，违背了迪米特原则

    以下都是以登录功能为例

    1. class MVCDemoActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    2.  
    3.     private lateinit var usernameEdit: EditText
    4.     private lateinit var passwordEdit: EditText
    5.     private lateinit var usernameText: TextView
    6.     private lateinit var passwordText: TextView
    7.     private lateinit var loginBtn: Button
    8.  
    9.     private var username: String = ""
    10.     private var password: String = ""
    11.  
    12.     private var loadingDialog: LoadingDialog? = null
    13.  
    14.     override fun onCreate(savedInstanceState: Bundle?) {
    15.         super.onCreate(savedInstanceState)
    16.         setContentView(R.layout.activity_mvc)
    17.  
    18.         initViews()
    19.     }
    20.  
    21.     private fun initViews() {
    22.  
    23.         usernameText = findViewById(R.id.tv_username)
    24.         passwordText = findViewById(R.id.tv_password)
    25.  
    26.         usernameEdit = findViewById(R.id.edit_username)
    27.         usernameEdit.afterTextChanged {
    28.             username = it
    29.         }
    30.  
    31.         passwordEdit = findViewById(R.id.edit_password)
    32.         passwordEdit.afterTextChanged {
    33.             password = it
    34.         }
    35.  
    36.         loginBtn = findViewById(R.id.btn_login)
    37.         loginBtn.setOnClickListener {
    38.             doLogin()
    39.         }
    40.     }
    41.  
    42.     @SuppressLint("SetTextI18n")
    43.     private fun doLogin() {
    44.         showLoading(true)
    45.         launch(Dispatchers.IO) {
    46.             when (val loginResult = HttpUtil.login(username, password)) {
    47.                 is LoginResult.Success -> {
    48.                     runOnUiThread {
    49.                         usernameEdit.visibility = View.GONE
    50.                         passwordEdit.visibility = View.GONE
    51.                         loginBtn.visibility = View.GONE
    52.  
    53.                         usernameText.text =
    54.                             getString(R.string.username) + loginResult.userInfo.userName
    55.                         passwordText.text =
    56.                             getString(R.string.password) + loginResult.userInfo.password
    57.  
    58.                         showLoading(false)
    59.                         showToast("登录成功")
    60.                     }
    61.  
    62.                 }
    63.                 is LoginResult.Fail -> {
    64.                     runOnUiThread {
    65.                         showLoading(false)
    66.                         showToast(loginResult.message)
    67.                     }
    68.                 }
    69.             }
    70.         }
    71.  
    72.     }
    73.  
    74. }
    75.  
    1. <--activity_mvc.xml-->
    2. "1.0" encoding="utf-8"?>
    3. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    4.     xmlns:app="http://schemas.android.com/apk/res-auto"
    5.     android:layout_width="match_parent"
    6.     android:layout_height="match_parent">
    7.  
    8.     <TextView
    9.         android:id="@+id/tv_username"
    10.         android:layout_width="wrap_content"
    11.         android:layout_height="wrap_content"
    12.         android:layout_marginStart="16dp"
    13.         android:layout_marginBottom="20dp"
    14.         android:text="@string/username"
    15.         android:textSize="24sp"
    16.         android:textStyle="bold"
    17.         app:layout_constraintBottom_toTopOf="@+id/tv_password"
    18.         app:layout_constraintStart_toStartOf="parent"
    19.         app:layout_constraintTop_toTopOf="parent"
    20.         app:layout_constraintVertical_chainStyle="packed" />
    21.  
    22.     <EditText
    23.         android:id="@+id/edit_username"
    24.         android:layout_width="0dp"
    25.         android:layout_height="wrap_content"
    26.         android:layout_marginStart="8dp"
    27.         android:layout_marginEnd="16dp"
    28.         app:layout_constraintBottom_toBottomOf="@+id/tv_username"
    29.         app:layout_constraintEnd_toEndOf="parent"
    30.         app:layout_constraintStart_toEndOf="@+id/tv_username"
    31.         app:layout_constraintTop_toTopOf="@+id/tv_username" />
    32.  
    33.     <TextView
    34.         android:id="@+id/tv_password"
    35.         android:layout_width="wrap_content"
    36.         android:layout_height="wrap_content"
    37.         android:layout_marginStart="16dp"
    38.         android:layout_marginBottom="20dp"
    39.         android:text="@string/password"
    40.         android:textSize="24sp"
    41.         android:textStyle="bold"
    42.         app:layout_constraintBottom_toTopOf="@+id/btn_login"
    43.         app:layout_constraintStart_toStartOf="parent"
    44.         app:layout_constraintTop_toBottomOf="@+id/tv_username" />
    45.  
    46.     <EditText
    47.         android:id="@+id/edit_password"
    48.         android:layout_width="0dp"
    49.         android:layout_height="wrap_content"
    50.         app:layout_constraintBottom_toBottomOf="@+id/tv_password"
    51.         app:layout_constraintEnd_toEndOf="@+id/edit_username"
    52.         app:layout_constraintStart_toStartOf="@+id/edit_username"
    53.         app:layout_constraintTop_toTopOf="@+id/tv_password" />
    54.  
    55.     <Button
    56.         android:id="@+id/btn_login"
    57.         android:layout_width="match_parent"
    58.         android:layout_height="wrap_content"
    59.         android:layout_marginHorizontal="16dp"
    60.         android:text="@string/login"
    61.         app:layout_constraintBottom_toBottomOf="parent"
    62.         app:layout_constraintTop_toBottomOf="@+id/tv_password" />
    63.  
    64. androidx.constraintlayout.widget.ConstraintLayout>

    从上面的代码可以看出，所有的业务逻辑以及UI更新都放在了Activity中，如果功能简单还比较容易维护，但随着功能越来越复杂，Activity的代码量会成倍的膨胀，并且业务逻辑会交织在一起，越来混乱。

    为了解决上面的问题，MVP就推广开了。

    MVP

    View层：对应于Activity与XML,只负责显示UI,只与Presenter层交互，与Model层没有耦合

    Presenter层： 主要负责处理业务逻辑，通过接口调用Model层获取数据，并回调View层

    Model层：主要负责网络请求，数据库处理，I/O的操作，即页面的数据来源

    存在问题：

    1. Presenter层通过接口与View通信，实际上持有了View的引用
    2. 随着业务逻辑的增加，页面的复杂度及页面的数量增加，会造成View的接口很庞大。

     登录示例代码

    1. class MVPDemoActivity : AppCompatActivity(), LoginContact.LoginView {
    2.  
    3.     private lateinit var loginPresenter: LoginContact.LoginPresenter
    4.  
    5.     private lateinit var usernameEdit: EditText
    6.     private lateinit var passwordEdit: EditText
    7.     private lateinit var usernameText: TextView
    8.     private lateinit var passwordText: TextView
    9.     private lateinit var loginBtn: Button
    10.  
    11.     private var username: String = ""
    12.     private var password: String = ""
    13.  
    14.     private var loadingDialog: LoadingDialog? = null
    15.  
    16.     override fun onCreate(savedInstanceState: Bundle?) {
    17.         super.onCreate(savedInstanceState)
    18.         setContentView(R.layout.activity_mvp)
    19.  
    20.         loginPresenter = LoginPresenterImp(this)
    21.  
    22.         initViews()
    23.     }
    24.  
    25.     private fun initViews() {
    26.  
    27.         usernameText = findViewById(R.id.tv_username)
    28.         passwordText = findViewById(R.id.tv_password)
    29.  
    30.         usernameEdit = findViewById(R.id.edit_username)
    31.         usernameEdit.afterTextChanged {
    32.             username = it
    33.         }
    34.  
    35.         passwordEdit = findViewById(R.id.edit_password)
    36.         passwordEdit.afterTextChanged {
    37.             password = it
    38.         }
    39.  
    40.         loginBtn = findViewById(R.id.btn_login)
    41.         loginBtn.setOnClickListener {
    42.             loginPresenter.login(username, password)
    43.         }
    44.     }
    45.  
    46.     override fun showSuccess(userInfo: UserInfo) {
    47.         runOnUiThread {
    48.             usernameEdit.visibility = View.GONE
    49.             passwordEdit.visibility = View.GONE
    50.             loginBtn.visibility = View.GONE
    51.  
    52.             usernameText.text = getString(R.string.username) + userInfo.userName
    53.             passwordText.text = getString(R.string.password) + userInfo.password
    54.  
    55.             showToast("登录成功")
    56.         }
    57.     }
    58.  
    59.     override fun showFail(message: String) {
    60.         runOnUiThread {
    61.             showToast(message)
    62.         }
    63.     }
    64.  
    65.     override fun showLoading(show: Boolean) {
    66.         if (show) {
    67.             loadingDialog = LoadingDialog(this)
    68.             loadingDialog?.show()
    69.         } else {
    70.             loadingDialog?.cancel()
    71.             loadingDialog = null
    72.         }
    73.     }
    74. }
    1. interface LoginContact {
    2.  
    3.     interface LoginModel {
    4.         suspend fun login(username: String, password: String)
    5.     }
    6.  
    7.     interface LoginView {
    8.         fun showSuccess(userInfo: UserInfo)
    9.         fun showFail(message: String)
    10.         fun showLoading(show: Boolean)
    11.     }
    12.  
    13.     interface LoginPresenter {
    14.         fun login(username: String, password: String)
    15.         fun onLoginSuccess(userInfo: UserInfo)
    16.         fun onLoginFail(message: String)
    17.     }
    18. }
    1. class LoginPresenterImp(private val loginView: LoginContact.LoginView) :
    2.     LoginContact.LoginPresenter,
    3.     CoroutineScope by MainScope() {
    4.  
    5.     private val loginModel: LoginContact.LoginModel
    6.  
    7.     init {
    8.         loginModel = LoginModelImpl(this)
    9.     }
    10.  
    11.     override fun login(username: String, password: String) {
    12.         loginView.showLoading(true)
    13.         launch(Dispatchers.IO) {
    14.             loginModel.login(username, password)
    15.         }
    16.     }
    17.  
    18.     override fun onLoginSuccess(userInfo: UserInfo) {
    19.         loginView.showLoading(false)
    20.         loginView.showSuccess(userInfo)
    21.     }
    22.  
    23.     override fun onLoginFail(message: String) {
    24.         loginView.showLoading(false)
    25.         loginView.showFail(message)
    26.     }
    27. }
    1. class LoginModelImpl(private val loginPresenter: LoginContact.LoginPresenter) : LoginContact.LoginModel {
    2.  
    3.     override suspend fun login(username: String, password: String) {
    4.         when (val loginResult = HttpUtil.login(username, password)) {
    5.             is LoginResult.Success -> {
    6.                 loginPresenter.onLoginSuccess(loginResult.userInfo)
    7.             }
    8.             is LoginResult.Fail -> {
    9.                 loginPresenter.onLoginFail(loginResult.message)
    10.             }
    11.         }
    12.     }
    13. }

    从上面的代码可以看出，Activity不再与Model模块有交互，只和Presenter进行接口调用，所有的业务逻辑、UI刷新逻辑都由Presenser去实现，但这样就导致了Presenter持有了Activity的引用，存在耦合关系；同时可以看到LoginContact中定义了大量的接口类，随着业务的增加，接口类会几何倍数的增加，维护起来会越发困难。

    为了解决上面的问题，Google开始推广MVVM架构，并为其定制实现了Jetpack组件，为开发人员快速实现MVVM架构提供强大的支持。

    MVVM

    View: 对应于Activity和XML，负责View的绘制以及与用户交互。

    Model:主要负责网络请求，数据库处理，I/O的操作，即页面的数据来源

    ViewModel: 负责完成View与Model间的交互，负责业务逻辑。

    MVVM 模式将 Presenter 改名为 ViewModel，基本上与 MVP 模式完全一致。

    唯一的区别是，它采用双向数据绑定（Data-Binding）：View的变动，自动反映在 ViewModel，反之亦然

    MVVM的两种实现方案：

    1. 使用DataBinding库：使用DataBinding将数据Bean与xml直接绑定在一起，从而实现双向绑定，一方改变就会影响另一方，不需要手动更新UI；同时不再需要fingViewById或ButterKnife，DataBinding可以直接完成；还支持生命周期检测，不需担心界面销毁重建的问题；消除了大量的接口，降低耦合性。
    2. 使用AAC(LiveData)：使用LiveData、LifeCycle、ViewModel、Room等组件，ViewModel中进行数据请求，通过LiveData发送到Activity中，而在Activity中通过LiveData的obseve接收ViewModel穿过来的数据、事件更新UI。

     Jetpack是Google为了解决Android架构问题而引入的，Google官方说的说法：“Jetpack是一套库、工具和指南，可以帮助开发者更轻松地编写应用程序。Jetpack中的组件可以帮助开发者遵循最佳做法、摆脱编写样板代码的工作并简化复杂的任务，以便他们能将精力集中放在业务所需的代码上。”

    Jetpack学习https://blog.csdn.net/gxlgxjhll/category_10836219.html

    Google官方推荐的MVVM架构

    登录示例，采用AAC方案（Google官方推荐）

    1. class MVVMDemoActivity : AppCompatActivity() {
    2.  
    3.     private val viewModel: LoginViewModel by viewModels()
    4.  
    5.     private var loadingDialog: LoadingDialog? = null
    6.  
    7.     private lateinit var binding: ActivityMvvmBinding
    8.     override fun onCreate(savedInstanceState: Bundle?) {
    9.         super.onCreate(savedInstanceState)
    10.         binding = ActivityMvvmBinding.inflate(layoutInflater)
    11.         setContentView(binding.root)
    12.         binding.vm = viewModel
    13.  
    14.         initObserver()
    15.     }
    16.  
    17.     @SuppressLint("SetTextI18n")
    18.     private fun initObserver() {
    19.  
    20.         binding.editUsername.afterTextChanged {
    21.             viewModel.userName = it
    22.         }
    23.  
    24.         binding.editPassword.afterTextChanged {
    25.             viewModel.password = it
    26.         }
    27.  
    28.         viewModel.loginMessage.observe(this) { message ->
    29.             showToast(message)
    30.         }
    31.  
    32.         viewModel.userInfo.observe(this) { userInfo ->
    33.             binding.editUsername.visibility = View.GONE
    34.             binding.editPassword.visibility = View.GONE
    35.             binding.btnLogin.visibility = View.GONE
    36.  
    37.             binding.tvUsername.text = getString(R.string.username) + userInfo.userName
    38.             binding.tvPassword.text = getString(R.string.password) + userInfo.password
    39.         }
    40.  
    41.         viewModel.isLoading.observe(this) { show ->
    42.             showLoading(show)
    43.         }
    44.     }
    45.  
    46. }
    1. <--activity_mvvm.xml-->
    2. "1.0" encoding="utf-8"?>
    3. <layout xmlns:android="http://schemas.android.com/apk/res/android"
    4.     xmlns:app="http://schemas.android.com/apk/res-auto">
    5.  
    6.     <data>
    7.  
    8.         <variable
    9.             name="vm"
    10.             type="com.example.architecture.mvvm.LoginViewModel" />
    11.     data>
    12.  
    13.     <androidx.constraintlayout.widget.ConstraintLayout
    14.         android:layout_width="match_parent"
    15.         android:layout_height="match_parent">
    16.  
    17.         <TextView
    18.             android:id="@+id/tv_username"
    19.             android:layout_width="wrap_content"
    20.             android:layout_height="wrap_content"
    21.             android:layout_marginStart="16dp"
    22.             android:layout_marginBottom="20dp"
    23.             android:text="@string/username"
    24.             android:textSize="24sp"
    25.             android:textStyle="bold"
    26.             app:layout_constraintBottom_toTopOf="@+id/tv_password"
    27.             app:layout_constraintStart_toStartOf="parent"
    28.             app:layout_constraintTop_toTopOf="parent"
    29.             app:layout_constraintVertical_chainStyle="packed" />
    30.  
    31.         <EditText
    32.             android:id="@+id/edit_username"
    33.             android:layout_width="0dp"
    34.             android:layout_height="wrap_content"
    35.             android:layout_marginStart="8dp"
    36.             android:layout_marginEnd="16dp"
    37.             app:layout_constraintBottom_toBottomOf="@+id/tv_username"
    38.             app:layout_constraintEnd_toEndOf="parent"
    39.             app:layout_constraintStart_toEndOf="@+id/tv_username"
    40.             app:layout_constraintTop_toTopOf="@+id/tv_username" />
    41.  
    42.         <TextView
    43.             android:id="@+id/tv_password"
    44.             android:layout_width="wrap_content"
    45.             android:layout_height="wrap_content"
    46.             android:layout_marginStart="16dp"
    47.             android:layout_marginBottom="20dp"
    48.             android:text="@string/password"
    49.             android:textSize="24sp"
    50.             android:textStyle="bold"
    51.             app:layout_constraintBottom_toTopOf="@+id/btn_login"
    52.             app:layout_constraintStart_toStartOf="parent"
    53.             app:layout_constraintTop_toBottomOf="@+id/tv_username" />
    54.  
    55.         <EditText
    56.             android:id="@+id/edit_password"
    57.             android:layout_width="0dp"
    58.             android:layout_height="wrap_content"
    59.             app:layout_constraintBottom_toBottomOf="@+id/tv_password"
    60.             app:layout_constraintEnd_toEndOf="@+id/edit_username"
    61.             app:layout_constraintStart_toStartOf="@+id/edit_username"
    62.             app:layout_constraintTop_toTopOf="@+id/tv_password" />
    63.  
    64.         <Button
    65.             android:id="@+id/btn_login"
    66.             android:layout_width="match_parent"
    67.             android:layout_height="wrap_content"
    68.             android:layout_marginHorizontal="16dp"
    69.             android:onClick="@{() -> vm.login()}"
    70.             android:text="@string/login"
    71.             app:layout_constraintBottom_toBottomOf="parent"
    72.             app:layout_constraintTop_toBottomOf="@+id/tv_password" />
    73.     androidx.constraintlayout.widget.ConstraintLayout>
    74.  
    75. layout>
    1. class LoginViewModel : ViewModel() {
    2.  
    3.     private val repository = LoginRepository()
    4.  
    5.     var userName: String = ""
    6.     var password: String = ""
    7.  
    8.     private val _loginMessage = MutableLiveData()
    9.     val loginMessage: LiveData = _loginMessage
    10.  
    11.     private val _userInfo = MutableLiveData()
    12.     val userInfo: LiveData = _userInfo
    13.  
    14.     private val _isLoading = MutableLiveData<Boolean>()
    15.     val isLoading: LiveData<Boolean> = _isLoading
    16.  
    17.     fun login() {
    18.         viewModelScope.launch(Dispatchers.IO) {
    19.             _isLoading.postValue(true)
    20.             when (val loginResult = repository.login(userName, password)) {
    21.                 is LoginResult.Success -> {
    22.                     _isLoading.postValue(false)
    23.                     _userInfo.postValue(loginResult.userInfo)
    24.                     _loginMessage.postValue("登录成功")
    25.                 }
    26.                 is LoginResult.Fail -> {
    27.                     _isLoading.postValue(false)
    28.                     _loginMessage.postValue(loginResult.message)
    29.                 }
    30.             }
    31.         }
    32.     }
    33. }
    1. class LoginRepository {
    2.  
    3.     suspend fun login(username: String, password: String): LoginResult {
    4.         return HttpUtil.login(username, password)
    5.     }
    6. }

    从上面的代码可以看到，Activity只进行UI更新，Repository负责数据获取，而ViewModel负责业务逻辑，通过LiveData将数据发送到Activity中，各组件已最小的持有其他引用。

    但这种架构还是存在一定的问题，一是为了保证LiveData数据的更新只在ViewModel中，则必须定义一个私有和一个公开的属性，随着数据的增多，属性会成倍的增加；二是Activity中是通过LiveData的observe方法来更新UI的，而在ViewModel中LiveData数据的更新并没有约束，各种方法里都可能进行更新，使用混乱，难以管理。

    而为了解决上面的问题，Google官方推出了最新的架构，我们姑且称之为MVI吧（我觉得这种说法并不准确）。

    MVI

    要了解MVI架构，首先要先了解两个架构原则。

    单一数据源

    Goolge官方介绍：

    在应用中定义新数据类型时，您应为其分配单一数据源 (SSOT)。SSOT 是该数据的所有者，而且只有此 SSOT 可以修改或转变该数据。为了实现这一点，SSOT 会以不可变类型公开数据；而且为了修改数据，SSOT 会公开函数或接收其他类型可以调用的事件。

    此模式具有多种优势：

    • 将对特定类型数据的所有更改集中到一处。
    • 保护数据，防止其他类型篡改此数据。
    • 更易于跟踪对数据的更改。因此，更容易发现 bug。

    在离线优先应用中，应用数据的单一数据源通常是数据库。在其他某些情况下，单一数据源可以是 ViewModel 甚至是界面。

    单向数据流 

    单一数据源原则常常与单向数据流 (UDF) 模式一起使用。在 UDF 中，状态仅朝一个方向流动。修改数据的事件朝相反方向流动。

    在 Android 中，状态或数据通常从分区层次结构中较高的分区类型流向较低的分区类型。事件通常在分区层次结构中较低的分区类型触发，直到其到达 SSOT 的相应数据类型。例如，应用数据通常从数据源流向界面。用户事件（例如按钮按下操作）从界面流向 SSOT，在 SSOT 中应用数据被修改并以不可变类型公开。

    此模式可以更好地保证数据一致性，不易出错、更易于调试，并且具备 SSOT 模式的所有优势。

    然后我们再看一下Google官方推荐的架构

    基于上一部分提到的常见架构原则，每个应用应至少有两个层：

    • 界面层 - 在屏幕上显示应用数据。
    • 数据层 - 包含应用的业务逻辑并公开应用数据。

    您可以额外添加一个名为“网域层”的架构层，以简化和重复使用界面层与数据层之间的交互。

    界面层

    界面层（或呈现层）的作用是在屏幕上显示应用数据。每当数据发生变化时，无论是因为用户互动（例如按了某个按钮），还是因为外部输入（例如网络响应），界面都应随之更新，以反映这些变化。

    界面层由以下两部分组成：

    • 在屏幕上呈现数据的界面元素。您可以使用 View 或 Jetpack Compose 函数构建这些元素。
    • 用于存储数据、向界面提供数据以及处理逻辑的状态容器（如 ViewModel 类）。

    数据层

    应用的数据层包含业务逻辑。业务逻辑决定应用的价值，它包含决定应用如何创建、存储和更改数据的规则。

    数据层由多个代码库组成，其中每个代码库可包含零到多个数据源。您应该为应用中处理的每种不同类型的数据分别创建一个存储库类。例如，您可以为与电影相关的数据创建一个 MoviesRepository 类，或者为与付款相关的数据创建一个 PaymentsRepository 类。
     

    代码库类负责以下任务：

    • 向应用的其余部分公开数据。
    • 集中处理数据变化。
    • 解决多个数据源之间的冲突。
    • 对应用其余部分的数据源进行抽象化处理。
    • 包含业务逻辑。

    每个数据源类应仅负责处理一个数据源，数据源可以是文件、网络来源或本地数据库。数据源类是应用与数据操作系统之间的桥梁。

    根据官方推荐的架构，转化成我们实际开发架构，可以用下图来表示：

    数据是从界面发出的事件（意图），即 MVI 中 I（Intent），ViewModel根据业务对这个Intent进行处理（数据请求、业务逻辑），将处理的数据封装成State，即UI状态，发送给View进行UI更新。

    而这个State通常是UI所有元素显示状态的集合，通过其对UI进行统一的管理。

    登录示例代码

    1. class MVIDemoActivity : AppCompatActivity() {
    2.  
    3.     private val viewModel: LoginViewModel by viewModels()
    4.  
    5.     private lateinit var binding: ActivityMviBinding
    6.  
    7.     private var loadingDialog: LoadingDialog? = null
    8.  
    9.     override fun onCreate(savedInstanceState: Bundle?) {
    10.         super.onCreate(savedInstanceState)
    11.  
    12.         binding = ActivityMviBinding.inflate(layoutInflater)
    13.         binding.vm = viewModel
    14.  
    15.         setContentView(binding.root)
    16.  
    17.         initObserver()
    18.     }
    19.  
    20.     @SuppressLint("SetTextI18n")
    21.     private fun initObserver() {
    22.  
    23.         binding.editUsername.afterTextChanged {
    24.             viewModel.userName = it
    25.         }
    26.  
    27.         binding.editPassword.afterTextChanged {
    28.             viewModel.password = it
    29.         }
    30.  
    31.         lifecycleScope.launch {
    32.             this@MVIDemoActivity.repeatOnLifecycle(Lifecycle.State.STARTED) {
    33.                 viewModel.loginStateFlow.collect { loginState ->
    34.                     loginState.userInfo?.let { userInfo ->
    35.                         binding.tvUsername.text = getString(R.string.username) + userInfo.userName
    36.                         binding.tvPassword.text = getString(R.string.password) + userInfo.password
    37.                     }
    38.  
    39.                     if (loginState.isLogin) {
    40.                         binding.editUsername.visibility = View.GONE
    41.                         binding.editPassword.visibility = View.GONE
    42.                         binding.btnLogin.visibility = View.GONE
    43.                     } else {
    44.                         binding.editUsername.visibility = View.VISIBLE
    45.                         binding.editPassword.visibility = View.VISIBLE
    46.                         binding.btnLogin.visibility = View.VISIBLE
    47.                     }
    48.  
    49.                     if (loginState.isLoading) {
    50.                         loadingDialog = LoadingDialog(this@MVIDemoActivity)
    51.                         loadingDialog?.show()
    52.                     } else {
    53.                         loadingDialog?.cancel()
    54.                         loadingDialog = null
    55.                     }
    56.                 }
    57.             }
    58.         }
    59.  
    60.         lifecycleScope.launch {
    61.             this@MVIDemoActivity.repeatOnLifecycle(Lifecycle.State.STARTED) {
    62.                 viewModel.loginEventFlow.collect { event ->
    63.                     when (event) {
    64.                         is LoginViewModel.LoginEvent.ToastEvent -> {
    65.                             showToast(event.message, event.isShort)
    66.                         }
    67.                     }
    68.                 }
    69.             }
    70.         }
    71.     }
    72.  
    73. }
    1. class LoginViewModel : ViewModel() {
    2.  
    3.     private val repository = LoginRepository()
    4.  
    5.     var userName: String = ""
    6.     var password: String = ""
    7.  
    8.     private val _loginStateFlow = MutableStateFlow(LoginState())
    9.     private val _loginEventFlow = MutableSharedFlow()
    10.  
    11.     val loginStateFlow: StateFlow = _loginStateFlow
    12.     val loginEventFlow: SharedFlow = _loginEventFlow
    13.  
    14.     fun login() {
    15.         viewModelScope.launch(Dispatchers.IO) {
    16.             _loginStateFlow.update { loginState ->
    17.                 loginState.copy(isLoading = true)
    18.             }
    19.             when (val loginResult = repository.login(userName, password)) {
    20.                 is LoginResult.Success -> {
    21.                     _loginStateFlow.update { loginState ->
    22.                         loginState.copy(
    23.                             userInfo = loginResult.userInfo,
    24.                             isLoading = false,
    25.                             isLogin = true
    26.                         )
    27.                     }
    28.  
    29.                     _loginEventFlow.emit(LoginEvent.ToastEvent("登录成功"))
    30.                 }
    31.                 is LoginResult.Fail -> {
    32.                     _loginStateFlow.update { loginState ->
    33.                         loginState.copy(isLoading = false, isLogin = false)
    34.                     }
    35.                     _loginEventFlow.emit(LoginEvent.ToastEvent(loginResult.message))
    36.                 }
    37.             }
    38.         }
    39.     }
    40.  
    41.     data class LoginState(
    42.         val userInfo: UserInfo? = null,
    43.         val isLoading: Boolean = false,
    44.         val isLogin: Boolean = false
    45.     )
    46.  
    47.     sealed class LoginEvent {
    48.         class ToastEvent(val message: String, val isShort: Boolean = true) : LoginEvent()
    49.     }
    50.  
    51. }

    从上面的代码可以看出，State对UI的状态进行了约束，所有出口都由其提供，并且其只和UI显示的元素相关，和业务逻辑解耦。

     AndroidMVC、MVP、MVVM、MVI架构示例https://download.csdn.net/download/gxlgxjhll/86937904

  • 相关阅读:
    java汽车租赁超时罚款系统springboot+vue-前后端分离-e36ht
    C语言速成笔记 —— 考点详解 & 知识点图解
    TM-30 计算软件 (Excel图表显示版本)
    C++实现的动态规划求解分解为若干素数之和的方案总数
    Java中的volatile为什么不能保证原子性
    深入理解Numpy中sum求和的axis参数
    【1day】用友时空KSOA平台 任意文件上传漏洞学习
    【知识图谱论文】AnyBURL：用于知识图完成的随时自下而上的规则学习
    Zookeeper：Mac通过Docker安装Zookeeper集群
    动手学深度学习7.2 使用块的网络（VGG）-笔记&练习（PyTorch）
  • 原文地址：https://blog.csdn.net/gxlgxjhll/article/details/127773241