Swift自定义类的存储

在Swift开发中，许多时候会涉及到存储自定义的类，不管是存储到本地文件还是远程服务器，都会涉及到编码和解码的问题。下面就来介绍一下在Swift中怎么存储自定义的类。
在Swift中存储自定义的类有两种方法，一种是Swift 3.0版本的NSCoding，还有一种是Swift 4.0版本的Codable。我们就两种方法来谈谈其中的区别吧。

Swift 3.0: NSCoding

在NSCoding这个协议在OC中就存在，所以自然而然的，Swift也能使用它。使用NSCoding协议，需要这个类继承自NSObject并遵循NSCoding协议，而且还要实现NSCoding协议中的两个方法，才能编码和解码自定义的类。例子如下：

class Person: NSObject, NSCoding {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    //编码
    func encode(with aCoder: NSCoder) {
        aCoder.encode(name, forKey: "name")
        aCoder.encode(age, forKey: "age")
    }

    //解码
    required init?(coder aDecoder: NSCoder) {
        self.name = aDecoder.decodeObject(forKey: "name") as! String
        self.age = aDecoder.decodeInteger(forKey: "age")
    }
}

其中编码和解码两个方法就是NSCoding协议中要求实现的两个方法，只有实现了这两个方法，才能将自定义的类序列化和反序列化。接下来，我们就要创建一个Person类的实例，并保存到本地文件中，和从本地文件中读取内容。

let person = Person(name: "Tom", age: 18)

//拿到一个本地文件的URL
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")

//序列化Person实例
let dataWrite = NSKeyedArchiver.archivedData(withRootObject: person)

do {
    //将数据写入文件
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}

//从本地文件读取数据
if let dataRead = try? Data(contentsOf: url!) {
    //反序列化数据，并将结果强转为Person类的实例
    let person = NSKeyedUnarchiver.unarchiveObject(with: dataRead) as! Person
    //输出内容
    print("name: \(person.name)")  //输出: name: Tom
    print("age: \(person.age)")  //输出: age: 18
} else {
    print("文件不存在，读取本地文件失败")
}

可以看出，当第一步完成之后，保存自定义类就变得非常简单了，只需要使用系统定义好的NSKeyedArchiver类和NSKeyedUnarchiver类就可以了。

Swift 4.0: Codable

接下来再看看Swift 4.0的Codable协议怎么保存自定义类。
在Swift 4.0版本，Apple推出了一个新的协议叫Codable。只要类或者结构体遵循了这个协议，就能够很方便地将类或者结构体的实例转换为JSON数据，并且不需要在类或者结构体中实现编码和解码方法，可以看出，Codable协议比NSCoding协议更加方便、简洁。废话不多说，来看看具体的实现：

class Person: Codable {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

let person = Person(name: "Tom", age: 18)

//拿到一个本地文件的URL
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")

//将Person实例转换为JSON数据
let dataWrite = try JSONEncoder().encode(person)
do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}

//从本地文件读取数据
if let dataRead = try? Data(contentsOf: url!) {
    //将数据转换为Person实例
    let person = try JSONDecoder().decode(Person.self, from: dataRead)
    //输出内容
    print("name: \(person.name)")  //输出: name: Tom
    print("age: \(person.age)")  //输出: age: 18
} else {
    print("文件不存在，读取本地文件失败")
}

可以看出，Codable协议比NSCoding协议方便很多，而且代码看起来也简洁了很多。

Codable的坑

那可能就有人想问了，既然有了Codable协议，而且还这么简洁，那么NSCoding协议的存在还有什么意义呢？这个问题博主当初也想了很久，后来在一次偶然的机会，发现了Codable协议的不足。先卖个关子，我们来看一个需求：
要求：现有一个AnimalProtocol协议，该协议有一个eat()方法，然后实现两个类Cat和Dog，这两个类都有一个类型为String的name属性，并且需要遵循AnimalProtocol协议，实现eat()方法。创建一个数组，数组中保存若干个Cat实例和Dog实例，将此数组保存到本地文件中，并从文件中读取到相应的内容。

先来看看NSCoding协议是怎么实现这个需求的：

//定义协议
protocol AnimalProtocol {
    func eat()
}

//定义Cat类
class Cat: NSObject, NSCoding, AnimalProtocol {
    var name: String

    init(name: String) {
        self.name = name
    }

    func eat() {
        print("cat \(self.name) eat")
    }

    func encode(with aCoder: NSCoder) {
        aCoder.encode(name, forKey: "name")
    }

    required init?(coder aDecoder: NSCoder) {
        self.name = aDecoder.decodeObject(forKey: "name") as! String
    }
}

//定义Dog类
class Dog: NSObject, NSCoding, AnimalProtocol {
    var name: String

    init(name: String) {
        self.name = name
    }

    func eat() {
        print("dog \(self.name) eat")
    }

    func encode(with aCoder: NSCoder) {
        aCoder.encode(name, forKey: "name")
    }

    required init?(coder aDecoder: NSCoder) {
        self.name = aDecoder.decodeObject(forKey: "name") as! String
    }
}

//创建一个空数组(因为这个数组要同时保存两个类的实例，所以需要以它们共同的一个类型来创建数组)
var animalArray = [AnimalProtocol]()

//然后用循环创建多个Cat和Dog实例，并加入数组中
for i in 1...3 {
    let cat = Cat(name: "cat\(i)")
    let dog = Dog(name: "dog\(i)")

    animalArray.append(cat)
    animalArray.append(dog)
}

let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")

let dataWrite = NSKeyedArchiver.archivedData(withRootObject: animalArray)
do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}

if let dataRead = try? Data(contentsOf: url!) {
    let newArray = NSKeyedUnarchiver.unarchiveObject(with: dataRead) as! [AnimalProtocol]

    for item in newArray {
        item.eat()
    }
}
//输出如下
/*
cat cat1 eat
dog dog1 eat
cat cat2 eat
dog dog2 eat
cat cat3 eat
dog dog3 eat
*/

可以看到，虽然步骤有一点点麻烦，但是还是能很方便地实现我们的需求的，接下来，我们再看看Codable协议是怎么做的吧。
先上代码：

//定义协议
protocol AnimalProtocol: Codable {
    func eat()
}

//定义Cat类
class Cat: AnimalProtocol {
    var name: String

    init(name: String) {
        self.name = name
    }

    func eat() {
        print("cat \(self.name) eat")
    }
}

//定义Dog类
class Dog: AnimalProtocol {
    var name: String

    init(name: String) {
        self.name = name
    }

    func eat() {
        print("dog \(self.name) eat")
    }
}

var animalArray = [AnimalProtocol]()

for i in 1...3 {
    let cat = Cat(name: "cat\(i)")
    let dog = Dog(name: "dog\(i)")

    animalArray.append(cat)
    animalArray.append(dog)
}

let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")

let dataWrite = try JSONEncoder().encode(animalArray)

do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}

if let dataRead = try? Data(contentsOf: url!) {
    let newArray = try JSONDecoder().decode([AnimalProtocol].self, from: dataRead)

    for item in newArray {
        item.eat()
    }
} else {
    print("文件不存在，读取本地文件失败")
}

看代码没错，而且能通过编译，但是一运行，直接crash。还报了一个莫名其妙的错误，错误是这样写的：fatal error: Array does not conform to Encodable because AnimalProtocol does not conform to Encodable.: file /Library/Caches/com.apple.xbs/Sources/swiftlang/swiftlang-900.0.65/src/swift/stdlib/public/core/Codable.swift, line 3962
2017-10-14 19:43:37.565213+0800 study[5383:411423] fatal error: Array does not conform to Encodable because AnimalProtocol does not conform to Encodable.: file /Library/Caches/com.apple.xbs/Sources/swiftlang/swiftlang-900.0.65/src/swift/stdlib/public/core/Codable.swift, line 3962
我去！这就郁闷了，明明我的类遵循了Codable协议，你却说没有遵循，这是什么鬼，而且就算用扩展让Array遵循协议也不可以

extension Array: Codable {
}

难道是遇到鬼了？不会吧！
后来博主请教导师，才知道原来这是Codable的一个不足点。遵循了Codable协议的类的数组，其中的元素必须为同一个类型。虽然这里是用协议类型去创建的数组，但其元素却是遵循了该协议类型的类的实例。所以本质上不尽相同。

如果在这里将AnimalProtocol协议改成一个类的话，虽然在运行时不会崩溃，但却无法将其向下转换为其子类了。代码如下：

//定义父类
class Animal: Codable {
    func eat() {
        print("Animal")
    }

}

//定义Cat类
class Cat: Animal {
    var name: String

    init(name: String) {
        self.name = name
        super.init()
    }

    required init(from decoder: Decoder) throws {
        fatalError("init(from:) has not been implemented")
    }

    override func eat() {
        print("cat \(self.name) eat")
    }
}

//定义Dog类
class Dog: Animal {
    var name: String

    init(name: String) {
        self.name = name
        super.init()
    }

    required init(from decoder: Decoder) throws {
        fatalError("init(from:) has not been implemented")
    }

    override func eat() {
        print("dog \(self.name) eat")
    }
}

var animalArray = [Animal]()

for i in 1...3 {
    let cat = Cat(name: "cat\(i)")
    let dog = Dog(name: "dog\(i)")

    animalArray.append(cat)
    animalArray.append(dog)
}

let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")

let dataWrite = try JSONEncoder().encode(animalArray)

do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}

if let dataRead = try? Data(contentsOf: url!) {
    let newArray = try JSONDecoder().decode([Animal].self, from: dataRead)

    for item in newArray {
        if item is Cat {
            (item as! Cat).eat()
        } else if item is Dog {
            (item as! Dog).eat()
        } else {
            item.eat()
        }
    }
} else {
    print("文件不存在，读取本地文件失败")
}
/*
输出结果为：
Animal
Animal
Animal
Animal
Animal
Animal
*/

以上便是博主个人的一些看法，如有错误，还请各位看客纠正。