文 / 菲拉兔
自己撸的图
要求：
- Platform: iOS8.0+
- Language: Swift4.0
- Editor: Xcode9
【问题补充2017-09-28】
最近我发现了一个问题：在Swift4.0中对JSON数据进行解析的时候，如果还用老的
JSONSerialization类的话，会出现一个BUG：
- 问题： 比如我有一个
NSObject的类叫Student，其中包含一个var name = ""属性，那么在以上方法解析JSON数据的过程中，name的值将不被写入，这应该是Swift4.0的一个BUG；- 解决方法：
- 用其他的名字替代
name字段（暂时发现只有对这个属性不起作用），例如var sname = ""；
- 用
JSONDecoder新的方式去解析；
Swift4.0以前和OC时代的JSON数据处理
Swift（1..<4）& Objective-C
Swift4.0以前的JSON解析/编码，和OC时代一样，都是通过NSJSONSerialization类的一些类方法进行处理的
- JSON解析
struct GroceryProduct{
var name: String
var points: Int
var description: String
}
// 数据获取
guard let fileURL = Bundle.main.url(forResource: "test.json", withExtension: nil),
let data = try? Data.init(contentsOf: fileURL) else{
fatalError("`JSON File Fetch Failed`")
}
// JSON序列化
guard let json = try? JSONSerialization.jsonObject(with: data, options: .mutableContainers),
let array = json as? [[String: Any]] else{
fatalError("`JSON Data Serialize Failed`")
}
// 数据整理
var products = [GroceryProduct]()
for dict in array {
products.append(GroceryProduct.init(name: dict["name"] as? String ?? "",
points: dict["points"] as? Int ?? 0,
description: dict["description"] as? String ?? ""))
}
print(products)
Note：Swift编程中官方推荐用Struct代替Class，因为不占存储空间，但在实际开发中，如果用Struct去存储解析出来的JSON数据，还是比较麻烦的，尤其是在JSON序列化方面。下面用Class代替Struct演示Class在JSON序列化过程中的方便之处。
// 数据解析和处理全封装在数据Model里，更体现封装性
class GroceryProduct: NSObject{
var name = ""
var points = 0
var descript = ""
override func setValue(_ value: Any?, forKey key: String) {
// 拦截并进行数据处理
if key == "points" {
points = (value as? Int) ?? 10
}
else{
super.setValue(value, forKey: key)
}
}
// 未定义key的处理
override func setValue(_ value: Any?, forUndefinedKey key: String) {
if key == "description" {
descript = value as? String ?? ""
}
}
}
// 数据整理
var products = [GroceryProduct]()
for dict in array {
let product = GroceryProduct()
product.setValuesForKeys(dict)
products.append(product)
}
print(products)
- JSON编码
// JSON编码
struct GroceryProduct{
var name: String
var points: Int
var description: String
// 将对象中的属性-值转换为JSON字典
func JSONDictionary(ignored keys: [String] = []) -> [String: Any] {
var dictionary = [String: Any]()
let mirror = Mirror.init(reflecting: self)
for (key, value) in mirror.children {
guard let key = key else{
continue
}
guard !keys.contains(key) else{
continue
}
dictionary.updateValue(value, forKey: key)
}
return dictionary
}
}
// 需要编码的JSON Object
var jsonArray = [[String: Any]]()
for product in products {
jsonArray.append(product.JSONDictionary())
}
// 判断是否是合法的JSON Object
guard JSONSerialization.isValidJSONObject(jsonArray) else{
fatalError("`Not Validate JSON Object`")
}
// 对象编码为JSON Data，并解析为JSON Text
guard let data = try? JSONSerialization.data(withJSONObject: jsonArray, options: .prettyPrinted),
let jsonText = String(data: data, encoding: .utf8) else{
fatalError("`JSON Object Encode Failed`")
}
print(jsonText)
Note: 合法的JSON Object应满足：
- 顶层对象为
数组或字典对象- 数组/字典中的所有对象必须为
字符串, 数字类型NSNumber, 数组, 字典, 或 NSNull- 所有的字典keys为
字符串- 所有的数字对象不能为
NaN 或 infinity
所以struct / class 对象在JSON编码过程中需要自己手动转换成字典/数组，才可以正确被编码为JSON Data，并转换为字符串，然后发给服务器。
Swift4.0中JSON的操作
Swift4.0中利用全新采用JSONDecoder/JSONEncoder类来实现JSON数据的解析和编码。
JSONDecoder
- 要将JSON Data解析成相应的数据模型，并匹配相应的属性-值，对应的Struct或Class类型要遵守Decodable协议
//Decodable只能解析，不能被编码
struct GroceryProduct: Decodable{
var name: String
var points: Int
var description: String
}
func swift4JSONParser() {
// 数据获取
guard let fileURL = Bundle.main.url(forResource: "test.json", withExtension: nil),
let data = try? Data.init(contentsOf: fileURL) else{
fatalError("`JSON File Fetch Failed`")
}
// 利用JSONDecoder来解析JSON Data，解析成[GroceryProduct].self数组类型
let decoder = JSONDecoder()
guard let products = try? decoder.decode([GroceryProduct].self, from: data) else{
fatalError("`JSON Decode Failed`")
}
print(products)
}
Custom Key Names
- 有些时候，服务器返回的JSON数据中的字段名采用“蛇形”命名法，如果要转成iOS中“驼峰”命名法，就要手动对keys做一次匹配。
- Swift4.0中，只要指定Struct/Class中的CodingKeys并遵守CodingKeys协议枚举类型属性，并实现对应关系，就可以自动进行匹配替换解析。但注意如果CodingKeys中case没有匹配到JSON中的字段，解析就会失败。
- 从这一点来说，还是挺麻烦的，不如用Class中的
setValue(_ value: Any?, forUndefinedKey key: String)，然后匹配指定对应的属性名称。
struct GroceryProduct: Decodable{
var name: String
var points: Int
var description: String
// CodingKeys
private enum CodingKeys: String, CodingKey{
case name = "product_name"
case points = "product_points"
case description //保持一致，但必须实现所有属性
}
}
func swift4JSONParser() {
// 数据获取
guard let fileURL = Bundle.main.url(forResource: "test.json", withExtension: nil),
let data = try? Data.init(contentsOf: fileURL) else{
fatalError("`JSON File Fetch Failed`")
}
let decoder = JSONDecoder()
guard let products = try? decoder.decode([GroceryProduct].self, from: data) else{
fatalError("`JSON Decode Failed`")
}
print(products)
}
Simple Nested JSON Data
Swift4.0中对于JSON数据的嵌套结构解析，也有了新的方式，不过还是较为简单。
- JSON数据：
[
{
"name": "Home Town Market",
"products": [
{
"name": "Banana",
"points": 200,
"description": "A banana that's perfectly ripe."
},
{
"name": "Apple",
"points": 200,
"description": "A banana that's perfectly ripe."
}
]
}
]
- 定义结构体
struct Product: Decodable {
var name: String
var points: Int
var description: String
}
struct GroceryStore: Decodable {
var name: String
var products: [Product]
}
- 嵌套解析
func swift4JSONParser() {
// 数据获取
guard let fileURL = Bundle.main.url(forResource: "test.json", withExtension: nil),
let data = try? Data.init(contentsOf: fileURL) else{
fatalError("`JSON File Fetch Failed`")
}
// 会自动匹配解析成相应的Product对象，因为Product也实现了Decodable协议
let decoder = JSONDecoder()
guard let stores = try? decoder.decode([GroceryStore].self, from: data) else{
fatalError("`JSON Decode Failed`")
}
print(stores)
Multiple Level Nested JSON Data
多层嵌套数据解析时，有一些结构是我们不需要存储的，这就我们定义一个中间的service模型来临时搭建这个结构。
- JSON数据：
[
{
"name": "Big City Market",
"aisles": [
{
"name": "Sale Aisle",
"shelves": [
{
"name": "Seasonal Sale",
"product": {
"name": "Chestnuts",
"points": 700,
"description": "Chestnuts that were roasted over an open fire."
}
},
{
"name": "Last Season's Clearance",
"product": {
"name": "Pumpkin Seeds",
"points": 400,
"description": "Seeds harvested from a pumpkin."
}
}
]
}
]
}
]
- 定义存储数据模型
struct Product: Decodable {
var name: String
var points: Int
var description: String
}
struct GroceryStore {
var name: String
var products: [Product]
}
// 中间`架构`类型
struct GroceryStoreService: Decodable {
let name: String
let aisles: [Aisle]
struct Aisle: Decodable {
let name: String
let shelves: [Shelf]
struct Shelf: Decodable {
let name: String
let product: Product
}
}
}
// 扩展接口，实现数据解析
extension GroceryStore {
init(from service: GroceryStoreService) {
name = service.name
products = []
for aisle in service.aisles {
for shelf in aisle.shelves{
products.append(shelf.product)
}
}
}
}
- 嵌套解析
func swift4JSONParser() {
// 数据获取
guard let fileURL = Bundle.main.url(forResource: "test.json", withExtension: nil),
let data = try? Data.init(contentsOf: fileURL) else{
fatalError("`JSON File Fetch Failed`")
}
let decoder = JSONDecoder()
guard let serviceStores = try? decoder.decode([GroceryStoreService].self, from: data)else{
fatalError("`JSON Decode Failed`")
}
// 数据剥离存储
let stores = serviceStores.map{ GroceryStore(from: $0) }
print(stores)
}
Merge Data from Different Depths
合并不同深度层的数据。此时一般要转换成KeyedDecodingContainer进行解析。
- JSON数据：
{
"Banana": {
"points": 200,
"description": "A banana grown in Ecuador."
},
"Orange": {
"points": 100,
"description": "A juicy orange."
}
}
- 数据模型:
struct GroceryStore {
struct Product {
let name: String
let points: Int
let description: String
}
var products: [Product]
init(products: [Product] = []) {
self.products = products
}
}
- 合并解析
// 扩展增加ProductKey实现CodingKey，便于深层次解析属性
extension GroceryStore {
struct ProductKey: CodingKey {
// 实现协议方法和属性
var stringValue: String
init?(stringValue: String) {
self.stringValue = stringValue
}
var intValue: Int? { return nil }
init?(intValue: Int) { return nil }
// 自定义keys
static let points = ProductKey(stringValue: "points")!
static let description = ProductKey(stringValue: "description")!
}
}
// 扩展实现Decodable协议，并通过decoder.container找到key对应的容器对象
extension GroceryStore: Decodable{
init(from decoder: Decoder) throws {
var products = [Product]()
// 找到包含ProductKey中的属性的所有容器
let container = try decoder.container(keyedBy: ProductKey.self)
// 然后遍历这个容器中的所有key，解析出容器中key对应的数据值
for key in container.allKeys {
let productContainer = try container.nestedContainer(keyedBy: ProductKey.self, forKey: key)
let points = try productContainer.decode(Int.self, forKey: .points)
let description = try productContainer.decode(String.self, forKey: .description)
let product = Product(name: key.stringValue, points: points, description: description)
products.append(product)
}
self.init(products: products)
}
}
func swift4JSONParser() {
// 数据获取
guard let fileURL = Bundle.main.url(forResource: "test.json", withExtension: nil),
let data = try? Data.init(contentsOf: fileURL) else{
fatalError("`JSON File Fetch Failed`")
}
// 数据解析
let decoder = JSONDecoder()
guard let store = try? decoder.decode(GroceryStore.self, from: data)else{
fatalError("`JSON Decode Failed`")
}
print(store.products)
}
JSONEncoder
要实现包含Struct/Class对象的JSON对象的编码，在Swift4.0中较为简单，只需要遵守Encodable协议，并指定要编码的keys和实现协议encode方法即可。
- JSON数据：
[
{
"name": "Vegetables Store",
"products": [
{
"name": "Banana",
"points": 200,
"description": "A banana grown in Ecuador."
},
{
"name": "Orange",
"points": 100,
"description": "A juicy orange."
}
]
}
]
- 编码实现
struct Product: Decodable {
let name: String
let points: Int
let description: String
}
struct GroceryStore: Decodable {
var name: String
var products: [Product]
}
// 实现编码协议
extension GroceryStore: Encodable{
private enum CodingKeys: CodingKey{
case name
case products
}
// 封装要编码的数据结构
func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encode(name, forKey: .name)
try container.encode(products, forKey: .products)
}
}
extension Product: Encodable{
private enum CodingKeys: CodingKey{
case name
case points
case description
}
func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encode(name, forKey: .name)
try container.encode(points, forKey: .points)
try container.encode(description, forKey: .description)
}
}
// 要求object为实现了Encodable协议的对象
func swift4JSONEncode<T: Encodable> (withJSONObject object: T){
// 编码
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
guard let encodedData = try? encoder.encode(object),
let jsonText = String(data: encodedData, encoding: .utf8) else {
fatalError("`JSON Encode Failed`")
}
print(jsonText)
}
补充2017-09-22
在有些情况下，需要struct对象中的某些属性不是全部需要被存储和解析，就需要手动进行decode了
- 定义结构体
struct GitHubUser {
var id: Int
var type: String
var loginName: String
var avatarUrl: String
var homepageUrl: String
var profileUrl: String
var name: String
var company: String
var location: String
var blog: String
var bio: String
enum CodingKeys: String, CodingKey{
case id,type,name,company,location,blog,bio
case loginName = "login"
case avatarUrl = "avatar_url"
case homepageUrl = "html_url"
case profileUrl = "url"
}
}
- 自定义解析
extension GitHubUser: Decodable{
// 必须实现所有属性 - 初始值
init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
id = try values.decode(Int.self, forKey: .id)
type = try values.decode(String.self, forKey: .type)
loginName = try values.decode(String.self, forKey: .loginName)
avatarUrl = try values.decode(String.self, forKey: .avatarUrl)
homepageUrl = try values.decode(String.self, forKey: .homepageUrl)
profileUrl = try values.decode(String.self, forKey: .profileUrl)
// 以下属性为可选解析的，设置默认值
do {
name = try values.decode(String.self, forKey: .name)
}catch{
name = ""
}
do {
company = try values.decode(String.self, forKey: .company)
}catch{
company = ""
}
do {
location = try values.decode(String.self, forKey: .location)
}catch{
location = ""
}
do{
blog = try values.decode(String.self, forKey: .blog)
}catch{
blog = ""
}
do{
bio = try values.decode(String.self, forKey: .bio)
}catch{
bio = ""
}
}
}
如果对你有帮助，别忘了点个❤️并关注下我哦。
