基本使用
使用时，类或结构体必须遵循Mappable协议
class User: Mappable {
var username: String?
var age: Int?
var weight: Double!
var array: [Any]?
var dictionary: [String : Any] = [:]
var bestFriend: User? // Nested User object
var friends: [User]? // Array of Users
var birthday: Date?
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"]
//反向转换
fahrenheit >>> map["重新命名JSON中的字段"]
}}
对JSON进行互换
let user = User(JSONString: JSONString)let JSONString = user.toJSONString(prettyPrint: true)
或者这样转换let user = Mapper<User>().map(JSONString: JSONString)let JSONString = Mapper().toJSONString(user, prettyPrint: true)
支持类型
Int
Bool
Double
Float
StringRawRepresentable (Enums)
Array<Any>
Dictionary<String, Any>
Object<T: Mappable>
Array<T: Mappable>
Array<Array<T: Mappable>>
Set<T: Mappable>
Dictionary<String, T: Mappable>
Dictionary<String, Array<T: Mappable>>
Mappable Protocol
mutating func mapping(map: Map)
解析JSON时，此功能在成功创建对象后执行。 当生成JSON时，它是在对象上调用的唯一函数。
init?(map: Map)
ObjectMapper使用这个构造器来创建对象。 在对象序列化之前，开发人员可以使用它来验证JSON。 在函数内返回nil将阻止映射发生。
required init?(map: Map){
// check if a required "name" property exists within the JSON.
if map.JSON["name"] == nil {
return nil
}}
嵌套对象的映射
[if !supportLists]· [endif]dictionary嵌套映射
"distance" : {
"text" : "102 ft",
"value" : 31}
//直接将31 映射到 distanceValuefunc mapping(map: Map) {
distanceValue <- map["distance.value"]}
[if !supportLists]· [endif]Array嵌套映射
//直接获取数组第一个元素的值distance <- map["distances.0.value"]
[if !supportLists]· [endif]key中含有.,禁用嵌套点语法
func mapping(map: Map) {
identifier <- map["app.identifier", nested: false]}
[if !supportLists]· [endif]自定义嵌套类型
{
"kr.xoul.user": {
"kr.xoul.name": "Suyeol Jeon",
"kr.xoul.username": "devxoul"
}}
//这种情况下，mapping解析出来就是不正确的
func mapping(map: Map) {
// this will parse the key as ["kr"]["xoul"]["user"]["kr"]["xoul"]["name"]
name <- map["kr.xoul.user.kr.xoul.name"]}
//自定义嵌套类型func mapping(map: Map) {
// this will parse the key as ["kr.xoul.user"]["kr.xoul.name"]
name <- map["kr.xoul.user->kr.xoul.name", delimiter: "->"]}
自定义转换规则
ObjectMapper支持在映射过程中转换值的自定义变换。
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)}
除了使用ObjectMapper给我们提供的转换规则（DateTransform，DateFormatterTransform，DataTransform，DateTransform，DictionaryTransform）外，我们还可以通过实现TransformType协议来自定义我们的转换规则
public protocol TransformType {
associatedtype Object
associatedtype JSON
func transformFromJSON(_ value: Any?) -> Object?
func transformToJSON(_ value: Object?) -> JSON?}
TransformOf
ObjectMapper为我们提供了一个TransformOf类来实现转换结果，TransformOf实际就是实现了TransformType协议的，TransformOf有两个类型的参数和两个闭包参数，类型表示参与转换的数据的类型
let transform = TransformOf<Int, String>(fromJSON: { (value: String?) -> Int? in
return Int(value!)}, toJSON: { (value: Int?) -> String? in
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) } }))
子类
子类可以继承父类的映射
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)
Mapping 上下文
在映射期间传递的Map对象具有可选的MapContext对象，如果在映射期间需要传递信息，该对象可供开发人员使用。只需创建一个实现MapContext的对象（它是一个空协议），并在初始化期间将其传递给Mapper。
struct Context: MapContext {
var importantMappingInfo = "Info that I need during mapping"}
class User: Mappable {
var name: String?
required init?(map: Map){
}
func mapping(map: Map){
if let context = map.context as? Context {
// use context to make decisions about mapping
}
}}
let context = Context()let user = Mapper<User>(context: context).map(JSONString)
网友评论