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

weixin_33830216發表於2016-03-16

在實際專案開發過程中,很多時候移動終端裝置都要與伺服器進行資料互動。兩者之間的資料格式通常為 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 使用就介紹到這,若在使用過程有什麼問題,可以一起交流學習。

相關文章