init(map: Map) throws { id = try map.value("id") name = try? map.value("name") } mutating func mapping(map: Map) { id <- map["id"] name <- map["name"] }

Model -> JSON

mutating func mapping(map: Map) { id >>> map["id"] name >>> map["name"] } mutating func mapping(map: Map) { id <- map["id"] name <- map["name"] }

Initializing

try User(JSONString: JSONString) User(JSONString: JSONString)

init(map: Map) throws

这个可能抛出异常的初始化函数用于在提供的 Map 里映射不可变属性。每个不可变的初始化属性都要在这个初始化函数里初始化。

当发生下列情况时初始化函数会抛出一个错误：

Map 根据提供的键名获取不到对应值

Map 使用 Transform 后没有得到值

ImmutableMappable 使用 Map.value(_:using:) 方法从 Map 中获取值。因为可能抛出异常，这个方法在使用时需要使用 try 关键字。 Optional 的属性可以简单的用 try? 处理。

init(map: Map) throws { name = try map.value("name") // throws an error when it fails createdAt = try map.value("createdAt", using: DateTransform()) // throws an error when it fails updatedAt = try? map.value("updatedAt", using: DateTransform()) // optional posts = (try? map.value("posts")) ?? [] // optional + default value } mutating func mapping(map: Map)

这个方法是在 Model 转回 JSON 时调用的。因为不可变的属性不能被 <- 映射，所以映射回来时需要使用 >>> 。

mutating func mapping(map: Map) { name >>> map["name"] createdAt >>> (map["createdAt"], DateTransform()) updatedAt >>> (map["updatedAt"], DateTransform()) posts >>> map["posts"] } 轻松映射嵌套对象

ObjectMapper 支持使用点语法来轻松实现嵌套对象的映射。比如有如下的 JSON 字符串：

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

你可以通过这种写法直接访问到嵌套对象：

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

嵌套的键名也支持访问数组中的值。如果有一个返回的 JSON 是一个包含 distance 的数组，可以通过这种写法访问：

distance <- map["distances.0.value"]

如果你的键名刚好含有 . 符号，你需要特别声明关闭上面提到的获取嵌套对象功能：

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

如果刚好有嵌套的对象的键名还有 . ,可以在中间加入一个自定义的分割符（#629）:

func mapping(map: Map) { appName <- map["com.myapp.info->com.myapp.name", delimiter: "->"] }

这种情况的 JSON 是这样的：

"com.myapp.info" : { "com.myapp.name" : "SwiftOldDriver" } 自定义转换规则

ObjectMapper 也支持在映射时自定义转换规则。如果要使用自定义转换，创建一个 tuple（元祖）包含 map["field_name"] 和你要使用的变换放在 <- 的右边：

birthday <- (map["birthday"], DateTransform())

当解析 JSON 时上面的转换会把 JSON 里面的 Int 值转成一个 NSDate ，如果是对象转为 JSON 时，则会把 NSDate 对象转成 Int 值。

只要实现 TransformType 协议就可以轻松的创建自定义的转换规则：

public protocol TransformType { associatedtype Object associatedtype JSON func transformFromJSON(_ value: Any?) -> Object? func transformToJSON(_ value: Object?) -> JSON? } TransformOf

大多数情况下你都可以使用框架提供的转换类 TransformOf 来快速的实现一个期望的转换。 TransformOf 的初始化需要两个类型和两个闭包。两个类型声明了转换的目标类型和源类型，闭包则实现具体转换逻辑。

举个例子，如果你想要把一个 JSON 字符串转成 Int ，你可以像这样使用 TransformOf ：

let transform = TransformOf<Int, String>(fromJSON: { (value: String?) -> Int? in // 把值从 String? 转成 Int? return Int(value!) }, toJSON: { (value: Int?) -> String? in // 把值从 Int? 转成 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) } })) 继承

实现了 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"] } }

注意确认子类中的实现调用了父类中正确的初始化器和映射函数。

泛型对象

ObjectMapper 可以处理泛型只要这个泛型也实现了 Mappable 协议。看这个例子：

class Result<T: Mappable>: Mappable { var result: T? required init?(map: Map){ } func mapping(map: Map) { result <- map["result"] } } let result = Mapper<Result<User>>().map(JSON) 映射时的上下文对象

Map 是在映射时传入的对象，带有一个 optional MapContext 对象，开发者可以通过使用这个对象在映射时传入一些信息。