Android 开发者必知必会的 8 种缓存策略

前言

作为安卓开发者，我们都曾经历过这样的窘境——眼睁睁地看着用户因为加载时间过长、网络请求过多或离线功能糟糕而放弃我们的应用。解决方案是什么？答案是实施战略性的缓存，这能将你的应用从迟钝变为闪电般迅速。

本文介绍每位安卓开发者都应掌握的八种强大的缓存策略，并提供完整的 Kotlin 实现和真实场景示例。

为什么缓存比以往任何时候都更重要

在深入研究具体实现之前，让我们先理解为什么缓存对于现代安卓应用至关重要：

• 性能提升 (Performance): 将加载时间从几秒缩短到几毫秒。
• 用户体验 (User Experience): 提供即时可用的内容。
• 网络效率 (Network Efficiency): 最大限度地减少昂贵的 API 调用和数据使用。
• 离线能力 (Offline Capability): 在没有互联网连接的情况下也能使用应用功能。
• 电池续航 (Battery Life): 减少消耗电池的网络操作。
  根据谷歌的数据，用户期望应用在 3 秒内加载完成。如果没有适当的缓存，要达到这个期望几乎是不可能的。

策略 1：内存缓存 (In-Memory Caching) — 速度之王

内存缓存是你对抗性能瓶颈的第一道防线。它将数据直接存储在 RAM 中，提供最快的访问速度。

实现

import java.util.LinkedHashMap
import kotlin.collections.MutableMap
class InMemoryCache<K, V>(private val maxSize: Int) {
    // 使用 LinkedHashMap 实现 LRU (最近最少使用) 策略
    private val cache = object : LinkedHashMap<K, V>(16, 0.75f, true) {
        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<K, V>?): Boolean {
            // 当缓存大小超过最大值时，移除最旧的条目
            return size > maxSize
        }
    }
    @Synchronized
    fun put(key: K, value: V) {
        cache[key] = value
    }
    @Synchronized
    fun get(key: K): V? = cache[key]
    @Synchronized
    fun remove(key: K): V? = cache.remove(key)
    @Synchronized
    fun clear() = cache.clear()
}

真实场景用法

class UserRepository {
    private val userCache = InMemoryCache<String, User>(100) // 最多缓存 100 个用户对象
    suspend fun getUser(userId: String): User? {
        // 首先进行闪电般的缓存检查
        userCache.get(userId)?.let { return it }
        // 仅在必要时才回退到网络请求
        val user = apiService.getUser(userId)
        user?.let { userCache.put(userId, it) }
        return user
    }
}

• 适用场景: 频繁访问的对象、用户个人资料、配置数据，或任何需要即时检索的数据。
• 优点: 访问速度最快，通过 LRU 策略自动管理内存。
• 缺点: 应用重启后数据丢失，受限于可用 RAM 大小。

策略 2：SharedPreferences 缓存 — 持久化的轻量级选手

对于需要在应用重启后依然存在的小型持久化数据，SharedPreferences 提供了一个出色的缓存解决方案。

高级 SharedPreferences 缓存实现

import android.content.Context
import com.google.gson.Gson
class PreferencesCache(private val context: Context) {
    private val prefs = context.getSharedPreferences("app_cache", Context.MODE_PRIVATE)
    private val gson = Gson()
    fun <T> put(key: String, value: T) {
        val json = gson.toJson(value)
        prefs.edit().putString(key, json).apply()
    }
    inline fun <reified T> get(key: String): T? {
        val json = prefs.getString(key, null) ?: return null
        return try {
            gson.fromJson(json, T::class.java)
        } catch (e: Exception) {
            null
        }
    }
    fun remove(key: String) {
        prefs.edit().remove(key).apply()
    }
    fun clear() {
        prefs.edit().clear().apply()
    }
}

实际应用

class SettingsRepository(context: Context) {
    private val cache = PreferencesCache(context)
    fun saveUserSettings(settings: UserSettings) {
        cache.put("user_settings", settings)
    }
    fun getUserSettings(): UserSettings? {
        return cache.get<UserSettings>("user_settings")
    }
}

• 适用场景: 用户偏好设置、应用配置、认证令牌、小型配置对象。
• 优点: 应用重启后数据依然存在，实现简单，可自动进行 JSON 序列化。
• 缺点: 存储大小有限，涉及同步 I/O 操作（尽管 apply() 是异步的）。

策略 3：基于文件的缓存 — 重量级选手

当你需要缓存大量数据或二进制内容时，基于文件的缓存就变得至关重要。

健壮的文件缓存实现

import android.content.Context
import java.io.File
class FileCache(private val context: Context) {
    private val cacheDir = File(context.cacheDir, "file_cache")
    init {
        if (!cacheDir.exists()) {
            cacheDir.mkdirs()
        }
    }
    fun put(key: String, data: ByteArray) {
        try {
            // 使用 key 的哈希码作为文件名，以避免非法字符问题
            val file = File(cacheDir, key.hashCode().toString())
            file.writeBytes(data)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    fun put(key: String, text: String) {
        put(key, text.toByteArray())
    }
    fun get(key: String): ByteArray? {
        return try {
            val file = File(cacheDir, key.hashCode().toString())
            if (file.exists()) file.readBytes() else null
        } catch (e: Exception) {
            null
        }
    }
    fun getString(key: String): String? {
        return get(key)?.toString(Charsets.UTF_8)
    }
    fun getCacheSize(): Long {
        return cacheDir.listFiles()?.sumOf { it.length() } ?: 0L
    }
    fun clear() {
        cacheDir.listFiles()?.forEach { it.delete() }
    }
}

• 适用场景: 图片、大型 JSON 响应、下载的文件、API 响应缓存。
• 优点: 没有大小限制，应用重启后数据依然存在，系统可在存储空间不足时自动清理。
• 缺点: 比内存缓存慢，需要进行磁盘 I/O 操作。

策略 4：使用 Room 的数据库缓存 — 结构化方案

对于复杂的数据关系和高级查询需求，Room 数据库缓存提供了最强大的解决方案。

基于 Room 的缓存实现

import androidx.room.*
@Entity(tableName = "cached_articles")
data class CachedArticle(
    @PrimaryKey val id: String,
    val title: String,
    val content: String,
    val timestamp: Long = System.currentTimeMillis()
)
@Dao
interface CacheDao {
    @Query("SELECT * FROM cached_articles WHERE id = :id")
    suspend fun get(id: String): CachedArticle?
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(article: CachedArticle)
    @Query("DELETE FROM cached_articles WHERE timestamp < :cutoff")
    suspend fun deleteOldEntries(cutoff: Long)
    @Query("SELECT COUNT(*) FROM cached_articles")
    suspend fun getCacheSize(): Int
}
@Database(entities = [CachedArticle::class], version = 1)
abstract class CacheDatabase : RoomDatabase() {
    abstract fun cacheDao(): CacheDao
}

• 适用场景: 复杂数据结构、离线优先的应用、需要查询的数据、关系型数据。
• 优点: 具备 ACID（原子性、一致性、隔离性、持久性）特性，支持复杂查询和关系，保证数据完整性。
• 缺点: 设置更复杂，需要引入 Room 依赖，对于简单数据来说有些大材小用。

策略 5：多级缓存 — 终极性能系统

最强大的方法是结合多种缓存策略，创建一个层次结构，从而同时优化速度和持久性。

高级多级缓存实现

class MultiLevelCache(
    private val context: Context,
    private val database: CacheDatabase
) {
    private val memoryCache = InMemoryCache<String, CachedArticle>(50)
    private val fileCache = FileCache(context)
    private val cacheDao = database.cacheDao()
    suspend fun get(key: String): CachedArticle? {
        // 第一级：内存缓存 (最快 - 约 1ms)
        memoryCache.get(key)?.let { 
            println("Cache HIT: L1 Memory")
            return it 
        }
        // 第二级：数据库缓存 (约 5-10ms)
        val dbResult = cacheDao.get(key)
        dbResult?.let { 
            println("Cache HIT: L2 Database")
            memoryCache.put(key, it) // 提升到 L1 缓存
            return it 
        }
        println("Cache MISS: All levels")
        return null
    }
    suspend fun put(key: String, article: CachedArticle) {
        // 存储到所有级别以实现最大可用性
        memoryCache.put(key, article)
        cacheDao.insert(article)
        // 可选的文件备份
        val json = Gson().toJson(article)
        fileCache.put(key, json)
    }
    suspend fun clearExpired(maxAge: Long = 24 * 60 * 60 * 1000) { // 默认 24 小时
        val cutoff = System.currentTimeMillis() - maxAge
        cacheDao.deleteOldEntries(cutoff)
    }
}

• 适用场景: 高性能应用、复杂数据需求、网络条件多变的应用。
• 优点: 最佳性能，容错性强，灵活的存储选项。
• 缺点: 增加了复杂性，更高的内存占用，需要维护更多代码。

策略 6：TTL (Time To Live) 缓存 — 智能过期系统

数据的新鲜度至关重要。TTL 缓存自动处理数据过期，确保你的用户总能获得相关信息。

智能 TTL 实现

import java.util.concurrent.ConcurrentHashMap
data class CacheEntry<T>(
    val data: T,
    val timestamp: Long,
    val ttl: Long // Time To Live in milliseconds
) {
    fun isExpired(): Boolean = System.currentTimeMillis() - timestamp > ttl
}
class TTLCache<K, V>(private val defaultTtl: Long = 5 * 60 * 1000) { // 默认 5 分钟
    private val cache = ConcurrentHashMap<K, CacheEntry<V>>()
    fun put(key: K, value: V, ttl: Long = defaultTtl) {
        val entry = CacheEntry(value, System.currentTimeMillis(), ttl)
        cache[key] = entry
    }
    fun get(key: K): V? {
        val entry = cache[key] ?: return null
        return if (entry.isExpired()) {
            cache.remove(key) // 自动清理过期条目
            null
        } else {
            entry.data
        }
    }
    // 定期清理任务
    fun cleanExpired() {
        val iterator = cache.iterator()
        while (iterator.hasNext()) {
            val entry = iterator.next()
            if (entry.value.isExpired()) {
                iterator.remove()
            }
        }
    }
}

使用示例

class TokenManager {
    private val tokenCache = TTLCache<String, AuthToken>()
    fun cacheToken(userId: String, token: AuthToken) {
        // 将令牌缓存 1 小时
        tokenCache.put(userId, token, 60 * 60 * 1000)
    }
    fun getValidToken(userId: String): AuthToken? {
        return tokenCache.get(userId) // 如果过期则返回 null
    }
}

• 适用场景: 认证令牌、有已知新鲜度要求的 API 响应、临时数据。
• 优点: 自动过期，防止陈旧数据，可为每个条目配置不同的 TTL。
• 缺点: 额外的内存开销，需要定期清理。

策略 7：使用 OkHttp 的 HTTP 缓存 — 网络优化器

让 OkHttp 自动处理网络级别的缓存，减少冗余的 API 调用并改善响应时间。

智能 HTTP 缓存设置

import okhttp3.Cache
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.io.File
class NetworkRepository(private val context: Context) {
    private val client = OkHttpClient.Builder()
        .cache(Cache(File(context.cacheDir, "http_cache"), 10 * 1024 * 1024)) // 10MB 缓存
        .addInterceptor { chain -> // 注意：这里使用 addInterceptor 更适合修改响应头
            val request = chain.request()
            val response = chain.proceed(request)
            val cacheControl = if (isNetworkAvailable()) {
                "public, max-age=300" // 在线时缓存 5 分钟
            } else {
                "public, only-if-cached, max-stale=${60 * 60 * 24 * 7}" // 离线时使用一周内的旧缓存
            }
            response.newBuilder()
                .header("Cache-Control", cacheControl)
                .build()
        }
        .build()
    private val retrofit = Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .client(client)
        .addConverterFactory(GsonConverterFactory.create())
        .build()
    private val api = retrofit.create(ApiService::class.java)
    suspend fun getData(): List<DataItem> {
        return api.getData() // 由 OkHttp 自动缓存
    }
    private fun isNetworkAvailable(): Boolean {
        // 实现网络状态检查逻辑
        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as android.net.ConnectivityManager
        val activeNetwork = cm.activeNetworkInfo
        return activeNetwork?.isConnectedOrConnecting == true
    }
}

• 适用场景: REST API 调用、图片加载、任何基于 HTTP 的数据获取。
• 优点: 自动缓存管理，遵循 HTTP 头部规则，支持离线工作。
• 缺点: 仅限于 HTTP 请求，依赖于服务器的缓存头（或客户端覆写）。

策略 8：统一缓存管理器 — 一站式解决方案

通过一个统一的缓存管理器将所有策略整合在一起，为复杂的缓存策略提供一个简单的接口。

完整的缓存管理器

class CacheManager private constructor(context: Context) {
    companion object {
        @Volatile
        private var INSTANCE: CacheManager? = null
        fun getInstance(context: Context): CacheManager {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: CacheManager(context.applicationContext).also { INSTANCE = it }
            }
        }
    }
    private val memoryCache = InMemoryCache<String, Any>(100)
    private val prefsCache = PreferencesCache(context)
    private val fileCache = FileCache(context)
    private val ttlCache = TTLCache<String, Any>()
    inline fun <reified T : Any> get(key: String, strategy: CacheStrategy = CacheStrategy.MEMORY_FIRST): T? {
        return when (strategy) {
            CacheStrategy.MEMORY_ONLY -> memoryCache.get(key) as? T
            CacheStrategy.PREFS_ONLY -> prefsCache.get<T>(key)
            CacheStrategy.TTL_ONLY -> ttlCache.get(key) as? T
            CacheStrategy.MEMORY_FIRST -> {
                (memoryCache.get(key) as? T)
                    ?: (prefsCache.get<T>(key)?.also { memoryCache.put(key, it) })
            }
        }
    }
    fun <T: Any> put(key: String, value: T, strategy: CacheStrategy = CacheStrategy.MEMORY_FIRST) {
        when (strategy) {
            CacheStrategy.MEMORY_ONLY -> memoryCache.put(key, value)
            CacheStrategy.PREFS_ONLY -> prefsCache.put(key, value)
            CacheStrategy.TTL_ONLY -> ttlCache.put(key, value)
            CacheStrategy.MEMORY_FIRST -> {
                memoryCache.put(key, value)
                prefsCache.put(key, value)
            }
        }
    }
    fun clearAll() {
        memoryCache.clear()
        prefsCache.clear()
        fileCache.clear()
        ttlCache.cleanExpired() // 或者直接 clear()
    }
}
enum class CacheStrategy {
    MEMORY_ONLY,
    PREFS_ONLY,
    TTL_ONLY,
    MEMORY_FIRST // 示例：先内存，后 SharedPreferences
}

生产环境应用的最佳实践

1. 缓存策略选择矩阵

2. 内存管理

class CacheMemoryManager {
    fun monitorMemoryUsage() {
        val runtime = Runtime.getRuntime()
        val usedMemory = runtime.totalMemory() - runtime.freeMemory()
        val maxMemory = runtime.maxMemory()
        // 当已用内存超过最大内存的 80% 时
        if (usedMemory > maxMemory * 0.8) {
            // 触发缓存清理
            clearLeastImportantCaches()
        }
    }
    private fun clearLeastImportantCaches() {
        // 优先级：保留用户数据，首先清理临时数据
        // imageCache.clear()
        // temporaryDataCache.clear()
        println("Clearing non-critical caches due to memory pressure.")
    }
}

3. 缓存失效策略

class CacheInvalidationManager(
    private val memoryCache: InMemoryCache<String, Any>,
    private val cacheDao: CacheDao
) {
    fun invalidateUserData(userId: String) {
        // 级联失效
        memoryCache.remove("user_$userId")
        memoryCache.remove("user_profile_$userId")
        memoryCache.remove("user_settings_$userId")
        // 更新数据库查询的时间戳或直接删除
        // updateUserDataTimestamp(userId)
    }
    fun invalidateExpiredData() {
        // 使用协程在后台执行
        GlobalScope.launch {
            val cutoffTime = System.currentTimeMillis() - TimeUnit.HOURS.toMillis(24)
            cacheDao.deleteOldEntries(cutoffTime)
        }
    }
}

4. 测试你的缓存实现

import org.junit.Test
import org.junit.Assert.*
class CacheTest {
    @Test
    fun testCachePerformance() {
        val cache = InMemoryCache<String, String>(100)
        val startTime = System.nanoTime()
        // 测试缓存操作
        cache.put("test", "value")
        val result = cache.get("test")
        val endTime = System.nanoTime()
        val duration = endTime - startTime
        // 断言缓存操作应在 1ms 以下
        assertTrue("Cache operation should be under 1ms", duration < 1_000_000)
        assertEquals("value", result)
    }
}

性能影响：真实数据

基于真实世界的实现，你可以期待以下效果：

• 内存缓存: 0.1–1ms 访问时间，对于频繁访问的数据有 90%+ 的命中率。
• 数据库缓存: 5–15ms 访问时间，非常适合离线场景。
• 文件缓存: 10–50ms 访问时间，能有效处理大数据。
• HTTP 缓存: 减少 50–90% 的网络请求。
• 多级缓存: 集各家之长，命中率可达 95%+，并带有回退选项。

需要避免的常见陷阱

1. 内存泄漏

// 错误：存储 Activity context
class BadCache(private val context: Activity) // 不要这样做！
// 正确：使用 Application context
class GoodCache(private val context: Context) {
    private val appContext = context.applicationContext
}

2. 线程安全问题

// 错误：非线程安全的缓存
private val cache = HashMap<String, Any>()
// 正确：线程安全的替代方案
private val cache = ConcurrentHashMap<String, Any>()
// 或者
private val cache = Collections.synchronizedMap(HashMap<String, Any>())

3. 过度缓存

// 错误：缓存所有东西
fun cacheEverything(data: Any) {
    cache.put(UUID.randomUUID().toString(), data) // 内存泄漏！
}
// 正确：带有大小限制的策略性缓存
fun cacheStrategically(key: String, data: Any) {
    if (isWorthCaching(data)) {
        // 假设 cache 是一个有大小限制的 LRUCache
        cache.put(key, data)
    }
}

结论

实施正确的缓存策略可以将你的安卓应用从平庸提升到卓越。关键在于理解你的数据模式、用户行为和性能要求。
从简单的内存缓存开始以获得立竿见影的效果，然后随着应用的增长逐步实施更复杂的策略。请记住，最佳的缓存策略通常是多种方法协同工作的结果。
你的用户会立即注意到差异——更快的加载时间、更好的离线功能以及更流畅的整体体验，这些都会让他们愿意再次使用你的应用。