如何在CoreData中读写复杂对象并保持可查询性？

一、你设想的Transformable方案实现步骤 #

1. 配置CoreData实体字段 #

创建对应MyObject的CoreData实体（比如命名为MyObjectEntity）：

• 原生类型字段（如userid、date_Created、acknowledgementStatus等）直接对应CoreData的基础类型（String、Date、Integer 64等），这些字段可直接用于查询。
• 所有HOV_前缀的自定义类型字段，设置为Transformable类型，后续通过自定义转换器实现序列化。

2. 实现自定义ValueTransformer #

基于Codable协议实现通用转换器，替代默认归档方式，保证序列化一致性：

class HOVCodableTransformer<T: Codable>: ValueTransformer {
    override class func transformedValueClass() -> AnyClass { Data.self }
    override class func allowsReverseTransformation() -> Bool { true }
    
    override func transformedValue(_ value: Any?) -> Any? {
        guard let hovItem = value as? T else { return nil }
        return try? JSONEncoder().encode(hovItem)
    }
    
    override func reverseTransformedValue(_ value: Any?) -> Any? {
        guard let data = value as? Data else { return nil }
        return try? JSONDecoder().decode(T.self, from: data)
    }
}

3. 注册转换器 #

在App启动阶段（比如AppDelegate或SceneDelegate的初始化方法中），为每个HOV_类型注册转换器：

// 注册各类HOV转换器
ValueTransformer.setValueTransformer(HOVCodableTransformer<HOV_Bool>(), forName: .init(rawValue: "HOV_BoolTransformer"))
ValueTransformer.setValueTransformer(HOVCodableTransformer<HOV_String>(), forName: .init(rawValue: "HOV_StringTransformer"))
ValueTransformer.setValueTransformer(HOVCodableTransformer<HOV_Float>(), forName: .init(rawValue: "HOV_FloatTransformer"))
ValueTransformer.setValueTransformer(HOVCodableTransformer<HOV_Date>(), forName: .init(rawValue: "HOV_DateTransformer"))

4. 关联转换器到CoreData字段 #

打开CoreData模型编辑器，选中每个HOV_类型的Transformable字段，在右侧检查器的「Data Model」面板中，将「Transformer」设置为对应的注册名称（比如HOV_Bool字段选HOV_BoolTransformer）。

5. 实现实体与MyObject的双向转换 #

为CoreData实体编写扩展，完成和MyObject的转换逻辑：

extension MyObjectEntity {
    // 从MyObject配置实体数据
    func setup(with object: MyObject) {
        // 原生字段直接赋值
        self.userid = object.userid
        self.date_Saved = object.date_Saved
        self.date_Created = object.date_Created
        self.acknowledgementStatus = Int32(object.acknowledgementStatus)
        self.buildNo = Int32(object.buildNo)
        // ...其他原生字段
        
        // HOV类型字段直接赋值（转换器自动处理序列化/反序列化）
        self.opportunityID = object.opportunityID
        self.displayName = object.displayName
        self.opportunityAchieved = object.opportunityAchieved
        // ...其他HOV字段
    }
    
    // 将实体转换为MyObject实例
    func toMyObject() -> MyObject? {
        guard let opportunityID = opportunityID as? HOV_String,
              let displayName = displayName as? HOV_String,
              let opportunityAchieved = opportunityAchieved as? HOV_Bool,
              // ...所有HOV字段需安全解包
              let userid = userid else {
            return nil
        }
        
        return MyObject(
            opportunityID: opportunityID,
            displayName: displayName,
            opportunityAchieved: opportunityAchieved,
            // ...其他HOV参数
            userid: userid,
            date_Saved: date_Saved,
            date_Created: date_Created,
            acknowledgementStatus: Int(acknowledgementStatus),
            buildNo: Int(buildNo),
            // ...其他原生参数，补充初始化器所需全部内容
        )
    }
}

二、更优的行业标准方案：拆分HOV_类型字段 #

如果未来需要查询HOV_类型内部的value值（比如筛选opportunityAchieved.value == true的数据），直接存储整个HOV_类型为Data会无法实现这类查询。此时建议拆分每个HOV_类型为两个字段：

• 一个字段存储value（对应原生类型，如Bool?、String?等），可直接用于查询。
• 另一个字段存储updateData（Transformable类型，对应UpdateMetaData）。

比如针对HOV_Bool类型的opportunityAchieved，在CoreData实体中创建两个字段：

• opportunityAchievedValue: Boolean?
• opportunityAchievedUpdateData: Transformable（使用HOVCodableTransformer<UpdateMetaData>）

转换时直接拆分赋值：

// 从MyObject配置实体
self.opportunityAchievedValue = object.opportunityAchieved.value
self.opportunityAchievedUpdateData = object.opportunityAchieved.updateData

// 将实体转换为MyObject
let opportunityAchieved = HOV_Bool(val: opportunityAchievedValue, time: opportunityAchievedUpdateData?.lastUpdated)

这种方案兼顾了可查询性和HOV_类型的完整性，是更灵活的长期解决方案。

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