调用每个可编码对象的encode(to:)，而不是singleValueContainer()。它可以将多个可编码对象连接到一个可编码对象中，而无需定义额外的CodingKeys。

struct RequestModel: Encodable {
    let session: Session
    let person: Person

    public func encode(to encoder: Encoder) throws {
        try session.encode(to: encoder)
        try person.encode(to: encoder)
    }
}

字符串

使用encoder.container(keyedBy: CodingKeys.self)而不是singleValueContainer()，并分别添加键值对，即

struct RequestModel: Encodable
{
    let session: Session
    let person: Person

    enum CodingKeys: String, CodingKey {
        case sessionId, name, age
    }

    public func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(person.age, forKey: RequestModel.CodingKeys.age)
        try container.encode(person.name, forKey: RequestModel.CodingKeys.name)
        try container.encode(session.sessionId, forKey: RequestModel.CodingKeys.sessionId)
    }
}

字符串

输出：

{
  "age" : 36,
  "name" : "Jan",
  "sessionId" : "xyz"
}

型
让我知道如果你仍然面临任何问题。

我想在这里扩展@marty-suzuki的答案，因为如果你不小心的话，可能会错过一些细微的差别。下面是我的代码版本：

struct EncodableCombiner: Encodable {
    let subelements: [Encodable]
    func encode(to encoder: Encoder) throws {
        for element in subelements {
            try element.encode(to: encoder)
        }
    }
}

字符串
简单地用一个可编码对象的数组示例化，并将结果对象本身视为可编码对象。现在，使用此方法时需要记住几个重要注意事项：
1.在JSON中只能有一种类型的根对象，它可以是单个值、数组或字典。因此，当你在各种可编码对象中实现encode(to:)时，千万不要使用encoder.singleValueContainer创建容器。
1.你希望合并的每个对象都必须在同一种容器上操作，所以如果其中一个使用unkeyedContainer()，那么它们都必须使用。类似地，如果一个使用container(keyedBy:)，那么其他的也必须使用。
1.如果你使用的是键控容器，那么所有组合对象中的两个变量不能共享相同的键名！否则，你会发现它们会互相覆盖，因为它们被解析到同一个字典中。
另一种可以缓解这些问题，但不会产生相同的JSON结构的方法是：

struct EncodableCombiner: Encodable {
    let elementA: MyEncodableA
    let elementB: MyEncodableB
    func encode(to encoder: Encoder) throws {
        var container = encoder.unkeyedContainer()
        try container.encode(elementA)
        try container.encode(elementB)
    }
}

型
现在，这有点不方便，因为我们不能简单地提供一个符合Encodable的对象数组;它需要确切地知道它们被称为container.encode()。结果是一个JSON对象，其根对象是数组，每个子元素表示为该数组中的一个元素。事实上，你可以进一步简化它，就像这样：

struct EncodableCombiner: Encodable {
    let elementA: MyEncodableA
    let elementB: MyEncodableB
}

型
...这当然会导致一个字典根对象，其编码形式为MyEncodableA，键为elementA，MyEncodableB为elementB。
这完全取决于你想要什么样的结构。

我个人觉得我的版本最方便

struct BaseParams: Encodable {
    let platform: String = "ios"
    let deviceId: String = "deviceId"
}

struct RequestModel<PayloadType: Encodable>: Encodable {
    let session = BaseParams()
    let payload: PayloadType

    public func encode(to encoder: Encoder) throws {
        try session.encode(to: encoder)
        try payload.encode(to: encoder)
    }
}

字符串
使用情况

struct TransactionParams: Encodable {
    let transation: [String]
}

let transactionParams = TransactionParams(transation: ["1", "2"])
let requestModel = RequestModel(payload: transactionParams)

let data = try JSONEncoder().encode(requestModel)
try JSONSerialization.jsonObject(with: data)

型
测试结果
[“平台”：“ios”，“transation”：[“1”，“2”]，“deviceId”：“deviceId”]