Какие знаешь зависимости в MVVM?

Зависимости в архитектуре MVVM для Android

В паттерне Model-View-ViewModel (MVVM) зависимости играют ключевую роль для обеспечения разделения ответственности, тестируемости и поддержки кода. Основные зависимости строятся по принципу инверсии зависимостей (Dependency Inversion Principle) - высокоуровневые модули не должны зависеть от низкоуровневых, оба должны зависеть от абстракций.

Ключевые типы зависимостей в MVVM:

1. Зависимости View от ViewModel

View (Activity/Fragment) зависит от ViewModel через наблюдаемые поля (LiveData/StateFlow):

class MainActivity : AppCompatActivity() {
    private val viewModel: MainViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Подписка на изменения данных из ViewModel
        viewModel.userData.observe(this) { user ->
            updateUI(user)
        }
        
        // Вызов методов ViewModel
        button.setOnClickListener {
            viewModel.loadUserData()
        }
    }
}

2. Зависимости ViewModel от Model/Repository

ViewModel зависит от репозиториев или use cases, а не напрямую от источников данных:

class UserViewModel(
    private val userRepository: UserRepository,
    private val preferencesManager: PreferencesManager
) : ViewModel() {
    
    private val _userState = MutableStateFlow<UserState>(UserState.Loading)
    val userState: StateFlow<UserState> = _userState
    
    fun loadUser() {
        viewModelScope.launch {
            _userState.value = UserState.Loading
            try {
                val user = userRepository.getUser()
                val settings = preferencesManager.getSettings()
                _userState.value = UserState.Success(user, settings)
            } catch (e: Exception) {
                _userState.value = UserState.Error(e.message)
            }
        }
    }
}

3. Зависимости Repository от Data Sources

Репозиторий зависит от различных источников данных:

class UserRepositoryImpl(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource,
    private val networkChecker: NetworkChecker
) : UserRepository {
    
    override suspend fun getUser(): User {
        return if (networkChecker.isConnected()) {
            // Сначала пробуем получить свежие данные
            val remoteUser = remoteDataSource.fetchUser()
            localDataSource.saveUser(remoteUser)
            remoteUser
        } else {
            // Используем локальные данные
            localDataSource.getUser()
        }
    }
}

Способы управления зависимостями:

Dependency Injection (DI)

Наиболее распространенный подход для управления зависимостями:

1. Ручная инъекция зависимостей (просто, но не масштабируется)
2. Dagger/Hilt (стандарт для Android)
3. Koin (альтернативный легковесный DI-фреймворк)

Пример с Hilt:

@Module
@InstallIn(ViewModelComponent::class)
object AppModule {
    
    @Provides
    fun provideUserRepository(
        localDataSource: UserLocalDataSource,
        remoteDataSource: UserRemoteDataSource
    ): UserRepository {
        return UserRepositoryImpl(localDataSource, remoteDataSource)
    }
    
    @Provides
    fun provideUserLocalDataSource(
        database: AppDatabase
    ): UserLocalDataSource {
        return UserLocalDataSourceImpl(database.userDao())
    }
}

Важные принципы управления зависимостями:

• Инверсия управления: ViewModel не создает зависимости самостоятельно
• Внедрение через конструктор: наиболее чистый и тестируемый способ
• Использование интерфейсов/абстракций: упрощает замену реализаций и тестирование
• Жизненный цикл зависимостей: разные зависимости имеют разные scope (Application, Activity, ViewModel)

Преимущества правильного управления зависимостями:

• Тестируемость: легко мокать зависимости в unit-тестах
• Гибкость: просто заменять реализации
• Поддержка: код становится более понятным и модульным
• Жизненный цикл: автоматическое освобождение ресурсов

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

1. Создание зависимостей внутри ViewModel:

   // ❌ Плохо
   class MyViewModel : ViewModel() {
       private val repository = MyRepository() // Прямое создание
   }
   
   // ✅ Правильно
   class MyViewModel(
       private val repository: MyRepository // Внедрение через конструктор
   ) : ViewModel()
   

2. Использование синглтонов напрямую вместо инъекции зависимостей

3. Смешивание ответственности: когда ViewModel содержит бизнес-логику вместо делегирования use cases

Правильное управление зависимостями в MVVM критически важно для создания масштабируемых, тестируемых и поддерживаемых Android-приложений. Современные подходы с использованием Hilt или Koin значительно упрощают этот процесс, автоматизируя создание и управление графом зависимостей.