iOS基础 - CoreData

▶ 什么是 CoreData

CoreData 是苹果公司封装的进行数据持久化的框架，是 iOS 5 之后新出来的的一个框架, 它允许按照实体-属性-值模型组织数据，并以 XML、二进制文件或者 SQLite 数据文件的格式持久化数据。CoreData 可以节省代码量：一般可达 30% 到 70%；它支持可视化建模；支持模型版本升级

CoreData 的底层是用 Sqlite3 来实现的，我们在内存中的对象时如何最后写入 Sqlite3 数据库中去的 ？其实是通过一个叫 Coordinator 的东西，它究竟是怎么实现的，就不要去关心了。CoreData 主要提供 对象-关系映射 功能（ORM：Object Relational Mapping），把 OC对象 转化为数据保存到文件，也可以数据转化为 OC对象

CoreData数据库 和 Sqlite数据库 两者的区别

A. Sqlite数据库：它基于 C 接口，需要使用 sql语句，但是代码较为繁琐；在处理大量数据时，表关系更为直观；在 OC 中不是可视化的；可以跨平台使用：iOS 和安卓

B. CoreData 数据库：可视化，有 undo/redo 能力；可以实现多种文件格式 NSSQLiteStoreType、NSBinaryStoreType、NSInMemoryStoreType、NSXMLStoreType；不能跨平台使用，只支持 iOS；苹果官方 API 支持，与 iOS 结合更紧密

▶ CoreData 的核心类

NSManagedObjectConext：被管理对象上下文（数据管理器）。相当于一个临时数据库，它负责应用与数据库之间的交互，增删改查基本操作都要用到，在实际开发中我们只关注该层

NSManagedObjectModel：被管理对象模型（数据模型器）。它可以添加实体及实体的属性，为 ***.xcdatamodeld文件，是 CoreData数据库 的可视化文件

NSPersistentStoreCoordinator：持久化存储助理（数据链接器）。是整个 CoreData 的核心，用来配置数据存储的名字、位置、存储方式等

NSManagedObject：是从 CoreData 中取出来的对象，默认都是 NSManagedObject 对象，通过键值对来存取所有的实体属性，相当于数据库中的表格记录

NSFetchRequest：获取数据时的请求

▶ CoreData 的使用方式

DemoA：iOS 10 之前的版本

A. 新建项目并勾选 CoreData：它会将 CoreData.framework 增加到我们工程的 Frameworks 列表中，并在 AppDelegate 中增加了一些关于 CoreData 的代码

B. 选中 ***.xcdatamodel 文件（Xcode 勾选 Use Core Data 时系统自动生成的文件，相当于数据库），创建 MyClass 和 Student两个实体（实体就相当于数据库中的表）并为其添加属性

C. 根据实体创建托管对象

选中 MyClass、Student 

之后系统会自动帮你生成 MyClass 和 Student 两个类文件且属性、映射关系等均已实现。下面以  MyClass 为例

D. 代码实现：有这样一个需求，我们在程序启动时利用 CoreData 插入数据并打印所所插入的数据信息！界面搭建则使用 storyBoard 拖一个 tableView 对数据进行展示，并完成增、删、改、查功能

// - AppDelegate.h 

#import <UIKit/UIKit.h>
#import <CoreData/CoreData.h>

@interface AppDelegate : UIResponder <UIApplicationDelegate>
@property (strong, nonatomic) UIWindow *window;

// -------------- 以下代码全是系统自动生成 ----------------

// 管理数据库上下文的对象，可以进行增、删、改、查
@property (readonly, strong, nonatomic) NSManagedObjectContext *managedObjectContext;
// 数据模型
@property (readonly, strong, nonatomic) NSManagedObjectModel *managedObjectModel;
// 数据库持久化协调器，实际的工作都是由它来处理
@property (readonly, strong, nonatomic) NSPersistentStoreCoordinator *persistentStoreCoordinator;
// 存储
- (void)saveContext;

// 文件路径
- (NSURL *)applicationDocumentsDirectory;

@end

// - AppDelegate.m 

#import "AppDelegate.h"
#import "Student.h"
@interface AppDelegate ()

@end

@implementation AppDelegate

//  我们在 didFinishLaunchingWithOptions 中实现插入、查询功能
//  然后在 TableViewController 实现删改操作
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    NSLog(@"%@",NSHomeDirectory());
    
    //-----------------------  CoreData 的使用 -----------------------
    
    // ------插入数据：添加对象------
    // 方式一
    // Student *student1 = [NSEntityDescription insertNewObjectForEntityForName:@"Student" inManagedObjectContext:self.managedObjectContext];
    
    // 方式二
    NSEntityDescription *entityDescription = [NSEntityDescription entityForName:@"Student" inManagedObjectContext:self.managedObjectContext];
    Student *student1 = [[Student alloc] initWithEntity:entityDescription insertIntoManagedObjectContext:self.managedObjectContext];
    
    // 赋值
    student1.name = @"Solina";
    student1.sex = @"female";
    student1.age = @16;
    
    // --------- 存储数据 ---------
    // 方式一
    BOOL result = [_managedObjectContext save:nil];
    if (result) {
        NSLog(@"添加数据成功");
    }else{
        NSLog(@"添加数据失败");
    }
    
    // 方式二
    // [self saveContext];
    
    // -------- 查询数据 --------
    NSFetchRequest *request = [[NSFetchRequest alloc] initWithEntityName:@"Student"];
    
    // 谓词：检索条件一定要根据实体中的属性来设置
    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"name == %@",@"Solina"];
    request.predicate = predicate;
    // 排序
    NSSortDescriptor *descriptor = [[NSSortDescriptor alloc] initWithKey:@"age" ascending:YES];
    request.sortDescriptors = @[descriptor];
    NSError *error = nil;
    NSArray *resultArray = [self.managedObjectContext executeFetchRequest:request error:&error];
    
    // 打印结果
    NSLog(@"%@",resultArray);
    
    return YES;
}

// 退出程序时保存数据
- (void)applicationWillTerminate:(UIApplication *)application {
    [self saveContext];
}


// ---------------------- 以下代码全是系统自动生成 -----------------------
#pragma mark - Core Data stack
// 这些都是创建时系统自动生成
@synthesize managedObjectContext = _managedObjectContext;
@synthesize managedObjectModel   = _managedObjectModel;
@synthesize persistentStoreCoordinator = _persistentStoreCoordinator;

// 返回 CoreData 存储的路径
- (NSURL *)applicationDocumentsDirectory {
    
    // 打印路径
    NSLog(@"%@",[[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject]);
    return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
}
// 获取管理对象
- (NSManagedObjectModel *)managedObjectModel {
    if (_managedObjectModel != nil) {
        return _managedObjectModel;
    }
    // 从应用程序中加载模型文件
    // momd 是编译后的文件后缀
    NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"CoreDataDemo" withExtension:@"momd"];
    _managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    return _managedObjectModel;
}
// 数据持久化协调器（真正做事情的）
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator {
    
    if (_persistentStoreCoordinator != nil) {
        return _persistentStoreCoordinator;
    }
    
    // 连接器对象关联的实体模型
    _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    //  定义数据存储的路径
    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"CoreDataDemo.sqlite"];
    NSError *error = nil;
    NSString *failureReason = @"There was an error creating or loading the application's saved data.";
    
    // NSSQLiteStoreType 这个参数决定文件存储的形式(sqlite、XML、二进制等)
    // 版本升级的话：把 options 原参数 nil 改成字典 @{NSMigratePersistentStoresAutomaticallyOption:@YES} ，意味着自动升级
    if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:@{NSMigratePersistentStoresAutomaticallyOption:@YES} error:&error]) {
        NSMutableDictionary *dict = [NSMutableDictionary dictionary];
        dict[NSLocalizedDescriptionKey] = @"Failed to initialize the application's saved data";
        dict[NSLocalizedFailureReasonErrorKey] = failureReason;
        dict[NSUnderlyingErrorKey] = error;
        error = [NSError errorWithDomain:@"YOUR_ERROR_DOMAIN" code:9999 userInfo:dict];
        
        NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
        // abort()会导致应用程序生成一个崩溃日志和终止。
        abort();
    }
    
    return _persistentStoreCoordinator;
}
// 获取数据库上下文
- (NSManagedObjectContext *)managedObjectContext {
    
    if (_managedObjectContext != nil) {
        return _managedObjectContext;
    }
    
    // 创建数据持久化协调器
    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (!coordinator) {
        return nil;
    }

    // ConcurrencyType 并发类型，是一个枚举值
    //      NSMainQueueConcurrencyType      主队列并发类型   2
    //      NSPrivateQueueConcurrencyType   私有队列并发类型  1
    //      NSConfinementConcurrencyType    限制并发类型     0
    _managedObjectContext = [[NSManagedObjectContext alloc] init];
    
    // 数据连接器 关联 被管理上下文
    [_managedObjectContext setPersistentStoreCoordinator:coordinator];
    return _managedObjectContext;
}

#pragma mark - Core Data Saving support
- (void)saveContext {
    NSManagedObjectContext *managedObjectContext = self.managedObjectContext;
    if (managedObjectContext != nil) {
        NSError *error = nil;
        if ([managedObjectContext hasChanges] && ![managedObjectContext save:&error]) {
            NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
            abort();
        }
    }
}

@end

// - TableViewController.h

#import <UIKit/UIKit.h>
#import "AppDelegate.h"
@interface TableViewController : UITableViewController
// 右上方的添加按钮
- (IBAction)addModel:(id)sender;
// 数据源
@property(nonatomic,strong)NSMutableArray *dataSource;
// 引入 AppDelegate
@property(nonatomic,strong)AppDelegate *myAPPDelegate;
@end

// - TableViewController.m

#import "TableViewController.h"
#import "Student.h"
@interface TableViewController ()

@end

@implementation TableViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.dataSource = [NSMutableArray arrayWithCapacity:1];
    self.myAPPDelegate = (id)[UIApplication sharedApplication].delegate;
    
    // 我们已经在 APP启动 时新增了些数据
    // 下面我们开始查询数据
    NSFetchRequest *request = [[NSFetchRequest alloc] initWithEntityName:@"Student"];
    NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"age" ascending:YES];
    request.sortDescriptors = @[sortDescriptor];
    NSError *error = nil;
    NSArray *result = [self.myAPPDelegate.managedObjectContext executeFetchRequest:request error:&error];
    
    // 获取数据
    [self.dataSource addObjectsFromArray:result];
}

#pragma mark - Table view data source
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    
    return 1;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    
    return self.dataSource.count;
}


// ---------- CoreData修改操作 -----------
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath{
    
    Student *stu = (Student*)self.dataSource[indexPath.row];
    stu.name = @"Rose";
    [self.tableView reloadRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
    // 数据持久化
    [self.myAPPDelegate saveContext];
    
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"CellID" forIndexPath:indexPath];
    Student *stuA = self.dataSource[indexPath.row];
    cell.textLabel.text = [NSString stringWithFormat:@"%@ ----- %@", stuA.name,stuA.age];
    return cell;
}

- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
    return YES;
}


//  ------ CoreData删除操作 --------
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        
        // 删除数据
        Student *stu = self.dataSource[indexPath.row];
        [self.dataSource removeObject:stu];
        // 注意数据管理器中的数据也要同步删除
        [self.myAPPDelegate.managedObjectContext deleteObject:stu];
        // 永久保存也需要同步更新
        [self.myAPPDelegate saveContext];
        
        // 更新 UI
        [tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
    }
}


// ------ CoreData新增操作 --------
- (IBAction)addModel:(id)sender {
    
    NSEntityDescription *description = [NSEntityDescription entityForName:@"Student" inManagedObjectContext:self.myAPPDelegate.managedObjectContext];
    Student *stu = [[Student alloc] initWithEntity:description insertIntoManagedObjectContext:self.myAPPDelegate.managedObjectContext];
    stu.name = @"Puma";
    int age = arc4random()%10+10;
    stu.age = [NSNumber numberWithInt:age];
    [self.dataSource addObject:stu];
    
    // 更新UI
    [self.tableView insertRowsAtIndexPaths:@[[NSIndexPath indexPathForRow:self.dataSource.count-1 inSection:0]] withRowAnimation:UITableViewRowAnimationLeft];
    // 更新数据
    [self.myAPPDelegate saveContext];
}

@end

运行效果

DemoB：iOS10 之后的版本

A. 在撸代码之前，先了解下新增的 NSPersistentContainer！找到源码，我们发现它是将之前方法进行了封装

#import <Foundation/NSArray.h>
#import <Foundation/NSDictionary.h>
#import <Foundation/NSError.h>
#import <CoreData/NSManagedObjectContext.h>
#import <CoreData/NSPersistentStoreCoordinator.h>
#import <CoreData/NSManagedObjectModel.h>
#import <CoreData/NSPersistentStoreDescription.h>

@class NSURL;


// 版本要求
API_AVAILABLE(macosx(10.12),ios(10.0),tvos(10.0),watchos(3.0))

// 将之前的属性直接封装
@interface NSPersistentContainer : NSObject {
}

/*
*  name 表示保存的数据库文件名称
*  默认模型文件名称为 name
*/
+ (instancetype)persistentContainerWithName:(NSString *)name;

/*
* name  表示保存的数据库文件名称
* model 对象管理模型
*/
+ (instancetype)persistentContainerWithName:(NSString *)name managedObjectModel:(NSManagedObjectModel *)model;

// 返回沙盒中存储数据库的文件夹 URL 路径
// 这个文件夹是动态创建的 Library->Application Support
+ (NSURL *)defaultDirectoryURL;

// 当前 NSPersistentContainer 容器的名称
@property (copy, readonly) NSString *name;
// 自动生成的管理对象上下文，这个上下文默认的操作类型是 NSMainQueueConcurrencyType 主线程
@property (strong, readonly) NSManagedObjectContext *viewContext;
@property (strong, readonly) NSManagedObjectModel *managedObjectModel;
@property (strong, readonly) NSPersistentStoreCoordinator *persistentStoreCoordinator;
// 存储器描述数组
@property (copy) NSArray<NSPersistentStoreDescription *> *persistentStoreDescriptions;


- (instancetype)initWithName:(NSString *)name;
- (instancetype)initWithName:(NSString *)name managedObjectModel:(NSManagedObjectModel *)model NS_DESIGNATED_INITIALIZER;
// 加载存储器，此方法必须要调用，否则无法存储数据
// block 中 NSPersistentStoreDescription 用于描述生成的存储器信息
// 如：数据库文件路径、存储类型等
- (void)loadPersistentStoresWithCompletionHandler:(void (^)(NSPersistentStoreDescription *, NSError * _Nullable))block;
// 返回一个基于多线程的管理对象上下文，我们无需关心多线程的内部实现以及线程安全，由 NSPersistentContainer 新创建一个
// 调用这个方法之后，对返回的上下文做一些数据的处理都是在子线程中完成的，可以用于处理对数据库进行大量数据操作的场景
- (NSManagedObjectContext *)newBackgroundContext NS_RETURNS_RETAINED;
// 使用存储调度器快速在多线程中操作数据库，效率非常高
- (void)performBackgroundTask:(void (^)(NSManagedObjectContext *))block;

@end

这时候 AppDelegate.m文件 中的方法只有两个

// - AppDelegate.h

#import <UIKit/UIKit.h>
#import <CoreData/CoreData.h>
@interface AppDelegate : UIResponder <UIApplicationDelegate>
@property (readonly, strong) NSPersistentContainer *persistentContainer;
- (void)saveContext;
@end

// - AppDelegate.m

#pragma mark - Core Data stack

@synthesize persistentContainer = _persistentContainer;

- (NSPersistentContainer *)persistentContainer {
    // The persistent container for the application. This implementation creates and returns a container, having loaded the store for the application to it.
    @synchronized (self) {
        if (_persistentContainer == nil) {
            _persistentContainer = [[NSPersistentContainer alloc] initWithName:@"DemoTest"];
            [_persistentContainer loadPersistentStoresWithCompletionHandler:^(NSPersistentStoreDescription *storeDescription, NSError *error) {
                if (error != nil) {
                    // 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.
                    
                    /*
                     Typical reasons for an error here include:
                     * The parent directory does not exist, cannot be created, or disallows writing.
                     * The persistent store is not accessible, due to permissions or data protection when the device is locked.
                     * The device is out of space.
                     * The store could not be migrated to the current model version.
                     Check the error message to determine what the actual problem was.
                    */
                    NSLog(@"Unresolved error %@, %@", error, error.userInfo);
                    abort();
                }
            }];
        }
    }
    
    return _persistentContainer;
}

#pragma mark - Core Data Saving support

- (void)saveContext {
    NSManagedObjectContext *context = self.persistentContainer.viewContext;
    NSError *error = nil;
    if ([context hasChanges] && ![context save:&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.
        NSLog(@"Unresolved error %@, %@", error, error.userInfo);
        abort();
    }
}

B. 我们新增 Student实体，并添加添加 name、sex、age 属性

C. 接着为之创建托管对象，系统就会自动创建以下 4 个文件

// - Student+CoreDataProperties.h

#import "Student+CoreDataClass.h"
@interface Student (CoreDataProperties)
+ (NSFetchRequest<Student *> *)fetchRequest;
@property (nullable, nonatomic, copy) NSString *name;
@property (nullable, nonatomic, copy) NSString *sex;
@property (nonatomic) int64_t age;
@end

// - Student+CoreDataProperties.m

#import "Student+CoreDataProperties.h"
@implementation Student (CoreDataProperties)
+ (NSFetchRequest<Student *> *)fetchRequest {
    return [NSFetchRequest fetchRequestWithEntityName:@"Student"];
}
@dynamic name;
@dynamic sex;
@dynamic age;
@end

// - Student+CoreDataClass.h

#import <Foundation/Foundation.h>
#import <CoreData/CoreData.h>
@interface Student : NSManagedObject
@end
#import "Student+CoreDataProperties.h"

// - Student+CoreDataClass.m 

#import "Student+CoreDataClass.h"
@implementation Student
@end

D. 代码实现

// - AppDelegate.h

#import <UIKit/UIKit.h>
#import <CoreData/CoreData.h>
@interface AppDelegate : UIResponder <UIApplicationDelegate>
@property (readonly, strong) NSPersistentContainer *persistentContainer;
- (void)saveContext;
@end

// - AppDelegate.m

#import "AppDelegate.h"
#import "Student+CoreDataClass.h"
@interface AppDelegate ()

@end

@implementation AppDelegate

// 需要引入头文件 Student+CoreDataClass.h
// 我们在 didFinishLaunchingWithOptions: 中做一些简单的数据操作：添加、存储、删除
// 除了引用的头文件和该方法中的代码，其他代码均是系统生成
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // 添加数据
    Student *newEintity = [NSEntityDescription insertNewObjectForEntityForName:@"Student" inManagedObjectContext:self.persistentContainer.viewContext];
    newEintity.name = @"张三";

    [self saveContext];

    // 删除数据
    NSFetchRequest *request = [[NSFetchRequest alloc] initWithEntityName:@"Student"];
    NSPredicate *predic = [NSPredicate predicateWithFormat:@"name = %@",@"张三"];
    request.predicate = predic;
    NSArray *arr = [self.persistentContainer.viewContext executeFetchRequest:request error:nil];
    if (arr.count > 0) {
        [self.persistentContainer.viewContext deleteObject:arr.firstObject];
        [self saveContext];
    }

    return YES;
}


#pragma mark - UISceneSession lifecycle


- (UISceneConfiguration *)application:(UIApplication *)application configurationForConnectingSceneSession:(UISceneSession *)connectingSceneSession options:(UISceneConnectionOptions *)options {
    return [[UISceneConfiguration alloc] initWithName:@"Default Configuration" sessionRole:connectingSceneSession.role];
}


- (void)application:(UIApplication *)application didDiscardSceneSessions:(NSSet<UISceneSession *> *)sceneSessions {
}


#pragma mark - Core Data stack

@synthesize persistentContainer = _persistentContainer;

- (NSPersistentContainer *)persistentContainer {
    @synchronized (self) {
        if (_persistentContainer == nil) {
            _persistentContainer = [[NSPersistentContainer alloc] initWithName:@"iOSWithCoreData"];
            [_persistentContainer loadPersistentStoresWithCompletionHandler:^(NSPersistentStoreDescription *storeDescription, NSError *error) {
                if (error != nil) {
                    NSLog(@"Unresolved error %@, %@", error, error.userInfo);
                    abort();
                }
            }];
        }
    }
    
    return _persistentContainer;
}

#pragma mark - Core Data Saving support
- (void)saveContext {
    NSManagedObjectContext *context = self.persistentContainer.viewContext;
    NSError *error = nil;
    if ([context hasChanges] && ![context save:&error]) {
        NSLog(@"Unresolved error %@, %@", error, error.userInfo);
        abort();
    }
}

@end

▶ CoreData 模型升级

CoreData 支持随着 App开发 的推进而带来的对 NSManagedObjectModel 升级或修改的管理。如果你要改变你的模型，你就必须要改变现有存储中的数据：即数据存储格式，这被称为数据迁移！具体实现步骤如下

A. 选中 ***.xcdatamodeld 文件，选择 Editor -> Add Model Version

B. 新建的 iosWithCoreData 2.xcdatamodel 如下

你可以在工程右侧属性面板的当前数据版本，这里我们选择了新版本 

C. 更新实体：为 Student实体 新增 score属性

在为 Student实体 创建新的托管对象之前，我们要在 APPDelegate.m文件 中修改 persistentStoreCoordinator方法，使其自动升级

D 最后为对应的实体创建新的托管对象即可：它会覆盖掉原来的 Student实体

注：如果你想要使 model版本 回退，则在工程右侧属性面板中选择 旧版model，然后选择对应的实体、并重复创建托管对象这一操作即可（model升级或回退，其实就是不同版本之间的覆盖）

▶ 结语

CoreData 的使用流程

A. 模型文件操作

第一步：创建模型文件，后缀名为 .xcdatamodeld。创建模型文件之后，可以在其内部进行添加实体等操作 ，用于表示数据库文件的数据结构

第二步：添加实体、属性 。实体表示数据库文件中的表结构

第三步：根据指定实体，创建托管对象类文件

B. 实例化上下文对象

第一步：创建托管对象上下文 NSManagedObjectContext

第二步：创建托管对象模型    NSManagedObjectModel

第三步：根据托管对象模型，创建持久化存储协调器 NSPersistentStoreCoordinator

第四步：关联并创建本地数据库文件，并返回持久化存储对象 NSPersistentStore；最后将持久化存储协调器赋值给托管对象上下文