Android 开发中 Kotlin 架构演进：从 MVC 到 MVVM

这样的代码有太多问题：职责不清、难以测试、回调地狱。接下来，让我们看看如何用架构模式重构它。

一、MVC 模式：最基础的分层架构

1.1 MVC 概念解析

MVC（Model-View-Controller） 是最经典的架构模式，将应用分为三层：

• Model（模型）：数据和业务逻辑
• View（视图）：UI 展示
• Controller（控制器）：处理用户输入，协调 Model 和 View

在 Android 中，通常：

• View = XML 布局 + Activity/Fragment（视图部分）
• Controller = Activity/Fragment（控制逻辑部分）
• Model = 数据类、仓库、业务逻辑类

// Kotlin MVC 实现示例
// ==================== Model 层 ====================
data class User(val username: String, val password: String)

class LoginModel {
    // 业务逻辑
    fun validateCredentials(username: String, password: String): Boolean {
        return username.length >= 3 && password.length >= 6
    }
    
    // 模拟网络请求
    suspend fun login(username: String, password: String): Boolean {
        delay(2000) // 模拟网络延迟
        return username == "admin" && password == "123456"
    }
}

// ==================== View 层 ====================
// activity_login.xml (UI 布局)

// ==================== Controller 层 ====================
class LoginController(private val view: LoginView) {
    private val model = LoginModel()

    fun onLoginClicked(username: String, password: String) {
        // 1. 验证输入
        if (username.isEmpty() || password.isEmpty()) {
            view.showError("用户名或密码不能为空")
            return
        }
        if (!model.validateCredentials(username, password)) {
            view.showError("用户名或密码格式错误")
            return
        }
        // 2. 执行登录
        view.showLoading()
        // 使用协程处理异步
        launchOnLifecycle {
            try {
                val success = model.login(username, password)
                if (success) {
                    view.onLoginSuccess()
                } else {
                    view.showError("用户名或密码错误")
                }
            } catch (e: Exception) {
                view.showError("网络错误：${e.message}")
            } finally {
                view.hideLoading()
            }
        }
    }
}

interface LoginView {
    fun showLoading()
    fun hideLoading()
    fun showError(message: String)
    fun onLoginSuccess()
    fun launchOnLifecycle(block: suspend () -> Unit)
}

// ==================== Activity（View+Controller 混合）====================
class LoginActivity : AppCompatActivity(), LoginView {
    private lateinit var controller: LoginController
    private lateinit var binding: ActivityLoginBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityLoginBinding.inflate(layoutInflater)
        setContentView(binding.root)
        controller = LoginController(this)
        binding.buttonLogin.setOnClickListener {
            val username = binding.editUsername.text.toString()
            val password = binding.editPassword.text.toString()
            controller.onLoginClicked(username, password)
        }
    }

    override fun showLoading() {
        binding.progressBar.visibility = View.VISIBLE
        binding.buttonLogin.isEnabled = false
    }

    override fun hideLoading() {
        binding.progressBar.visibility = View.GONE
        binding.buttonLogin.isEnabled = true
    }

    override fun showError(message: String) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }

    override fun onLoginSuccess() {
        Toast.makeText(this, "登录成功", Toast.LENGTH_SHORT).show()
        startActivity(Intent(this, MainActivity::class.java))
        finish()
    }

    override fun launchOnLifecycle(block: suspend () -> Unit) {
        lifecycleScope.launch {
            block()
        }
    }
}

1.2 MVC 的优缺点分析

优点：

1. 结构清晰，简单易懂
2. 分离了数据和展示
3. 适合小型项目

缺点：

1. Activity/Fragment 既是 View 又是 Controller，容易变得臃肿
2. View 和 Model 有直接或间接耦合
3. 单元测试困难

Kotlin 带来的改进：

• 协程简化异步操作，避免回调地狱
• 扩展函数可以抽离通用 UI 逻辑
• 数据类简化 Model 定义

二、MVP 模式：关注点分离的进化

2.1 MVP 概念解析

MVP（Model-View-Presenter） 是对 MVC 的改进，核心变化：

• Presenter 替代 Controller，负责所有业务逻辑
• View 只负责 UI 展示，变成被动接口
• Model 保持不变

关键特点：View 和 Model 完全解耦，通过 Presenter 通信。

// Kotlin MVP 实现示例
// ==================== Contract（契约接口）====================
// 使用 Kotlin 的接口默认方法
interface LoginContract {
    interface View {
        fun showLoading()
        fun hideLoading()
        fun showError(message: String)
        fun onLoginSuccess()
        fun getUsername(): String
        fun getPassword(): String
        fun clearInputs()
    }

    interface Presenter {
        fun attachView(view: View)
        fun detachView()
        fun onLoginClicked()
        fun validateInput(): Boolean
    }
}

// ==================== Model 层 ====================
data class User(val id: String, val name: String, val token: String)

interface UserRepository {
    suspend fun login(username: String, password: String): Result<User>
}

class UserRepositoryImpl : UserRepository {
    override suspend fun login(username: String, password: String): Result<User> {
        delay(2000) // 模拟网络延迟
        return if (username == "admin" && password == "123456") {
            Result.success(User("001", "管理员", "token_abc123"))
        } else {
            Result.failure(Exception("用户名或密码错误"))
        }
    }
}

// ==================== Presenter 层 ====================
class LoginPresenter(
    private val repository: UserRepository,
    private val dispatcher: CoroutineDispatcher = Dispatchers.Main
) : LoginContract.Presenter {
    private var view: LoginContract.View? = null
    private var job: Job? = null

    override fun attachView(view: LoginContract.View) {
        this.view = view
    }

    override fun detachView() {
        job?.cancel()
        view = null
    }

    override fun onLoginClicked() {
        // 验证输入
        if (!validateInput()) {
            return
        }
        val view = this.view ?: return
        val username = view.getUsername()
        val password = view.getPassword()
        // 显示加载
        view.showLoading()
        // 启动协程
        job = CoroutineScope(dispatcher).launch {
            try {
                val result = withContext(Dispatchers.IO) {
                    repository.login(username, password)
                }
                handleLoginResult(result)
            } catch (e: Exception) {
                view?.showError("网络错误：${e.message}")
            } finally {
                view?.hideLoading()
            }
        }
    }

    override fun validateInput(): Boolean {
        val view = this.view ?: return false
        val username = view.getUsername()
        val password = view.getPassword()
        return when {
            username.isEmpty() -> {
                view.showError("用户名不能为空")
                false
            }
            password.isEmpty() -> {
                view.showError("密码不能为空")
                false
            }
            username.length < 3 -> {
                view.showError("用户名至少 3 个字符")
                false
            }
            password.length < 6 -> {
                view.showError("密码至少 6 个字符")
                false
            }
            else -> true
        }
    }

    private fun handleLoginResult(result: Result<User>) {
        val view = this.view ?: return
        result.fold(
            onSuccess = { user ->
                // 登录成功
                view.onLoginSuccess()
                view.clearInputs()
                // 可以保存用户信息等操作
            },
            onFailure = { error ->
                view.showError(error.message ?: "登录失败")
            }
        )
    }
}

// ==================== View 层 ====================
class LoginActivity : AppCompatActivity(), LoginContract.View {
    private lateinit var presenter: LoginPresenter
    private lateinit var binding: ActivityLoginBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityLoginBinding.inflate(layoutInflater)
        setContentView(binding.root)
        // 初始化 Presenter
        val repository = UserRepositoryImpl()
        presenter = LoginPresenter(repository)
        presenter.attachView(this)
        binding.buttonLogin.setOnClickListener {
            presenter.onLoginClicked()
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        presenter.detachView()
    }

    // 实现 View 接口
    override fun showLoading() {
        binding.progressBar.visibility = View.VISIBLE
        binding.buttonLogin.isEnabled = false
        binding.buttonLogin.text = "登录中..."
    }

    override fun hideLoading() {
        binding.progressBar.visibility = View.GONE
        binding.buttonLogin.isEnabled = true
        binding.buttonLogin.text = "登录"
    }

    override fun showError(message: String) {
        Snackbar.make(binding.root, message, Snackbar.LENGTH_LONG).show()
    }

    override fun onLoginSuccess() {
        startActivity(Intent(this, MainActivity::class.java))
        finish()
    }

    override fun getUsername(): String = binding.editUsername.text.toString()
    override fun getPassword(): String = binding.editPassword.text.toString()
    override fun clearInputs() {
        binding.editUsername.text.clear()
        binding.editPassword.text.clear()
    }
}

2.2 MVP 的进阶优化

使用 Kotlin 特性优化 MVP：

// 使用 Kotlin 委托简化 Presenter 管理
abstract class BaseMvpActivity<V : Any, P : BasePresenter<V>> : AppCompatActivity() {
    protected lateinit var presenter: P

    @Suppress("UNCHECKED_CAST")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        presenter = createPresenter()
        presenter.attachView(this as V)
    }

    override fun onDestroy() {
        super.onDestroy()
        presenter.detachView()
    }

    abstract fun createPresenter(): P
}

// 使用泛型和反射简化 Presenter 创建
abstract class BasePresenter<V : Any> {
    protected var view: V? = null

    fun attachView(view: V) {
        this.view = view
        onViewAttached()
    }

    fun detachView() {
        onViewDetached()
        this.view = null
    }

    protected open fun onViewAttached() {}
    protected open fun onViewDetached() {}

    protected fun withView(block: (V) -> Unit) {
        view?.let(block)
    }
}

// 使用扩展函数简化 UI 操作
fun LoginContract.View.showSuccessAndNavigate(message: String) {
    showMessage(message) // 假设有 showMessage 方法
    onLoginSuccess()
}

// 使用密封类处理结果
sealed class LoginResult {
    data class Success(val user: User) : LoginResult()
    data class Error(val message: String) : LoginResult()
    object Loading : LoginResult()
    object InvalidInput : LoginResult()
}

// 响应式 Presenter
class ReactiveLoginPresenter(private val repository: UserRepository) : LoginContract.Presenter {
    private val _state = MutableStateFlow<LoginResult>(LoginResult.InvalidInput)
    val state: StateFlow<LoginResult> = _state.asStateFlow()

    override fun onLoginClicked() {
        // 通过状态流通知 View 更新
    }
}

2.3 MVP 的优缺点分析

优点：

1. View 和 Model 完全解耦
2. Presenter 可测试（纯 Java/Kotlin 对象）
3. 职责清晰，View 只处理 UI

缺点：

1. 需要大量接口，代码量增加
2. Presenter 可能变得臃肿
3. 生命周期管理复杂

Kotlin 改进：

• 接口默认方法减少模板代码
• 协程简化异步和生命周期管理
• 扩展函数抽离通用逻辑
• 委托属性管理 Presenter

三、MVVM 模式：数据驱动的现代架构

3.1 MVVM 概念解析

MVVM（Model-View-ViewModel） 是目前 Android 官方推荐的架构：

• ViewModel：管理 UI 相关数据，survives 配置变化
• View：观察 ViewModel 的数据变化，自动更新
• Model：数据源和业务逻辑

核心：数据绑定（Data Binding）或视图绑定（View Binding）+ LiveData/StateFlow。

// Kotlin MVVM 实现示例（使用 Android Architecture Components）
// ==================== Model 层 ====================
data class User(val id: String, val name: String, val email: String, val token: String)

sealed class ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>()
    data class Error(val message: String) : ApiResult<Nothing>()
    object Loading : ApiResult<Nothing>()
}

interface AuthRepository {
    suspend fun login(username: String, password: String): ApiResult<User>
    suspend fun register(username: String, password: String, email: String): ApiResult<User>
    fun logout()
}

class AuthRepositoryImpl @Inject constructor(
    private val apiService: AuthApiService,
    private val prefs: SharedPreferences
) : AuthRepository {
    override suspend fun login(username: String, password: String): ApiResult<User> {
        return try {
            // 实际网络请求
            val response = apiService.login(LoginRequest(username, password))
            if (response.isSuccessful) {
                val user = response.body()?.toUser() ?: throw Exception("数据解析错误")
                // 保存 token
                prefs.edit().putString("auth_token", user.token).apply()
                ApiResult.Success(user)
            } else {
                ApiResult.Error("登录失败：${response.message()}")
            }
        } catch (e: Exception) {
            ApiResult.Error("网络错误：${e.message}")
        }
    }
    // 其他方法...
}

// ==================== ViewModel 层 ====================
@HiltViewModel
class LoginViewModel @Inject constructor(
    private val repository: AuthRepository,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    // UI 状态（使用密封类）
    private val _uiState = MutableStateFlow<LoginUiState>(LoginUiState.Idle)
    val uiState: StateFlow<LoginUiState> = _uiState.asStateFlow()

    // 表单数据
    val username = savedStateHandle.getStateFlow("username", "")
    val password = savedStateHandle.getStateFlow("password", "")

    // 表单验证状态
    val isFormValid = combine(username, password) { user, pass ->
        user.isNotBlank() && pass.isNotBlank() && user.length >= 3 && pass.length >= 6
    }.stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = false
    )

    // 用户操作
    fun onUsernameChanged(newValue: String) {
        savedStateHandle["username"] = newValue
    }

    fun onPasswordChanged(newValue: String) {
        savedStateHandle["password"] = newValue
    }

    fun onLoginClick() {
        viewModelScope.launch {
            _uiState.value = LoginUiState.Loading
            val result = repository.login(username.value, password.value)
            _uiState.value = when (result) {
                is ApiResult.Success -> LoginUiState.Success(result.data)
                is ApiResult.Error -> LoginUiState.Error(result.message)
                else -> LoginUiState.Idle
            }
        }
    }

    fun resetState() {
        _uiState.value = LoginUiState.Idle
    }
}

// UI 状态密封类
sealed class LoginUiState {
    object Idle : LoginUiState()
    object Loading : LoginUiState()
    data class Success(val user: User) : LoginUiState()
    data class Error(val message: String) : LoginUiState()
}

// ==================== View 层 ====================
@AndroidEntryPoint
class LoginFragment : Fragment() {
    private var _binding: FragmentLoginBinding? = null
    private val binding get() = _binding!!
    private val viewModel: LoginViewModel by viewModels()

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentLoginBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        setupViews()
        observeViewModel()
    }

    private fun setupViews() {
        // 使用数据绑定（也可用视图绑定）
        binding.apply {
            // 双向数据绑定
            editUsername.doAfterTextChanged { text ->
                viewModel.onUsernameChanged(text.toString())
            }
            editPassword.doAfterTextChanged { text ->
                viewModel.onPasswordChanged(text.toString())
            }
            buttonLogin.setOnClickListener {
                viewModel.onLoginClick()
            }
            // 根据表单状态更新按钮
            viewLifecycleOwner.lifecycleScope.launch {
                viewModel.isFormValid.collect { isValid ->
                    buttonLogin.isEnabled = isValid
                    buttonLogin.alpha = if (isValid) 1f else 0.5f
                }
            }
        }
    }

    private fun observeViewModel() {
        viewLifecycleOwner.lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.uiState.collect { state ->
                    when (state) {
                        is LoginUiState.Idle -> handleIdleState()
                        is LoginUiState.Loading -> handleLoadingState()
                        is LoginUiState.Success -> handleSuccessState(state.user)
                        is LoginUiState.Error -> handleErrorState(state.message)
                    }
                }
            }
        }
    }

    private fun handleIdleState() {
        binding.progressBar.hide()
        binding.buttonLogin.isEnabled = true
    }

    private fun handleLoadingState() {
        binding.progressBar.show()
        binding.buttonLogin.isEnabled = false
    }

    private fun handleSuccessState(user: User) {
        binding.progressBar.hide()
        showSuccessMessage("欢迎回来，${user.name}！")
        // 导航到主界面
        findNavController().navigate(
            LoginFragmentDirections.actionLoginFragmentToHomeFragment(user)
        )
    }

    private fun handleErrorState(message: String) {
        binding.progressBar.hide()
        binding.buttonLogin.isEnabled = true
        showErrorMessage(message)
    }

    private fun showSuccessMessage(message: String) {
        Snackbar.make(binding.root, message, Snackbar.LENGTH_LONG)
            .setBackgroundTint(ContextCompat.getColor(requireContext(), R.color.success))
            .show()
    }

    private fun showErrorMessage(message: String) {
        Snackbar.make(binding.root, message, Snackbar.LENGTH_LONG)
            .setBackgroundTint(ContextCompat.getColor(requireContext(), R.color.error))
            .setAction("重试") {
                viewModel.onLoginClick()
            }
            .show()
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

3.2 MVVM 的进阶：使用 Jetpack Compose

// Jetpack Compose + MVVM + Kotlin 的现代组合
@Composable
fun LoginScreen(
    viewModel: LoginViewModel = hiltViewModel(),
    onLoginSuccess: (User) -> Unit
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    val isFormValid by viewModel.isFormValid.collectAsStateWithLifecycle()

    Column(
        modifier = Modifier.fillMaxSize().padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        // Logo
        Icon(
            painter = painterResource(R.drawable.ic_logo),
            contentDescription = "Logo",
            modifier = Modifier.size(100.dp),
            tint = MaterialTheme.colorScheme.primary
        )

        Spacer(modifier = Modifier.height(32.dp))

        // 用户名输入
        OutlinedTextField(
            value = viewModel.username.value,
            onValueChange = viewModel::onUsernameChanged,
            label = { Text("用户名") },
            modifier = Modifier.fillMaxWidth(),
            isError = viewModel.username.value.isNotEmpty() && viewModel.username.value.length < 3
        )

        Spacer(modifier = Modifier.height(16.dp))

        // 密码输入
        OutlinedTextField(
            value = viewModel.password.value,
            onValueChange = viewModel::onPasswordChanged,
            label = { Text("密码") },
            modifier = Modifier.fillMaxWidth(),
            visualTransformation = PasswordVisualTransformation(),
            isError = viewModel.password.value.isNotEmpty() && viewModel.password.value.length < 6
        )

        Spacer(modifier = Modifier.height(32.dp))

        // 登录按钮
        Button(
            onClick = viewModel::onLoginClick,
            modifier = Modifier.fillMaxWidth(),
            enabled = isFormValid && uiState !is LoginUiState.Loading
        ) {
            if (uiState is LoginUiState.Loading) {
                CircularProgressIndicator(
                    modifier = Modifier.size(20.dp),
                    color = MaterialTheme.colorScheme.onPrimary
                )
                Spacer(modifier = Modifier.width(8.dp))
                Text("登录中...")
            } else {
                Text("登录")
            }
        }

        // 处理状态
        when (val state = uiState) {
            is LoginUiState.Error -> {
                Spacer(modifier = Modifier.height(16.dp))
                Text(
                    text = state.message,
                    color = MaterialTheme.colorScheme.error,
                    style = MaterialTheme.typography.bodySmall
                )
            }
            is LoginUiState.Success -> {
                LaunchedEffect(state) {
                    onLoginSuccess(state.user)
                }
            }
            else -> {}
        }
    }
}

3.3 MVVM 的优缺点分析

优点：

1. 数据驱动 UI，自动更新
2. ViewModel survives 配置变化
3. 配合 Data Binding/Compose 减少模板代码
4. 官方支持，生态完善

缺点：

1. 学习曲线较陡
2. Data Binding 调试困难
3. 过度使用可能造成内存泄漏

Kotlin 改进：

• 协程 Flow 替代 LiveData（更强大）
• 密封类优雅处理状态
• 扩展函数简化数据绑定
• 委托属性管理 ViewModel

四、架构模式对比与选型指南

4.1 三种架构模式对比

4.2 实际项目选型建议

// 项目架构决策器
object ArchitectureDecider {
    fun decideArchitecture(project: ProjectInfo): Architecture {
        return when {
            // 小型工具类应用
            project.teamSize <= 2 && project.complexity == Complexity.SIMPLE -> Architecture.MVC
            // 中型商业应用
            project.teamSize in 3..5 && project.hasUnitTest -> Architecture.MVP
            // 大型复杂应用
            project.teamSize > 5 && project.longTermMaintenance -> Architecture.MVVM
            // 使用 Jetpack Compose
            project.usesCompose && project.minSdk >= 21 -> Architecture.MVVM_WITH_COMPOSE
            // 混合架构（过渡期）
            else -> Architecture.HYBRID
        }
    }
}

data class ProjectInfo(
    val teamSize: Int,
    val complexity: Complexity,
    val hasUnitTest: Boolean,
    val longTermMaintenance: Boolean,
    val usesCompose: Boolean = false,
    val minSdk: Int = 21
)

enum class Complexity { SIMPLE, MEDIUM, COMPLEX }
enum class Architecture { MVC, MVP, MVVM, MVVM_WITH_COMPOSE, HYBRID }

4.3 混合架构实践

在实际项目中，常常需要混合使用多种架构：

// 混合架构示例：MVVM + Clean Architecture
@HiltViewModel
class UserProfileViewModel @Inject constructor(
    private val getUserUseCase: GetUserUseCase,
    private val updateUserUseCase: UpdateUserUseCase,
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    // UI 状态（MVVM）
    private val _uiState = MutableStateFlow<UserProfileUiState>(UserProfileUiState.Loading)
    val uiState: StateFlow<UserProfileUiState> = _uiState.asStateFlow()

    // 从 Clean Architecture 的 UseCase 获取数据
    fun loadUserProfile(userId: String) {
        viewModelScope.launch {
            _uiState.value = UserProfileUiState.Loading
            val result = getUserUseCase.invoke(userId)
            _uiState.value = when (result) {
                is Result.Success -> UserProfileUiState.Success(result.data)
                is Result.Error -> UserProfileUiState.Error(result.message)
            }
        }
    }

    // 使用 MVP 模式的契约接口进行模块间通信
    fun updateProfile(data: ProfileData) {
        viewModelScope.launch {
            val result = updateUserUseCase.invoke(data)
            if (result is Result.Success) {
                // 通知其他模块（类似 MVP 的接口回调）
                eventChannel.send(ProfileUpdateEvent.Success)
            }
        }
    }

    private val eventChannel = Channel<ProfileUpdateEvent>()
    val events = eventChannel.receiveAsFlow()
}

// Clean Architecture 的 UseCase（领域层）
class GetUserUseCase @Inject constructor(
    private val userRepository: UserRepository
) {
    suspend operator fun invoke(userId: String): Result<User> {
        return userRepository.getUserById(userId)
    }
}

// 事件密封类（类似 MVP 的契约接口）
sealed class ProfileUpdateEvent {
    object Success : ProfileUpdateEvent()
    data class Error(val message: String) : ProfileUpdateEvent()
}

五、Kotlin 在架构中的最佳实践

5.1 使用 Kotlin 特性优化架构代码

// 1. 使用密封类处理状态（替代枚举 + 接口）
sealed class Resource<out T> {
    data class Success<T>(val data: T) : Resource<T>()
    data class Error(val exception: Throwable) : Resource<Nothing>()
    object Loading : Resource<Nothing>()

    // 扩展函数处理不同状态
    fun onSuccess(block: (T) -> Unit): Resource<T> = this.also {
        if (this is Success) block(data)
    }

    fun onError(block: (Throwable) -> Unit): Resource<T> = this.also {
        if (this is Error) block(exception)
    }
}

// 2. 使用扩展函数简化架构组件
fun <T> Flow<Resource<T>>.bindToView(
    lifecycleOwner: LifecycleOwner,
    onSuccess: (T) -> Unit,
    onError: (Throwable) -> Unit,
    onLoading: () -> Unit = {}
) {
    lifecycleOwner.lifecycleScope.launch {
        lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
            this@bindToView.collect { resource ->
                when (resource) {
                    is Resource.Loading -> onLoading()
                    is Resource.Success -> onSuccess(resource.data)
                    is Resource.Error -> onError(resource.exception)
                }
            }
        }
    }
}

// 3. 使用委托属性管理依赖
interface Injectable {
    val injector: Injector get() = InjectorProvider.injector
}

class MainViewModel : ViewModel(), Injectable {
    // 延迟注入依赖
    private val repository: UserRepository by inject { UserRepositoryImpl() }
    // 或者使用 Koin/Koin/Hilt
    private val useCase: GetUserUseCase by inject()
}

// 4. 使用内联函数减少模板代码
inline fun <T> ViewModel.launchWithState(
    stateFlow: MutableStateFlow<Resource<T>>,
    crossinline block: suspend () -> T
) {
    viewModelScope.launch {
        stateFlow.value = Resource.Loading
        try {
            val result = block()
            stateFlow.value = Resource.Success(result)
        } catch (e: Exception) {
            stateFlow.value = Resource.Error(e)
        }
    }
}

5.2 架构组件与 Kotlin 协程的完美结合

// 使用协程 Flow 构建响应式架构
class ProductListViewModel @Inject constructor(
    private val getProductsUseCase: GetProductsUseCase,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    // 搜索词（状态保存）
    private val searchQuery = savedStateHandle.getStateFlow("searchQuery", "")
    // 排序方式
    private val sortOrder = MutableStateFlow(SortOrder.DEFAULT)

    // 产品列表（自动响应搜索词和排序变化）
    val products: StateFlow<Resource<List<Product>>> = combine(
        searchQuery.debounce(300), // 防抖
        sortOrder
    ) { query, order -> Pair(query, order) }
        .flatMapLatest { (query, order) ->
            getProductsUseCase(query, order)
                .map { Resource.Success(it) }
                .catch { emit(Resource.Error(it)) }
                .onStart { emit(Resource.Loading) }
        }
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = Resource.Loading
        )

    fun onSearchQueryChanged(query: String) {
        savedStateHandle["searchQuery"] = query
    }

    fun onSortOrderChanged(order: SortOrder) {
        sortOrder.value = order
    }
}

六、常见面试题

基础概念题

1. MVC、MVP 和 MVVM 三种架构模式的主要区别是什么？各有什么优缺点？
   • 答案要点：MVC 中 Controller 处理业务逻辑，View 和 Model 可能耦合；MVP 中 Presenter 处理所有逻辑，View 被动；MVVM 中 ViewModel 管理数据，View 观察数据变化。MVC 简单但易臃肿，MVP 解耦但接口多，MVVM 数据驱动但学习成本高。
2. 在 MVVM 架构中，LiveData 和 StateFlow 有什么区别？为什么推荐使用 StateFlow？
   • 答案要点：LiveData 是生命周期感知的，但功能有限；StateFlow 基于协程，支持复杂的变换操作、背压处理、线程切换。StateFlow 更强大、更符合 Kotlin 协程生态、支持测试更方便。
3. 如何防止在 MVVM 架构中出现内存泄漏？ViewModel 的 scope 是如何管理的？
   • 答案要点：1) 使用 ViewLifecycleOwner 而非 Activity；2) 在 onDestroyView 中清除绑定；3) 使用 repeatOnLifecycle 收集 Flow；4) ViewModel 由 ViewModelStore 管理，在 Activity 重建时保持，在 Finish 时销毁。

实践应用题

4. 将一个使用回调的 MVC 网络请求模块，改造成使用协程的 MVVM 架构，请写出关键代码。

5. 在 MVP 架构中，如何处理 Presenter 的生命周期？如何避免内存泄漏？

   • 答案要点：1) 在 onCreate 中创建 Presenter，onDestroy 中解绑；2) 使用弱引用持有 View；3) 使用 BasePresenter 管理生命周期；4) 在 View 销毁时取消所有异步任务。示例：Presenter 中定义 attach/detach 方法，Activity 在对应生命周期调用。

6. 如何设计一个支持离线功能的 MVVM 架构？请描述数据流向。

   • 答案要点：采用 Repository 模式，数据流向：View → ViewModel → Repository → （优先缓存 → 网络）。关键点：1) 单一数据源；2) 缓存策略；3) 网络状态监测；4) 数据同步机制。使用 Room 缓存，Flow 实现数据更新通知。

答案要点：

// 改造前（MVC+ 回调）
class UserManager {
    fun fetchUser(callback: (User) -> Unit) { ... }
}

// 改造后（MVVM+ 协程）
class UserRepository {
    suspend fun fetchUser(): User = withContext(Dispatchers.IO) { ... }
}

class UserViewModel : ViewModel() {
    private val _user = MutableStateFlow<Resource<User>>(Resource.Loading)
    val user: StateFlow<Resource<User>> = _user.asStateFlow()

    fun loadUser() {
        viewModelScope.launch {
            _user.value = Resource.Loading
            try {
                val user = repository.fetchUser()
                _user.value = Resource.Success(user)
            } catch (e: Exception) {
                _user.value = Resource.Error(e)
            }
        }
    }
}

深入原理题

7. Data Binding 和 View Binding 有什么区别？在 MVVM 中如何选择？
   • 答案要点：DataBinding 支持双向绑定和表达式，但编译速度慢、调试困难；ViewBinding 只生成视图引用，简单高效。选择：简单场景用 ViewBinding，复杂数据绑定用 DataBinding，或两者混合使用（主要用 ViewBinding，局部用 DataBinding）。
8. 在大型项目中，如何组织 MVVM 的模块结构？如何避免 ViewModel 臃肿？
   • 答案要点：按功能模块划分：feature 包（View+ViewModel）、data 包（Repository+Model）、domain 包（UseCase）。避免 ViewModel 臃肿：1) 使用 UseCase 封装业务逻辑；2) 使用 State 管理 UI 状态；3) 使用 Event 处理一次性事件；4) 提取基类 ViewModel。
9. 如何测试 MVVM 架构中的 ViewModel？如何模拟依赖？
   • 答案要点：使用 JUnit + MockK + Turbine。步骤：1) 使用依赖注入（Hilt/Koin）；2) 测试中提供模拟依赖；3) 测试 StateFlow 的状态变化；4) 测试协程执行逻辑。示例：使用 TestCoroutineDispatcher，验证状态流转。

总结

从 MVC 到 MVVM，不仅是架构模式的演进，更是开发思维从"界面驱动"到"数据驱动"的转变。Kotlin 作为现代编程语言，其协程、扩展函数、密封类、Flow 等特性，与 MVVM 架构完美契合，让 Android 开发变得更加高效、优雅。

对于从 Java 转向 Kotlin 的开发者，建议的学习路径是：

1. 先理解 MVC：掌握基础分层思想
2. 实践 MVP：体会接口契约和测试优势
3. 深入 MVVM：掌握数据驱动和响应式编程
4. 融合最佳实践：结合 Clean Architecture、UseCase 等

在实际项目中，没有"最好"的架构，只有"最适合"的架构。小型工具类应用可能 MVC 就够了，中型商业应用适合 MVP，大型复杂应用则推荐 MVVM。重要的是保持架构一致性和可维护性。

随着 Jetpack Compose 的成熟，"Compose + MVVM"正在成为新的标准范式。掌握 Kotlin 和现代 Android 架构，就能在移动开发的道路上走得更远。