Class & Struct 的 NSCoding 一种较好的实现思路

1.Class 类型的 NSCoding

1.1 正儿八经的使用方式

前提一定是要继承NSObject，实现NSCoding协议，和 OC 基本差不多。

class Coordinate:NSObject,NSCoding {
    let latitude:Double = 10
    let longitude:Double = 10
    
    init(latitude:Double,longitude:Double) {
        self.latitude = latitude
        self.longitude = longitude
    }

    convenience required init?(coder aDecoder: NSCoder) {
      self.init()
      self.latitude = aDecoder.decodeObject(forKey: "latitude")
      self.longitude = aDecoder.decodeObject(forKey: "longitude")
    }
    
    func encode(with aCoder: NSCoder) {
        aCoder.encode(coordinate?.latitude,forKey:"latitude")
        aCoder.encode(coordinate?.longitude,forKey:"longitude")
    }
}

1.2 Mirror基础知识

下面是一个简单的例子：

class Project {
    var title: String = ""
    var id: Int = 0
    var platform: String = ""
    var version: Int = 0
    var info: String?
}

创建一个实例，得到其反射结果。我们可以得到的东西很多，类型，值，标签等等

let sampleProject = Project()
sampleProject.title = "MirrorMirror"
sampleProject.id = 199
sampleProject.platform = "iOS"
sampleProject.version = 2
sampleProject.info = "test app for Reflection"
The code below shows the creating of Mirror instance. The children property of the mirror is a AnyForwardCollection<Child> where Child is typealias tuple for subject's property and value. Child had a label: String and value: Any.

let projectMirror = Mirror(reflecting: sampleProject)
let properties = projectMirror.children

print(properties.count)        //5
print(properties.first?.label) //Optional("title")
print(properties.first!.value) //MirrorMirror
print()

for property in properties {
    print("\(property.label!):\(property.value)")
}

终端输出如下：

title:MirrorMirror
id:199
platform:iOS
version:2
info:Optional("test app for Reflection")

Tested in Playground on Xcode 8 beta 2

语法：

Mirror(reflecting: instance) // Initializes a mirror with the subject to reflect
mirror.displayStyle // 这里就是 Class 当让也会是struct
mirror.description // 其实就是 CustomStringConvertible 协议的描述
mirror.subjectType // 返回被反射的对象的类型 这里是Project
mirror.superclassMirror // 返回被反射的对象的父类的类型 这里没有就是nil

如果你想完整的看Mirror用法，请前往swiftgg 阅读 Swift 反射 API 及用法 一文。

1.3 使用Mirror改写NSCoding

/// 继承 NSCoding 协议的 Class
class PersonClass:NSObject,NSCoding{
    var name:String = "pmst"
    var age:Int = 20
    
    override var description: String{
        return "name:\(name) age:\(age)"
    }
    
    override init() {
        super.init()
    }
    
    convenience required init?(coder aDecoder: NSCoder) {
        self.init()
        
        var mirror:Mirror? = Mirror(reflecting: self)
        repeat {
            // typealias Children = AnyCollection<Mirror.Child>
            // typealias Child = (label: String?, value: Any)
            // 以上是额外的知识点
            for case let (label?,value) in mirror!.children {
                setValue(value, forKey: label)
            }
            mirror = mirror!.superclassMirror
            
        } while mirror != nil
    }
    
    func encode(with aCoder: NSCoder) {
        var mirror:Mirror? = Mirror(reflecting: self)
        repeat {
            
            // typealias Children = AnyCollection<Mirror.Child>
            // typealias Child = (label: String?, value: Any)
            // 以上是额外的知识点
            for case let (label?,value) in mirror!.children {
                aCoder.encode(value, forKey: label)
            }
            mirror = mirror!.superclassMirror
            
        } while mirror != nil
    }
}


class Teacher:PersonClass{
    var course = "英文"
    var workAge = 10
    
    override var description: String{
        return super.description + " course:\(course)" + "workAge:\(workAge)"
    }
}

实战：

let encodePerson = PersonClass()
let documentsPath = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.documentDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).first
let path = documentsPath?.appending("/person1")
print(path)
let data = NSKeyedArchiver.archiveRootObject(encodePerson, toFile: path!)
print(encodePerson)
encodePerson.name = "machao"
encodePerson.age = 18
print(encodePerson)

// 解压出来
let decodePerson = NSKeyedUnarchiver.unarchiveObject(withFile: path!)
print(decodePerson)

let encodeTeacher = Teacher()
let path1 = documentsPath?.appending("/teacher")
let data1 = NSKeyedArchiver.archiveRootObject(encodeTeacher, toFile: path1!)
let decodeTeacher = NSKeyedUnarchiver.unarchiveObject(withFile: path1!)
print(decodeTeacher)

2. Struct 类型的 NSCoding

NSCoding 协议定义了 encode 和 decode，另外 Swift 必须遵循 NSObjectProtocol ，顾名思义只适用类对象，结构体 struct 显然被排除在外。那么如何让结构体也能达到 encode 和 decode呢？

创建一个专门负责encode和decode的类，这种做法在设计模式中应该叫做策略模式？单一职责原则也是我们所提倡的。下面介绍几种实现方式，本质都是需要创建一个类。下面介绍几种方式。

2.1 方式一

代码如下：

/// 坐标的基本数据结构
struct Coordinate {
    let latitude:Double
    let longitude:Double
    
    init(latitude:Double,longitude:Double) {
        self.latitude = latitude
        self.longitude = longitude
    }
}

/// 搞一个类负责encoding 这样可以更严格地适用单一职责原则
class EncodingCoordinate:NSObject,NSCoding{
    var coordinate:Coordinate?
    init(coordinate:Coordinate?) {
        self.coordinate = coordinate
    }
    
    required init?(coder aDecoder: NSCoder) {
        guard
            let latitude = aDecoder.decodeObject(forKey: "latitude") as? Double,
            let longitude = aDecoder.decodeObject(forKey: "longitude") as? Double else {
            return nil
        }
        coordinate = Coordinate(latitude: latitude, longitude: longitude)
    }
    
    func encode(with aCoder: NSCoder) {
        aCoder.encode(coordinate?.latitude,forKey:"latitude")
        aCoder.encode(coordinate?.longitude,forKey:"longitude")
    }
}
let coordinate = Coordinate(latitude: 12.0, longitude: 13.1)
let encodable = EncodingCoordinate(coordinate: coordinate)
let documentsPath = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.documentDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).first
let path = documentsPath?.appending("/Coordinate")
print(path)
let data = NSKeyedArchiver.archiveRootObject(encodable, toFile: path!)// 关键！archiveRootObject的对象一定是实现了NSCoding协议的

优点：把encode和decode的职责单独搞成了一个类，我们使用时只需要传入结构体实例coordinate得到一个EncodingCoordinate类型的实例encodable，然后拿它来归档和接档操作。
缺点：每次都要为我们结构体单独创建一个归档解档的类，而且都是分离的，内聚性低。

因此我们尝试将归档解档的类嵌入到结构体中。

2.2 方式二

我们最终会调用结构体的encode和decode，但是我们会依靠HelperClass类，正如你看到的真正归档和解档的操作是由HelperClass来实现的，它实现NSCoding协议，和方式一的做法一样，我们会传入person对象。

struct Person{
    let firstName:String
    let lastName:String

    static func encode(person: Person) {
        let personClassObject = HelperClass(person: person)

        NSKeyedArchiver.archiveRootObject(personClassObject, toFile: HelperClass.path())
    }

    static func decode() -> Person? {
        let personClassObject = NSKeyedUnarchiver.unarchiveObject(withFile: HelperClass.path()) as? HelperClass

        return personClassObject?.person
    }
}

extension Person{
    class HelperClass:NSObject,NSCoding {
        var person:Person?

        init(person:Person){
            super.init()
            self.person = person
        }
        class func path() -> String {
            let documentsPath = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.documentDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).first
            let path = documentsPath?.appending("/Person")
            return path!
        }

        required init?(coder aDecoder: NSCoder) {
            super.init()
            
            guard let firstName = aDecoder.decodeObject(forKey: "firstName") as? String else { person = nil; return nil }
            guard let laseName = aDecoder.decodeObject(forKey: "lastName") as? String else { person = nil;  return nil }

            person = Person(firstName: firstName, lastName: laseName)
        }

        func encode(with aCoder: NSCoder) {
            aCoder.encode(person!.firstName, forKey: "firstName")
            aCoder.encode(person!.lastName, forKey: "lastName")
        }
    }
}

这里似乎我们只是进步了一点点，内聚性相对高一些，但是又遵循了单一职责原则。

2.3 方式三

swiftgg 结构体与 NSCoding 一文提供协议方式，但是我感觉还是局限性很大，只是为了结合Cache来做一些东西。接着Coordinate的代码改进，下面贴出代码：

/// 定义两个协议 前者是
protocol Encoded {
    associatedtype Encoder: NSCoding
    
    var encoder: Encoder { get } // 要求像Coordinate结构体对象提供一个实例，负责归档解档职责。ps:有点绕。
}

protocol Encodable {
    associatedtype Value
    
    var value: Value? { get }
}

extension EncodableCoordinate: Encodable {
    var value: Coordinate? {
        return coordinate
    }
}

extension Coordinate: Encoded {
    var encoder: EncodableCoordinate {
        return EncodableCoordinate(coordinate: self)
    }
}

/// cache对象 save和fetch两个操作分别对象归档和解档行为 这里的泛型约束很重要
/// T 首先是要遵循Encoded协议，提供一个归档解档类；接着T的关联类型 Encoder 要遵循Encodable协议，为的就是让encoder返回解档的值；最后保证解档的值的类型和T一致
class Cache<T: Encoded> where T.Encoder: Encodable, T.Encoder.Value == T {
    //...
    func save(object: T) {
    NSKeyedArchiver.archiveRootObject(object.encoder, toFile: path)
  }
  
  func fetchObject() -> T? {
    let fetchedEncoder = NSKeyedUnarchiver.unarchiveObject(withFile: storagePath)
    let typedEncoder = fetchedEncoder as? T.Encoder
    return typedEncoder?.value as T?
  }
}

/// 使用
let cache = Cache<Coordinate>(name: "coordinateCache")
cache.save(object: coordinate)

2.4 另类的一种方式

实现思路是先转成字典，然后将字典归档解档。这里只是提供一种思路，但是只是个雏形，尽管结构体只要实现一个方法即可，但是感觉还是不太优雅。

代码如下：

protocol StructDecoder {
    static func dictionaryTo(dict:Dictionary<String,Any>)->Self
    static func path()->String
    static func decode()->Self
    func encode()
}

extension StructDecoder {
    var mirrorObject:Mirror {
        return Mirror(reflecting: self)
    }
    
    static func path()->String {
        let documentsPath = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.documentDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).first
        let path = documentsPath?.appending("/\(Self.self)")
        return path!
    }
    
    func toDictionary() -> Dictionary<String, Any> {
        var mirror:Mirror? = mirrorObject
        var dict:[String:Any] = [:]
        repeat {
            
            for case let (label?,value) in mirror!.children {
                dict[label] = value
            }
            mirror = mirror!.superclassMirror
            
        } while mirror != nil
        
        return dict
    }
    
    func encode(){
        NSKeyedArchiver.archiveRootObject(toDictionary(), toFile:Self.path())
    }

    static func decode()->Self {
        let dict = NSKeyedUnarchiver.unarchiveObject(withFile: path()) as! [String:Any]
        
        return Self.dictionaryTo(dict: dict)
    }
    
}

struct STPerson:StructDecoder {

    var name:String = "pmst"
    var age:Int = 20
    
    static func dictionaryTo(dict: Dictionary<String, Any>) -> STPerson {
        return STPerson(name: dict["name"] as! String, age: dict["age"] as! Int)
    }
}

可以看到只要实现dictionaryTo方法即可，原本我是希望也能默认实现的，但是发现貌似有点麻烦，暂且搁置。具体使用代码也很简单：

var stPerson = STPerson()
print(stPerson)
stPerson.age = 100
stPerson.name = "添加"
stPerson.encode()
var stPerson1 = STPerson.decode()
print(stPerson1)

优点：丑陋的一面被我隐藏在了extension里，你也做的不过是给你一个字典，自己映射到Model中。
缺点：一个对象只能归档到一个文件，当然这个只需要少许改动代码即可；用反射的归档解档效率肯定低，目前看来是致命伤！

如果有好的思路想法，请在下面给我留言哈。

新浪微博：Ninth_Day