ObjectMapper使用

基本使用

使用时，类或结构体必须遵循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().map(JSONString: JSONString)
let JSONString = Mapper().toJSONString(user, prettyPrint: true)

支持类型

Int
Bool
Double
Float
String
RawRepresentable (Enums)
Array
Dictionary
Object
Array
Array>
Set
Dictionary
Dictionary>

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
    }
}

嵌套对象的映射

• dictionary嵌套映射

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

//直接将31 映射到  distanceValue
func mapping(map: Map) {
    distanceValue <- map["distance.value"]
}

• Array嵌套映射

//直接获取数组第一个元素的值
distance <- map["distances.0.value"]

• key中含有.,禁用嵌套点语法

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

• 自定义嵌套类型

{
  "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().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(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(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: Mappable {
    var result: T?

    required init?(map: Map){

    }

    func mapping(map: Map) {
        result <- map["result"]
    }
}

let result = Mapper>().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(context: context).map(JSONString)