_YYModelMeta 这个内部的类主要是对这个类的描述。包含了和此类转换相关的数据。
/// A class info in object model.
@interface _YYModelMeta : NSObject {
@package
YYClassInfo *_classInfo;
/// Key:mapped key and key path, Value:_YYModelPropertyMeta.
NSDictionary *_mapper;
/// Array<_YYModelPropertyMeta>, all property meta of this model.
NSArray *_allPropertyMetas;
/// Array<_YYModelPropertyMeta>, property meta which is mapped to a key path.
NSArray *_keyPathPropertyMetas;
/// Array<_YYModelPropertyMeta>, property meta which is mapped to multi keys.
NSArray *_multiKeysPropertyMetas;
/// The number of mapped key (and key path), same to _mapper.count.
NSUInteger _keyMappedCount;
/// Model class type.
YYEncodingNSType _nsType; BOOL _hasCustomWillTransformFromDictionary;
BOOL _hasCustomTransformFromDictionary;
BOOL _hasCustomTransformToDictionary;
BOOL _hasCustomClassFromDictionary;
}
@end
YYClassInfo *_classInfo; ------------- 抽象的类信息
对这个映射的关系 ，可能大家不太了解，下边通过一个例子可以非常清晰的解释这一过程
自定义的映射关系有一下几种：
1. 一个属性名对应一个json key
+ (NSDictionary *)modelCustomPropertyMapper {
return @{@"userID" : @"id",
@"idString" : @"idstr",
}
2. 多个属性映射同一个json key
+ (NSDictionary *)modelCustomPropertyMapper {
return @{@"userID" : @"id",
@"idString" : @"id",
@"uid" : @"id",
}
3. 一个属性映射 一个 json keyPath
+ (NSDictionary *)modelCustomPropertyMapper {
return @{@"userID" : @"user.id",
}
4. 一个属性 映射 多个json key 或者 keyPath
+ (NSDictionary *)modelCustomPropertyMapper {
// 映射的数组送 包含key 也包含keyPath
return @{@"userID" : @[@"ID",@"id",@"user.id"],
}
上边的第二个情况
@{@"userID" : @"id",
@"idString" : @"id",
@"uid" : @"id",
}
中为了解决多个属性映射同一 key 的 问题， 引入了链表的 操作
-> next 指针指向下一个 属性
至于 链表的知识 请查资料了解
NSDictionary *_mapper ---------- > 来源于原始json 的 映射关系
"attitudes_count" = "<_YYModelPropertyMeta: 0x7f8f89efb7d0>";
"thumbnail" : {
"cut_type" : ,
"type" : "WEBP",
"url" : "http://ww2.sinaimg.cn/or180/eb8fce65jw1ew468zkxcgj237k1t01l0.jpg",
"width" : ,
"height" :
},上边的代码是一个json 我们在代码中是这样写的
@property (nonatomic, strong) YYWeiboPictureMetadata *thumbnail;
那么 映射完成后的结果是
"cut_type" = "<_YYModelPropertyMeta: 0x7f8f8eb14c90>";
height = "<_YYModelPropertyMeta: 0x7f8f8eb14fa0>";
type = "<_YYModelPropertyMeta: 0x7f8f8eb14b40>";
url = "<_YYModelPropertyMeta: 0x7f8f8eb14d10>";
width = "<_YYModelPropertyMeta: 0x7f8f8eb14d90>";
key 依然是原有的json 的key 但是 value 是 在这个映射类中 包含已经映射成功后的对这个key的YYModelPropertyMeta封装
NSArray *_allPropertyMetas --------- > 包含该类和该类的所有父类 直到 NSObject/NSProxy为止的所有属性抽象类NSArray<_YYModelPropertyMeta>
NSArray *_keyPathPropertyMetas --------- > 包含 映射为keypath 的 NSArray<_YYModelPropertyMeta>
NSArray *_multiKeysPropertyMetas ----------> @{@"userID" : @[@"ID",@"id",@"user.id"] 类似这样映射，包含有数组映射的NSArray<_YYModelPropertyMeta>
在下边的这个实现方法中不但给上面介绍的 属性赋值外，还给_YYModelPropertyMeta 内的部分属性进行了赋值，代码中都有相信的说明
- (instancetype)initWithClass:(Class)cls {
// 根据类 生成 抽象的ClassInfo 类
YYClassInfo *classInfo = [YYClassInfo classInfoWithClass:cls];
if (!classInfo) return nil;
self = [super init];
// Get black list
// 黑名单，在转换过程中会忽略数组中属性
NSSet *blacklist = nil;
if ([cls respondsToSelector:@selector(modelPropertyBlacklist)]) {
NSArray *properties = [(id<YYModel>)cls modelPropertyBlacklist];
if (properties) {
blacklist = [NSSet setWithArray:properties];
}
}
// Get white list
// 白名单，转换过程 中处理 数组内的属性，不处理数组外的数据
NSSet *whitelist = nil;
if ([cls respondsToSelector:@selector(modelPropertyWhitelist)]) {
NSArray *properties = [(id<YYModel>)cls modelPropertyWhitelist];
if (properties) {
whitelist = [NSSet setWithArray:properties];
}
}
// Get container property's generic class
// 获取 容器内部制定的类型字典
/**
+ (NSDictionary *)modelContainerPropertyGenericClass {
return @{@"shadows" : [Shadow class],
@"borders" : Border.class,
@"attachments" : @"Attachment" };
}
经过下边转换后得到：
@{
@"shadows" : Shadow,
@"borders" : Border,
@"attachments" : Attachment
};
*/
NSDictionary *genericMapper = nil;
if ([cls respondsToSelector:@selector(modelContainerPropertyGenericClass)]) {
genericMapper = [(id<YYModel>)cls modelContainerPropertyGenericClass];
if (genericMapper) {
NSMutableDictionary *tmp = [NSMutableDictionary new];
[genericMapper enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
if (![key isKindOfClass:[NSString class]]) return;
Class meta = object_getClass(obj);
if (!meta) return;
if (class_isMetaClass(meta)) {
tmp[key] = obj;
} else if ([obj isKindOfClass:[NSString class]]) {
Class cls = NSClassFromString(obj);
if (cls) {
tmp[key] = cls;
}
}
}];
genericMapper = tmp;
}
}
// Create all property metas.
// 获取 所有的属性
NSMutableDictionary *allPropertyMetas = [NSMutableDictionary new];
YYClassInfo *curClassInfo = classInfo;
/**
* 向上层便利类，知道父类为空位置，目的是获取所有的属性
*/
while (curClassInfo && curClassInfo.superCls != nil) { // recursive parse super class, but ignore root class (NSObject/NSProxy)
for (YYClassPropertyInfo *propertyInfo in curClassInfo.propertyInfos.allValues) {
//属性名称为空 忽略
if (!propertyInfo.name) continue;
//在黑名单中 忽略
if (blacklist && [blacklist containsObject:propertyInfo.name]) continue;
// 不在白名单中忽略
if (whitelist && ![whitelist containsObject:propertyInfo.name]) continue;
/**
* 创建对该条属性的抽象类
* classInfo
* propertyInfo
* genericMapper[propertyInfo.name] 容器内指定的类
*/
_YYModelPropertyMeta *meta = [_YYModelPropertyMeta metaWithClassInfo:classInfo
propertyInfo:propertyInfo
generic:genericMapper[propertyInfo.name]];
// 判断
if (!meta || !meta->_name) continue;
if (!meta->_getter || !meta->_setter) continue;
// 如果字典中存在，忽略
if (allPropertyMetas[meta->_name]) continue;
// 给字典复制
allPropertyMetas[meta->_name] = meta;
}
// 当前的类 指向上一个类的父类
curClassInfo = curClassInfo.superClassInfo;
}
// 给本类的属性_allPropertyMetas 赋值
if (allPropertyMetas.count) _allPropertyMetas = allPropertyMetas.allValues.copy;
// create mapper
NSMutableDictionary *mapper = [NSMutableDictionary new];
NSMutableArray *keyPathPropertyMetas = [NSMutableArray new];
NSMutableArray *multiKeysPropertyMetas = [NSMutableArray new];
/**
* 如果实现了 modelCustomPropertyMapper 方法
*
* @param modelCustomPropertyMapper
*
*/
if ([cls respondsToSelector:@selector(modelCustomPropertyMapper)]) {
// 获取自定义的字典
NSDictionary *customMapper = [(id <YYModel>)cls modelCustomPropertyMapper];
// 遍历字典
[customMapper enumerateKeysAndObjectsUsingBlock:^(NSString *propertyName, NSString *mappedToKey, BOOL *stop) {
// 根据名字 在 全部属性字典中取出与之相对应的属性抽象类
_YYModelPropertyMeta *propertyMeta = allPropertyMetas[propertyName];
if (!propertyMeta) return;
// 已经找到了结果，可以删除掉，这样在下次查找的时候，就不用做多余的遍历了 ，能够节省时间
[allPropertyMetas removeObjectForKey:propertyName];
if ([mappedToKey isKindOfClass:[NSString class]]) {
if (mappedToKey.length == ) return;
// 给抽象类的_mappedToKey 赋值 标示要被映射的名称 下边的指的就是@"n",@"p"...
/*
+ (NSDictionary *)modelCustomPropertyMapper {
return @{@"name" : @"n",
@"page" : @"p",
@"desc" : @"ext.desc",
@"bookID" : @[@"id",@"ID",@"book_id"]};
}
*/
propertyMeta->_mappedToKey = mappedToKey;
// 映射对象 如果是keypath ，@"user.id"
NSArray *keyPath = [mappedToKey componentsSeparatedByString:@"."];
// 遍历数组 ，删除空字符串
for (NSString *onePath in keyPath) {
// 如果存在空字符 则在原数组中删除
if (onePath.length == ) {
NSMutableArray *tmp = keyPath.mutableCopy;
[tmp removeObject:@""];
keyPath = tmp;
break;
}
}
// keypath 的个数大于1 说明为 有效路径
if (keyPath.count > ) {
// 赋值
propertyMeta->_mappedToKeyPath = keyPath;
[keyPathPropertyMetas addObject:propertyMeta];
}
// 控制 propertyMeta 的 next 指针 指向下一个 映射
propertyMeta->_next = mapper[mappedToKey] ?: nil;
mapper[mappedToKey] = propertyMeta;
} else if ([mappedToKey isKindOfClass:[NSArray class]]) {
NSMutableArray *mappedToKeyArray = [NSMutableArray new];
for (NSString *oneKey in ((NSArray *)mappedToKey)) {
if (![oneKey isKindOfClass:[NSString class]]) continue;
if (oneKey.length == ) continue;
// 如果映射的是数组，保存 数组到mappedToKeyArray 中， 否则保存 映射字符串
NSArray *keyPath = [oneKey componentsSeparatedByString:@"."];
if (keyPath.count > ) {
[mappedToKeyArray addObject:keyPath];
} else {
[mappedToKeyArray addObject:oneKey];
}
// 赋值
if (!propertyMeta->_mappedToKey) {
propertyMeta->_mappedToKey = oneKey;
propertyMeta->_mappedToKeyPath = keyPath.count > ? keyPath : nil;
}
}
if (!propertyMeta->_mappedToKey) return;
propertyMeta->_mappedToKeyArray = mappedToKeyArray;
[multiKeysPropertyMetas addObject:propertyMeta];
propertyMeta->_next = mapper[mappedToKey] ?: nil;
mapper[mappedToKey] = propertyMeta;
}
}];
}
[allPropertyMetas enumerateKeysAndObjectsUsingBlock:^(NSString *name, _YYModelPropertyMeta *propertyMeta, BOOL *stop) {
propertyMeta->_mappedToKey = name;
propertyMeta->_next = mapper[name] ?: nil;
mapper[name] = propertyMeta;
}];
if (mapper.count) _mapper = mapper;
if (keyPathPropertyMetas) _keyPathPropertyMetas = keyPathPropertyMetas;
if (multiKeysPropertyMetas) _multiKeysPropertyMetas = multiKeysPropertyMetas;
NSLog(@" allmapper: -----%@ \n keyPathPropertyMetas: ------%@",allPropertyMetas,keyPathPropertyMetas);
_classInfo = classInfo;
_keyMappedCount = _allPropertyMetas.count;
_nsType = YYClassGetNSType(cls);
_hasCustomWillTransformFromDictionary = ([cls instancesRespondToSelector:@selector(modelCustomWillTransformFromDictionary:)]);
_hasCustomTransformFromDictionary = ([cls instancesRespondToSelector:@selector(modelCustomTransformFromDictionary:)]);
_hasCustomTransformToDictionary = ([cls instancesRespondToSelector:@selector(modelCustomTransformToDictionary:)]);
_hasCustomClassFromDictionary = ([cls respondsToSelector:@selector(modelCustomClassForDictionary:)]);
return self;
}下边的方法是 在缓存中读取 抽象类
/// Returns the cached model class meta
+ (instancetype)metaWithClass:(Class)cls {
if (!cls) return nil;
static CFMutableDictionaryRef cache;
static dispatch_once_t onceToken;
static dispatch_semaphore_t lock;
dispatch_once(&onceToken, ^{
cache = CFDictionaryCreateMutable(CFAllocatorGetDefault(), , &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
lock = dispatch_semaphore_create();
});
dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
_YYModelMeta *meta = CFDictionaryGetValue(cache, (__bridge const void *)(cls));
dispatch_semaphore_signal(lock);
if (!meta || meta->_classInfo.needUpdate) {
meta = [[_YYModelMeta alloc] initWithClass:cls];
if (meta) {
dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
CFDictionarySetValue(cache, (__bridge const void *)(cls), (__bridge const void *)(meta));
dispatch_semaphore_signal(lock);
}
}
return meta;
}
简单总结下_YYModelMeta 实现的思路
1.根据类 生成 抽象的ClassInfo 类
classInfo
2. 获取黑名单，在转换过程中会忽略数组中属性
blacklist
3. 获取白名单，转换过程 中处理 数组内的属性，不处理数组外的数据
whitelist
4.对实现了modelContainerPropertyGenericClass 方法 进行必要的转换 类中包含有容易的情况
/**
+ (NSDictionary *)modelContainerPropertyGenericClass {
return @{@"shadows" : [Shadow class],
@"borders" : Border.class,
@"attachments" : @"Attachment" };
}
经过下边转换后得到：
@{
@"shadows" : Shadow,
@"borders" : Border,
@"attachments" : Attachment
};
*/5. 获取 所有的属性
allPropertyMetas
/**
* 向上层便利类，知道父类为空位置，目的是获取所有的属性
*/
6. 给本类的属性_allPropertyMetas 赋值
if (allPropertyMetas.count) _allPropertyMetas = allPropertyMetas.allValues.copy;
7. 如果实现了 modelCustomPropertyMapper 方法 也就是自定义了映射
7.1 通过下边的方法可判断是不是进行了自定义映射
if ([cls respondsToSelector:@selector(modelCustomPropertyMapper)])
7.2 获取自定义的字典 customMapper
NSDictionary *customMapper = [(id <YYModel>)cls modelCustomPropertyMapper];
7.3 遍历 字典
mappedToKey 有两个类型
一种是：字符串， 另一种是 字符数组
如果是字符串 propertyMeta->_mappedToKey = mappedToKey 直接赋值
如果是数组 取数组中第一个不为空的字符串
同理，keypath 也同上一样的获取到
multiKeysPropertyMetas 同在 在是数组的情况加 添加抽象类
8. 赋值其他