在现代应用开发中，经常需要涉及到前端与后端的数据交换。对于 Swift 开发者来说，如何高效地在本地数据模型与后端 API（例如 JSON 格式）之间进行数据转换，是一个值得探讨的问题。

本文将介绍两种常见的解决方案：使用数据传输对象（DTO）和 Swift 提供的 Codable 协议，并比较它们的异同和适用场景。

Swift 本地数据模型

在 Swift 中，数据模型通常使用类（class）或结构体（struct）来定义，用于描述应用程序中的实体。例如：

struct User {
    var id: Int
    var name: String
    var email: String
}

这个 User 结构体就是一个简单的数据模型，包含用户的基本信息。

如果你使用 SwiftData 持久化本地数据，可以这样定义数据模型：

import SwiftData

@Model
class User {
    @Attribute(.unique) var id: Int // 唯一标识符，确保唯一性
    var name: String // 用户名称
    var email: String // 用户邮箱
    var profilePictureURL: String? // 可选的用户头像地址

    // 初始化方法
    init(id: Int, name: String, email: String, profilePictureURL: String? = nil) {
        self.id = id
        self.name = name
        self.email = email
        self.profilePictureURL = profilePictureURL
    }
}

通过这种方式，可以轻松地管理和持久化本地数据。

远程服务端数据结构

目前，服务端最常用的接收和返回的数据格式是 JSON（JavaScript Object Notation）。其他格式，如 XML 或 Protobuf，也有一定应用场景，但在移动应用中，JSON 占据主导地位。

客户端向服务端发送的数据通常也是 JSON 格式，并根据 API 的需求包含必要字段。例如，一个用户注册请求可能如下：

{
    "name": "Jane Doe",
    "email": "jane.doe@example.com",
    "password": "securepassword123"
}

服务端返回的 JSON 数据示例：

{
    "id": 123,
    "name": "John Doe",
    "email": "john.doe@example.com",
    "profile_picture_url": "https://example.com/profile.jpg",
    "roles": ["admin", "user"]
}

本地与远程数据交互面临的问题

当应用需要与后端 API 通信时，需要将本地数据模型转换为后端可以理解的格式（如 JSON），反之亦然。这就涉及到序列化（例如将模型转换为 JSON）和反序列化（将 JSON 转换为模型）的过程。

在数据处理的过程中，可能面临的问题包括但不限于：

字段命名方式不一致

Swift 使用 驼峰命名法（camelCase），而后端 JSON 数据通常采用 下划线命名法（snake_case）。这会导致字段在解码或编码时无法自动匹配。

字段缺失或冗余

后端 JSON 数据可能包含本地模型中未定义的冗余字段，或者缺失本地模型所需的某些字段。例如：

• 后端返回了 last_login_time 字段，而本地模型中没有该属性。
• 本地模型定义了 age 属性，但后端 JSON 中没有对应的数据。

数据类型不一致

后端和本地模型中相同字段的类型可能不同。例如：

• 后端将 id 表示为字符串，而本地模型将其定义为整型。
• 时间戳在后端用字符串格式（如 "2024-11-14T10:00:00Z"）表示，而本地可能使用 Date 类型。

嵌套结构处理

后端的 JSON 数据可能存在嵌套结构，而本地模型通常是扁平化设计。例如：

• 本地模型可能将 city 和 zip 平铺到 User 模型中。

后端返回的 JSON：

{
    "id": 123,
    "name": "John Doe",
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

本地与远程数据模型转换

为了解决上述问题，我们需要一种高效且安全的方法来进行数据转换。在 Swift 编程中，常用的解决方案有两种：创建 DTO 层和 Codable 协议。

使用 DTO（Data Transfer Object）

DTO，全称是数据传输对象（Data Transfer Object）。它是一种专门用来在系统之间传递数据的小工具。

本地和服务器的数据结构可能不完全一样，DTO 就像是一个中间层的“映射工具”（但不止于映射），它可以把远程的数据（比如后端的 JSON）映射到本地的某种格式，或者从本地的数据格式映射回后端需要的格式。

创建一个与数据模型对应的 DTO，例如：

struct UserDTO: Codable {
    var id: Int
    var name: String
    var email: String
    var profile_picture_url: String?
}

在需要进行数据传输时，使用 UserDTO 进行编码和解码：

let jsonData = ... // 后端返回的 JSON 数据
let decoder = JSONDecoder()
let userDTO = try? decoder.decode(UserDTO.self, from: jsonData)

// 将 DTO 转换为本地模型
if let userDTO = userDTO {
    let user = User(from: userDTO)
    print(user.name)
}

// 将本地模型转回 DTO，再编码为 JSON
let user = User(id: 1, name: "John", email: "john@example.com")
let encoder = JSONEncoder()
let encodedData = try? encoder.encode(user.toDTO())

如果创建了一个专门的 DTO 层，则本地的数据模型不需要再定义 Codable 协议或实现编码/解码方法。

想详细了解如何创建 DTO 管理数据模型的转换，请参看我这篇文章：

使用 Swift 的 Codable 协议

Codable 是 Swift 提供的一个组合协议，包含了 Encodable 和 Decodable，用于简化对象的编码和解码过程。支持将 Swift 数据模型与外部数据（如 JSON）直接进行序列化和反序列化。

直接在本地数据模型中声明对 Codable 的遵循。这样，本地模型可以直接参与 JSON 的编码和解码：

struct User: Codable {
    var id: Int
    var name: String
    var email: String
    var profilePictureURL: String?

    enum CodingKeys: String, CodingKey {
        case id
        case name
        case email
        case profilePictureURL = "profile_picture_url" // JSON 字段映射
    }
}

使用 Swift 的 JSONEncoder 和 JSONDecoder，即可轻松地在模型和 JSON 之间进行转换：

let jsonData = ... // 从后端获取的 JSON 数据
let decoder = JSONDecoder()
let user = try? decoder.decode(User.self, from: jsonData)

if let user = user {
    print(user.name) // 输出解析后的用户名
}

// 将模型编码为 JSON 数据
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted // 美化输出
let encodedData = try? encoder.encode(user)
if let jsonString = encodedData.flatMap({ String(data: $0, encoding: .utf8) }) {
    print(jsonString)
}

想详细了解如何使用 Swift 中的 Codable 协议，请参看我这篇文章：

DTO 与 Codable 协议的适用场景

Codable 协议的出现，使得数据模型可以直接参与序列化，简化了对象的编码和解码过程。然而，这也带来了模型与数据传输过程的耦合。因此，Codable 协议并不能完全替代 DTO。在需要解耦数据模型和传输过程、保护敏感信息或满足复杂转换需求的场景下，DTO 仍然是必要的。

对于追求代码简洁、快速开发的项目，Codable 提供了方便的解决方案。而对于需要高安全性、低耦合性的项目，使用 DTO 则更加合适。

我的建议：

• 小型项目或快速原型开发：优先使用 Codable，提升开发效率。
• 大型项目或安全性要求高的应用：考虑使用 DTO，确保数据传输的安全和代码的可维护性。非常适合大型项目，尤其是需要多个版本的 API 或需要支持后端与本地模型结构迥异的项目。