在实际项目开发过程中，很多时候移动终端设备都要与服务器进行数据交互。两者之间的数据格式通常为 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 使用就介绍到这，若在使用过程有什么问题，可以一起交流学习。
