000-数据存储

一、iOS常见的几种数据存储

1.plist列表(writeToFile:)

2.偏好设置(NSUserDefaults)

3.归档(NSCodeing、NSKeyedArchiver)

4.SQLite3(数据库、一般借助第三方库FMDB)

5.Core Data(对象型的数据库)

 

二、应用沙盒

1.简介

　　每一个应用都有自己的应用沙盒，也就是系统文件目录。每一个应用都必须呆在自己的应用沙盒中，不可以访问别的应用沙盒(iOS8已经允许访问其他应用沙盒)

2.结构

　　

　　应用沙盒下面一级文件夹有三个：Documents、Library、tmp；Library文件夹下有二级文件有两个：Caches、Preferences

　　1）Documents：保存应⽤运行时生成的需要持久化的数据，iTunes同步设备时会备份该目录

　　2）Library/Caches：保存应用运行时⽣成的需要持久化的数据，iTunes同步设备时不会备份该目录(一般存储体积大、不需要备份的非重要数据)

　　3）Library/Preference：保存应用的所有偏好设置，iOS的Settings(设置) 应⽤会在该⺫录中查找应⽤的设置信息。iTunes同步设备时会备份该目录 

　　4）tmp:保存应⽤运行时所需的临时数据，使⽤完毕后再将相应的文件从该目录删除。应用没有运行时，系统也可能会清除该目录下的文件。iTunes同步设备时 不会备份该目录 

3.应用沙盒目录的获取方法

    // 1.获取沙盒根目录
    NSString *homePath = NSHomeDirectory();
    
    // 2.获取Documents目录
    // 第一种方法：根目录直接拼接(不建议采用，原因是如果苹果公司将文件夹名称改了，那就会很麻烦)
    NSString *docPath1 = [homePath stringByAppendingPathComponent:@"Documents"];
    // 第二种方法：方法获取(推荐使用)
    // 参数1：NSDocumentDirectory  查找Documents文件夹
    // 参数2：NSUserDomainMask     在用户目录下查找
    // 参数3：YES                  是否展开用户目录(NO就是~，YES就是展开)
    NSString *docPath2 = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).lastObject;
    
    // 3.拼接文件路径
    // 假设Documents文件夹下面存储一张图片image.png
    NSString *filePath = [docPath2 stringByAppendingPathComponent:@"image.png"];

 

三、plist列表

1.简介　　

　　1）plist列表只能存储一些系统自定义的数据类型，例如：NSString、NSArray、NSNumber、NSDictionary、NSData等等

　　2）plist列表不能存储一些我们自定义的对象类型，例如：自定义的Person对象

　　3）我们一般将plist文件保存在沙河目录Documents文件夹下，文件后缀名为.plist

2.实际应用

#pragma mark - 数据保存
- (void)saveData
{
    // 1.获取Documents目录
    NSString *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).lastObject;
    
    // 2.拼接文件路径
    // 数组形式保存文件名：user1.plist
    // 字典形式保存文件名：user2.plist
    NSString *filePath1 = [docPath stringByAppendingPathComponent:@"user1.plist"];
    NSString *filePath2 = [docPath stringByAppendingPathComponent:@"user2.plist"];
    
    // 3.保存数据
    // 第一种情况：数组形式保存
    NSArray *userArr = @[@"Frank", @25, @"M", @"湖北黄冈"];
    [userArr writeToFile:filePath1 atomically:YES];
    // 第二种情况：字典形式保存
    NSDictionary *userDic = @{@"name": @"Frank", @"age": @25, @"sex": @"M", @"home": @"湖北黄冈"};
    [userDic writeToFile:filePath2 atomically:YES];
}

#pragma mark - 读取数据
- (void)readData
{
    // 1.获取Documents目录
    NSString *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).lastObject;
    
    // 2.拼接文件路径
    // 数组形式保存文件名：user1.plist
    // 字典形式保存文件名：user2.plist
    NSString *filePath1 = [docPath stringByAppendingPathComponent:@"user1.plist"];
    NSString *filePath2 = [docPath stringByAppendingPathComponent:@"user2.plist"];
    
    // 3.读取数据
    // 第一种情况：数组形式
    NSArray *userArr = [NSArray arrayWithContentsOfFile:filePath1];
    NSLog(@"userArr = %@", userArr);
    // 第二种情况：字典形式
    NSDictionary *userDic = [NSDictionary dictionaryWithContentsOfFile:filePath2];
    NSLog(@"userDic = %@", userDic);
}

 

四、偏好设置

1.简介　　

　　1）很多应用都支持偏好设置，iOS提供了一套标准的解决方案来为应用加入偏好设置。

　　2）每一个应用都有一个实例NSUserDefault，iOS就是通过它来存储偏好设置

　　3）文件存储在沙河目录Library下文件夹Preferences，文件后缀名为.plist

　　4）注意我们的偏好设置是将所有的东西都保存在同一个文件中，且主要用来保存应用的一些设置信息

　　5）偏好设置同plist列表一样只能保存iOS系统自定义的一些数据类型

2.实际应用

#pragma mark - 数据保存
- (void)saveData
{
    // 1.获取NSUserDefaults对象
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    
    // 2.保存数据
    [defaults setObject:@"Frank" forKey:@"name"];
    [defaults setInteger:25 forKey:@"age"];
    [defaults setDouble:1.69 forKey:@"height"];
    [defaults setFloat:148.2f forKey:@"weight"];
    [defaults setObject:@"M" forKey:@"sex"];
    
    // 3.同步数据(强制数据立即保存) -- 有点类似我们刷新表
    // 若没有同步数据，系统会在将来某一时间点自动将数据保存到Preferences文件夹下
    [defaults synchronize];
}

#pragma mark - 读取数据
- (void)readData
{
    // 1.获取NSUserDefaults对象
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    
    // 2.读取保存的数据
    NSString *name = [defaults objectForKey:@"name"];
    NSInteger age = [defaults integerForKey:@"age"];
    double height = [defaults doubleForKey:@"height"];
    CGFloat weight = [defaults floatForKey:@"weight"];
    NSString *sex = [defaults objectForKey:@"sex"];
    
    // 3.打印输出数据
    NSLog(@"name=%@, age=%ld, height=%.2f, weight=%.2f, sex=%@", name, age, height, weight, sex);
}

 

五、NSKeydeArchiver归档

1.简介

　　1）与前面两中数据保存方法均不能针对自定义对象类型，归档是专门针对自定义对象类型的数据保存

　　2）我们一般将归档文件保存在沙盒目录下的Documents文件夹下，其文件后缀名可以是任意的

　　3）通过plist存储的文件在文件中打开是直接显示的，而归档存储的文件在文件打开时是乱码的，更加安全

2.实际应用

　　1）自定义对象：UserModel类

// UserModel.h文件
#import <Foundation/Foundation.h>

#pragma mark - 归档对象必须遵循<NSCoding>协议
@interface UserModel : NSObject<NSCoding>

@property (nonatomic, copy) NSString *userId;      // 用户ID
@property (nonatomic, copy) NSString *userName;    // 用户名
@property (nonatomic, copy) NSString *password;    // 用户密码
@property (nonatomic, assign) NSInteger age;       // 用户的年龄
@property (nonatomic, assign) double weight;       // 用户的体重
@property (nonatomic, assign) float height;        // 用户的身高
@property (nonatomic, copy) NSString *userTel;     // 用户的电话号码
@property (nonatomic, copy) NSString *userEmail;   // 用户的邮箱

@end


// UserModel.m文件
#import "UserModel.h"

@implementation UserModel

#pragma mark - 必须实现的协议方法<NSCoding>
// 1.归档
- (void)encodeWithCoder:(NSCoder *)aCoder
{
    [aCoder encodeObject:_userId forKey:@"userId"];        // 用户ID
    [aCoder encodeObject:_userName forKey:@"userName"];    // 用户名
    [aCoder encodeObject:_password forKey:@"password"];    // 用户密码
    [aCoder encodeInteger:_age forKey:@"age"];             // 用户的年龄
    [aCoder encodeDouble:_weight forKey:@"weight"];        // 用户的体重
    [aCoder encodeFloat:_height forKey:@"height"];         // 用户的身高
    [aCoder encodeObject:_userTel forKey:@"userTel"];      // 用户的电话号码
    [aCoder encodeObject:_userEmail forKey:@"userEmail"];  // 用户的邮箱
}
// 2.解档
- (id)initWithCoder:(NSCoder *)aDecoder
{
    if (self = [super init]) {
        _userId = [aDecoder decodeObjectForKey:@"userId"];        // 用户ID
        _userName = [aDecoder decodeObjectForKey:@"userName"];    // 用户名
        _password = [aDecoder decodeObjectForKey:@"password"];    // 用户密码
        _age = [aDecoder decodeIntegerForKey:@"age"];             // 用户的年龄
        _weight = [aDecoder decodeDoubleForKey:@"weight"];        // 用户的体重
        _height = [aDecoder decodeFloatForKey:@"height"];         // 用户的身高
        _userTel = [aDecoder decodeObjectForKey:@"userTel"];      // 用户的电话号码
        _userEmail = [aDecoder decodeObjectForKey:@"userEmail"];  // 用户的邮箱
    }
    return self;
}

@end

　　2）保存数据、读取数据工具类：UserDataSaveTool类

// UserDataSaveTool.h文件
#import <Foundation/Foundation.h>
#import "UserModel.h"

@interface UserDataSaveTool : NSObject

#pragma mark - 保存用户数据
+ (void)saveUserModel:(UserModel *)userModel;

#pragma mark - 获取用户数据
+ (UserModel *)getUserModel;

@end


// UserDataSaveTool.m文件
#import "UserDataSaveTool.h"

@implementation UserDataSaveTool

#pragma mark - 用户信息保存的沙盒路径
+ (NSString *)getAccoutPath
{
    // 归档文件名为：account.archive
    NSString *filePath = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject] stringByAppendingPathComponent:@"account.archive"];
    return filePath;
}

#pragma mark - 保存用户数据
+ (void)saveUserModel:(UserModel *)userModel
{
    // 用户信息(用户信息model：accout)归档 -- 执行这个就会自动跳转执行用户model里的归档协议
    [NSKeyedArchiver archiveRootObject:userModel toFile:[self getAccoutPath]];
}

#pragma mark - 获取用户数据
+ (UserModel *)getUserModel
{
    // 取出账号(账号存的就是一个model) -- 执行这个就会自动跳转执行用户model里的解档协议
    UserModel *userModel = [NSKeyedUnarchiver unarchiveObjectWithFile:[self getAccoutPath]];
    return userModel;
}

@end

　　3）实际调用

#pragma mark - 数据保存
- (void)saveData
{
    // 1.初始化自定义对象模型
    UserModel *userModel = [[UserModel alloc] init];
    userModel.userId = @"20099830215";
    userModel.userName = @"Frank";
    userModel.password = @"9830215";
    userModel.age = 25;
    userModel.weight = 110.0;
    userModel.height = 1.69;
    userModel.userTel = @"15112256959";
    userModel.userEmail = @"1058842360@qq.com";
    
    // 2.借助UserDataSaveTool工具保存对象模型
    [UserDataSaveTool saveUserModel:userModel];
}

#pragma mark - 读取数据
- (void)readData
{
    // 1.借助UserDataSaveTool工具获取对象模型
    UserModel *userModel = [UserDataSaveTool getUserModel];
    
    // 2.打印输出
    NSLog(@"userModel = %@", userModel);
}

3.注意

　　1）对象必须遵循NSCoding协议，并且重写协议的两个方法

　　2）如果是继承，在子类中也是要重写NSCoding协议的两个方法，而且协议方法中必须先调用父类的方法

　　例如：给上面的UserModel添加一个属性"sex"

// PersonModel.h文件
#import "UserModel.h"

@interface PersonModel : UserModel

#pragma mark - 给子类的属性
@property (nonatomic, copy) NSString *sex;  // 性别

@end


// PersonModel.m文件
#import "PersonModel.h"

@implementation PersonModel

#pragma mark - 重写协议方法<NSCoding>
// 1.归档
- (void)encodeWithCoder:(NSCoder *)aCoder
{
    // 先调用父类的归档协议方法
    [super encodeWithCoder:aCoder];
    [aCoder encodeObject:@"M" forKey:@"sex"];
}
// 2.解档
- (instancetype)initWithCoder:(NSCoder *)aDecoder
{
    // 先初始化父类
    if (self = [super initWithCoder:aDecoder]) {
        [aDecoder decodeObjectForKey:@"sex"];
    }
    return self;
}

@end

 

六、SQLite3

1.前言

　　在我们的实际开发中都需要做一些离线数据的处理，即离线缓存。上面三个方法都可以实现离线缓存，但是它们都有一个致命的弱点：无法存储大批量的数据，存在一些性能的问题。除了这个关键性的问题外，它们还存在各种各样不同的约束问题。例如：对于归档，它只支持一次性写入，一次性读取，这对于大数据的存储有着很大的问题。针对这些问题，数据库SQLite3可以解决。

2.SQLite3的简介

　　1）3是SQLite的版本号

　　2）SQLite3是一种轻量级的嵌入式数据库，目前安卓和iOS使用的都是SQLite数据库

　　3）SQLite的占用资源非常低、处理速度也较MySql、PostgreSQL这两款著名的数据库快

　　4）SQLite中可以有多张表，表里的元素都是以字段存储和读取

3.SQL语句

　　1）SQL语句中字段的类型

　　　　integer：整型

　　　　real：浮点类型

　　　　text：文本字符串

　　　　blob：二进制数据(比如文件)

　　2）SQL语句的基本的操作

　　　　a.创表

　　　　　　create table 表名(字段名1 字段类型, 字段名2 字段类型, 字段名3 字段类型, ...);

　　　　　　create table if not exists 表名(字段名1 字段类型, 字段名2 字段类型, 字段名3 字段类型, ...);

　　　　　　// 实际上SQLite是无类型的，就算声明为integer类型，还是能存储字符串文本(主键除外)，创表时可以不用去声明字段类型

　　　　b.删表

　　　　　　drop table 表明;

　　　　　　drop table if exists 表名;

　　　　c.插入数据

　　　　　　insert into 表名(字段1, 字段2, ...) values (字段1的值, 字段2的值, ...);

　　　　　　例：insert into t_student(name, age, sex) values ('Frank', 25, 'M');

　　　　　　// 注意：SQL中字符串的值必须使用单引号''引上

　　　　d.更新数据

　　　　　　update 表名 set 字段1 = 字段1的值, 字段2 = 字段2的值, ...;

　　　　　　例：update t_student set name = 'Frank', age = 25;

　　　　　　// 上面语句是将表t_student中所有记录的字段name的值改为"Frank"，所有记录的字段age的值改为25

　　　　e.删除数据

　　　　　　delete from 表名;

　　　　　　例：delete from t_student;

　　　　　　// 上面语句是将表t_student中的所有记录删除

　　　　d.条件语句

　　　　　　where 指定字段 = 指定值;

　　　　　　where 指定字段 is 指定值;

　　　　　　where 指定字段 != 指定值;

　　　　　　where 指定字段 is not 指定值;

　　　　　　where 指定字段 > 指定值;

　　　　　　where 指定字段1 = 指定值1 and 指定字段2 > 指定值2;

　　　　　　where 指定字段1 = 指定值1 or 指定字段2 = 指定值2;

　　　　e.查找语句

　　　　　　select 字段1, 字段2, ... from 表名;        // 查询指定字段

　　　　　　select * from 表名;                             // 查询所有字段

　　　　f.排序

　　　　　　select * from 表名 order by 字段;      // 查询结果按照指定字段升序排列(默认)

　　　　　　select * from 表名 order by 字段 desc;      // 查询结果按照指定字段降序排列

　　　　　　select * from 表名 order by 字段 asc;      // 查询结果按照指定字段升序排列　

　　　　　　select * from 表名 order by 字段1 desc, 字段2 asc;  // 查询结果按照字段1降序排列，按照字段2升序排列

　　　　g.使用limit精准控制查询结果的数量

　　　　　　select * from 表名 limit 数值;                  // 指定获取查询结果的前几条数据

　　　　　　select * from 表名 limit 数值1, 数值2;       // 指定跳过前面几条(数值1)数据，然后取指定条(数值2)数据

　　　　h.普通字段约束

　　　　　　创表时，可以给一些特定的字段设置一些约束条件，常见的有：

　　　　　　　　not null：规定字段值不能为null

　　　　　　　　unique：规定字段的值必须唯一

　　　　　　　　default：指定字段的默认值

　　　　　　例：create table t_student (id integer, name text not null unique, age integer not null default 1);

　　　　　　　　// name字段：不能为null，并且唯一

　　　　　　　　// age字段：不能为null，默认值为1

　　　　i.主键约束

　　　　　　主键用来唯一标识某一条记录。主键可以是一个字段或多个字段

　　　　　　只要声明为primary key ，就说明是一个主键字段

　　　　　　主键字段默认就包含了not null和unique两个约束

　　　　　　主键自动增长，应该增加autoincrement

　　　　　　例：create table t_student (id integer primary key autoincrement, name text, age integer); 

　　　　　　　　// 自动增长的主键

　　　　j.外键约束

　　　　　　外键约束可以用来建立表与表之间的联系

　　　　　　例：create table t_student (id integer primary key autoincrement, name text, class_id integer, constraint fk_student_class foreign key (class_id) references t_class (id));

　　　　　　　　// t_student表中的外键：fk_t_student_class_id_t_class_id

　　　　　　　　// 作用：用t_student表中的class_id字段引用t_class表的id字段

4.FMDB　　　　　　

　　1）什么是FMDB

　　　　a.FMDB是iOS平台的SQLite数据库框架

　　　　b.FMDB以OC的方式封装了SQLite的C语言API

　　2）FMDB的优点

　　　　a.使用起来更加面向对象，省去了很多麻烦、冗余的C语言代码

　　　　b.对比苹果自带的CoreData框架，更加轻量级和灵活

　　　　c.提供了多线程安全的数据库操作方法，有效地防止数据混乱

　　3）FMDB的核心类

　　　　a.FMDatabase：一个FMDatabase对象就代表一个单独的SQLite数据库。用来执行SQL语句

　　　　b.FMResultSet：使用FMDatabase执行查询后的结果集

　　　　c.FMDdatabaseQueue：用于多线程中执行多个查询或更新，它是线程安全的

　　4）打开数据库(根据文件路径)

　　　　FMDatabase *db = [FMDatabase databaseWithPath:dbPath];

　　　　if (![db open]) {

　　　　　　NSLog(@"数据库打开失败!");

　　　　}

　　　　// 文件路径有三种情况：

　　　　a.文件路径具体：如果不存在该数据库文件会自动创建

　　　　b.文件路径为空字符串@""：会在临时目录下创建一个空的数据库；当FMDatabase连接关闭时，数据库文件也被删除

　　　　c.文件路径为nil：会创建一个内存中临时数据库；当FMDatabase连接关闭时，数据库会被销毁

　　5）FMDB的用法

　　　　a.在项目中导入系统框架libsqlite3.dylib

　　　　b.将第三方库FMDB拖入到项目中

　　6）FMDB管理工具类

// FMDBManager.h文件
#import <Foundation/Foundation.h>
#import "FMDatabaseQueue.h"
#import "FMDatabaseAdditions.h"
#import <objc/runtime.h>

@interface FMDBManager : NSObject


// 工具类特点：
// 1.根据实体对象创表，每张表的主键为实体类的首个属性名，主键为自增NSInteger类型
// 2.删除和插入可以灵活地传入实体对应的任何一个属性作为依据字段，根据该字段来判断删除的记录是否存在和判断是插入还是更新操作
// 3.查找方法可以将一个字符串作为参数传递，该字符串为条件查找的条件语句；方法内部会根据该字符串是否为nil，来判断是条件查询还是全部查询

// 工具类的要求：
// 1.实体对应的首字段取名最好为“idNum”
// 2.实体所有属性最好都是NSString类型

#pragma mark - 数据库管理类对象
+ (FMDBManager *)sharedInstace;

#pragma mark - 创建表
- (void)creatTable:(id)model;

#pragma mark - 数据库更新或插入数据
- (void)insertAndUpdateModelToDatabase:(id)model selectColumn:(NSString *)selectColumn;

#pragma mark - 删除元素
- (void)deleteModelInDatabase:(id)model selectColumn:(NSString *)selectColumn;

#pragma mark - 全部查找
- (NSArray *)selectModelArrayInDatabase:(NSString *)className factorString:(NSString *)factorString;

@end


// FMDBManager.m文件
#import "FMDBManager.h"

// 通过实体获取类名
#define KCLASS_NAME(model) NSStringFromClass([model class])
// 通过实体获取属性数组
#define KMODEL_PROPERTYS [self getAllProperties:model]
// 通过实体获取属性数组的数目
#define KMODEL_PROPERTYS_COUNT [[self getAllProperties:model] count]

@implementation FMDBManager
{
    FMDatabaseQueue *_dbQueue; // 数据库操作队列
}

#pragma mark - 数据库管理类对象
+ (FMDBManager *)sharedInstace
{
    static dispatch_once_t onceToken;
    static FMDBManager *manager = nil;
    dispatch_once(&onceToken, ^{
        manager = [[FMDBManager alloc] init];
    });
    return manager;
}

#pragma mark - 获取沙盒路径
- (NSString *)getDBFilePath
{
    NSString *dbFilePath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:@"db.sqlite"];
    NSLog(@"%@", dbFilePath);
    return dbFilePath;
}

#pragma mark - 创建数据库操作队列
// 一个数据库文件对应一个数据库操作队列
- (void)creatDBQueue
{
    // 创建数据库操作队列的同时还会判断数据库是否存在，如果不存在，系统自动创建数据库
    _dbQueue = [[FMDatabaseQueue alloc] initWithPath:[self getDBFilePath]];
}

#pragma mark - 获取实体对象的属性数组
// 参数：model 实体对象
// 返回值：实体对象属性数组
- (NSArray *)getAllProperties:(id)model
{
    u_int count;
    objc_property_t *properties  = class_copyPropertyList([model class], &count);
    // 定义一个可变的属性数组
    NSMutableArray *propertiesArray = [NSMutableArray array];
    for (int i = 0; i < count ; i++)
    {
        const char* propertyName = property_getName(properties[i]);
        [propertiesArray addObject: [NSString stringWithUTF8String: propertyName]];
    }
    free(properties);
    return propertiesArray;
}

#pragma mark - 创表
// 参数1：model 实体对象
- (void)creatTable:(id)model
{
    // 判断数据库操作队列是否存在
    if (!_dbQueue) {
        // 数据库操作队列不存，就得创建
        [self creatDBQueue];
    }
    
    // 使用数据库操作队列操作数据库
    [_dbQueue inDatabase:^(FMDatabase *db) {
        // 打开数据库
        if (![db open]) {
            // 数据库打开失败
            NSLog(@"数据库打开失败");
            return;
        }
        
        // 为数据设置缓存，提高查询效率
        [db setShouldCacheStatements:YES];
        
        // 判断数据库中是否已经存在该实体对应的表
        // 不存在该实体对应的表，才创建表
        if (![db tableExists:KCLASS_NAME(model)]) {
            // 创表语句的第一部分
            // %@ integer primary key autoincrement(设置主键为实体model的首字段，integer类型，自增)
            // 主键
            NSString *primaryKey = KMODEL_PROPERTYS[0];
            NSString *creatTableOneStr = [NSString stringWithFormat:@"create table %@(%@ integer primary key autoincrement", KCLASS_NAME(model), primaryKey];
            
            // 创表语句的第二部分
            NSMutableString *createTableTwoStr = [NSMutableString string];
            // 遍历实体对象的属性数组
            // 直接跳过实体的首字段
            for (int i = 1; i < KMODEL_PROPERTYS_COUNT; i++) {
                // 实体对应的字段都是以文本字符串类型存储到数据库表中
                NSString *popertyName = KMODEL_PROPERTYS[i];
                [createTableTwoStr appendFormat:@", %@ text", popertyName];
            }
            
            // 创建表总语句
            NSString *createTableStr = [NSString stringWithFormat:@"%@%@)", creatTableOneStr, createTableTwoStr];
            
            // 创表方法
            if ([db executeUpdate:createTableStr]) {
                NSLog(@"创表成功");
            }
        }
        
        // 关闭数据库
        [db close];
    }];
}

#pragma mark - 数据库更新或插入数据
// 参数1：model 实体对象
// 参数2：selectColumn 依据字段
- (void)insertAndUpdateModelToDatabase:(id)model selectColumn:(NSString *)selectColumn
{
    // 判断数据库操作队列是否存在
    if (!_dbQueue) {
        // 数据库操作队列不存，就得创建
        [self creatDBQueue];
    }
    
    // 使用数据库操作队列操作数据库
    [_dbQueue inDatabase:^(FMDatabase *db) {
        // 打开数据库
        if (![db open]) {
            // 数据库打开失败
            NSLog(@"数据库打开失败");
            return;
        }
        
        // 为数据设置缓存，提高查询效率
        [db setShouldCacheStatements:YES];
        
        // 判断是否存在该实体对象所对应的表
        if (![db tableExists:KCLASS_NAME(model)]) {
            // 不存在该实体对象所对应的表就去创表
            [self creatTable:model];
        }
        
        // 按照传进来的查找字段查找该条记录是否存在
        NSString *selectStr = [NSString stringWithFormat:@"select * from %@ where %@ = ?", KCLASS_NAME(model), selectColumn];
        // 获取实体对象的首个属性对应的值
        NSString *selectColumnValue = [model valueForKey:selectColumn];
        // 查找
        FMResultSet *resultSet = [db executeQuery:selectStr, selectColumnValue];
        // 判断查找结果是否为空
        // 如果有查找结果，对应实体对象就是更新操作
        if ([resultSet next]) {
            // 更新语句第一部分
            NSString *updateOneStr = [NSString stringWithFormat:@"update %@ set ",KCLASS_NAME(model)];
            
            // 更新语句第二部分
            NSMutableString *updateTwoStr = [NSMutableString string];
            // 遍历实体对象的属性数组
            // 跳过实体对应的首字段
            for (int i = 1; i < KMODEL_PROPERTYS_COUNT; i++) {
                // 获取实体属性字段
                NSString *propertyName = KMODEL_PROPERTYS[i];
                if ([propertyName isEqualToString:selectColumn]) {
                    continue;
                }
                [updateTwoStr appendFormat:@"%@ = ?", propertyName];
                // 判断是否遍历到属性数组的最后一个
                if (i != KMODEL_PROPERTYS_COUNT - 1) {
                    [updateTwoStr appendFormat:@", "];
                }
            }
            
            // 更新语句第三部分
            NSString *updateThreeStr = [NSString stringWithFormat:@" where %@ = %@",selectColumn, selectColumnValue];
            
            // 更新总语句
            NSString *updateStr = [NSString stringWithFormat:@"%@%@%@", updateOneStr, updateTwoStr, updateThreeStr];
            
            // 属性值数组
            NSMutableArray *propertyValueArr = [NSMutableArray array];
            // 遍历属性数组
            // 跳过实体对应的首字段
            for (int i = 1; i < KMODEL_PROPERTYS_COUNT; i++) {
                NSString *propertyName = KMODEL_PROPERTYS[i];
                if ([propertyName isEqualToString:selectColumn]) {
                    continue;
                }
                NSString *propertyValue = [model valueForKey:propertyName];
                if (propertyValue == nil) {
                    propertyValue = @"";
                }
                [propertyValueArr addObject:propertyValue];
            }
            
            // 调用更新方法
            if([db executeUpdate:updateStr withArgumentsInArray:propertyValueArr])
            {
                NSLog(@"数据更新成功");
            }
        } else {
            // 插入操作
            
            // 插入语句第一部分
            NSString *insertOneStr = [NSString stringWithFormat:@"insert into %@ (",KCLASS_NAME(model)];
            
            // 插入语句第二部分
            NSMutableString *insertTwoStr =[NSMutableString string];
            // 跳过实体对应的首字段
            for (int i = 1; i < KMODEL_PROPERTYS_COUNT; i++) {
                // 获取实体属性字段
                NSString *propertyName = KMODEL_PROPERTYS[i];
                [insertTwoStr appendFormat:@"%@", propertyName];
                if (i != KMODEL_PROPERTYS_COUNT - 1) {
                    [insertTwoStr appendFormat:@", "];
                }
            }
            
            // 插入语句第三部分
            NSString *insertThreeStr =[NSString stringWithFormat:@") values ("];
            
            // 插入语句第四部分
            NSMutableString *insertFourStr =[NSMutableString string];
            // 跳过实体对应的首字段
            for (int i = 1; i < KMODEL_PROPERTYS_COUNT; i++) {
                [insertFourStr appendFormat:@"?"];
                if (i != KMODEL_PROPERTYS_COUNT - 1) {
                    [insertFourStr appendFormat:@", "];
                }
            }
            
            // 插入整个语句
            NSString *insertStr = [NSString stringWithFormat:@"%@%@%@%@)", insertOneStr, insertTwoStr, insertThreeStr, insertFourStr];
            
            // 属性值数组
            NSMutableArray *propertyValueArr = [NSMutableArray array];
            // 遍历属性数组
            // 跳过实体对应的首字段
            for (int i = 1; i < KMODEL_PROPERTYS_COUNT; i++) {
                // 获取实体属性字段
                NSString *propertyName = KMODEL_PROPERTYS[i];
                // 通过实体的字段获取对应的值
                NSString *propertyValue = [model valueForKey:propertyName];
                // 判断这个值是否为nil
                if (propertyValue == nil) {
                    propertyValue = @"";
                }
                [propertyValueArr addObject:propertyValue];
            }
            
            // 调用插入方法
            if([db executeUpdate:insertStr withArgumentsInArray:propertyValueArr])
            {
                NSLog(@"插入成功");
            }
            
            // 关闭数据库
            [db close];
        }
    }];
}

#pragma mark - 删除元素
// 参数1：model 实体对象
// 参数2：selectColumn 依据字段
- (void)deleteModelInDatabase:(id)model selectColumn:(NSString *)selectColumn
{
    // 判断数据库操作队列是否存在
    if (!_dbQueue) {
        // 数据库操作队列不存，就得创建
        [self creatDBQueue];
    }
    
    // 使用数据库操作队列操作数据库
    [_dbQueue inDatabase:^(FMDatabase *db) {
        // 打开数据库
        if (![db open]) {
            // 数据库打开失败
            NSLog(@"数据库打开失败");
            return;
        }
        
        // 为数据设置缓存，提高查询效率
        [db setShouldCacheStatements:YES];
        
        // 判断是否存在该实体对象所对应的表
        if (![db tableExists:KCLASS_NAME(model)]) {
            // 不存在该实体对象所对应的表就去创表
            [self creatTable:model];
        }
        
        // 删除语句(根据实体首字段的首属性字段去删)
        NSString *deleteStr = [NSString stringWithFormat:@"delete from %@ where %@ = ?", KCLASS_NAME(model), selectColumn];
        
        // 执行删除方法
        // 实体字段对应的值
        NSString *selectColumnValue = [model valueForKey:selectColumn];
        if([db executeUpdate:deleteStr, selectColumnValue])
        {
            NSLog(@"删除成功");
        }
        
        // 关闭数据库
        [db close];
        
    }];
}

#pragma mark - 查找
// 参数1：tableName 表名
// 参数2：factorString 条件查找语句
// 返回值：直接返回实体数组
- (NSArray *)selectModelArrayInDatabase:(NSString *)tableName factorString:(NSString *)factorString
{
    // 判断数据库操作队列是否存在
    if (!_dbQueue) {
        // 数据库操作队列不存，就得创建
        [self creatDBQueue];
    }
    
    // 需要返回的实体数组(block里面需要改变其值，所以必须使用__block修饰)
    __block NSMutableArray *modelArray = [NSMutableArray array];
    
    // 使用数据库操作队列操作数据库
    [_dbQueue inDatabase:^(FMDatabase *db) {
        // 打开数据库
        if (![db open]) {
            // 数据库打开失败
            NSLog(@"数据库打开失败");
            return;
        }
        
        // 为数据设置缓存，提高查询效率
        [db setShouldCacheStatements:YES];
        
        // 条件查询
        NSString * selectStr = nil;
        if (factorString != nil) {
            selectStr = [NSString stringWithFormat:@"SELECT * FROM %@ %@",tableName, factorString];
        }else {
            // 全局查询
            selectStr = [NSString stringWithFormat:@"select * from %@",tableName];
        }
        
        FMResultSet *resultSet = [db executeQuery:selectStr];
        while([resultSet next]) {
            // 使用表名作为类名创建对应的类的对象
            id model = [[NSClassFromString(tableName) alloc] init];
            for (int i = 0; i < KMODEL_PROPERTYS_COUNT; i++) {
                // 值是从我们的数据表的Column字段取出来
                // 获取表中字段
                NSString *propertyName = KMODEL_PROPERTYS[i];
                NSString *propertyValue = [resultSet stringForColumn:propertyName];
                // 设置model对应属性的对应值
                [model setValue:propertyValue forKey:propertyName];
            }
            [modelArray addObject:model];
        }
    }];
    return modelArray;
}

@end

　　7）事务

　　　　例：银行转账系统，张三和李四账户上都有1000元钱，张三现在给李四转账500元

　　　　　　update t_account set money = 500 where name = @"张三";

　　　　　　update t_account set money = 1500 where name = @"李四";

　　　　　　张三给李四转账500元，这一操作就会执行上面两条SQL语句，但是考虑到安全性，我们必须要求两条语句同生同死。这个时候我们可以将他放在同一个事务中

　　　　事务：把多条语句放到同一个事务中，就会同生共死(即使前面的SQL语句执行成功，而后面的SQL执行失败，系统也会回滚，使它们全部失败)

    [_dbQueue inDatabase:^(FMDatabase *db) {
        // 创建事务
        [db beginTransaction];
        [db executeUpdate:@"insert into t_person (name, age) values (?, ?);", @"Frank", @22];
        [db executeUpdate:@"insert into t_person (name, age) values (?, ?);", @"Kin", @15];
        // 提交事务
        [db commit];
        }];