MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Objective-C中的Core Data数据库操作

2023-09-102.2k 阅读

Core Data 简介

Core Data 是 iOS 和 macOS 开发中用于管理应用程序数据模型的框架。它提供了一种面向对象的方式来处理数据持久化，使得开发者可以轻松地将数据存储到磁盘上，并在需要时进行检索和更新。Core Data 不仅仅是一个简单的数据库框架，它还涵盖了数据建模、对象管理、数据持久化等多个方面。

在 Objective-C 开发中，Core Data 允许开发者以对象的形式来操作数据，而不是直接编写 SQL 语句。这大大简化了数据处理的流程，尤其是在处理复杂的数据关系时。例如，在一个社交应用中，可能会有用户、好友、动态等多种数据类型，这些数据之间存在着复杂的关联关系，使用 Core Data 可以很方便地对这些关系进行建模和管理。

Core Data 数据模型

  1. 实体（Entity）
    • 实体是 Core Data 数据模型的基本构建块，类似于数据库中的表。每个实体都代表应用程序中的一种数据类型。例如，在一个待办事项应用中，可以有一个“Task”实体，用来表示具体的待办事项。
    • 在 Objective - C 中，我们通过 NSEntityDescription 类来表示实体。以下是创建一个简单“Task”实体的代码示例：
// 创建一个实体描述
NSEntityDescription *taskEntity = [NSEntityDescription entityForName:@"Task" inManagedObjectContext:managedObjectContext];
  1. 属性（Attribute）
    • 属性定义了实体所具有的特性。对于“Task”实体，可能会有“title”（标题）、“isCompleted”（是否完成）等属性。属性有不同的数据类型，如字符串（NSString 对应的 NSStringAttributeType）、布尔值（NSNumber 对应的 NSBooleanAttributeType）等。
    • 以下是为“Task”实体添加属性的代码示例：
// 创建标题属性
NSAttributeDescription *titleAttribute = [[NSAttributeDescription alloc] init];
titleAttribute.name = @"title";
titleAttribute.attributeType = NSStringAttributeType;

// 创建是否完成属性
NSAttributeDescription *isCompletedAttribute = [[NSAttributeDescription alloc] init];
isCompletedAttribute.name = @"isCompleted";
isCompletedAttribute.attributeType = NSBooleanAttributeType;

// 将属性添加到实体
[taskEntity.properties addObject:titleAttribute];
[taskEntity.properties addObject:isCompletedAttribute];
  1. 关系（Relationship）
    • 关系用于定义不同实体之间的联系。例如，在一个博客应用中，“Post”（文章）实体和“Author”（作者）实体之间可能存在“一对多”的关系，即一个作者可以有多篇文章。
    • 有两种主要的关系类型：一对一（NSOneToOneRelationshipType）和一对多（NSOneToManyRelationshipType）。以下是定义“Post”和“Author”之间一对多关系的代码示例：
// 创建 Post 实体
NSEntityDescription *postEntity = [NSEntityDescription entityForName:@"Post" inManagedObjectContext:managedObjectContext];

// 创建 Author 实体
NSEntityDescription *authorEntity = [NSEntityDescription entityForName:@"Author" inManagedObjectContext:managedObjectContext];

// 创建 Post 到 Author 的关系
NSRelationshipDescription *postToAuthorRelationship = [[NSRelationshipDescription alloc] init];
postToAuthorRelationship.name = @"author";
postToAuthorRelationship.destinationEntity = authorEntity;
postToAuthorRelationship.minCount = 1;
postToAuthorRelationship.maxCount = 1;
postToAuthorRelationship.deleteRule = NSNullifyDeleteRule;

// 创建 Author 到 Post 的关系
NSRelationshipDescription *authorToPostRelationship = [[NSRelationshipDescription alloc] init];
authorToPostRelationship.name = @"posts";
authorToPostRelationship.destinationEntity = postEntity;
authorToPostRelationship.minCount = 0;
authorToPostRelationship.maxCount = NSNotFound;
authorToPostRelationship.deleteRule = NSNullifyDeleteRule;

// 将关系添加到实体
[postEntity.relationships addObject:postToAuthorRelationship];
[authorEntity.relationships addObject:authorToPostRelationship];

Core Data 栈

  1. 托管对象上下文（Managed Object Context）
    • 托管对象上下文是 Core Data 的核心部分，它管理着一组托管对象（Managed Object）。托管对象上下文就像是一个工作空间，开发者在这个空间内对数据进行创建、读取、更新和删除操作。
    • 在 Objective - C 中，我们通过 NSManagedObjectContext 类来创建和管理托管对象上下文。通常一个应用程序会有一个主上下文，用于与用户界面交互，同时可能会有一些子上下文用于后台操作。以下是创建主托管对象上下文的代码示例：
- (NSManagedObjectContext *)managedObjectContext {
    if (_managedObjectContext!= nil) {
        return _managedObjectContext;
    }

    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (coordinator!= nil) {
        _managedObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
        [_managedObjectContext setPersistentStoreCoordinator:coordinator];
    }
    return _managedObjectContext;
}
  1. 持久化存储协调器（Persistent Store Coordinator）
    • 持久化存储协调器负责管理应用程序的持久化存储。它可以处理多个不同类型的持久化存储，如 SQLite 数据库、二进制文件等。
    • 在 Objective - C 中，通过 NSPersistentStoreCoordinator 类来实现。以下是创建持久化存储协调器的代码示例：
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator {
    if (_persistentStoreCoordinator!= nil) {
        return _persistentStoreCoordinator;
    }

    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"MyApp.sqlite"];

    NSError *error = nil;
    _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
        NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
        abort();
    }

    return _persistentStoreCoordinator;
}
  1. 托管对象模型（Managed Object Model）
    • 托管对象模型定义了应用程序的数据结构，包括实体、属性和关系。它是 Core Data 栈的基础，持久化存储协调器和托管对象上下文都依赖于它。
    • 在 Objective - C 中，通过 NSManagedObjectModel 类来表示。通常，我们可以从应用程序的资源文件（.momd 文件）中加载托管对象模型。以下是加载托管对象模型的代码示例：
- (NSManagedObjectModel *)managedObjectModel {
    if (_managedObjectModel!= nil) {
        return _managedObjectModel;
    }
    NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"MyApp" withExtension:@"momd"];
    _managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    return _managedObjectModel;
}

Core Data 操作

  1. 创建托管对象
    • 要在 Core Data 中创建一个新的托管对象，我们使用 NSEntityDescription 的 insertNewObjectForEntityForName:inManagedObjectContext: 方法。例如，继续以“Task”实体为例，创建一个新的待办事项：
NSManagedObjectContext *context = [self managedObjectContext];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Task" inManagedObjectContext:context];
NSManagedObject *newTask = [NSEntityDescription insertNewObjectForEntityForName:@"Task" inManagedObjectContext:context];
[newTask setValue:@"Learn Core Data" forKey:@"title"];
[newTask setValue:@NO forKey:@"isCompleted"];

NSError *error = nil;
if (![context save:&error]) {
    NSLog(@"Error saving context: %@", error);
}
  1. 读取托管对象
    • 读取数据通常使用 NSFetchRequest。NSFetchRequest 定义了要获取的数据的条件、排序等。例如，要获取所有未完成的待办事项：
NSManagedObjectContext *context = [self managedObjectContext];
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Task"];
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"isCompleted == NO"];
[fetchRequest setPredicate:predicate];

NSError *error = nil;
NSArray *tasks = [context executeFetchRequest:fetchRequest error:&error];
if (tasks == nil) {
    NSLog(@"Error fetching tasks: %@", error);
} else {
    for (NSManagedObject *task in tasks) {
        NSString *title = [task valueForKey:@"title"];
        NSLog(@"Task: %@", title);
    }
}
  1. 更新托管对象
    • 更新托管对象很简单，获取到要更新的对象后，直接修改其属性值，然后保存托管对象上下文。例如，将一个待办事项标记为已完成：
NSManagedObjectContext *context = [self managedObjectContext];
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Task"];
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"title == %@", @"Learn Core Data"];
[fetchRequest setPredicate:predicate];

NSError *error = nil;
NSArray *tasks = [context executeFetchRequest:fetchRequest error:&error];
if (tasks!= nil && tasks.count > 0) {
    NSManagedObject *task = tasks[0];
    [task setValue:@YES forKey:@"isCompleted"];

    if (![context save:&error]) {
        NSLog(@"Error saving context: %@", error);
    }
}
  1. 删除托管对象
    • 删除托管对象使用 NSManagedObjectContext 的 deleteObject: 方法。例如，删除一个待办事项：
NSManagedObjectContext *context = [self managedObjectContext];
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Task"];
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"title == %@", @"Learn Core Data"];
[fetchRequest setPredicate:predicate];

NSError *error = nil;
NSArray *tasks = [context executeFetchRequest:fetchRequest error:&error];
if (tasks!= nil && tasks.count > 0) {
    NSManagedObject *task = tasks[0];
    [context deleteObject:task];

    if (![context save:&error]) {
        NSLog(@"Error saving context: %@", error);
    }
}

高级 Core Data 功能

  1. 批量操作
    • 在处理大量数据时，批量操作可以提高性能。例如，我们要一次性创建多个待办事项，可以使用 NSBatchInsertRequest 和 NSBatchDeleteRequest。以下是批量创建待办事项的代码示例：
NSManagedObjectContext *context = [self managedObjectContext];
NSArray *taskTitles = @[@"Task 1", @"Task 2", @"Task 3"];

NSMutableArray *newTasks = [NSMutableArray array];
for (NSString *title in taskTitles) {
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"Task" inManagedObjectContext:context];
    NSManagedObject *newTask = [NSEntityDescription insertNewObjectForEntityForName:@"Task" inManagedObjectContext:context];
    [newTask setValue:title forKey:@"title"];
    [newTask setValue:@NO forKey:@"isCompleted"];
    [newTasks addObject:newTask];
}

NSBatchInsertRequest *batchInsertRequest = [[NSBatchInsertRequest alloc] init];
batchInsertRequest.entity = [NSEntityDescription entityForName:@"Task" inManagedObjectContext:context];
batchInsertRequest.objects = newTasks;

NSError *error = nil;
[context executeRequest:batchInsertRequest error:&error];
if (error!= nil) {
    NSLog(@"Error batch inserting tasks: %@", error);
}
  1. 关系处理
    • 当处理实体之间的关系时，Core Data 提供了方便的方法。例如，在前面提到的“Post”和“Author”关系中，为一篇文章设置作者：
NSManagedObjectContext *context = [self managedObjectContext];

// 获取一篇文章
NSFetchRequest *postFetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Post"];
NSPredicate *postPredicate = [NSPredicate predicateWithFormat:@"title == %@", @"My First Post"];
[postFetchRequest setPredicate:postPredicate];
NSArray *posts = [context executeFetchRequest:postFetchRequest error:nil];
NSManagedObject *post = posts[0];

// 获取一个作者
NSFetchRequest *authorFetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Author"];
NSPredicate *authorPredicate = [NSPredicate predicateWithFormat:@"name == %@", @"John Doe"];
[authorFetchRequest setPredicate:authorPredicate];
NSArray *authors = [context executeFetchRequest:authorFetchRequest error:nil];
NSManagedObject *author = authors[0];

// 设置文章的作者
[post setValue:author forKey:@"author"];

NSError *saveError = nil;
if (![context save:&saveError]) {
    NSLog(@"Error saving context: %@", saveError);
}
  1. 数据迁移
    • 随着应用程序的发展，数据模型可能需要更新。Core Data 提供了数据迁移功能来处理这种情况。有两种主要的迁移类型：轻量级迁移（Lightweight Migration）和手动迁移（Manual Migration）。
    • 轻量级迁移：如果数据模型的变化比较简单，如添加或删除属性等，轻量级迁移可以自动完成。在 NSPersistentStoreCoordinator 添加持久化存储时，设置 NSMigratePersistentStoresAutomaticallyOption 和 NSInferMappingModelAutomaticallyOption 选项即可。例如：
NSDictionary *options = @{
    NSMigratePersistentStoresAutomaticallyOption : @YES,
    NSInferMappingModelAutomaticallyOption : @YES
};

NSError *error = nil;
if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:options error:&error]) {
    NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
    abort();
}
  • 手动迁移：当数据模型变化较为复杂，如实体结构的重大调整等，需要手动进行迁移。这涉及到创建映射模型（Mapping Model），并编写代码来处理数据的转换。例如，假设我们将“Task”实体中的“isCompleted”属性重命名为“completed”，并且数据类型从布尔值改为整数（0 表示未完成，1 表示完成），我们需要创建一个映射模型，并在代码中处理数据转换：
// 创建映射模型
NSURL *mappingModelURL = [[NSBundle mainBundle] URLForResource:@"MyAppMapping" withExtension:@"mom"];
NSMappingModel *mappingModel = [[NSMappingModel alloc] initWithContentsOfURL:mappingModelURL];

// 创建迁移管理器
NSPersistentStoreMigrationManager *migrationManager = [[NSPersistentStoreMigrationManager alloc] initWithSourceModel:oldModel destinationModel:newModel];

// 执行迁移
NSError *migrationError = nil;
BOOL success = [migrationManager migrateStoreFromURL:sourceURL type:sourceStoreType options:sourceOptions withMappingModel:mappingModel toDestinationURL:destinationURL destinationType:destinationStoreType destinationOptions:destinationOptions error:&migrationError];
if (!success) {
    NSLog(@"Migration error: %@", migrationError);
}

Core Data 性能优化

  1. 合理使用获取请求
    • 在编写 NSFetchRequest 时，尽量减少不必要的数据获取。例如，如果只需要获取对象的某个属性，而不是整个对象，可以使用 setPropertiesToFetch: 方法来指定只获取特定属性。这可以减少内存占用和数据库查询时间。
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Task"];
[fetchRequest setPropertiesToFetch:@[@"title"]];
  1. 批量获取
    • 使用 NSFetchRequest 的 setFetchBatchSize: 方法来设置每次从数据库中获取的对象数量。这样可以避免一次性加载大量数据，特别是在处理大量数据时，可以有效降低内存峰值。
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Task"];
[fetchRequest setFetchBatchSize:50];
  1. 缓存管理
    • Core Data 本身有一定的缓存机制，但开发者也可以根据应用程序的需求进行更细致的缓存管理。例如，对于一些不经常变化的数据，可以在内存中缓存起来，避免频繁查询数据库。可以使用 NSCache 类来实现简单的缓存功能。
NSCache *taskCache = [[NSCache alloc] init];
// 从缓存中获取任务
NSArray *cachedTasks = [taskCache objectForKey:@"tasks"];
if (cachedTasks == nil) {
    // 如果缓存中没有，从数据库获取
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Task"];
    NSError *error = nil;
    cachedTasks = [context executeFetchRequest:fetchRequest error:&error];
    if (cachedTasks!= nil) {
        [taskCache setObject:cachedTasks forKey:@"tasks"];
    }
}

多线程与 Core Data

  1. 线程安全
    • Core Data 在多线程环境下使用时需要特别注意线程安全。NSManagedObjectContext 有不同的并发类型，如 NSMainQueueConcurrencyType 和 NSPrivateQueueConcurrencyType。主队列并发类型适用于与用户界面交互的上下文，而私有队列并发类型适用于后台操作。
    • 当在不同线程间传递托管对象时，需要使用 NSManagedObjectID 而不是直接传递托管对象实例。因为托管对象实例与创建它的上下文紧密相关，在不同上下文间直接传递可能会导致错误。例如：
// 在主上下文创建对象
NSManagedObjectContext *mainContext = [self managedObjectContext];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Task" inManagedObjectContext:mainContext];
NSManagedObject *newTask = [NSEntityDescription insertNewObjectForEntityForName:@"Task" inManagedObjectContext:mainContext];
[newTask setValue:@"Background Task" forKey:@"title"];
[newTask setValue:@NO forKey:@"isCompleted"];

NSError *error = nil;
if (![mainContext save:&error]) {
    NSLog(@"Error saving main context: %@", error);
}

// 获取对象的 ID
NSManagedObjectID *taskID = [newTask objectID];

// 在后台上下文获取对象
NSManagedObjectContext *backgroundContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
backgroundContext.persistentStoreCoordinator = mainContext.persistentStoreCoordinator;

[backgroundContext performBlock:^{
    NSManagedObject *taskInBackground = [backgroundContext objectWithID:taskID];
    [taskInBackground setValue:@YES forKey:@"isCompleted"];

    NSError *backgroundError = nil;
    if (![backgroundContext save:&backgroundError]) {
        NSLog(@"Error saving background context: %@", backgroundError);
    }
}];
  1. 父子上下文关系
    • 可以使用父子上下文关系来简化多线程操作。父上下文通常是主上下文，子上下文可以是私有队列上下文。子上下文的更改可以先提交到父上下文，然后再由父上下文提交到持久化存储。这样可以减少冲突，并且在某些情况下提高性能。例如：
NSManagedObjectContext *mainContext = [self managedObjectContext];
NSManagedObjectContext *childContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
childContext.parentContext = mainContext;

// 在子上下文创建对象
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Task" inManagedObjectContext:childContext];
NSManagedObject *newTask = [NSEntityDescription insertNewObjectForEntityForName:@"Task" inManagedObjectContext:childContext];
[newTask setValue:@"Child Context Task" forKey:@"title"];
[newTask setValue:@NO forKey:@"isCompleted"];

// 保存子上下文
NSError *childError = nil;
if (![childContext save:&childError]) {
    NSLog(@"Error saving child context: %@", childError);
}

// 保存父上下文
[mainContext performBlock:^{
    NSError *parentError = nil;
    if (![mainContext save:&parentError]) {
        NSLog(@"Error saving parent context: %@", parentError);
    }
}];

通过上述内容，我们全面深入地探讨了 Objective - C 中 Core Data 的数据库操作，从基础的数据模型构建，到 Core Data 栈的各个组件，再到具体的增删改查操作以及高级功能和性能优化，希望能帮助开发者更好地在实际项目中运用 Core Data 来管理数据。