Swift结构体遵循Codable与带协议属性协议的适配及数据隔离问题

首先说你当前代码的编译错误：Struct1里的protocol2属性类型是Struct2，但Protocol1要求的属性类型是Protocol2——Swift里协议作为类型要求时，属性的显式类型必须匹配协议定义，把Struct1的protocol2类型改成Protocol2就能解决这个基础问题，不过还要额外处理Codable的适配（因为协议本身不能直接支持Codable）。

回到你的核心需求：不需要强制拆分服务内外两套结构体，通过访问控制+协议约束就能实现“内部可修改存储、对外只读隐藏细节、避免外部误创建修改”的目标，下面给你两种可行方案：

方案一：私有初始化器+只读协议约束 #

这是最直接的方案，通过访问控制把结构体的初始化器和内部属性设为私有/文件私有，对外只通过协议暴露允许访问的只读接口：

// 对外暴露的只读协议
protocol Protocol1 {
    var protocol2: Protocol2 { get }
    // 如果需要对外暴露id这类属性，直接加到协议里
    var id: String { get }
}

protocol Protocol2 {}

// 内部使用的结构体，外部无法直接创建或修改内部属性
struct Struct1: Protocol1, Codable {
    // 对外只读（协议里是get），内部可写
    private(set) var id: String
    private(set) var lastModified: Date
    private(set) var protocol2: Protocol2

    // 私有初始化器，外部完全无法直接创建实例
    private init(id: String, lastModified: Date, protocol2: Struct2) {
        self.id = id
        self.lastModified = lastModified
        self.protocol2 = protocol2
    }

    // 内部专属的修改方法，只有服务内部能调用
    mutating func refreshLastModified() {
        lastModified = Date()
    }

    // 手动实现Codable，处理Protocol2的编码解码
    enum CodingKeys: String, CodingKey {
        case id, lastModified, protocol2
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(id, forKey: .id)
        try container.encode(lastModified, forKey: .lastModified)
        // 强制转成Struct2编码，因为内部存储的就是这个类型
        guard let struct2 = protocol2 as? Struct2 else {
            throw EncodingError.invalidValue(protocol2, .init(codingPath: [.protocol2], debugDescription: "Expected Struct2 instance"))
        }
        try container.encode(struct2, forKey: .protocol2)
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        id = try container.decode(String.self, forKey: .id)
        lastModified = try container.decode(Date.self, forKey: .lastModified)
        protocol2 = try container.decode(Struct2.self, forKey: .protocol2)
    }
}

struct Struct2: Protocol2, Codable {
    // 内部属性设为私有，外部不可见
    private(set) var internalDetail: String

    private init(internalDetail: String) {
        self.internalDetail = internalDetail
    }
}

class MyService {
    // 内部存储具体的Struct1实例
    private var dataStore: [Struct1] = []

    // 对外只返回协议类型，外部无法修改内部属性
    func getData() -> [Protocol1] {
        return dataStore
    }

    // 内部修改数据的逻辑，完全对外隐藏
    func updateData() {
        guard !dataStore.isEmpty else { return }
        var updatedItem = dataStore[0]
        updatedItem.refreshLastModified()
        dataStore[0] = updatedItem
    }
}

方案二：类型擦除彻底隐藏具体类型 #

如果需要更彻底的类型隔离（比如不想让外部通过类型转换拿到内部结构体），可以用类型擦除包装器：

// 对外暴露的协议
protocol Protocol1 {
    var protocol2: Protocol2 { get }
}

protocol Protocol2 {}

// 类型擦除的包装器，对外只暴露Protocol1的接口
struct AnyProtocol1: Protocol1 {
    private let _getProtocol2: () -> Protocol2

    var protocol2: Protocol2 {
        return _getProtocol2()
    }

    init<T: Protocol1>(_ wrapped: T) {
        _getProtocol2 = { wrapped.protocol2 }
    }
}

// 内部结构体，不需要对外暴露任何协议实现细节
struct Struct1: Codable {
    var id: String
    var lastModified: Date
    var protocol2: Struct2
}

struct Struct2: Codable {}

// 让Struct1适配Protocol1，用扩展实现（内部可见即可）
extension Struct1: Protocol1 {
    var protocol2: Protocol2 {
        return self.protocol2 as Protocol2
    }
}

class MyService {
    private var dataStore: [Struct1] = []

    // 对外返回类型擦除后的实例，外部无法拿到Struct1的具体类型
    func getData() -> [AnyProtocol1] {
        return dataStore.map(AnyProtocol1.init)
    }

    // 内部修改逻辑不受影响
    func updateData() {
        guard !dataStore.isEmpty else { return }
        dataStore[0].lastModified = Date()
    }
}

什么时候需要拆分内外结构体？ #

只有当内部结构体的属性、逻辑和对外暴露的协议接口差异极大，或者需要完全隔离内部实现的变更影响时，才考虑拆分。绝大多数场景下，上面两种方案都能满足需求，还能避免重复代码。

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