В чём разница между MVC, MVP и MVVM? Какую архитектуру предпочитаете и почему?

Разница между MVC, MVP и MVVM

Это три основных архитектурных паттерна, используемых в Android-разработке для разделения ответственности между компонентами приложения. Каждый из них решает проблему тесной связности между бизнес-логикой и UI, но делает это по-разному.

MVC (Model-View-Controller)

• Model - отвечает за данные и бизнес-логику
• View - отвечает за отображение данных (UI-компоненты)
• Controller - посредник между Model и View, обрабатывает пользовательский ввод

// Упрощенный пример MVC в Android
class UserModel(var name: String, var email: String)

class UserView(private val textView: TextView) {
    fun displayUser(user: UserModel) {
        textView.text = "${user.name} (${user.email})"
    }
}

class UserController(private val model: UserModel, private val view: UserView) {
    fun updateUser(name: String, email: String) {
        model.name = name
        model.email = email
        view.displayUser(model)
    }
}

Проблема в Android: Activity/Fragment часто выступают одновременно как Controller и View, что приводит к "раздутым" классам с混合ной ответственностью.

MVP (Model-View-Presenter)

• Model - данные и бизнес-логика
• View - пассивный интерфейс для отображения (обычно реализуется Activity/Fragment)
• Presenter - получает данные от Model, преобразует их и обновляет View

// Контракт для MVP
interface UserContract {
    interface View {
        fun showUser(name: String, email: String)
        fun showError(message: String)
    }
    
    interface Presenter {
        fun loadUser()
        fun updateUser(name: String, email: String)
    }
}

class UserPresenter(
    private val view: UserContract.View,
    private val repository: UserRepository
) : UserContract.Presenter {
    
    override fun loadUser() {
        repository.getUser { user ->
            view.showUser(user.name, user.email)
        }
    }
}

Ключевое отличие от MVC: View пассивна и знает только о Presenter, а не о Model. Presenter содержит всю логику отображения.

MVVM (Model-View-ViewModel)

• Model - данные и бизнес-логика
• View - UI-компоненты (Activity/Fragment/Composable)
• ViewModel - хранит состояние UI и предоставляет данные для View, используя Data Binding или State Flow

// MVVM с использованием ViewModel и StateFlow
class UserViewModel(private val repository: UserRepository) : ViewModel() {
    private val _userState = MutableStateFlow<UserState>(UserState.Loading)
    val userState: StateFlow<UserState> = _userState.asStateFlow()
    
    fun loadUser() {
        viewModelScope.launch {
            _userState.value = UserState.Loading
            try {
                val user = repository.getUser()
                _userState.value = UserState.Success(user)
            } catch (e: Exception) {
                _userState.value = UserState.Error(e.message ?: "Unknown error")
            }
        }
    }
}

// Во View (Fragment)
viewModel.userState.collect { state ->
    when (state) {
        is UserState.Success -> {
            binding.nameTextView.text = state.user.name
            binding.emailTextView.text = state.user.email
        }
        // ... обработка других состояний
    }
}

Главное преимущество: автоматическая привязка данных и реактивное программирование. ViewModel переживает изменения конфигурации и не зависит от View.

Сравнительная таблица

Моё предпочтение: MVVM

Я предпочитаю MVVM в сочетании с Clean Architecture и Jetpack компонентами по следующим причинам:

Аргументы за MVVM:

1. Интеграция с современным Android стеком - паттерн идеально сочетается с Jetpack ViewModel, LiveData/StateFlow, Data Binding и Compose
2. Реактивное программирование - использование StateFlow/RxJava позволяет создавать отзывчивые интерфейсы
3. Автоматическое управление жизненным циклом - ViewModel автоматически переживает изменения конфигурации
4. Лучшая тестируемость - ViewModel не зависит от Android фреймворка, можно тестировать без эмулятора
5. Четкое разделение ответственности - View только отображает состояние, ViewModel управляет состоянием, Model работает с данными

Мой типичный стек:

// Clean Architecture + MVVM
class FeatureViewModel(
    private val getDataUseCase: GetDataUseCase,
    private val dispatcher: CoroutineDispatcher = Dispatchers.IO
) : ViewModel() {
    
    private val _uiState = MutableStateFlow<UiState>(UiState.Idle)
    val uiState: StateFlow<UiState> = _uiState
    
    fun loadData() {
        viewModelScope.launch(dispatcher) {
            _uiState.value = UiState.Loading
            val result = getDataUseCase.execute()
            _uiState.value = when (result) {
                is Result.Success -> UiState.Success(result.data)
                is Result.Error -> UiState.Error(result.message)
            }
        }
    }
}

Когда выбираю другие подходы:

• MVP - для legacy проектов или когда нужен полный контроль над View
• MVI (Model-View-Intent) - для сложных экранов с односторонним потоком данных
• MVC - только для простых приложений или прототипов

Вывод: MVVM стал де-факто стандартом для Android-разработки благодаря глубокой интеграции с Jetpack Components и поддержке Google. Он обеспечивает лучшую поддерживаемость, тестируемость и соответствие современным практикам реактивного программирования. Однако окончательный выбор всегда зависит от конкретного проекта, команды и требований.