终于把前面的base文件夹简简单单的看了一遍，终于可以回到正片上来了，保证不烂尾。

项目天天用yymodel解析数据，效率高也没看看到底为啥效率高，最近有时间，仔细看看。

NSObject+YYModel

YYClassInfo

这个类怎么学习呢？我从调用入口看是看起。

由于yykit 框架里面的yymodel 方法名没有标记yy_ 所以，我们使用的是yymodel 进行分析。

yymodel 类是NSObject 的category

+ (instancetype)yy_modelWithJSON:(id)json {

NSDictionary *dic = [self _yy_dictionaryWithJSON:json];

return [self yy_modelWithDictionary:dic];

}

1.调用 + (NSDictionary *)_yy_dictionaryWithJSON:(id)json<1> 函数获取 dic

2 调用+ (instancetype)yy_modelWithDictionary:(NSDictionary *)dictionary<2> 返回结果

我们看<1> 的函数

+ (NSDictionary *)_yy_dictionaryWithJSON:(id)json {

if (!json || json == (id)kCFNull) return nil;

NSDictionary *dic = nil;

NSData *jsonData = nil;

if ([json isKindOfClass:[NSDictionary class]]) {

dic = json;

} else if ([json isKindOfClass:[NSString class]]) {

jsonData = [(NSString *)json dataUsingEncoding : NSUTF8StringEncoding];

} else if ([json isKindOfClass:[NSData class]]) {

jsonData = json;

}

if (jsonData) {

dic = [NSJSONSerialization JSONObjectWithData:jsonData options:kNilOptions error:NULL];

if (![dic isKindOfClass:[NSDictionary class]]) dic = nil;

}

return dic;

}

我们从这里看出来我们外界传入到该类的参数可以是NSDictionary NSString NSData

但是最后返回的结果是NSDictionary

接下来我们看<2>出的函数

+ (instancetype)yy_modelWithDictionary:(NSDictionary *)dictionary {

if (!dictionary || dictionary == (id)kCFNull) return nil;

if (![dictionary isKindOfClass:[NSDictionary class]]) return nil;

Class cls = [self class];

_YYModelMeta *modelMeta = [_YYModelMeta metaWithClass:cls];

if (modelMeta->_hasCustomClassFromDictionary) {

cls = [cls modelCustomClassForDictionary:dictionary] ?: cls;

}

NSObject *one = [cls new];

if ([one yy_modelSetWithDictionary:dictionary]) return one;

return nil;

}

这个函数算是真正解析的入口了。我们看看这个方法都干了啥事情

1 第一步校验参数是否正确

2获取该类的class

3 通过_YYModelMeta 的类方法+ (instancetype)metaWithClass:(Class)cls <3>获取一个_YYModelMeta 对象

4 判断 _YYModelMeta对象是否有_hasCustomClassFromDictionary标记为YES，有的话，cls 就调用下+ (nullable Class)modelCustomClassForDictionary:(NSDictionary *)dictionary <4> 方法 .要是返会cls 那么就给赋值，没有则用原来的cls

5 .创建对象

6 调用- (BOOL)yy_modelSetWithDictionary:(NSDictionary *)dic <5>方法

7返回

这个函数有个新类_YYModelMeta

我们看看这个类干啥的

先看看这个类的属性

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;

属性先不做介绍，看源码实现。先调用这个函数

这里是<3 >处的分析

/// 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(), 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

lock = dispatch_semaphore_create(1);

});

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;

}

这个函数干啥了呢?

1.生成一个单例缓存CFMutableDictionaryRef cache 和一个信号量

2.从缓存中查找key 是class的 _YYModelMeta

3.要是缓存中没有meta 或者meta 标记为需要更新

4. 通过- (instancetype)initWithClass:(Class)cls 方法创建meta

5 将meta 更新到单例缓存数组中

总结下这个函数，这个函数就是从缓存获取解析完毕的_YYModelMeta 没有就解析该类

接下来看- (instancetype)initWithClass:(Class)cls 函数

- (instancetype)initWithClass:(Class)cls { 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)cls modelPropertyBlacklist]; if (properties) { blacklist = [NSSet setWithArray:properties]; } } // Get white list NSSet *whitelist = nil; if ([cls respondsToSelector:@selector(modelPropertyWhitelist)]) { NSArray *properties = [(id)cls modelPropertyWhitelist]; if (properties) { whitelist = [NSSet setWithArray:properties]; } } // Get container property's generic class NSDictionary *genericMapper = nil; if ([cls respondsToSelector:@selector(modelContainerPropertyGenericClass)]) { genericMapper = [(id)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; _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; } if (allPropertyMetas.count) _allPropertyMetas = allPropertyMetas.allValues.copy; // create mapper NSMutableDictionary *mapper = [NSMutableDictionary new]; NSMutableArray *keyPathPropertyMetas = [NSMutableArray new]; NSMutableArray *multiKeysPropertyMetas = [NSMutableArray new]; if ([cls respondsToSelector:@selector(modelCustomPropertyMapper)]) { NSDictionary *customMapper = [(id)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 == 0) return;

propertyMeta->_mappedToKey = mappedToKey;

NSArray *keyPath = [mappedToKey componentsSeparatedByString:@"."];

for (NSString *onePath in keyPath) {

if (onePath.length == 0) {

NSMutableArray *tmp = keyPath.mutableCopy;

[tmp removeObject:@""];

keyPath = tmp;

break;

}

}

if (keyPath.count > 1) {

propertyMeta->_mappedToKeyPath = keyPath;

[keyPathPropertyMetas addObject:propertyMeta];

}

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 == 0) continue;

NSArray *keyPath = [oneKey componentsSeparatedByString:@"."];

if (keyPath.count > 1) {

[mappedToKeyArray addObject:keyPath];

} else {

[mappedToKeyArray addObject:oneKey];

}

if (!propertyMeta->_mappedToKey) {

propertyMeta->_mappedToKey = oneKey;

propertyMeta->_mappedToKeyPath = keyPath.count > 1 ? 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;

_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;

}

这个方法我们看看都干啥了

1. 生成一个YYClassInfo 对象

2.要是 cla 实现 + (nullable NSArray*)modelPropertyBlacklist 方法了，回去改方法的数据

3.要是cls 实现+ (nullable NSArray*)modelPropertyWhitelist; 方法，临时变量保存改方法的返回值

4 要是cls 实现+ (NSDictionary *)modelContainerPropertyGenericClass 方法。那么就对返回的数据进行简单的处理，保存到临时变量中。（这里适配了 obj 是class 或者字符串两种形式。）

5.给临时数组allPropertyMetas 增加key是_YYModelPropertyMeta 的name 值是self 对象。这里的具体细节解析在下面分析，暂时标记为<6>

6. 变量_allPropertyMetas 指向临时变量allPropertyMetas 的所有value 值

7.要是cls实现了 + (NSDictionary *)modelCustomPropertyMapper ，那么调用cls调用+ (NSDictionary *)modelCustomPropertyMapper 方法。给临时变量mapper，keyPathPropertyMetas ，multiKeysPropertyMetas 赋值。具体赋值看<7>出

8.修改临时变量allPropertyMetas 中的_YYModelPropertyMeta 相关属性

9.给变量_mapper，_keyPathPropertyMetas，_multiKeysPropertyMetas 赋值。

10给变量 _classInfo _keyMappedCount _nsType 赋值。这里有个static force_inline YYEncodingNSType YYClassGetNSType(Class cls)<8> 方法。

11 给变量 _hasCustomWillTransformFromDictionary _hasCustomTransformFromDictionary _hasCustomTransformToDictionary _hasCustomClassFromDictionary 赋值这四个参数分别标记是否有一个特定关联的函数

12 返回self

这个类关键处 YYClassInfo _YYModelPropertyMeta 和没有分析的标记的<6>出的地方

接下来先看 YYClassInfo 类

分析类成员变量

黄色代表 public 属性

粉红色代表 privite 变量

接下来我们看初始化

public方法提供了两个，只有类方法初始化，没有实例初始化

+ (instancetype)classInfoWithClassName:(NSString *)className

+ (instancetype)classInfoWithClass:(Class)cls

+ (instancetype)classInfoWithClassName:(NSString *)className {

Class cls = NSClassFromString(className);

return [self classInfoWithClass:cls];

}

这个函数就是将className 转换成class 再调用上面的初始化方法

+ (instancetype)classInfoWithClass:(Class)cls {

if (!cls) return nil;

static CFMutableDictionaryRef classCache;

static CFMutableDictionaryRef metaCache;

static dispatch_once_t onceToken;

static dispatch_semaphore_t lock;

dispatch_once(&onceToken, ^{

classCache = CFDictionaryCreateMutable(CFAllocatorGetDefault(), 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

metaCache = CFDictionaryCreateMutable(CFAllocatorGetDefault(), 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

lock = dispatch_semaphore_create(1);

});

dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);

YYClassInfo *info = CFDictionaryGetValue(class_isMetaClass(cls) ? metaCache : classCache, (__bridge const void *)(cls));

if (info && info->_needUpdate) {

[info _update];

}

dispatch_semaphore_signal(lock);

if (!info) {

info = [[YYClassInfo alloc] initWithClass:cls];

if (info) {

dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);

CFDictionarySetValue(info.isMeta ? metaCache : classCache, (__bridge const void *)(cls), (__bridge const void *)(info));

dispatch_semaphore_signal(lock);

}

}

return info;

}

这个函数干啥了呢

1.单例实例化一个classCache 字典和metaCache 字典，还初始化了信号量

2. 检查class 是meta 还是 class ，是meta 从meta 字典去key 是cls 的值，不是meta ，那么从class 字典中取 key是cls的值。

3 要是从缓存中获取到了cls 值，并且cls标记为需要更新，那么调用 - (void)_update <9>

4没有值，那么创建一个YYClassInfo ，并根据是否是meta保存到相应字典中去

5返回。

这个函数就是从缓存中获取class 信息，没有就创建一个，具体创建方法是这个房- (instancetype)initWithClass:(Class)cls。

- (instancetype)initWithClass:(Class)cls {

if (!cls) return nil;

self = [super init];

_cls = cls;

_superCls = class_getSuperclass(cls);

_isMeta = class_isMetaClass(cls);

if (!_isMeta) {

_metaCls = objc_getMetaClass(class_getName(cls));

}

_name = NSStringFromClass(cls);

[self _update];

_superClassInfo = [self.class classInfoWithClass:_superCls];

return self;

}

这个方法干啥事情了呢？

1. 根据类的特性给变量_cls _superCls _isMeta _metaCls _name 赋值，

2.调用- (void)_update 方法

3.解析父类class ，将结果赋值给 _superClassInfo 结构如下

className 是解析的class

superClassInfo 保存的是super的解析的YYClassInfo

类结构明白了。那么我们应该看看 <9> - (void)_update 这个类解析啥了

- (void)_update {

_ivarInfos = nil;

_methodInfos = nil;

_propertyInfos = nil;

Class cls = self.cls;

unsigned int methodCount = 0;

Method *methods = class_copyMethodList(cls, &methodCount);

if (methods) {

NSMutableDictionary *methodInfos = [NSMutableDictionary new];

_methodInfos = methodInfos;

for (unsigned int i = 0; i < methodCount; i++) {

YYClassMethodInfo *info = [[YYClassMethodInfo alloc] initWithMethod:methods[i]];

if (info.name) methodInfos[info.name] = info;

}

free(methods);

}

unsigned int propertyCount = 0;

objc_property_t *properties = class_copyPropertyList(cls, &propertyCount);

if (properties) {

NSMutableDictionary *propertyInfos = [NSMutableDictionary new];

_propertyInfos = propertyInfos;

for (unsigned int i = 0; i < propertyCount; i++) {

YYClassPropertyInfo *info = [[YYClassPropertyInfo alloc] initWithProperty:properties[i]];

if (info.name) propertyInfos[info.name] = info;

}

free(properties);

}

unsigned int ivarCount = 0;

Ivar *ivars = class_copyIvarList(cls, &ivarCount);

if (ivars) {

NSMutableDictionary *ivarInfos = [NSMutableDictionary new];

_ivarInfos = ivarInfos;

for (unsigned int i = 0; i < ivarCount; i++) {

YYClassIvarInfo *info = [[YYClassIvarInfo alloc] initWithIvar:ivars[i]];

if (info.name) ivarInfos[info.name] = info;

}

free(ivars);

}

if (!_ivarInfos) _ivarInfos = @{};

if (!_methodInfos) _methodInfos = @{};

if (!_propertyInfos) _propertyInfos = @{};

_needUpdate = NO;

}

1.获取self.cls 的所有method

2. 用YYClassMethodInfo 解析method 的每一个方法，将YYClassMethodInfo 保存到到变量_methodInfos字典中，key是 YYClassMethodInfo 的name ，将字典

3.获取objc_property_t 列表，用YYClassPropertyInfo 解析每一个属性，将YYClassPropertyInfo 保存到变量_propertyInfos 中key 是YYClassPropertyInfo 的name

4同理，_ivarInfos 保存该类的Ivar ，将Ivar 封装在了YYClassIvarInfo，key是name

5.将_needUpdate 变量设置为NO

这个类里面出现了三个新的类YYClassMethodInfo，YYClassPropertyInfo，YYClassIvarInfo。

YYClassMethodInfo类

这个类的方法就一个

- (instancetype)initWithMethod:(Method)method;

- (instancetype)initWithMethod:(Method)method {

if (!method) return nil;

self = [super init];

_method = method;

_sel = method_getName(method);

_imp = method_getImplementation(method);

const char *name = sel_getName(_sel);

if (name) {

_name = [NSString stringWithUTF8String:name];

}

const char *typeEncoding = method_getTypeEncoding(method);

if (typeEncoding) {

_typeEncoding = [NSString stringWithUTF8String:typeEncoding];

}

char *returnType = method_copyReturnType(method);

if (returnType) {

_returnTypeEncoding = [NSString stringWithUTF8String:returnType];

free(returnType);

}

unsigned int argumentCount = method_getNumberOfArguments(method);

if (argumentCount > 0) {

NSMutableArray *argumentTypes = [NSMutableArray new];

for (unsigned int i = 0; i < argumentCount; i++) {

char *argumentType = method_copyArgumentType(method, i);

NSString *type = argumentType ? [NSString stringWithUTF8String:argumentType] : nil;

[argumentTypes addObject:type ? type : @""];

if (argumentType) free(argumentType);

}

_argumentTypeEncodings = argumentTypes;

}

return self;

}

1变量_method 保存method

2 变量_sel 保存method 的 name

3变量_imp 保存method 的方法实现

4 获取变量_sel的name 将其保存在变量_name 属性中

5 获取method 的编码，保存在变量_typeEncoding 中

6 获取method 的返回值类型，保存在变量_returnTypeEncoding 中

7获取mthod的参数数量，变量获取每一个参数类型，将参数类型保存依次加入到参数数组中，让变量_argumentTypeEncodings 引用该参数数组。

8.返回self

YYClassMethodInfo 类就是解析了Method 的方方面面。

YYClassPropertyInfo 类

上图是YYClassPropertyInfo 的类结构

方法也就一个

- (instancetype)initWithProperty:(objc_property_t)property

- (instancetype)initWithProperty:(objc_property_t)property {

if (!property) return nil;

self = [super init];

_property = property;

const char *name = property_getName(property);

if (name) {

_name = [NSString stringWithUTF8String:name];

}

YYEncodingType type = 0;

unsigned int attrCount;

objc_property_attribute_t *attrs = property_copyAttributeList(property, &attrCount);

for (unsigned int i = 0; i < attrCount; i++) {

switch (attrs[i].name[0]) {

case 'T': { // Type encoding

if (attrs[i].value) {

_typeEncoding = [NSString stringWithUTF8String:attrs[i].value];

type = YYEncodingGetType(attrs[i].value);

if ((type & YYEncodingTypeMask) == YYEncodingTypeObject && _typeEncoding.length) {

NSScanner *scanner = [NSScanner scannerWithString:_typeEncoding];

if (![scanner scanString:@"@\"" intoString:NULL]) continue;

NSString *clsName = nil;

if ([scanner scanUpToCharactersFromSet: [NSCharacterSet characterSetWithCharactersInString:@"\"<"] intoString:&clsName]) {

if (clsName.length) _cls = objc_getClass(clsName.UTF8String);

}

NSMutableArray *protocols = nil;

while ([scanner scanString:@"<" intoString:NULL]) {

NSString* protocol = nil;

if ([scanner scanUpToString:@">" intoString: &protocol]) {

if (protocol.length) {

if (!protocols) protocols = [NSMutableArray new];

[protocols addObject:protocol];

}

}

[scanner scanString:@">" intoString:NULL];

}

_protocols = protocols;

}

}

} break;

case 'V': { // Instance variable

if (attrs[i].value) {

_ivarName = [NSString stringWithUTF8String:attrs[i].value];

}

} break;

case 'R': {

type |= YYEncodingTypePropertyReadonly;

} break;

case 'C': {

type |= YYEncodingTypePropertyCopy;

} break;

case '&': {

type |= YYEncodingTypePropertyRetain;

} break;

case 'N': {

type |= YYEncodingTypePropertyNonatomic;

} break;

case 'D': {

type |= YYEncodingTypePropertyDynamic;

} break;

case 'W': {

type |= YYEncodingTypePropertyWeak;

} break;

case 'G': {

type |= YYEncodingTypePropertyCustomGetter;

if (attrs[i].value) {

_getter = NSSelectorFromString([NSString stringWithUTF8String:attrs[i].value]);

}

} break;

case 'S': {

type |= YYEncodingTypePropertyCustomSetter;

if (attrs[i].value) {

_setter = NSSelectorFromString([NSString stringWithUTF8String:attrs[i].value]);

}

} // break; commented for code coverage in next line

default: break;

}

}

if (attrs) {

free(attrs);

attrs = NULL;

}

_type = type;

if (_name.length) {

if (!_getter) {

_getter = NSSelectorFromString(_name);

}

if (!_setter) {

_setter = NSSelectorFromString([NSString stringWithFormat:@"set%@%@:", [_name substringToIndex:1].uppercaseString, [_name substringFromIndex:1]]);

}

}

return self;

}

1 变量_property 保存objc_property_t 结构体

2获取 objc_property_t 的name 保存到变量_name 中

3获取objc_property_t 结构体的属性和数量

这里我们就应该了解属性的type 苹果官网的编码还有一篇

You can use theproperty_getAttributesfunction to discover the name, the@encodetype string of a property, and other attributes of the property.

The string starts with aTfollowed by the@encodetype and a comma, and finishes with aVfollowed by the name of the backing instance variable. Between these, the attributes are specified by the following descriptors, separated by commas:

截图如下

这个表里面没有T T代表属性类型。

@property(readonly) int intReadonly;

结果是

Ti,R,VintReadonly Ti 代表int 类型，R 代表只读属性，V代表实例变量intReadonly

4.解析属性，给相关变量赋值

5.将解析的type 赋值给_type 变量

6.要是没有设置get set 方法。设置get set 方法。

7 返回self

这个函数的关键部分是上面介绍的第四步

这里分情况讨论objc_property_attribute_t 的name[0] 属性值

<1> name[0]=T

这里给_typeEncoding 变量赋值，值是objc_property_attribute_t value 的字符串。

这里有个编码 YYEncodingType YYEncodingGetType(const char *typeEncoding)

返回结果是YYEncodingType

/**

Type encoding's type.

*/

typedef NS_OPTIONS(NSUInteger, YYEncodingType) {

YYEncodingTypeMask = 0xFF, ///< mask of type value

YYEncodingTypeUnknown = 0, ///< unknown

YYEncodingTypeVoid = 1, ///< void

YYEncodingTypeBool = 2, ///< bool

YYEncodingTypeInt8 = 3, ///< char / BOOL

YYEncodingTypeUInt8 = 4, ///< unsigned char

YYEncodingTypeInt16 = 5, ///< short

YYEncodingTypeUInt16 = 6, ///< unsigned short

YYEncodingTypeInt32 = 7, ///< int

YYEncodingTypeUInt32 = 8, ///< unsigned int

YYEncodingTypeInt64 = 9, ///< long long

YYEncodingTypeUInt64 = 10, ///< unsigned long long

YYEncodingTypeFloat = 11, ///< float

YYEncodingTypeDouble = 12, ///< double

YYEncodingTypeLongDouble = 13, ///< long double

YYEncodingTypeObject = 14, ///< id

YYEncodingTypeClass = 15, ///< Class

YYEncodingTypeSEL = 16, ///< SEL

YYEncodingTypeBlock = 17, ///< block

YYEncodingTypePointer = 18, ///< void*

YYEncodingTypeStruct = 19, ///< struct

YYEncodingTypeUnion = 20, ///< union

YYEncodingTypeCString = 21, ///< char*

YYEncodingTypeCArray = 22, ///< char[10] (for example)

YYEncodingTypeQualifierMask = 0xFF00, ///< mask of qualifier

YYEncodingTypeQualifierConst = 1 << 8, ///< const

YYEncodingTypeQualifierIn = 1 << 9, ///< in

YYEncodingTypeQualifierInout = 1 << 10, ///< inout

YYEncodingTypeQualifierOut = 1 << 11, ///< out

YYEncodingTypeQualifierBycopy = 1 << 12, ///< bycopy

YYEncodingTypeQualifierByref = 1 << 13, ///< byref

YYEncodingTypeQualifierOneway = 1 << 14, ///< oneway

YYEncodingTypePropertyMask = 0xFF0000, ///< mask of property

YYEncodingTypePropertyReadonly = 1 << 16, ///< readonly

YYEncodingTypePropertyCopy = 1 << 17, ///< copy

YYEncodingTypePropertyRetain = 1 << 18, ///< retain

YYEncodingTypePropertyNonatomic = 1 << 19, ///< nonatomic

YYEncodingTypePropertyWeak = 1 << 20, ///< weak

YYEncodingTypePropertyCustomGetter = 1 << 21, ///< getter=

YYEncodingTypePropertyCustomSetter = 1 << 22, ///< setter=

YYEncodingTypePropertyDynamic = 1 << 23, ///< @dynamic

};

类型编码

YYEncodingTypeMask 编码区对应的是类型编码官网

YYEncodingTypeQualifierMask 编码区对应的是方法编码官网最下方

YYEncodingTypePropertyMask 对应的属性编码官网

接下来看字符串怎么转换的成编码的

YYEncodingType YYEncodingGetType(const char *typeEncoding) {

char *type = (char *)typeEncoding;

if (!type) return YYEncodingTypeUnknown;

size_t len = strlen(type);

if (len == 0) return YYEncodingTypeUnknown;

YYEncodingType qualifier = 0;

bool prefix = true;

while (prefix) {

switch (*type) {

case 'r': {

qualifier |= YYEncodingTypeQualifierConst;

type++;

} break;

case 'n': {

qualifier |= YYEncodingTypeQualifierIn;

type++;

} break;

case 'N': {

qualifier |= YYEncodingTypeQualifierInout;

type++;

} break;

case 'o': {

qualifier |= YYEncodingTypeQualifierOut;

type++;

} break;

case 'O': {

qualifier |= YYEncodingTypeQualifierBycopy;

type++;

} break;

case 'R': {

qualifier |= YYEncodingTypeQualifierByref;

type++;

} break;

case 'V': {

qualifier |= YYEncodingTypeQualifierOneway;

type++;

} break;

default: { prefix = false; } break;

}

}

len = strlen(type);

if (len == 0) return YYEncodingTypeUnknown | qualifier;

switch (*type) {

case 'v': return YYEncodingTypeVoid | qualifier;

case 'B': return YYEncodingTypeBool | qualifier;

case 'c': return YYEncodingTypeInt8 | qualifier;

case 'C': return YYEncodingTypeUInt8 | qualifier;

case 's': return YYEncodingTypeInt16 | qualifier;

case 'S': return YYEncodingTypeUInt16 | qualifier;

case 'i': return YYEncodingTypeInt32 | qualifier;

case 'I': return YYEncodingTypeUInt32 | qualifier;

case 'l': return YYEncodingTypeInt32 | qualifier;

case 'L': return YYEncodingTypeUInt32 | qualifier;

case 'q': return YYEncodingTypeInt64 | qualifier;

case 'Q': return YYEncodingTypeUInt64 | qualifier;

case 'f': return YYEncodingTypeFloat | qualifier;

case 'd': return YYEncodingTypeDouble | qualifier;

case 'D': return YYEncodingTypeLongDouble | qualifier;

case '#': return YYEncodingTypeClass | qualifier;

case ':': return YYEncodingTypeSEL | qualifier;

case '*': return YYEncodingTypeCString | qualifier;

case '^': return YYEncodingTypePointer | qualifier;

case '[': return YYEncodingTypeCArray | qualifier;

case '(': return YYEncodingTypeUnion | qualifier;

case '{': return YYEncodingTypeStruct | qualifier;

case '@': {

if (len == 2 && *(type + 1) == '?')

return YYEncodingTypeBlock | qualifier;

else

return YYEncodingTypeObject | qualifier;

}

default: return YYEncodingTypeUnknown | qualifier;

}

}

1检测参数是否正确

2 判断字符串是否是YYEncodingTypeQualifierMask 。给type 赋值

3 检测字符串是否是YYEncodingTypeMask 给type赋值

这里没有对YYEncodingTypePropertyMask 区间进行检测

@property (assign) NSString * str

type = YYEncodingGetType(attrs[i].value);

这里 type 获取的是 NSString 的类型是 id

接下来，我们判断type 类型是不是id 类型的，是id 类型。用_typeEncoding 变量类型进一步校验。

@property (nonatomic ,strong) YYDelegateModel * model;

2017-12-21 17:20:31.552278+0800 YYKitDemo[53387:12086693] @"YYDelegateModel"

要是是id 类型，我们扫描从"到 “< 之间的值。这之间的值就是类值。赋值给变量_cls

剩余的部分是协议部分.每一个协议都是用<> 包含起来的。

由于协议可以多个，所以将其用数组承接。放入变量 _protocols 中

<2>name[0]=V

V 是成员变量的代表 value 的值成员变量的名字

<3> 其他的就是onlyRead ，nonatomic，Getting,Setting 等的特有的标示符号了。

这里get方法和setting 设置type 的时候同时给 _getter 和_setter 方式设置赋值了。

YYClassIvarInfo 类

这个类是成员变量

public方法只有一个- (instancetype)initWithIvar:(Ivar)ivar;

- (instancetype)initWithIvar:(Ivar)ivar {

if (!ivar) return nil;

self = [super init];

_ivar = ivar;

const char *name = ivar_getName(ivar);

if (name) {

_name = [NSString stringWithUTF8String:name];

}

_offset = ivar_getOffset(ivar);

const char *typeEncoding = ivar_getTypeEncoding(ivar);

if (typeEncoding) {

_typeEncoding = [NSString stringWithUTF8String:typeEncoding];

_type = YYEncodingGetType(typeEncoding);

}

return self;

}

1 变量_ivar 保存参数ivar

2 变量_name 保存 ivar的name

3 变量 _offset 保存 ivar 的偏移量

4 获取typeEncoding，将其保存到变量 _typeEncoding 中

5.将_typeEncoding 转换成 YYEncoding 保存到变量_type 中。

总结下YYClassMethodInfo，YYClassPropertyInfo，YYClassIvarInfo这三个类。

YYClassMethodInfo 代表该类的所有method

YYClassPropertyInfo 代表该类的所有属性

YYClassIvarInfo 代表该类的所有成员变量

YYClassInfo 包含了自己和superClass 的所有method 属性和成员变量

这里将YYClassInfo 分析结束了。

那么我们返回<6> 出看看这个地方具体干啥了

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;

_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;

}

这里是个递归。依次调用super类，直到superClass是nil为止结束。在每次递归的过程中，对每个类的属性都进行包装成_YYModelPropertyMeta ，最后封装在allPropertyMetas 字典中，key值是 _YYModelPropertyMeta 中的name

这里关键是生成了一个类_YYModelPropertyMeta

我们看看这个类的实现

_YYModelPropertyMeta

成员变量如下

NSString *_name; ///< property's name

YYEncodingType _type; ///< property's type

YYEncodingNSType _nsType; ///< property's Foundation type

BOOL _isCNumber; ///< is c number type

Class _cls; ///< property's class, or nil

Class _genericCls; ///< container's generic class, or nil if threr's no generic class

SEL _getter; ///< getter, or nil if the instances cannot respond

SEL _setter; ///< setter, or nil if the instances cannot respond

BOOL _isKVCCompatible; ///< YES if it can access with key-value coding

BOOL _isStructAvailableForKeyedArchiver; ///< YES if the struct can encoded with keyed archiver/unarchiver

BOOL _hasCustomClassFromDictionary; ///< class/generic class implements +modelCustomClassForDictionary:

/*

property->key: _mappedToKey:key _mappedToKeyPath:nil _mappedToKeyArray:nil

property->keyPath: _mappedToKey:keyPath _mappedToKeyPath:keyPath(array) _mappedToKeyArray:nil

property->keys: _mappedToKey:keys[0] _mappedToKeyPath:nil/keyPath _mappedToKeyArray:keys(array)

*/

NSString *_mappedToKey; ///< the key mapped to

NSArray *_mappedToKeyPath; ///< the key path mapped to (nil if the name is not key path)

NSArray *_mappedToKeyArray; ///< the key(NSString) or keyPath(NSArray) array (nil if not mapped to multiple keys)

YYClassPropertyInfo *_info; ///< property's info

_YYModelPropertyMeta *_next; ///< next meta if there are multiple properties mapped to the same key.

这个类就一个方法实现

+ (instancetype)metaWithClassInfo:(YYClassInfo *)classInfo propertyInfo:(YYClassPropertyInfo *)propertyInfo generic:(Class)generic {

// support pseudo generic class with protocol name

if (!generic && propertyInfo.protocols) {

for (NSString *protocol in propertyInfo.protocols) {

Class cls = objc_getClass(protocol.UTF8String);

if (cls) {

generic = cls;

break;

}

}

}

_YYModelPropertyMeta *meta = [self new];

meta->_name = propertyInfo.name;

meta->_type = propertyInfo.type;

meta->_info = propertyInfo;

meta->_genericCls = generic;

if ((meta->_type & YYEncodingTypeMask) == YYEncodingTypeObject) {

meta->_nsType = YYClassGetNSType(propertyInfo.cls);

} else {

meta->_isCNumber = YYEncodingTypeIsCNumber(meta->_type);

}

if ((meta->_type & YYEncodingTypeMask) == YYEncodingTypeStruct) {

/*

It seems that NSKeyedUnarchiver cannot decode NSValue except these structs:

*/

static NSSet *types = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

NSMutableSet *set = [NSMutableSet new];

// 32 bit

[set addObject:@"{CGSize=ff}"];

[set addObject:@"{CGPoint=ff}"];

[set addObject:@"{CGRect={CGPoint=ff}{CGSize=ff}}"];

[set addObject:@"{CGAffineTransform=ffffff}"];

[set addObject:@"{UIEdgeInsets=ffff}"];

[set addObject:@"{UIOffset=ff}"];

// 64 bit

[set addObject:@"{CGSize=dd}"];

[set addObject:@"{CGPoint=dd}"];

[set addObject:@"{CGRect={CGPoint=dd}{CGSize=dd}}"];

[set addObject:@"{CGAffineTransform=dddddd}"];

[set addObject:@"{UIEdgeInsets=dddd}"];

[set addObject:@"{UIOffset=dd}"];

types = set;

});

if ([types containsObject:propertyInfo.typeEncoding]) {

meta->_isStructAvailableForKeyedArchiver = YES;

}

}

meta->_cls = propertyInfo.cls;

if (generic) {

meta->_hasCustomClassFromDictionary = [generic respondsToSelector:@selector(modelCustomClassForDictionary:)];

} else if (meta->_cls && meta->_nsType == YYEncodingTypeNSUnknown) {

meta->_hasCustomClassFromDictionary = [meta->_cls respondsToSelector:@selector(modelCustomClassForDictionary:)];

}

if (propertyInfo.getter) {

if ([classInfo.cls instancesRespondToSelector:propertyInfo.getter]) {

meta->_getter = propertyInfo.getter;

}

}

if (propertyInfo.setter) {

if ([classInfo.cls instancesRespondToSelector:propertyInfo.setter]) {

meta->_setter = propertyInfo.setter;

}

}

if (meta->_getter && meta->_setter) {

/*

KVC invalid type:

long double

pointer (such as SEL/CoreFoundation object)

*/

switch (meta->_type & YYEncodingTypeMask) {

case YYEncodingTypeBool:

case YYEncodingTypeInt8:

case YYEncodingTypeUInt8:

case YYEncodingTypeInt16:

case YYEncodingTypeUInt16:

case YYEncodingTypeInt32:

case YYEncodingTypeUInt32:

case YYEncodingTypeInt64:

case YYEncodingTypeUInt64:

case YYEncodingTypeFloat:

case YYEncodingTypeDouble:

case YYEncodingTypeObject:

case YYEncodingTypeClass:

case YYEncodingTypeBlock:

case YYEncodingTypeStruct:

case YYEncodingTypeUnion: {

meta->_isKVCCompatible = YES;

} break;

default: break;

}

}

return meta;

}

传入的参数有 YYClassInfo， YYClassPropertyInfo， Class 类型的三个参数

YYClassInfo 当前类

YYClassPropertyInfo 类的属性

Class 暂时不详

1 . 判断 class 和 YYClassPropertyInfo是否有协议。对class 进行相关赋值。

2.生成meta对象，保存，property的name ，type ，和自身，_genericCls 保存class

3.判断属性的修饰是不是id 类型的。是的话，通过函数YYClassGetNSType 给_nsType 赋值。这个函数的返回值是枚举YYEncodingNSType 类型的。看看这个枚举值

typedef NS_ENUM (NSUInteger, YYEncodingNSType) {

YYEncodingTypeNSUnknown = 0,

YYEncodingTypeNSString,

YYEncodingTypeNSMutableString,

YYEncodingTypeNSValue,

YYEncodingTypeNSNumber,

YYEncodingTypeNSDecimalNumber,

YYEncodingTypeNSData,

YYEncodingTypeNSMutableData,

YYEncodingTypeNSDate,

YYEncodingTypeNSURL,

YYEncodingTypeNSArray,

YYEncodingTypeNSMutableArray,

YYEncodingTypeNSDictionary,

YYEncodingTypeNSMutableDictionary,

YYEncodingTypeNSSet,

YYEncodingTypeNSMutableSet,

};

这些是foundation class 类型，包含nsstring ， NSMutableString, NSValue,NSNumber,NSDecimalNumber,NSData,NSMutableData,NSDate,NSURL,NSArray,NSMutableArray,NSDictionary,NSMutableDictionary,NSSet,NSMutableSet

看下面函数怎么转换成特定类型的

/// Get the Foundation class type from property info.

static force_inline YYEncodingNSType YYClassGetNSType(Class cls) {

if (!cls) return YYEncodingTypeNSUnknown;

if ([cls isSubclassOfClass:[NSMutableString class]]) return YYEncodingTypeNSMutableString;

if ([cls isSubclassOfClass:[NSString class]]) return YYEncodingTypeNSString;

if ([cls isSubclassOfClass:[NSDecimalNumber class]]) return YYEncodingTypeNSDecimalNumber;

if ([cls isSubclassOfClass:[NSNumber class]]) return YYEncodingTypeNSNumber;

if ([cls isSubclassOfClass:[NSValue class]]) return YYEncodingTypeNSValue;

if ([cls isSubclassOfClass:[NSMutableData class]]) return YYEncodingTypeNSMutableData;

if ([cls isSubclassOfClass:[NSData class]]) return YYEncodingTypeNSData;

if ([cls isSubclassOfClass:[NSDate class]]) return YYEncodingTypeNSDate;

if ([cls isSubclassOfClass:[NSURL class]]) return YYEncodingTypeNSURL;

if ([cls isSubclassOfClass:[NSMutableArray class]]) return YYEncodingTypeNSMutableArray;

if ([cls isSubclassOfClass:[NSArray class]]) return YYEncodingTypeNSArray;

if ([cls isSubclassOfClass:[NSMutableDictionary class]]) return YYEncodingTypeNSMutableDictionary;

if ([cls isSubclassOfClass:[NSDictionary class]]) return YYEncodingTypeNSDictionary;

if ([cls isSubclassOfClass:[NSMutableSet class]]) return YYEncodingTypeNSMutableSet;

if ([cls isSubclassOfClass:[NSSet class]]) return YYEncodingTypeNSSet;

return YYEncodingTypeNSUnknown;

}

纸老虎，很简单，不做介绍。一一匹配就行。

4 要是不是id 类型的就认为是数字。给_isCNumber 变量赋值。是数字类型就YES, 反之NO

/// Whether the type is c number.

static force_inline BOOL YYEncodingTypeIsCNumber(YYEncodingType type) {

switch (type & YYEncodingTypeMask) {

case YYEncodingTypeBool:

case YYEncodingTypeInt8:

case YYEncodingTypeUInt8:

case YYEncodingTypeInt16:

case YYEncodingTypeUInt16:

case YYEncodingTypeInt32:

case YYEncodingTypeUInt32:

case YYEncodingTypeInt64:

case YYEncodingTypeUInt64:

case YYEncodingTypeFloat:

case YYEncodingTypeDouble:

case YYEncodingTypeLongDouble: return YES;

default: return NO;

}

}

5.检查类型修饰是不是结构体类型YYEncodingTypeStruct

这里有个单例，

static NSSet *types = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

NSMutableSet *set = [NSMutableSet new];

// 32 bit

[set addObject:@"{CGSize=ff}"];

[set addObject:@"{CGPoint=ff}"];

[set addObject:@"{CGRect={CGPoint=ff}{CGSize=ff}}"];

[set addObject:@"{CGAffineTransform=ffffff}"];

[set addObject:@"{UIEdgeInsets=ffff}"];

[set addObject:@"{UIOffset=ff}"];

// 64 bit

[set addObject:@"{CGSize=dd}"];

[set addObject:@"{CGPoint=dd}"];

[set addObject:@"{CGRect={CGPoint=dd}{CGSize=dd}}"];

[set addObject:@"{CGAffineTransform=dddddd}"];

[set addObject:@"{UIEdgeInsets=dddd}"];

[set addObject:@"{UIOffset=dd}"];

types = set;

});

枚举了foundation 中，结构体的type类型具体描述

要是在这个单例数组中包含了，type 类型，就将变量_isStructAvailableForKeyedArchiver 设置为YES

6 meta 的_cls 设置为propertyInfo 的cls（这个cls 其实就是属性前面的修饰eg:NSString）

7.要是有generic 检查modelCustomClassForDictionary 方法是否含有

8.没有检测是否_nsType 为YYEncodingTypeNSUnknown 检测方法modelCustomClassForDictionary 方法是否含有

7 和8 两步暂时不知道干啥用的。不影响主要流程不计较

9.要是class.cls 响应getter方法，给_getter 变量赋值

10.同理给_setting 变量赋值

11 要是meta 的getter 和setting 变量赋值了。那么检测类型，标记为_isKVCCompatible 为yes

12 返回self

所以_YYModelPropertyMeta 代表了property 。

而该类对属性数据进行了一些处理，例如getting 或者setting 方法。

接下来我们看<7>的地方

这里有个枚举customMapper 字典。看看每次枚举都干啥事情了

1.检查allPropertyMetas 字典中是否含有属性名字，没有就结束

2.要是有的话就从allPropertyMetas移除该键值对

3 枚举的键值对value的类型

4 要是字符串的话，propertyMeta 的_mappedToKey 保存该value。对mappedToKey 进行分割，分割出的propertyMeta 大于1 ，给_mappedToKeyPath 赋值keyPath 。keyPathPropertyMetas 加入propertyMeta。检查mapper 中是否含有mappedToKey，给_next 赋值。mapper[mappedToKey] 保存propertyMeta

5 要是数组的话，对数组中的每个元素进行上述4步骤

仔细看这里

if (allPropertyMetas.count) _allPropertyMetas = allPropertyMetas.allValues.copy;

[allPropertyMetas removeObjectForKey:propertyName];

[allPropertyMetas enumerateKeysAndObjectsUsingBlock:^(NSString *name, _YYModelPropertyMeta *propertyMeta, BOOL *stop) {

propertyMeta->_mappedToKey = name;

propertyMeta->_next = mapper[name] ?: nil;

mapper[name] = propertyMeta;

}];

这三个地方操作allPropertyMetas ，其实我们操作的是allPropertyMetas 里面的对象，修改了allPropertyMetas里面的对象，成员变量_allPropertyMetas 的里面的对象也就发生改变了。

我们还是做个_YYModelMeta 指针分布图更好看些

接下来我们看<5>,暂时略过<4>

- (BOOL)modelSetWithDictionary:(NSDictionary *)dic { if (!dic || dic == (id)kCFNull) return NO; if (![dic isKindOfClass:[NSDictionary class]]) return NO; _YYModelMeta *modelMeta = [_YYModelMeta metaWithClass:object_getClass(self)]; if (modelMeta->_keyMappedCount == 0) return NO; if (modelMeta->_hasCustomWillTransformFromDictionary) { dic = [((id)self) modelCustomWillTransformFromDictionary:dic]; if (![dic isKindOfClass:[NSDictionary class]]) return NO; } ModelSetContext context = {0}; context.modelMeta = (__bridge void *)(modelMeta); context.model = (__bridge void *)(self); context.dictionary = (__bridge void *)(dic); if (modelMeta->_keyMappedCount >= CFDictionaryGetCount((CFDictionaryRef)dic)) { CFDictionaryApplyFunction((CFDictionaryRef)dic, ModelSetWithDictionaryFunction, &context); if (modelMeta->_keyPathPropertyMetas) { CFArrayApplyFunction((CFArrayRef)modelMeta->_keyPathPropertyMetas, CFRangeMake(0, CFArrayGetCount((CFArrayRef)modelMeta->_keyPathPropertyMetas)), ModelSetWithPropertyMetaArrayFunction, &context); } if (modelMeta->_multiKeysPropertyMetas) { CFArrayApplyFunction((CFArrayRef)modelMeta->_multiKeysPropertyMetas, CFRangeMake(0, CFArrayGetCount((CFArrayRef)modelMeta->_multiKeysPropertyMetas)), ModelSetWithPropertyMetaArrayFunction, &context); } } else { CFArrayApplyFunction((CFArrayRef)modelMeta->_allPropertyMetas, CFRangeMake(0, modelMeta->_keyMappedCount), ModelSetWithPropertyMetaArrayFunction, &context); } if (modelMeta->_hasCustomTransformFromDictionary) { return [((id)self) modelCustomTransformFromDictionary:dic];

}

return YES;

}

这里有个object_getClass(self) 我们看看object_getClass(self) 和 [self class] 区别

这里有篇文章介绍

直接获取结论

1.obj为Object实例对象

结论：当obj为实例变量时，object_getClass(obj)与[obj class]输出结果一直，均获得isa指针，即指向类对象的指针。

2.obj为Class类对象

结论：当obj为类对象时，object_getClass(obj)返回类对象中的isa指针，即指向元类对象的指针；[obj class]返回的则是其本身。

3.obj为Metaclass类对象

结论：当obj为Metaclass（元类）对象时，object_getClass(obj)返回元类对象中的isa指针，因为元类对象的isa指针指向根类，所有返回的是根类对象的地址指针；[obj class]返回的则是其本身。

4.obj为Rootclass类对象

结论：当obj为Rootclass（元类）对象时，object_getClass(obj)返回根类对象中的isa指针，因为跟类对象的isa指针指向Rootclass‘s metaclass(根元类)，即返回的是根元类的地址指针；[obj class]返回的则是其本身。

因为根类的isa指针其实是指向本身的，所有根元类其实就是根类，所有输出的结果是一样的。

总结：经上面初步的探索得知，object_getClass(obj)返回的是obj中的isa指针；而[obj class]则分两种情况：一是当obj为实例对象时，[obj class]中class是实例方法：- (Class)class，返回的obj对象中的isa指针；二是当obj为类对象（包括元类和根类以及根元类）时，调用的是类方法：+ (Class)class，返回的结果为其本身。

所以这里的self 是实例本身，

这个函数介绍

1.检查参数

2.获取self 对应的_YYModelMeta 对象

3.检查_keyMappedCount是否为0

4.是否需要转换数据dic

5ModelSetContext 结构体声明，保存，_YYModelMeta self 还有json 字典

6 判断_keyMappedCount 是否比dic 的键值对多

7，要是_keyMappedCount 不小于dic的键值对，进行

CFDictionaryApplyFunction((CFDictionaryRef)dic, ModelSetWithDictionaryFunction, &context);

这里有个函数指针ModelSetWithDictionaryFunction

看看实现

static void ModelSetWithDictionaryFunction(const void *_key, const void *_value, void *_context) {

ModelSetContext *context = _context;

__unsafe_unretained _YYModelMeta *meta = (__bridge _YYModelMeta *)(context->modelMeta);

__unsafe_unretained _YYModelPropertyMeta *propertyMeta = [meta->_mapper objectForKey:(__bridge id)(_key)];

__unsafe_unretained id model = (__bridge id)(context->model);

while (propertyMeta) {

if (propertyMeta->_setter) {

ModelSetValueForProperty(model, (__bridge __unsafe_unretained id)_value, propertyMeta);

}

propertyMeta = propertyMeta->_next;

};

}

这个函数比较简单

1 获取_YYModelMeta

2 根据key获取 _YYModelPropertyMeta

3 进行遍历_YYModelPropertyMeta ，调用ModelSetValueForProperty，将propertyMeta 的next指针指向自己。

这里有个_mapper 还有个_next ，是时候完全弄懂这些变量的具体含义的时候了

回到函数- (instancetype)initWithClass:(Class)cls 中

先看看allPropertyMetas 字典盛放的数据都是啥

allPropertyMetas 存放的是类以及父类的所有的属性，与属性的名字一一对应。

接下来看看mapper 先看下面这段

[allPropertyMetas enumerateKeysAndObjectsUsingBlock:^(NSString *name, _YYModelPropertyMeta *propertyMeta, BOOL *stop) {

propertyMeta->_mappedToKey = name;

propertyMeta->_next = mapper[name] ?: nil;

mapper[name] = propertyMeta;

}];

name 是 key value 是_YYModelPropertyMeta

我们给propertyMeta 的_mappedToKey 变量赋值为name ，

propertyMeta的_next 指向是 mapper[name]

最后mapper[name] 指向propertyMeta

这里到底是什么意思呢？

假设cls 没有实现modelCustomPropertyMapper 方法

那么这里就可以这样认为，

我们遍历allPropertyMetas中的每一个元素，将每一个propertyMeta 的_mappedToKey 赋值为name

因为这时候mapper什么元素也没有，即使有，也没有包含name 的键值对。那么。

propertyMeta->_next = mapper[name] ?: nil;相当于propertyMeta->_next = nil

最后，我们mapper[name] = propertyMeta;

见下面

propertyMeta->_mappedToKey = name;

propertyMeta->_next =nil;

mapper[name] = propertyMeta;

根据这里看，我们知道了，mapper 和allPropertyMetas 差不多，都是存了所有属性的键值对。

那为什么会有propertyMeta->_next = mapper[name] ?: nil; 呢

就要看modelCustomPropertyMapper 这里面的实现了

我们知道modelCustomPropertyMapper 返回的是一个Dic

分步看这块代码

1.首先从allPropertyMetas 数组找key对应的_YYModelPropertyMeta ，没有就返回了。不用解释。

2.要是有的话，就从allPropertyMetas 中移除该数组。那么在上面枚举allPropertyMetas 该类的时候就不包含该key 了。那么从数组移除的这个键值对要做啥处理呢。

3.这里先处理value。检测value 字符串还是数组

4.value是字符串，我们把_YYModelPropertyMeta 的_mappedToKey 设置为value，而在allPropertyMetas 设置的是key。看到这里大概明白了，key值替换。

5. 这里对value 进行点分割。其实就是判断是否需要KVC，要是有.的话，那么我们就用

_mappedToKeyPath 保存住分割后的数组。这里有propertyMeta->_next = mapper[mappedToKey] ?: nil; 什么时候出现mapper[mappedToKey] 不是nil的情况呢?

我们看mappedToKey 是代表的value 。我们知道在一个字典里面，key 一定是唯一的，不可能出现重复的，而value 可以出现重复的。

假设这里modelCustomPropertyMapper 函数返回的字典是@{"userid":"name","id":"name"} 那么在遍历customMapper 第二次的时候就会出现mapper[mappedToKey] 不是nil的情况，她保存的是上一次 userid 对应的_YYModelPropertyMeta，因为我们将第二次的_YYModelPropertyMeta 的_next 保存userid 对应的 _YYModelPropertyMeta

见图

6.value 是数组，方式很相同，不做解释

allPropertyMetas 枚举的时候有这么一段，propertyMeta->_next = mapper[name] ?: nil;

类似链表的操作。因为name 可能和modelCustomPropertyMapper 方法中保存的key 值有重复。

我们返回ModelSetWithDictionaryFunction 函数中

这里的mapper 盛放的是每个属性name 对应的自己的_YYModelPropertyMeta键值对

篇幅所限，我们在下面的章节中分析ModelSetValueForProperty 函数

YYKit 源码解析（5）-YYModel

NSObject+YYModel

YYClassInfo

你可能感兴趣的:(YYKit 源码解析（5）-YYModel)