Где будешь хранить кеш в твоем проекте?

Подход к кешированию в Android-проекте

Кеширование в современном Android-приложении — это многоуровневая архитектура, где каждый слой решает конкретные задачи. Я всегда реализую гибридный подход, сочетающий несколько стратегий хранения.

1. In-Memory кеш (оперативная память)

Для быстрого доступа к часто используемым данным:

// Использую LruCache или реализацию на основе Map с TTL
class MemoryCache<K, V>(private val maxSize: Int) {
    private val cache = LinkedHashMap<K, CacheEntry<V>>(maxSize, 0.75f, true)
    
    data class CacheEntry<V>(val value: V, val timestamp: Long)
    
    operator fun get(key: K): V? {
        return cache[key]?.takeIf { isValid(it) }?.value
    }
    
    private fun isValid(entry: CacheEntry<V>): Boolean {
        return System.currentTimeMillis() - entry.timestamp < MAX_AGE
    }
}

Преимущества:

• Мгновенный доступ к данным
• Идеально для конфигураций, UI-состояний, флагов
• Минимальные накладные расходы

2. Дисковый кеш (файловая система)

Для персистентного хранения:

// Использую Room Database для структурированных данных
@Entity(tableName = "cache_entries")
data class CacheEntity(
    @PrimaryKey val key: String,
    @ColumnInfo(name = "value") val value: String,
    @ColumnInfo(name = "timestamp") val timestamp: Long,
    @ColumnInfo(name = "ttl") val ttl: Long
)

@Dao
interface CacheDao {
    @Query("SELECT * FROM cache_entries WHERE key = :key AND timestamp + ttl > :currentTime")
    suspend fun getValidEntry(key: String, currentTime: Long): CacheEntity?
}

Для бинарных данных (изображения, файлы):

// OkHttp DiskLruCache или кастомное решение
class DiskFileCache(
    private val cacheDir: File,
    private val maxSize: Long
) {
    fun getFile(key: String): File? {
        val file = File(cacheDir, key.hashCode().toString())
        return file.takeIf { it.exists() && isValid(it) }
    }
}

3. SharedPreferences vs DataStore

Для небольших примитивов и конфигураций:

// Предпочитаю DataStore из-за асинхронности и типобезопасности
val Context.settingsDataStore: DataStore<Preferences> by preferencesDataStore(
    name = "settings_cache"
)

val IS_DARK_THEME = booleanPreferencesKey("is_dark_theme")

suspend fun saveThemePreference(isDark: Boolean) {
    context.settingsDataStore.edit { preferences ->
        preferences[IS_DARK_THEME] = isDark
    }
}

4. Сетевое кеширование

Использую HTTP-кеширование через OkHttp/Retrofit:

val cacheSize = 10L * 1024L * 1024L // 10 MB
val cache = Cache(File(context.cacheDir, "http_cache"), cacheSize)

val okHttpClient = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor(CacheInterceptor())
    .build()

class CacheInterceptor : Interceptor {
    override fun intercept(chain: Chain): Response {
        val request = chain.request()
        // Кастомная логика кеширования
        if (NetworkUtils.isNetworkAvailable()) {
            request = request.newBuilder()
                .header("Cache-Control", "public, max-age=60")
                .build()
        }
        return chain.proceed(request)
    }
}

5. Архитектурные принципы

Реализую через репозиторий с стратегиями:

class CachedRepository(
    private val memoryCache: MemoryCache<String, Data>,
    private val diskCache: DiskCache,
    private val remoteSource: RemoteDataSource
) {
    suspend fun getData(key: String): Data {
        return memoryCache.get(key)
            ?: diskCache.get(key)
            ?: remoteSource.fetch(key).also { data ->
                memoryCache.put(key, data)
                diskCache.save(key, data)
            }
    }
}

Критерии выбора стратегии

Обязательно учитываю:

• Объем данных — для больших файлов (изображения, видео) использую дисковое кеширование
• Частоту доступа — hot data храню в памяти
• Время жизни — реализую TTL (Time-To-Live) механизмы
• Чувствительность к актуальности — для финансовых данных минимизирую кеширование
• Безопасность — для чувствительных данных добавляю шифрование
• Производительность — профилирую hit/miss ratio для оптимизации

Мониторинг и отладка

Всегда добавляю инструменты мониторинга:

• Логирование hit/miss статистики
• Метрики размера кеша
• Автоматическую очистку при нехватке памяти
• Инвалидацию кеша при логине/логауте пользователя

Такой многоуровневый подход обеспечивает оптимальный баланс между производительностью, надежностью хранения данных и эффективным использованием ресурсов устройства. Ключевой принцип — каждый тип данных получает наиболее подходящую стратегию кеширования, а не универсальное решение для всех случаев.