Swift 使用Codable协议进行json转模型
2022-05-22 本文已影响0人
aven_kang
1.序列化和反序列化
- 序列化：将对象转换为字节序列的过程，在传递和保存对象时，保证对象的完整性和完整性，方便在网络上传输或者保存在文件中
let responseData = try? JSONSerialization.data(withJSONObject: response)
- 反序列化：将字节序列恢复为对象的过程，重建对象，方便使用
let obj = try? JSONSerialization.jsonObject(with: data, options: .allowFragments
2.encode和decode
- encode：将自身类型编码成其他外部类型
let data = try? JSONEncoder().encode(obj)
- decode：将其他外部类型解码成自身类型
let obj = try? JSONDecoder().decode(T.self, from: data)
3.Codable
public typealias Codable = Decodable & Encodable
实际上，Codable就是指的编码和解码协议
4.json转模型
4.1在用原生Codable协议的时候，需要遵守协议Codable，结构体，枚举，类都可以遵守这个协议，一般使用struct
struct UserModel:Codable {
var name: String?
var age: Int?
var sex: Bool?
var name_op: String?
}
注意，你的json里面的字段可能没有值，因此需要设置可选值
4.2 json数据里面的字段和model字段不一致
解决办法：实现 enum CodingKeys: String, CodingKey {}这个映射关系
struct UserModel:Codable {
var name: String?
var age: Int?
var sex: Bool?
var name_op: String?
var nick: String?
enum CodingKeys: String, CodingKey {
case name
case age
case sex
case name_op
case nick = "nick_name"
}
}
上诉代码中，如果后台返回的字段名称叫做nick_name，但是你想用自己命名的nick，就可以用到上述枚举中的映射去替换你想要的字段名字。
4.3如果你的模型里面带有嵌套关系，比如你的模型里面有个其他模型或者模型数组，那么只要保证嵌套的模型里面依然实现了对应的协议
struct UserModel:Codable {
var name: String?
var age: Int?
var sex: Bool?
var name_op: String?
var nick: String?
var books_op: [BookModel]?
enum CodingKeys: String, CodingKey {
case name
case age
case sex
case name_op
case nick = "nick_name"
}
}
// BookModel
struct BookModel:Codable {
var name:String ?
}
4.4如果json里面数据类型和model数据类型不一致，最常见的有（Bool和Int，Int和String）这些在后台弱类型语言上是不加区分
解决办法：定义了一个可能是Bool或者Int的类型
struct TIntBool:Codable {
var int:Int {
didSet {
if int == 0 { self.bool = false
} else { self.bool = true }
}
}
var bool:Bool {
didSet {
if bool { self.int = 1
} else { self.int = 0 }
}
}
//自定义解码(通过覆盖默认方法实现)
init(from decoder: Decoder) throws {
let singleValueContainer = try decoder.singleValueContainer()
if let intValue = try? singleValueContainer.decode(Int.self) {
self.int = intValue
self.bool = (intValue != 0)
} else if let boolValue = try? singleValueContainer.decode(Bool.self) {
self.bool = boolValue
if boolValue { self.int = 1
} else { self.int = 0 }
} else {
self.bool = false
self.int = 0
}
}
}
下面是一个Int 或者String类型的
struct TStrInt: Codable {
var int:Int {
didSet {
let stringValue = String(int)
if stringValue != string {
string = stringValue
}
}
}
var string:String {
didSet {
if let intValue = Int(string), intValue != int {
int = intValue
}
}
}
//自定义解码(通过覆盖默认方法实现)
init(from decoder: Decoder) throws {
let singleValueContainer = try decoder.singleValueContainer()
if let stringValue = try? singleValueContainer.decode(String.self)
{
string = stringValue
int = Int(stringValue) ?? 0
} else if let intValue = try? singleValueContainer.decode(Int.self)
{
int = intValue
string = String(intValue);
} else
{
int = 0
string = ""
}
}
}
因此在模型设计的时候就可以这样了：
struct UserModel:Codable {
var name: String?
var age: Int?
var sex: Bool?
var name_op: String?
var nick: String?
var books_op: [BookModel]?
var stringInt: TStrInt?
var boolInt: TIntBool?
enum CodingKeys: String, CodingKey {
case name
case age
case sex
case name_op
case nick = "nick_name"
case stringInt
case boolInt
}
}
// BookModel
struct BookModel:Codable {
var name:String ?
}
4.4使用JSONDecoder进行json转model
private func jsonToModel<T: Codable>(_ modelType: T.Type, _ response: Any) -> T? {
guard let data = try? JSONSerialization.data(withJSONObject: response), let info = try? JSONDecoder().decode(T.self, from: data) else {
return nil
}
return info
}
先使用JSONSerialization进行一次序列化操作
看一下decode源码：
// MARK: - Decoding Values
/// Decodes a top-level value of the given type from the given JSON representation.
///
/// - parameter type: The type of the value to decode.
/// - parameter data: The data to decode from.
/// - returns: A value of the requested type.
/// - throws: `DecodingError.dataCorrupted` if values requested from the payload are corrupted, or if the given data is not valid JSON.
/// - throws: An error if any value throws an error during decoding.
open func decode<T : Decodable>(_ type: T.Type, from data: Data) throws -> T {//泛型并且约束遵守协议
let topLevel: Any
do {
//反序列化操作
topLevel = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
} catch {
throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "The given data was not valid JSON.", underlyingError: error))
}
let decoder = _JSONDecoder(referencing: topLevel, options: self.options)
//调用unbox解码并返回解码后的数据
guard let value = try decoder.unbox(topLevel, as: type) else {
throw DecodingError.valueNotFound(type, DecodingError.Context(codingPath: [], debugDescription: "The given data did not contain a top-level value."))
}
return value
}
可以看到在转model的时候，先进行一次序列化操作，decode内部又进行一次反序列化操作，苹果这样设计估计是在参数传递的时候想让我们传递字节流
至此就可以使用swift原生协议Codable进行json转model了
JSON字符串转模型
这是一个字符串
let jsonString:String = """
{
"name":"Tomas",
"age":"10",
"gender":"man"
}
"""
如果将它解析成User对象
let jsonData: Data = jsonString.data(using:String.Encoding.utf8)!
let decoder = JSONDecoder()
do {
let user:UserModel = try decoder.decode(UserModel.self,from:jsonData)
} catch {
}
JSONSerialization
Serialization 是序列化的意思，JSONSerialization 顾名思义是对JSON进行序列化。
JSONSerialization 是对 JSON 字符串进行序列化和反序列化的工具类。用这个类可以将JSON转成对象，也可以将对象转成JSON。
let dict:[String:Any] = ["name":"jack",
"age":10,
"gender":"man"]
if JSONSerialization.isValidJSONObject(dict) == false {
return
}
let data:Data = try! JSONSerialization.data(withJSONObject: dict, options: .fragmentsAllowed);
// 将data转换成制定model
guard let Model:UserModel = try? JSONDecoder().decode(UserModel.self, from: data) else {
return
}
// 将data转成字符串输出
let string = String(data: data, encoding: String.Encoding.utf8)
print(string)
print(Model.name)
Optional("{\"name\":\"jack\",\"gender\":\"man\",\"age\":10}")
Optional("jack")
- JSON转字典
let jsonString = "{\"name\":\"jack\",\"age\":10}";
let data = jsonString.data(using: .utf8)
let dict = try! JSONSerialization.jsonObject(with: data!, options: .allowFragments)
print(dict)
