iOS JSON與Object之間的對映 ObjectMapper For Swift

weixin_33830216發表於2016-03-16
iOSJSONObjectAPPSwift

在實際專案開發過程中，很多時候移動終端裝置都要與伺服器進行資料互動。兩者之間的資料格式通常為 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<Temperature>().map(jsonString)
  • 物件轉換成 json 字串：let json = Mapper().toJSONString(temperature, prettyPrint: true)

其中 prettyPrint 欄位表示是否以一種優雅的方式輸出，當 prettyPrint = true 時在控制檯輸出的格式為：

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

當 prettyPrint = false 時在控制檯的輸出格式為：

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

相當於 prettyPrint 欄位會在每個鍵值對的基礎上插入換行符"\n"。

ObjectMapper 支援對映的類的屬性的型別有：

  • Int
  • Bool
  • Double
  • Float
  • String
  • Array<AnyObject>
  • Dictionary<String, Object>
  • RawRepresentable (Enums)
  • Object<T: Mappable>
  • Array<T: Mappable>
  • Set<T: Mappable>
  • Dictionary<String, T: Mappable>
  • Dictionary<String, Array<T: Mappable>>
  • Optionals of all above（以上型別的可選值）
  • Implictily unwrapped Optionals all above（以上型別的隱私解析可選值）

二、巢狀物件的對映

在鍵Key欄位裡可以通過圓點"."來實現巢狀物件的對映，下面為巢狀物件的 JSON 資料

{
    "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 使用就介紹到這，若在使用過程有什麼問題，可以一起交流學習。

相關文章