如何用redux-persist实现多键数据持久化以规避Android SQLite限制？

方案1：拆分Persist Reducer，多键独立存储 #

这是最直接的解决方案——将原本的根Reducer拆分为多个子Reducer，给每个子Reducer单独配置persistReducer并指定独立的存储键。这样每个模块的数据会存在单独的AsyncStorage键下，单个键的大小就不会触发2MB限制。

示例代码：

// userReducer.js
const initialUserState = { /* 用户模块初始状态 */ };
const userReducer = (state = initialUserState, action) => {
  // 用户模块的Reducer逻辑
};

// 为用户模块配置独立的持久化
export const persistedUserReducer = persistReducer(
  {
    key: 'app_user',
    storage: AsyncStorage,
    // 可按需添加whitelist/blacklist控制持久化字段
  },
  userReducer
);

// settingsReducer.js
const initialSettingsState = { /* 设置模块初始状态 */ };
const settingsReducer = (state = initialSettingsState, action) => {
  // 设置模块的Reducer逻辑
};

export const persistedSettingsReducer = persistReducer(
  {
    key: 'app_settings',
    storage: AsyncStorage,
  },
  settingsReducer
);

合并持久化后的Reducer并创建Store：

import { combineReducers, createStore } from 'redux';
import { persistStore } from 'redux-persist';
import { persistedUserReducer, persistedSettingsReducer } from './reducers';

const rootReducer = combineReducers({
  user: persistedUserReducer,
  settings: persistedSettingsReducer,
});

export const store = createStore(rootReducer);
export const persistor = persistStore(store);

这种方案的优势是逻辑清晰，完全贴合Redux的模块化设计，且不需要修改底层存储逻辑。

方案2：自定义Transform拆分大体积单Reducer数据 #

如果不想拆分Reducer，可以利用react-persist的createTransformAPI，将单个大体积State拆分为多个AsyncStorage键存储，读取时再合并回原State结构。

示例代码：

import { createTransform } from 'redux-persist';
import AsyncStorage from '@react-native-async-storage/async-storage';

// 创建自定义Transform，拆分大字段
const largeDataSplitTransform = createTransform(
  // 存储时：将大字段单独存入子键，返回剥离大字段后的State
  (inboundState) => {
    // 假设State中有两个大字段：bigDataA、bigDataB
    if (inboundState.bigDataA) {
      AsyncStorage.setItem('root_bigDataA', JSON.stringify(inboundState.bigDataA));
    }
    if (inboundState.bigDataB) {
      AsyncStorage.setItem('root_bigDataB', JSON.stringify(inboundState.bigDataB));
    }
    return { ...inboundState, bigDataA: null, bigDataB: null };
  },
  // 读取时：从子键中恢复大字段，合并回State
  async (outboundState) => {
    try {
      const bigDataA = await AsyncStorage.getItem('root_bigDataA');
      const bigDataB = await AsyncStorage.getItem('root_bigDataB');
      return {
        ...outboundState,
        bigDataA: bigDataA ? JSON.parse(bigDataA) : null,
        bigDataB: bigDataB ? JSON.parse(bigDataB) : null,
      };
    } catch (err) {
      console.error('恢复大字段失败:', err);
      return outboundState;
    }
  },
  // 指定仅对根Reducer应用此Transform
  { whitelist: ['root'] }
);

// 配置持久化时添加Transform
const persistConfig = {
  key: 'root',
  storage: AsyncStorage,
  transforms: [largeDataSplitTransform],
};

const persistedReducer = persistReducer(persistConfig, rootReducer);

注意：使用此方案需要额外处理数据清理（比如删除根键时要同步删除子键），以及异步读取的错误捕获。

方案3：替换底层存储为文件系统存储 #

如果AsyncStorage的SQLite限制难以绕过，可以将react-persist的底层存储替换为基于文件系统的实现，每个持久化键对应一个独立文件，天然避免单键大小限制。

示例代码：

import FSStorage from 'redux-persist-fs-storage';
import { persistReducer } from 'redux-persist';

const persistConfig = {
  key: 'root',
  // 使用文件系统存储替代AsyncStorage
  storage: FSStorage(),
  // 可选：指定存储路径（默认是应用文档目录）
  // storage: FSStorage({ path: `${RNFS.DocumentDirectoryPath}/my-app-storage` })
};

const persistedReducer = persistReducer(persistConfig, rootReducer);

此方案的优势是无需修改现有Reducer结构，但需要额外安装依赖包，且文件系统的读写性能略低于AsyncStorage。

内容的提问来源于stack exchange，提问作者Fclass