Какой класс или модуль отвечает за получение данных из базы данных и отправку их на сервер?

Архитектурный подход к работе с данными

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

Ключевые компоненты и их ответственность

1. Repository (Репозиторий) - центральный координатор

Репозиторий — это основной класс/интерфейс, который абстрагирует источник данных и предоставляет единый API для остальных слоев приложения. Он решает, откуда брать данные (локальная БД, сеть, кэш) и куда их сохранять.

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) {
    suspend fun getUsers(): Flow<List<User>> {
        // 1. Проверяем локальные данные
        val localUsers = localDataSource.getUsers()
        
        // 2. При необходимости обновляем из сети
        try {
            val remoteUsers = remoteDataSource.fetchUsers()
            localDataSource.saveUsers(remoteUsers)
        } catch (e: Exception) {
            // Обработка ошибок сети
        }
        
        // 3. Возвращаем Flow из локальной БД
        return localDataSource.observeUsers()
    }
    
    suspend fun syncUser(user: User) {
        // 1. Сохраняем в локальную БД
        localDataSource.saveUser(user)
        
        // 2. Отправляем на сервер
        remoteDataSource.postUser(user)
    }
}

2. Data Sources (Источники данных) - специализированные модули

LocalDataSource - работа с локальной БД

Отвечает исключительно за операции с базой данных через Room Persistence Library:

class UserLocalDataSource(private val userDao: UserDao) {
    suspend fun saveUsers(users: List<User>) {
        userDao.insertAll(users)
    }
    
    fun observeUsers(): Flow<List<User>> {
        return userDao.getAll()
    }
}

RemoteDataSource - работа с сетевым API

Отвечает исключительно за сетевые операции через Retrofit:

class UserRemoteDataSource(private val apiService: UserApiService) {
    suspend fun fetchUsers(): List<User> {
        return apiService.getUsers()
    }
    
    suspend fun postUser(user: User) {
        apiService.updateUser(user)
    }
}

3. Use Cases/Interactors (Сценарии использования)

Обрабатывают бизнес-логику, используя Repository:

class SyncUserUseCase(private val repository: UserRepository) {
    suspend operator fun invoke(user: User) {
        // Добавление бизнес-правил: валидация, преобразования
        if (user.isValid()) {
            repository.syncUser(user)
        }
    }
}

Полный цикл на примере синхронизации данных

1. ViewModel вызывает Use Case для синхронизации пользователя
2. Use Case выполняет бизнес-логику и обращается к Repository
3. Repository определяет стратегию:
   • Сначала сохраняет в LocalDataSource (Room)
   • Затем отправляет через RemoteDataSource (Retrofit)
   • Обрабатывает конфликты и ошибки

// В ViewModel
viewModelScope.launch {
    try {
        syncUserUseCase(user)
        _uiState.value = UiState.Success
    } catch (e: Exception) {
        _uiState.value = UiState.Error(e.message)
    }
}

Преимущества такого разделения ответственности

• Тестируемость: каждый компонент можно тестировать изолированно
• Гибкость: легко заменить источник данных (например, заменить REST API на GraphQL)
• Соблюдение принципа единой ответственности: каждый класс делает одну вещь
• Сохранение целостности данных: локальная БД выступает как сингл источник истины (single source of truth)

Альтернативные архитектурные подходы

В более сложных приложениях могут использоваться:

• Repository с Mediator LiveData/Flow для автоматического обновления
• Paging Library для пагинации данных
• WorkManager для фоновой синхронизации
• DataStore/SharedPreferences для простых ключ-значение данных

Таким образом, хотя формально Repository является центральным координатором**, реальная работа распределена между LocalDataSource (Room), RemoteDataSource (Retrofit) и вспомогательными компонентами, что обеспечивает поддержку кода и его масштабируемость.