С какой архитектурой presentation слоя работал

Работа с архитектурой Presentation Layer в Android

Я работал с несколькими ключевыми архитектурами presentation слоя, выбирая их в зависимости от масштаба проекта, требований к тестированию, поддержке и сложности бизнес-логики. Основными были MVVM, MVI и Clean Architecture с использованием ViewModel и Coroutines/Flow.

MVVM (Model-View-ViewModel)

Это наиболее распространенная архитектура в современных Android проектах, особенно с использованием Android Jetpack. Я использовал ее в 70% проектов благодаря четкому разделению ответственности.

Ключевые компоненты:

• Model: Бизнес-логика и данные (репозитории, entities)
• View: UI компоненты (Activity, Fragment, Composable) – только отображение
• ViewModel: Промежуточный слой, управляющий состоянием для View и взаимодействующий с Model

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

// ViewModel с StateFlow для состояния
class UserViewModel(
    private val userRepository: UserRepository
) : ViewModel() {
    
    private val _userState = MutableStateFlow<UserState>(UserState.Loading)
    val userState: StateFlow<UserState> = _userState
    
    fun loadUser(userId: String) {
        viewModelScope.launch {
            _userState.value = UserState.Loading
            try {
                val user = userRepository.getUser(userId)
                _userState.value = UserState.Success(user)
            } catch (e: Exception) {
                _userState.value = UserState.Error(e.message)
            }
        }
    }
}

// Состояния в sealed class для четкого управления
sealed class UserState {
    object Loading : UserState()
    data class Success(val user: User) : UserState()
    data class Error(val message: String?) : UserState()
}

Преимущества MVVM в моей практике:

• Тестирование: ViewModel легко тестируется без зависимостей от Android фреймворка
• Lifecycle-aware: Integration с AndroidViewModel и viewModelScope
• Data Binding: Возможность использования с Data Binding или View Binding
• Минимальная связь View и Model: View знает только о ViewModel

MVI (Model-View-Intent)

Я применял MVI в сложных проектах с требованием к строгому управлению состоянием и однозначной трассировке пользовательских действий. Особенно эффективно в приложениях с множеством UI состояний.

Особенности реализации:

// Система состояний, действий и результатов
sealed class SearchState {
    object Idle : SearchState()
    data class Loading(val query: String) : SearchState()
    data class Results(val items: List<Item>, val query: String) : SearchState()
    data class Error(val message: String) : SearchState()
}

sealed class SearchIntent {
    data class SearchQuery(val query: String) : SearchIntent()
    object ClearResults : SearchIntent()
}

// ViewModel в стиле MVI
class SearchViewModel : ViewModel() {
    private val _state = MutableStateFlow<SearchState>(SearchState.Idle)
    val state: StateFlow<SearchState> = _state
    
    fun processIntent(intent: SearchIntent) {
        when (intent) {
            is SearchIntent.SearchQuery -> performSearch(intent.query)
            SearchIntent.ClearResults -> _state.value = SearchState.Idle
        }
    }
    
    private fun performSearch(query: String) {
        // Реализация поиска с обновлением состояния
    }
}

Плюсы MVI:

• Unidirectional data flow: Данные движутся в одном направлении (Intent → State → View)
• Декларативное состояние: UI полностью описывается текущим State объектом
• Простота отладки: Все изменения состояния централизованы и отслеживаемы
• Предотвращение рассинхронизации: Состояние всегда консистентно

Clean Architecture + MVVM

Для крупных enterprise проектов я комбинировал MVVM с Clean Architecture, где presentation layer был частью более крупной структуры:

Структура слоев:

1. Domain Layer (Entities, Use Cases, Repositories Interfaces)
2. Data Layer (Repositories Implementations, Data Sources)
3. Presentation Layer (ViewModel, Views, UI States)

Пример организации:

// Use Case из Domain Layer
class GetUserUseCase(
    private val userRepository: UserRepository
) {
    suspend operator fun invoke(userId: String): Result<User> {
        return userRepository.getUser(userId)
    }
}

// ViewModel в Presentation Layer
class UserViewModel(
    private val getUserUseCase: GetUserUseCase
) : ViewModel() {
    // Использование Use Case вместо прямого обращения к репозиторию
    fun loadUser(userId: String) {
        viewModelScope.launch {
            val result = getUserUseCase(userId)
            // Обработка результата
        }
    }
}

Дополнительные подходы и инструменты

• Coroutines и Flow: Для асинхронных операций и управления потоками данных
• Dependency Injection: Использование Dagger Hilt или Koin для внедрения зависимостей в ViewModel
• Compose UI: В современных проектах с Jetpack Compose использую MVI или MVVM с State Hoisting
• Сохранение состояния: Сохранение состояния ViewModel через SavedStateHandle для навигации

Критерии выбора архитектуры

Я выбирал архитектуру на основе:

• Проектных требований: MVVM для большинства случаев, MVI для сложных state-heavy UI
• Тестируемости: Все архитектуры позволяют unit testing ViewModel
• Поддержки Google: MVVM с Jetpack является де-факто стандартом
• Опыта команды: Для новых команд предпочтительнее MVVM из-за простоты освоения

В итоге, я считаю что MVVM с Clean Architecture является наиболее балансным подходом для большинства производственных приложений, обеспечивая хорошую тестируемость, модульность и соответствие современным Android практикам.