DataSource详解以及优势

目录

• 一、概述
• 二、添加依赖
• [三、Preferences DataStore 详细使用](#三、Preferences DataStore 详细使用 "#%E4%B8%89preferences-datastore-%E8%AF%A6%E7%BB%86%E4%BD%BF%E7%94%A8")
• [四、Proto DataStore 详细使用](#四、Proto DataStore 详细使用 "#%E5%9B%9Bproto-datastore-%E8%AF%A6%E7%BB%86%E4%BD%BF%E7%94%A8")
• 五、完整封装工具类
• 六、核心原理详解
• 七、数据完整性保证机制
• 八、多进程支持
• 九、性能特点
• 十、最佳实践
• 十一、迁移指南
• 十二、对比总结
• 十三、常见问题

---

一、概述

1.1 什么是 DataStore

DataStore 是 Jetpack 提供的异步、一致的数据存储解决方案，用于替代 SharedPreferences。

1.2 核心特点

特性	说明
完全异步	基于 Kotlin 协程和 Flow，不会阻塞 UI 线程
数据一致性	事务性写入，保证数据完整性
类型安全	Proto DataStore 提供编译时类型检查
响应式更新	基于 Flow，数据变化自动通知
损坏恢复	内置 CorruptionHandler 机制
多进程支持	支持 MultiProcessDataStore
迁移支持	支持从 SharedPreferences 平滑迁移

1.3 两种类型对比

类型	特点	适用场景
Preferences DataStore	键值对存储，类似 SharedPreferences	简单配置数据
Proto DataStore	类型安全，使用 Protocol Buffers	复杂数据结构，需要类型安全

1.4 存储位置

/data/data/包名/files/datastore/xxx.preferences_pb

---

二、添加依赖

2.1 build.gradle 配置

dependencies {
    // Preferences DataStore (推荐，简单易用)
    implementation "androidx.datastore:datastore-preferences:1.0.0"

    // Proto DataStore (可选，类型安全)
    implementation "androidx.datastore:datastore:1.0.0"
}

// 如果使用 Proto DataStore，还需要添加插件
plugins {
    id "com.google.protobuf" version "0.9.0"
}

---

三、Preferences DataStore 详细使用

3.1 创建 DataStore 实例

方式一：扩展属性（推荐）

// 在顶层文件或单独的文件中定义
val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
    name = "settings",                    // 文件名
    corruptionHandler = ReplaceFileCorruptionHandler {  // 损坏处理器
        emptyPreferences()
    },
    scope = CoroutineScope(Dispatchers.IO + SupervisorJob()),  // 协程作用域
    produceMigrations = { context ->   // 迁移配置
        listOf(
            SharedPreferencesMigration(context, "old_prefs_name")
        )
    }
)

方式二：单例模式

object DataStoreManager {
    private var INSTANCE: DataStore<Preferences>? = null

    fun getInstance(context: Context): DataStore<Preferences> {
        return INSTANCE ?: synchronized(this) {
            INSTANCE ?: PreferenceDataStoreFactory.create(
                corruptionHandler = ReplaceFileCorruptionHandler { emptyPreferences() },
                migrations = listOf(SharedPreferencesMigration(context, "old_prefs")),
                scope = CoroutineScope(Dispatchers.IO + SupervisorJob()),
                file = context.preferencesDataStoreFile("settings")
            ).also { INSTANCE = it }
        }
    }
}

3.2 定义 Key

/**
 * Preferences Key 定义
 *
 * 支持的类型：String, Int, Long, Float, Double, Boolean, Set<String>
 */
object PreferenceKeys {
    val USER_NAME = stringPreferencesKey("user_name")
    val USER_AGE = intPreferencesKey("user_age")
    val USER_SCORE = floatPreferencesKey("user_score")
    val IS_LOGIN = booleanPreferencesKey("is_login")
    val TIMESTAMP = longPreferencesKey("timestamp")
    val BALANCE = doublePreferencesKey("balance")
    val TAGS = stringSetPreferencesKey("tags")
}

3.3 写入数据

// 写入单个数据
suspend fun saveUserName(context: Context, name: String) {
    context.dataStore.edit { preferences ->
        preferences[PreferenceKeys.USER_NAME] = name
    }
}

// 批量写入数据
suspend fun saveUserInfo(context: Context, name: String, age: Int, isLogin: Boolean) {
    context.dataStore.edit { preferences ->
        preferences[PreferenceKeys.USER_NAME] = name
        preferences[PreferenceKeys.USER_AGE] = age
        preferences[PreferenceKeys.IS_LOGIN] = isLogin
    }
}

// 使用 updateData（返回新数据）
suspend fun incrementLoginCount(context: Context): Int {
    return context.dataStore.updateData { preferences ->
        val currentCount = preferences[PreferenceKeys.LOGIN_COUNT] ?: 0
        preferences.toMutablePreferences().apply {
            this[PreferenceKeys.LOGIN_COUNT] = currentCount + 1
        }
    }[PreferenceKeys.LOGIN_COUNT] ?: 0
}

3.4 读取数据

方式一：Flow 响应式读取（推荐）

// 单个值
val userNameFlow: Flow<String> = context.dataStore.data
    .map { preferences ->
        preferences[PreferenceKeys.USER_NAME] ?: ""
    }

// 组合多个值
data class UserInfo(
    val name: String,
    val age: Int,
    val isLogin: Boolean
)

val userInfoFlow: Flow<UserInfo> = context.dataStore.data
    .map { preferences ->
        UserInfo(
            name = preferences[PreferenceKeys.USER_NAME] ?: "",
            age = preferences[PreferenceKeys.USER_AGE] ?: 0,
            isLogin = preferences[PreferenceKeys.IS_LOGIN] ?: false
        )
    }

方式二：一次性读取

suspend fun getUserName(context: Context): String {
    return context.dataStore.data.first()[PreferenceKeys.USER_NAME] ?: ""
}

方式三：带异常处理的读取

val safeUserNameFlow: Flow<String> = context.dataStore.data
    .catch { exception ->
        if (exception is IOException) {
            emit(emptyPreferences())
        } else {
            throw exception
        }
    }
    .map { preferences ->
        preferences[PreferenceKeys.USER_NAME] ?: ""
    }

3.5 删除数据

// 删除单个 key
suspend fun removeUserName(context: Context) {
    context.dataStore.edit { preferences ->
        preferences.remove(PreferenceKeys.USER_NAME)
    }
}

// 清空所有数据
suspend fun clearAll(context: Context) {
    context.dataStore.edit { preferences ->
        preferences.clear()
    }
}

3.6 监听数据变化

context.dataStore.data
    .map { it[PreferenceKeys.USER_NAME] ?: "" }
    .distinctUntilChanged()  // 只有值真正变化时才通知
    .collect { name ->
        Log.d("DataStore", "Name changed to: $name")
        updateUI(name)
    }

---

四、Proto DataStore 详细使用

4.1 定义 Proto 文件

// app/src/main/proto/user.proto
syntax = "proto3";

option java_package = "com.example.app.data";
option java_multiple_files = true;

message User {
    string name = 1;
    int32 age = 2;
    bool is_login = 3;
    float score = 4;
    int64 timestamp = 5;

    message Address {
        string city = 1;
        string street = 2;
    }

    Address address = 6;
    repeated string tags = 7;  // 列表类型
}

4.2 创建 Serializer

object UserSerializer : Serializer<User> {

    // 默认值，文件不存在或损坏时使用
    override val defaultValue: User = User.getDefaultInstance()
        .toBuilder()
        .setName("")
        .setAge(0)
        .setIsLogin(false)
        .build()

    // 从输入流读取
    override suspend fun readFrom(input: InputStream): User {
        return try {
            User.parseFrom(input)
        } catch (e: InvalidProtocolBufferException) {
            defaultValue
        }
    }

    // 写入到输出流
    override suspend fun writeTo(t: User, output: OutputStream) {
        t.writeTo(output)
    }
}

4.3 创建 Proto DataStore

val Context.userStore: DataStore<User> by dataStore(
    fileName = "user.pb",
    serializer = UserSerializer
)

4.4 读写数据

// 读取数据
val userNameFlow: Flow<String> = context.userStore.data
    .map { user -> user.name }

// 写入数据
suspend fun updateUserName(context: Context, name: String) {
    context.userStore.updateData { user ->
        user.toBuilder()
            .setName(name)
            .build()
    }
}

// 更新嵌套对象
suspend fun updateUserAddress(context: Context, city: String, street: String) {
    context.userStore.updateData { user ->
        val address = User.Address.newBuilder()
            .setCity(city)
            .setStreet(street)
            .build()

        user.toBuilder()
            .setAddress(address)
            .build()
    }
}

---

五、完整封装工具类

/**
 * DataStore 工具类
 */
object DataStoreHelper {

    private const val TAG = "DataStoreHelper"
    private const val DEFAULT_FILE_NAME = "app_config"

    private var dataStore: DataStore<Preferences>? = null

    /**
     * 初始化（在 Application 中调用）
     */
    fun init(context: Context) {
        if (dataStore == null) {
            dataStore = PreferenceDataStoreFactory.create(
                corruptionHandler = ReplaceFileCorruptionHandler { emptyPreferences() },
                migrations = listOf(SharedPreferencesMigration(context, "old_prefs")),
                scope = CoroutineScope(Dispatchers.IO + SupervisorJob()),
                file = context.preferencesDataStoreFile(DEFAULT_FILE_NAME)
            )
        }
    }

    private fun getDataStore(): DataStore<Preferences> {
        return dataStore
            ?: throw IllegalStateException("DataStore not initialized. Call init() first.")
    }

    // ========== 写入操作 ==========

    suspend fun putString(key: String, value: String) {
        getDataStore().edit { it[stringPreferencesKey(key)] = value }
    }

    suspend fun putInt(key: String, value: Int) {
        getDataStore().edit { it[intPreferencesKey(key)] = value }
    }

    suspend fun putLong(key: String, value: Long) {
        getDataStore().edit { it[longPreferencesKey(key)] = value }
    }

    suspend fun putFloat(key: String, value: Float) {
        getDataStore().edit { it[floatPreferencesKey(key)] = value }
    }

    suspend fun putBoolean(key: String, value: Boolean) {
        getDataStore().edit { it[booleanPreferencesKey(key)] = value }
    }

    // ========== 批量写入 ==========

    suspend fun putAll(vararg pairs: Pair<String, Any>) {
        getDataStore().edit { prefs ->
            pairs.forEach { (key, value) ->
                when (value) {
                    is String -> prefs[stringPreferencesKey(key)] = value
                    is Int -> prefs[intPreferencesKey(key)] = value
                    is Long -> prefs[longPreferencesKey(key)] = value
                    is Float -> prefs[floatPreferencesKey(key)] = value
                    is Boolean -> prefs[booleanPreferencesKey(key)] = value
                }
            }
        }
    }

    // ========== 读取操作（Flow）==========

    fun getStringFlow(key: String, defaultValue: String = ""): Flow<String> {
        return getDataStore().data
            .catch { e ->
                if (e is IOException) emit(emptyPreferences())
            }
            .map { it[stringPreferencesKey(key)] ?: defaultValue }
            .distinctUntilChanged()
    }

    fun getIntFlow(key: String, defaultValue: Int = 0): Flow<Int> {
        return getDataStore().data
            .catch { e ->
                if (e is IOException) emit(emptyPreferences())
            }
            .map { it[intPreferencesKey(key)] ?: defaultValue }
            .distinctUntilChanged()
    }

    fun getBooleanFlow(key: String, defaultValue: Boolean = false): Flow<Boolean> {
        return getDataStore().data
            .catch { e ->
                if (e is IOException) emit(emptyPreferences())
            }
            .map { it[booleanPreferencesKey(key)] ?: defaultValue }
            .distinctUntilChanged()
    }

    // ========== 读取操作（一次性）==========

    suspend fun getString(key: String, defaultValue: String = ""): String {
        return getDataStore().data.first()[stringPreferencesKey(key)] ?: defaultValue
    }

    suspend fun getInt(key: String, defaultValue: Int = 0): Int {
        return getDataStore().data.first()[intPreferencesKey(key)] ?: defaultValue
    }

    suspend fun getBoolean(key: String, defaultValue: Boolean = false): Boolean {
        return getDataStore().data.first()[booleanPreferencesKey(key)] ?: defaultValue
    }

    // ========== 删除操作 ==========

    suspend fun remove(key: String) {
        getDataStore().edit { it.remove(stringPreferencesKey(key)) }
    }

    suspend fun clear() {
        getDataStore().edit { it.clear() }
    }

    // ========== 检查操作 ==========

    suspend fun contains(key: String): Boolean {
        return getDataStore().data.first().contains(stringPreferencesKey(key))
    }
}

使用示例

// 在 Application 中初始化
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        DataStoreHelper.init(this)
    }
}

// 在 Activity/ViewModel 中使用
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 写入数据
        lifecycleScope.launch {
            DataStoreHelper.putString("user_name", "张三")
            DataStoreHelper.putInt("user_age", 25)
        }

        // 响应式读取
        lifecycleScope.launch {
            DataStoreHelper.getStringFlow("user_name")
                .collect { name -> textView.text = name }
        }

        // 一次性读取
        lifecycleScope.launch {
            val name = DataStoreHelper.getString("user_name")
            updateUI(name)
        }
    }
}

---

六、核心原理详解

6.1 数据加载流程

首次访问 data 属性：
┌──────────────────────────────────────────────────────────────────┐
│  1. 创建 Flow                                                      │
│     ↓                                                             │
│  2. 检查缓存                                                       │
│     ├── 有缓存 → 直接返回 Flow                                    │
│     └── 无缓存 → 继续加载                                         │
│         ↓                                                         │
│  3. 执行迁移（如果配置了）                                         │
│     SharedPreferencesMigration:                                    │
│       - 读取旧 SP 数据                                            │
│       - 合并到 DataStore                                          │
│       - 删除旧 SP 文件                                            │
│     ↓                                                             │
│  4. 读取文件                                                       │
│     ├── 文件存在 → 解析 ProtoBuf                                  │
│     ├── 文件不存在 → 返回 defaultValue                            │
│     └── 文件损坏 → 触发 CorruptionHandler                         │
│     ↓                                                             │
│  5. 更新缓存并发送给订阅者                                         │
└──────────────────────────────────────────────────────────────────┘

6.2 数据写入流程

edit {} 或 updateData {} 调用：
┌──────────────────────────────────────────────────────────────────┐
│  1. 获取当前数据（等待进行中的写入完成）                           │
│     ↓                                                             │
│  2. 执行转换（调用传入的 lambda）                                  │
│     ↓                                                             │
│  3. 更新内存缓存（立即生效）                                       │
│     ↓                                                             │
│  4. 发送新数据给订阅者                                             │
│     ↓                                                             │
│  5. 写入磁盘                                                       │
│     ├── a. 创建临时文件: file.tmp                                 │
│     ├── b. 序列化数据写入临时文件                                 │
│     ├── c. 调用 FileChannel.force(true) 刷新到磁盘               │
│     ├── d. 原子重命名: file.tmp → file                           │
│     └── e. 删除备份文件                                           │
│     ↓                                                             │
│  6. 完成                                                           │
└──────────────────────────────────────────────────────────────────┘

---

七、数据完整性保证机制

7.1 原子写入机制

为什么需要原子写入？
┌──────────────────────────────────────────────────────────────────┐
│  直接写入的问题：                                                  │
│  原文件: [完整数据]                                               │
│       ↓ 直接写入                                                  │
│  写入中: [一半新数据][一半旧数据]  ← 崩溃！                       │
│       ↓                                                           │
│  结果:   [损坏的数据]  无法恢复                                   │
└──────────────────────────────────────────────────────────────────┘

DataStore 的原子写入：
┌──────────────────────────────────────────────────────────────────┐
│  步骤 1：写入临时文件                                              │
│  原文件: [完整数据]                                               │
│  临时文件: [新数据]  (独立文件)                                   │
│                                                                   │
│  步骤 2：原子重命名                                                │
│  file.renameTo(temp) 是原子操作：                                 │
│  • 要么成功：临时文件完全替换原文件                               │
│  • 要么失败：原文件保持不变                                       │
│  • 不会出现"半替换"状态                                           │
│                                                                   │
│  步骤 3：崩溃恢复                                                  │
│  • 写入前崩溃：原文件完整，临时文件不存在                         │
│  • 写入后崩溃：原文件完整，临时文件被忽略                         │
│  • 重命名后崩溃：新文件完整                                       │
└──────────────────────────────────────────────────────────────────┘

7.2 fsync 确保持久化

// DataStore 在写入时会调用
stream.channel.force(true)  // 等同于 fsync

// 效果：强制将数据从操作系统缓存刷入磁盘
// 代价：写入变慢，但数据安全

7.3 CorruptionHandler 损坏恢复

// 使用内置实现
val Context.dataStore by preferencesDataStore(
    name = "settings",
    corruptionHandler = ReplaceFileCorruptionHandler {
        // 损坏时返回默认数据
        emptyPreferences()
    }
)

// 自定义损坏处理器
class CustomCorruptionHandler : CorruptionHandler<Preferences> {
    override suspend fun handleCorruption(ex: Exception): Preferences {
        Log.w("DataStore", "Data corruption detected", ex)
        // 1. 上报错误
        // 2. 尝试从备份恢复
        // 3. 返回默认值
        return emptyPreferences()
    }
}

---

八、多进程支持

8.1 创建 MultiProcessDataStore

val Context.multiProcessDataStore: DataStore<Preferences> by multiProcessDataStore(
    fileName = "shared_config.preferences_pb",
    corruptionHandler = ReplaceFileCorruptionHandler { emptyPreferences() }
)

8.2 多进程同步原理

核心机制：
┌──────────────────────────────────────────────────────────────────┐
│  1. 文件锁 (FileLock)                                             │
│     • 跨进程互斥                                                  │
│     • 保证写入原子性                                              │
│                                                                   │
│  2. 内容观察者 (ContentObserver)                                   │
│     • 监听文件变化                                                │
│     • 其他进程修改时收到通知                                      │
│                                                                   │
│  3. 主动轮询（兜底）                                               │
│     • 定期检查文件修改时间                                        │
│     • 防止通知丢失                                                │
└──────────────────────────────────────────────────────────────────┘

同步流程：
进程 A (写入)                    进程 B (读取)
┌─────────────────┐            ┌─────────────────┐
│ 1. 获取文件锁   │            │                 │
│ 2. 写入数据     │            │                 │
│ 3. 释放锁       │───────────>│ ContentObserver │
│ 4. 通知变化     │            │ 被触发          │
└─────────────────┘            │ 重新加载数据    │
                               │ 更新 Flow       │
                               └─────────────────┘

8.3 多进程注意事项

// 1. 使用正确的工厂方法
// ✗ 错误：单进程 DataStore
val singleProcessDataStore = context.dataStore

// ✓ 正确：多进程 DataStore
val multiProcessDataStore = MultiProcessDataStoreFactory.create(
    file = context.preferencesDataStoreFile("shared"),
    corruptionHandler = ReplaceFileCorruptionHandler { emptyPreferences() }
)

// 2. 避免竞态条件 - 使用 updateData
suspend fun incrementCounter(dataStore: DataStore<Preferences>) {
    // ✓ 正确：updateData 是原子操作
    dataStore.updateData { prefs ->
        prefs.toMutablePreferences().apply {
            val current = this[COUNTER] ?: 0
            this[COUNTER] = current + 1
        }
    }
}

---

九、性能特点

9.1 内存使用

场景	建议
< 100KB	✅ 推荐
100KB - 1MB	⚠️ 可接受
> 1MB	❌ 不推荐（使用数据库/文件存储）

9.2 读写性能

读取性能：
• 首次读取：需要解析 ProtoBuf 文件，较慢
• 后续读取：直接从内存读取，极快
• Flow 订阅：数据变化时自动通知，无额外开销

写入性能：
• 内存更新：同步，立即生效
• 磁盘写入：异步，在 IO 线程
• fsync 开销：每次写入都会 fsync，保证数据安全

优化建议：
• 批量写入，减少 edit() 调用次数
• 不要在循环中频繁写入
• 使用 distinctUntilChanged() 减少重复通知

---

十、最佳实践

10.1 项目结构

app/
├── src/main/java/com/example/app/
│   ├── data/
│   │   ├── datastore/
│   │   │   ├── DataStoreHelper.kt      # 工具类
│   │   │   └── PreferenceKeys.kt       # Key 定义
│   │   └── proto/
│   │       └── user.proto              # Proto 定义
│   └── ...

10.2 Key 管理

object PreferenceKeys {
    // 用户相关
    object User {
        val NAME = stringPreferencesKey("user_name")
        val AGE = intPreferencesKey("user_age")
        val IS_LOGIN = booleanPreferencesKey("user_is_login")
    }

    // 设置相关
    object Settings {
        val DARK_MODE = booleanPreferencesKey("settings_dark_mode")
        val LANGUAGE = stringPreferencesKey("settings_language")
    }
}

10.3 响应式 UI 集成

// ViewModel 中使用
class UserViewModel(
    private val dataStore: DataStore<Preferences>
) : ViewModel() {

    data class UserUiState(
        val name: String = "",
        val age: Int = 0,
        val isLogin: Boolean = false
    )

    val uiState: StateFlow<UserUiState> = dataStore.data
        .map { prefs ->
            UserUiState(
                name = prefs[PreferenceKeys.User.NAME] ?: "",
                age = prefs[PreferenceKeys.User.AGE] ?: 0,
                isLogin = prefs[PreferenceKeys.User.IS_LOGIN] ?: false
            )
        }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), UserUiState())

    fun updateName(name: String) {
        viewModelScope.launch {
            dataStore.edit { it[PreferenceKeys.User.NAME] = name }
        }
    }
}

// Compose 中使用
@Composable
fun UserScreen(viewModel: UserViewModel) {
    val uiState by viewModel.uiState.collectAsState()

    Column {
        Text(text = "Name: ${uiState.name}")
        Button(onClick = { viewModel.updateName("新名字") }) {
            Text("Update")
        }
    }
}

10.4 异常处理

// 安全读取
val safeFlow = dataStore.data
    .catch { e ->
        Log.e(TAG, "Read failed", e)
        if (e is IOException) {
            emit(emptyPreferences())
        } else {
            throw e
        }
    }
    .map { prefs -> prefs[KEY] ?: defaultValue }

// 安全写入
suspend fun safeWrite(block: Preferences.MutablePreferences.() -> Unit): Boolean {
    return try {
        dataStore.edit(block)
        true
    } catch (e: Exception) {
        Log.e(TAG, "Write failed", e)
        false
    }
}

---

十一、迁移指南

11.1 从 SharedPreferences 迁移

// 方式一：自动迁移（推荐）
val Context.dataStore by preferencesDataStore(
    name = "settings",
    produceMigrations = { context ->
        listOf(
            SharedPreferencesMigration(
                context = context,
                sharedPreferencesName = "old_prefs",
                keysToMigrate = setOf("name", "age", "is_login")  // 可选：指定迁移的 key
            )
        )
    }
)

// 方式二：手动迁移
suspend fun migrateFromSharedPreferences(
    context: Context,
    oldPrefsName: String,
    dataStore: DataStore<Preferences>
) {
    val oldPrefs = context.getSharedPreferences(oldPrefsName, Context.MODE_PRIVATE)

    // 读取旧数据
    val name = oldPrefs.getString("name", "") ?: ""
    val age = oldPrefs.getInt("age", 0)

    // 写入新数据
    dataStore.edit { prefs ->
        prefs[stringPreferencesKey("name")] = name
        prefs[intPreferencesKey("age")] = age
    }

    // 清理旧数据
    oldPrefs.edit().clear().apply()
}

---

十二、对比总结

12.1 DataStore vs SharedPreferences vs MMKV

特性	SharedPreferences	DataStore	MMKV
API 风格	同步	异步 (Flow + 协程)	同步 + 回调
类型安全	✗	✓	△
数据完整性	△ (可能丢失)	✓ (原子写入)	✓ (mmap)
多进程支持	✗ (已废弃)	✓	✓ (原生)
ANR 风险	✓ (有)	△ (低)	✗ (无)
性能	中	中	极高
Jetpack 集成	✗	✓	✗
官方支持	✓	✓	✗ (腾讯)

12.2 选型建议

场景	推荐
新项目	DataStore (Preferences 或 Proto)
高性能需求	MMKV
多进程高频访问	MMKV
旧项目维护	SharedPreferences
需要 Jetpack 集成	DataStore

---

─────────────────────────────────────────────────────────────────────────────────┐
│                    核心特性对比                                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   特性              │  SP           │  DataStore     │  MMKV                  │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   发布者            │  Google       │  Google/Jetpack │  腾讯                  │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   存储格式          │  XML          │  ProtoBuf       │  内存映射 + 二进制     │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   数据结构          │  键值对       │  键值对/Proto   │  键值对                │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   API 风格          │  同步         │  异步+ 协程│  同步 + 异步回调       │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   类型安全          │  ✗            │  ✓              │  △ (部分)              │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   数据完整性        │  △ (可能丢失) │  ✓ (原子写入)   │  ✓ (mmap 特性)        │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   多进程支持        │  ✗ (已废弃)  │  ✓ (MultiProcess)│  ✓ (原生支持)         │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   ANR 风险          │  ✓ (有)       │  △ (apply 可能) │  ✗ (无)               │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   跨平台            │  ✗            │  ✗              │  ✓ (Android/iOS/等)  │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   加密支持          │  ✗            │  ✗              │  ✓ (CRC/加密)         │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   包体积增量        │  0             │  ~50KB          │  ~500KB              │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   读取性能          │  中           │  中              │  极高                │
│   ──────────────────┼───────────────┼────────────────┼────────────────────────│
│   写入性能          │  慢           │  中              │  极高                │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────

十三、常见问题

Q1: DataStore 和 SharedPreferences 可以同时使用吗？

不建议。如果使用 DataStore，应该迁移所有 SharedPreferences 数据，避免数据不一致。

Q2: 如何处理大量数据？

DataStore 不适合存储大量数据（> 1MB）。建议使用：

• Room 数据库（结构化数据）
• 文件存储（大文件）
• MMKV（高性能键值对）

Q3: apply() 会阻塞吗？

DataStore 没有 apply/commit 的概念。所有写入都是异步的，通过 edit 或 updateData 完成。

Q4: 如何在 Java 中使用？

DataStore 基于 Kotlin 协程，在 Java 中使用较复杂。建议：

• 使用 MMKV（更好的 Java 支持）
• 或者通过 LiveData 转换

Q5: 多进程性能如何？

DataStore 多进程通过 ContentProvider + FileLock 实现，有一定性能开销。如果需要高频多进程访问，建议使用 MMKV。

---

附录：参考资料

• DataStore 官方文档
• SharedPreferences 迁移指南
• Proto DataStore