前言
swift的数据编解码，我们可以使用多种方案，常见的有用苹果自带的Codable和三方HandyJSON、swiftyJson等都很好用。
个人觉得能够用官方提供的就尽量用，但是使用Codable的一个很大问题就是不能设置默认值，所以常在模型里面会有很多的可选值出现，导致我们在使用时会随处都要解包，而且还有个很大的问题是如果，在json数据中出现了我们模型中不对应的类型或者缺少，我们的解码就会完全失败。
面临这个问题，我们就能使用苹果提供的@propertyWrapper属性包装来处理，其中喵神已经做了很全面的说明：使用 Property Wrapper 为 Codable 解码设定默认值，如果只关心实现方案，就可以直接看我这里。
开始
1、弄一个属性包装
/// 让需要有默认值的，遵循这个协议，提供默认值的能力，就是让模型必须有个静态属性
protocol DefaultValue {
associatedtype DefValue: Codable, DefaultValue
static var defaultValue: DefValue { get }
}
/// 属性包装
@propertyWrapper
struct Default<T: DefaultValue> {
var wrappedValue: T.DefValue
}
2、因为编解码是要实现Codable的，所以让Default遵循Codable协议，实现init(from decoder: Decoder) throws {}这个方法，在失败时传入我们的默认值T.defaultValue
extension Default: Codable {
init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
wrappedValue = (try? container.decode(T.DefValue.self)) ?? T.defaultValue
}
}
3、在解码时会调用到KeyedDecodingContainer中的各种decode方法，例如：func decode(Double.Type, forKey: KeyedDecodingContainer<K>.Key) -> Double，我们就需要在KeyedDecodingContainer为Default扩展一个解码方法，也是在解码失败给他传入我们的默认值
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)
}
}
4、然后就是为我们的常用类型做一些默认值的扩展，这里我列出了一些常用默认值，可以直接copy，其中要注意的就是数组和字典，他们是有泛型。
// MARK: Dictionary默认值扩展
extension Dictionary: DefaultValue where Key: Codable, Value: DefaultValue & Codable {
static var defaultValue: [Key: Value] { get { return [Key: Value]() } }
}
// MARK: Array默认值扩展
extension Array: DefaultValue where Element: DefaultValue & Codable {
static var defaultValue: [Element] { get { return [] } }
}
// MARK: Float默认值扩展
extension Float: DefaultValue {
static var defaultValue: Float = 0
}
// MARK: Double默认值扩展
extension Double: DefaultValue {
static var defaultValue: Double = 0
}
// MARK: Bool默认值扩展
extension Bool: DefaultValue {
static let defaultValue = false
enum True: DefaultValue {
static let defaultValue = true
}
}
// MARK: String默认值扩展
extension String: DefaultValue {
static let defaultValue = ""
}
extension String {
enum Empty: DefaultValue {
static let defaultValue = ""
}
}
extension Int: DefaultValue {
static let defaultValue = 0
enum NegativeOne: DefaultValue {
static let defaultValue = -1
}
}
// MARK: 取别名
extension Default {
//Bool
typealias True = Default<Bool.True>
typealias False = Default<Bool>
//String
typealias EmptyString = Default<String>
/// Int
typealias ZeroInt = Default<Int>
}
5、现在我们的Codable终于是能支持默认值了，使用方法如下：
class FSDefStuct: Codable, DefaultValue {
@Default<Array> var arr: [FSDefStuctArr] = .defaultValue
@Default<FSDefStuctBody> var body: FSDefStuctBody = .defaultValue
@Default<Int> var id: Int = .defaultValue
static let defaultValue = FSDefStuct()
required init() {}
}
class FSDefStuctBody: Codable, DefaultValue {
@Default<String> var Auth: String = .defaultValue
@Default<String> var name: String = .defaultValue
static let defaultValue = FSDefStuctBody()
required init() {}
}
class FSDefStuctArr: Codable, DefaultValue {
@Default<String> var name: String = .defaultValue
@Default<MyType> var type: MyType = .defaultValue
static let defaultValue = FSDefStuctArr()
required init() {}
}
enum MyType: Int, Codable, DefaultValue {
case swift
case OC
case undefine
static let defaultValue = MyType.undefine
}
private let testJson = #"{"id": 12345, "body": {"name": "abc", "Auth": "erd"}, "arr": [{"type": 0, "name":"swift"},{"type": 1, "name":"OC"},{"type": 5, "name":"Java"}]}"#
如上面的{"type": 5, "name":"Java"}就是没在我的定义范围内，就会默认转为case undefine，其他的可以将上面testJson中任意删除掉一些字段，或写为null做测试。
是不是很开心，but打印下我们编解码的东西，会看到是如下：
{
"arr" : {
"wrappedValue" : [
{
"name" : {
"wrappedValue" : "swift"
},
"type" : {
"wrappedValue" : 0
}
},
{
"name" : {
"wrappedValue" : "OC"
},
"type" : {
"wrappedValue" : 1
}
},
{
"name" : {
"wrappedValue" : "Java"
},
"type" : {
"wrappedValue" : 2
}
}
]
},
"id" : {
"wrappedValue" : 12345
},
"body" : {
"wrappedValue" : {
"name" : {
"wrappedValue" : "abc"
},
"Auth" : {
"wrappedValue" : "erd"
}
}
}
}
怎么会变成这样？？？，这就是属性包装帮你做的事情，但是谁都不想要这种效果。这里其实是编码时出的问题，我们只扩展了用于解码的KeyedDecodingContainer，所以我们还需要扩展一下编码KeyedEncodingContainer，在编码时直接取wrappedValue里边的值就行了。
extension KeyedEncodingContainer {
mutating func encode<T>(
_ value: Default<T>,
forKey key: Self.Key
) throws where T : Encodable & DefaultValue {
try encodeIfPresent(value.wrappedValue, forKey: key)
}
}
这样就能转json时出现我们想要的效果了
{
"arr" : [
{
"name" : "swift",
"type" : 0
},
{
"name" : "OC",
"type" : 1
},
{
"name" : "Java",
"type" : 2
}
],
"id" : 12345,
"body" : {
"name" : "abc",
"Auth" : "erd"
}
}
到此还没完，作为cv大法的coder们，肯定觉得是如果这样手写模型好累啊，所以我这里就借用JSONConverter增加了一个DefaultCodableBuilder.swift文件。
import Foundation
class DefaultCodableBuilder: BuilderProtocol {
func isMatchLang(_ lang: LangType) -> Bool {
return lang == .DefualtCodable
}
func propertyText(_ type: PropertyType, keyName: String, strategy: PropertyStrategy, maxKeyNameLength: Int, typeName: String?) -> String {
assert(!((type == .Dictionary || type == .ArrayDictionary) && typeName == nil), " Dictionary type the typeName can not be nil")
let tempKeyName = strategy.processed(keyName)
var str = ""
switch type {
case .String, .Null:
str = "\t<String> var \(tempKeyName): String\n"
case .Int:
str = "\t<Int> var \(tempKeyName): Int\n"
case .Float:
str = "\t<Float> var \(tempKeyName): Float\n"
case .Double:
str = "\t<Double> var \(tempKeyName): Double\n"
case .Bool:
str = "\t<Bool> var \(tempKeyName): Bool\n"
case .Dictionary:
str = "\t<\(typeName!)> var \(tempKeyName): \(typeName!)\n"
case .ArrayString, .ArrayNull:
str = "\t<Array> var \(tempKeyName): [String]\n"
case .ArrayInt:
str = "\t<Array> var \(tempKeyName): [Int]\n"
case .ArrayFloat:
str = "\t<Array> var \(tempKeyName): [Float]\n"
case .ArrayDouble:
str = "\t<Array> var \(tempKeyName): [Double]\n"
case .ArrayBool:
str = "\t<Array> var \(tempKeyName): [Bool]\n"
case .ArrayDictionary:
str = "\t<Array> var \(tempKeyName): [\(typeName!)]\n"
}
str.insert(contentsOf: "@Default", at: str.index(str.startIndex, offsetBy: 1))
str.insert(contentsOf: " = .defaultValue", at: str.index(str.endIndex, offsetBy: -1))
return str
}
func contentParentClassText(_ clsText: String?) -> String {
return StringUtils.isEmpty(clsText) ? ": Codable" : ": \(clsText!)"
}
func contentText(_ structType: StructType, clsName: String, parentClsName: String, propertiesText: inout String, propertiesInitText: inout String?, propertiesGetterSetterText: inout String?) -> String {
if structType == .class {
return "\nclass \(clsName)\(parentClsName), DefaultValue {\n\(propertiesText)\n\tstatic let defaultValue = \(clsName)()\n\trequired init() {}\n}\n"
} else {
propertiesText.removeLastChar()
return "\nstruct \(clsName)\(parentClsName), DefaultValue {\n\(propertiesText)\n\tstatic let defaultValue = \(clsName)(\(propertiesInitText!.substring(from: 2)))\n}\n"
}
}
func fileExtension() -> String {
return "swift"
}
func fileImportText(_ rootName: String, contents: [Content], strategy: PropertyStrategy, prefix: String?) -> String {
return"\nimport Foundation\n"
}
}
这样就能卡卡的转模型了。
转Class
转Struct
至此完成，喜欢的觉得有用的点个赞！！！
