iOS ObjectMapper增量更新

Question

我的项目有问题，当我的应用程序启动时，配置会从服务器自动更新，json来自服务器，如下所示：

{
"version":1 
"config": 
{
    "key1": {xxx}
    "key2": {xxx}
    "key3": {xxx}
    "key4": {xxx}
    "key5": {xxx}
    "key6": {xxx}
}

我使用ObjectMapper将json转换为模型，如下所示：

struct GlobalConfig: Mappable {

var version = 0
var key1: [String: [LocalizedText]]?
var key2: [RouteObject]?
var key3: UrlConfig?
var key4: [String: [String: [[String: Any]]]]?
var key5: DegreeInfoList?
var key6: [String: String]?

init?(map: Map) { }

mutating func mapping(map: Map) {
    version <- map["version"]
    key1 <- map["key1"]
    key2 <- map["key2"]
    key3 <- map["key3"]
    key4 <- map["key4"]
    key5 <- map["key5"]
    key6 <- map["key6"]
}

现在有一个问题，当来自服务器的json很大时，它将消耗大量的流量。事实上，有些配置不需要更新。服务器上的json会喜欢这样的：

{
"version":2
"config": 
{
    "key1": {xxx}
    "key2": {xxx}
}

这意味着key1和key2将被更新，key3、key4、key5和key6将保留旧的值。如何处理JSON?

Answer 1

我不明白Mapper对象是什么。这可以用Codable来完成。

您可以这样做，用传入的配置更新本地配置。

struct GlobalConfig: Codable {
    var version = 0
    var key1: [String: [LocalizedText]]?
    var key2: [RouteObject]?
    var key3: UrlConfig?
    var key4: [String: [String: [[String: Any]]]]?
    var key5: DegreeInfoList?
    var key6: [String: String]?
    
    mutating func combine(with config: GlobalConfig) {
        if let k = config.key1 { key1 = k }
        if let k = config.key2 { key2 = k }
        ...
    }
}

class App {
    var config: GlobalConfig
    
    func receiveConfig(newConfig: GlobalConfig) {
        config.combine(with: newConfig)
    }
}

编辑:

作为对评论的回应，这里给出了“深度”组合的可能解决方案。

粗略地说：

extension Dictionary {
    func combine(with dictionary: Dictionary) {

    } 
}

extension Array {
    func combine(with array: Array) {

    } 
}

protocol Combinable: Codable {
    func combine(with object: Self)
}

struct GlobalConfig: Combinable {
    var version = 0
    var key1: [String: [LocalizedText]]?
    var key2: [RouteObject]?

    mutating func combine(with config: GlobalConfig) {
        if let k = config.key1 { key1.combine(with: k) }
        if let k = config.key2 { key2.combine(with: k) }
        ...
    }
}

这是另一个主题，但是应该避免像[String: [String: [[String: Any]]]]这样的类型。它很难阅读、调试和组合;)

我认为使用结构化子模型更好。更安全、可扩展和“可文档化”。

struct GlobalConfig: Codable {
    ...
    // Old format: var key4: [String: [String: [[String: Any]]]]?
    var key4: MegaSettings?
    ...
}

struct MegaSettings: Combinable {
    struct ScreenOptions: Combinable {
        var options: [String: Any]
    }

    struct DisplayOptions: Combinable {
        struct DeviceDisplayOptions {
            var screen: [ScreenOptions]
        }

        var optionsPerDevice: [String: DeviceDisplayOptions]
    }

    var displayOptions: [String: DisplayOptions]
}