我们开发中经常会遇到这样的场景，就是我们客户端用户进行了某个操作，这个操作影响了数据的状态，但是我们又不方便重新请求一次数据，
这个时候，就需要我们记录一下本地状态在内存中，随着业务越来越复杂，要记录的状态也越来越多，如果状态都是对应同一个ID还比较好处理，如果不同的状态对应的ID都不是同一个，则管理起来比较麻烦，比如，有些情况下，我们不能根据某条数据的内容ID，而要记录到实例队形的颗粒度，这个时候，就需要我们支持不同的ID来记录本地状态了，
一下是我的处理思路,
我们可以创建一个单例，单例中有一个数组，数组中
有字典，字典中包含三个键： type:对应 id的类型，
ID,对应ID的值，data，对应我们要记录的数据,通常情况下是一个字典，对应我们要记录的状态字段和值，我们获取记录的状态的时候，传入一个ID数组，就会遍历整个容器，获取到对应的ID下的所有数据,如下所示

[
{
“type”:”contentId”,
“id”: “xxxx”
“data”: {
“hasComment”:“0”
}
},
{
“type”:”userId”,
“id”: “xxxx”
“data”: {
“hasComment”:“1”
}
},
{
“type”:”xxxid”,
“id”: “xxxx”
“data”: {
“hasSee”:“1”
}
},
]

具体代码如下

保存本地数据的实现，单例中

- (void)updateData:(NSArray *)newData {
    NSMutableArray *keysToUpdate = [[NSMutableArray alloc] init];
    
    for (NSDictionary *data in newData) {
        NSString *IDString = [data stringForKey:@"id"];
        NSString *type = [data stringForKey:@"type"];
        NSDictionary *templateData = [data dictionaryForKey:@"data"];
        
        if (IDString.length <= 0 || type.length <= 0 || templateData.count <= 0) continue;
        
        NSUInteger synchronizedTemplateDataToUpdateIndex = 0;
        NSDictionary *synchronizedTemplateDataToUpdate = nil;
        
        for (NSUInteger i = 0; i < self.synchronizedDataList.count; i++) {
            NSDictionary *synchronizedData = [self.synchronizedDataList objectAtIndex:i];
            NSString *synchronizedIDString = [synchronizedData stringForKey:@"id"];
            NSString *synchronizedType = [synchronizedData stringForKey:@"type" ];
            NSMutableDictionary *synchronizedTemplateData = [[synchronizedData dictionaryForKey:@"data"] mutableCopy];
            
            if (![synchronizedIDString isEqualToString:IDString] || ![synchronizedType isEqualToString:type]) continue;
            
            for (NSString *key in templateData.allKeys) {
                NSString *value = [templateData stringForKey:key];
                
                [synchronizedTemplateData setObject:value forKey:key];
            }
            
            synchronizedTemplateDataToUpdateIndex = i;
            synchronizedTemplateDataToUpdate = @{
                @"id": IDString,
                @"type": type,
                @"data": synchronizedTemplateData
            };
            
            break;
        }
        
        if (synchronizedTemplateDataToUpdate == nil) {
            [self.synchronizedDataList addObject:data];
        } else {
            [self.synchronizedDataList removeObjectAtIndex:synchronizedTemplateDataToUpdateIndex];
            [self.synchronizedDataList addObject:synchronizedTemplateDataToUpdate];
        }
        
        [keysToUpdate addObject:@{
            @"id": IDString ?: @"",
            @"type": type ?: @""
        }];
    }
    

更新本地数据

   NSMutableDictionary *data = [NSMutableDictionary dictionary];
        data[@"hasCancelRecommend"] = @(NO);
        NSString *addressId = [NSString stringWithFormat:@"%p", model];
        NSDictionary *updateData = @{
            @"id": addressId ?: @"",
            @"type": @"modelAddress",
            @"data": data
        };
            [[LBDataSyncDataManager sharedManager] updateData:@[updateData]];

根据所有ID获取本地数据, 单例的实例方法

- (NSDictionary *)getMemoryDataWithKeys:(NSArray *)keys {
    NSMutableDictionary *getSynchronizedData = [[NSMutableDictionary alloc] init];
    
    for (NSString *key in keys) {
        for (NSDictionary *synchronizedData in self.synchDataList) {
            NSString *synchronizedIDString = [synchronizedData stringForKey:@"id"];
            
            if (![key isEqualToString:synchronizedIDString]) continue;
            
            [getSynchronizedData addEntriesFromDictionary:[synchronizedData dictionaryForKey:@"data"]];
            
            break;
        }
    }
    
    return getSynchronizedData;
}

调用，获取到所有的本地状态

  
    NSString *cardInstanceAddress = [NSString stringWithFormat:@"%p", instance];
    
    NSDictionary *mergedData = [[LBDataSyncDataManager sharedManager] getMergedDataWithKeys:@[contentID ?: @"", publicID ?: @"", Address ?: @""]];