NSKeyedArchive存储大对象致APP崩溃，寻求高效本地存储替代方案

嘿，这种用NSKeyedArchiver处理几百MB带图片的字典场景，踩坑太正常了——它的序列化逻辑是把整个对象图一次性塞进内存处理，内存爆仓、APP退出慢都是典型症状。给你几个经过实战验证的优化方案，从根上解决问题：

1. 放弃整体归档，改用分块存储+文件系统管理 #

这是解决内存爆炸最直接的方案，核心是把大字典拆成小单元，避免一次性加载所有数据：

• 给每个字典key单独创建一个子文件夹，用key作为文件夹名，存在Documents目录的专属子目录下。
• 拆分MyCustomObject的存储：
  • String类型的属性用plist单独存为元数据文件（比如每个对象对应一个xxx_meta.plist）。
  • UIImage不要序列化进对象，而是单独存为图片文件（优先用WebP格式，iOS14+原生支持，压缩率远高于JPEG/PNG），然后在元数据里记录图片的文件名。
• 读取时懒加载：只在需要某个key对应的数组时，才去读取对应文件夹的内容，不会启动就加载几百MB数据。

2. 替换NSKeyedArchiver为更高效的序列化方式 #

NSKeyedArchiver的性能和内存表现都不太适合大体积数据，推荐用原生的Codable+PropertyListEncoder/JSONEncoder结合文件操作，或者直接用文件系统读写：

• 对于非图片属性，用Codable序列化到plist/json文件，比NSKeyedArchiver更快、内存占用更低。
• 图片直接以二进制文件存储，避免Base64转码带来的体积膨胀（Base64会让图片体积增加30%左右）。

3. 内存&性能细节优化 #

• 压缩图片：存储前用UIImageJPEGRepresentation（压缩质量0.7-0.8）或WebP格式压缩，大幅降低存储体积，同时减少读写耗时。
• 异步处理：所有存储、读取操作都放到后台队列（比如DispatchQueue.global().async）执行，绝不阻塞主线程。APP进入后台时，用UIApplication.shared.beginBackgroundTask申请额外后台时间完成存储，避免被系统中断。
• 批量操作时释放内存：遍历字典存储数据时，处理完一个key就及时释放对应数组的内存，不要把所有数据都留在内存里。

4. 可选方案：Core Data（适合需要查询的场景） #

如果需要对这些数据做查询、排序等操作，Core Data是不错的选择，但要注意正确配置：

• 不要把UIImage的Data存在Core Data实体里，而是开启属性的允许外部存储选项，让Core Data自动把大二进制数据存在外部文件，只在实体里记录路径。
• 用NSBatchInsertRequest批量插入数据，比单个插入效率高一个量级。

示例代码：分块存储的核心实现 #

import UIKit

// 假设你的MyCustomObject定义
class MyCustomObject {
    var text: String
    var image: UIImage?
    
    init(text: String, image: UIImage?) {
        self.text = text
        self.image = image
    }
}

// 存储管理器类
class CustomDataStorage {
    private let baseDirectory: URL
    
    init() {
        let docDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
        baseDirectory = docDir.appendingPathComponent("CustomObjectStorage")
        try? FileManager.default.createDirectory(at: baseDirectory, withIntermediateDirectories: true)
    }
    
    // 异步存储单个key对应的对象数组
    func saveObjects(_ objects: [MyCustomObject], forKey key: String) async throws {
        let keyDir = baseDirectory.appendingPathComponent(key)
        try? FileManager.default.createDirectory(at: keyDir, withIntermediateDirectories: true)
        
        // 先清空旧数据
        try? FileManager.default.removeItem(at: keyDir)
        try FileManager.default.createDirectory(at: keyDir, withIntermediateDirectories: true)
        
        // 存储每个对象的元数据和图片
        for (index, obj) in objects.enumerated() {
            // 存储元数据（String属性）
            let metaURL = keyDir.appendingPathComponent("\(index)_meta.plist")
            let metaData: [String: Any] = ["text": obj.text]
            try PropertyListSerialization.writePropertyList(metaData, to: metaURL, format: .binary, options: 0)
            
            // 存储图片（WebP格式）
            if let image = obj.image {
                let imageURL = keyDir.appendingPathComponent("\(index)_image.webp")
                guard let webpData = image.webpData(compressionQuality: 0.8) else { continue }
                try webpData.write(to: imageURL)
            }
        }
        
        // 记录对象数量，方便读取
        let countURL = keyDir.appendingPathComponent("count.plist")
        try PropertyListSerialization.writePropertyList(objects.count, to: countURL, format: .binary, options: 0)
    }
    
    // 异步读取单个key对应的对象数组
    func loadObjects(forKey key: String) async throws -> [MyCustomObject] {
        let keyDir = baseDirectory.appendingPathComponent(key)
        guard FileManager.default.fileExists(atPath: keyDir.path) else { return [] }
        
        // 读取对象数量
        let countURL = keyDir.appendingPathComponent("count.plist")
        let count = try PropertyListSerialization.propertyList(from: countURL, options: [], format: nil) as? Int ?? 0
        
        var objects = [MyCustomObject]()
        for index in 0..<count {
            // 读取元数据
            let metaURL = keyDir.appendingPathComponent("\(index)_meta.plist")
            let metaData = try PropertyListSerialization.propertyList(from: metaURL, options: [], format: nil) as? [String: String] ?? [:]
            
            // 读取图片
            let imageURL = keyDir.appendingPathComponent("\(index)_image.webp")
            let image = try? Data(contentsOf: imageURL).flatMap { UIImage(data: $0) }
            
            let obj = MyCustomObject(text: metaData["text"] ?? "", image: image)
            objects.append(obj)
        }
        
        return objects
    }
}

使用方式 #

let storage = CustomDataStorage()

// 异步存储
Task {
    let testObjects = (0..<1000).map { MyCustomObject(text: "Item \($0)", image: UIImage(named: "testImage")) }
    try await storage.saveObjects(testObjects, forKey: "testKey")
}

// 异步读取
Task {
    let objects = try await storage.loadObjects(forKey: "testKey")
    // 处理读取到的对象
}

这种方案下，内存只会加载当前操作的单个key的数据，不会出现几百MB内存占用的情况，读写操作都在后台，APP退出时也不会有卡顿。

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