逐步实现 JSON 解析类

最新推荐文章于 2024-04-11 07:30:00 发布
最新推荐文章于 2024-04-11 07:30:00 发布
阅读量558 收藏
点赞数
分类专栏： iOS 数据解析 文章标签： ios json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CuiXg/article/details/115204277
版权

逐步实现解析库

主流 JSON 解析库

  1. SwiftyJSON
  2. ObjectMapper
  3. HandyJSON
  4. JSONEncoder
  5. MJExtension
  6. YYModel
    …

Codable

Codable Swift 4 带来的新特性，是苹果官方提供的一套用于 JSON 解析的协议。
Codable 其实是一个组合协议，由 Decodable 和 Encodable 两个协议组成：

Codable` is a type alias for the `Encodable` and `Decodable` protocols.

相对于其他三方解析库，Codable最大的优势：只需要在类型声明中加上 Codable 协议就可以了，不需要写任何实际实现的代码。

简单应用

Model 类定义

如果使用 Codable 进行数据解析，仅需要使定义的数据模型遵守 Codable 协议即可。
定义的属性数据类型必须页遵守 Codable 协议。

class People: Codable {
    let name: String
    let age: Int
    let address: String
}

自定义键名

在定义的 modle 类中声明一个枚举，遵守 CodingKey 协议即可。

class People: Codable {
    let name: String
    let age: Int
    let address: String

    enum CodingKeys: String, CodingKey {
        case name = "user_name"
        case age = "user_age"
        case address
    }
}

解析方式使用

定义了一个简单的 JSON 解析类，很简单，一看就懂。

//
//  JSON.swift
//
//  Created by CuiXg on 2021/03/25.
//  Copyright © 2021 CuiXg. All rights reserved.
//

import UIKit

public struct JSONError: Error {
    public var code: Int
    public var message: String
    public var localizedDescription: String {
        return message
    }

    public init(code: Int, message: String) {
        self.code = code
        self.message = message
    }
}

public class JSON {


    /// Model 转 Data
    /// - Parameter object: 需要转换模型
    /// - Throws: 异常
    /// - Returns: 转换后 Data
    class func toData<T>(_ object: T) throws -> Data where T: Encodable {
        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        return try encoder.encode(object)
    }

    /// 数组 转 Data
    /// - Parameter array: 需要转换数组
    /// - Throws: 异常
    /// - Returns: 转换后 Data
    class func toData<T>(_ array: Array<T>) throws -> Data where T: Encodable {
        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        return try encoder.encode(array)
    }

    /// Model 转 JSONString
    /// - Parameter object: 需要转换数据模型
    /// - Throws: 异常
    /// - Returns: 转换后 JSON 字符串
    public class func toJSONString<T>(_ object: T) throws -> String where T: Encodable {

        let jsonData = try toData(object)
        if let JSONString = String(data: jsonData, encoding: .utf8) {
            return JSONString
        }else {
            throw JSONError(code: 1, message: "Data 转 JSONString 失败")
        }
    }

    /// 数组 转 JSONString
    /// - Parameter array: 需要转换数组
    /// - Throws: 异常
    /// - Returns: 转换后 JSON 字符串
    public class func toJSONString<T>(_ array: Array<T>) throws -> String where T: Encodable {
        let jsonData = try toData(array)
        if let JSONString = String(data: jsonData, encoding: .utf8) {
            return JSONString
        }else {
            throw JSONError(code: 1, message: "Data 转 JSONString 失败")
        }
    }

    /// JSONString 转 Model
    /// - Parameters:
    ///   - JSONString: 需要解析 JSON 字符串
    ///   - type: 数据模型类型
    /// - Throws: 异常
    /// - Returns: 转换后数据模型
    public class func parseObject<T>(_ JSONString: String, type: T.Type) throws -> T where T: Decodable {
        guard let jsonData = JSONString.data(using: .utf8) else {
            throw JSONError(code: 2, message: "JSONString 转 Data 失败")
        }
        return try JSONDecoder().decode(type, from: jsonData)
    }

    /// JSONString 转 数组
    /// - Parameters:
    ///   - JSONString: 需要解析 JSON 字符串
    ///   - type: 数组类型
    /// - Throws: 异常
    /// - Returns: 转换后数组
    public class func parseArray<T>(_ JSONString: String, type: Array<T>.Type) throws -> Array<T> where T: Decodable {
        guard let jsonData = JSONString.data(using: .utf8) else {
            throw JSONError(code: 2, message: "JSONString 转 Data 失败")
        }
        return try JSONDecoder().decode(type, from: jsonData)
    }
}

extension KeyedDecodingContainer {
    #if DEBUG
    #else
    public func decodeIfPresent<T>(_ type: T.Type, forKey key: K) throws -> T? where T: Decodable {
        if let value = try? decode(type, forKey: key) {
            return value
        }
        return nil
    }
    #endif
}

特殊处理

字段设置默认值或者缺少字段处理

使用 Property Wrapper 为 Codable 解码设定默认值
如何优雅的使用Swift Codable协议
参考以上两篇博客，实现了一个简单的设置默认值。

//
//  Default.swift
//
//  Created by CuiXg on 2021/3/25.
//  Copyright © 2021 CuiXg. All rights reserved.
//


/**
 *  为属性设置默认值,可与 Codable 联合使用
 *
 */

import UIKit

@propertyWrapper
struct Default<T: DefaultValue> {
    var wrappedValue: T.Value
}

extension Default: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(T.Value.self)) ?? T.defaultValue
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

protocol DefaultValue {
    associatedtype Value: Codable
    static var defaultValue: Value{ get }
}

extension KeyedDecodingContainer {
    func decode<T>(_ type: Default<T>.Type, forKey key: Key) throws -> Default<T> where T: DefaultValue {
        try decodeIfPresent(type, forKey: key) ?? Default(wrappedValue: T.defaultValue)
    }
}

extension KeyedEncodingContainer {
    mutating func encode<T>(_ value: Default<T>, forKey key: KeyedEncodingContainer<K>.Key) throws where T : DefaultValue{
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }
}

extension Int {
    enum Zero: DefaultValue {
        static let defaultValue = 0
    }
}

extension Float {
    enum Zero: DefaultValue {
        static let defaultValue = 0
    }
}

extension Double {
    enum Zero: DefaultValue {
        static let defaultValue = 0
    }
}

extension String {
    enum Empty: DefaultValue {
        static let defaultValue = ""
    }
}

extension Bool {
    enum False: DefaultValue {
        static let defaultValue = false
    }

    enum True: DefaultValue {
        static let defaultValue = true
    }
}


// String
@propertyWrapper
struct StringAsEmpty {
    var wrappedValue: String
}

extension StringAsEmpty: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(String.self)) ?? ""
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

extension KeyedDecodingContainer {
    func decode(_ type: StringAsEmpty.Type, forKey key: Key) throws -> StringAsEmpty {
        try decodeIfPresent(type, forKey: key) ?? StringAsEmpty(wrappedValue: "")
    }
}

extension KeyedEncodingContainer {
    mutating func encode(_ value: StringAsEmpty, forKey key: KeyedEncodingContainer<K>.Key) throws {
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }
}

// Int
@propertyWrapper
struct IntAsZero {
    var wrappedValue: Int
}

extension IntAsZero: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(Int.self)) ?? 0
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

extension KeyedDecodingContainer {
    func decode(_ type: IntAsZero.Type, forKey key: Key) throws -> IntAsZero {
        try decodeIfPresent(type, forKey: key) ?? IntAsZero(wrappedValue: 0)
    }
}

extension KeyedEncodingContainer {
    mutating func encode(_ value: IntAsZero, forKey key: KeyedEncodingContainer<K>.Key) throws {
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }
}

// Float
@propertyWrapper
struct FloatAsZero {
    var wrappedValue: Float
}

extension FloatAsZero: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(Float.self)) ?? 0
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

extension KeyedDecodingContainer {
    func decode(_ type: FloatAsZero.Type, forKey key: Key) throws -> FloatAsZero {
        try decodeIfPresent(type, forKey: key) ?? FloatAsZero(wrappedValue: 0)
    }
}

extension KeyedEncodingContainer {
    mutating func encode(_ value: FloatAsZero, forKey key: KeyedEncodingContainer<K>.Key) throws {
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }
}

// Double
@propertyWrapper
struct DoubleAsZero {
    var wrappedValue: Double
}

extension DoubleAsZero: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(Double.self)) ?? 0
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

extension KeyedDecodingContainer {
    func decode(_ type: DoubleAsZero.Type, forKey key: Key) throws -> DoubleAsZero {
        try decodeIfPresent(type, forKey: key) ?? DoubleAsZero(wrappedValue: 0)
    }
}

extension KeyedEncodingContainer {
    mutating func encode(_ value: DoubleAsZero, forKey key: KeyedEncodingContainer<K>.Key) throws {
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }
}


// Bool
@propertyWrapper
struct BoolAsFalse {
    var wrappedValue: Bool
}

extension BoolAsFalse: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(Bool.self)) ?? false
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

struct BoolAsTrue {
    var wrappedValue: Bool
}

extension BoolAsTrue: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(Bool.self)) ?? true
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

extension KeyedDecodingContainer {
    func decode(_ type: BoolAsFalse.Type, forKey key: Key) throws -> BoolAsFalse {
        try decodeIfPresent(type, forKey: key) ?? BoolAsFalse(wrappedValue: false)
    }

    func decode(_ type: BoolAsTrue.Type, forKey key: Key) throws -> BoolAsTrue {
        try decodeIfPresent(type, forKey: key) ?? BoolAsTrue(wrappedValue: true)
    }
}

extension KeyedEncodingContainer {
    mutating func encode(_ value: BoolAsFalse, forKey key: KeyedEncodingContainer<K>.Key) throws {
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }

    mutating func encode(_ value: BoolAsTrue, forKey key: KeyedEncodingContainer<K>.Key) throws {
       try encodeIfPresent(value.wrappedValue, forKey: key)
   }
}

简单使用;

class People: Codable {
    @StringAsEmpty var name: String // 默认值为 "" 不存在字段自动赋值为 ""
    @IntAsZero var age: Int // 默认值为 0
    @Default<Bool.False> var isMan: Bool // 为空时 默认值 false
    let address: String
}

本文源码|github

CuiXg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
json解析万能工具类
11-12
用于json解析万能工具类，只需传入jsonString以及数据模板类，可以返回对应的对象或list对象
json解析类
weixin_30924239的博客
12-31 74
package test; import java.util.List; import net.sf.json.JSONObject; import org.apache.http.HttpEntity;import org.apache.http.HttpResponse;import org.apache.http.client.HttpClient;import org.apac...
Json解析类
weixin_34041003的博客
07-18 57
Json解析类 定义两个辅助类　　 1 public class JSONObject : Dictionary<string, object> 2 { } 3 4 5 public class JSONArray : List<object> 6 { } 琮义两个辅助类 序列化 pu...
Json解析工具类
weixin_30807677的博客
07-30 429
这篇文章我是怀着无比激动的心情写得，为啥为啥？因为都要放假了！你们的小心心是不是已经躁动不安了！族长考虑到现在离高速免费通行还有几个小时，大家也闲来无事，在下就写点让小伙伴们打发打发时间！今天我们就看一点通过Gson-2.3.1.jar封装的工具类！希望有助于你（温馨提醒：别看的忘了游玩出行的时间哦~~） 工具类 package com.sunfreeter.util;i...
一文吃透Json解析工具类合集（FastJson、Jackson、Gson）
DT辰白
06-13 3893
Json解析工具类前言一、各个JSON技术的简介1.1 FastJson角色1.2 Jackson角色1.3 Gson角色二、使用步骤2.1 引入库1、FastJson依赖2、Jackson依赖3、Gson依赖2.2 将JSON 字符串转换为Java 对象1、FastJson版本2、Jackson版本3、Gson版本2.3 将Java对象转换为JSON 字符串1、FastJson版本2、Jackson版本3、Gson版本2.4 将JSON 字符串数组转为JSON数组1、FastJson版本2、Jackson
linux下c语言json解析源码实现
02-22
总的来说，C语言实现JSON解析需要深入理解JSON的语法规则，同时掌握C语言的基础知识，包括字符串处理、内存管理以及数据结构。虽然这是一项挑战，但通过实践和学习，我们可以创建出高效且可靠的JSON解析器。对于初学...
java解析DWG文件为json使用superMap
06-23
注意，实际的代码实现会涉及到SuperMap iObjects Java的具体API，例如使用`DataFactory`类加载DWG文件，然后使用`Dataset`和`Feature`对象处理地理数据，最后使用JSON库（如Jackson或Gson）将数据转换为JSON格式。...
Json解析工具
09-02
### Json解析工具详解 在日常开发工作中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式被广泛使用。为了方便地处理JSON数据，开发者们通常会选择使用各种JSON解析库来简化这一过程。本文将详细...
json所需要的夹包，json解析用，json，json夹包和教程，解析json所需要的夹包
11-15
它的API简洁明了，适用于快速实现JSON解析的小型项目。 对于Python，其标准库`json`提供了基本的解析和生成功能，语法简单。如果需要更高级的功能，可以使用第三方库如`SimpleJSON`，它提供了更快的性能。 学习...
SBJSON包的JSON解析
12-26
在这个场景中，我们将主要探讨SBJSON包中的JSON解析方式。 首先，SBJSON提供了四种不同的方法来处理JSON数据，虽然描述中提到“这里只有一种”，但为了全面理解，我们会详细讲解所有四种方法： 1. **解析（Parsing...
json解析成对象
05-21
json解析，解析复杂类型的数据。。。。。。。。。。。。。
C++实现JSon文件解析类
qq_32579021的博客
12-11 1293
不是很清楚
JSON三种数据解析方法
最新发布
专注于全栈开发领域
04-11 3025
上面写了三种解析JSON数据的方法，第一种是最麻烦的，但是不一定是最差的，后面两种Gson和FastJson都是最常用的方法，本博客里面用到的API也是最常用的API，基本开发都够用了，其余未涉及到的请自行查看源码学习吧。
JSON解析详解
程序猿老樊的博客
05-26 7813
​ JSON(JavaScriptObject Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。 ​
swift之字典转模型kvc、mjextention桥接、反射、HandyJSON、ObjectMapper、Codable
代码解释生活
01-31 1594
参考swift4.0字典转模型：https://www.cnblogs.com/shaoting/p/8087153.html     =====================kvc字典转模型========================= *****第一层模型 import UIKit class LYBHomeLunboModel: NSObject {     @...
Swift Codable 解析不确定类型
weixin_41963895的博客
02-08 580
【代码】SwiftCodable解析不确定类型。
JSON解析的几种方式
热门推荐
u011555996的博客
07-26 3万+
JSON是首先一种数据结构，说白了就是对数据的描述，刚刚出现是为了取代XML，可惜并没有，但是在作为配置文件上，却是很好，由于它小巧灵活，描述数据很好，所以在网络上进行数据传输更加方便。 请记住JSON对数据的描述形式，既然是形式，那么它的数据形式是什么样的： 对象的描述是: {} 这个表示jsonobject（json对象） 数组的描述是: [] 表示jsonarray（json数
stm32实现json解析
08-10
STM32是一款强大的单片机芯片，具有丰富的外设资源和高性能的处理器。要实现JSON解析，我们可以借助STM32的资源和功能来完成。 首先，我们需要在STM32上实现串口通信功能，这样可以通过串口将JSON数据发送到STM32芯片上。可以选择使用USART、UART或者USB等串口通信协议。 其次，我们需要编写相应的解析代码。JSON是一种轻量级的数据交换格式，常用于数据传输和存储。我们可以采用逐个字符解析的方式，逐步分析JSON字符串的各个部分，然后提取出需要的数据。 在解析过程中，我们可以使用STM32提供的字符串处理库来进行字符串的分割、拆分、比对等操作。同时，我们还可以利用STM32的内存操作功能，对解析到的JSON数据进行存储和处理。 最后，我们需要根据具体需求，将解析出的数据进行相应的处理。可以通过读取JSON数据中的属性值，控制STM32芯片的外设资源或者运行特定的功能。 总结起来，要在STM32上实现JSON解析，首先需要实现串口通信功能，然后编写解析代码，最后根据需求处理解析出的数据。这样就可以利用STM32的强大功能，实现JSON解析的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值