Swift中动态存储与访问API返回数据的最优方案问询

你的问题很典型——当后端返回的JSON结构会频繁变化时，硬编码每个字段的赋值不仅繁琐，还会随着结构更新不断修改代码。下面提供两种更灵活的方案，既能实现全局访问，又能适配JSON结构的动态变化：

方案一：动态字典存储（最灵活） #

这种方式直接把整个JSON转成[String: Any]字典存储在ObservableObject中，不需要提前定义所有字段，完全适配结构变化。

1. 创建全局数据存储类 #

class UserDataStore: NSObject, ObservableObject {
    // 存储完整的用户数据（包括嵌套结构）
    @Published var rawUserData: [String: Any] = [:]
    
    // 可选：为常用字段添加便捷计算属性，避免重复类型转换
    var uid: String? { rawUserData["uid"] as? String }
    var email: String? { rawUserData["email"] as? String }
    var username: String? { rawUserData["username"] as? String }
    var isVerified: Bool? { rawUserData["isVerified"] as? Bool }
    
    // 动态获取任意嵌套字段的工具方法（支持点分隔路径，比如"hub.cameraService.bridgeIP"）
    func value<T>(forKeyPath keyPath: String) -> T? {
        let keys = keyPath.components(separatedBy: ".")
        var currentValue: Any? = rawUserData
        
        for key in keys {
            guard let currentDict = currentValue as? [String: Any],
                  let nextValue = currentDict[key] else {
                return nil
            }
            currentValue = nextValue
        }
        
        return currentValue as? T
    }
}

2. API请求后赋值 #

不管你是直接拿到字典还是JSON Data，都可以快速赋值：

@EnvironmentObject var userStore: UserDataStore

// 假设API返回的是字典类型的response
if let responseDict = response as? [String: Any] {
    DispatchQueue.main.async {
        self.userStore.rawUserData = responseDict
        print("用户数据已动态更新")
    }
}

// 如果是从Data解析：
do {
    guard let responseDict = try JSONSerialization.jsonObject(with: apiData, options: []) as? [String: Any] else {
        print("JSON解析失败")
        return
    }
    DispatchQueue.main.async {
        self.userStore.rawUserData = responseDict
    }
} catch {
    print("解析错误：\(error)")
}

3. 视图中访问数据 #

既可以用便捷属性，也可以动态访问任意字段：

@EnvironmentObject var userStore: UserDataStore

var body: some View {
    VStack(spacing: 16) {
        // 访问常用字段
        if let username = userStore.username {
            Text("欢迎回来，\(username)！")
        }
        
        // 动态访问嵌套字段（用工具方法）
        if let bridgeIP = userStore.value(forKeyPath: "hub.cameraService.bridgeIP") as? String {
            Text("摄像头桥接IP：\(bridgeIP)")
        }
        
        // 直接访问字典（适合临时调试或特殊字段）
        if let hubVersion = userStore.rawUserData["hub"]?["hubSWVersion"] as? Double {
            Text("Hub版本：\(hubVersion)")
        }
    }
}

方案二：类型安全的Codable结构体（兼顾灵活与安全） #

如果需要一定的类型安全，同时允许JSON新增字段，可以用带可选属性的Codable结构体——新增的字段不会导致解析失败，只是不会被映射到结构体属性中。

1. 定义Codable模型 #

struct UserData: Codable {
    var username: String?
    var email: String?
    var uid: String?
    var isVerified: Bool?
    var hub: HubData?
    var code: String?
    var message: String?
    
    struct HubData: Codable {
        var hubID: String?
        var isSetup: Bool?
        var hubSWVersion: Double?
        var cameraService: CameraService?
        var servicesSetup: [String: String]?
        
        struct CameraService: Codable {
            var isSetup: Bool?
            var bridgeIP: String?
            var username: String?
        }
    }
}

2. 更新数据存储类 #

class UserDataStore: NSObject, ObservableObject {
    @Published var userData: UserData?
    
    func updateUser(with data: Data) {
        do {
            let decodedData = try JSONDecoder().decode(UserData.self, from: data)
            DispatchQueue.main.async {
                self.userData = decodedData
            }
        } catch {
            print("解析错误：\(error)")
        }
    }
}

3. 视图中访问 #

@EnvironmentObject var userStore: UserDataStore

var body: some View {
    VStack {
        if let username = userStore.userData?.username {
            Text("Welcome, \(username)!")
        }
        
        if let bridgeIP = userStore.userData?.hub?.cameraService?.bridgeIP {
            Text("Camera IP: \(bridgeIP)")
        }
    }
}

方案选择建议 #

• 动态字典方案：适合JSON结构频繁变化、不需要严格类型检查的场景，完全不需要修改存储类就能适配新字段。
• Codable结构体方案：适合结构变化不频繁、需要类型安全的场景，新增字段时只需在结构体中添加对应可选属性即可。

两种方案都保留了ObservableObject的响应式特性，数据更新时视图会自动刷新，同时支持全局通过@EnvironmentObject访问。

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