关于ios:KakaJSON源码浅析一

目前 github 上比拟常见的 Swift 版本 JSON 解析库有：

• ObjectMapper

  底层实现次要是通过运算符重载机制，须要手动对每一个属性写映射关系，比拟繁琐。

  struct Temperature: Mappable {
      var celsius: Double?
      var fahrenheit: Double?
  
      init?(map: Map) { }
  
      mutating func mapping(map: Map) {celsius     <- map["celsius"]
          fahrenheit     <- map["fahrenheit"]
      }
  }

• SwiftyJSON

  每次取值都须要通过下标，也比拟繁琐并且容易出错，底层实现次要是通过 JSONSerialization 相干 api 转成字典。

  // Getting a string from a JSON Dictionary
  let name = json["name"].stringValue

• HandyJSON（举荐应用）

  阿里推出的库，刚开始的版本应用了反射机制 Mirror 类，苹果并不激励应用，有性能方面的问题，前面也弃用了，引入了 reflection 这个库的源码并做了改变，用来实现类属性解析的性能。

  struct BasicTypes: HandyJSON {
      var int: Int = 2
      var doubleOptional: Double?
      var stringImplicitlyUnwrapped: String!
  }
  
  let jsonString = "{\"doubleOptional\":1.1,\"stringImplicitlyUnwrapped\":\"hello\",\"int\":1}"
  if let object = BasicTypes.deserialize(from: jsonString) {// …}

• KakaJSON（举荐应用）

前面进去的 MJ 开源的一个库，充分运用了 Swift 协定、运算符重载、指针、metadata 等技术，反对多种数据格式，比较完善；倡议有工夫能够认真看看底层源码的实现，源码到处都是协定。

struct Cat: Convertible {
    var name: String = ""
    var weight: Double = 0.0
}

// json can also be NSDictionary, NSMutableDictionary
let json: [String: Any] = [
    "name": "Miaomiao",
    "weight": 6.66
]

let cat1 = json.kj.model(Cat.self)

1、代码构造

这个代码构造，能够帮忙咱们大略的了解下各个次要代码模块是干啥的，对于有须要理解外围模块实现原理就可着重看看这块。

2、JSON 解析出 Model 具体的流程

咱们这里为了可能疾速调试出解析流程，model 外面临时只定义一个存储属性，多个属性或者其它 model 类型是相似的原理。

import KakaJSON
struct KKModel: Convertible {
    //var args: Any?
    //var headers: [String: Any]?
    //var origin: String?
    var url: String?
}

// 这里 value 是 Alamofire 返回的 json 数据
if let model = (value as? [String: Any])?.kj.model(KKModel.self) {print("解析 model 胜利", model)
}

通过调试后能够失去如下的解析流程图：

剖析下这里赋值操作的外围代码

mutating func kj_convert(from json: [String: Any]) {guard let mt = Metadata.type(self) as? ModelType else {Logger.warnning("Not a class or struct instance.")
            return
        }
        guard let properties = mt.properties else {Logger.warnning("Don't have any property.")
            return
        }
        
        // get data address
        let model = _ptr() 
        kj_willConvertToModel(from: json)
        
        for property in properties {
            // key filter
            let key = mt.modelKey(from: property.name,
                                  kj_modelKey(from: property)) 
            
            guard let newValue = kj_modelValue(from: json.kj_value(for: key),
                property)~! else {continue}
            
            let propertyType = property.dataType
            
            if Swift.type(of: newValue) == propertyType {property.set(newValue, for: model)
                continue
            }
            
            // Model Type have priority
            // it can return subclass object to match superclass type
            if let modelType = kj_modelType(from: newValue, property),
                let value = _modelTypeValue(newValue, modelType, propertyType) {property.set(value, for: model)
                continue
            }
            
            // try to convert newValue to propertyType
            guard let value = Values.value(newValue,
                                           propertyType,
                                           property.get(from: model)) else {property.set(newValue, for: model)
                continue
            }
            
            property.set(value, for: model)
        }
        
        kj_didConvertToModel(from: json)
    }

外面有几个代码点须要着重剖析了解下：

1）、guard let mt = Metadata.type(self) as? ModelType

Metadata.type(self) 是获取以后 model 的类型 BaseType

首先咱们看下各种 Type 的继承关系图：

咱们定义的 model 要么是类 class 要么是构造体 struct，它们都继承 ModelType，所以这里判断 model 的类型是 ClassType 或者 StructType，如果定义的 model 不是这 2 种 Type，提醒错误信息并 return。

从 Type 继承图关系能够看到还有很多其它 Type 类型，如元组、CFArray 这种类型等，次要利用于 model 定义的存储属性，所以这里要辨别开，不要搞混了（刚开始看这里的代码的时候会很容易搞混????）。

2）、let model = _ptr()

这里的 model 是以后定义的模型实例地址即指针，是 UnsafeMutableRawPointer 类型，前面在进行 set 赋值的时候会通过运算符重载将其转换为 UnsafeMutablePointer<T> 指针类型。

3）、for property in properties {}

遍历定义的存储属性，对每一个存储属性进行赋值

具体分析下外面的赋值代码：

a）、

// 这里是获取 key，返回的 key 是一个字符串或者数组
let key = mt.modelKey(from: property.name,
                                  kj_modelKey(from: property))

底层办法调用流程图：

b）、

// 将 json 值转换为用户自定义 model 外面实现 kj_modelValue 办法的值，如果用户没有实现 kj_modelValue，那么间接返回 jsonValue
guard let newValue = kj_modelValue(from: json.kj_value(for: key),
                property)~! else {continue}

底层办法调用流程图：

c）、

// 如果它们类型雷同间接赋值，比方 Any.Type 和 String.Type 是不相等的，比方用户类型写错了或者也没有实现 kj_modelValue 办法，类型无奈匹配
if Swift.type(of: newValue) == propertyType {
    // 会把指针 model 传入会被转换为 UnsafeMutablePointer<T> 类型进行赋值操作
    property.set(newValue, for: model)
    continue
}

外围赋值操作都是调用 property.set(newValue, for: model)，咱们剖析下底层这里是如何实现的：

为了能更直观的展现调用过程，咱们这里还是用流程图：

看完这里你是不是会有一个疑难，就是如果类型不匹配怎么办，即应该有类型失败的一个判断，比方咱们定义的存储属性是 String，然而 json 返回的是一个 Array 数组？看流程图的最初一步，as? 就是类型转换的一个判断，如果类型不匹配是不会通过指针写入内存的。

d）、

// 如果下面都还没有赋值胜利，那么就进行类型转换
guard let value = Values.value(newValue,
                               propertyType,
                               property.get(from: model)) else {
    // 类型转换失败，用 newValue 间接进行赋值，如果失败交给 as？去解决
    property.set(newValue, for: model)
    continue
}

e）、

kj_willConvertToModel(from: json)
kj_didConvertToModel(from: json)

当有须要监听转换过程，可实现这 2 个办法

至此整个 JSON 解析过程咱们就剖析完了

很多时候咱们在看一些第三方库源码的时候有时候会云里雾里的，这个时候可再去看看作者在 github 下面介绍的这个库的性能点，你就能恍然大悟，因为咱们平时在我的项目中用的时候并不是所有性能点都能用到，看理论需要。

参考文献

https://github.com/kakaopenso…

https://github.com/alibaba/Ha…