GYDataCenter

这是FMDB数据库的封装版本,具备内存缓存,自动创建及更新数据库表,线程安全,自动批量写入等特征,微信读书团队作品,值得信赖。
官方文章先容:http://wereadteam.github.io/2016/07/06/GYDataCenter/
下面是本人阅读源码的一点记录

GYDataContext,完成数据的增删改查等,先看内部私有类GYDataContextQueue,这个是模仿FMDatabaseQueue写的,利用串行队列保证线程安全

@interface GYDataContextQueue : NSObject
@property (nonatomic, strong) NSMutableDictionary *cache;
@end

@implementation GYDataContextQueue {
    dispatch_queue_t _queue;
}
static const void * const kDispatchQueueSpecificKey = &kDispatchQueueSpecificKey;

- (instancetype)initWithDBName:(NSString *)dbName {
    self = [super init];
    if (self) {
        _queue = dispatch_queue_create([[NSString stringWithFormat:@"GYDataCenter.%@", dbName] UTF8String], NULL);
        dispatch_queue_set_specific(_queue, kDispatchQueueSpecificKey, (__bridge void *)self, NULL);
        _cache = [[NSMutableDictionary alloc] init];
    }
    return self;
}

- (void)dispatchSync:(dispatch_block_t)block {
    GYDataContextQueue *currentQueue = (__bridge id)dispatch_get_specific(kDispatchQueueSpecificKey);
    if (currentQueue == self) { // .....@1
        block();
    } else {
        dispatch_sync(_queue, block);
    }
}
@end

dispatch_queue_create跟objc_setAssociatedObject方法类似,大意就是绑定一个对象到当前的队列,根据一个key取出来。在dispatchSync方法中,dispatch_get_specific就是获取到当前调用队列根据key所绑定的值。
@1的作用是避免在当前队列再次实行dispatch_sync(_queue, block)方法以防死锁。在FMDB中原文说明是

Get the currently executing queue (which should probably be nil, but in theory could be another DB queue
* and then check it against self to make sure we're not about to deadlock. 

下面看GYDataContext的四大基础操作

1、查询操作

- (id)getObject:(Class<GYModelObjectProtocol>)modelClass  properties:(NSArray*)properties
     primaryKey:(id)primaryKey {
    GYDataContextQueue *queue = [self queueForDBName:[modelClass dbName]];
    __block id object = nil;
    [queue dispatchSync:^{
        NSMutableDictionary *cache = [self tableCacheFromDBCache:queue.cache class:modelClass];
        object = [cache objectForKey:primaryKey];
        if (!object || ((id<GYModelObjectProtocol>)object).isFault) {
            NSString *where = [self whereIdSqlForClass:modelClass];
            NSArray *objects = [_dbRunner objectsOfClass:modelClass
                                              properties:properties
                                                   where:where
                                               arguments:@[ primaryKey ]];
            object = [objects firstObject];
            if (object && !properties.count) {
                [cache setObject:object forKey:primaryKey];
            }
        }
    }];
    return object;
}

在同步队列中,先查询内存缓存,没有就从磁盘_dbRunner中查,查到了再内存缓存起来。

2、写入操作

- (void)saveObject:(id<GYModelObjectProtocol>)object {
    Class<GYModelObjectProtocol> modelClass = [object class];
    GYDataContextQueue *queue = [self queueForDBName:[modelClass dbName]];
    [queue dispatchSync:^{
        if (object.isSaving) {
            return;
        }
        [(id)object setValue:@YES forKey:@"saving"];
        [_dbRunner saveObject:object];
        NSMutableDictionary *cache = [self tableCacheFromDBCache:queue.cache class:modelClass];
        if (cache) {
            [cache setObject:object forKey:[(id)object valueForKey:[modelClass primaryKey]]];
        }
        [(id)object setValue:@NO forKey:@"saving"];
    }];
}

先是存入磁盘,再缓存到内存中。在写入过程中对object的saving字段设置为YES,本意看起来是防止多次调用该方法时同时写入,但是既然是串行队列应该没有此类问题,个人觉得没什么用。

3、删除操作

- (void)deleteObject:(Class<GYModelObjectProtocol>)modelClass
          primaryKey:(id)primaryKey {
    GYDataContextQueue *queue = [self queueForDBName:[modelClass dbName]];
    [queue dispatchSync:^{
        NSMutableDictionary *cache = [self tableCacheFromDBCache:queue.cache class:modelClass];
        id object = [cache objectForKey:primaryKey];
        if (object) {
            [cache removeObjectForKey:primaryKey];
            [object setValue:@YES forKey:@"deleted"];
        }
        NSString *where = [self whereIdSqlForClass:modelClass];
        [_dbRunner deleteClass:modelClass
                         where:where
                     arguments:@[ primaryKey ]];
    }];
}

先删除内存缓存,在删除磁盘缓存。注意的是该对象虽然被从内存缓存中移除,但是外界可能尚有变量引用而不会释放,给对象的属性deleted置为YES,表征该对象已经被删除,外界在合适的时间判断这个deleted属性知晓。

4、修改操作

- (void)updateObject:(Class<GYModelObjectProtocol>)modelClass set:(NSDictionary *)set  primaryKey:(id)primaryKey {
   GYDataContextQueue *queue = [self queueForDBName:[modelClass dbName]];
    [queue dispatchSync:^{
        NSMutableDictionary *cache = [self tableCacheFromDBCache:queue.cache class:modelClass];
        [cache removeObjectForKey:primaryKey];
        NSString *where = [self whereIdSqlForClass:modelClass];
        [_dbRunner updateClass:modelClass set:set where:where arguments:@[ primaryKey ]];
    }];
}

先删除内存中的,在更新磁盘中的缓存。此时该对象的内存缓存已经没有了,待下一次查询操作的时候再次去磁盘查询最新的对象,并缓存到内存之中。这里为何不直接更新内存缓存,反而绕了个弯?感觉是因为接口设计的问题,这里的modelClass是一个类,而不是一个对象,没法直接使用。

GYDBRunner,写的是数据库的读写操作,事务处理等,以下是数据库的特性点
1、自动批量写入

- (void)autoTransactionForDatabaseInfo:(GYDatabaseInfo *)databaseInfo {
    databaseInfo.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, [databaseInfo.databaseQueue queue]);
    if (databaseInfo.timer) {
        [databaseInfo.databaseQueue asyncInDatabase:^(FMDatabase *db) {
            [db beginTransaction];
        }];
        dispatch_source_set_timer(databaseInfo.timer,
                                  dispatch_time(DISPATCH_TIME_NOW, kTransactionTimeInterval * NSEC_PER_SEC),
                                  kTransactionTimeInterval * NSEC_PER_SEC,
                                  NSEC_PER_MSEC);
        dispatch_source_set_event_handler(databaseInfo.timer, ^{
            if (databaseInfo.needCommitTransaction) {
                [databaseInfo.databaseQueue syncInDatabase:^(FMDatabase *db) {
                    [db commit];
                    [db beginTransaction];
                }];
                databaseInfo.needCommitTransaction = NO;
            }
        });
        dispatch_resume(databaseInfo.timer);
    }
}

开启定时器,开启事务,每隔1s自动提交该时间内的所有事务。当然不是所有的操作都需要事物,增删改的时候databaseInfo.needCommitTransaction才会设置为YES,才会进行事务提交保证数据库的正确性,查询操作的时候一般是没有事务操作的。
如果不手动加事务,SQLite 会为每个 SQL 的实行创建一个事务,耗费性能。把多个 SQL 的实行包在一个事务中,每隔1s提交一次,避免了创建多个事务的开销。在读写频繁的时候性能提升很大。

2、自动创建及更新数据库表
当实行数据库操作时,比较当前对象模型需要持久化存储的属性,跟数据库中已存储对象的属性之间的差别,只支撑当前对象属性增加时的自动更新数据库表结构,对删除、修改字段无能为力,此时需要自己新建表,完成数据迁移。

3、关系型 property 及 faulting
当数据库查询Employee时,若发现其某一个属性department所对应的是另外一个关系对象Department,此时并不会联动查询Department,而只是会创建Department对象,设置department属性,让Employee的department属性指向Department。此时,会对Department对象做一个标记,设置其fault属性为YES,当真正使用Employee的department属性时,发现对应Department的 fault属性为YES,知晓其为不完全初始化的值,再去查找数据库Department。
再来具体化看下GYDataContext的查询操作

- (id)getObject:(Class<GYModelObjectProtocol>)modelClass  properties:(NSArray*)properties
     primaryKey:(id)primaryKey {
    GYDataContextQueue *queue = [self queueForDBName:[modelClass dbName]];
    __block id object = nil;
    [queue dispatchSync:^{
        NSMutableDictionary *cache = [self tableCacheFromDBCache:queue.cache class:modelClass];
        object = [cache objectForKey:primaryKey];
        if (!object || ((id<GYModelObjectProtocol>)object).isFault) {// ......@2
            NSString *where = [self whereIdSqlForClass:modelClass];
            NSArray *objects = [_dbRunner objectsOfClass:modelClass
                                              properties:properties
                                                   where:where
                                               arguments:@[ primaryKey ]];
            object = [objects firstObject];
            if (object && !properties.count) {
                [cache setObject:object forKey:primaryKey];
            }
        }
    }];
    return object;
}

刚开始查询Employee对象,参数modelClass为Employee,@2条件因为object为nil进入,去数据库查询Employee对象,注意内部会将Employee.department所指向的Department对象局部实例化并缓存起来,设置isFault为YES,同时让Employee.department指向该对象。当用户具体使用到Employee.department时,会再次进入该方法,此时参数modelClass为Department对象。查找缓存找到对应的对象,但是发现isFault为YES,为未完全初始化对象,再去数据库查找实例化。
Faulting 机制避免了拿一个对象时把它所有的关系对象,以及关系对象的关系对象都拿出来。这样可以提升查询速度,延迟加载所需对象。

推荐阅读更多精彩内容