ToB企服应用市场:ToB评测及商务社交产业平台

标题: iOS全埋点解决方案-数据存储 [打印本页]
作者: 吴旭华    时间: 2022-6-20 14:54
标题: iOS全埋点解决方案-数据存储
前言

​        SDK 需要把事件数据缓冲到本地，待符合一定策略再去同步数据。
一、数据存储策略

​        在 iOS 应用程序中，从 “数据缓冲在哪里” 这个纬度看，缓冲一般分两种类型。
​        内存缓冲是将数据缓冲在内存中，供应用程序直接读取和使用。优点是读取速度快。缺点是由于内存资源有限，应用程序在系统中申请的内存，会随着应用生命周期结束而被释放，会导致内存中的数据丢失，因此将事件数据缓冲到内存中不是最佳选择。
​        磁盘缓冲是将数据缓冲到磁盘空间中，其特点正好和磁盘缓冲相反。磁盘缓冲容量打，但是读写速度对于内存缓冲要慢点。不过磁盘缓冲可以持久化存储，不受应用程序生命周期影响。因为，将数据保存在磁盘中，丢失的风险比较低。即使磁盘缓冲数据速度较慢，但综合考虑，磁盘缓冲是缓冲事件数据最优的选择。
1.1 沙盒

​        iOS 系统为了保证系统的安全性，采用了沙盒机制（即每个应用程序都有自己的一个独立存储空间）。其原理就是通过重定向技术，把应用程序生成和修改的文件重定向到自身的文件中。因此，在 iOS 应用程序里，磁盘缓存的数据一般都存储在沙盒中。
​        我们可以通过下面的方式获取沙盒路径：
  1. // 获取沙盒主目录路径
  2. NSString *homeDir = NSHomeDirectory();
复制代码
​        在模拟上，输出沙盒路径示例如下：
  1. /Users/renwei/Library/Developer/CoreSimulator/Devices/B1D7EC3E-BE72-4F8D-A4EF-E3D6316827CF/data/Containers/Data/Application/229B24A6-E13D-4DE6-9B52-363E832F9717
复制代码
​        沙盒的根目录下有三个常用的文件夹：
（1）Document 文件夹
​        在 Document 文件夹中，保存的一般是应用程序本身产生的数据。
​        获取 Document 文件夹路径的方法：
  1. NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask , YES).lastObject;
复制代码
  1. /Users/renwei/Library/Developer/CoreSimulator/Devices/B1D7EC3E-BE72-4F8D-A4EF-E3D6316827CF/data/Containers/Data/Application/86212089-1D48-4B92-A919-AB87D3683191/Documents
复制代码
（2） Library 文件夹
​                获取 Library 文件夹路径方法：
  1.     NSString *path = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask , NO).lastObject;
复制代码
  1. /Users/renwei/Library/Developer/CoreSimulator/Devices/B1D7EC3E-BE72-4F8D-A4EF-E3D6316827CF/data/Containers/Data/Application/4BBA5D3E-0C75-4543-B831-AE3344DCC940/Library
复制代码
在 Library 文件夹下有两个常用的子文件夹：
​        Caches 文件夹主要用来保存应用程序运行时产生的需要持久化的数据，需要应用程序复制删除。
获取 Caches 文件夹路径的方法
  1.     NSString *path = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask , YES).lastObject;
复制代码
  1. /Users/renwei/Library/Developer/CoreSimulator/Devices/B1D7EC3E-BE72-4F8D-A4EF-E3D6316827CF/data/Containers/Data/Application/38CEA9CA-4C49-4B94-84F3-16E434ABFE0F/Library/Caches
复制代码
​        Preferences 文件保存的是应用程序的偏好设置，即 iOS 系统设置应用会从该目录中读取偏好设置信息，因此，该目录一般不用于存储应用程序产生的数据。
（3）tmp 文件夹
​        tmp 文件夹主要用于保存应用程序运行时参数的临时数据，使用后在将相应的文件从该目录中删除，不会对 tmp 文件中的数据进行备份。
​        获取 tmp 文件路径的方法：
  1. NSString *path = NSTemporaryDirectory();
复制代码
  1. /Users/renwei/Library/Developer/CoreSimulator/Devices/B1D7EC3E-BE72-4F8D-A4EF-E3D6316827CF/data/Containers/Data/Application/8E8906B8-0CBC-4A83-A220-A09F397304CD/tmp/
复制代码
通过上面综合对比发现，最适合缓存事件数据的地方，就是 Library 下 Caches 文件夹中。
1.2 数据缓存

​        在 iOS 应用程序中，一般通过两种方式进行磁盘缓存：
​        这两种方式都是可以实现数据采集 SDK 的缓冲机制。缓冲的策略即当事件发生后，先将事件数据存储在缓存中，待符合一定策略后从缓存中读取事件数据并进行同步，同步成功后，将已同步的事件从缓存中删除。
​        对于写入的性能，SQLite 数据库优于文件缓存.
​        对于读取的性能：如果单条数据小于 100KB，则 SQLite 数据库读取的速度更快。如果单条数据大于 100KB，则从文件中读取的速度更快。
​        因此，数据采集 SDK 一般都是使用 SQLite 数据库来缓存数据，这样可以拥有最佳的读写性能。如果希望采集更完整，更全面的信息，比如采集用户操作时当前截图的信息（一般超过100KB）,文件缓存可能是最优的选择。
二、文件缓存

​        可以使用 NSKeyedArchiver 类将字典对象进行归档并写入文件，也可以使用 NSJSONSerialization 类把字典对象转成 JSON 格式字符串写入文件。
2.1 实现步骤

第一步：新建处理文件的工具类 SensorsAnalyticsFileStore ，在工具类中新增一个属性 filePath 用于保存存储文件的路径。在  SensorsAnalyticsFileStore 文件的 -init 方法中初始化 filePath 属性，我们默认在 Caches 目录下 SensorsAnalytics.plist 文件来缓存数据。
  1. @interface SensorsAnalyticsFileStore : NSObject
  3. /// 保存存储文件的路径
  4. @property (nonatomic, copy) NSString *filePath;
  6. @end
复制代码
  1. static NSString * const SensorsAnalyticsDefaultFileName = @"SensorsAnalytics.plist";
  3. @implementation SensorsAnalyticsFileStore
  5. - (instancetype)init {
  6.     self = [super init];
  7.     if (self) {
  8.         // 初始化默认的事件数据存储地址
  9.         _filePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultFileName];
  10.     }
  11.     return self;
  12. }
  14. @end
复制代码
第二步：我们使用 NSJSONSerialization 类将字典对象转换成 JSON 格式并写入文件。新增 - saveEvent: 方法用于事件数据写入文件，同时，新增 NSMutableArray *events；并在  - init 方法中进行初始化
  1. - (instancetype)init {
  2.     self = [super init];
  3.     if (self) {
  4.         // 初始化默认的事件数据存储地址
  5.         _filePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultFileName];
  6.         // 初始化事件数据，从文件路径中读取数据
  7.        [self readAllEventsFromFilePath:_filePath];
  8.     }
  9.     return self;
  10. }
  12. - (void)saveEvent:(NSDictionary *)event {
  13.     // 在数组中直接添加事件数据
  14.     [self.events addObject:event];
  15.     // 将事件数据保存在文件中
  16.     [self writeEventsToFile];
  17.    
  18. }
  20. - (void)writeEventsToFile {
  21.     NSError *error = nil;
  22.     // 将字典数据解析成 JSON 数据
  23.     NSData *data = [NSJSONSerialization dataWithJSONObject:self.events options:NSJSONWritingPrettyPrinted error:&error];
  24.     if (error) {
  25.         return NSLog(@"The JSON object`s serialization error: %@", error);
  26.     }
  27.    
  28.     // 将数据写入到文件
  29.     [data writeToFile:self.filePath atomically:YES];
  30. }
复制代码
第三步：在 SensorsAnalyticsSDK.m 文件中新增一个 SensorsAnalyticsFileStore 类型属性 fileStroe，并在 - init 方法中进行初始化
  1. #import "SensorsAnalyticsFileStore.h"
  3. /// 文件缓存事件数据对象
  4. @property (nonatomic, strong) SensorsAnalyticsFileStore *fileStroe;
  6. - (instancetype)init {
  7.     self = [super init];
  8.     if (self) {
  9.         _automaticProperties = [self collectAutomaticProperties];
  11.         // 设置是否需是被动启动标记
  12.         _launchedPassively = UIApplication.sharedApplication.backgroundTimeRemaining != UIApplicationBackgroundFetchIntervalNever;
  13.         
  14.         _loginId = [[NSUserDefaults standardUserDefaults] objectForKey:SensorsAnalyticsLoginId];
  15.         
  16.         _trackTimer = [NSMutableDictionary dictionary];
  17.         
  18.         _enterBackgroundTrackTimerEvents = [NSMutableArray array];
  19.         
  20.         _fileStroe = [[SensorsAnalyticsFileStore alloc] init];
  21.         
  22.         // 添加应用程序状态监听
  23.         [self setupListeners];
  24.     }
  25.     return self;
  26. }
复制代码
第四步：修改 SensorsAnalyticsSDK 的类别 Track 中的 - track: properties: 方法。
  1. - (void)track:(NSString *)eventName properties:(nullable NSDictionary<NSString *, id> *)properties {
  2.     NSMutableDictionary *event = [NSMutableDictionary dictionary];
  3.     // 设置事件 distinct_id 字段，用于唯一标识一个用户
  4.     event[@"distinct_id"] = self.loginId ?: self.anonymousId;
  5.     // 设置事件名称
  6.     event[@"event"] = eventName;
  7.     // 事件发生的时间戳，单位毫秒
  8.     event[@"time"] = [NSNumber numberWithLong:NSDate.date.timeIntervalSince1970 *1000];
  9.    
  10.     NSMutableDictionary *eventProperties = [NSMutableDictionary dictionary];
  11.     // 添加预置属性
  12.     [eventProperties addEntriesFromDictionary:self.automaticProperties];
  13.     // 添加自定义属性
  14.     [eventProperties addEntriesFromDictionary:properties];
  15.     // 判断是否是被动启动状态
  16.     if (self.isLaunchedPassively) {
  17.         eventProperties[@"$app_state"] = @"background";
  18.     }
  19.     // 设置事件属性
  20.     event[@"propeerties"] = eventProperties;
  21.    
  22.     // 打印
  23.     [self printEvent:event];
  24.     [self.fileStroe saveEvent:event];
  25. }
复制代码
第五步：测试验证
第六步：在文件中读取和删除事件数据
  1. @interface SensorsAnalyticsFileStore : NSObject
  3. /// 保存存储文件的路径
  4. @property (nonatomic, copy) NSString *filePath;
  6. /// 获取本地缓存的所有事件数据
  7. @property (nonatomic, copy, readonly) NSArray<NSDictionary *> *allEvents;
  9. /// 将事件保存到文件中
  10. /// @param event 事件数据
  11. - (void)saveEvent:(NSDictionary *)event;
  14. /// 根据数量删除本地保存的事件数据
  15. /// @param count 需要删除的事件数量
  16. - (void)deleteEventsForCount:(NSInteger)count;
  18. @end
复制代码
  1. - (void)readAllEventsFromFilePath:(NSString *)filePath {
  2.     NSData *data = [NSData dataWithContentsOfFile:filePath];
  3.     if (data) {
  4.         // 解析在文件中读取 JSON 数据
  5.         NSMutableArray *allEvents = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableContainers error:nil];
  6.         // 将文件中的数据读取到内存中
  7.         self.events = allEvents ?: [NSMutableArray array];
  8.     } else {
  9.         self.events = [NSMutableArray array];
  10.     }
  11. }
  13. - (NSArray<NSDictionary *> *)allEvents {
  14.     return [self.events copy];
  15. }
  17. - (void)deleteEventsForCount:(NSInteger)count {
  18.     // 删除前 count 条事件数据
  19.     [self.events removeObjectsInRange:NSMakeRange(0, count)];
  20.     // 将删除后剩余的事件数据保存到文件中
  21.     [self writeEventsToFile];
  22.    
  23. }
复制代码
2.2 优化

​        通过上面实现文件缓存存在两个非常明细的问题。
（1）如果在主线程中触发事件，那么读取事件、保存事件及删除事件都在主线程中运行，会出现所谓的 “卡主线程”问题。
（2）在无网环境下，如果在文件中缓存了大量的事件数据，会导致内存占用过大，影响应用程序性能。
2.2.1 多线程优化

​        解决 “卡主线程” 问题的方法主要是把处理文件的逻辑都放到多线程中运行。
第一步：在 SensorsAnalyticsFileStore.m 文件中新增一个 dispatch_queue_t 类型的属性 queue， 并在 -init 方法中进行初始化
  1. @interface SensorsAnalyticsFileStore()
  3. /// 事件数据
  4. @property (nonatomic, strong) NSMutableArray<NSDictionary *> *events;
  6. /// 串行队列
  7. @property (nonatomic, strong) dispatch_queue_t queue;
  9. @end
  11. @implementation SensorsAnalyticsFileStore
  13. - (instancetype)init {
  14.     self = [super init];
  15.     if (self) {
  16.         // 初始化默认的事件数据存储地址
  17.         _filePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultFileName];
  18.       
  19.         // 初始化队列的唯一标识
  20.         NSString *label = [NSString stringWithFormat:@"cn.sensorsdata.serialQueue.%p", self];
  21.         // 创建一个 serial 类型的 queue，即 FIFO
  22.         _queue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_SERIAL);
  23.         
  24.         _maxLocalEventCount = 1000;
  25.         
  26.         // 初始化事件数据，从文件路径中读取数据
  27.        [self readAllEventsFromFilePath:_filePath];
  28.     }
  29.     return self;
  30. }
  31. @end
复制代码
第二步：使用 dispatch_async 函数优化 - saveEvent: 、-  readAllEventsFromFilePath: 及 - deleteEventsForCount: 方法，使用 dispatch_sync 函数优化 - allEvents 方法
  1. //
  2. //  SensorsAnalyticsFileStore.m
  3. //  SensorsSDK
  4. //
  5. //  Created by 任伟 on 2022/4/12.
  6. //
  8. #import "SensorsAnalyticsFileStore.h"
  10. static NSString * const SensorsAnalyticsDefaultFileName = @"SensorsAnalytics.plist";
  12. @interface SensorsAnalyticsFileStore()
  14. /// 事件数据
  15. @property (nonatomic, strong) NSMutableArray<NSDictionary *> *events;
  17. /// 串行队列
  18. @property (nonatomic, strong) dispatch_queue_t queue;
  20. @end
  22. @implementation SensorsAnalyticsFileStore
  24. - (instancetype)init {
  25.     self = [super init];
  26.     if (self) {
  27.         // 初始化默认的事件数据存储地址
  28.         _filePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultFileName];
  29.       
  30.         // 初始化队列的唯一标识
  31.         NSString *label = [NSString stringWithFormat:@"cn.sensorsdata.serialQueue.%p", self];
  32.         // 创建一个 serial 类型的 queue，即 FIFO
  33.         _queue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_SERIAL);
  34.         
  35.         _maxLocalEventCount = 1000;
  36.         
  37.         // 初始化事件数据，从文件路径中读取数据
  38.        [self readAllEventsFromFilePath:_filePath];
  39.     }
  40.     return self;
  41. }
  43. - (void)saveEvent:(NSDictionary *)event {
  44.     dispatch_async(self.queue, ^{
  45.         if (self.events.count >= _maxLocalEventCount) {
  46.             [self.events removeObjectAtIndex:0];
  47.         }
  48.         // 在数组中直接添加事件数据
  49.         [self.events addObject:event];
  50.         // 将事件数据保存在文件中
  51.         [self writeEventsToFile];
  52.     });
  53. }
  55. - (void)writeEventsToFile {
  56.     NSError *error = nil;
  57.     // 将字典数据解析成 JSON 数据
  58.     NSData *data = [NSJSONSerialization dataWithJSONObject:self.events options:NSJSONWritingPrettyPrinted error:&error];
  59.     if (error) {
  60.         return NSLog(@"The JSON object`s serialization error: %@", error);
  61.     }
  62.    
  63.     // 将数据写入到文件
  64.     [data writeToFile:self.filePath atomically:YES];
  65. }
  67. - (void)readAllEventsFromFilePath:(NSString *)filePath {
  68.     dispatch_async(self.queue, ^{
  69.         NSData *data = [NSData dataWithContentsOfFile:filePath];
  70.         if (data) {
  71.             // 解析在文件中读取 JSON 数据
  72.             NSMutableArray *allEvents = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableContainers error:nil];
  73.             // 将文件中的数据读取到内存中
  74.             self.events = allEvents ?: [NSMutableArray array];
  75.         } else {
  76.             self.events = [NSMutableArray array];
  77.         }
  78.     });
  79. }
  81. - (NSArray<NSDictionary *> *)allEvents {
  82.     __block NSArray<NSDictionary *> *allEvents = nil;
  83.     dispatch_sync(self.queue, ^{
  84.         allEvents = [self.events copy];
  85.     })
  86.     return allEvents;
  87. }
  89. - (void)deleteEventsForCount:(NSInteger)count {
  90.     dispatch_async(self.queue, ^{
  91.         // 删除前 count 条事件数据
  92.         [self.events removeObjectsInRange:NSMakeRange(0, count)];
  93.         // 将删除后剩余的事件数据保存到文件中
  94.         [self writeEventsToFile];
  95.     });
  96. }
  98. @end
复制代码
2.2.2 内存优化

​        设置一个本地可缓存的最大事件条数，当本地已经缓存到事件条数超过本地可缓存最大事件条数时，删除最旧的事件数据。以保证最新的事件数据可以被缓存。
第一步：在 SensorsAnalyticsFileStore.h 文件中新增 maxLocalEventCount 属性, 并在 - init 方法中进行初始化，默认设置 1000 条数。
  1. /// 本地可最大缓存事件条数
  2. @property (nonatomic) NSUInteger maxLocalEventCount;
复制代码
  1. - (instancetype)init {
  2.     self = [super init];
  3.     if (self) {
  4.         // 初始化默认的事件数据存储地址
  5.         _filePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultFileName];
  6.       
  7.         // 初始化队列的唯一标识
  8.         NSString *label = [NSString stringWithFormat:@"cn.sensorsdata.serialQueue.%p", self];
  9.         // 创建一个 serial 类型的 queue，即 FIFO
  10.         _queue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_SERIAL);
  11.         
  12.         _maxLocalEventCount = 1000;
  13.         
  14.         // 初始化事件数据，从文件路径中读取数据
  15.        [self readAllEventsFromFilePath:_filePath];
  16.     }
  17.     return self;
  18. }
复制代码
第二步：在 - saveEvent: 方法插入数据之前，先判断已缓存的事件条数是否超过了本地可缓存的事件条数，如果已经超过，则删除最旧的事件
  1. - (void)saveEvent:(NSDictionary *)event {
  2.     dispatch_async(self.queue, ^{
  3.         if (self.events.count >= _maxLocalEventCount) {
  4.             [self.events removeObjectAtIndex:0];
  5.         }
  6.         // 在数组中直接添加事件数据
  7.         [self.events addObject:event];
  8.         // 将事件数据保存在文件中
  9.         [self writeEventsToFile];
  10.     });
  11. }
复制代码
2.3 总结

​        我们可以使用文件缓存实现事件数据的持久化操作。
首先，主要实现了一下三个功能：
然后有进行了两项优化
​        文件缓存相对来说还是比较简单，主要操作就是写文件和读取文件。每次写入的 数据量越大，文件缓存的性能越好。
​        当然，文件缓存是不够灵活的，我们很难使用更细的颗粒去操作数据。比如很难对某一条数据进行读写操作。
三、数据库缓存

​        在 iOS 应用程序中，使用的数据库一般是 SQLite 数据库，SQLite 是轻量级数据库，数据存储简单高效，使用也非常简单，只是需要在项目中添加 libssqlite3.0 依赖，并在使用的时候引入 sqlite3.h 头文件即可。
3.1 实现步骤

第一步：创建 SensorsAnalyticsDatabase 工具类
  1. //
  2. //  SensorsAnalyticsDatabase.h
  3. //  SensorsSDK
  4. //
  5. //  Created by 任伟 on 2022/4/13.
  6. //
  8. #import <Foundation/Foundation.h>
  10. NS_ASSUME_NONNULL_BEGIN
  12. @interface SensorsAnalyticsDatabase : NSObject
  14. /// 数据库文件的路径
  15. @property (nonatomic, copy, readonly) NSString *filePath;
  17. //+ (instancetype)new NS_UNAVAILABLE;
  18. //- (instancetype)init NS_UNAVAILABLE;
  19. /// 初始化方法
  20. /// @param filePath 数据库路径，如果是nil, 使用默认路径
  21. - (instancetype)initWithFilePath:(nullable NSString *)filePath NS_DESIGNATED_INITIALIZER;
  24. /// 同步向数据库插入事件数据
  25. /// @param event 事件
  26. - (void)insertEvent: (NSDictionary *) event;
  29. /// 从数据库中获取事件数据
  30. /// @param count 获取事件数据条数
  31. - (NSArray<NSString *> *)selectEventsForCount:(NSInteger)count;
  34. /// 从数据库中删除一定数量的事件数据
  35. /// @param count 需要删除的事件条数
  36. - (BOOL)deleteEventsForCount:(NSInteger)count;
  38. @end
  40. NS_ASSUME_NONNULL_END
复制代码
  1. //
  2. //  SensorsAnalyticsDatabase.m
  3. //  SensorsSDK
  4. //
  5. //  Created by 任伟 on 2022/4/13.
  6. //
  8. #import "SensorsAnalyticsDatabase.h"
  10. #import <sqlite3.h>
  12. static NSString * const SensorsAnalyticsDefaultDatabaseName = @"SensorsAnalyticsDatabase.sqlite";
  14. @interface SensorsAnalyticsDatabase()
  16. /// 数据库文件的路径
  17. @property (nonatomic, copy) NSString *filePath;
  19. /// 数据库私有属性
  20. @property (nonatomic) sqlite3 *database;
  22. /// 串行队列
  23. @property (nonatomic, strong) dispatch_queue_t queue;
  25. @end
  27. @implementation SensorsAnalyticsDatabase {
  28.     sqlite3 *_database;
  29. }
  31. - (instancetype)init {
  32.     return [self initWithFilePath:nil];
  33. }
  35. - (instancetype)initWithFilePath:(NSString *)filePath {
  36.     self = [super init];
  37.     if (self) {
  38.         _filePath = filePath ?: [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultDatabaseName];
  39.         
  40.         // 初始化队列的唯一标识
  41.         NSString *label = [NSString stringWithFormat:@"cn.sensorsdata.serialQueue.%p", self];
  42.         // 创建一个 serial 类型的 queue，即 FIFO
  43.         _queue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_SERIAL);
  44.         
  45.         // 打开数据库
  46.         [self open];
  47.     }
  48.     return self;
  49. }
  51. - (void)open {
  52.     dispatch_async(self.queue, ^{
  53.         // 初始化 SQLite 库
  54.         if (sqlite3_initialize() != SQLITE_OK) {
  55.             return;
  56.         }
  57.         
  58.         // 打开数据库，获取数据库指针
  59.         if (sqlite3_open_v2([self.filePath UTF8String], &(self->_database), SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK) {
  60.             return NSLog(@"SQLite stmt  prepare error: %s", sqlite3_errmsg(self.database));
  61.         }
  62.         
  63.         char *error;
  64.         // 创建数据库表的 SQL 语句
  65. //        NSString *sql = @"CREATE TABLE IF NOT EXISTS events（id integer PRIMARY KEY AUTOINCREMENT, name text NOT NULL UNIQUE）;";
  66.       NSString *sql = @"CREATE TABLE IF NOT EXISTS events (id integer PRIMARY KEY AUTOINCREMENT, event BLOB);";
  67.         // 运行创建表格的 SQL 语句
  68.         if (sqlite3_exec(self.database, [sql UTF8String], NULL, NULL, &error) != SQLITE_OK) {
  69.             return NSLog(@"Create events failure %s", error);
  70.         }
  71.     });
  72. }
  74. - (void)insertEvent:(NSDictionary *)event {
  75.     dispatch_async(self.queue, ^{
  76.         // 自定义 SQLite Statement
  77.         sqlite3_stmt *stmt;
  78.         // 插入语句
  79.         NSString *sql = @"INSERT INTO events (event) values (?)";
  80.         // 准备执行 SQL 语句，获取 sqlite3_stmt
  81.         if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &stmt, NULL) != SQLITE_OK) {
  82.             // 准备执行 SQL 语句失败，打印 log 返回失败 NO
  83.             return NSLog(@"SQLite stmt prepare error: %s", sqlite3_errmsg(self.database));
  84.         }
  85.         NSError *error;
  86.         // 将 event 转换成 JSON 数据
  87.         NSData *data = [NSJSONSerialization dataWithJSONObject:event options:NSJSONWritingPrettyPrinted error:&error];
  88.         if (error) {
  89.             return NSLog(@"The JSON object`s serialization error: %@", error);
  90.         }
  91.         
  92.         // 将JSON数据与 stmt 绑定
  93.         sqlite3_bind_blob(stmt, 1, data.bytes, (int)data.length, SQLITE_TRANSIENT);
  94.         // 执行 stmt
  95.         if (sqlite3_step(stmt) != SQLITE_DONE) {
  96.             // 执行失败，打印log，返回失败（NO）
  97.             return NSLog(@"Insert event into events error");
  98.         }
  99.     });
  100. }
  102. - (NSArray<NSString *> *)selectEventsForCount:(NSInteger)count {
  103.     // 初始化数组，用于存储查询到的事件数据
  104.     NSMutableArray<NSString *> *events = [NSMutableArray arrayWithCapacity:count];
  105.     dispatch_sync(self.queue, ^{
  106.         // 自定义 SQLite Statement
  107.         sqlite3_stmt *stmt;
  108.         // 查询语句
  109.         NSString *sql = [NSString stringWithFormat:@"SELECT id, event FROM events ORDER BY id ASC LIMIT %lu", (unsigned long)count];
  110.         // 准备执行 SQL 语句，获取sqlite3——stmt
  111.         if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &stmt, NULL) != SQLITE_OK) {
  112.             // 准备执行 SQL 语句失败，打印log返回失败(no)
  113.             return NSLog(@"SQLite stmt prepare error： %s,", sqlite3_errmsg(self.database));
  114.         }
  115.         
  116.         // 执行 SQL 语句
  117.         while (sqlite3_step(stmt) == SQLITE_ROW) {
  118.             // 将当前查询的这条数据转换成 NSData 对象
  119.             NSData *data = [[NSData alloc] initWithBytes:sqlite3_column_blob(stmt, 1) length:sqlite3_column_bytes(stmt, 1)];
  120.             // 将查询到的时间数据转换成JSON字符串
  121.             NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  122. #ifdef DUBUG
  123.             NSLog(@"%@", jsonString);
  124. #endif
  125.             // 将JSON字符串添加到数组中
  126.             [events addObject:jsonString];
  127.         }
  128.     });
  129.     return events;
  130. }
  132. - (BOOL)deleteEventsForCount:(NSInteger)count {
  133.     __block BOOL success = YES;
  134.     dispatch_sync(self.queue, ^{
  135.         // 删除语句
  136.         NSString *sql = [NSString stringWithFormat:@"DELETE FROM events WHERE id IN (SELECT id FROM events ORDER BY id ASC LIMIT %lu);", (unsigned long)count];
  137.         char *errmsg;
  138.         //执行删除语句
  139.         if (sqlite3_exec(self.database, sql.UTF8String, NULL, NULL, &errmsg) != SQLITE_OK) {
  140.             success = NO;
  141.             return NSLog(@"Failed to delete record msg=%s", errmsg);
  142.         }
  143.     });
  144.    
  145.     return success;
  146. }
  148. @end
复制代码
第二步：在 SensorsAnalyticsSDK.m 文件中新增 SensorsAnalyticsDatabase 类型私有属性 database，并在 -init 方法中进行初始化
  1. - (instancetype)init {
  2.     self = [super init];
  3.     if (self) {
  4.         _automaticProperties = [self collectAutomaticProperties];
  6.         // 设置是否需是被动启动标记
  7.         _launchedPassively = UIApplication.sharedApplication.backgroundTimeRemaining != UIApplicationBackgroundFetchIntervalNever;
  8.         
  9.         _loginId = [[NSUserDefaults standardUserDefaults] objectForKey:SensorsAnalyticsLoginId];
  10.         
  11.         _trackTimer = [NSMutableDictionary dictionary];
  12.         
  13.         _enterBackgroundTrackTimerEvents = [NSMutableArray array];
  14.         
  15.         _fileStroe = [[SensorsAnalyticsFileStore alloc] init];
  16.         
  17.         _database = [[SensorsAnalyticsDatabase alloc] init];
  18.         
  19.         // 添加应用程序状态监听
  20.         [self setupListeners];
  21.     }
  22.     return self;
  23. }
复制代码
第三步：修改 -track: properties: 的数据存储方式
  1. - (void)track:(NSString *)eventName properties:(nullable NSDictionary<NSString *, id> *)properties {
  2.     NSMutableDictionary *event = [NSMutableDictionary dictionary];
  3.     // 设置事件 distinct_id 字段，用于唯一标识一个用户
  4.     event[@"distinct_id"] = self.loginId ?: self.anonymousId;
  5.     // 设置事件名称
  6.     event[@"event"] = eventName;
  7.     // 事件发生的时间戳，单位毫秒
  8.     event[@"time"] = [NSNumber numberWithLong:NSDate.date.timeIntervalSince1970 *1000];
  9.    
  10.     NSMutableDictionary *eventProperties = [NSMutableDictionary dictionary];
  11.     // 添加预置属性
  12.     [eventProperties addEntriesFromDictionary:self.automaticProperties];
  13.     // 添加自定义属性
  14.     [eventProperties addEntriesFromDictionary:properties];
  15.     // 判断是否是被动启动状态
  16.     if (self.isLaunchedPassively) {
  17.         eventProperties[@"$app_state"] = @"background";
  18.     }
  19.     // 设置事件属性
  20.     event[@"propeerties"] = eventProperties;
  21.    
  22.     // 打印
  23.     [self printEvent:event];
  24. //    [self.fileStroe saveEvent:event];
  25.     [self.database insertEvent:event];
  26. }
复制代码
第四步：测试验证（和文件存储验证方式一样）
3.2 优化

​        需要优化的内容：
在每次插入和查询数据的时候，都会执行 “准备执行SQL的语句”的操作，比较浪费资源
在查询和删除操作时，如果数据表中没有存储任何的数据，其实无须执行 SQL 语句
（1）缓存 sqlite3_stmt
  1. static sqlite3_stmt *insertStmt = NULL;
  2. - (void)insertEvent:(NSDictionary *)event {
  3.     dispatch_async(self.queue, ^{
  4.         if (insertStmt) {
  5.             // 重置插入语句，重置之后可重新绑定数据
  6.             sqlite3_reset(insertStmt);
  7.         } else {
  8.             // 插入语句
  9.             NSString *sql = @"INSERT INTO events (event) values (?)";
  10.             // 准备执行 SQL 语句，获取 sqlite3_stmt
  11.             if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &insertStmt, NULL) != SQLITE_OK) {
  12.                 // 准备执行 SQL 语句失败，打印 log 返回失败 NO
  13.                 return NSLog(@"SQLite stmt prepare error: %s", sqlite3_errmsg(self.database));
  14.             }
  15.         }
  17.         NSError *error;
  18.         // 将 event 转换成 JSON 数据
  19.         NSData *data = [NSJSONSerialization dataWithJSONObject:event options:NSJSONWritingPrettyPrinted error:&error];
  20.         if (error) {
  21.             return NSLog(@"The JSON object`s serialization error: %@", error);
  22.         }
  23.         
  24.         // 将JSON数据与 insertStmt 绑定
  25.         sqlite3_bind_blob(insertStmt, 1, data.bytes, (int)data.length, SQLITE_TRANSIENT);
  26.         // 执行 stmt
  27.         if (sqlite3_step(insertStmt) != SQLITE_DONE) {
  28.             // 执行失败，打印log，返回失败（NO）
  29.             return NSLog(@"Insert event into events error");
  30.         }
  31.     });
  32. }
复制代码
  1. // 最后一次查询下的事件数量
  2. static NSUInteger lastSelectEventCount = 50;
  3. static sqlite3_stmt *selectStmt = NULL;
  4. - (NSArray<NSString *> *)selectEventsForCount:(NSInteger)count {
  5.     // 初始化数组，用于存储查询到的事件数据
  6.     NSMutableArray<NSString *> *events = [NSMutableArray arrayWithCapacity:count];
  7.     dispatch_sync(self.queue, ^{
  8.         if (count != lastSelectEventCount) {
  9.             lastSelectEventCount = count;
  10.             selectStmt = NULL;
  11.         }
  12.         if (selectStmt) {
  13.             // 重置插入语句，重置之后可重新查询数据
  14.             sqlite3_reset(selectStmt);
  15.         } else {
  16.             // 查询语句
  17.             NSString *sql = [NSString stringWithFormat:@"SELECT id, event FROM events ORDER BY id ASC LIMIT %lu", (unsigned long)count];
  18.             // 准备执行 SQL 语句，获取sqlite3——stmt
  19.             if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &selectStmt, NULL) != SQLITE_OK) {
  20.                 // 准备执行 SQL 语句失败，打印log返回失败(no)
  21.                 return NSLog(@"SQLite stmt prepare error： %s,", sqlite3_errmsg(self.database));
  22.             }
  23.         }
  25.         // 执行 SQL 语句
  26.         while (sqlite3_step(selectStmt) == SQLITE_ROW) {
  27.             // 将当前查询的这条数据转换成 NSData 对象
  28.             NSData *data = [[NSData alloc] initWithBytes:sqlite3_column_blob(selectStmt, 1) length:sqlite3_column_bytes(stmt, 1)];
  29.             // 将查询到的时间数据转换成JSON字符串
  30.             NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  31. #ifdef DUBUG
  32.             NSLog(@"%@", jsonString);
  33. #endif
  34.             // 将JSON字符串添加到数组中
  35.             [events addObject:jsonString];
  36.         }
  37.     });
  38.     return events;
  39. }       
复制代码
（2）缓存事件总条数

​        添加一个方法用于查询数据库已经存储事件条数，新增一个 eventCount 属性，初始化时，他的数值就是当前数据库已经存储事件条数，每次成功插入一条数据的时候值对应的加1，在删除数据的时候减去相应删除的数据条数，这样就保证 eventCount 和本地数据存储的事件条数一致，减少查询次数。
第一步：在 SensorsAnalyticsDatabase.h 中新增 eventCount 属性
  1. /// 本地事件存储总量
  2. @property (nonatomic) NSUInteger eventCount;
复制代码
第二步：在 SensorsAnalyticsDatabase.m 文件中新增私有方法 - queryLocalDatabaseEventCount，查询数据库中已经缓存事件数。
  1. // 查询数据库中已经缓存事件的条数
  2. - (void)queryLocalDatabaseEventCount {
  3.     dispatch_async(self.queue, ^{
  4.        // 查询语句
  5.         NSString *sql = @"SELECT count(*) FORM events";
  6.         sqlite3_stmt *stmt = NULL;
  7.         // 准备执行SQL语句，获取 sqlite3_stmt
  8.         if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &stmt, NULL) != SQLITE_OK) {
  9.             // 准备执行SQL语句失败，打印log返回失败 NO
  10.             return NSLog(@"SQLite stmt prepare error: %s", sqlite3_errmsg(self.database));
  11.         }
  12.         while (sqlite3_step(stmt) == SQLITE_ROW) {
  13.             self.eventCount = sqlite3_column_int(stmt, 0);
  14.         }
  15.     });
  16. }
复制代码
第三步 ：在 - initWithFilePath: 初始化方法中调用 - queryLocalDatabaseEventCount，初始化 eventCount
  1. - (instancetype)initWithFilePath:(NSString *)filePath {
  2.     self = [super init];
  3.     if (self) {
  4.         _filePath = filePath ?: [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).lastObject stringByAppendingPathComponent:SensorsAnalyticsDefaultDatabaseName];
  5.         
  6.         // 初始化队列的唯一标识
  7.         NSString *label = [NSString stringWithFormat:@"cn.sensorsdata.serialQueue.%p", self];
  8.         // 创建一个 serial 类型的 queue，即 FIFO
  9.         _queue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_SERIAL);
  10.         
  11.         // 打开数据库
  12.         [self open];
  13.         
  14.         [self queryLocalDatabaseEventCount];
  15.     }
  16.     return self;
  17. }
复制代码
第四步：优化 - insertEvent: 方法，事件插入成功，事件数量  eventCount 加 1
  1. static sqlite3_stmt *insertStmt = NULL;
  2. - (void)insertEvent:(NSDictionary *)event {
  3.     dispatch_async(self.queue, ^{
  4.         if (insertStmt) {
  5.             // 重置插入语句，重置之后可重新绑定数据
  6.             sqlite3_reset(insertStmt);
  7.         } else {
  8.             // 插入语句
  9.             NSString *sql = @"INSERT INTO events (event) values (?)";
  10.             // 准备执行 SQL 语句，获取 sqlite3_stmt
  11.             if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &insertStmt, NULL) != SQLITE_OK) {
  12.                 // 准备执行 SQL 语句失败，打印 log 返回失败 NO
  13.                 return NSLog(@"SQLite stmt prepare error: %s", sqlite3_errmsg(self.database));
  14.             }
  15.         }
  17.         NSError *error;
  18.         // 将 event 转换成 JSON 数据
  19.         NSData *data = [NSJSONSerialization dataWithJSONObject:event options:NSJSONWritingPrettyPrinted error:&error];
  20.         if (error) {
  21.             return NSLog(@"The JSON object`s serialization error: %@", error);
  22.         }
  23.         
  24.         // 将JSON数据与 insertStmt 绑定
  25.         sqlite3_bind_blob(insertStmt, 1, data.bytes, (int)data.length, SQLITE_TRANSIENT);
  26.         // 执行 stmt
  27.         if (sqlite3_step(insertStmt) != SQLITE_DONE) {
  28.             // 执行失败，打印log，返回失败（NO）
  29.             return NSLog(@"Insert event into events error");
  30.         }
  31.         
  32.         // 数据插入成功 事件数量加1
  33.         self.eventCount ++;
  34.     });
  35. }
复制代码
第五步：优化 - deleteEventsForCount: 方法，当 eventCount 为 0 时，直接返回；当数据删除成功时，事件数量减去相应的删除条数
  1. - (BOOL)deleteEventsForCount:(NSInteger)count {
  2.     __block BOOL success = YES;
  3.     dispatch_sync(self.queue, ^{
  4.         // 当本地事件数量为 0 时，直接返回
  5.         if (self.eventCount == 0) {
  6.             return;
  7.         }
  8.         // 删除语句
  9.         NSString *sql = [NSString stringWithFormat:@"DELETE FROM events WHERE id IN (SELECT id FROM events ORDER BY id ASC LIMIT %lu);", (unsigned long)count];
  10.         char *errmsg;
  11.         //执行删除语句
  12.         if (sqlite3_exec(self.database, sql.UTF8String, NULL, NULL, &errmsg) != SQLITE_OK) {
  13.             success = NO;
  14.             return NSLog(@"Failed to delete record msg=%s", errmsg);
  15.         }
  16.         self.eventCount = self.eventCount < count ? 0 : self.eventCount - count;
  17.     });
  18.    
  19.     return success;
  20. }
复制代码
第六步：优化 - selectEventsForCount: 方法，当 eventCount 为 0 时，直接返回
  1. // 最后一次查询下的事件数量
  2. static NSUInteger lastSelectEventCount = 50;
  3. static sqlite3_stmt *selectStmt = NULL;
  4. - (NSArray<NSString *> *)selectEventsForCount:(NSInteger)count {
  5.     // 初始化数组，用于存储查询到的事件数据
  6.     NSMutableArray<NSString *> *events = [NSMutableArray arrayWithCapacity:count];
  7.     dispatch_sync(self.queue, ^{
  8.         // 当本地事件数量为 0 ，直接返回
  9.         if (self.eventCount == 0) {
  10.             return;
  11.         }
  12.         
  13.         if (count != lastSelectEventCount) {
  14.             lastSelectEventCount = count;
  15.             selectStmt = NULL;
  16.         }
  17.         if (selectStmt) {
  18.             // 重置插入语句，重置之后可重新查询数据
  19.             sqlite3_reset(selectStmt);
  20.         } else {
  21.             // 查询语句
  22.             NSString *sql = [NSString stringWithFormat:@"SELECT id, event FROM events ORDER BY id ASC LIMIT %lu", (unsigned long)count];
  23.             // 准备执行 SQL 语句，获取sqlite3——stmt
  24.             if (sqlite3_prepare_v2(self.database, sql.UTF8String, -1, &selectStmt, NULL) != SQLITE_OK) {
  25.                 // 准备执行 SQL 语句失败，打印log返回失败(no)
  26.                 return NSLog(@"SQLite stmt prepare error： %s,", sqlite3_errmsg(self.database));
  27.             }
  28.         }
  30.         // 执行 SQL 语句
  31.         while (sqlite3_step(selectStmt) == SQLITE_ROW) {
  32.             // 将当前查询的这条数据转换成 NSData 对象
  33.             NSData *data = [[NSData alloc] initWithBytes:sqlite3_column_blob(selectStmt, 1) length:sqlite3_column_bytes(stmt, 1)];
  34.             // 将查询到的时间数据转换成JSON字符串
  35.             NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  36. #ifdef DUBUG
  37.             NSLog(@"%@", jsonString);
  38. #endif
  39.             // 将JSON字符串添加到数组中
  40.             [events addObject:jsonString];
  41.         }
  42.     });
  43.     return events;
  44. }
复制代码
3.3 总结

​        通过上面我们实现了数据库缓存事件数据，并实现了如下功能
​        然后对数据缓存性能进行了优化。对于文件缓存来说，数据库缓存更加灵活，可以实现对单条数据的查询、插入和删除操作，同时调试也更容易。SQLite 数据库也有极高的性能，特别是对单条数据的操作，性能明显由于文件缓存。

来源：https://www.cnblogs.com/r360/p/16299922.html
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4