精通iOS Core Data：进阶指南

5星 · 超过95%的资源需积分: 10 101 浏览量更新于2024-07-26 收藏 22.62MB PDF 举报

"Pro Core Data for iOS - 学习Core Data必读之书，第二版" 这本书是iOS开发者深入理解并掌握Core Data的重要参考资料。Core Data是Apple提供的一种数据管理框架，用于处理应用程序中的对象图和持久化存储。它简化了数据模型的创建、数据的管理以及数据与用户界面的绑定，是iOS和macOS开发中不可或缺的一部分。在"Getting Started"章节，作者将引导读者了解Core Data的基本概念和工作流程，包括如何设置项目并首次使用Core Data。这一部分通常会涵盖Xcode中的数据模型编辑器，以及如何创建第一个数据模型。 "Understanding Core Data"章节深入探讨了Core Data架构，包括实体、属性、关系以及上下文（ManagedObjectContext）等核心概念。读者将学习到如何定义实体之间的关系，以及如何通过NSManagedObject子类来操作数据。 "Storing Data: SQLite and Other Options"章节将介绍Core Data支持的存储机制，主要讲解SQLite作为默认后端数据库的工作方式，以及如何选择适合应用的存储选项。此外，可能还会讨论其他非关系型数据库的集成。 "Creating a Data Model"章节详细介绍了如何设计和创建数据模型，包括实体、属性和关系的配置，以及逆向工程从现有数据生成数据模型的方法。 "Working with Data Objects"章节涵盖了如何创建和管理NSManagedObject实例，包括插入、更新、删除操作，以及事务处理和并发控制。 "Refining Result Sets"章节讨论了查询优化，如使用NSPredicate构建复杂查询，以及如何使用排序和分组来定制检索结果。 "Tuning Performance and Memory Usage"章节提供了提高Core Data性能和管理内存的策略，包括批处理操作、懒加载、缓存策略等。 "Versioning and Migrating Data"章节是关于数据模型版本管理和迁移的，这对于应用程序的升级和扩展至关重要。读者将学习如何处理数据模型的变化，并无损地迁移用户数据。 "Managing TableViews Using a FetchedResultsController"章节展示了如何利用FetchedResultsController与表格视图（UITableView）进行集成，实现高效的数据展示和响应式用户交互。 "Using Core Data in Advanced Applications"章节则探讨了更高级的主题，如后台处理、多线程、云同步等，帮助读者应对大型或复杂应用的挑战。这本书全面覆盖了从基础到进阶的Core Data知识，旨在帮助iOS开发者充分利用这一强大的框架，构建高效、稳定且数据驱动的应用程序。通过阅读此书，读者不仅可以学会如何使用Core Data，还能理解其背后的原理，从而更好地解决实际开发中遇到的问题。

CHAPTER 1: Getting Started

The implementation of the MasterViewController, found in MasterViewController.m,

shows how to interact with the Core Data framework to store and retrieve data. The

MasterViewController implementation provides an explicit getter for the

fetchedResultsController property that preconfigures it to fetch data from the data store.

The first step in creating the fetch controller consists of creating a request that will retrieve

Event entities, as shown in this code from the fetchedResultsController accessor:

NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];

NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event"

inManagedObjectContext:self.managedObjectContext];

[fetchRequest setEntity:entity];

The result of the request can be ordered using the sort descriptor from the Cocoa

Foundation framework. The sort descriptor defines the field to use for sorting and

whether the sort is ascending or descending. In this case, you sort by descending

chronological order, like so:

NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:

@"timeStamp" ascending:NO];

NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor, nil];

[fetchRequest setSortDescriptors:sortDescriptors];

Once you define the request, you can use it to construct the fetch controller. Because

the MasterViewController implements NSFetchedResultsControllerDelegate, it can be

set as the NSFetchedResultsController’s delegate so that it is automatically notified as

the result set changes and so that it updates its view appropriately. You could get the

same results by invoking the executeFetchRequest of the managed object context, but

you would not benefit from the other advantages that come from using the

NSFetchedResultsController such as the seamless integration with the UITableView, as

you’ll see later in this section and in Chapter 9. Here is the code that constructs the

fetch controller:

NSFetchedResultsController *aFetchedResultsController = [[NSFetchedResultsController

alloc] initWithFetchRequest:fetchRequest managedObjectContext:

self.managedObjectContext sectionNameKeyPath:nil cacheName:@"Master"];

aFetchedResultsController.delegate = self;

self.fetchedResultsController = aFetchedResultsController;

NOTE: You may have noticed that the initWithFetchRequest shown earlier uses a

parameter called cacheName. You could pass nil for the cacheName parameter to prevent

caching, but naming a cache indicates to Core Data to check for a cache with a name matching

the passed name and see whether it already contains the same fetch request definition. If it does

find a match, it will reuse the cached results. If it finds a cache entry by that name but the

request doesn’t match, then it is deleted. If it doesn’t find it at all, then the request is executed,

and the cache entry is created for the next time. This is obviously an optimization that aims to

prevent executing the same request over and over. Core Data manages its caches intelligently so

that if the results are updated by another call, the cache is removed if affected.

CHAPTER 1: Getting Started

Finally, you tell the controller to execute its query to start retrieving results. To do this,

use the performFetch method.

NSError *error = nil;

if (![self.fetchedResultsController performFetch:&error]) {

NSLog(@"Unresolved error %@, %@", error, [error userInfo]);

abort();

}

You can see the entire getter method for fetchedResultsController in Listing 1–1.

Listing 1–1. The Entire Getter Method for fetchedResultsController

- (NSFetchedResultsController *)fetchedResultsController

{

if (__fetchedResultsController != nil)

{

return __fetchedResultsController;

}

Set up the fetched results controller.

// Create the fetch request for the entity.

NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];

// Edit the entity name as appropriate.

NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event"

inManagedObjectContext:self.managedObjectContext];

[fetchRequest setEntity:entity];

// Set the batch size to a suitable number.

[fetchRequest setFetchBatchSize:20];

// Edit the sort key as appropriate.

NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"timeStamp"

ascending:NO];

NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor, nil];

[fetchRequest setSortDescriptors:sortDescriptors];

// Edit the section name key path and cache name if appropriate.

// nil for section name key path means "no sections".

NSFetchedResultsController *aFetchedResultsController = [[NSFetchedResultsController

alloc] initWithFetchRequest:fetchRequest managedObjectContext:self.managedObjectContext

sectionNameKeyPath:nil cacheName:@"Master"];

aFetchedResultsController.delegate = self;

self.fetchedResultsController = aFetchedResultsController;

NSError *error = nil;

if (![self.fetchedResultsController performFetch:&error])

{

Replace this implementation with code to handle the error appropriately.

abort() causes the application to generate a crash log and terminate. You should

not use this function in a shipping application, although it may be useful during

development. If it is not possible to recover from the error, display an alert panel

that instructs the user to quit the application by pressing the Home button.

CHAPTER 1: Getting Started

NSLog(@"Unresolved error %@, %@", error, [error userInfo]);

abort();

}

return __fetchedResultsController;

}

NSFetchedResultsController behaves as a collection of managed objects, similar to an

NSArray, which makes it easy to use. In fact, it exposes a read-only property called

fetchedObjects that is of type NSArray to make things even easier to access the objects

it fetches. The MasterViewController class, which also extends UITableViewController,

demonstrates just how suited the NSFetchedResultsController is to manage the table’s

content.

Inserting New Objects

A quick glance at the insertNewObject: method shows how new events (the managed

objects) are created and added to the persistent store. Managed objects are defined by

the entity description from the data model and can live only within a context. The first

step is to get a hold of the current context as well as the entity definition. In this case,

instead of explicitly naming the entity, you reuse the entity definitions that are attached

to the fetched results controller:

NSManagedObjectContext *context = [self.fetchedResultsController managedObjectContext];

NSEntityDescription *entity = [[self.fetchedResultsController fetchRequest] entity];

Now that you’ve gathered all the elements needed to bring the new managed object to

existence, you create the Event object and set its timeStamp value.

NSManagedObject *newManagedObject = [NSEntityDescription

insertNewObjectForEntityForName:[entity name] inManagedObjectContext:context];

[newManagedObject setValue:[NSDate date] forKey:@"timeStamp"];

The last step of the process is to tell Core Data to save changes to its context. The

obvious change is the object you just created, but keep in mind that calling the save.

method will also affect any other unsaved changes to the context.

NSError *error = nil;

if (![context save:&error]) {

NSLog(@"Unresolved error %@, %@", error, [error userInfo]);

abort();

}

The complete method for inserting the new Event object is shown in Listing 1–2.

Listing 1–2. The Complete Method for Inserting the New Event Object

- (void)insertNewObject {

// Create a new instance of the entity managed by the fetched results controller.

NSManagedObjectContext *context = [self.fetchedResultsController

managedObjectContext];

NSEntityDescription *entity = [[self.fetchedResultsController fetchRequest] entity];

NSManagedObject *newManagedObject = [NSEntityDescription

insertNewObjectForEntityForName:[entity name] inManagedObjectContext:context];

CHAPTER 1: Getting Started

// If appropriate, configure the new managed object.

// Normally you should use accessor methods, but using KVC here avoids the need to add

a custom class to the template.

[newManagedObject setValue:[NSDate date] forKey:@"timeStamp"];

// Save the context.

NSError *error = nil;

if (![context save:&error]) {

NSLog(@"Unresolved error %@, %@", error, [error userInfo]);

abort();

}

Initializing the Managed Context

Obviously, none of this can happen without initializing the managed context first. This is

the role of the application delegate. In a Core Data–enabled application, the delegate

must expose three properties.

@property (readonly, strong, nonatomic) NSManagedObjectContext *managedObjectContext;

@property (readonly, strong, nonatomic) NSManagedObjectModel *managedObjectModel;

@property (readonly, strong, nonatomic) NSPersistentStoreCoordinator

*persistentStoreCoordinator;

Note that they are all marked as read-only, which prevents any other component in the

application from setting them directly. A closer look at BasicApplicationAppDelegate.m

shows that all three properties have explicit getter methods.

First, the managed object model is derived from the data model

(BasicApplication.xcdatamodel) and loaded.

- (NSManagedObjectModel *)managedObjectModel

{

if (__managedObjectModel != nil)

{

return __managedObjectModel;

}

NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"BasicApplication"

withExtension:@"momd"];

__managedObjectModel = [[NSManagedObjectModel alloc]

initWithContentsOfURL:modelURL];

return __managedObjectModel;

}

Then a persistent store is created to support the model. In this case, as well as in most

Core Data scenarios, the persistent store is backed by a SQLite database. The managed

object model is a logical representation of the data store, while the persistent store is

the materialization of that data store.

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator {

if (__persistentStoreCoordinator != nil) {

return __persistentStoreCoordinator;

}

剩余397页未读，继续阅读

勇敢的小鸟

粉丝: 2
资源: 7

精通iOS Core Data：进阶指南

Pro Core Data for IOS

Core Data iOS iOS iOS

IOS CoreData使用

Pro Core Data for iOS.pdf

Pro Core Data for iOS, Second Edition

《Pro Core Data for iOS(Second Edition)》电子书

Apress.Pro.Core.Data.for.iOS.Jan.2011

Apress.Pro.Core.Data.for.iOS.2nd.Ed

iOS应用高效数据存储与持久化指南：Pro-Core-Data-for-iOS.pdf

Apress.Pro.Core.Data.for.iOS.Data.Access.and.Persistence.Engine.for.iPhone.iPad.and.iPod.touch

最新资源