HandyJSON原理

发布于：2025-03-29 ⋅ 阅读:(25) ⋅ 点赞:(0)

HandyJSON 的优势

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式, 应用广泛. 在 App 的使用过程中, 服务端给移动端发送的大部分都是 JSON 数据, 移动端需要解析数据才能做进一步的处理. 在解析JSON数据这一块, 目前 Swift 中流行的框架基本上是 SwiftyJSON, ObjectMapper, JSONNeverDie, HandyJSON 这么几种.

我们应该如何选择呢?

首先我们应该先明白解析 JSON 的原理. 目前有两个方向.

保持 JSON 语义, 直接解析 JSON.
SwiftyJSON 就是这样的. 本质上仍然需要根据 JSON 结构去取值.

预定义 Model 类, 将 JSON 反序列化类的实例, 再使用这些实例.
这种方式和 OC 中的 MJExtension 的思路是一致的. 在 Swift 中, ObjectMapper, JSONNeverDie, 以及 HandyJSON 做的都是将 JSON 文本反序列化到 Model 类上.

第二种思路是我们熟悉和比较方便的. 和服务端定义好数据结构, 写好 Model 就可以直接解析.

第二种思路有三种实现方式:

完全沿用 OC 中的方式, 让 Model 类继承自 NSObject, 通过 class_copyPropertyList 方法拿到 Model 的各种属性, 从 JSON 中拿到对应的 value, 再通过 OC 中 利用runtime 机制 实现的 KVC 方法为属性赋值. 如 JSONNeverDie.
支持纯 Swift 类, 但要求开发者实现 mapping 函数, 使用重载的运算符进行赋值, 如 ObjectMapper.
获取到 JSON 数据后, 直接在内存中为实例的属性赋值. HandyJSON 就是这样实现的.
第一种方式的缺点在于需要强制继承 NSObject, 这不适用于 struct 定义的 Model. 因为 struct 创建的 Model 不能通过 KVC 为其赋值.
第二种方式的缺点在于自定义 mapping 函数, 维护比较困难.
第三种方式在使用上和 MJExtension 基本差不多, 比较方便. 是我们所推荐的.

HandyJSON 解析数据的原理.

如何在内存上为实例的属性赋值呢?
为属性赋值, 我们需要以下步骤:

获取到属性的名称和类型.
找到实例在内存中的 headPointer, 通过属性的类型计算内存中的偏移值, 确定属性在内存中的位置.
在内存中为属性赋值.
在 Swift 中实现反射机制的类是 Mirror, 通过 Mirror 类可以获取到类的属性, 但是不能为属性赋值, 它是可读的. 但是我们可以直接在内存中为实例赋值. 这是一种思路. 另外一种思路是不利用 Mirror, 直接在内存中获取到属性的名称和类型, 这也是可以的. 目前 HandyJSON 就是利用的第二种方式.

1. 核心原理：绕过反射，直接操作内存

传统的 JSON 库（如 ObjectMapper）依赖 Swift 的 Mirror 反射机制遍历模型属性，但反射存在性能瓶颈且无法直接修改属性值。HandyJSON 通过以下方式实现高效解析：

a. 利用类型元数据（Type Metadata）
  • Swift 编译器会为每个类型生成元数据，包含属性名称、类型、内存偏移量等信息。
  • HandyJSON 直接访问这些元数据，获取属性的名称和内存位置，无需通过反射。
  • 例如，结构体的属性在内存中是连续排列的，通过元数据可以计算出每个属性的偏移量。
b. 内存拷贝与指针操作

  • 通过 UnsafeMutablePointer 直接操作模型实例的内存。

  • 将 JSON 值转换为目标类型后，直接写入对应的内存地址。

  • 示例代码逻辑：

    swift

    let offset = getPropertyOffset(from: metadata) // 获取属性偏移量
let pointer = instancePointer + offset          // 计算属性内存地址
let value = parseJSONValue(...)                // 解析 JSON 值
pointer.storeBytes(of: value, as: type)         // 直接写入内存

2. 实现步骤详解

a. 类型元数据解析
  • 获取类型信息：通过 type(of:) 或泛型类型参数获取类型的元数据。
  • 解析属性列表：从元数据中提取属性名称、类型、是否为可选类型（Optional）等信息。
  • 处理继承和协议：遍历类型的继承链，确保父类属性也能被正确映射。
b. JSON 到内存的映射
  1. 解析 JSON：将 JSON 数据转换为字典（[String: Any]）。
  2. 匹配键与属性：将 JSON 的键与模型属性名匹配（支持自定义键名映射）。
  3. 类型转换：将 JSON 值转换为目标属性类型（如 String 转 Int、处理嵌套模型等）。
  4. 内存写入：通过指针将转换后的值写入模型实例的内存。
c. 特殊类型处理
  • 可选类型（Optional）：根据 JSON 是否存在键值决定是否写入 nil。
  • 枚举（Enum）：将 JSON 值映射到枚举的 rawValue 或关联值。
  • 泛型类型：需要特殊处理元数据的动态解析。

HandyJSON和codeble的区别

HandyJSON 和 Codable 都是 Swift 中用于 JSON 解析的库，但它们的底层实现和使用方式存在较大差异。下面从多个方面对比 HandyJSON 和 Codable 的区别：

1. 底层原理

​ • HandyJSON

​ • 通过 元数据解析 实现 JSON 与对象的转换。

​ • 直接操作 类型元数据，并利用 内存操作 进行对象实例化和属性赋值，避免手动映射字段。

​ • 解析时不依赖 init 方法，而是直接修改对象的内存，使其更灵活。

​ • Codable

​ • 基于 Swift 的 Encodable 和 Decodable 协议，结合编译器自动生成的 CodingKeys 来进行编码和解码。

​ • 依赖 JSONDecoder 和 JSONEncoder 进行序列化和反序列化。

​ • 需要手动实现 init(from decoder: Decoder) 进行自定义解析（如果字段名不匹配或需要额外处理）。

2. 使用方式

​ • HandyJSON

import HandyJSON

struct User: HandyJSON {
    var name: String?
    var age: Int?
}

let jsonString = "{\"name\":\"Tom\",\"age\":25}"
if let user = User.deserialize(from: jsonString) {
    print(user.name)  // 输出: Tom
}

​ • Codable

import Foundation

struct User: Codable {
    var name: String
    var age: Int
}

let jsonData = """
{"name": "Tom", "age": 25}
""".data(using: .utf8)!

let decoder = JSONDecoder()
if let user = try? decoder.decode(User.self, from: jsonData) {
    print(user.name)  // 输出: Tom
}

3. 是否需要 init 构造方法

​ • HandyJSON

​ • 解析时不需要定义 init()，可以直接解析 JSON 并填充到结构体或类中。

​ • 直接修改对象的内存，不依赖 init(from:)。

​ • 适用于 struct 和 class，但更适合 class（因为 struct 可能需要 mutating 修饰）。

​ • Codable

​ • 依赖 init(from decoder: Decoder) 进行解析，如果字段名不同，需要手动实现 CodingKeys 或 init(from:)。

​ • 必须使用 init() 构造函数，如果 struct 的属性是 let，则必须提供所有初始值。

4. 字段匹配

​ • HandyJSON

​ • 支持隐式映射，如果 JSON 中的字段与模型属性匹配，HandyJSON 自动填充值。

​ • 支持 mapping 方法 进行字段转换：

struct User: HandyJSON {
    var name: String?
    var age: Int?
    
    mutating func mapping(mapper: HelpingMapper) {
        mapper.specify(property: &name, name: "user_name")  // JSON "user_name" → name
    }
}

​ • Codable

​ • 默认情况下，JSON 字段名必须与模型属性一致，否则解析会失败。

​ • 必须手动使用 CodingKeys 进行字段转换：

struct User: Codable {
    var name: String
    var age: Int

    enum CodingKeys: String, CodingKey {
        case name = "user_name"  // JSON "user_name" → name
        case age
    }
}

5. 可选值处理

​ • HandyJSON

​ • 支持非必填字段，如果 JSON 中缺少某个字段，解析时不会出错，而是保持默认值 nil。

​ • 更适合处理 不确定 JSON 结构 的情况。

​ • Codable

​ • 字段缺失时解析会失败（除非属性是 Optional）。

​ • 适用于结构稳定的 JSON，但如果 JSON 结构不固定，需要 init(from:) 进行额外处理。

6. 性能

​ • HandyJSON

​ • 由于直接操作 Swift 运行时元数据 和 内存赋值，解析速度快。

​ • 适用于 大规模数据解析，但由于底层是非官方 API，可能有兼容性风险。

​ • Codable

​ • 由于使用 静态类型检查 和 编译期生成的解析代码，解析速度稍慢，但更稳定。

​ • 适用于 严格类型检查的应用。

7. 适用场景

适用场景 HandyJSON Codable
动态 JSON 结构 ✅ 更适合 ❌ 需要手动解析
稳定 JSON 结构 ✅ 适用 ✅ 更适合
解析速度要求高 ✅ 较快 ❌ 相对较慢
字段匹配灵活 ✅ 自动映射 ❌ 需手动 CodingKeys
依赖标准库 ❌ 依赖 HandyJSON ✅ 纯 Swift 标准库
适用于 class ✅ 更合适 ✅ 适用
适用于 struct ✅ 适用 ✅ 更推荐

8. 总结

维度 HandyJSON Codable
底层原理 运行时反射 + 内存操作 静态类型解析 + 编译期自动生成
是否需要 init() 不需要 需要
自动映射 JSON ✅ 支持 ❌ 需 CodingKeys
字段缺失容忍度 ✅ 可缺失 ❌ 需 Optional 处理
性能 ✅ 高效 ❌ 稍慢
兼容性 ❌ 可能受 Swift 版本影响 ✅ 稳定
标准库支持 ❌ 需引入 HandyJSON ✅ Swift 原生

9. 选择建议

​ • 如果你的 JSON 结构 稳定，并且 不想依赖第三方库，推荐 Codable。

​ • 如果你的 JSON 结构 复杂、字段可能缺失，并且 需要高性能解析，推荐 HandyJSON。

​ • Codable 适用于 Swift 官方标准，更安全、可维护性更高，但对字段要求严格。

​ • HandyJSON 更灵活，解析速度快，但依赖运行时，可能存在兼容性问题（例如 Swift 版本升级后）。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布