【iOS】JSONModel源码阅读笔记

---

媒介

JSONModel是一个很经典的源码库，先前基本把iOS的底层看的差不多了，暑假之前都会举行源码与算法学习
一、JSONModel使用

之前已经详细写过使用，有一些没写到的使用会在后面增补
【iOS】JSONModel的基本使用
二、JSONModel其他方法

转换属性名称

有时候我们的JSONModel的属性名称与传入的字典的键值不对应，我们就必要使用keyMapper来转换JSON键，将模型中的属性转换为KeyMapper中对应的键名，dictionary中的key值为属性名，value为json键名

1. #import <JSONModel/JSONModel.h>
3. @interface UserProfile : JSONModel
5. @property (strong, nonatomic) NSString* userId;
6. @property (strong, nonatomic) NSString* emailAddress;
7. @property (strong, nonatomic) NSString* firstName;
8. @property (strong, nonatomic) NSString* lastName;
10. @end

复制代码

设置键映射
为了将JSON键映射到正确的模型属性，你必要在模型类中重写+ (JSONKeyMapper *)keyMapper方法，指定怎样将模型中的属性转换为JSON中的键名

1. @implementation UserProfile
3. // 使用 JSONKeyMapper 来定义 JSON 字段与模型属性之间的映射关系
4. + (JSONKeyMapper *)keyMapper {
5.     return [[JSONKeyMapper alloc] initWithModelToJSONDictionary:@{
6.         @"userId": @"user_id",
7.         @"emailAddress": @"email_address",
8.         @"firstName": @"profile_info.first_name",
9.         @"lastName": @"profile_info.last_name"
10.     }];
11. }
12. @end

复制代码

三、源码分析

先看流程图

看一下源代码的目录，可以看到以下内容

在JSONModel中提供了四种初始化方法

1. -(instancetype)initWithString:(NSString*)string error:(JSONModelError**)err;
2. -(instancetype)initWithString:(NSString *)string usingEncoding:(NSStringEncoding)encoding error:(JSONModelError**)err;
3. -(instancetype)initWithDictionary:(NSDictionary*)dict error:(NSError **)err;
4. -(instancetype)initWithData:(NSData *)data error:(NSError **)error;

复制代码

四种方法大同小异，我们从最经典的-(instancetype)initWithDictionaryNSDictionary*)dict errorNSError **)err;讲起
- (instancetype)initWithDictionaryNSDictionary*)dict errorNSError **)err

照旧先查看源代码

1. -(id)initWithDictionary:(NSDictionary*)dict error:(NSError**)err
2. {
3.     //方法1. 参数为nil
4.     if (!dict) {
5.         if (err) *err = [JSONModelError errorInputIsNil];
6.         return nil;
7.     }
8.     //方法2. 参数不是nil，但也不是字典
9.     if (![dict isKindOfClass:[NSDictionary class]]) {
10.         if (err) *err = [JSONModelError errorInvalidDataWithMessage:@"Attempt to initialize JSONModel object using initWithDictionary:error: but the dictionary parameter was not an 'NSDictionary'."];
11.         return nil;
12.     }
13.     //方法3. 初始化
14.     self = [self init];
15.     if (!self) {
16.         //初始化失败
17.         if (err) *err = [JSONModelError errorModelIsInvalid];
18.         return nil;
19.     }
20.     //方法4. 检查用户定义的模型里的属性集合是否大于传入的字典里的key集合（如果大于，则返回NO）
21.     if (![self __doesDictionary:dict matchModelWithKeyMapper:self.__keyMapper error:err]) {
22.         return nil;
23.     }
24.     //方法5. 核心方法：字典的key与模型的属性的映射
25.     if (![self __importDictionary:dict withKeyMapper:self.__keyMapper validation:YES error:err]) {
26.         return nil;
27.     }
28.     //方法6. 可以重写[self validate:err]方法并返回NO，让用户自定义错误并阻拦model的返回
29.     if (![self validate:err]) {
30.         return nil;
31.     }
32.     //方法7. 终于通过了！成功返回model
33.     return self;
34. }

复制代码

可以看到源代码分为了七步，我们来渐渐解说

• 第一步：首先举行判错操纵，查询参数是否为空，如果为空则直接返回nil
  
• 第二步：查看参数dict是否为字范例例，如果不是则也返回nil
  
• 第三步：初始化JSONModel模型，设置Model的属性集合
  
• 第四步：查询是否存在KeyMapper，如果有则举行底层dict键名的变换，然后验证Model中的属性是否都在dict的键名匹配，如果有没有被匹配的则会报错
  
• 第五步：焦点方法，终于到了dict的键值与模型的Model的相互映射
  
• 第六步：可以重写[self validate:err]方法并返回NO，让用户自界说错误并阻拦model的返回
  
• 第七步：返回JSONModel
  

整个过程看起来并不难，但是涉及到的底层知识点比较多
重点主要在第三步第四步第五步，我们来看一下
但是在解说之前，我们必须讲一下JSONModel中持有的一些关联对象的数据

• 关联对象kClassPropertiesKey用来保存全部属性信息的NSDictionary)
  
• 关联对象kClassRequiredPropertyNamesKey：(用来保存全部属性的名称NSSet)
  
• 关联对象kMapperObjectKey：(用来保存JSONKeyMapper)：自界说的mapper，具体的使用方法在上面的例子中可以看到。
  

[self init]

先来看一下第三步的源代码

1. self = [self init];
2.     if (!self) {
3.         //super init didn't succeed
4.         if (err) *err = [JSONModelError errorModelIsInvalid];
5.         return nil;
6.     }

复制代码

[self init]的代码调用了init初始化函数，实现如下，我们主要关注的是其中[self setup]

1. - (id)init
2. {
3.     self = [super init];
4.     if (self) {
5.         //do initial class setup
6.         [self __setup__];
7.     }
8.     return self;
9. }

复制代码

setup

来看一下setup的实现

1. - (void)__setup__
2. {
3.     //if first instance of this model, generate the property list
4.     // 如果是该模型的第一个实例，则生成属性列表
5.     if (!objc_getAssociatedObject(self.class, &kClassPropertiesKey)) {
6.         [self __inspectProperties];
7.     }
9.     //if there's a custom key mapper, store it in the associated object
10.     id mapper = [[self class] keyMapper];
11.     if ( mapper && !objc_getAssociatedObject(self.class, &kMapperObjectKey) ) {
12.         objc_setAssociatedObject(
13.                                  self.class,
14.                                  &kMapperObjectKey,
15.                                  mapper,
16.                                  OBJC_ASSOCIATION_RETAIN // This is atomic
17.                                  );
18.     }
19. }

复制代码

我们来渐渐分析
第一句代码（!objc_getAssociatedObject(self.class, &kClassPropertiesKey)）查看当前类是否存在关联对象，如果是该模型的第一个实例，则生成属性列表，也就是调用[self __inspectProperties];检索属性
检索完之后如果存在keyMapper将keyMapper也与模型类举行关联

1. if ( mapper && !objc_getAssociatedObject(self.class, &kMapperObjectKey) ) {
2.         objc_setAssociatedObject(
3.                                  self.class,
4.                                  &kMapperObjectKey,
5.                                  mapper,
6.                                  OBJC_ASSOCIATION_RETAIN // This is atomic
7.                                  );
8.     }

复制代码

__inspectProperties

1. -(void)__inspectProperties
2. {
3. //    最终保存所有属性的字典，形式为：
4. //    {
5. //        age = "@property primitive age (Setters = [])";
6. //        friends = "@property NSArray* friends (Standard JSON type, Setters = [])";
7. //        gender = "@property NSString* gender (Standard JSON type, Setters = [])";
8. //        name = "@property NSString* name (Standard JSON type, Setters = [])";
9. //    }
10.     NSMutableDictionary* propertyIndex = [NSMutableDictionary dictionary];
11.     //获取当前的类名
12.     Class class = [self class];   
13.     NSScanner* scanner = nil;
14.     NSString* propertyType = nil;
15.     // 循环条件：当class 是 JSONModel自己的时候终止
16.     while (class != [JSONModel class]) {        
17.         //属性的个数
18.         unsigned int propertyCount;
19.         //获得属性列表（所有@property声明的属性）
20.         objc_property_t *properties = class_copyPropertyList(class, &propertyCount);
21.         //遍历所有的属性
22.         for (unsigned int i = 0; i < propertyCount; i++) {
23.             //获得属性名称
24.             objc_property_t property = properties[i];//获得当前的属性
25.             const char *propertyName = property_getName(property);//name（C字符串）            
26.             //JSONModel里的每一个属性，都被封装成一个JSONModelClassProperty对象
27.             JSONModelClassProperty* p = [[JSONModelClassProperty alloc] init];
29.             p.name = @(propertyName);//propertyName:属性名称，例如：name，age，gender
30.             //获得属性类型
31.             const char *attrs = property_getAttributes(property);
32.             NSString* propertyAttributes = @(attrs);
33.             // T@"NSString",C,N,V_name
34.             // Tq,N,V_age
35.             // T@"NSString",C,N,V_gender
36.             // T@"NSArray",&,N,V_friends            
37.             NSArray* attributeItems = [propertyAttributes componentsSeparatedByString:@","];
38.             //说明是只读属性，不做任何操作
39.             if ([attributeItems containsObject:@"R"]) {
40.                 continue; //to next property
41.             }
42.             //检查出是布尔值
43.             if ([propertyAttributes hasPrefix:@"Tc,"]) {
44.                 p.structName = @"BOOL";//使其变为结构体
45.             }            
46.             //实例化一个scanner
47.             scanner = [NSScanner scannerWithString: propertyAttributes];
48.             [scanner scanUpToString:@"T" intoString: nil];
49.             [scanner scanString:@"T" intoString:nil];
50.             //http://blog.csdn.net/kmyhy/article/details/8258858           
51.             if ([scanner scanString:@"@"" intoString: &propertyType]) {               
52.                  //属性是一个对象
53.                 [scanner scanUpToCharactersFromSet:[NSCharacterSet characterSetWithCharactersInString:@""<"]
54.                                         intoString:&propertyType];//propertyType -> NSString               
55.                 p.type = NSClassFromString(propertyType);// p.type = @"NSString"
56.                 p.isMutable = ([propertyType rangeOfString:@"Mutable"].location != NSNotFound); //判断是否是可变的对象
57.                 p.isStandardJSONType = [allowedJSONTypes containsObject:p.type];//是否是该框架兼容的类型
58.                 //存在协议(数组，也就是嵌套模型)
59.                 while ([scanner scanString:@"<" intoString:NULL]) {
60.                     NSString* protocolName = nil;
61.                     [scanner scanUpToString:@">" intoString: &protocolName];
62.                     if ([protocolName isEqualToString:@"Optional"]) {
63.                         p.isOptional = YES;
64.                     } else if([protocolName isEqualToString:@"Index"]) {
65. #pragma GCC diagnostic push
66. #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
67.                         p.isIndex = YES;
68. #pragma GCC diagnostic pop
69.                         objc_setAssociatedObject(
70.                                                  self.class,
71.                                                  &kIndexPropertyNameKey,
72.                                                  p.name,
73.                                                  OBJC_ASSOCIATION_RETAIN // This is atomic
74.                                                  );
75.                     } else if([protocolName isEqualToString:@"Ignore"]) {
76.                         p = nil;
77.                     } else {
78.                         p.protocol = protocolName;
79.                     }
80.                     //到最接近的>为止
81.                     [scanner scanString:@">" intoString:NULL];
82.                 }
83.             }            
84.             else if ([scanner scanString:@"{" intoString: &propertyType])               
85.                 //属性是结构体
86.                 [scanner scanCharactersFromSet:[NSCharacterSet alphanumericCharacterSet]
87.                                     intoString:&propertyType];
88.                 p.isStandardJSONType = NO;
89.                 p.structName = propertyType;
90.             }
91.             else {
92.                 //属性是基本类型：Tq,N,V_age
93.                 [scanner scanUpToCharactersFromSet:[NSCharacterSet characterSetWithCharactersInString:@","]
94.                                         intoString:&propertyType];
95.                 //propertyType:q
96.                 propertyType = valueTransformer.primitivesNames[propertyType];              
97.                 //propertyType:long
98.                 //基本类型数组
99.                 if (![allowedPrimitiveTypes containsObject:propertyType]) {
100.                     //类型不支持
101.                     @throw [NSException exceptionWithName:@"JSONModelProperty type not allowed"
102.                                                    reason:[NSString stringWithFormat:@"Property type of %@.%@ is not supported by JSONModel.", self.class, p.name]
103.                                                  userInfo:nil];
104.                 }
105.             }
106.             NSString *nsPropertyName = @(propertyName);            
107.             //可选的
108.             if([[self class] propertyIsOptional:nsPropertyName]){
109.                 p.isOptional = YES;
110.             }
111.             //可忽略的
112.             if([[self class] propertyIsIgnored:nsPropertyName]){
113.                 p = nil;
114.             }
115.             //集合类
116.             Class customClass = [[self class] classForCollectionProperty:nsPropertyName];            
117.             if (customClass) {
118.                 p.protocol = NSStringFromClass(customClass);
119.             }
120.             //忽略block
121.             if ([propertyType isEqualToString:@"Block"]) {
122.                 p = nil;
123.             }
124.             //如果字典里不存在，则添加到属性字典里（终于添加上去了。。。）
125.             if (p && ![propertyIndex objectForKey:p.name]) {
126.                 [propertyIndex setValue:p forKey:p.name];
127.             }
128.             //setter 和 getter
129.             if (p)
130.             {   //name ->Name
131.                 NSString *name = [p.name stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:[p.name substringToIndex:1].uppercaseString];
132.                 // getter
133.                 SEL getter = NSSelectorFromString([NSString stringWithFormat:@"JSONObjectFor%@", name]);
134.                 if ([self respondsToSelector:getter])
135.                     p.customGetter = getter;
136.                 // setters
137.                 p.customSetters = [NSMutableDictionary new];
138.                 SEL genericSetter = NSSelectorFromString([NSString stringWithFormat:@"set%@WithJSONObject:", name]);
139.                 if ([self respondsToSelector:genericSetter])
140.                     p.customSetters[@"generic"] = [NSValue valueWithBytes:&genericSetter objCType:@encode(SEL)];
141.                 for (Class type in allowedJSONTypes)
142.                 {
143.                     NSString *class = NSStringFromClass([JSONValueTransformer classByResolvingClusterClasses:type]);
144.                     if (p.customSetters[class])
145.                         continue;
146.                     SEL setter = NSSelectorFromString([NSString stringWithFormat:@"set%@With%@:", name, class]);
147.                     if ([self respondsToSelector:setter])
148.                         p.customSetters[class] = [NSValue valueWithBytes:&setter objCType:@encode(SEL)];
149.                 }
150.             }
151.         }
152.         free(properties);
153.         //再指向自己的父类，知道等于JSONModel才停止
154.         class = [class superclass];
155.     }
156.     //最后保存所有当前类，JSONModel的所有的父类的属性
157.     objc_setAssociatedObject(
158.                              self.class,
159.                              &kClassPropertiesKey,
160.                              [propertyIndex copy],
161.                              OBJC_ASSOCIATION_RETAIN
162.                              );
163. }

复制代码

这是一串非常长的代码，先来大概解说一下这个方法：
这个方法用于检索JSONModel类中的属性，并将其转化为一个可用的 NSDictionary 对象。该方法会遍历模型类的属性，然后剖析每个属性的相关信息（如属性名、数据范例、对应的 JSON 字段名等），并将其存储在 NSDictionary 对象中，也就是上文的propertyIndex
如果我们具体分析代码流程，就会发现：

• 该方法会先使用运行时函数获取JSONModel的属性列表
  

1. objc_property_t *properties = class_copyPropertyList(class, &propertyCount);

复制代码

• 然后为每个属性创建一个JSONModelProperty 对象，也就是下文的p实例
  

1. JSONModelClassProperty* p = [[JSONModelClassProperty alloc] init];

复制代码

• p实例也是我们创建的dictionary的value值
  

1. if (p && ![propertyIndex objectForKey:p.name]) {
2.         [propertyIndex setValue:p forKey:p.name];
3. }

复制代码

• JSONModelProperty 对象中包含了属性名、数据范例、对应的 JSON 字段名等信息，以下代码可见一斑
  

1. p.type = NSClassFromString(propertyType);
2. p.isMutable = ([propertyType rangeOfString:@"Mutable"].location != NSNotFound);
3. p.isStandardJSONType = [allowedJSONTypes containsObject:p.type];

复制代码

• 最后全部的这些 JSONModelProperty 对象都会存储在一个NSMutableDictionary 对象——propertyIndex中，然后通过objc_setAssociatedObject与模型举行关联，这一步是由于先前没有设置关联，如果不是第一次实例化这个类就不会调用__inspectProperties方法
  

1. //最后保存所有当前类，JSONModel的所有的父类的属性
2. objc_setAssociatedObject(
3.         self.class,
4.         &kClassPropertiesKey,
5.         [propertyIndex copy],
6.         OBJC_ASSOCIATION_RETAIN
7. );

复制代码

• 同时必要注意当前类会不断沿superclass继续链向上检索直到父类为JSONModel
  

1. while (class != [JSONModel class]) {
2.            ......................
3.            ......................
4.   class = [class superclass];
5. }

复制代码

- (BOOL)__doesDictionaryNSDictionary*)dict matchModelWithKeyMapperJSONKeyMapper*)keyMapper

在这一步，我们先不看源码，我们直译一下这个方法：
字典是否与拥有KeyMapper的模型匹配
那么我们就很容易理解这个方法的作用，就是检查字典与模型是否匹配，在上一个方法中我们将

1. //model类里面定义的属性集合是不能大于传入的字典里的key集合的。
2. //如果存在了用户自定义的mapper，则需要按照用户的定义来进行转换。
3. //（例如将gender转换为了sex）。
4. -(BOOL)__doesDictionary:(NSDictionary*)dict matchModelWithKeyMapper:(JSONKeyMapper*)keyMapper error:(NSError**)err
5. {
6.     //check if all required properties are present
7.     //拿到字典里所有的key
8.     NSArray* incomingKeysArray = [dict allKeys];
10.     NSMutableSet* requiredProperties = [self __requiredPropertyNames].mutableCopy;
12.     //从array拿到set
13.     NSSet* incomingKeys = [NSSet setWithArray: incomingKeysArray];
16.     //transform the key names, if necessary
17.     //如有必要，变换键名称
18.     //如果用户自定义了mapper，则进行转换
19.     if (keyMapper || globalKeyMapper) {
21.         NSMutableSet* transformedIncomingKeys = [NSMutableSet setWithCapacity: requiredProperties.count];
22.         NSString* transformedName = nil;
24.         //loop over the required properties list
25.         //在所需属性列表上循环
26.         //遍历需要转换的属性列表
27.         for (JSONModelClassProperty* property in [self __properties__])
28. {
29.             //被转换成的属性名称（例如）TestModel（模型内） -> url（字典内）
30.             transformedName = (keyMapper||globalKeyMapper) ? [self __mapString:property.name withKeyMapper:keyMapper] : property.name;
33.             //check if exists and if so, add to incoming keys
34.             //检查是否存在，如果存在，则添加到传入密钥
35.             //（例如）拿到url以后，查看传入的字典里是否有url对应的值
36.             id value;
37.             @try {
38.                 value = [dict valueForKeyPath:transformedName];
39.             }
40.             @catch (NSException *exception) {
41.                 value = dict[transformedName];
42.             }
44.             if (value) {
45.                 [transformedIncomingKeys addObject: property.name];
46.             }
47.         }
49.         //overwrite the raw incoming list with the mapped key names
50.         //用映射的键名称覆盖原始传入列表
51.         incomingKeys = transformedIncomingKeys;
53.     }
55.     //check for missing input keys
56.     //检查是否缺少输入键
57.     //查看当前的model的属性的集合是否大于传入的属性集合，如果是，则返回错误
58.     //也就是说模型类里的属性是不能多于传入字典里的key的，例如：
59.     if (![requiredProperties isSubsetOfSet:incomingKeys]) {
61.         //get a list of the missing properties
62.         //获取缺失属性的列表（获取多出来的属性）
63.         [requiredProperties minusSet:incomingKeys];
65.         //not all required properties are in - invalid input
66.         //并非所有必需的属性都在 in - 输入无效
67.         JMLog(@"Incoming data was invalid [%@ initWithDictionary:]. Keys missing: %@", self.class, requiredProperties);
69.         if (err) *err = [JSONModelError errorInvalidDataWithMissingKeys:requiredProperties];
70.         return NO;
71.     }
73.     //not needed anymore
74.     //不再需要了，释放掉
75.     incomingKeys= nil;
76.     requiredProperties= nil;
78.     return YES;
79. }

复制代码

• 首先获取dict中全部的键名
  

1.     NSArray* incomingKeysArray = [dict allKeys];

复制代码

• 其次获取模型类中全部的属性名
  

1. NSMutableSet* requiredProperties = [self __requiredPropertyNames].mutableCopy;

复制代码

这里跳进__requiredPropertyNames方法看一下：

1. -(NSMutableSet*)__requiredPropertyNames
2. {
3.     //fetch the associated property names
4.     NSMutableSet* classRequiredPropertyNames = objc_getAssociatedObject(self.class, &kClassRequiredPropertyNamesKey);
6.     if (!classRequiredPropertyNames) {
7.         classRequiredPropertyNames = [NSMutableSet set];
8.         [[self __properties__] enumerateObjectsUsingBlock:^(JSONModelClassProperty* p, NSUInteger idx, BOOL *stop) {
9.             if (!p.isOptional) [classRequiredPropertyNames addObject:p.name];
10.         }];
12.         //persist the list
13.         objc_setAssociatedObject(
14.                                  self.class,
15.                                  &kClassRequiredPropertyNamesKey,
16.                                  classRequiredPropertyNames,
17.                                  OBJC_ASSOCIATION_RETAIN // This is atomic
18.                                  );
19.     }
20.     return classRequiredPropertyNames;
21. }

复制代码

我们先前说了，kClassRequiredPropertyNamesKey是一个用来保存全部属性的名称NSSet，因此调用这个方法可以让requiredProperties获取模型类中的全部属性名

• 将dict中得到的key数组转换为set范例
  

1.     NSSet* incomingKeys = [NSSet setWithArray: incomingKeysArray];

复制代码

• 如果存在keyMapper或是globalKeyMapper，则将模型中的属性名转换为KeyMapper中对应的Value，也就是将JSONModel中的属性名转换为Json键名
  

1. transformedName = (keyMapper||globalKeyMapper) ? [self __mapString:property.name withKeyMapper:keyMapper] : property.name;

复制代码

具体怎样转换可以跳进-(NSString*)__mapStringNSString*)string withKeyMapperJSONKeyMapper*)keyMapper方法查看

• 最后更新dict的键名集合，这样做是为了包管dict中的每个键名都有对应的有效值，而不是仅仅只有一个key键
  

1. incomingKeys = transformedIncomingKeys;

复制代码

• 最后查看模型类的属性列表是否为JSON键值集合的子集
  如果不是则会报错，意味着JSON中的数据不能完全覆盖我们声明的属性，说明我们有属性得不到赋值，因此会判定出错
  

1.     //check for missing input keys
2.     if (![requiredProperties isSubsetOfSet:incomingKeys]) {
4.         //get a list of the missing properties
5.         [requiredProperties minusSet:incomingKeys];
7.         //not all required properties are in - invalid input
8.         JMLog(@"Incoming data was invalid [%@ initWithDictionary:]. Keys missing: %@", self.class, requiredProperties);
10.         if (err) *err = [JSONModelError errorInvalidDataWithMissingKeys:requiredProperties];
11.         return NO;
12.     }

复制代码

- (BOOL)__importDictionaryNSDictionary*)dict withKeyMapper:(JSONKeyMapper*)keyMapper validation:(BOOL)validation error:(NSError**)err

前面举行了许多验证的操纵，终于到了将JSON数据导入模型中的操纵了

1. //作者在最后给属性赋值的时候使用的是kvc的setValue:ForKey:的方法。
2. //作者判断了模型里的属性的类型是否是JSONModel的子类，可见作者的考虑是非常周全的。
3. //整个框架看下来，有很多的地方涉及到了错误判断，作者将将错误类型单独抽出一个类（JSONModelError），里面支持的错误类型很多，可以侧面反应作者思维之缜密。而且这个做法也可以在我们写自己的框架或者项目中使用。
4. //从字典里获取值并赋给当前模型对象
5. -(BOOL)__importDictionary:(NSDictionary*)dict withKeyMapper:(JSONKeyMapper*)keyMapper validation:(BOOL)validation error:(NSError**)err
6. {
7.     //loop over the incoming keys and set self's properties
8.     //遍历保存的所有属性的字典
9.     for (JSONModelClassProperty* property in [self __properties__])
10. {
12.         //convert key name to model keys, if a mapper is provided
13.         //将属性的名称（若有改动就拿改后的名称）拿过来，作为key，用这个key来查找传进来的字典里对应的值
14.         NSString* jsonKeyPath = (keyMapper||globalKeyMapper) ? [self __mapString:property.name withKeyMapper:keyMapper] : property.name;
16.         //JMLog(@"keyPath: %@", jsonKeyPath);
18.         //general check for data type compliance
19.         //用来保存从字典里获取的值
20.         id jsonValue;
21.         @try {
22.             jsonValue = [dict valueForKeyPath: jsonKeyPath];
23.         }
24.         @catch (NSException *exception) {
25.             jsonValue = dict[jsonKeyPath];
26.         }
28.         //check for Optional properties
29.         //检查可选属性
30.         //字典不存在对应的key
31.         if (isNull(jsonValue)) {
32.             //skip this property, continue with next property
33.             //跳过此属性，继续下一个属性
34.             //如果这个key是可以不存在的
35.             if (property.isOptional || !validation) continue;
36.             //如果这个key是必须有的，则返回错误
37.             if (err) {
38.                 //null value for required property
39.                 //所需属性的值为null
40.                 NSString* msg = [NSString stringWithFormat:@"Value of required model key %@ is null", property.name];
41.                 JSONModelError* dataErr = [JSONModelError errorInvalidDataWithMessage:msg];
42.                 *err = [dataErr errorByPrependingKeyPathComponent:property.name];
43.             }
44.             return NO;
45.         }
46.         //获取，取到的值的类型
47.         Class jsonValueClass = [jsonValue class];
48.         BOOL isValueOfAllowedType = NO;
49.         //查看是否是本框架兼容的属性类型
50.         for (Class allowedType in allowedJSONTypes) {
51.             if ( [jsonValueClass isSubclassOfClass: allowedType] ) {
52.                 isValueOfAllowedType = YES;
53.                 break;
54.             }
55.         }
56.         
57.         //如果不兼容，则返回NO，mapping失败，抛出错误
58.         if (isValueOfAllowedType==NO) {
59.             //type not allowed
60.             JMLog(@"Type %@ is not allowed in JSON.", NSStringFromClass(jsonValueClass));
62.             if (err) {
63.                 NSString* msg = [NSString stringWithFormat:@"Type %@ is not allowed in JSON.", NSStringFromClass(jsonValueClass)];
64.                 JSONModelError* dataErr = [JSONModelError errorInvalidDataWithMessage:msg];
65.                 *err = [dataErr errorByPrependingKeyPathComponent:property.name];
66.             }
67.             return NO;
68.         }
70.         //check if there's matching property in the model
71.         //检查模型中是否有匹配的属性
72.         //如果是兼容的类型：
73.         if (property) {
75.             // check for custom setter, than the model doesn't need to do any guessing
76.             // how to read the property's value from JSON
77.             //检查自定义setter，则模型不需要进行任何猜测（查看是否有自定义setter，并设置）
78.             //如何从JSON读取属性值
79.             if ([self __customSetValue:jsonValue forProperty:property]) {
80.                 //skip to next JSON key
81.                 //跳到下一个JSON键
82.                 continue;
83.             };
85.             // 0) handle primitives
86.             //0）句柄原语
87.             //基本类型
88.             if (property.type == nil && property.structName==nil) {
90.                 //generic setter
91.                 //通用setter
92.                 //kvc赋值
93.                 if (jsonValue != [self valueForKey:property.name]) {
94.                     [self setValue:jsonValue forKey: property.name];
95.                 }
97.                 //skip directly to the next key
98.                 //直接跳到下一个键
99.                 continue;
100.             }
102.             // 0.5) handle nils
103.             //如果传来的值是空，即使当前的属性对应的值不是空，也要将空值赋给它
104.             if (isNull(jsonValue)) {
105.                 if ([self valueForKey:property.name] != nil) {
106.                     [self setValue:nil forKey: property.name];
107.                 }
108.                 continue;
109.             }
112.             // 1) check if property is itself a JSONModel
113.             //检查属性本身是否是jsonmodel类型
114.             if ([self __isJSONModelSubClass:property.type]) {
116.                 //initialize the property's model, store it
117.                 //初始化属性的模型，并将其存储
118.                 //通过自身的转模型方法，获取对应的值
119.                 JSONModelError* initErr = nil;
120.                 id value = [[property.type alloc] initWithDictionary: jsonValue error:&initErr];
122.                 if (!value) {
123.                     //skip this property, continue with next property
124.                     //跳过此属性，继续下一个属性（如果该属性不是必须的，则略过）
125.                     if (property.isOptional || !validation) continue;
127.                     // Propagate the error, including the property name as the key-path component
128.                     //传播错误，包括将属性名称作为密钥路径组件（如果该属性是必须的，则返回错误）
129.                     if((err != nil) && (initErr != nil))
130.                     {
131.                         *err = [initErr errorByPrependingKeyPathComponent:property.name];
132.                     }
133.                     return NO;
134.                 }
135.                 //当前的属性值与value不同时，则赋值
136.                 if (![value isEqual:[self valueForKey:property.name]]) {
137.                     [self setValue:value forKey: property.name];
138.                 }
140.                 //for clarity, does the same without continue
141.                 //为清楚起见，不继续执行相同操作
142.                 continue;
144.             } else {
146.                 // 2) check if there's a protocol to the property
147.                 //  ) might or not be the case there's a built in transform for it
148.                 //2）检查是否有协议
149.                 //）可能是，也可能不是，它有一个内置的转换
150.                 if (property.protocol) {
152.                     //JMLog(@"proto: %@", p.protocol);
153.                     //转化为数组，这个数组就是例子中的friends属性
154.                     jsonValue = [self __transform:jsonValue forProperty:property error:err];
155.                     if (!jsonValue) {
156.                         if ((err != nil) && (*err == nil)) {
157.                             NSString* msg = [NSString stringWithFormat:@"Failed to transform value, but no error was set during transformation. (%@)", property];
158.                             JSONModelError* dataErr = [JSONModelError errorInvalidDataWithMessage:msg];
159.                             *err = [dataErr errorByPrependingKeyPathComponent:property.name];
160.                         }
161.                         return NO;
162.                     }
163.                 }
165.                 // 3.1) handle matching standard JSON types
166.                 //3.1）句柄匹配标准JSON类型
167.                 //对象类型
168.                 if (property.isStandardJSONType && [jsonValue isKindOfClass: property.type]) {
170.                     //mutable properties
171.                     //可变类型的属性
172.                     if (property.isMutable) {
173.                         jsonValue = [jsonValue mutableCopy];
174.                     }
176.                     //set the property value
177.                     //为属性赋值
178.                     if (![jsonValue isEqual:[self valueForKey:property.name]]) {
179.                         [self setValue:jsonValue forKey: property.name];
180.                     }
181.                     continue;
182.                 }
184.                 // 3.3) handle values to transform
185.                 //3.3）处理要转换的值
186.                 //当前的值的类型与对应的属性的类型不一样的时候，需要查看用户是否自定义了转换器（例如从NSSet到NSArray转换：-(NSSet *)NSSetFromNSArray:(NSArray *)array）
187.                 if (
188.                     (![jsonValue isKindOfClass:property.type] && !isNull(jsonValue))
189.                     ||
190.                     //the property is mutable
191.                     //属性是可变的
192.                     property.isMutable
193.                     ||
194.                     //custom struct property
195.                     //自定义结构属性
196.                     property.structName
197.                     ) {
199.                     // searched around the web how to do this better
200.                     // but did not find any solution, maybe that's the best idea? (hardly)
201.                     //在网上搜索如何更好地做到这一点
202.                     //但是没有找到任何解决方案，也许这是最好的主意？（几乎没有）
203.                     Class sourceClass = [JSONValueTransformer classByResolvingClusterClasses:[jsonValue class]];
205.                     //JMLog(@"to type: [%@] from type: [%@] transformer: [%@]", p.type, sourceClass, selectorName);
207.                     //build a method selector for the property and json object classes
208.                     //为属性和json对象类构建方法选择器
209.                     NSString* selectorName = [NSString stringWithFormat:@"%@From%@:",
210.                                               (property.structName? property.structName : property.type), //target name目标名
211.                                               sourceClass]; //source name源名称
212.                     SEL selector = NSSelectorFromString(selectorName);
214.                     //check for custom transformer
215.                     //查看自定义的转换器是否存在
216.                     BOOL foundCustomTransformer = NO;
217.                     if ([valueTransformer respondsToSelector:selector]) {
218.                         foundCustomTransformer = YES;
219.                     } else {
220.                         //try for hidden custom transformer
221.                         //尝试隐藏自定义转换器
222.                         selectorName = [NSString stringWithFormat:@"__%@",selectorName];
223.                         selector = NSSelectorFromString(selectorName);
224.                         if ([valueTransformer respondsToSelector:selector]) {
225.                             foundCustomTransformer = YES;
226.                         }
227.                     }
229.                     //check if there's a transformer with that name
230.                     //检查是否有同名变压器
231.                     //如果存在自定义转换器，则进行转换
232.                     if (foundCustomTransformer) {
233.                         IMP imp = [valueTransformer methodForSelector:selector];
234.                         id (*func)(id, SEL, id) = (void *)imp;
235.                         jsonValue = func(valueTransformer, selector, jsonValue);
237.                         if (![jsonValue isEqual:[self valueForKey:property.name]])
238.                             [self setValue:jsonValue forKey:property.name];
239.                     } else {
240.                         //如果没有自定义转换器，返回错误
241.                         if (err) {
242.                             NSString* msg = [NSString stringWithFormat:@"%@ type not supported for %@.%@", property.type, [self class], property.name];
243.                             JSONModelError* dataErr = [JSONModelError errorInvalidDataWithTypeMismatch:msg];
244.                             *err = [dataErr errorByPrependingKeyPathComponent:property.name];
245.                         }
246.                         return NO;
247.                     }
248.                 } else {
249.                     // 3.4) handle "all other" cases (if any)
250.                     //3.4）处理“所有其他”情况（如有）
251.                     if (![jsonValue isEqual:[self valueForKey:property.name]])
252.                         [self setValue:jsonValue forKey:property.name];
253.                 }
254.             }
255.         }
256.     }
258.     return YES;
259. }

复制代码

• 首先遍历模型类中的全部属性
  

1. for (JSONModelClassProperty* property in [self __properties__])

复制代码

• 找到JSON字典中与模型类对应的key
  

1.         NSString* jsonKeyPath = (keyMapper||globalKeyMapper) ? [self __mapString:property.name withKeyMapper:keyMapper] : property.name;

复制代码

• 获取keyvalue，这里不用担心获取为空，由于在上一步验证dict是否与keymapper有匹配的方法中已经验证过了
  

1. id jsonValue;
2.         @try {
3.             jsonValue = [dict valueForKeyPath: jsonKeyPath];
4.         }
5.         @catch (NSException *exception) {
6.             jsonValue = dict[jsonKeyPath];
7.         }

复制代码

• 举行一系列检查操纵，就不讲了，最后终于通过KVC将JSON字典中的值赋给了模型类
  

1.             if (property.type == nil && property.structName==nil) {
3.                 //generic setter
4.                 //通用setter
5.                 //kvc赋值
6.                 if (jsonValue != [self valueForKey:property.name]) {
7.                     [self setValue:jsonValue forKey: property.name];
8.                 }
10.                 //skip directly to the next key
11.                 //直接跳到下一个键
12.                 continue;
13.             }

复制代码

总结

JSONModel提供了一种方法，

• 得到的JSON数据自动与Model举行匹配
  
• 还提供了keyMapper将JSON键自动映射到模型的属性
  
• 还让我们可以自界说错误处理
  

这里再讲一下JSONModel的实现流程：
方法中通过获取JSONModel类的属性列表，与传入的JSON数据自动匹配，同时还可以通过KeyMapper修改不类似的映射，如果模型类与JSON数据字段不匹配则会抛出错误（这里体现为Model中某些必须的属性没有在JSON数据中找到相应的映射），最后如果范例等都检查成功，则通过KVC将JSON数据中的value设置在Model类的对应的属性上

1. if (jsonValue != [self valueForKey:property.name]) {
2.                     [self setValue:jsonValue forKey: property.name];

复制代码

这里再总结一下JSONModel的几个优点

• 首先就是Runtime中动态剖析Model数据范例，可以实现自动匹配
  
• 然后在setup方法中还通过AssociatedObject实现了已经剖析过了Model的属性列表等必须信息的缓存，避免了类似模型的重复剖析
  
• 还有就是KVC附值
  
• 使用KeyMapper修改不同等的JSON字段与属性
  

这里还有必要再讲一下KeyMapper，你可以通过重写模型类中的 +keyMapper 方法来自界说键映射。这个方法必要返回一个 JSONKeyMapper 对象，该对象通过初始化方法接收一个字典来界说映射关系。

1. @interface User : JSONModel
2. @property (strong, nonatomic) NSString *userId;
3. @property (strong, nonatomic) NSString *email;
4. @property (strong, nonatomic) NSString *userDescription;
5. @end
7. @implementation User
9. + (JSONKeyMapper *)keyMapper {
10.     return [[JSONKeyMapper alloc] initWithModelToJSONDictionary:@{
11.         @"userId": @"id",
12.         @"email": @"email_address",
13.         @"userDescription": @"description"
14.     }];
15. }
17. @end

复制代码

参考博客：
JSONModel源码剖析
【iOS-JSONModel源码】
JSONModel源代码剖析

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。