走进Core Data的世界

发表于 | 分类于 | | 阅读次数: |
字数统计: 35k | 阅读时长 ≈ 35 mins.

Core Data作为一个OS X和iOS中自带的数据存储框架，很早就存在了。因其存在一些缺点使得很多人放弃使用而采用其它方案。但苹果依然在每个iOS版本中不断对其改进，例如在iOS 8中加入了BetchUpdate，解决了之前一直令人诟病的批量更新问题，使得Core Data更为强大。

0. Core Data Stack

先说说Core Data Stack吧，主要有以下个类组成：

  • NSManagedObjectModel
  • NSPersistentStore
  • NSPersistentStoreCoordinator
  • NSManagedObjectContext

NSManagedObjectModel：代表了数据模型，也就是Xcode中创建的.xcdatamodel文件中所表诉的信息。
NSPersistentStore：是数据存放的地方，可以是SQLite、XML（仅OS X）、二进制文件、或仅内存中。
NSPersistentStoreCoordinator：是协调者，用来在NSManagedObjectContext和NSPersistentStore之间建立连接。
NSManagedObjectContext：是应用程序唯一需要访问的类，其中提供了对数据操作的一系列接口。

另外Core Data中最常用的类就是NSFetchRequest和NSManagedObject。
NSFetchRequest用来执行查询，NSManagedObject就是模型对象。

废话不多说，下面来分条介绍Core Data具有哪些特性。

1. 图形用户界面

Xcode为Core Data提供的图形界面是其方便使用的原因之一，使用图形界面可以做以下事情：

  1. 创建实体极其属性
  2. 创建关联
  3. 查看对象图
  4. 设置二进制数据分离存储
  5. 完成常见的数据迁移操作

等等……

2. Fetch Template

对于一些固定的Fetch操作，可以用Xcode图形化的创建Fetch Template，来减少代码的编写。

通过FetchTemplate创建FetchRequest

1
let fetchRequest = managedObjectModel.fetchRequestTemplateForName("templateName")

3. Fetch Result Type

Fetch数据的结果可以很方便的按需求选择类型，可以以一下四种类型呈现：

  • NSManagedObjectResultType：直接返回NSManagedObject对象
  • NSCountResultType：返回总数，出于性能考虑，在只需要总数不需要具体对象数据时，用这个类型。
  • NSDictionaryResultType：将数据用字典类型返回。
  • NSManagedObjectIDResultType：返回所有NSManagedObject对象的唯一标识符

4. NSPredicate

NSPredicate和NSFetchRequest配合可以实现各种各样需求的查询，非常强大。

1
2
let dogFetch = NSFetchRequest(entityName: "Dog")
dogFetch.predicate = NSPredicate(format: "name == %@", dogName)

以上代码为查询name为dogName变量值的Dog对象

出于性能考虑，有多个条件时，应该把最简单的条件放到最前，例如：
(salary > 5000000) AND (lastName LIKE 'Quincey')
的性能要比
(lastName LIKE 'Quincey') AND (salary > 5000000)
好。

5. Data Validation

Core Data的大部分类型都能通过图形界面方便的设置Validation

比如上图，图中的属性是一个Double类型，可以用面板为它设置最大值最小值。当保存的值不在这个范围内时，会抛出一个异常。

也可以在NSManagedObject的子类中实现validate<属性名>:方法来自定义Validation

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func validateAge(value: AutoreleasingUnsafeMutablePointer<AnyObject?>) throws {
    if value == nil {
        return
    }
    
    let valueNumber = value.memory as! NSNumber
    if valueNumber.floatValue > 0.0 {
        return
    }
    let errorStr = NSLocalizedString("Age must be greater than zero", tableName: "Employee", comment: "validation: zero age error")
    let userInfoDict = [NSLocalizedDescriptionKey: errorStr]
    let error = NSError(domain: "EMPLOYEE_ERROR_DOMAIN", code: 1123, userInfo: userInfoDict)
    throw error
}

也可以实现validateForInsert:、validateForUpdate:、validateForDelete:方法来在，数据插入、更新、删除等操作时进行Validation，这里就不细讲了。

6. NSFetchedResultController

因为Core Data中的数据大部分都会由UITableView来展示，苹果工程师开发了NSFetchedResultController这个组件来使得写很少的代码就能让数据和UITableView绑定，并且保证了良好的性能。

创建NSFetchedResultController：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func initializeFetchedResultsController() {
    let request = NSFetchRequest(entityName: "Person")
    let departmentSort = NSSortDescriptor(key: "department.name", ascending: true)
    let lastNameSort = NSSortDescriptor(key: "lastName", ascending: true)
    request.sortDescriptors = [departmentSort, lastNameSort]
    
    let moc = self.dataController.managedObjectContext
    self.fetchedResultsController = NSFetchedResultsController(fetchRequest: request, managedObjectContext: moc, sectionNameKeyPath: "department.name", cacheName: "rootCache")
    self.fetchedResultsController.delegate = self
    
    do {
        try self.fetchedResultsController.performFetch()
    } catch {
        fatalError("Failed to initialize FetchedResultsController: \(error)")
    }
}

和UITableView绑定：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func configureCell(cell: UITableViewCell, indexPath: NSIndexPath) {
    let employee = self.fetchedResultsController.objectAtIndexPath(indexPath) as! AAAEmployeeMO
    // Populate cell from the NSManagedObject instance
    print("Object for configuration: \(object)")
}
 
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCellWithIdentifier("cellIdentifier", forIndexPath: indexPath) as! UITableViewCell
    // Set up the cell
    self.configureCell(cell, indexPath: indexPath)
    return cell
}
 
override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
    return self.fetchedResultsController.sections!.count
}
 
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    let sections = self.fetchedResultsController.sections as! [NSFetchedResultsSesionInfo]
    let sectionInfo = sections[section]
    return sectionInfo.numberOfObjects
}

UITableView监听数据变化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
func controllerWillChangeContent(controller: NSFetchedResultsController) {
    self.tableView.beginUpdates()
}
 
func controller(controller: NSFetchedResultsController, didChangeSection sectionInfo: NSFetchedResultsSectionInfo, atIndex sectionIndex: Int, forChangeType type: NSFetchedResultsChangeType) {
    switch type {
    case .Insert:
        self.tableView.insertSections(NSIndexSet(index: sectionIndex), withRowAnimation: .Fade)
    case .Delete:
        self.tableView.deleteSections(NSIndexSet(index: sectionIndex), withRowAnimation: .Fade)
    case .Move:
        break
    case .Update:
        break
    }
}
 
func controller(controller: NSFetchedResultsController, didChangeObject anObject: NSManagedObject, atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType, newIndexPath: NSIndexPath?) {
    switch type {
    case .Insert:
        self.tableView.insertRowsAtIndexPaths([newIndexPath!], withRowAnimation: .Fade)
    case .Delete:
        self.tableView.deleteRowsAtIndexPaths([indexPath!], withRowAnimation: .Fade)
    case .Update:
        self.configureCell(self.tableView.cellForRowAtIndexPath(indexPath!)!, indexPath: indexPath!)
    case .Move:
        self.tableView.deleteRowsAtIndexPaths([indexPath!], withRowAnimation: .Fade)
        self.tableView.insertRowsAtIndexPaths([indexPath!], withRowAnimation: .Fade)
    }
}
 
func controllerDidChangeContent(controller: NSFetchedResultsController) {
    self.tableView.endUpdates()
}

7. 异步Fetch

有时Fetch数据的时间会很长，为了避免其阻塞UI，可以使用异步Fetch。这是iOS 8新增的API——NSAsynchronousFetchRequest。不要被它的名字误导了，它并不继承于NSFetchRequest，而是继承于NSPersistentStoreRequest。

1
2
3
4
5
6
7
8
9
10
11
12
fetchRequest = NSFetchRequest(entityName: "Employee")

asycnFetchRequest = NSAsynchronousFetchRequest(fetchRequest: fetchRequest) { [unowned self] result in
    self.employees = result.finalResult as! [Employee]
    self.tableView.reloadData()
}

do {
    try context.executeRequest(asycnFetchRequest)
} catch let error as NSError {
    print("Could not fetch \(error), \(error.userInfo)")
}

如上代码所示，通过NSAsynchronousFetchRequest可以异步的执行一个NSFetchRequest，并在执行结束后回调闭包。

8. Auto Migration

Core Data对一些常见的，不是特别复杂的结构变动支持自动迁移。
一些比较复杂的结构变动也可以在Xcode图形界面中去编辑迁移规则，这样也可以不写代码实现数据迁移。
对于特别复杂的，就自己编写代码来手工迁移吧。

数据迁移部分将来会单独研究。

9. NSUndoManager

Core Data支持用NSUndoManager来回退操作。

10. iCloud支持

Core Data支持方便的将全部或部分数据同步到iCloud中。如果APP中有这样的需求，那么所有本地数据存储方案中，Core Data肯定是首选。

11. Batch Update

有时，我们希望对所有对象的某一个属性值进行改变，也就是批量更新。如果先把这些对象从Core Data中全部读取出来，遍历改变他们的值，然后保存更改，这种操作费时又费性能。
iOS 8后引进了Batch Update，这种方式可以批量更新Core Data中的对象而不需要把它们读入内存。
Batch Update不需要经过NSManagedObjectContext，而是直接操作NSPersistenceStore。

1
2
3
4
5
6
7
8
9
10
11
12
13
let batchUpdate = NSBatchUpdateRequest(entityName: "Employee")

batchUpdate.propertiesToUpdate = ["favorite": NSNumber(bool: true)]
batchUpdate.affectedStores = context.persistentStoreCoordinator!.persistentStores

batchUpdate.resultType = .UpdatedObjectsCountResultType

do {
    let batchResult = try context.executeRequest(batchUpdate) as! NSBatchUpdateResult
    print("Records updated \(batchResult.result!)")
} catch let error as NSError {
    print("Could not update \(error), \(error.userInfo)")
}

如上面代码，为Employee这个实体创建一个NSBatchUpdateRequest对象，通过propertiesToUpdate来设置要改变的属性名和属性值。
通过设置affectedStores来决定要在哪些NSPersistenceStore上生效。

12. Batch Delete

NSBatchDeleteRequest是iOS 9新增的API，用法和NSBatchUpdateRequest差不多，它会直接从PersistenceStore中删除数据，省去先载入到内存，删除，再写回Store的过程。

13. NSExpression

NSExpression也可以和NSFetchRequest配合使用，使用NSExpression内置的一些函数，例如求和“sum:”，求平均数“average:”等等
可以在查询数据的时候带来很好的性能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let fetchRequest = NSFetchRequest(entityName: "Venue")
 
fetchRequest.resultType = .DictionaryResultType

let sumExpressionDesc = NSExpressionDescription()
sumExpressionDesc.name = "sumDeals"

sumExpressionDesc.expression = NSExpression(forFunction: "sum:", arguments:[NSExpression(forKeyPath: "specialCount")]) sumExpressionDesc.expressionResultType = .Integer32AttributeType
fetchRequest.propertiesToFetch = [sumExpressionDesc]

do {
	let results = try coreDataStack.context
.executeFetchRequest(fetchRequest) as! [NSDictionary]
	let resultDict = results.first!
	let numDeals = resultDict["sumDeals"] 
	numDealsLabel.text = "\(numDeals!) total deals"
} catch let error as NSError {
	print("Could not fetch \(error), \(error.userInfo)")
}

14. Instruments

Xcode的Instruments中带有专门调试Core Data的工具，帮助排查使用Core Data遇到的问题。

15. Private Queue Context

当执行一些耗时较长的操作时，例如插入、更新大量数据，用主队列Context会阻塞UI，于是需要将这些操作放到非主线程去做。而Core Data的Context执行的操作都不是线程安全的，如果用GCD这种去将操作放在后台执行会出现不可预期的问题。
Core Data为解决这个问题提供了Private Queue Context，也就是后台Context，可以让后台Context去执行这些操作，从PrivateQueue这个名字上也能看出，这个Queue只有创建它的Context可以访问，Context执行的操作都会限制在这一个Queue上，避免线程安全问题。

1
2
3
4
5
6
7
8
9
10
11
12

let privateContext = NSManagedObjectContext(concurrencyType: .PrivateQueueConcurrencyType)
privateContext.persistentStoreCoordinator = coreDataStack.context.persistentStoreCoordinator

privateContext.performBlock {
	let results: [AnyObject]
	do {
		results = try self.coreDataStack.context .executeFetchRequest(self.surfJournalFetchRequest())
	} catch {
		let nserror = error as NSError print("ERROR: \(nserror)") results = []
	}
}

看上面代码，通过给concurrencyType传入.PrivateQueueConcurrencyType即可创建一个PrivateQueueContext，把MainQueueContext的persistentStoreCoordinator赋给它，即可让PrivateQueueContext也可以访问MainQueueContext下的持久化存储区。

在performBlock的末尾部分，可以向主队列追加一些操作来更新UI

1
2
3
4
5
6
7
8
9
	...
	
	dispatch_async(dispatch_get_main_queue(), {
		self.navigationItem.leftBarButtonItem =
		self.exportBarButtonItem()
		print("Export Path: \(exportFilePath)") 		self.showExportFinishedAlertView(exportFilePath)
	})

} // closing brace for performBlock()

16. Child Context

Core Data中的每一个NSManagedObjectContext都有一个父存储区（Parent Store），Context以这个父存储区作为持久化存储区（PersistenceStore）与之交互。
最上层Context的ParentStore就是NSPersistentStoreCoordinator。
每个子Context就以它的父Context为PersistenceStore。

可以为主Context创建一些Child Context去做一些临时的操作，操作执行完以后会保存到主Context，当主Context执行了保存时才会把数据真正保存到存储区。

还有一种用法是可以在程序中创建两个Context，一个主队列Context，一个PrivateQueueContext，然后令主队列Context作为PrivateQueueContext的子Context，这样主队列Context的操作会先保存到PrivateQueueContext中，再由PrivateQueueContext在后台慢慢的保存到PersistenceStore中，来保证界面的性能良好。

关于Child Context本文先不做详细研究。

17. Performance

Core Data的性能方面苹果是花了不少功夫的，比如说采用了faulting技术。除了iOS 7下批量更新的问题，iOS 8以上的Core Data性能应该是不错的。在Core Data的使用中，有很多优化点可以保证良好的性能，本文暂先不做介绍了。