Android序列化对象存储到SharedPreferences全解析

在Android开发中，SharedPreferences作为轻量级数据存储方案，广泛应用于保存用户偏好设置、应用状态等简单数据。然而，当需要存储复杂对象时，直接使用SharedPreferences的put方法会遇到限制。本文将详细介绍如何通过序列化技术将对象安全存储到SharedPreferences，并提供完整的实现方案与优化建议。

一、SharedPreferences基础与限制

SharedPreferences是Android提供的基于XML文件的键值对存储系统，适用于存储基本数据类型（int、String、boolean等）。其核心特点包括：

• 轻量级：适合存储少量数据
• 异步访问：通过apply()实现非阻塞写入
• 自动备份：部分系统支持自动备份到云端

典型使用场景：

// 存储基本类型
SharedPreferences pref = getSharedPreferences("MyPrefs", MODE_PRIVATE);
pref.edit().putString("username", "user123").apply();
// 读取基本类型
String username = pref.getString("username", null);

存储限制：

1. 仅支持基本数据类型及其数组
2. 不支持复杂对象直接存储
3. 大数据量存储性能下降

二、对象序列化技术选型

要实现对象存储，必须先将对象转换为可存储格式。Android开发中主要有两种序列化方式：

1. Java原生序列化

通过实现Serializable接口实现：

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    // 构造方法、getter/setter省略
}

优点：

• Java标准支持
• 实现简单

缺点：

• 性能较差
• 序列化结果包含类元数据，存在安全隐患
• 不支持跨语言

2. JSON序列化（推荐）

使用Gson或Moshi等库将对象转为JSON字符串：

// 使用Gson示例
Gson gson = new Gson();
String userJson = gson.toJson(user); // 序列化
User user = gson.fromJson(userJson, User.class); // 反序列化

优势：

• 性能优于Java序列化
• 跨平台支持
• 可读性强
• 更小的存储空间

三、完整实现方案

1. 基础实现代码

public class PrefsHelper {
    private static final String PREFS_NAME = "AppPrefs";
    private final SharedPreferences prefs;
    private final Gson gson;
    public PrefsHelper(Context context) {
        prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        gson = new Gson();
    }
    // 存储对象
    public void saveObject(String key, Object object) {
        String json = gson.toJson(object);
        prefs.edit().putString(key, json).apply();
    }
    // 读取对象
    public <T> T getObject(String key, Class<T> classOfT) {
        String json = prefs.getString(key, null);
        return json == null ? null : gson.fromJson(json, classOfT);
    }
}

2. 类型安全增强版

public class SafePrefsHelper<T> {
    private final SharedPreferences prefs;
    private final Gson gson;
    private final Class<T> type;
    public SafePrefsHelper(Context context, String prefsName, Class<T> type) {
        this.prefs = context.getSharedPreferences(prefsName, Context.MODE_PRIVATE);
        this.gson = new GsonBuilder().create();
        this.type = type;
    }
    public void save(String key, T object) {
        if (object == null) {
            prefs.edit().remove(key).apply();
            return;
        }
        String json = gson.toJson(object);
        prefs.edit().putString(key, json).apply();
    }
    public T get(String key) {
        String json = prefs.getString(key, null);
        return json == null ? null : gson.fromJson(json, type);
    }
}

四、性能优化策略

1. 批量操作优化

// 批量存储
public void saveAll(Map<String, Object> dataMap) {
    SharedPreferences.Editor editor = prefs.edit();
    for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
        String json = gson.toJson(entry.getValue());
        editor.putString(entry.getKey(), json);
    }
    editor.apply(); // 或commit()同步执行
}

2. 序列化配置优化

// 使用GsonBuilder配置更高效的序列化
Gson gson = new GsonBuilder()
    .setPrettyPrinting(false) // 禁用格式化减少空间
    .excludeFieldsWithoutExposeAnnotation() // 只序列化有@Expose注解的字段
    .create();

3. 存储空间优化

• 对大对象考虑分块存储
• 使用压缩算法（如GZIP）处理大型JSON
• 定期清理过期数据

五、安全注意事项

1. 敏感数据保护

// 加密存储示例
public class EncryptedPrefsHelper {
    private static final String AES = "AES";
    private static final String SECRET_KEY = "YourSecretKey123"; // 实际应使用安全存储的密钥
    public String encrypt(String value) {
        try {
            SecretKeySpec key = new SecretKeySpec(SECRET_KEY.getBytes(), AES);
            Cipher cipher = Cipher.getInstance(AES);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] encrypted = cipher.doFinal(value.getBytes());
            return Base64.encodeToString(encrypted, Base64.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    // 解密方法省略...
}

2. 反序列化安全

• 验证反序列化对象是否为预期类型
• 捕获并处理解析异常
• 避免反序列化不可信来源的数据

六、实际应用案例

1. 用户会话管理

public class SessionManager {
    private final SafePrefsHelper<UserSession> prefs;
    public SessionManager(Context context) {
        prefs = new SafePrefsHelper<>(context, "SessionPrefs", UserSession.class);
    }
    public void saveSession(UserSession session) {
        prefs.save("current_session", session);
    }
    public UserSession getSession() {
        return prefs.get("current_session");
    }
    public boolean isLoggedIn() {
        return getSession() != null;
    }
}

2. 应用配置持久化

public class AppConfig {
    private boolean isDarkMode;
    private int fontSize;
    private List<String> recentItems;
    // 使用TypeToken处理泛型集合
    public static AppConfig fromPrefs(SharedPreferences prefs) {
        Gson gson = new Gson();
        String json = prefs.getString("app_config", null);
        return json == null ? new AppConfig() : gson.fromJson(json, AppConfig.class);
    }
    public void saveToPrefs(SharedPreferences prefs) {
        Gson gson = new Gson();
        String json = gson.toJson(this);
        prefs.edit().putString("app_config", json).apply();
    }
}

七、常见问题解决方案

1. 处理序列化异常

try {
    User user = gson.fromJson(json, User.class);
} catch (JsonSyntaxException e) {
    Log.e("PrefsHelper", "JSON解析错误", e);
    // 返回默认值或抛出业务异常
}

2. 版本兼容处理

// 使用@SerializedName注解处理字段变更
public class User {
    @SerializedName("old_name") // 旧版本字段名
    private String name;
    // 其他字段...
}

3. 大数据量处理

对于超过100KB的数据，建议：

1. 使用SQLite数据库
2. 存储到应用私有文件目录
3. 分块存储到多个SharedPreferences文件

八、最佳实践总结

1. 类型安全：始终验证反序列化结果类型
2. 异常处理：捕获并妥善处理所有序列化/反序列化异常
3. 性能监控：对关键路径的存储操作进行性能测试
4. 安全审计：定期检查敏感数据的存储方式
5. 文档完善：记录所有存储的键名及其用途

通过合理应用上述技术，开发者可以安全、高效地在SharedPreferences中存储复杂对象，同时保持代码的简洁性和可维护性。在实际项目中，建议将SharedPreferences操作封装为独立的工具类，并通过依赖注入的方式管理其生命周期。