В чем разница между MVVM, MVI и MVP?

Сравнение архитектурных паттернов MVP, MVVM и MVI

В современной Android-разработке выбор архитектурного паттерна критически важен для создания поддерживаемых, тестируемых и масштабируемых приложений. MVP, MVVM и MVI представляют собой эволюцию подходов к разделению ответственности между компонентами, каждый со своей философией управления состоянием и данными.

Model-View-Presenter (MVP)

MVP — классический паттерн, пришедший на смену MVC в контексте Android. Его ключевая характеристика — четкое разделение между представлением и бизнес-логикой.

Основные компоненты:

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

Пример реализации:

// Контракт определяет взаимодействие
interface LoginContract {
    interface View {
        fun showError(message: String)
        fun navigateToHome()
    }
    
    interface Presenter {
        fun login(username: String, password: String)
    }
}

// Реализация Presenter
class LoginPresenter(private val view: LoginContract.View) : LoginContract.Presenter {
    private val model = AuthModel()
    
    override fun login(username: String, password: String) {
        if (model.validateCredentials(username, password)) {
            view.navigateToHome()
        } else {
            view.showError("Invalid credentials")
        }
    }
}

Преимущества MVP: простота понимания, хорошая тестируемость Presenter'а, четкое разделение ответственности.

Недостатки: сильная связь между View и Presenter, ручное управление обновлениями UI, возможное раздувание Presenter'а.

Model-View-ViewModel (MVVM)

MVVM представляет более реактивный подход, использующий Data Binding или LiveData/Flow для автоматического обновления UI при изменении данных.

Ключевые особенности:

• ViewModel — хранит состояние UI и обрабатывает логику, переживает изменения конфигурации
• Data Binding — автоматическое обновление View при изменении данных в ViewModel
• Reactive Streams — использование LiveData, StateFlow, RxJava для реактивного программирования

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

// Activity/Fragment наблюдает за состоянием
class UserActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val viewModel: UserViewModel by viewModels()
        
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.userState.collect { state ->
                    when (state) {
                        is UserState.Success -> showUser(state.user)
                        is UserState.Error -> showError(state.message)
                        UserState.Loading -> showLoading()
                    }
                }
            }
        }
    }
}

Преимущества MVVM: автоматическое обновление UI, меньшая связность, встроенная поддержка жизненного цикла через ViewModel.

Недостатки: потенциально большая сложность при использовании Data Binding, необходимость управления подписками на потоки данных.

Model-View-Intent (MVI)

MVI — наиболее строгий и функциональный подход, основанный на концепции однонаправленного потока данных и неизменяемого состояния.

Основные принципы:

1. Единое неизменяемое состояние — весь UI состояние описано в одном data-классе
2. Intent — намерения пользователя или системы, которые преобразуются в действия
3. Однонаправленный поток: View отправляет Intents → Model обрабатывает → новое State → View отображает

// Единое состояние для UI
data class SearchState(
    val query: String = "",
    val results: List<Item> = emptyList(),
    val isLoading: Boolean = false,
    val error: String? = null
)

// События/Intents
sealed class SearchIntent {
    data class QueryChanged(val query: String) : SearchIntent()
    object SearchSubmitted : SearchIntent()
    data class ItemSelected(val item: Item) : SearchIntent()
}

// Редуктор обрабатывает интенты
class SearchReducer {
    fun reduce(state: SearchState, intent: SearchIntent): SearchState {
        return when (intent) {
            is SearchIntent.QueryChanged -> state.copy(query = intent.query)
            is SearchIntent.SearchSubmitted -> state.copy(isLoading = true, error = null)
            // ... обработка других интентов
        }
    }
}

// MVI компонент
class SearchViewModel : ViewModel() {
    private val reducer = SearchReducer()
    private val _state = MutableStateFlow(SearchState())
    val state: StateFlow<SearchState> = _state.asStateFlow()
    
    fun processIntent(intent: SearchIntent) {
        val newState = reducer.reduce(_state.value, intent)
        _state.value = newState
        // Дополнительные side effects
    }
}

Преимущества MVI: предсказуемость состояния, простота отладки (логирование всех интентов и состояний), иммутабельность предотвращает случайные изменения.

Недостатки: более высокая порог вхождения, избыточность для простых экранов, необходимость писать больше boilerplate-кода.

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

Практические рекомендации по выбору

1. MVP подходит для:

   • Легационных проектов
   • Небольших приложений с простой логикой
   • Команд, начинающих изучать архитектурные паттерны

2. MVVM рекомендуется для:

   • Большинства современных Android-приложений
   • Проектов с использованием Jetpack Components
   • Ситуаций, где нужен баланс между простотой и мощностью

3. MVI выбирайте для:

   • Сложных экранов с множеством состояний
   • Приложений, где критична предсказуемость
   • Команд с опытом функционального программирования

Эволюционный путь многих проектов: от MVP к MVVM, а для сложных экранов — к MVI. Современный тренд — использование MVVM с элементами MVI (единое состояние, но менее строгая архитектура), что реализовано в таких библиотеках как Jetpack Compose с подходом UDF (Unidirectional Data Flow).

Ключевой принцип вне зависимости от выбора паттерна: разделение ответственности, тестируемость и управление состоянием как первоклассная концепция.