iOS JSON与Object之间的映射 ObjectMapper For Swift

在实际项目开发过程中，很多时候移动终端设备都要与服务器进行数据交互。两者之间的数据格式通常为 JSON 和 XML。而 JSON 数据格式因其简单、易操作、高效率的特点而被广大开发者所使用。

在项目开发中，根据不同的业务我们需要创建不同 Model。在成功接收到从服务器返回过来的数据后，我们可以将 JSON 数据当作一个个的键值对然后进行解析，虽然这也算是一种解决方式，但一定程度上加大开发者的工作量。为了能够快速解析数据并更新到应用界面上，我们更希望能将 JSON 数据快速的解析成一个 Object。于是乎就有了 ObjectMappper 这个第三方开源库。

ObjectMapper 是一个基于 Swift 语言开发的能够让 JSON 与 Object 之间轻易转换的类库。通过 ObjectMapper 我们可以将 JSON 数据转换成 Model 对象或将 Model 对象转换成 JSON 数据。

ObjectMapper 有如下几大特点：

1. Mapping JSON to Object（JSON 映射成对象）
2. Mapping Object to JSON（对象转换成 JSON）
3. Nested Object（支持内嵌对象功能，包括数据和字典），这个功能确实很赞
4. Support Struct（也对结构体做了支持）

一、基本操作

ObjectMapper 类库有一个 Mappable 协议，我们的 Model 实体类只有实现了这个 Protocol 能实现真正的映射解析功能。

public protocol Mappable {
    init?(_ map: Map)
    mutating func mapping(map: Map)
}

同时使用 “<-” 操作符来实现 JSON 字段与 Object 对象中属性之间的映射关系。以下为官方事例：

class User: Mappable {
    var username: String?
    var age: Int?
    var weight: Double!
    var array: [AnyObject]?
    var dictionary: [String : AnyObject] = [:]
    var bestFriend: User?                       // Nested User object
    var friends: [User]?                        // Array of Users
    var birthday: NSDate?

    required init?(_ map: Map) {

    }

    // Mappable
    func mapping(map: Map) {
        username    <- map["username"]
        age         <- map["age"]
        weight      <- map["weight"]
        array       <- map["arr"]
        dictionary  <- map["dict"]
        bestFriend  <- map["best_friend"]
        friends     <- map["friends"]
        birthday    <- (map["birthday"], DateTransform())
    }
}
struct Temperature: Mappable {
    var celsius: Double?
    var fahrenheit: Double?

    init?(_ map: Map) {

    }

    mutating func mapping(map: Map) {
        celsius     <- map["celsius"]
        fahrenheit  <- map["fahrenheit"]
    }
}

这里顺便补充一下：Swift 语言中，在 Struct 中定义的方法默认情况下对其属性只有读取权限，没有修改权限。因此，为了实现在 Struct 中的方法实体里也能像 Class 的方法实体里读写成员属性，需要在方法定义前面添加一个 mutating 关键字，表示这个方法也能修改 Struct 定义的属性。（注：class 的方法实体中默认就能对属性进行读写操作）

一旦你完成上面操作，我们就可以通过这个 Mappable 类来实现很多功能，如：

• JSON 映射成对象： let temperature = Mapper\

{
  "age" : 12,
  "name" : "zhangsan" }

当 prettyPrint = false 时在控制台的输出格式为：

{"age":12,"name":"zhangsan"}

相当于 prettyPrint 字段会在每个键值对的基础上插入换行符”\n”。

ObjectMapper 支持映射的类的属性的类型有：

• Int
• Bool
• Double
• Float
• String
• Array
• Dictionary

{
    "distance" : { "text" : "102 ft", "value" : 31 } }

通过如下方式直接取出 distance 对象中 value 的值，也可以理解为级联取值或是嵌套键Key:

func mapping(map: Map) {
    distance <- map["distance.value"] } 

注意： Error Domain=NSCocoaErrorDomain Code=3840 "Garbage at end." UserInfo={NSDebugDescription=Garbage at end.}
distanceValue: nil

出错的原因是你所提供待解析的不是一个完整 JSON 格式的数据，比如：

"distance" : {
    "text" : "102 ft",
    "value" : 31
}

只要将上述内容通过一个大括号括起来那就是一个完整JSON格式的数据了。

针对下面的 JSON 字符串呢, distance 里包含的是一个对象数组 Array：

{
    "distance" : {
        [
         "text" : "102 ft",
         "value" : 31
       ],
       [
         "text" : "102 ft",
         "value" : 31
       ],
       [
         "text" : "102 ft",
         "value" : 31
       ]
    }
}

其实，ObjectMapper 也对对象数组做了很好的支持：

func mapping(map: Map) {
    distance <- map["distance.0.value"] }

通过在 distance 后面添加数字充当数组的游标就可以访问数组中指定位置的数据了。是不是很方便

当然，如果 JSON 字符串中的键 Key 本身就带有圆点”.”的，如：

{
    "name.length": 10 }

这种情况如果再直接使用上面的解析方式就会出错，真正的解决方案为：

func mapping(map: Map) {
    identifier <- map["app.identifier", nested: false] }

其中nested字段表示不进行嵌套解析。

三、自定义转换规则

ObjectMapper 允许开发者在数据映射过程中指定转换规则。常见的操作就是将一个 Long 类型的日期转换成 NSDate 类型的。

class People: Mappable {
    var birthday: NSDate?

    required init?(_ map: Map) {
    }

    func mapping(map Map) {
        birthday <- (map["birthday"], DateTransform())
    }
}

let JSON = "\"birthday\":1458117795332"
let result = Mapper<People>().map(JSON)

上面的操作在解析 JSON 数据的时候会将 Long 解析成一个 NSDate，同时在转换成 JSON 数据的时候会将 NSDate 类型转换成 Long 类型。

当然，我们也可以很方便的通过实现 TransformType 协议来自定义我们的转换规则。

public protocol TransformType {
    typealias Object
    typealias JSON

    func transformFromJSON(value: AnyObject?) -> Object?
    func transformToJSON(value: Object?) -> JSON?
}

大多数情况下我们使用类库自带的 TransformOf 类就能实现我们想要的转换结果，TransformOf 实际就是实现了 TransformType 协议的。TransformOf 有两个类型的参数和两个闭包参数，类型表示参与转换的数据的类型，闭包表示转换规则。

let transform = TransformOf<Int, String>(fromJSON: { (value: String?) -> Int? in 
    // transform value from String? to Int?
    return Int(value!)
}, toJSON: { (value: Int?) -> String? in
    // transform value from Int? to String?
    if let value = value {
        return String(value)
    }
    return nil
})

id <- (map["id"], transform)

我们也可以对上面代码做进一步优化：

id <- (map["id"], TransformOf<Int, String>(fromJSON: { Int($0!) }, toJSON: { $0.map { String($0) } }))

其中，TransformOf 的第一个数据为最終解析后的类型，第二个参数为 JSON 数据原始的类型，后面指定的是解析规则和转换规则。上面代码的意思是将 json 数据中键为 “id” 的值从 String 类型转换为 Int 类型。这里需要注意一下，如果 “id” 键对应的值不是 String 类型则会运行错误。

四、类的继承

当父类实现了 Mappable 协议，子类在继承父类后需要重写 Mappable 协议的两个方法。同时请确保在重写这两个方法时调用了父类对应的方法。

class Base: Mappable {
    var base: String?

    required init?(_ map: Map) {

    }

    func mapping(map: Map) {
        base <- map["base"]
    }
}

class Subclass: Base {
    var sub: String? required init?(_ map: Map) {
        super.init(map)
    }

    override func mapping(map: Map) {
        super.mapping(map)

        sub <- map["sub"] } } let JSON = "{\"base\":\"base\", \"sub\":\"sub\"}"
let result = Mapper<SubClass>().map(JSON)

五、泛型对象

ObjectMappper 同样可以处理泛型类型的参数。不过这个泛型类型需要在实现了 Mappable 协议的基础上才可以正常使用。

class User: Mappable {
    var name: String?

    required init?(_ map; Map) {
    }

    func mappping(_ map: Map) {
        name <- map["name"]
    }
}

class Result<T: Mappable>: Mappable {
    var result: T?

    required init?(_ map: Map){

    }

    func mapping(map: Map) {
        result <- map["result"]
    }
}

let JSON = "{\"result\": {\"name\": \"anenn\"}}"
let result = Mapper<Result<User>>().map(JSON)

如果你现在正在使用 Alamofire 这个第三方网络请求工具包的话，其实我们还可选择 ObjectMappper 的衍生产品 AlamofireObjectmapper 来实现 JSON 与 Object 的关系映射。

同理，ObjectMapper 也支持 Realm ORM 框架的并同使用。具体可参照官方文档

好吧，关于 ObjectMapper 使用就介绍到这，若在使用过程有什么问题，可以一起交流学习。