在實際項目開發過程中，很多時候移動終端設備都要與服務器進行數據交互。兩者之間的數據格式通常為 JSON 和 XML。而 JSON 數據格式因其簡單、易操作、高效率的特點而被廣大開發者所使用。
在項目開發中，根據不同的業務我們需要創建不同 Model。在成功接收到從服務器返回過來的數據后，我們可以將 JSON 數據當作一個個的鍵值對然后進行解析，雖然這也算是一種解決方式，但一定程度上加大開發者的工作量。為了能夠快速解析數據并更新到應用界面上，我們更希望能將 JSON 數據快速的解析成一個 Object。于是乎就有了 ObjectMappper 這個第三方開源庫。
ObjectMapper 是一個基于 Swift 語言開發的能夠讓 JSON 與 Object 之間輕易轉換的類庫。通過 ObjectMapper 我們可以將 JSON 數據轉換成 Model 對象或將 Model 對象轉換成 JSON 數據。
ObjectMapper 有如下幾大特點：
- Mapping JSON to Object（JSON 映射成對象）
- Mapping Object to JSON（對象轉換成 JSON）
- Nested Object（支持內嵌對象功能，包括數據和字典），這個功能確實很贊??
- 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 使用就介紹到這，若在使用過程有什么問題，可以一起交流學習。
