Какие знаешь архитектуры разработки ПО?

# Архитектурные паттерны в разработке ПО для Android

Основные архитектурные подходы

1. Clean Architecture (Чистая архитектура)

Наиболее популярная архитектура в современных Android-приложениях, основанная на принципах Роберта Мартина. Главная идея — разделение ответственности на слои:

// Пример структуры слоев
data class UserEntity(val id: Long, val name: String) // Data layer

data class User(val id: Long, val name: String) // Domain layer

data class UserUiState(val name: String) // Presentation layer

Ключевые принципы:

• Зависимость направлена внутрь — внешние слои зависят от внутренних
• Инверсия зависимостей через интерфейсы
• Тестируемость каждого слоя независимо
• Слои:
  • Domain — бизнес-логика и use cases
  • Data — источники данных и репозитории
  • Presentation — UI и ViewModels

2. MVVM (Model-View-ViewModel)

Архитектурный паттерн, активно продвигаемый Google через Android Architecture Components:

class UserViewModel : ViewModel() {
    private val _userState = MutableStateFlow<UserUiState>(UserUiState.Loading)
    val userState: StateFlow<UserUiState> = _userState.asStateFlow()
    
    fun loadUser(userId: String) {
        viewModelScope.launch {
            _userState.value = UserUiState.Loading
            try {
                val user = userRepository.getUser(userId)
                _userState.value = UserUiState.Success(user)
            } catch (e: Exception) {
                _userState.value = UserUiState.Error(e.message)
            }
        }
    }
}

// В Activity/Fragment
viewModel.userState.collect { state ->
    when (state) {
        is UserUiState.Success -> showUser(state.user)
        is UserUiState.Error -> showError(state.message)
        UserUiState.Loading -> showProgress()
    }
}

3. MVI (Model-View-Intent)

Односторонний поток данных, популярный в реактивном программировании:

sealed class UserIntent {
    object LoadUser : UserIntent()
    data class UpdateName(val name: String) : UserIntent()
}

data class UserState(
    val isLoading: Boolean = false,
    val user: User? = null,
    val error: String? = null
)

class UserProcessor {
    fun process(intent: UserIntent): Flow<UserState> = flow {
        when (intent) {
            is UserIntent.LoadUser -> {
                emit(UserState(isLoading = true))
                // Загрузка данных
                emit(UserState(user = loadedUser))
            }
        }
    }
}

4. MVP (Model-View-Presenter)

Традиционный паттерн, до сих пор встречающийся в legacy-проектах:

interface UserContract {
    interface View {
        fun showUser(user: User)
        fun showError(message: String)
    }
    
    interface Presenter {
        fun attachView(view: View)
        fun loadUser(userId: String)
        fun detachView()
    }
}

class UserPresenter(private val repository: UserRepository) : 
    UserContract.Presenter {
    
    private var view: UserContract.View? = null
    
    override fun attachView(view: UserContract.View) {
        this.view = view
    }
    
    override fun loadUser(userId: String) {
        view?.showUser(repository.getUser(userId))
    }
}

5. Слоистая архитектура (Layered Architecture)

Классический подход с четким разделением на слои:

┌─────────────────┐
│   Presentation  │ ← UI, Activities, Fragments
├─────────────────┤
│    Domain       │ ← Business logic, Entities
├─────────────────┤
│     Data        │ ← Repositories, APIs, Database
└─────────────────┘

Современные тенденции и гибридные подходы

Мультимодульная архитектура

Разделение приложения на feature-модули для улучшения:

• Инкапсуляции функциональности
• Времени сборки через параллелизацию
• Масштабируемости команды

// settings.gradle.kts
include(
    ":app",
    ":core:network",
    ":core:database",
    ":core:ui",
    ":feature:auth",
    ":feature:profile",
    ":feature:feed"
)

Compose-ориентированная архитектура

С появлением Jetpack Compose меняются подходы к управлению состоянием:

@Composable
fun UserProfileScreen(
    viewModel: UserViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsState()
    
    when (val state = uiState) {
        is UserUiState.Success -> UserProfileContent(state.user)
        is UserUiState.Error -> ErrorScreen(state.message)
        UserUiState.Loading -> LoadingIndicator()
    }
}

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

Для нового проекта:

1. Clean Architecture + MVVM — стандарт для большинства проектов
2. MVI — для сложных UI с множеством состояний
3. Compose + ViewModel — для современных приложений

Для legacy-проектов:

1. Постепенная миграция к Clean Architecture
2. Внедрение ViewModel вместо чистого MVP
3. Выделение доменного слоя из presentation логики

Практические рекомендации

Ключевые принципы успешной архитектуры:

• SOLID-принципы как основа любой архитектуры
• Принцип единственной ответственности для каждого компонента
• Инверсия зависимостей через внедрение зависимостей (Dagger/Hilt)
• Реактивное программирование с Kotlin Flows/RxJava
• Тестопригодность — архитектура должна позволять unit-тестирование

Распространенные ошибки:

// ПЛОХО: Смешивание слоев
class UserActivity : AppCompatActivity() {
    // Не должно быть в Presentation слое!
    private val database = Room.databaseBuilder(...).build()
    
    override fun onCreate() {
        // Бизнес-логика в Activity
        val user = database.userDao().getUser() 
        if (user.isPremium) { /* ... */ }
    }
}

// ХОРОШО: Разделение ответственности
class UserViewModel @Inject constructor(
    private val getUserUseCase: GetUserUseCase // Domain слой
) : ViewModel() {
    fun loadUser() {
        viewModelScope.launch {
            _state.value = getUserUseCase()
        }
    }
}

Инструменты и библиотеки

Для внедрения зависимостей:

• Dagger/Hilt — стандарт в Android разработке
• Koin — альтернатива для небольших проектов

Для реактивного программирования:

• Kotlin Flow — современный выбор от Google
• RxJava — для legacy проектов или сложных потоков

Для управления состоянием:

• ViewModel + StateFlow — базовый подход
• MVIKotlin/Mobius — для строгого MVI
• Redux-подобные решения — для сложных state-машин

Заключение

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

Для enterprise-приложений рекомендую мультимодульную Clean Architecture, для быстрых прототипов — упрощенный MVVM, а для проектов с сложной UI-логикой — MVI или Redux-подобные решения.