帅驼驼
帅驼驼

Swift底层进阶--015：Codable源码解析

Codable协议在Swift4.0开始被引入，目的是取代NSCoding协议。Codable协议对Swift基本内嵌类型完美支持，能够把JSON弱类型数据转为代码中使用的强类型数据。

Codable协议是Encodable和Decodable协议的组合，如果实现了Codable，就表明实现了Encodable和Decodable。如果想要实现自定义类型或数据模型的编码和解码，必须遵循Codable协议。

Swift基本内嵌类型都默认遵循Codable协议，比如String、Int、Double、Date和Data。另外Array、Dictionary和Optional也都遵循Codable协议，可以直接使用编码和解码。

常⻅⽤法

定义LGTeacher结构体，遵循Codable协议

struct LGTeacher: Codable{
    var name: String
    var age: Int
}

JSONEncoder编码，将自定义类型转为JSON

let t = LGTeacher.init(name: "Zang", age: 18)

let jsonEncoder = JSONEncoder()
let jsonData = try? jsonEncoder.encode(t)

if let data = jsonData {
    let jsonString = String(decoding: data, as: UTF8.self)
    print(jsonString)
}

//输出以下内容：
//{"name":"Zang","age":18}

JSONDecoder解码，将JSON转为自定义类型

let jsonString = """
{
    "age": 18,
    "name": "Zang",
}
"""

let jsonData = jsonString.data(using: .utf8)
if let data = jsonData{
    
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode(LGTeacher.self, from: data)
    print(t ?? "解析失败")
}

//输出以下内容：
//LGTeacher(name: "Zang", age: 18)
嵌套的模型

对于嵌套模型，必须保证所有模型都遵循Codable协议，才能进行编码和解码

struct LGTeacher: Codable{
    var name: String
    var className: String
    var courceCycle: Int
    var personInfo: PersonInfo
}

extension LGTeacher {
    struct PersonInfo: Codable {
        var age: Int
        var height: Double
    }
}

JSONEncoder编码

let t = LGTeacher.init(name: "Zang", className: "Swift", courceCycle: 10, personInfo: LGTeacher.PersonInfo.init(age: 18, height: 1.85))

let jsonEncoder = JSONEncoder()
let jsonData = try? jsonEncoder.encode(t)

if let data = jsonData {
    let jsonString = String(decoding: data, as: UTF8.self)
    print(jsonString)
}

//输出以下内容：
//{"personInfo":{"age":18,"height":1.85},"courceCycle":10,"className":"Swift","name":"Zang"}

JSONDecoder解码

let jsonString = """
{
    "name": "Zang",
    "className": "Swift",
    "courceCycle": 10,
    "personInfo": {
        "age": 18,
        "height": 1.85
    }
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{

    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode(LGTeacher.self, from: data)
    print(t ?? "解析失败")
}

//输出以下内容：
//LGTeacher(name: "Zang", className: "Swift", courceCycle: 10, personInfo: xdgTestHelper.LGTeacher.PersonInfo(age: 18, height: 1.85))

如果出现未遵循Codable协议的类型，例如PersonInfo，编译报错

编译报错

包含数组

LGTeacher结构体内，包含personList数组类型

struct LGTeacher: Codable{
    var name: String
    var className: String
    var courceCycle: Int
    var personList: [PersonInfo]
}

extension LGTeacher {
    struct PersonInfo: Codable {
        var age: Int
        var height: Double
    }
}

JSONDecoder解码

let jsonString = """
{
    "name": "Zang",
    "className": "Swift",
    "courceCycle": 10,
    "personList": [
        {
            "age": 18,
            "height": 1.85
        },{
            "age": 20,
            "height": 1.75
        }
    ]
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode(LGTeacher.self, from: data)
    print(t ?? "解析失败")
}

//输出以下内容：
//LGTeacher(name: "Zang", className: "Swift", courceCycle: 10, personList: [xdgTestHelper.LGTeacher.PersonInfo(age: 18, height: 1.85), xdgTestHelper.LGTeacher.PersonInfo(age: 20, height: 1.75)])
数组集合

当解析类型为数组集合，在decode方法传入[LGTeacher].self即可

struct LGTeacher: Codable{
    var name: String
    var className: String
    var courceCycle: Int
}

let jsonString = """
[
    {
        "name": "Kody",
        "className": "Swift",
        "courceCycle": 12
    },{
        "name": "Cat",
        "className": "强化班",
        "courceCycle": 15
    },{
        "name": "Hank",
        "className": "逆向班",
        "courceCycle": 22
    },{
        "name": "Cooci",
        "className": "⼤师班",
        "courceCycle": 22
    }
]
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode([LGTeacher].self, from: data)
    print(t ?? "解析失败")
}

//输出以下内容：
//[xdgTestHelper.LGTeacher(name: "Kody", className: "Swift", courceCycle: 12), xdgTestHelper.LGTeacher(name: "Cat", className: "强化班", courceCycle: 15), xdgTestHelper.LGTeacher(name: "Hank", className: "逆向班", courceCycle: 22), xdgTestHelper.LGTeacher(name: "Cooci", className: "⼤师班", courceCycle: 22)]
JSON数据中有Optional values

日常开发中，和服务端对接数据难免出现null，如果处理不当很可能程序crash

crash

兼容方案：将可能为null的属性使用声明为Optional可选值

Optional 

struct LGTeacher: Codable{
    var name: String
    var className: String?
    var courceCycle: Int
}

let jsonString = """
[
    {
        "name": "Kody",
        "className": "Swift",
        "courceCycle": 12
    },{
        "name": "Cat",
        "className": "强化班",
        "courceCycle": 15
    },{
        "name": "Hank",
        "className": null,
        "courceCycle": 22
    },{
        "name": "Cooci",
        "className": "⼤师班",
        "courceCycle": 22
    }
]
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode([LGTeacher].self, from: data)
    print(t ?? "解析失败")
}

//输出以下内容：
//[xdgTestHelper.LGTeacher(name: "Kody", className: Optional("Swift"), courceCycle: 12), xdgTestHelper.LGTeacher(name: "Cat", className: Optional("强化班"), courceCycle: 15), xdgTestHelper.LGTeacher(name: "Hank", className: nil, courceCycle: 22), xdgTestHelper.LGTeacher(name: "Cooci", className: Optional("⼤师班"), courceCycle: 22)]
元组类型

⽐如⼀个坐标，location : [20, 10]，当使⽤Codable进⾏解析的过程中，需要实现init(from decoder: Decoder)方法

struct Location: Codable {
    var x: Double
    var y: Double

    init(from decoder: Decoder) throws{
        var contaioner = try decoder.unkeyedContainer()
        self.x = try contaioner.decode(Double.self)
        self.y = try contaioner.decode(Double.self)
    }
}

struct RawSeverResponse: Codable{
    var location: Location
}

let jsonString = """
{
    "location": [20, 10]
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode(RawSeverResponse.self, from: data)
    print(t ?? "解析失败")
}

//输出以下内容：
//RawSeverResponse(location: xdgTestHelper.Location(x: 20.0, y: 10.0))

使用unkeyedContainer，表示不解析当前的Key，也就是x、y。然后单方面赋值给x和y属性

继承

父类和子类无法同时遵循Codable协议，否则编译报错

编译报错

尝试让父类遵循Codable协议，是否可以解码正常？

class LGTeacher: Codable {
    var name: String?
}

class LGChild: LGTeacher {
    var partTime: Int?
}

let jsonString = """
{
    "name": "Zang",
    "partTime": 20
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let c = try? jsonDecoder.decode(LGChild.self, from: data)
    print("name：\(c?.name)，partTime：\(c?.partTime)")
}

//输出以下内容：
//name：Optional("Zang")，partTime：nil

上述代码，父类遵循Codable协议，仅父类的属性可以被解析，子类的属性被解析为nil

如果让子类遵循Codable协议，是不是就正常了？

class LGTeacher {
    var name: String?
}

class LGChild: LGTeacher, Codable {
    var partTime: Int?
}

let jsonString = """
{
    "name": "Zang",
    "partTime": 20
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let c = try? jsonDecoder.decode(LGChild.self, from: data)
    print("name：\(c?.name)，partTime：\(c?.partTime)")
}

//输出以下内容：
//name：nil，partTime：Optional(20)

上述代码，子类遵循Codable协议，仅子类的属性可以被解析，父类的属性被解析为nil

针对继承造成的编解码问题，在后面的Codable坑点分析里详细介绍，并提供解决方案

协议

当结构体遵循自定义协议，同时也遵循Codable协议，就可以成功编解码

protocol LGProtocol {
    var name: String{ get set }
}

struct LGTeacher: LGProtocol, Codable {
    var name: String
    var partTime: Int?
}

let jsonString = """
{
    "name": "Zang",
    "partTime": 20
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()   
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(name: "Zang", partTime: Optional(20))

可以让自定义协议遵循Codable协议，也能成功编解码

protocol LGProtocol: Codable {
    var name: String{ get set }
}

struct LGTeacher: LGProtocol {
    var name: String
    var partTime: Int?
}

let jsonString = """
{
    "name": "Zang",
    "partTime": 20
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(name: "Zang", partTime: Optional(20))
数据和对象存在结构差异

遇到服务端返回数据和客户端对象存在结构差异的情况，可以这样处理：

struct LGTeacher: Decodable{
    let elements: [String]
    
    enum CodingKeys: String, CaseIterable, CodingKey {
        case item0 = "item.0"
        case item1 = "item.1"
        case item2 = "item.2"
        case item3 = "item.3"
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        var element: [String]  = []
        
        for item in CodingKeys.allCases{
            guard container.contains(item) else { break }
            element.append(try container.decode(String.self, forKey: item))
        }
        
        self.elements = element
    }
}

let jsonString = """
{
    "item.3": "Kody",
    "item.0": "Hank",
    "item.2": "Cooci",
    "item.1": "Cat"
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(elements: ["Hank", "Cat", "Cooci", "Kody"])

上述代码，实现init(from decoder: Decoder)方法自定义解析，让CodingKeys遵循CaseIterable协议，使枚举类型具有可遍历的特性。仅需要解码功能，可以只遵循Decodable协议

源码解析
Codable

Codable定义：包含Encodable和Decodable

public typealias Codable = Decodable & Encodable
Decodable

Decodable：解码，用于弱类型数据向自定义类型的转换

public protocol Decodable {
    init(from decoder: Decoder) throws
}
Decoder

init方法内的Decoder也是一个协议，它提供了如何解码数据类型的协议，定义如下：

public protocol Decoder {
    var codingPath: [CodingKey] { get }
    var userInfo: [CodingUserInfoKey : Any] { get }
    func container(keyedBy type: Key.Type) throws -> KeyedDecodingContainer where Key : CodingKey
    func unkeyedContainer() throws -> UnkeyedDecodingContainer
    func singleValueContainer() throws -> SingleValueDecodingContainer
}
JSONDecoder

Decoder提供了一个解码器JSONDecoder，定义如下：

open class JSONDecoder {
    public enum DateDecodingStrategy {
        case deferredToDate
        case secondsSince1970
        case millisecondsSince1970

        @available(macOS 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
        case iso8601
        case formatted(DateFormatter)
        case custom((_ decoder: Decoder) throws -> Date)
    }

    public enum DataDecodingStrategy {
        case deferredToData
        case base64
        case custom((_ decoder: Decoder) throws -> Data)
    }

    public enum NonConformingFloatDecodingStrategy {
        case `throw`
        case convertFromString(positiveInfinity: String, negativeInfinity: String, nan: String)
    }
    
    public enum KeyDecodingStrategy {
        case useDefaultKeys
        case convertFromSnakeCase
        case custom((_ codingPath: [CodingKey]) -> CodingKey)
        
        fileprivate static func _convertFromSnakeCase(_ stringKey: String) -> String {
            guard !stringKey.isEmpty else { return stringKey }

            guard let firstNonUnderscore = stringKey.firstIndex(where: { $0 != "_" }) else {
                return stringKey
            }

            var lastNonUnderscore = stringKey.index(before: stringKey.endIndex)
            while lastNonUnderscore > firstNonUnderscore && stringKey[lastNonUnderscore] == "_" {
                stringKey.formIndex(before: &lastNonUnderscore)
            }
            
            let keyRange = firstNonUnderscore...lastNonUnderscore
            let leadingUnderscoreRange = stringKey.startIndex..(_ 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)

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

JSONDecoder类定义了DateDecodingStrategy枚举类型，使用何种策略解析日期格式，案例如下：

struct LGTeacher: Codable {
    var date: Date
}

deferredToDate：默认策略

let jsonString = """
{
    "date": 1609183207
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()
    jsonDecoder.dateDecodingStrategy = .deferredToDate
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(date: 2051-12-29 19:20:07 +0000)

secondsSince1970：距离1970.01.01的秒数

let jsonString = """
{
    "date": 1609183207
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()
    jsonDecoder.dateDecodingStrategy = .secondsSince1970
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(date: 2020-12-28 19:20:07 +0000)

millisecondsSince1970：距离1970.01.01的毫秒数

let jsonString = """
{
    "date": 1609183207000
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()
    jsonDecoder.dateDecodingStrategy = .millisecondsSince1970
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(date: 2020-12-28 19:20:07 +0000)

iso8601：解码为ISO-8601格式（RFC 3339格式）

let jsonString = """
{
    "date": "1969-09-26T12:00:00Z"
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()
    jsonDecoder.dateDecodingStrategy = .iso8601
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(date: 1969-09-26 12:00:00 +0000)

formatted：后台自定义的格式，使用DateFormatter解析

let jsonString = """
{
    "date": "2020/12/28 19:20:00"
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()
    
    let formatter = DateFormatter()
    formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
    jsonDecoder.dateDecodingStrategy = .formatted(formatter)
    
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(date: 2020-12-28 11:20:00 +0000)

custom：自定义格式，通过闭包表达式返回Date类型

let jsonString = """
{
    "date": "2020/12/28 19:20:00"
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData {
    let jsonDecoder = JSONDecoder()

    jsonDecoder.dateDecodingStrategy = .custom(){decoder -> Date in

        let container = try decoder.singleValueContainer()
        let strDate = try container.decode(String.self)
        
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
        
        guard let date = formatter.date(from: strDate) else {
            return Date()
        }
        
        return date
    }
    
    let t = try jsonDecoder.decode(LGTeacher.self, from: data)
    print(t)
}

//输出以下内容：
//LGTeacher(date: 2020-12-28 11:20:00 +0000)
DataDecodingStrategy

DataDecodingStrategy：二进制解码策略

  • deferredToData：默认解码策略
  • base64：使用base64解码
  • custom：自定义方式解码
NonConformingFloatDecodingStrategy

NonConformingFloatDecodingStrategy：不合法浮点数的编码策略

  • throw
  • convertFromString
KeyDecodingStrategy

KeyDecodingStrategy：Key的编码策略

  • useDefaultKeys
  • convertFromSnakeCase
  • custom
decode

decode方法用于将JSON转为指定类型，接收T.Type类型和Data数据

open func decode(_ 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)

    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
}
  • 入参的泛型T必须遵循Decodable协议
  • 使用JSONSerialization将data数据序列化为字典的KeyValue
  • 调用内部类_JSONDecoder传入字典和编码策略返回decoder对象
  • 通过decoder对象的unbox方法解码并返回value
解码流程
_JSONDecoder

_JSONDecoder是用来解码操作的内部类，它遵循了Decoder协议

fileprivate class _JSONDecoder : Decoder {

    fileprivate var storage: _JSONDecodingStorage

    fileprivate let options: JSONDecoder._Options

    fileprivate(set) public var codingPath: [CodingKey]

    public var userInfo: [CodingUserInfoKey : Any] {
        return self.options.userInfo
    }

    fileprivate init(referencing container: Any, at codingPath: [CodingKey] = [], options: JSONDecoder._Options) {
        self.storage = _JSONDecodingStorage()
        self.storage.push(container: container)
        self.codingPath = codingPath
        self.options = options
    }

    public func container(keyedBy type: Key.Type) throws -> KeyedDecodingContainer {
        guard !(self.storage.topContainer is NSNull) else {
            throw DecodingError.valueNotFound(KeyedDecodingContainer.self,
                                              DecodingError.Context(codingPath: self.codingPath,
                                                                    debugDescription: "Cannot get keyed decoding container -- found null value instead."))
        }

        guard let topContainer = self.storage.topContainer as? [String : Any] else {
            throw DecodingError._typeMismatch(at: self.codingPath, expectation: [String : Any].self, reality: self.storage.topContainer)
        }

        let container = _JSONKeyedDecodingContainer(referencing: self, wrapping: topContainer)
        return KeyedDecodingContainer(container)
    }

    public func unkeyedContainer() throws -> UnkeyedDecodingContainer {
        guard !(self.storage.topContainer is NSNull) else {
            throw DecodingError.valueNotFound(UnkeyedDecodingContainer.self,
                                              DecodingError.Context(codingPath: self.codingPath,
                                                                    debugDescription: "Cannot get unkeyed decoding container -- found null value instead."))
        }

        guard let topContainer = self.storage.topContainer as? [Any] else {
            throw DecodingError._typeMismatch(at: self.codingPath, expectation: [Any].self, reality: self.storage.topContainer)
        }

        return _JSONUnkeyedDecodingContainer(referencing: self, wrapping: topContainer)
    }

    public func singleValueContainer() throws -> SingleValueDecodingContainer {
        return self
    }
}

init方法，有三个参数传入

  • container：序列化后的KeyValue
  • codingPath：CodingKey类型的空数组
  • options：编码策略
fileprivate init(referencing container: Any, at codingPath: [CodingKey] = [], options: JSONDecoder._Options) {
    self.storage = _JSONDecodingStorage()
    self.storage.push(container: container)
    self.codingPath = codingPath
    self.options = options
}
  • 创建内部类_JSONDecodingStorage
  • 使用push方法存储要解码的数据

_JSONDecodingStorage是一个结构体，内部有Any类型数组可存放任意类型，提供push、popContainer等方法，相当于一个容器

fileprivate struct _JSONDecodingStorage {
    private(set) fileprivate var containers: [Any] = []

    fileprivate init() {}

    fileprivate var count: Int {
        return self.containers.count
    }

    fileprivate var topContainer: Any {
        precondition(!self.containers.isEmpty, "Empty container stack.")
        return self.containers.last!
    }

    fileprivate mutating func push(container: Any) {
        self.containers.append(container)
    }

    fileprivate mutating func popContainer() {
        precondition(!self.containers.isEmpty, "Empty container stack.")
        self.containers.removeLast()
    }
}

unbox方法用于解码操作，匹配对应的类型然后执行条件分支

fileprivate func unbox(_ value: Any, as type: T.Type) throws -> T? {
    return try unbox_(value, as: type) as? T
}

fileprivate func unbox_(_ value: Any, as type: Decodable.Type) throws -> Any? {
    #if DEPLOYMENT_RUNTIME_SWIFT

    if type == Date.self {
        guard let date = try self.unbox(value, as: Date.self) else { return nil }
        return date
    } else if type == Data.self {
        guard let data = try self.unbox(value, as: Data.self) else { return nil }
        return data
    } else if type == URL.self {
        guard let urlString = try self.unbox(value, as: String.self) else {
            return nil
        }

        guard let url = URL(string: urlString) else {
            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: self.codingPath,
                                                                    debugDescription: "Invalid URL string."))
        }
        return url
    } else if type == Decimal.self {
        guard let decimal = try self.unbox(value, as: Decimal.self) else { return nil }
        return decimal
    } else if let stringKeyedDictType = type as? _JSONStringDictionaryDecodableMarker.Type {
        return try self.unbox(value, as: stringKeyedDictType)
    } else {
        self.storage.push(container: value)
        defer { self.storage.popContainer() }
        return try type.init(from: self)
    }
    #else
    if type == Date.self || type == NSDate.self {
        return try self.unbox(value, as: Date.self)
    } else if type == Data.self || type == NSData.self {
        return try self.unbox(value, as: Data.self)
    } else if type == URL.self || type == NSURL.self {
        guard let urlString = try self.unbox(value, as: String.self) else {
            return nil
        }
        
        guard let url = URL(string: urlString) else {
            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: self.codingPath,
                                                                    debugDescription: "Invalid URL string."))
        }
        
        return url
    } else if type == Decimal.self || type == NSDecimalNumber.self {
        return try self.unbox(value, as: Decimal.self)
    } else if let stringKeyedDictType = type as? _JSONStringDictionaryDecodableMarker.Type {
        return try self.unbox(value, as: stringKeyedDictType)
    } else {
        self.storage.push(container: value)
        defer { self.storage.popContainer() }
        return try type.init(from: self)
    }
    #endif
}

例如：针对Date类型的解码，内部会根据不同编码策略，执行不同的代码分支

fileprivate func unbox(_ value: Any, as type: Date.Type) throws -> Date? {
    guard !(value is NSNull) else { return nil }

    switch self.options.dateDecodingStrategy {
    case .deferredToDate:
        self.storage.push(container: value)
        defer { self.storage.popContainer() }
        return try Date(from: self)

    case .secondsSince1970:
        let double = try self.unbox(value, as: Double.self)!
        return Date(timeIntervalSince1970: double)

    case .millisecondsSince1970:
        let double = try self.unbox(value, as: Double.self)!
        return Date(timeIntervalSince1970: double / 1000.0)

    case .iso8601:
        if #available(macOS 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *) {
            let string = try self.unbox(value, as: String.self)!
            guard let date = _iso8601Formatter.date(from: string) else {
                throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: self.codingPath, debugDescription: "Expected date string to be ISO8601-formatted."))
            }

            return date
        } else {
            fatalError("ISO8601DateFormatter is unavailable on this platform.")
        }

    case .formatted(let formatter):
        let string = try self.unbox(value, as: String.self)!
        guard let date = formatter.date(from: string) else {
            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: self.codingPath, debugDescription: "Date string does not match format expected by formatter."))
        }

        return date

    case .custom(let closure):
        self.storage.push(container: value)
        defer { self.storage.popContainer() }
        return try closure(self)
    }
}

unbox方法内有一个代码分支，针对_JSONStringDictionaryDecodableMarker类型进行解码

else if let stringKeyedDictType = type as? _JSONStringDictionaryDecodableMarker.Type {
    return try self.unbox(value, as: stringKeyedDictType)
}

查看_JSONStringDictionaryDecodableMarker的定义

fileprivate protocol _JSONStringDictionaryEncodableMarker { }

extension Dictionary : _JSONStringDictionaryEncodableMarker where Key == String, Value: Encodable { }

fileprivate protocol _JSONStringDictionaryDecodableMarker {
    static var elementType: Decodable.Type { get }
}

extension Dictionary : _JSONStringDictionaryDecodableMarker where Key == String, Value: Decodable {
    static var elementType: Decodable.Type { return Value.self }
}

_JSONStringDictionaryEncodableMarker是一个协议，并且字典扩展遵循了这个协议，有两个限制条件

  • Key必须为String类型
  • Value必须遵循Decodable协议

查看针对_JSONStringDictionaryDecodableMarker类型的解码方法

fileprivate func unbox(_ value: Any, as type: _JSONStringDictionaryDecodableMarker.Type) throws -> T? {
    guard !(value is NSNull) else { return nil }

    var result = [String : Any]()
    guard let dict = value as? NSDictionary else {
        throw DecodingError._typeMismatch(at: self.codingPath, expectation: type, reality: value)
    }
    let elementType = type.elementType
    for (key, value) in dict {
        let key = key as! String
        self.codingPath.append(_JSONKey(stringValue: key, intValue: nil))
        defer { self.codingPath.removeLast() }

        result[key] = try unbox_(value, as: elementType)
    }

    return result as? T
}

对于_JSONStringDictionaryDecodableMarker类型的解码过程，其实就是一个递归操作

分析SIL代码
struct LGTeacher: Codable{
    var name: String
    var age: Int
}

let jsonString = """
{
    "age": 18,
    "name": "Zang",
}
"""

let jsonData = jsonString.data(using: .utf8)
let jsonDecoder = JSONDecoder()
let t = try? jsonDecoder.decode(LGTeacher.self, from: jsonData!)

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

struct LGTeacher : Decodable & Encodable {
  @_hasStorage var name: String { get set }
  @_hasStorage var age: Int { get set }
  init(name: String, age: Int)
  enum CodingKeys : CodingKey {
    case name
    case age
    @_implements(Equatable, ==(_:_:)) static func __derived_enum_equals(_ a: LGTeacher.CodingKeys, _ b: LGTeacher.CodingKeys) -> Bool
    var hashValue: Int { get }
    func hash(into hasher: inout Hasher)
    var stringValue: String { get }
    init?(stringValue: String)
    var intValue: Int? { get }
    init?(intValue: Int)
  }
  init(from decoder: Decoder) throws
  func encode(to encoder: Encoder) throws
}
  • 编译器自动实现CodingKeys枚举类型，并遵循CodingKey协议。解码过程中会通过CodingKeys找到对应case
  • 编译器自动实现decode解码方法：init(from decoder: Decoder)
  • 编译器自动实现encode编码方法：encode(to encoder: Encoder)

源码中type.init(from:)方法，传入的self，本质是_JSONDecoder

return try type.init(from: self)

查看源码中type.init(from:)方法的SIL代码实现：

// LGTeacher.init(from:)
sil hidden @main.LGTeacher.init(from: Swift.Decoder) throws -> main.LGTeacher : $@convention(method) (@in Decoder, @thin LGTeacher.Type) -> (@owned LGTeacher, @error Error) {
// %0 "decoder"                                   // users: %69, %49, %9, %6
// %1 "$metatype"
bb0(%0 : $*Decoder, %1 : $@thin LGTeacher.Type):
  %2 = alloc_stack $Builtin.Int2                  // users: %70, %27, %5, %78, %52
  %3 = alloc_stack [dynamic_lifetime] $LGTeacher, var, name "self" // users: %40, %24, %50, %73, %77, %51
  %4 = integer_literal $Builtin.Int2, 0           // user: %5
  store %4 to %2 : $*Builtin.Int2                 // id: %5
  debug_value_addr %0 : $*Decoder, let, name "decoder", argno 1 // id: %6
  debug_value undef : $Error, var, name "$error", argno 2 // id: %7
  %8 = alloc_stack $KeyedDecodingContainer, let, name "container" // users: %45, %44, %37, %66, %65, %21, %60, %59, %13, %55
  %9 = open_existential_addr immutable_access %0 : $*Decoder to $*@opened("2D27860A-6118-11EB-ACCF-34363BD04690") Decoder // users: %13, %13, %12
  %10 = metatype $@thin LGTeacher.CodingKeys.Type
  %11 = metatype $@thick LGTeacher.CodingKeys.Type // user: %13
  %12 = witness_method $@opened("2D27860A-6118-11EB-ACCF-34363BD04690") Decoder, #Decoder.container :  (Self) -> (Key.Type) throws -> KeyedDecodingContainer, %9 : $*@opened("2D27860A-6118-11EB-ACCF-34363BD04690") Decoder : $@convention(witness_method: Decoder) <τ_0_0 where τ_0_0 : Decoder><τ_1_0 where τ_1_0 : CodingKey> (@thick τ_1_0.Type, @in_guaranteed τ_0_0) -> (@out KeyedDecodingContainer<τ_1_0>, @error Error) // type-defs: %9; user: %13
  try_apply %12<@opened("2D27860A-6118-11EB-ACCF-34363BD04690") Decoder, LGTeacher.CodingKeys>(%8, %11, %9) : $@convention(witness_method: Decoder) <τ_0_0 where τ_0_0 : Decoder><τ_1_0 where τ_1_0 : CodingKey> (@thick τ_1_0.Type, @in_guaranteed τ_0_0) -> (@out KeyedDecodingContainer<τ_1_0>, @error Error), normal bb1, error bb4 // type-defs: %9; id: %13
  • 创建$KeyedDecodingContainer的临时常量container
  • 在PWT协议目击表中找到container方法并调用

源码中可以看到_JSONDecoder确实遵循了Decoder协议

_JSONDecoder

Decoder协议中存在container方法的声明

Decoder

查看源码中_JSONDecoder的container方法，返回KeyedDecodingContainer

public func container(keyedBy type: Key.Type) throws -> KeyedDecodingContainer {
    guard !(self.storage.topContainer is NSNull) else {
        throw DecodingError.valueNotFound(KeyedDecodingContainer.self,
                                          DecodingError.Context(codingPath: self.codingPath,
                                                                debugDescription: "Cannot get keyed decoding container -- found null value instead."))
    }

    guard let topContainer = self.storage.topContainer as? [String : Any] else {
        throw DecodingError._typeMismatch(at: self.codingPath, expectation: [String : Any].self, reality: self.storage.topContainer)
    }

    let container = _JSONKeyedDecodingContainer(referencing: self, wrapping: topContainer)
    return KeyedDecodingContainer(container)
}

KeyedDecodingContainer是一个结构体，遵循KeyedDecodingContainerProtocol协议。有一个条件限制，K必须遵循CodingKey协议。结构体内定义各种类型的解码方法，会根据不同类型匹配到对应的decode方法

public struct KeyedDecodingContainer : KeyedDecodingContainerProtocol where K : CodingKey {
    public typealias Key = K
    public init(_ container: Container) where K == Container.Key, Container : KeyedDecodingContainerProtocol
    public var codingPath: [CodingKey] { get }
    public var allKeys: [KeyedDecodingContainer.Key] { get }
    public func contains(_ key: KeyedDecodingContainer.Key) -> Bool
    public func decodeNil(forKey key: KeyedDecodingContainer.Key) throws -> Bool
    public func decode(_ type: Bool.Type, forKey key: KeyedDecodingContainer.Key) throws -> Bool
    public func decode(_ type: String.Type, forKey key: KeyedDecodingContainer.Key) throws -> String
    public func decode(_ type: Double.Type, forKey key: KeyedDecodingContainer.Key) throws -> Double
    public func decode(_ type: Float.Type, forKey key: KeyedDecodingContainer.Key) throws -> Float
    public func decode(_ type: Int.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int
    public func decode(_ type: Int8.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int8
    public func decode(_ type: Int16.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int16
    public func decode(_ type: Int32.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int32
    public func decode(_ type: Int64.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int64
    public func decode(_ type: UInt.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt
    public func decode(_ type: UInt8.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt8
    public func decode(_ type: UInt16.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt16
    public func decode(_ type: UInt32.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt32
    public func decode(_ type: UInt64.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt64
    public func decode(_ type: T.Type, forKey key: KeyedDecodingContainer.Key) throws -> T where T : Decodable
    public func decodeIfPresent(_ type: Bool.Type, forKey key: KeyedDecodingContainer.Key) throws -> Bool?
    public func decodeIfPresent(_ type: String.Type, forKey key: KeyedDecodingContainer.Key) throws -> String?
    public func decodeIfPresent(_ type: Double.Type, forKey key: KeyedDecodingContainer.Key) throws -> Double?
    public func decodeIfPresent(_ type: Float.Type, forKey key: KeyedDecodingContainer.Key) throws -> Float?
    public func decodeIfPresent(_ type: Int.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int?
    public func decodeIfPresent(_ type: Int8.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int8?
    public func decodeIfPresent(_ type: Int16.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int16?
    public func decodeIfPresent(_ type: Int32.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int32?
    public func decodeIfPresent(_ type: Int64.Type, forKey key: KeyedDecodingContainer.Key) throws -> Int64?
    public func decodeIfPresent(_ type: UInt.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt?
    public func decodeIfPresent(_ type: UInt8.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt8?
    public func decodeIfPresent(_ type: UInt16.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt16?
    public func decodeIfPresent(_ type: UInt32.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt32?
    public func decodeIfPresent(_ type: UInt64.Type, forKey key: KeyedDecodingContainer.Key) throws -> UInt64?
    public func decodeIfPresent(_ type: T.Type, forKey key: KeyedDecodingContainer.Key) throws -> T? where T : Decodable
    public func nestedContainer(keyedBy type: NestedKey.Type, forKey key: KeyedDecodingContainer.Key) throws -> KeyedDecodingContainer where NestedKey : CodingKey
    public func nestedUnkeyedContainer(forKey key: KeyedDecodingContainer.Key) throws -> UnkeyedDecodingContainer
    public func superDecoder() throws -> Decoder
    public func superDecoder(forKey key: KeyedDecodingContainer.Key) throws -> Decoder
    public func decodeIfPresent(_ type: Bool.Type, forKey key: K) throws -> Bool?
    public func decodeIfPresent(_ type: String.Type, forKey key: K) throws -> String?
    public func decodeIfPresent(_ type: Double.Type, forKey key: K) throws -> Double?
    public func decodeIfPresent(_ type: Float.Type, forKey key: K) throws -> Float?
    public func decodeIfPresent(_ type: Int.Type, forKey key: K) throws -> Int?
    public func decodeIfPresent(_ type: Int8.Type, forKey key: K) throws -> Int8?
    public func decodeIfPresent(_ type: Int16.Type, forKey key: K) throws -> Int16?
    public func decodeIfPresent(_ type: Int32.Type, forKey key: K) throws -> Int32?
    public func decodeIfPresent(_ type: Int64.Type, forKey key: K) throws -> Int64?
    public func decodeIfPresent(_ type: UInt.Type, forKey key: K) throws -> UInt?
    public func decodeIfPresent(_ type: UInt8.Type, forKey key: K) throws -> UInt8?
    public func decodeIfPresent(_ type: UInt16.Type, forKey key: K) throws -> UInt16?
    public func decodeIfPresent(_ type: UInt32.Type, forKey key: K) throws -> UInt32?
    public func decodeIfPresent(_ type: UInt64.Type, forKey key: K) throws -> UInt64?
    public func decodeIfPresent(_ type: T.Type, forKey key: K) throws -> T? where T : Decodable
}

上述代码，结构体中定义了很多类型的decode方法，这些方法由苹果内部工具生成，利用Codable.swift.gyb模板文件生成Codable.swift源文件

Codable.swift.gyb模板文件：

定义集合存放所有可编解码的内嵌类型。以%开始和结束，视为代码的开始和结束，通过python控制，相当于模板文件

没有以%开始和结束，视为文本直接输出

同样是模板文件，遍历集合里的内嵌类型，${type}输出对应类型的文本，例如Bool、Int32

当自己实现init(from decoder: Decoder)方法时，其中decode和CodingKeys都由系统自动生成

let jsonString = """
{
    "name": "Zang",
    "age": 18,
}
"""

struct LGTeacher: Codable{
    var name: String
    var age: Int
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.name = try container.decode(String.self, forKey: .name)
        self.age = try container.decode(Int.self, forKey: .age)
    }
}

也可以重新定义CodingKeys来解决数据和对象存在结构差异的情况

let jsonString = """
{
    "Nickname": "Zang",
    "age": 18,
}
"""

struct LGTeacher: Codable{
    var name: String
    var age: Int
    
    enum CodingKeys: String, CodingKey {
        case name = "Nickname"
        case age
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.name = try container.decode(String.self, forKey: .name)
        self.age = try container.decode(Int.self, forKey: .age)
    }
}
Encodable

Encodable：编码，用于自定义类型向弱类型数据的转换

public protocol Encodable {
    func encode(to encoder: Encoder) throws
}
encode

encode方法，接收泛型T，泛型必须遵循Encodable协议，返回Data数据

open func encode(_ value: T) throws -> Data {
    let encoder = _JSONEncoder(options: self.options)

    guard let topLevel = try encoder.box_(value) else {
        throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: [], debugDescription: "Top-level \(T.self) did not encode any values."))
    }

    let writingOptions = JSONSerialization.WritingOptions(rawValue: self.outputFormatting.rawValue).union(.fragmentsAllowed)

    do {
        return try JSONSerialization.data(withJSONObject: topLevel, options: writingOptions)
    } catch {
        throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: [], debugDescription: "Unable to encode the given top-level value to JSON.", underlyingError: error))
    }
}
  • 创建内部类_JSONEncoder
  • 调用box_方法包装成字典类型
  • 使用JSONSerialization序列化为Data数据
_JSONEncoder

_JSONEncoder类遵循Encoder协议，主要提供container编码方法，返回KeyedEncodingContainer

fileprivate class _JSONEncoder : Encoder {
    fileprivate var storage: _JSONEncodingStorage

    fileprivate let options: JSONEncoder._Options

    public var codingPath: [CodingKey]

    public var userInfo: [CodingUserInfoKey : Any] {
        return self.options.userInfo
    }

    fileprivate init(options: JSONEncoder._Options, codingPath: [CodingKey] = []) {
        self.options = options
        self.storage = _JSONEncodingStorage()
        self.codingPath = codingPath
    }

    fileprivate var canEncodeNewValue: Bool {
        return self.storage.count == self.codingPath.count
    }

    public func container(keyedBy: Key.Type) -> KeyedEncodingContainer {
        let topContainer: NSMutableDictionary
        if self.canEncodeNewValue {
            topContainer = self.storage.pushKeyedContainer()
        } else {
            guard let container = self.storage.containers.last as? NSMutableDictionary else {
                preconditionFailure("Attempt to push new keyed encoding container when already previously encoded at this path.")
            }

            topContainer = container
        }

        let container = _JSONKeyedEncodingContainer(referencing: self, codingPath: self.codingPath, wrapping: topContainer)
        return KeyedEncodingContainer(container)
    }

    public func unkeyedContainer() -> UnkeyedEncodingContainer {
        let topContainer: NSMutableArray
        if self.canEncodeNewValue {
            topContainer = self.storage.pushUnkeyedContainer()
        } else {
            guard let container = self.storage.containers.last as? NSMutableArray else {
                preconditionFailure("Attempt to push new unkeyed encoding container when already previously encoded at this path.")
            }

            topContainer = container
        }

        return _JSONUnkeyedEncodingContainer(referencing: self, codingPath: self.codingPath, wrapping: topContainer)
    }

    public func singleValueContainer() -> SingleValueEncodingContainer {
        return self
    }
}

KeyedEncodingContainer结构体，遵循KeyedEncodingContainerProtocol协议，要求K必须遵循CodingKey协议，内部定义了各种类型对应的encode方法

public struct KeyedEncodingContainer : KeyedEncodingContainerProtocol where K : CodingKey {
    public typealias Key = K
    public init(_ container: Container) where K == Container.Key, Container : KeyedEncodingContainerProtocol
    public var codingPath: [CodingKey] { get }
    public mutating func encodeNil(forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Bool, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: String, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Double, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Float, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Int, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Int8, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Int16, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Int32, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: Int64, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: UInt, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: UInt8, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: UInt16, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: UInt32, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: UInt64, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encode(_ value: T, forKey key: KeyedEncodingContainer.Key) throws where T : Encodable
    public mutating func encodeConditional(_ object: T, forKey key: KeyedEncodingContainer.Key) throws where T : AnyObject, T : Encodable
    public mutating func encodeIfPresent(_ value: Bool?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: String?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Double?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Float?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Int?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Int8?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Int16?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Int32?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: Int64?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: UInt?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: UInt8?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: UInt16?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: UInt32?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: UInt64?, forKey key: KeyedEncodingContainer.Key) throws
    public mutating func encodeIfPresent(_ value: T?, forKey key: KeyedEncodingContainer.Key) throws where T : Encodable
    public mutating func nestedContainer(keyedBy keyType: NestedKey.Type, forKey key: KeyedEncodingContainer.Key) -> KeyedEncodingContainer where NestedKey : CodingKey
    public mutating func nestedUnkeyedContainer(forKey key: KeyedEncodingContainer.Key) -> UnkeyedEncodingContainer
    public mutating func superEncoder() -> Encoder
    public mutating func superEncoder(forKey key: KeyedEncodingContainer.Key) -> Encoder
    public mutating func encodeConditional(_ object: T, forKey key: K) throws where T : AnyObject, T : Encodable
    public mutating func encodeIfPresent(_ value: Bool?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: String?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Double?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Float?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Int?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Int8?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Int16?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Int32?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: Int64?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: UInt?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: UInt8?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: UInt16?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: UInt32?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: UInt64?, forKey key: K) throws
    public mutating func encodeIfPresent(_ value: T?, forKey key: K) throws where T : Encodable
}
box_

box_方法，根据value的不同类型，调用不同的代码分支，将value包装成对应的数据类型

fileprivate func box_(_ value: Encodable) throws -> NSObject? {
    let type = Swift.type(of: value)
    #if DEPLOYMENT_RUNTIME_SWIFT
    if type == Date.self {
        // Respect Date encoding strategy
        return try self.box((value as! Date))
    } else if type == Data.self {
        // Respect Data encoding strategy
        return try self.box((value as! Data))
    } else if type == URL.self {
        // Encode URLs as single strings.
        return self.box((value as! URL).absoluteString)
    } else if type == Decimal.self {
        // JSONSerialization can consume NSDecimalNumber values.
        return NSDecimalNumber(decimal: value as! Decimal)
    } else if value is _JSONStringDictionaryEncodableMarker {
        return try box(value as! [String : Encodable])
    }
    
    #else
    if type == Date.self || type == NSDate.self {
        // Respect Date encoding strategy
        return try self.box((value as! Date))
    } else if type == Data.self || type == NSData.self {
        // Respect Data encoding strategy
        return try self.box((value as! Data))
    } else if type == URL.self || type == NSURL.self {
        // Encode URLs as single strings.
        return self.box((value as! URL).absoluteString)
    } else if type == Decimal.self {
        // JSONSerialization can consume NSDecimalNumber values.
        return NSDecimalNumber(decimal: value as! Decimal)
    } else if value is _JSONStringDictionaryEncodableMarker {
        return try box(value as! [String : Encodable])
    }
    #endif
    
    // The value should request a container from the _JSONEncoder.
    let depth = self.storage.count
    do {
        try value.encode(to: self)
    } catch {
        // If the value pushed a container before throwing, pop it back off to restore state.
        if self.storage.count > depth {
            let _ = self.storage.popContainer()
        }
        throw error
    }
    
    // The top container should be a new container.
    guard self.storage.count > depth else {
        return nil
    }

    return self.storage.popContainer()
}

上述代码，如果value不是上述定义的数据类型，例如LGTeacher，最终会调用value.encode(to: self)方法，传入的self就是_JSONEncoder

box_方法内有一个代码分支，针对_JSONStringDictionaryEncodableMarker类型进行编码

else if value is _JSONStringDictionaryEncodableMarker {
    return try box(value as! [String : Encodable])
}

查看_JSONStringDictionaryEncodableMarker的定义

fileprivate protocol _JSONStringDictionaryEncodableMarker { }

extension Dictionary : _JSONStringDictionaryEncodableMarker where Key == String, Value: Encodable { }

fileprivate protocol _JSONStringDictionaryDecodableMarker {
    static var elementType: Decodable.Type { get }
}

extension Dictionary : _JSONStringDictionaryDecodableMarker where Key == String, Value: Decodable {
    static var elementType: Decodable.Type { return Value.self }
}

_JSONStringDictionaryEncodableMarker是一个协议，并且字典扩展遵循了这个协议，有两个限制条件

  • Key必须为String类型
  • Value必须遵循Encodable协议

查看针对_JSONStringDictionaryEncodableMarker类型的编码方法

fileprivate func box(_ dict: [String : Encodable]) throws -> NSObject? {
    let depth = self.storage.count
    let result = self.storage.pushKeyedContainer()
    do {
        for (key, value) in dict {
            self.codingPath.append(_JSONKey(stringValue: key, intValue: nil))
            defer { self.codingPath.removeLast() }
            result[key] = try box(value)
        }
    } catch {
        // If the value pushed a container before throwing, pop it back off to restore state.
        if self.storage.count > depth {
            let _ = self.storage.popContainer()
        }

        throw error
    }

    // The top container should be a new container.
    guard self.storage.count > depth else {
        return nil
    }

    return self.storage.popContainer()
}

对于_JSONStringDictionaryEncodableMarker类型的编码过程，通过遍历将key打包为String类型，将value打包成相应的数据类型，最终返回最后一个元素

整体encode编码流程，相当于跟decode解码流程是完全相反的逆过程

编码流程

Codable坑点分析

通过继承的案例，进行Codable的坑点分析

class LGPerson: Codable {
    var name: String?
    var age: Int?
}

class LGTeacher: LGPerson {
    var subjectName: String?
}

let t = LGTeacher()
t.age = 10
t.name = "Zang"
t.subjectName = "Swift"

let jsonEncoder = JSONEncoder()
let jsonData = try? jsonEncoder.encode(t)

if let data = jsonData{
    let jsonString = String(data: data, encoding: .utf8)
    print(jsonString ?? "解析失败")
}

//输出以下结果：
//{"name":"Zang","age":10}

上述代码，仅能编码出age和name属性，但subjectName属性无法正常编码

原因：

  • 父类LGPerson遵循了Codable协议，所以系统针对LGPerson自动生成了encode(to encoder: Encoder)方法
  • 子类LGTeacher虽然继承自LGPerson，但并没有重写encode(to encoder: Encoder)方法
  • 所以在编码过程中，找到的依然是父类的encode方法，最终仅父类属性可以被成功编码

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

class LGPerson : Decodable & Encodable {
  @_hasStorage @_hasInitialValue var name: String? { get set }
  @_hasStorage @_hasInitialValue var age: Int? { get set }
  @objc deinit
  init()
  enum CodingKeys : CodingKey {
    case name
    case age
    @_implements(Equatable, ==(_:_:)) static func __derived_enum_equals(_ a: LGPerson.CodingKeys, _ b: LGPerson.CodingKeys) -> Bool
    var hashValue: Int { get }
    func hash(into hasher: inout Hasher)
    var stringValue: String { get }
    init?(stringValue: String)
    var intValue: Int? { get }
    init?(intValue: Int)
  }
  required init(from decoder: Decoder) throws
  func encode(to encoder: Encoder) throws
}

针对LGPerson，系统自动生成了CodingKeys和encode(to encoder: Encoder)方法

@_inheritsConvenienceInitializers class LGTeacher : LGPerson {
  @_hasStorage @_hasInitialValue var subjectName: String? { get set }
  @objc deinit
  override init()
  required init(from decoder: Decoder) throws
}

但对于LGTeacher，仅存在init(from decoder: Decoder)方法

可以通过重写子类的encode(to encoder: Encoder)方法解决

class LGPerson: Codable {
    var name: String?
    var age: Int?
}

class LGTeacher: LGPerson {
    var subjectName: String?
    
    enum CodingKeys: String,CodingKey {
        case subjectName
    }
    
    override func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(subjectName, forKey: .subjectName)
        try super.encode(to: encoder)
    }
}

let t = LGTeacher()
t.age = 10
t.name = "Zang"
t.subjectName = "Swift"

let jsonEncoder = JSONEncoder()
let jsonData = try? jsonEncoder.encode(t)

if let data = jsonData{
    let jsonString = String(data: data, encoding: .utf8)
    print(jsonString ?? "解析失败")
}

//输出以下结果：
//{"subjectName":"Swift","name":"Zang","age":10}

如果在super.encode方法中，使用container.superEncoder()，在编码后的JSON数据里也会增加super节点，这里不推荐使用

override func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(subjectName, forKey: .subjectName)
    try super.encode(to: container.superEncoder())
}

//输出以下结果：
//{"subjectName":"Swift","super":{"name":"Zang","age":10}}

修改案例，如果将LGTeacher进行解码操作，能否正常解析所有属性？

class LGPerson: Codable {
    var name: String?
    var age: Int?
}

class LGTeacher: LGPerson {
    var subjectName: String?
}

let jsonString = """
{
    "name": "Zang",
    "age": 18,
    "subjectName": "Swift",
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode(LGTeacher.self, from: data)
    print("name：\(t?.name)，age：\(t?.age)，subjectName：\(t?.subjectName)")
}

//输出以下内容：
//name：Optional("Zang")，age：Optional(18)，subjectName：nil

仅父类的属性被成功解析，子类的subjectName属性被解析为nil

可以通过重写子类的init(from decoder: Decoder)方法解决

class LGPerson: Codable {
    var name: String?
    var age: Int?
}

class LGTeacher: LGPerson {
    var subjectName: String?

    enum CodingKeys: String, CodingKey{
        case subjectName
    }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.subjectName = try container.decode(String.self, forKey: .subjectName)
        try super.init(from: decoder)
    }
}

let jsonString = """
{
    "name": "Zang",
    "age": 18,
    "subjectName": "Swift",
}
"""

let jsonData = jsonString.data(using: .utf8)

if let data = jsonData{
    let jsonDecoder = JSONDecoder()
    let t = try? jsonDecoder.decode(LGTeacher.self, from: data)
    print("name：\(t?.name)，age：\(t?.age)，subjectName：\(t?.subjectName)")
}

//输出以下内容：
//name：Optional("Zang")，age：Optional(18)，subjectName：Optional("Swift")
多态模式下的编解码问题

当结构体存储自定义协议，即使协议遵循Codable协议，依然编译报错，提示：协议类型不符合Decodable协议，只允许使用struct、enum、class

编译报错

但LGPerson是个协议，无法实现init和encode方法

这时可以考虑使用中间层来解决问题

protocol LGPerson {
    var age: String { get set }
    var name: String { get set }
}

struct LGTeacher: LGPerson {
    var age: String
    var name: String
}

struct LGParTimeTeacher: LGPerson {
    var age: String
    var name: String
}

struct LGPersonBox: LGPerson, Codable {
    
    var age: String
    var name: String

    init(_ person: LGPerson) {
        self.age = person.age
        self.name = person.name
    }
}

struct Company: Codable{
    var person: [LGPersonBox]
    var companyName: String
}

let person: [LGPerson] = [LGTeacher(age: "20", name: "Kody"), LGParTimeTeacher(age: "30", name: "Hank")]
let company = Company(person: person.map(LGPersonBox.init), companyName: "Logic")

let jsonEncoder = JSONEncoder()
jsonEncoder.outputFormatting = .prettyPrinted

let jsonData = try jsonEncoder.encode(company)
if let jsonString = String(data: jsonData, encoding: .utf8) {
    print("编码：\(jsonString)")
}

print("\n--------------------\n")

let jsonDecoder = JSONDecoder()
let c = try? jsonDecoder.decode(Company.self, from: jsonData)
print("解码：\(c)")

//输出以下结果：
//编码：{
//  "companyName" : "Logic",
//  "person" : [
//    {
//      "age" : "20",
//      "name" : "Kody"
//    },
//    {
//      "age" : "30",
//      "name" : "Hank"
//    }
//  ]
//}
//
//--------------------
//
//解码：Optional(LGSwiftTest.Company(person: [LGSwiftTest.LGPersonBox(age: "20", name: "Kody"), LGSwiftTest.LGPersonBox(age: "30", name: "Hank")], companyName: "Logic"))

上述代码，编码和解码都能执行成功，但解码后输出的类型都是LGPersonBox。如果需要保留原始的类型信息，应该怎样处理？

方案1：使用unBox方法还原类型

enum LGPersonType:String, Codable {
    case teacher
    case partTeacher
    
    var metdadata: LGPerson.Type {
        switch self {
            case .teacher:
                return LGTeacher.self
            case .partTeacher:
                return LGParTimeTeacher.self
        }
    }
}

protocol LGPerson {
    var type: LGPersonType { get }
    var age: String { get set }
    var name: String { get set }
}

struct LGTeacher: LGPerson {
    var type: LGPersonType = LGPersonType.teacher
    var age: String
    var name: String

    static func unBox(_ person: LGPerson) -> LGPerson {
        return LGTeacher(age: person.age, name: person.name)
    }
}

struct LGParTimeTeacher: LGPerson {
    var type: LGPersonType = LGPersonType.partTeacher
    var age: String
    var name: String

    static func unBox(_ person: LGPerson) -> LGPerson {
        return LGParTimeTeacher(age: person.age, name: person.name)
    }
}

struct LGPersonBox: LGPerson, Codable {
    var type: LGPersonType
    var age: String
    var name: String

    init(_ person: LGPerson) {
        self.type = person.type
        self.age = person.age
        self.name = person.name
    }
    
    static func unBox(_ person: LGPerson) -> LGPerson {

        if person.type.metdadata == LGTeacher.self {
            return LGTeacher.unBox(person)
        }
        
        return LGParTimeTeacher.unBox(person)
    }
}

struct Company: Codable{
    var person: [LGPersonBox]
    var companyName: String
}

let person: [LGPerson] = [LGTeacher(age: "20", name: "Kody"), LGParTimeTeacher(age: "30", name: "Hank")]
let company = Company(person: person.map(LGPersonBox.init), companyName: "Logic")

let jsonEncoder = JSONEncoder()
jsonEncoder.outputFormatting = .prettyPrinted

let jsonData = try jsonEncoder.encode(company)
if let jsonString = String(data: jsonData, encoding: .utf8) {
    print("编码：\(jsonString)")
}

print("\n--------------------\n")

let jsonDecoder = JSONDecoder()
let c = try? jsonDecoder.decode(Company.self, from: jsonData)
print("解码：\(c?.person.map{ LGPersonBox.unBox($0) })")

//输出以下结果：
//编码：{
//  "companyName" : "Logic",
//  "person" : [
//    {
//      "type" : "teacher",
//      "age" : "20",
//      "name" : "Kody"
//    },
//    {
//      "type" : "partTeacher",
//      "age" : "30",
//      "name" : "Hank"
//    }
//  ]
//}
//
//--------------------
//
//解码：Optional([LGSwiftTest.LGTeacher(type: LGSwiftTest.LGPersonType.teacher, age: "20", name: "Kody"), LGSwiftTest.LGParTimeTeacher(type: LGSwiftTest.LGPersonType.partTeacher, age: "30", name: "Hank")])

方案2：可以在编码过程中将类型信息编码进去

enum LGPersonType:String, Codable {
    case teacher
    case partTeacher
    
    var metdadata: LGPerson.Type {
        switch self {
            case .teacher:
                return LGTeacher.self
            case .partTeacher:
                return LGParTimeTeacher.self
        }
    }
}

protocol LGPerson: Codable{
    static var type: LGPersonType { get }
    var age: Int { get set }
    var name: String { get set }
}

struct LGTeacher: LGPerson {
    static var type: LGPersonType = LGPersonType.teacher
    var age: Int
    var name: String
}

struct LGParTimeTeacher: LGPerson {
    static var type: LGPersonType = LGPersonType.partTeacher
    var age: Int
    var name: String
}

struct LGPersonBox: Codable {

    var p: LGPerson

    init(_ p: LGPerson) {
        self.p = p
    }

    private enum CodingKeys : CodingKey {
        case type
        case p
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let type = try container.decode(LGPersonType.self, forKey: .type)
        self.p = try type.metdadata.init(from: container.superDecoder(forKey: .p))
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(type(of: p).type, forKey: .type)
        try p.encode(to: container.superEncoder(forKey: .p))
    }
}

struct Company: Codable{
    var person: [LGPersonBox]
    var companyName: String
}

let person: [LGPerson] = [LGTeacher(age: 20, name: "Kody"), LGParTimeTeacher(age: 30, name: "Hank")]
let company = Company(person: person.map(LGPersonBox.init), companyName: "Logic")

let jsonEncoder = JSONEncoder()
jsonEncoder.outputFormatting = .prettyPrinted

let jsonData = try jsonEncoder.encode(company)
if let jsonString = String(data: jsonData, encoding: .utf8) {
    print("编码：\(jsonString)")
}

print("\n--------------------\n")

let jsonDecoder = JSONDecoder()
let c = try? jsonDecoder.decode(Company.self, from: jsonData)
print("解码：\(c)")

//输出以下结果：
//编码：{
//  "companyName" : "Logic",
//  "person" : [
//    {
//      "type" : "teacher",
//      "p" : {
//        "age" : 20,
//        "name" : "Kody"
//      }
//    },
//    {
//      "type" : "partTeacher",
//      "p" : {
//        "age" : 30,
//        "name" : "Hank"
//      }
//    }
//  ]
//}
//
//--------------------
//
//解码：Optional(LGSwiftTest.Company(person: [LGSwiftTest.LGPersonBox(p: LGSwiftTest.LGTeacher(age: 20, name: "Kody")), LGSwiftTest.LGPersonBox(p: LGSwiftTest.LGParTimeTeacher(age: 30, name: "Hank"))], companyName: "Logic"))

这里提供另一个实现方式

protocol Meta: Codable {
    associatedtype Element
    static func metatype(for typeString: String) -> Self
    var type: Decodable.Type { get }
}

struct MetaObject: Codable {
    let object: M.Element
    
    init(_ object: M.Element) {
        self.object = object
    }
    
    enum CodingKeys: String, CodingKey {
        case metatype
        case object
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let typeStr = try container.decode(String.self, forKey: .metatype)
        let metatype = M.metatype(for: typeStr)
        
        let superDecoder = try container.superDecoder(forKey: .object)
        let obj = try metatype.type.init(from: superDecoder)
        guard let element = obj as? M.Element else {
            fatalError()
        }
        self.object = element
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        let typeStr = String(describing: type(of: object))
        try container.encode(typeStr, forKey: .metatype)
        
        let superEncoder = container.superEncoder(forKey: .object)
        let encodable = object as? Encodable
        try encodable?.encode(to: superEncoder)
    }
}

enum LGPersonType: String, Meta {
    typealias Element = LGPerson
    case teacher = "LGTeacher"
    case partTimeTeacher = "LGPartTimeTeacher"
    
    static func metatype(for typeString: String) -> LGPersonType {
        guard let metatype = self.init(rawValue: typeString) else {
            fatalError()
        }
        return metatype
    }
    
    var type: Decodable.Type {
        switch self {
            case .teacher:
                return LGTeacher.self
            case .partTimeTeacher:
                return LGPartTimeTeacher.self
        }
    }
}

class LGPerson: Codable {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

class LGTeacher: LGPerson {
    var subjectName: String
    
    init(name: String, age: Int, subjectName: String) {
        self.subjectName = subjectName
        super.init(name: name, age: age)
    }
    
    enum CodingKeys: String, CodingKey {
        case subjectName
    }
    
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        subjectName = try container.decode(String.self, forKey: .subjectName)
        try super.init(from: decoder)
    }
    
    override func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(subjectName, forKey: .subjectName)
        try super.encode(to: encoder)
    }
}

class LGPartTimeTeacher: LGPerson {
    var partTime: Double
    
    init(name: String, age: Int, partTime: Double) {
        self.partTime = partTime
        super.init(name: name, age: age)
    }
    
    enum CodingKeys: String, CodingKey {
        case partTime
    }
    
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        partTime = try container.decode(Double.self, forKey: .partTime)
        try super.init(from: decoder)
    }
    
    override func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(partTime, forKey: .partTime)
        try super.encode(to: encoder)
    }
}

struct Company: Codable{
    private var person: [MetaObject]
    
    init() {
        self.person = []
    }
    
    mutating func add(p: LGPerson) {
        person.append(MetaObject(p as! M.Element))
    }
}


let p1: LGPerson = LGTeacher(name: "Kody", age: 20, subjectName: "Swift")
let p2: LGPerson = LGPartTimeTeacher(name: "Cat", age: 30, partTime: 1.85)
var company: Company = Company()
company.add(p: p1)
company.add(p: p2)

let jsonEncoder = JSONEncoder()
jsonEncoder.outputFormatting = .prettyPrinted

let jsonData = try jsonEncoder.encode(company)
if let jsonString = String(data: jsonData, encoding: .utf8) {
    print("编码：\(jsonString)")
}

print("\n--------------------\n")

let jsonDecoder = JSONDecoder()
let c = try? jsonDecoder.decode(Company.self, from: jsonData)
print("解码：\(c)")

//输出以下结果：
//编码：{
//  "person" : [
//    {
//      "metatype" : "LGTeacher",
//      "object" : {
//        "subjectName" : "Swift",
//        "name" : "Kody",
//        "age" : 20
//      }
//    },
//    {
//      "metatype" : "LGPartTimeTeacher",
//      "object" : {
//        "partTime" : 1.8500000000000001,
//        "name" : "Cat",
//        "age" : 30
//      }
//    }
//  ]
//}
//
//--------------------
//
//解码：Optional(LGSwiftTest.Company(person: [LGSwiftTest.MetaObject(object: LGSwiftTest.LGTeacher), LGSwiftTest.MetaObject(object: LGSwiftTest.LGPartTimeTeacher)]))
和其他编解码类库的对比
  • SwiftyJSON：使用下标的方式取值，很容易数组越界
  • ObjectMapper：手动对每一个对象提供映射关系，代码量很大
  • HandyJSON：使用内存赋值的方式进行编解码操作，原理和Codable殊途同归
  • Codable：遇到继承和多态模式，需要手动实现编解码功能

以上类库相比较而言，HandyJSON和Codable更具优势

你可能感兴趣的:(Swift底层进阶--015：Codable源码解析)

  • iOS面试：runtime如何实现weak变量的自动置nil？ androiios ios面试
    在iOS开发中，weak变量的自动置nil是Objective-C和Swift中内存管理的重要特性。这个特性主要依赖于Objective-C的运行时（runtime）机制。以下是对这个过程的详细解释：1.weak变量的定义weak变量是一种引用类型，它不会增加对象的引用计数。当一个对象的所有强引用（strong）被释放时，weak引用会自动被置为nil。这样可以避免循环引用（retaincycle
  • Pandas库性能优化指南：从基础到进阶（终） 小高要坚强 pandas性能优化python数据分析开发语言
    Pandas是Python中广泛使用的数据处理库，凭借其强大的功能和易用性，深受数据科学家和开发者的青睐。然而，Pandas在处理大规模数据时可能会遇到性能瓶颈，导致执行效率低下。本文将深入探讨如何通过一系列优化技巧，提升Pandas的性能表现，确保代码既高效又保持可读性。一、需要关注的问题在数据处理的过程中，性能往往是一个不可忽视的因素。虽然Pandas提供了丰富的函数和方法以简化数据操作，但在
  • python进阶--python操作excel（3） 太原浪子 Python基础语法excelpython
    一、xlsxwirter三方库优点写的快功能多缺点只能写问题内容并不是直接写入文件中只有在关闭的时候才会写入文件实例：#创建excel文件wb=xlsxwriter.Workbook("cars.xlsx")#在该文件下创建sheetws=self.wb.get_worksheet_by_name("Car")orself.wb.add_worksheet("Car")ws.write(row,c
  • Spring Cloud全解析：网关之GateWay简介 拾光师 springcloudjava
    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
  • 理解链接之链接的基本概念 Yonah潇
    前言我们知道，开发程序的基本流程是：设计-代码编写-编译-链接-执行每一个步骤展开都是一个很大的课题，链接是一个被人忽略的课题，因为它并不是很复杂，相对于编译来说它还是比较简单的，但是并不代表它不重要。现在编译链接的环节基本上由IDE帮助我们完成了，于是我们很少关注编译链接。虽然说不懂编译链接对开发程序并没有很大影响，但是如果要成为大牛，计算机底层的知识还是要掌握的。编译的知识很多，不是几篇文章能
  • Spring之Bean生命周期源码解析上 阿立聊代码 springspringjava后端
    Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的Bean的生成过程1.生成BeanDefinitionSpring启动的时候会进行扫描，会先调用org.springfr
  • python进阶语法---异常处理 鲨鱼学python python开发语言
    在Python中，异常处理是一种机制，用于处理程序运行时可能发生的错误，以确保程序能够优雅地处理错误情况，而不是直接崩溃。异常处理机制的核心是使用try、except、else和finally语句。一、基础语法异常处理的基本语法如下：try:#可能会引发异常的代码risky_code()exceptSomeExceptionase:#处理异常的代码print(f"Anerroroccurred:{
  • Metasploit漏洞利用系列（一）：MSF完美升级及目录结构深度解读 Alfadi联盟 萧瑶 网络安全
    在信息安全领域，MetasploitFramework（MSF）是一个无处不在的工具，它集合了大量的渗透测试和漏洞利用模块，帮助安全专家识别和利用系统中的弱点。本文将深入探讨如何对Metasploit进行完美升级，以及对其核心目录结构进行详尽解读，为初学者和进阶使用者提供全面指南。MSF完美升级指南1.环境准备确保你的操作系统已安装了Ruby环境，因为Metasploit是基于Ruby编写的。推荐
  • ArrayList 和 LinkedList 的区别？ XF鸭 面试题java
    ArrayList和LinkedList都是Java中的List接口的实现类，但它们的底层实现和性能特点有所不同，因此适用于不同的场景。以下是它们的主要区别：1.底层实现ArrayList：基于动态数组实现。ArrayList通过一个连续的内存块来存储元素，数组的容量可以动态扩展。当元素数量超过当前数组的容量时，ArrayList会创建一个更大的数组，并将旧数组中的元素复制到新数组中。Linked
  • 402，Swift和NSObject中Switch 的用法的区别(面试点：swift中switch中case：可以表示范围，每个case后面必须有可执行的语句，可以匹配元组，case的数值绑定，... 枫叶1234
    一，OC中的Switch语句1、switch语句分支必须是整数2、每个语句都需要一个break3、如果要穿透,case连着写。如:case9:case10:二，Swift中的switch：1、可以针对任意类型的值进行分支，不再局限于整数。（重）2、一般不需要break。3、如果使用多值，使用,4、所有分支至少有一条指令。如果什么都不做，才直接使用break.funcdemo(str:String)
  • Java中的网络编程（一） 北京最后的深情 网络
    一、网络编程概述什么是计算机网络把不同区域的计算机（广义）通过通信设备和线路连接，可以实现数据的传输和共享的系统。实现不同计算机之间的练习，必须有介质连接。网络编程是干什么的聊天-->聊天软件QQjava语言是支持网络间的数据传输的，将底层的细节都封装起来了，给程序员提供了一套标准的类库，可以很方便的使用java语言开发出进行网络通信的软件网络编程:借助计算机网络实现我们所写的程序可以在不同的电脑
  • ios睡眠分析 卧床 睡眠_在HealthKit中用 Swift 进行睡眠分析 汇商 ios睡眠分析卧床睡眠
    如今，睡眠革命逐渐成为一种时尚，跟之前相比，人们不仅想知道自己的睡眠时间，同时对用于分析他们一定时间段内睡眠状态的数据感兴趣。包括硬件技术在内的，尤其是手机技能的提升，为用户这一日益增长的需求带来了全新的希望.HealthKit苹果提供了一种安全、炫酷的方式来显示用户的个人健康信息，并将这些信息安全的存储在Health这个内置的应用中。你不仅可以使用HealthKit来创建一个健身应用，该框架还允
  • 华为仓颉语言的技术梗概，底层原理是什么？什么架构，以后会替换JAVA语言了，信创背景下，要不要开始进入仓颉赛道，详细为您剖析仓颉语言 九张算数 数字化转型华为架构java数据仓库
    华为仓颉语言（CangjieLanguage）是华为开发的一种编程语言，旨在提高软件开发效率和代码质量。以下是关于华为仓颉语言的技术梗概、底层原理、架构和语法的一些基本信息：技术梗概仓颉语言是一种高级编程语言，设计目标是简化代码编写过程，增强代码的可读性和可维护性。它结合了多种编程范式，支持面向对象编程、函数式编程和声明式编程，旨在提升开发人员的生产力。底层原理仓颉语言的底层原理主要包括以下几个方
  • 萝卜快跑（Apollo Go）的 无人驾驶底层原理是什么,烧萝卜武汉实现了7*24小时的全天候运营，估计2025年实现盈利，2024年全国大部分城市部署萝卜快跑 九张算数 数字化转型自动驾驶
    萝卜快跑（ApolloGo）是百度推出的无人驾驶出租车服务。它的底层技术原理基于百度的Apollo开放平台，该平台集成了多种先进的技术来实现无人驾驶。以下是一些关键的技术和原理：1.感知系统无人驾驶汽车需要感知周围环境，这主要依赖于多种传感器，包括：激光雷达（LiDAR）：通过发射激光束并测量反射回来的时间，生成高精度的三维地图。摄像头：用于捕捉道路标识、交通信号、行人和其他车辆。雷达（Radar
  • 4. Java中的ArrayList和LinkedList有什么区别？各自的优缺点是什么？在什么场景下选择使用它们？ 这孩子叫逆 面试题java集合java开发语言
    ArrayList和LinkedList是Java中两个常用的List接口实现类，它们都可以用来存储有序的元素，但在底层实现和性能特征上有显著的区别。1.内部实现ArrayList：ArrayList底层基于动态数组实现。它维护一个可调整大小的数组，用于存储元素。当数组的容量不足以容纳新增元素时，ArrayList会创建一个更大的新数组，并将旧数组中的元素复制到新数组中。LinkedList：Li
  • SQL进阶技巧：如何按任意时段分析时间区间问题？ | 分区间讨论【左、中、右】 莫叫石榴姐 #SQL进阶实战技巧数字化建设通关指南sql数据库mysql数据分析数据仓库hive
    目录0场景描述1数据准备2问题分析方法1：分情况讨论，找出重叠区间方法2：暴力美学法。按区间展开成日期明细表3拓展案例4小结0场景描述现有用户还款计划表user_repayment，该表内的一条数据，表示用户在指定日期区间内[date_start,date_end]，每天还款repayment元。如何统计任意时段内（如：2024-01-15至2024-01-16）每天所有用户的应还款总额？1数据准
  • 一款好用的内网穿透工具--神卓互联 坚持就是胜利1986 内网穿透服务器运维
    神卓互联是一款优秀的内网穿透工具，国内量大商业化做的最好的内网穿透一个是花生壳一个是神卓互联，都是自主研发，底层采用C语言，支持高并发高性能。由于Windows版本有GUI客户端，用户可以直接下载安装，操作便捷，这里记录一下Linux系统下安装神卓互联客户端的步骤：CentOS使用方法第一步，安装基础环境，很简洁，一行命令yuminstallgccgcc-c++wget-y第二步，创建一个安装目录
  • 你懂了“阴”“阳”吗？ 归去来兮ZYQ
    知道“得到”app是从钟杰老师的朋友圈，然后去关注，去搜索，去了解，最后成为会员。今天读到水木然的《人间清醒》，被其中对“阴”和“阳”的阐释折服。以前一说“阴阳”，首先想到的就是太极八卦，就是《易经》，总觉得深奥和玄乎，而书里的解释太有意思了。这些年来，人们总提起一个词语“底层逻辑”，作者认为所谓底层逻辑，就是事物运作的基本规律，类似于孔子所说的那个“礼”，老子说的那个“道”，佛祖说的那个“智慧”
  • 0218读书清单《进阶-身价倍增的时间、知识、情绪自我精进》（二） 阮默涵
    图片发自App001如何获得别人的支持去利他、去付出，不要只是索取，更不要得到了帮助而不懂感恩。002坚持向上的道路人向上走，当然要比向下滑容易得多，前者是逆势上行，后者是顺势下滑。003重视沟通的艺术采取理性、克制的态度，口吻不要切勿带有有挖苦、讽刺、职责，共同寻找解决方案。004为人多行善一个人如果在日常生活中没表达出对他人的善意，在大难临头的时候恐怕也不会迸发出人性的光辉。005欲速而不达有
  • ref函数与reactive函数的对比 白桃味稠鱼烧 vue3专栏javascript前端开发语言
    经过之前两篇ref函数和reactive函数我们对于这两种转换响应式数据方法的底层原理都有了一定的了解，因此，我们可以总结一下这两种方式的区别定义数据角度ref既可以用来定义基本数据类型，也可以用来定义对象(或数组)类型数据。当ref定义对象基本类型数据时，内部其实是自动通过reactive函数转化为代理对象reactive用来定义对象(或数组)类型数据。从原理角度ref函数通过Object.de
  • 初识LangChain的快速入门指南 hai40587 langchain
    初识LangChain的快速入门指南LangChain是一个强大的自然语言处理（NLP）工具链，旨在帮助开发者快速构建复杂的语言处理应用。它简化了与大语言模型（LLM）的交互过程，支持数据检索和将不同功能模块串联起来以完成复杂任务。本指南将详细介绍LangChain的安装、核心概念、基本使用、进阶使用以及社区与支持，帮助读者快速上手LangChain。一、安装与设置首先，确保你的系统中已安装Pyt
  • C++ 进阶 - const 的用法及尽量使用const的好处 路人暴脾气 C/C++进阶C++学习之路C++c++const用法使用const的好处
    文章有点长哈，可以耐心的看看。个人总结，请持怀疑态度参考。文章中代码的测试环境为VS2013进入正题。。。。const关键字在C++中的用法多种多样，可以概括如下：它可以在classes外部修饰global或namespace作用域中的常量或者修饰文件、函数或者块作用域中被声明为static的对象。它也可以修饰classes内部的静态成员和非静态成员变量。一、修饰指针在修饰指针时首先要明确cons
  • spring入门aop和ioc eqa11 springjava后端
    文章目录spring分层架构表现层服务层（业务层）持久层spring核心ioc（控制反转）1)**接下来是代码示例：**2)**ioc容器的使用过程**3)ioc中的bean管理4)实例化bean的三种方式aop（面向切面开发）定义优势AOP底层原理AOP相关的术语AOP入门aop注解开发aop纯注解开发Di（依赖注入）1）属性的set方法注入值的方式2）构造方法赋值的方法多配置文件多配置文件sp
  • 从C到C++ 番外篇 new和delete运算符 Gelercat 从C到C++c++
    1、内存分配编程中我们往往需要对内存进行动态分配，这也是C++和C贴近底层的体现。在C中动态内存分配机制使用了malloc和free两个函数.#defineSIZE100int*arr=(int*)malloc(SIZE*sizeof(int));free(arr);C++中也提供了这样的内存分配机制：new和delete。这两个函数务必搭配使用二次编辑：new出来的对象如果不进行delete，在
  • c++调用python和numpy混合编程 AIVoyager c++pythonc++pythonnumpy
    目录1.cmake配置2.python脚本3.c++头文件初始化4.c++调用python中的函数，实现功能参考在现代软件开发中，跨语言编程和混合编程的需求日益增长。C++作为一种高效、强大的编程语言，广泛应用于底层开发、游戏引擎、高性能计算等领域。而Python则因其简洁的语法、丰富的库和易于学习的特性，在数据科学、机器学习、Web开发等领域占据重要地位。NumPy是Python中一个用于数值计
  • 【408DS算法题】024进阶-12年真题_找出两个链表的共同后缀的起始位置 LIC_woodBird 算法链表数据结构
    Index真题题目（以下内容来自https://blog.csdn.net/weixin_60702024/article/details/141370977）分析实现总结真题题目（以下内容来自https://blog.csdn.net/weixin_60702024/article/details/141370977）用单链表保存m个整数，结点的结构为[data][link]，且∣data∣⩽n
  • Swift中$表示什么 ray_1942
    又有一段时间木有写啦，发一条刷刷存在感～$表示闭包中的第几个参数用于简化闭包代码，如下：letcities=["tianjin":100,"beijing":100,"shanghai":101,"guangzhou":102,"shenzhen":103]lettheValuesGreaterThan101=cities.filter{$0.value>101}lettheValuesLessT
  • 深入理解C语言指针原理——深入底层机制 极客代码 玩转C语言开发语言c语言
    概述在C语言中，指针是处理内存的核心工具。为了更好地理解指针如何工作，我们需要深入了解指针与底层硬件和操作系统之间的交互方式。本文将探讨指针的底层实现、内存布局、以及它们如何影响程序的行为。内存模型虚拟内存现代操作系统为每个进程提供了独立的虚拟地址空间。这个虚拟地址空间被划分为几个主要部分：代码段（CodeSegment）：包含程序的可执行指令。数据段（DataSegment）：存放已初始化的全局
  • 《黑神话·悟空》的编程语言探讨 hawkol c++小程序开发C++学习笔记游戏微信小程序小程序游戏源码C++
    《黑神话·悟空》作为备受瞩目的国产单机动作游戏，其开发技术和使用的编程语言一直是业界和玩家关注的热点。本文将详细探讨这款游戏主要使用的编程语言及其背后的技术考量。主要编程语言:C++根据多方信息参考《黑神话·悟空》的主要编程语言是C++。这一选择并非偶然，而是基于其开发所依赖的虚幻引擎(UnrealEngine)的底层源码特性。虚幻引擎，作为由EpicGames开发的一款强大的游戏开发平台，其核心
  • Java中的Jackson：高级进阶篇 墨瑾轩 Java类库Java乐园java开发语言
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣❓引言嗨，小伙伴们！今天我们将一起探索Jackson这个强大的JSON处理库。如果你需要在Java程序中处理JSON数据，那么Jackson绝对是你的首选。接下来，我们就一步步地探索Jackson的魅力吧！‍什么是Jackson？Jackson是一个开源的Ja
  • Js函数返回值 _wy_ jsreturn
    一、返回控制与函数结果，语法为：return 表达式;作用: 结束函数执行，返回调用函数，而且把表达式的值作为函数的结果 二、返回控制语法为：return;作用: 结束函数执行，返回调用函数，而且把undefined作为函数的结果 在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性
  • MySQL 的 char 与 varchar bylijinnan mysql
    今天发现，create table 时，MySQL 4.1有时会把 char 自动转换成 varchar 测试举例： CREATE TABLE `varcharLessThan4` ( `lastName` varchar(3) ) ; mysql> desc varcharLessThan4; +----------+---------+------+-
  • Quartz——TriggerListener和JobListener eksliang TriggerListenerJobListenerquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208624 一.概述 listener是一个监听器对象，用于监听scheduler中发生的事件，然后执行相应的操作；你可能已经猜到了，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。   二.JobListener监听器  j
  • oracle层次查询 18289753290 oracle；层次查询；树查询
    .oracle层次查询(connect  by) oracle的emp表中包含了一列mgr指出谁是雇员的经理，由于经理也是雇员，所以经理的信息也存储在emp表中。这样emp表就是一个自引用表，表中的mgr列是一个自引用列，它指向emp表中的empno列，mgr表示一个员工的管理者， select   empno,mgr,ename,sal  from e
  • 通过反射把map中的属性赋值到实体类bean对象中 酷的飞上天空 javaee泛型类型转换
    使用过struts2后感觉最方便的就是这个框架能自动把表单的参数赋值到action里面的对象中 但现在主要使用Spring框架的MVC，虽然也有@ModelAttribute可以使用但是明显感觉不方便。 好吧，那就自己再造一个轮子吧。 原理都知道，就是利用反射进行字段的赋值，下面贴代码 主要类如下：   import java.lang.reflect.Field; imp
  • SAP HANA数据存储：传统硬盘的瓶颈问题 蓝儿唯美 HANA
    SAPHANA平台有各种各样的应用场景，这也意味着客户的实施方法有许多种选择，关键是如何挑选最适合他们需求的实施方案。 在 《Implementing SAP HANA》这本书中，介绍了SAP平台在现实场景中的运作原理，并给出了实施建议和成功案例供参考。本系列文章节选自《Implementing SAP HANA》，介绍了行存储和列存储的各自特点，以及SAP HANA的数据存储方式如何提升空间压
  • Java Socket 多线程实现文件传输 随便小屋 javasocket
            高级操作系统作业，让用Socket实现文件传输，有些代码也是在网上找的，写的不好，如果大家能用就用上。 客户端类：   package edu.logic.client; import java.io.BufferedInputStream; import java.io.Buffered
  • java初学者路径 aijuans java
    学习Java有没有什么捷径?要想学好Java，首先要知道Java的大致分类。自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE
  • APP推广 aoyouzi APP推广
    一，免费篇 1，APP推荐类网站自主推荐 最美应用、酷安网、DEMO8、木蚂蚁发现频道等,如果产品独特新颖，还能获取最美应用的评测推荐。PS：推荐简单。只要产品有趣好玩，用户会自主分享传播。例如足迹APP在最美应用推荐一次，几天用户暴增将服务器击垮。 2，各大应用商店首发合作 老实盯着排期，多给应用市场官方负责人献殷勤。 3，论坛贴吧推广 百度知道，百度贴吧，猫扑论坛，天涯社区，豆瓣（
  • JSP转发与重定向 百合不是茶 jspservletJava Webjsp转发
      在servlet和jsp中我们经常需要请求,这时就需要用到转发和重定向;   转发包括;forward和include     例子;forwrad转发;  将请求装法给reg.html页面   关键代码;    req.getRequestDispatcher("reg.html
  • web.xml之jsp-config bijian1013 javaweb.xmlservletjsp-config
    1.作用：主要用于设定JSP页面的相关配置。 2.常见定义： <jsp-config> <taglib> <taglib-uri>URI(定义TLD文件的URI,JSP页面的tablib命令可以经由此URI获取到TLD文件)</tablib-uri> <taglib-location> TLD文件所在的位置
  • JSF2.2 ViewScoped Using CDI sunjing CDIJSF 2.2ViewScoped
    JSF 2.0 introduced annotation @ViewScoped; A bean annotated with this scope maintained its state as long as the user stays on the same view(reloads or navigation - no intervening views). One problem w
  • 【分布式数据一致性二】Zookeeper数据读写一致性 bit1129 zookeeper
    很多文档说Zookeeper是强一致性保证，事实不然。关于一致性模型请参考http://bit1129.iteye.com/blog/2155336    Zookeeper的数据同步协议 Zookeeper采用称为Quorum Based Protocol的数据同步协议。假如Zookeeper集群有N台Zookeeper服务器(N通常取奇数，3台能够满足数据可靠性同时
  • Java开发笔记 白糖_ java开发
    1、Map<key,value>的remove方法只能识别相同类型的key值   Map<Integer,String> map = new HashMap<Integer,String>(); map.put(1,"a"); map.put(2,"b"); map.put(3,"c"
  • 图片黑色阴影 bozch 图片
     .event{ padding:0;    width:460px;    min-width: 460px;    border:0px solid #e4e4e4;    height: 350px;    min-heig
  • 编程之美-饮料供货-动态规划 bylijinnan 动态规划
    import java.util.Arrays; import java.util.Random; public class BeverageSupply { /** * 编程之美 饮料供货 * 设Opt（V’，i）表示从i到n-1种饮料中，总容量为V’的方案中，满意度之和的最大值。 * 那么递归式就应该是：Opt（V’，i）=max{ k * Hi+Op
  • ajax大参数（大数据）提交性能分析 chenbowen00 WebAjax框架浏览器prototype
    近期在项目中发现如下一个问题 项目中有个提交现场事件的功能，该功能主要是在web客户端保存现场数据（主要有截屏，终端日志等信息）然后提交到服务器上方便我们分析定位问题。客户在使用该功能的过程中反应点击提交后反应很慢，大概要等10到20秒的时间浏览器才能操作，期间页面不响应事件。 根据客户描述分析了下的代码流程，很简单，主要通过OCX控件截屏，在将前端的日志等文件使用OCX控件打包，在将之转换为
  • [宇宙与天文]在太空采矿,在太空建造 comsci
         我们在太空进行工业活动...但是不太可能把太空工业产品又运回到地面上进行加工,而一般是在哪里开采,就在哪里加工,太空的微重力环境,可能会使我们的工业产品的制造尺度非常巨大....      地球上制造的最大工业机器是超级油轮和航空母舰,再大些就会遇到困难了,但是在空间船坞中,制造的最大工业机器,可能就没
  • ORACLE中CONSTRAINT的四对属性 daizj oracleCONSTRAINT
    ORACLE中CONSTRAINT的四对属性 summary:在data migrate时,某些表的约束总是困扰着我们,让我们的migratet举步维艰,如何利用约束本身的属性来处理这些问题呢?本文详细介绍了约束的四对属性: Deferrable/not deferrable, Deferred/immediate, enalbe/disable, validate/novalidate,以及如
  • Gradle入门教程 dengkane gradle
    一、寻找gradle的历程 一开始的时候，我们只有一个工程，所有要用到的jar包都放到工程目录下面，时间长了，工程越来越大，使用到的jar包也越来越多，难以理解jar之间的依赖关系。再后来我们把旧的工程拆分到不同的工程里，靠ide来管理工程之间的依赖关系，各工程下的jar包依赖是杂乱的。一段时间后，我们发现用ide来管理项程很不方便，比如不方便脱离ide自动构建，于是我们写自己的ant脚本。再后
  • C语言简单循环示例 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i; int count = 0; int sum = 0; float avg; for (i=1; i<=100; i++) { if (i%2==0) { count++; sum += i; } } avg
  • presentModalViewController 的动画效果 dcj3sjt126com controller
    系统自带(四种效果)： presentModalViewController模态的动画效果设置：     [cpp]  view plain copy   UIViewController *detailViewController = [[UIViewController al
  • java 二分查找 shuizhaosi888 二分查找java二分查找
    需求：在排好顺序的一串数字中，找到数字T   一般解法：从左到右扫描数据，其运行花费线性时间O(N)。然而这个算法并没有用到该表已经排序的事实。 /** * * @param array * 顺序数组 * @param t * 要查找对象 * @return */ public stati
  • Spring Security（07）——缓存UserDetails 234390216 ehcache缓存Spring Security
           Spring Security提供了一个实现了可以缓存UserDetails的UserDetailsService实现类，CachingUserDetailsService。该类的构造接收一个用于真正加载UserDetails的UserDetailsService实现类。当需要加载UserDetails时，其首先会从缓存中获取，如果缓存中没
  • Dozer 深层次复制 jayluns VOmavenpo
    最近在做项目上遇到了一些小问题，因为架构在做设计的时候web前段展示用到了vo层，而在后台进行与数据库层操作的时候用到的是Po层。这样在业务层返回vo到控制层，每一次都需要从po-->转化到vo层，用到BeanUtils.copyProperties(source, target)只能复制简单的属性，因为实体类都配置了hibernate那些关联关系，所以它满足不了现在的需求，但后发现还有个很
  • CSS规范整理（摘自懒人图库） a409435341 htmlUIcss浏览器
       刚没事闲着在网上瞎逛，找了一篇CSS规范整理，粗略看了一下后还蛮有一定的道理，并自问是否有这样的规范，这也是初入前端开发的人一个很好的规范吧。 一、文件规范 1、文件均归档至约定的目录中。 具体要求通过豆瓣的CSS规范进行讲解： 所有的CSS分为两大类：通用类和业务类。通用的CSS文件，放在如下目录中： 基本样式库 /css/core
  • C++动态链接库创建与使用 你不认识的休道人 C++dll
    一、创建动态链接库 1.新建工程test中选择”MFC [dll]”dll类型选择第二项"Regular DLL With MFC shared linked"，完成 2.在test.h中添加 extern “C” 返回类型 _declspec(dllexport)函数名(参数列表); 3.在test.cpp中最后写 extern “C” 返回类型 _decls
  • Android代码混淆之ProGuard rensanning ProGuard
    Android应用的Java代码，通过反编译apk文件（dex2jar、apktool）很容易得到源代码，所以在release版本的apk中一定要混淆一下一些关键的Java源码。 ProGuard是一个开源的Java代码混淆器（obfuscation）。ADT r8开始它被默认集成到了Android SDK中。 官网： http://proguard.sourceforge.net/
  • 程序员在编程中遇到的奇葩弱智问题 tomcat_oracle jquery编程ide
    　　现在收集一下：       　　排名不分先后，按照发言顺序来的。   1、Jquery插件一个通用函数一直报错，尤其是很明显是存在的函数，很有可能就是你没有引入jquery。。。或者版本不对 2、调试半天没变化：不在同一个文件中调试。这个很可怕，我们很多时候会备份好几个项目，改完发现改错了。有个群友说的好：   在汤匙
  • 解决maven-dependency-plugin (goals "copy-dependencies","unpack") is not supported xp9802 dependency
    解决办法：在plugins之前添加如下pluginManagement，二者前后顺序如下：   [html]  view plain copy   <build>           <pluginManagement
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他