iOS-runtime+归档保存App数据

最新推荐文章于 2022-08-03 17:09:04 发布
最新推荐文章于 2022-08-03 17:09:04 发布
阅读量978 收藏 1
点赞数
分类专栏： iOS iOS开发 文章标签： 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/samuelandkevin/article/details/53065611
版权
iOS 同时被 2 个专栏收录
106 篇文章 1 订阅
订阅专栏
iOS开发
87 篇文章 1 订阅
订阅专栏

在App开发中，如何保存应用的数据？对于轻量级的数据，可以选择runtime归档。

runtime工具github地址：SerializationKit

//
//  YHCacheManager.h
//  PikeWay
//
//  Created by YHIOS002 on 16/6/3.
//  Copyright © 2016年 YHSoft. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "YHWorkGroup.h"
#import "YHABUserInfo.h"
#import "YHIMHandler.h"
#import "ConversationListHandler.h"
#import "YHThirdPModel.h"

@interface YHCacheManager : NSObject

+ (instancetype)shareInstance;

//退出登录清除缓存
- (void)clearCacheWhenLogout;

#pragma mark - /*******我的名片*********/
//是否要更新
- (BOOL)needUpdateMyCard;
//缓存
- (void)cacheMyCard:(YHUserInfo*)userInfo;
//取出缓存
- (YHUserInfo*)getCacheMyCard;
//清除缓存
- (void)clearCacheMyCard;

#pragma mark - /*******工作圈动态列表*********/
//是否要更新
- (BOOL)needUpdateCacheWorkGroupDynamicList;
//缓存
- (void)cacheWorkGroupDynamicList:(NSArray<YHWorkGroup*>*)listData;
//取出缓存
- (NSArray<YHWorkGroup*>*)getCacheWorkGroupDynamiList;
//清除缓存
- (void)clearCacheWorkGroupDynamiList;

//按照动态类型缓存动态列表
- (void)cacheWorkGroupDynamicList:(NSArray<YHWorkGroup*>*)listData dynamicType:(NSInteger)dynamicType;
//按照动态类型取出缓存
- (NSArray<YHWorkGroup*>*)getCacheWorkGroupDynamiListWithDynamicType:(NSInteger)dynamicType;

#pragma mark - /*******我的动态列表*********/
//是否要更新
- (BOOL)needUpdateCacheMyDynamicList;
//缓存
- (void)cacheMyDynamciList:(NSArray<YHWorkGroup*>*)listData;
//取出缓存
- (NSArray<YHWorkGroup*>*)getCacheMyDynamiList;
//清除缓存
- (void)clearCacheMyDynamiList;

#pragma mark - /*******我的好友列表*********/
//是否要更新
- (BOOL)needUpdateCacheMyFriendsList;
//缓存
- (void)cacheMyFriendsList:(NSArray<YHUserInfo*>*)listData;
//取出缓存
- (NSArray<YHUserInfo*>*)getCacheMyFriendsList;
//清除缓存
- (void)clearCacheMyFriendsList;

#pragma mark - /*******我的通讯录*********/
//是否要更新
- (BOOL)needUpdateCacheMyABContactList;
//缓存
- (void)cacheMyABContactList:(NSArray<YHABUserInfo*>*)listData;
//取出缓存
- (NSArray<YHABUserInfo*>*)getCacheMyABContactList;
//清除缓存
- (void)clearCacheMyABContactList;


#pragma mark - /*******大咖列表列表*********/
//是否要更新
- (BOOL)needUpdateBigNameList;
//缓存
- (void)cacheBigNameList:(NSArray<YHUserInfo*>*)listData;
//取出缓存
- (NSArray<YHUserInfo*>*)getCacheBigNameList;
//清除缓存
- (void)clearCacheBigNameList;

#pragma mark - /*******我的访客*********/
//是否要更新
- (BOOL)needUpdateMyVisitorsList;
//缓存
- (void)cacheMyVisitorsList:(NSArray<YHUserInfo*>*)listData;
//取出缓存
- (NSArray<YHUserInfo*>*)getCacheMyVisitorsList;
//清除缓存
- (void)clearCacheMyVisitorsList;

#pragma mark - /*******新的好友*********/
//是否要更新
- (BOOL)needUpdateNewFriendsList;
//缓存
- (void)cacheNewFriendsList:(NSArray<YHUserInfo*>*)listData;
//取出缓存
- (NSArray<YHUserInfo*>*)getCacheNewFriendsList;
//清除缓存
- (void)clearCacheNewFriendsList;

#pragma mark - /*******行业职位列表*********/
//是否要更新
- (BOOL)needUpdateIndustryList;
//缓存
- (void)cacheIndustryList:(NSArray<NSDictionary*>*)listData;
//取出缓存
- (NSArray<NSDictionary*>*)getCacheIndustryList;
//清除缓存
- (void)clearCacheIndustryList;

#pragma mark - /*******评论推送列表*********/
//是否要更新
- (BOOL)needUpdateNotiCommentSingleton;
//缓存
- (void)cacheNotiCommentSingleton:(YHIMHandler *)singleton;
//取出缓存
- (YHIMHandler *)getCacheNotiCommentSingleton;
//清除缓存
- (void)clearCacheNotiCommentSingleton;

#pragma mark - /*******会话列表*********/
//是否要更新
- (BOOL)needUpdateConversationSingleton;
//缓存
- (void)cacheConversationSingleton:(ConversationListHandler *)singleton;
//取出缓存
- (ConversationListHandler *)getCacheConversationSingleton;
//清除缓存
- (void)clearCacheConversationSingleton;

#pragma mark - /*******第三方账号*********/
- (void)cacheThirdPartyAccount:(YHThirdPModel *)dict;
- (NSMutableDictionary<NSString *,YHThirdPModel *> *)getCacheThirdPartyAccountDict;
- (void)clearCacheThirdPartyAccountDict;

@end


//
//  YHCacheManager.m
//  PikeWay
//
//  Created by YHIOS002 on 16/6/3.
//  Copyright © 2016年 YHSoft. All rights reserved.
//

#import "YHCacheManager.h"
#import <objc/runtime.h>
#import "YHSerializeKit.h"


//有效率时长
static  long const kMyCardValidDuration = 0;
static  long const kWorkgroupDynamicListValidDuration = 3600 * 1;
static  long const kMyDynamicListValidDuration = 3600 * 1;
static  long const kMyFriendsListValidDuration = 60;
static  long const kMyABContactListValidDuration = 0;
static  long const kBigNameListValidDuration = 0;
static  long const kMyVisitorsListValidDuration = 0;
static  long const kNewFriendsListValidDuration = 0;
static  long const kIndustryListValidDuration   = 3600 * 24 * 7;
static  long const kNotiCommentSingletonValidDuration = 3600 * 24 * 30;
static  long const kConversationSingletonValidDuration = 0;

//date key
#define kcacheDateMyCard @"cacheDateMyCard"
#define kcacheDateWorkGroupDynamicList       @"cacheDateWorkgroupDynamicList"
#define kcacheDateMyDynamciList @"cacheDateMyDynamciList"
#define kcacheDateMyfriendsList @"cacheDateMyfriendsList"
#define kcacheDateMyABContactList @"cacheDateMyABContactList"
#define kcacheDateBigNameList @"cacheDateBigNameList"
#define kcacheDateMyVisitorsList @"cacheDateMyVisitorsList"
#define kcacheDateNewFriensList @"cacheDateNewFriensList"
#define kcacheDateIndustryList @"cacheDateIndustryList"
#define kcacheDateNotiCommentSingleton @"cacheDateNotiCommentSingleton"
#define kcacheDateConversationSingleton @"cacheDateConversationSingleton"
#define kcacheDateThirdPartyDict @"cacheDateThirdPartyDict"


//archive key
#define kArchiveKeyMyCard @"ArchiveKeyMyCard"
#define kArchiveKeyWorkGroupDynamicList @"ArchiveKeyWorkGroupDynamicList"
#define kArchiveKeyMyDynamciList @"ArchiveKeyMyDynamciList"
#define kArchiveKeyMyfriendsList @"ArchiveKeyMyfriendsList"
#define kArchiveKeyMyABContactList @"ArchiveKeyMyABContactList"
#define kArchiveKeyBigNameList @"ArchiveKeyBigNameList"
#define kArchiveKeyMyVisitorsList @"ArchiveKeyMyVisitorsList"
#define kArchiveKeyNewFriensList @"ArchiveKeyNewFriensList"
#define kArchiveKeyIndustryList @"ArchiveKeyIndustryList"
#define kArchiveKeyNotiCommentSingleton @"ArchiveKeyNotiCommentSingleton"
#define kArchiveKeyConversationSingleton @"ArchiveKeyConversationSingleton"
#define kArchiveKeyCacheThirdPartyDict @"ArchiveKeyCacheThirdPartyDict"


@interface YHCacheManager ()

@property (nonatomic,strong) YHUserInfo *cacheUserInfo;//我的名片
@property (nonatomic,strong) NSMutableArray *cacheDynamicList;  //工作圈动态
@property (nonatomic,strong) NSMutableArray *cacheMyDynamicList;//我的动态
@property (nonatomic,strong) NSMutableArray *cacheMyFriendsList;//我的好友
@property (nonatomic,strong) NSMutableArray *cacheMyABContactList;//我的通讯录
@property (nonatomic,strong) NSMutableArray *cacheBigNameList; //大咖列表
@property (nonatomic,strong) NSMutableArray *cacheMyVisitorsList;//我的访客列表
@property (nonatomic,strong) NSMutableArray *cacheNewFriendsList;//新的好友列表
@property (nonatomic,strong) NSMutableArray *cacheIndustryList;//行业职位列表
@property (nonatomic,strong) YHIMHandler    *cacheNotiCommentSingleton;//评论推送单例
@property (nonatomic,strong) ConversationListHandler *cacheConversationSingleton;//会话列表单例
@property (nonatomic,strong) NSDictionary *workgroupDict;//工作圈动态字典（按照动态类型保存动态）
@property (nonatomic,strong) NSMutableDictionary *thirdPartyDict;

@end

@implementation YHCacheManager

+ (instancetype)shareInstance
{
    static YHCacheManager *g_instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        g_instance = [[YHCacheManager alloc] init];
    });
    return g_instance;
    
}

- (instancetype)init{
    if (self = [super init]) {
       
    }
    return  self;
}

#pragma mark - Private
/**
 *  是否过期
 *
 *  @param cacheKey      缓存时间点的Key
 *  @param validDuration 有限时长
 *
 *  @return YES:过期 NO:有效
 */
- (BOOL)isExpiredWithCacheKey:(NSString *)cacheKey validDuration:(long)validDuration{
    //取出
    NSInteger ts = [[NSUserDefaults standardUserDefaults] integerForKey:cacheKey];
    if (ts == 0) {
        ts = [[NSDate date] timeIntervalSince1970];
        [[NSUserDefaults standardUserDefaults] setObject:@(ts) forKey:cacheKey];
    }
    
    //旧时间日期
    NSDate *oDate = [NSDate dateWithTimeIntervalSince1970:ts];
    //时间间隔
    NSTimeInterval distance = [[NSDate date] timeIntervalSinceDate:oDate];
    
    if (distance > validDuration) {
        return YES;
    }
    return NO;
}

//缓存当前日期
- (void)cacheCurrentDateWithKey:(NSString *)cacheDateKey{
    if(!cacheDateKey)
        return;
    NSTimeInterval interval =  [[NSDate date] timeIntervalSince1970];
    [[NSUserDefaults standardUserDefaults] setObject:@(interval) forKey:cacheDateKey];
}

#pragma mark - Public

- (void)clearCacheWhenLogout{
    [self clearCacheMyCard];
    [self clearCacheMyDynamiList];
    [self clearCacheMyFriendsList];
    [self clearCacheMyVisitorsList];
    [self clearCacheNewFriendsList];
    [self clearCacheNotiCommentSingleton];
    [self clearCacheConversationSingleton];
    [self clearCacheThirdPartyAccountDict];
}

/*******我的名片*********/
#pragma mark - 我的名片
//是否要更新
- (BOOL)needUpdateMyCard{
    if (!self.cacheUserInfo || [self isMyCardExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheMyCard:(YHUserInfo*)userInfo
{
    if (userInfo) {
        self.cacheUserInfo = userInfo;
        //缓存名片
    YHSERIALIZE_ARCHIVE(self.cacheUserInfo,kArchiveKeyMyCard,[self cacheMyCardFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateMyCard];
    }
}

//取出缓存
- (YHUserInfo*)getCacheMyCard
{
    
    YHSERIALIZE_UNARCHIVE(self.cacheUserInfo, kArchiveKeyMyCard, [self cacheMyCardFilePath]);
    return self.cacheUserInfo;
    
}

//清除缓存
- (void)clearCacheMyCard{
    [self deleteFileAtPath:[self cacheMyCardFilePath]];
}

//我的名片过期
- (BOOL)isMyCardExpired{
    
    return [self isExpiredWithCacheKey:kcacheDateMyCard validDuration:kMyCardValidDuration];
}


#pragma mark - 工作圈动态列表
//是否要更新
- (BOOL)needUpdateCacheWorkGroupDynamicList
{
    if (!self.cacheDynamicList.count || [self isWorkGroupDynamicListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheWorkGroupDynamicList:(NSArray<YHWorkGroup*>*)listData
{
    
    if (listData.count && listData) {
        self.cacheDynamicList = [listData mutableCopy];
        //缓存工作圈动态
  YHSERIALIZE_ARCHIVE(self.cacheDynamicList,kArchiveKeyWorkGroupDynamicList,[self cacheWorkGroupListFilePath]);
         [self cacheCurrentDateWithKey:kcacheDateWorkGroupDynamicList];
    }
}

//取出缓存
- (NSArray<YHWorkGroup*>*)getCacheWorkGroupDynamiList{
    
     YHSERIALIZE_UNARCHIVE(self.cacheDynamicList, kArchiveKeyWorkGroupDynamicList, [self cacheWorkGroupListFilePath]);
    return self.cacheDynamicList;
    
}

//清除缓存
- (void)clearCacheWorkGroupDynamiList{
    [self deleteFileAtPath:[self cacheWorkGroupListFilePath]];
}

//工作圈列表过期
- (BOOL)isWorkGroupDynamicListExpired{

    return [self isExpiredWithCacheKey:kcacheDateWorkGroupDynamicList validDuration:kWorkgroupDynamicListValidDuration];
}


//按照动态标签类型缓存动态列表
- (void)cacheWorkGroupDynamicList:(NSArray<YHWorkGroup*>*)listData dynamicType:(NSInteger)dynamicType{
    if (listData) {
 
        NSString *cacheKey = [NSString stringWithFormat:@"ArchiveKeyDynList%@",[@(dynamicType) stringValue]];
        NSString *cacheDateKey = [NSString stringWithFormat:@"cacheDateDynList%@",[@(dynamicType) stringValue]];
        //缓存工作圈动态
        YHSERIALIZE_ARCHIVE(listData,cacheKey,[self cacheWorkGroupListFilePathWithDynamicType:dynamicType]);
        [self cacheCurrentDateWithKey:cacheDateKey];

    }
}

//按照动态类型取出缓存
- (NSArray<YHWorkGroup*>*)getCacheWorkGroupDynamiListWithDynamicType:(NSInteger)dynamicType{
    
    NSArray *retArray = [NSArray new];
    NSString *cacheKey = [NSString stringWithFormat:@"ArchiveKeyDynList%@",[@(dynamicType) stringValue]];
    YHSERIALIZE_UNARCHIVE(retArray, cacheKey, [self cacheWorkGroupListFilePathWithDynamicType:dynamicType]);
    return retArray;
}



#pragma mark - 我的动态列表
//是否要更新
- (BOOL)needUpdateCacheMyDynamicList{
    if (!self.cacheMyDynamicList.count || [self isMyDynamicListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheMyDynamciList:(NSArray<YHWorkGroup*>*)listData{
    if (listData.count && listData) {
        self.cacheMyDynamicList = [listData mutableCopy];

  YHSERIALIZE_ARCHIVE(self.cacheMyDynamicList,kArchiveKeyMyDynamciList,[self cacheMyDynamicListFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateMyDynamciList];
    }
}

//取出缓存
- (NSArray<YHWorkGroup*>*)getCacheMyDynamiList{
   
    YHSERIALIZE_UNARCHIVE(self.cacheMyDynamicList, kArchiveKeyMyDynamciList, [self cacheMyDynamicListFilePath]);
    
    return self.cacheMyDynamicList;
}

//清除缓存
- (void)clearCacheMyDynamiList{
    [self deleteFileAtPath:[self cacheMyDynamicListFilePath]];
}

//我的动态列表过期
- (BOOL)isMyDynamicListExpired{
    
    return [self isExpiredWithCacheKey:kcacheDateMyDynamciList validDuration:kMyDynamicListValidDuration];
}

#pragma mark - 我的好友列表
//是否要更新
- (BOOL)needUpdateCacheMyFriendsList
{
    if (!self.cacheMyFriendsList.count || [self isMyFriendsListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheMyFriendsList:(NSArray<YHUserInfo*>*)listData{
    if (listData) {
        self.cacheMyFriendsList = [listData mutableCopy];
        
        YHSERIALIZE_ARCHIVE(self.cacheMyFriendsList,kArchiveKeyMyfriendsList,[self cacheMyFriendsListFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateMyfriendsList];
    }
}


//取出缓存
- (NSArray<YHUserInfo*>*)getCacheMyFriendsList{

    YHSERIALIZE_UNARCHIVE(self.cacheMyFriendsList, kArchiveKeyMyfriendsList, [self cacheMyFriendsListFilePath]);
    return self.cacheMyFriendsList;
}

//清除缓存
- (void)clearCacheMyFriendsList{
    [self deleteFileAtPath:[self cacheMyFriendsListFilePath]];
}

//我的好友列表过期
- (BOOL)isMyFriendsListExpired{
    
    return [self isExpiredWithCacheKey:kcacheDateMyfriendsList validDuration:kMyFriendsListValidDuration];
}

/*******我的通讯录*********/
#pragma mark - 我的通讯录
//是否要更新
- (BOOL)needUpdateCacheMyABContactList{
    if (!self.cacheMyABContactList.count || [self isMyABContactListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheMyABContactList:(NSArray<YHABUserInfo*>*)listData{
    if (listData.count && listData) {
        self.cacheMyABContactList = [listData mutableCopy];
        
        YHSERIALIZE_ARCHIVE(self.cacheMyABContactList,kArchiveKeyMyABContactList,[self cacheMyABContactListFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateMyABContactList];
    }

}

//取出缓存
- (NSArray<YHABUserInfo*>*)getCacheMyABContactList{
    
    YHSERIALIZE_UNARCHIVE(self.cacheMyABContactList, kArchiveKeyMyABContactList, [self cacheMyABContactListFilePath]);
    return self.cacheMyABContactList;
}

//清除缓存
- (void)clearCacheMyABContactList{
    [self deleteFileAtPath:[self cacheMyABContactListFilePath]];
}

//我的通讯录列表过期
- (BOOL)isMyABContactListExpired{
    
    return [self isExpiredWithCacheKey:kcacheDateMyABContactList validDuration:kMyABContactListValidDuration];
}

/*******大咖列表列表*********/
#pragma mark - 大咖列表列表
//是否要更新
- (BOOL)needUpdateBigNameList{
    if (!self.cacheBigNameList.count || [self isBigNameListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheBigNameList:(NSArray<YHUserInfo*>*)listData{
    
    if (listData.count && listData) {
        self.cacheBigNameList = [listData mutableCopy];
        
        YHSERIALIZE_ARCHIVE(self.cacheBigNameList,kArchiveKeyBigNameList,[self cacheBigNameListFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateBigNameList];
    }

    
}

//取出缓存
- (NSArray<YHUserInfo*>*)getCacheBigNameList{

    YHSERIALIZE_UNARCHIVE(self.cacheBigNameList, kArchiveKeyBigNameList, [self cacheBigNameListFilePath]);
    return self.cacheBigNameList;
}

//清除缓存
- (void)clearCacheBigNameList{
    [self deleteFileAtPath:[self cacheBigNameListFilePath]];
}

//大咖列表过期
- (BOOL)isBigNameListExpired{
   return [self isExpiredWithCacheKey:kcacheDateBigNameList validDuration:kBigNameListValidDuration];
}

/*******我的访客*********/
#pragma mark - 我的访客
//是否要更新
- (BOOL)needUpdateMyVisitorsList{
    if (!self.cacheMyVisitorsList.count || [self isMyVisitorsListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheMyVisitorsList:(NSArray<YHUserInfo*>*)listData{
    
    if (listData.count && listData) {
        self.cacheMyVisitorsList = [listData mutableCopy];
        
        YHSERIALIZE_ARCHIVE(self.cacheMyVisitorsList,kArchiveKeyMyVisitorsList,[self cacheMyVisitorsListFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateMyVisitorsList];
    }

}

//取出缓存
- (NSArray<YHUserInfo*>*)getCacheMyVisitorsList{
    
    YHSERIALIZE_UNARCHIVE(self.cacheMyVisitorsList, kArchiveKeyMyVisitorsList, [self cacheMyVisitorsListFilePath]);
    return self.cacheMyVisitorsList;
}

//清除缓存
- (void)clearCacheMyVisitorsList{
    [self deleteFileAtPath:[self cacheMyVisitorsListFilePath]];
}

//我的访客列表过期
- (BOOL)isMyVisitorsListExpired{
    return [self isExpiredWithCacheKey:kcacheDateMyVisitorsList validDuration:kMyVisitorsListValidDuration];
}

/*******新的好友*********/
#pragma mark - 新的好友
//是否要更新
- (BOOL)needUpdateNewFriendsList{
    if (!self.cacheNewFriendsList.count || [self isNewFriendsListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheNewFriendsList:(NSArray<YHUserInfo*>*)listData{
    if (listData.count && listData) {
        self.cacheNewFriendsList = [listData mutableCopy];
        
        YHSERIALIZE_ARCHIVE(self.cacheNewFriendsList,kArchiveKeyNewFriensList,[self cacheNewFriendsListFilePath]);
         [self cacheCurrentDateWithKey:kcacheDateNewFriensList];
    }
}
//取出缓存
- (NSArray<YHUserInfo*>*)getCacheNewFriendsList{
    
    YHSERIALIZE_UNARCHIVE(self.cacheNewFriendsList, kArchiveKeyNewFriensList, [self cacheNewFriendsListFilePath]);
    return self.cacheNewFriendsList;
}

- (void)clearCacheNewFriendsList{
    [self deleteFileAtPath:[self cacheNewFriendsListFilePath]];
}

//新的好友列表过期
- (BOOL)isNewFriendsListExpired{
    return [self isExpiredWithCacheKey:kcacheDateNewFriensList validDuration:kNewFriendsListValidDuration];
}


/*******行业职位列表*********/
#pragma mark - 行业职位列表
//是否要更新
- (BOOL)needUpdateIndustryList{
    if (!self.cacheIndustryList.count || [self isIndustryListExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheIndustryList:(NSArray<NSDictionary*>*)listData{
    if (listData.count && listData) {
        self.cacheIndustryList = [listData mutableCopy];
        
        YHSERIALIZE_ARCHIVE(self.cacheIndustryList,kArchiveKeyIndustryList,[self cacheIndustryListFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateIndustryList];
    }
}

//取出缓存
- (NSArray<NSDictionary*>*)getCacheIndustryList{
  
    YHSERIALIZE_UNARCHIVE(self.cacheIndustryList, kArchiveKeyIndustryList, [self cacheIndustryListFilePath]);
    return self.cacheIndustryList;
}

//清除缓存
- (void)clearCacheIndustryList{
    [self deleteFileAtPath:[self cacheIndustryListFilePath]];
}

//行业职位列表过期
- (BOOL)isIndustryListExpired{
    return [self isExpiredWithCacheKey:kcacheDateIndustryList validDuration:kIndustryListValidDuration];
}

/*******评论推送列表*********/
#pragma mark - 评论推送列表
//是否要更新
- (BOOL)needUpdateNotiCommentSingleton{
    if (!self.cacheNotiCommentSingleton || [self isNotiCommentSingletonExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheNotiCommentSingleton:(YHIMHandler *)singleton{
    if (singleton) {
        self.cacheNotiCommentSingleton = singleton;
        YHSERIALIZE_ARCHIVE(self.cacheNotiCommentSingleton,kArchiveKeyNotiCommentSingleton,[self cacheNotiCommentSingletonFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateNotiCommentSingleton];
    }
}

//取出缓存
- (YHIMHandler *)getCacheNotiCommentSingleton{
    
   YHSERIALIZE_UNARCHIVE(self.cacheNotiCommentSingleton, kArchiveKeyNotiCommentSingleton, [self cacheNotiCommentSingletonFilePath]);
    return self.cacheNotiCommentSingleton;
}

//清除缓存
- (void)clearCacheNotiCommentSingleton{
    [self deleteFileAtPath:[self cacheNotiCommentSingletonFilePath]];
    
    [[YHIMHandler sharedInstance].dataArray removeAllObjects];
    [YHIMHandler sharedInstance].totalBadge = 0;
}

//评论推送列表过期
- (BOOL)isNotiCommentSingletonExpired{
    return [self isExpiredWithCacheKey:kcacheDateNotiCommentSingleton validDuration:kNotiCommentSingletonValidDuration];
}

/*******会话列表*********/
#pragma mark - 会话列表
//是否要更新
- (BOOL)needUpdateConversationSingleton{
    if (!self.cacheConversationSingleton || [self isConversationSingletonExpired]) {
        return YES;
    }
    return NO;
}

//缓存
- (void)cacheConversationSingleton:(ConversationListHandler *)singleton{
    if (singleton) {
        self.cacheConversationSingleton = singleton;
        YHSERIALIZE_ARCHIVE(self.cacheConversationSingleton,kArchiveKeyConversationSingleton,[self cacheConversationSingletonFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateConversationSingleton];
    }
}

//取出缓存
- (ConversationListHandler *)getCacheConversationSingleton{
    YHSERIALIZE_UNARCHIVE(self.cacheConversationSingleton, kArchiveKeyConversationSingleton, [self cacheConversationSingletonFilePath]);
    return self.cacheConversationSingleton;
}

//清除缓存
- (void)clearCacheConversationSingleton{
    [self deleteFileAtPath:[self cacheConversationSingletonFilePath]];
    [[ConversationListHandler sharedInstance].ConversationList removeAllObjects];
}

//评论推送列表过期
- (BOOL)isConversationSingletonExpired{
    return [self isExpiredWithCacheKey:kcacheDateConversationSingleton validDuration:kConversationSingletonValidDuration];
}


#pragma mark - /*******第三方账号*********/
- (void)cacheThirdPartyAccount:(YHThirdPModel *)model{

    if (!model) {
        DDLog(@"缓存的model为nil");
        return;
    }
    
    //字段的key值与友盟platform名一致！
    NSString *platformName = @"tPAccount";
    switch (model.platformType) {
        case UMSocialPlatformType_QQ:
            platformName = @"qq";
            break;
        default:
            break;
    }
    
    NSMutableDictionary *dictCache = [self getCacheThirdPartyAccountDict];
    if (dictCache) {
        [dictCache setObject:model forKey:platformName];
    }
    else{
        NSMutableDictionary *dictWriteToF = [NSMutableDictionary new];
        [dictWriteToF setObject:model forKey:platformName];
        self.thirdPartyDict = dictWriteToF;
        
        YHSERIALIZE_ARCHIVE(self.thirdPartyDict,kArchiveKeyCacheThirdPartyDict,[self cacheThirdPartyAccountFilePath]);
        [self cacheCurrentDateWithKey:kcacheDateThirdPartyDict];
    }
}

- (NSMutableDictionary<NSString *,YHThirdPModel *> *)getCacheThirdPartyAccountDict{
    YHSERIALIZE_UNARCHIVE(self.thirdPartyDict, kArchiveKeyCacheThirdPartyDict, [self cacheThirdPartyAccountFilePath]);
    return self.thirdPartyDict;
}

- (void)clearCacheThirdPartyAccountDict{
    [self deleteFileAtPath:[self cacheThirdPartyAccountFilePath]];
    self.thirdPartyDict = nil;
}

#pragma mark - CachePath
- (BOOL)deleteFileAtPath:(NSString *)filePath{
    if (!filePath || filePath.length == 0) {
        return NO;
    }
    if (![[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
        DDLog(@"delete file error, %@ is not exist!", filePath);
        return NO;
    }
    NSError *removeErr = nil;
    if (![[NSFileManager defaultManager] removeItemAtPath:filePath error:&removeErr] ) {
        DDLog(@"delete file failed! %@", removeErr);
        return NO;
    }
    return NO;
}

- (NSString *)cachePath
{
    NSString *doc = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES)[0];
    
    NSString *cachePath = [doc stringByAppendingPathComponent:[[NSProcessInfo processInfo] processName]];
    return cachePath;
}

- (NSString *)cachePathInDocument{
    NSURL *docUrl = [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] objectAtIndex:0];
    return [docUrl path];
}

- (NSString *)cacheMyCardFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"myCard"];
}

- (NSString *)cacheWorkGroupListFilePath{
   return  [[self cachePath ]stringByAppendingPathComponent:@"wgdynList"];
}

- (NSString *)cacheWorkGroupListFilePathWithDynamicType:(NSInteger)dynamicType{
    return  [[self cachePath ]stringByAppendingPathComponent:[NSString stringWithFormat:@"wgdynList%@",[@(dynamicType) stringValue]]];
}

- (NSString *)cacheMyDynamicListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"mydynList"];
}

- (NSString *)cacheMyFriendsListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"myfriendsList"];
}

- (NSString *)cacheMyABContactListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"myABContactList"];
}

- (NSString *)cacheBigNameListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"bigNameList"];
}

- (NSString *)cacheMyVisitorsListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"myVisitorsList"];
}

- (NSString *)cacheNewFriendsListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"newFriendsList"];
}

- (NSString *)cacheIndustryListFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"industryList"];
}

- (NSString *)cacheNotiCommentSingletonFilePath{
    return  [[self cachePath ]stringByAppendingPathComponent:@"notiCommentSingleton"];
}

- (NSString *)cacheConversationSingletonFilePath{
    return  [[self cachePathInDocument ]stringByAppendingPathComponent:@"conversationSingleton"];
}

- (NSString *)cacheThirdPartyAccountFilePath{
    return [[self cachePath ]stringByAppendingPathComponent:@"thirdPartyAccount"];
}
@end



临海听风V
关注
专栏目录
iOS之Runtime原理解读
xiangzhihong8的专栏
06-12 3238
Runtime简介做过Android开发的同学都知道，早期的Android系统采用的是Dalvik机制，应用每次运行的时候，字节码都需要通过即时编译器转换为机器码，大大的降低了app的运行效率。在Android 5.0系统之后，系统采用了ART机制，应用在第一次安装的时候，字节码就会预先编译成机器码，以后每次运行速度大大的提高了。OC是一门动态语言，所以它总是想办法把一些决定工作从编译推迟到运行时，
iOS- 响应者链, runtime, runloop
zhz459880251的博客
04-04 2490
响应者链 响应者链条概念:iOS系统检测到手指触摸(Touch)操作时会将其打包成一个UIEvent对象，并放入当前活动Application的事件队列，单例的UIApplication会从事件队列中取出触摸事件并传递给单例的UIWindow来处理，UIWindow对象首先会使用hitTest:withEvent:方法寻找此次Touch操作初始点所在的视图(View)，即需要将触摸事件传递给其处
iOS 利用Runtime实现万能归档
weixin_34212762的博客
12-20 114
传统的归档通常我们都需要先遵循NSCoding协议，然后根据每个属性，每个属性不同的类型去调用不同的方法来实现我们的归档。详情请见我的另一篇简书归档与反归档,在这里我就不详细介绍了。 下面我们就开始用runtime来实现我们的一个万能归档。 1.首先我们还是要让对象遵循NSCoding协议，并实现相关的两个方法，示例如下所示。 @interface NSAchive : NSObject<N...
iOS-基于runtime的归档处理
飞不越的疯人院
12-13 489
基于runtimexiede归档存储处理.直接项目就能用.只需要改成自己相应需要存储的属性名字即可 ///邀请码 @property (nonatomic, copy) NSString *inviteCode; ///邀请注册 @property (nonatomic, copy) NSString *inviteFriend; ///已邀请人数 @p
iOS用runtime实现归档解归档
清秋锁梦的博客
08-08 472
好多人对runtime的使用方法应该还是懵的，现在我就举个例子 我们在持久化的时候可能会选择归档解，加入现在我们有个Person类，需要对里面的name属性和age属性做归档，通常的做法如下 @interface Person : NSObject&lt;NSCoding&gt; //需要归档的属性 @property (nonatomic, strong)NSString       ...
ios 对象归档解档 runtime实现
骑马走天涯的博客
05-04 676
什么是归档？什么是解档？归档：就是把对象序列化，序列化就是把对象写到一个指定的app路径下的文件里，app有三个目录分别是：docments、library、tmp，也叫做对象的持久化，ios开发中一般的持久化不支持自定义对象的持久化，归档解档就可以完成自定义对象的持久化。实现归档解档的步骤： Step1：要实现对象的归档解档首先继承Coding协议（protocol）Step2：实现两个方法：e
iOS runtime讲解，并且用runtime动态归档与解档
10-06 2231
// //  AppDelegate.m //  Runtime自动归档 // //  Created by CONGAING on 15/7/13. //  Copyright (c) Congwang. All rights reserved. // #import "AppDelegate.h" #import "Student.h" @inte
iOS 归档缓存
gsl111000的博客
10-30 156
代码如下： 头文件定义 // 归档缓存内容 + (void)archiverObject:(id)object byKey:(NSString *)key withPath:(NSString *)path; // 解归档缓存内容 + (id)unarchiverObjectByKey:(NSString *)key withPath:(NSString *)path; 方法实现 + (...
iOS开发中runtime常用的几种方法示例总结
08-27
iOS开发中runtime常用的几种方法示例总结 在iOS开发中，Runtime也就是所谓的“运行时”，因为是在运行时实现的。下面我们将详细介绍关于iOS开发中runtime常用的几种方法的相关资料。 一、Runtime简介 Runtime简称...
iOS - 基于CocoaAsyncSocket搭建完整的IM体系大体思路详解
coderMy的博客
04-24 5698
想要搭建一个完善 ,且自定义程度较高 , 又便于后期维修和修改的IM体系 , 采用环信或者融云等实际上是非常消耗精力和时间的 ,因为他们做得也不完善 . 目前咱们已知的通信协议大概有MQTT , XMPP等 .. 然而 , 通信协议是别人制定好的规则 , 想要不受约束 , 就需要自定义一套属于自己的通信协议 . 其实通信协议并不难 , 无非就是iOS端,安卓端,web端和服务器共同协商一套,大
IOS-Swift面试相关基础
CQUPT—ZHX
03-04 2223
Xcode部分 Storyboard基础控件： 视图控制器在SB种称为场景 控件： 1.Label：可包含任意数量的文本，UILabel可收缩，换行以及截断文本。 2.Button：按钮。 3.Segmentel Control：可表示单个或多个选择或命令列表，可显示文本或图像，但无法同时显示两者。 4.Text Field：用户可编辑的文本框。 5.Slider：可滑动的水平条。 6.Switc...
ios 使用runtime实现自动解归档
same_life的博客
08-03 351
iOS 使用runtime实现自动解归档
Runtime运行时机制
guojigang8963869的博客
04-05 1523
简介 Runtime 又叫运行时，是一套底层的 C 语言 API，其为 iOS 内部的核心之一，我们平时编写的 OC 代码，底层都是基于它来实现的。比如： [receiver message]; // 底层运行时会被编译器转化为： objc_msgSend(receiver, selector) // 如果其还有参数比如： [receiver message:(id)arg...]; // 底
iOS 服务器证书不受信任解决办法
热门推荐
samuelandkevin的专栏
11-29 2万+
在实际开发中，后台服务器开发人员为了方便自建证书,有时候这些证书不受苹果官方信任，此时App显示的是一片空白，用SDWebImage加载不了图片，从服务器获取不了数据，AFN请求也是被忽略了。细心的你会发现控制台打印一串提示信息，大概的内容是提醒CA证书不被信任，请更换合适的证书。
iOS-json字符串转为对象
samuelandkevin的专栏
05-26 1万+
场景在项目开发中,有时会遇到这种情况：服务器返回一个json字符串给前端。前端需要把json转换为相应的对象。 比如：服务器返回这样的数据：在编译器打印出来是这样的：（这是编译器处理过的，幻觉...） {"img_url":"http://www.nsr.net.cn/fet/img/2016/1216101053106.jpg","video_url":"https://apps.gtax.cn
iOS-仿赤兔、新浪微博动态列表（带评论、点赞、转发和分享,自动计算行高功能）
samuelandkevin的专栏
11-16 1万+
最近有空整理一下项目,做了一个仿赤兔、新浪微博动态列表（带评论、点赞、转发和分享,自动计算行高功能）的DEMO。HKPTimeLine   ,喜欢的可以star一下哦。 github:  https://github.com/samuelandkevin/HKPTimeLine        使用到的第三方框架有:Masonry，HYBMasonryAutoCellHeight，SDWebImage。
iOS-YHChat仿微信聊天（老司机带你入门即时通讯）
samuelandkevin的专栏
02-17 9692
iOS-YHChat仿微信聊天（老司机带你入门即时通讯）
iOS二维码生成中间带图片Logo
samuelandkevin的专栏
04-18 6031
iOS二维码生成中间带图片Logo
iOS- UICollectionView实现表情数据横排横滚动
samuelandkevin的专栏
02-10 5908
1.问题提出         在开发即时通讯项目时会遇到一个需求，那就是开发一个表情键盘。这时候实现的方法有好多种，大部分人会考虑用UIScrollView实现，但是当表情有200个的时候，UIScrollView的button难道就要创建200个么？考虑到按钮重用的，自然想到UICollectionView。想实现表情数据横排横滚动，可能会遇到设置cell的数据源的坑。 笔者数据源文件.pl...
uni-app+uView搭建app
最新发布
05-19
Uni-app 是一个跨平台的应用开发框架，可以用一套代码同时开发 iOS、Android、H5 等多个平台的应用。而 uView 是一套基于 uni-app 的 UI 组件库，提供了丰富的组件和样式，可以帮助开发者快速搭建应用。 下面是搭建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值