iOS源码解析—YYModel（NSObject+YYModel）

概述

​ iOS源码解析—YYModel（YYClassInfo）分析了如何根据OC的Class对象构建YYClassInfo对象，为接下来的JSON数据和Model转换作准备，这篇文章开始讲解NSObject+YYModel。

NSObject+YYModel.h

​ 分析NSObject+YYModel.h文件，包括3个Category和一个protocol，分别是：

NSObject（YYModel）

NSArray（YYModel）

NSDictionary（YYModel）

YYModel

1. NSObject（YYModel）

   负责扩展NSObject类，提供了Model相关方法，下面是代码注释：

   @interface NSObject (YYModel)
   //根据JSON对象创建Model
   + (nullable instancetype)yy_modelWithJSON:(id)json;
   //根据NSDictionary创建Model
   + (nullable instancetype)yy_modelWithDictionary:(NSDictionary *)dictionary;
   //将JSON对象的各字段映射到Model的各个字段
   - (BOOL)yy_modelSetWithJSON:(id)json;
   //将NSDictionary的各字段映射到Model的各个字段
   - (BOOL)yy_modelSetWithDictionary:(NSDictionary *)dic;
   //根据Model创建JSON对象
   - (nullable id)yy_modelToJSONObject;
   //根据Model创建JSON数据流
   - (nullable NSData *)yy_modelToJSONData;
   //根据Model创建JSON字符串
   - (nullable NSString *)yy_modelToJSONString;
   //复制Model
   - (nullable id)yy_modelCopy;
   //对Model进行归档
   - (void)yy_modelEncodeWithCoder:(NSCoder *)aCoder;
   //对Model进行解档
   - (id)yy_modelInitWithCoder:(NSCoder *)aDecoder;
   //model的hash值
   - (NSUInteger)yy_modelHash;
   //判断Model和参数model是否相同
   - (BOOL)yy_modelIsEqual:(id)model;
   //输出Model的相关信息
   - (NSString *)yy_modelDescription;
   @end
   

   例如定义一个Student类，代码如下：

   @interface College : NSObject
   @property (nonatomic, copy) NSString *name;
   @end
          
   //Student
   @interface Student : NSObject 
   @property (nonatomic, copy) NSString *name; //名字
   @property (nonatomic, assign) NSInteger age; //年龄
   @property (nonatomic, strong) College *college; //学校
   @end
   

   同时创建一个字典对象，如下：

   NSDictionary *studentDic = @{@"name" : @"Tomy",
                                @"age" : @18,
                                @"college" : @{@"name" : @"NJU"}};
   

   调用[Student yy_modelWithDictionary:studentDic]方法，创建一个Student类型的Model对象，然后将studentDic的每个value赋值给Model相应属性。property的名称和key一一对应。在转化的过程中，可以实现Model嵌套的情况，如Student中嵌套一个College对象。

   调用[Student yy_modelToJSONObject]方法，创建一个字典对象，各键值对中的key是Model相应属性的名称，value是属性值。在转化的过程中，也支持嵌套的情况。

2. NSArray（YYModel）

   负责扩展NSArray类，下面是代码注释:

    @interface NSArray (YYModel)
    //根据JSON创建Model数组（JSON是数组格式）
    + (nullable NSArray *)yy_modelArrayWithClass:(Class)cls json:(id)json;
    @end
   

   例如有一个数组，如下：

   NSArray *studentArr = 
            @[@{@"name" : @"Tomy", @"age" : @18, @"college" : @{@"name" : @"NJU"}}, 
        @{@"name" : @"Alex", @"age" : @19, @"college" : @{@"name" : @"Harvard"}},
        @{@"name" : @"Sunny", @"age" : @20, @"college" : @{@"name" : @"Yale"}}];
   

   调用[NSArray yy_modelArrayWithClass:Student json:studentArr]方法，创建一个Model数组，数组中的每个元素是Student对象。

3. NSDictionary（YYModel）

   负责扩展NSDictionary类，下面是代码注释：

   @interface NSDictionary (YYModel)
   //根据JSON的value和Class对象创建Model,并创建一个新字典，取json的key作为key，取Model作为value
   + (nullable NSDictionary *)yy_modelDictionaryWithClass:(Class)cls json:(id)json;
   @end
   

   例如创建一个字典，如下：

   NSDictionary *playerDic = 
     @{@"player1" : @{@"name" : @"Tomy",
                      @"age" : @18,
                      @"college" : @{@"name" : @"NJU"}},
     @"player2" : @{@"name" : @"Alex",
                    @"age" : @19,
                    @"college" : @{@"name" : @"Yale"}}};
   

   调用[NSDictionary yy_modelDictionaryWithClass:Student json:playerDic]得到一个新的字典studentDic，如下：

1-6.png

字典studentDic中的key对应原字典playerDic中的key，studentDic中的Model由playerDic中的value转化得到。

4. @protocol YYModel

   YYModel是iOS协议，里面声明了一些方法，调用类通过实现这些方法，实现JSON和Model之间转换过程中的特殊处理。

   + (nullable NSDictionary *)modelCustomPropertyMapper;
   + (nullable NSDictionary *)modelContainerPropertyGenericClass;
   + (nullable Class)modelCustomClassForDictionary:(NSDictionary *)dictionary;
   + (nullable NSArray *)modelPropertyBlacklist;
   + (nullable NSArray *)modelPropertyWhitelist;
   - (NSDictionary *)modelCustomWillTransformFromDictionary:(NSDictionary *)dic;
   - (BOOL)modelCustomTransformFromDictionary:(NSDictionary *)dic;
   - (BOOL)modelCustomTransformToDictionary:(NSMutableDictionary *)dic;
   

   下面讲一下协议中的每个方法：

   1. modelCustomPropertyMapper方法，可以指定json和model转化过程中key的映射关系，如果存在以下的字典：

      NSDictionary *studentDic = @{@"NAME" : @"Tomy",
                                     @"AGE" : @{@"num":@18},
                                   @"college" : @{@"name" : @"NJU"}};
      

      如果需要将studentDic转化成Student类型的model，需要实现如下modelCustomPropertyMapper方法：

      + (nullable NSDictionary *)modelCustomPropertyMapper
      {
        return @{@"name" : @"NAME",
                       @"age" : @"AGE.num"};
      }
      

      返回的键值对中的key是Student的property名称，value是studentDic中的key。

   2. 如果Student中存在property是对象数组或者字典，实现modelContainerPropertyGenericClass方法，例如Student存在属性mobilePhones，维护一组MobilePhone对象

      @interface MobilePhone : NSObject
      @property (nonatomic, copy) NSString *brand;
      @property (nonatomic, assign) NSInteger phoneNumber;
      @end
        
      @interface Student : NSObject 
      @property (nonatomic, copy) NSString *name;
      @property (nonatomic, assign) NSInteger age;
      @property (nonatomic, strong) College *college;
      @property (nonatomic, strong) NSArray *mobilePhones; //MobilePhone对象数组
      @end
      NSDictionary *studentDic = 
        @{@"name" : @"Tomy",
          @"age" : @18,
          @"college" : @{@"name" : @"NJU"},
          @"mobilePhones" : @[@{@"brand" : @"iphone",@"phoneNumber" : @123456},
                              @{@"brand" : @"HUAWEI",@"phoneNumber" : @123456}]};
      

      调用[Student yy_modelWithDictionary:studentDic]方法将studentDic中的mobilePhones转化成Student的mobilePhones属性，需要实现如下：

      + (nullable NSDictionary*)modelContainerPropertyGenericClass
      {
          return @{@"mobilePhones" : [MobilePhone class]};
      }
      

   3. modelCustomClassForDictionary方法用于指定生成Model的类型，如果没有实现该方法，用默认的类型，例如Student实现modelCustomClassForDictionary，如下：

      + (Class)modelCustomClassForDictionary:(NSDictionary*)dictionary {
        if ([dictionary[@"name"] isEqualToString @"Graduated"]) {
            return [Graduated class];
            } else {
            return [self class];
            }
      }
      

      调用[Student yy_modelWithDictionary:studentDic]方法，如果studentDic[@"name"]等于@"Graduated"，则不创建Student类型的对象，而是创建Graduated类型的对象。

   4. modelPropertyBlacklist方法和modelPropertyWhitelist方法的作用相反，如果实现了modelPropertyBlacklist，该方法返回一个数组，数组中的值指定了Model中不需要被赋值的property，例如代码如下：

      + (nullable NSArray *)modelPropertyBlacklist
      {
          return @[@"age", @"college"];
      }
      

      则Student中的age和college属性不会被赋值。如果实现了modelPropertyWhitelist方法，该方法返回一个数组，数组中的值指定了Model中仅需要被赋值的property，例如代码如下：

      + (nullable NSArray *)modelPropertyWhitelist
      {
          return @[@"age", @"college"];
      }
      

      则Student中只有age和college属性会被赋值。

   5. modelCustomWillTransformFromDictionary:方法作用于根据JSON创建Model对象之前，该方法可以把JSON字典转化成一个新的字典。

   6. modelCustomTransformFromDictionary:方法作用于根据JSON创建Model对象之后，该方法可以对生成的Model做一些处理。

   7. modelCustomTransformToDictionary:方法作用于根据Model对象创建JSON之后，该方法可以对生成的JSON字典做一些处理。

NSObject+YYModel.m

首先定义了两个类，_YYModelMeta和_YYModelPropertyMeta，分别封装了Model的信息和Model中各属性的信息。

_YYModelMeta维护了Class的相关信息，下面是注释：

@interface _YYModelMeta : NSObject {
    @package
    YYClassInfo *_classInfo; //关联的YYClassInfo对象
    NSDictionary *_mapper; //维护一个键值对，key是属性名，value是_YYModelPropertyMeta对象
    //维护一个数组，里面的元素是_YYModelPropertyMeta对象
    NSArray *_allPropertyMetas;
    //维护一个数组，里面的元素是_YYModelPropertyMeta对象
    NSArray *_keyPathPropertyMetas;
    //维护一个数组，里面的元素是_YYModelPropertyMeta对象
    NSArray *_multiKeysPropertyMetas;
    //通过映射相关
    NSUInteger _keyMappedCount;
    //对象类型
    YYEncodingNSType _nsType;
    ...
}
@end

_YYModelMeta是通过YYClassInfo对象的信息构建得到的。首先调用metaWithClass:cls方法，该方法如下：

+ (instancetype)metaWithClass:(Class)cls {
    ...
    _YYModelMeta *meta = CFDictionaryGetValue(cache, (__bridge const void *)(cls)); //从缓存中取
    ...
    if (!meta || meta->_classInfo.needUpdate) {
        meta = [[_YYModelMeta alloc] initWithClass:cls]; //创建一个新的_YYModelMeta对象
        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;
}

维护了一个键值对cache作为缓存，用cls作为key，调用CFDictionaryGetValue方法去缓存中查找，如果有，直接返回构建好的_____YYModelMeta对象，如果没有找到或者needUpdate属性标记为true，则根据cls创建一个新的_YYModelMeta对象，并且存入缓存。这样不需要每次都创建，提高了性能。

接下来看一下initWithClass:方法，

1. 创建一个YYClassInfo对象，在上一篇文章中分析了YYClassInfo的创建方法；

2. 判断调用层是否实现modelPropertyBlacklist方法，如果实现了，返回一组黑名单，数组中包含的属性名不会被转化。

3. 判断调用层是否实现modelPropertyWhitelist方法，如果实现了，返回一组白名单，不在数组中的属性名不会被转化。

4. 如果调用层实现了modelContainerPropertyGenericClass方法，则维护一个字典genericMapper，字典的value如果是NSString类型，需要转成Class类型。

5. 遍历对象的属性，生成_YYModelPropertyMeta，代码注释如下：

   NSMutableDictionary *allPropertyMetas = [NSMutableDictionary new];
   YYClassInfo *curClassInfo = classInfo;
   while (curClassInfo && curClassInfo.superCls != nil) {
    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创建_YYModelPropertyMeta
           _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; //存入allPropertyMetas字典中
       }
       curClassInfo = curClassInfo.superClassInfo;
   }
   if (allPropertyMetas.count) _allPropertyMetas = allPropertyMetas.allValues.copy; //赋值给_allPropertyMetas属性
   

   根据classInfo信息和propertyInfo信息创建_YYModelPropertyMeta对象，并用_allPropertyMetas字典存储，字典中的key是属性名，value是_YYModelPropertyMeta对象。

6. 如果调用层实现了modelCustomPropertyMapper方法，说明存在JSON字典key和属性名之间的映射关系，需要遍历这些属性，做特殊处理，如下：

   if ([cls respondsToSelector:@selector(modelCustomPropertyMapper)]) {
        NSDictionary *customMapper = [(id )cls modelCustomPropertyMapper];
    [customMapper enumerateKeysAndObjectsUsingBlock:^(NSString *propertyName, NSString *mappedToKey, BOOL *stop) {
            //这些属性名对应的_YYModelPropertyMeta从allPropertyMetas字典中删除
            _YYModelPropertyMeta *propertyMeta = allPropertyMetas[propertyName];
           if (!propertyMeta) return;
           [allPropertyMetas removeObjectForKey:propertyName];
            
            //mappedToKey作为新的key，存入mapper，value是propertyMeta，同时对mappedToKey做一些分割处理，表示映射的路径
           if ([mappedToKey isKindOfClass:[NSString class]]) {
            ...
               if (keyPath.count > 1) {
                       propertyMeta->_mappedToKeyPath = keyPath;
                       [keyPathPropertyMetas addObject:propertyMeta];
               }
                propertyMeta->_next = mapper[mappedToKey] ?: nil;
                mapper[mappedToKey] = propertyMeta;  
            } 
            ...
        }];
   }
   

7. 维护一个_mapper字典，key是mappedToKey，对于customMapper字典中不存在的属性，mappedToKey是其本身的属性名，value是创建的propertyMeta。同时维护一个_keyPathPropertyMetas数组和_multiKeysPropertyMetas数组，专门存储customMapper中存在的，即存在映射关系的_YYModelPropertyMeta。

   其中YYModelPropertyMeta类维护了property的相关信息，下面是相关注释：

   @interface _YYModelPropertyMeta : NSObject {
       @package
       NSString *_name;             //属性名
       YYEncodingType _type;        //属性类型
       YYEncodingNSType _nsType;    //属性如果是NSObject类型的对象，相应的类型
       BOOL _isCNumber;             //是否是数字类型
       Class _cls;                  //属性的类
       Class _genericCls;           //
       SEL _getter;                 //getter方法
       SEL _setter;                 //setter方法
       BOOL _isKVCCompatible;       //是否可以处理KVC
       BOOL _isStructAvailableForKeyedArchiver; //是否可以archiver/unarchiver
       BOOL _hasCustomClassFromDictionary; //
       
       NSString *_mappedToKey;      //该属性名对应的JSON字典中的key
       NSArray *_mappedToKeyPath;   //该属性名对应的JSON字典中的keyPath，keyPath是一个路径，例如AGE.NUM，该数组存储@[AGE,NUM]
       NSArray *_mappedToKeyArray;  //该属性名对应的JSON字典中的key，如果@[@"age",@"num"]
       YYClassPropertyInfo *_info;  //关联的YYClassPropertyInfo
       _YYModelPropertyMeta *_next; //另一个YYModelPropertyMeta对象，key名称相同
   }
   @end
   

   _YYModelPropertyMeta对象是通过YYClassPropertyInfo对象的信息构建得到的。

主要方法

下面分析几个重要的方法：

1. yy_modelWithJSON:方法

   该方法首先调用_yy_dictionaryWithJSON:方法将JSON数据进行转化，如果JSON数据是NSString或者NSData格式，转化为字典对象，否则直接返回。然后调用yy_modelWithDictionary:方法，代码如下:

   + (instancetype)yy_modelWithDictionary:(NSDictionary *)dictionary {
           ...
           Class cls = [self class];
            //1.metaWithClass
           _YYModelMeta *modelMeta = [_YYModelMeta metaWithClass:cls];
           if (modelMeta->_hasCustomClassFromDictionary) {
               cls = [cls modelCustomClassForDictionary:dictionary] ?: cls;
           }
           ...
           //2.根据json字典对新创建的model进行赋值
           NSObject *one = [cls new];
           if ([one yy_modelSetWithDictionary:dictionary]) return one;
           return nil;
       }
   

   该方法主要分为2个步骤：

• 根据Class对象cls创建_YYModelMeta

• 调用yy_modelSetWithDictionary:对model进行赋值，主要代码注释如下:

  if (modelMeta->_keyMappedCount >= CFDictionaryGetCount((CFDictionaryRef)dic)) {
             //1、遍历dic中的key和value，调用ModelSetWithDictionaryFunction方法进行属性赋值
         CFDictionaryApplyFunction((CFDictionaryRef)dic, ModelSetWithDictionaryFunction, &context);
        //2、如果_keyPathPropertyMetas存放有映射关系，调用ModelSetWithPropertyMetaArrayFunction方法进行赋值
         if (modelMeta->_keyPathPropertyMetas) {
             CFArrayApplyFunction((CFArrayRef)modelMeta->_keyPathPropertyMetas, CFRangeMake(0, CFArrayGetCount((CFArrayRef)modelMeta->_keyPathPropertyMetas)),
                                       ModelSetWithPropertyMetaArrayFunction,
                                       &context);
          }
        //3、如果_multiKeysPropertyMetas存放有映射关系，调用ModelSetWithPropertyMetaArrayFunction方法进行赋值
          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);
      }
  

  主要分为2种情况：

  1. 如果Model中不存在属性名的映射，调用CFDictionaryApplyFunction方法遍历JSON字典中的每一个键值对，调用ModelSetWithDictionaryFunction方法对每一个键值对进行处理，由于_YYModelMeta内部维护了一个mapper字典，通过mapper取出YYModelPropertyMeta对象，最终调用ModelSetValueForProperty方法进行该属性的赋值。方法如下：

     static void ModelSetWithDictionaryFunction(const void *_key, const void *_value, void *_context) {
         ModelSetContext *context = _context;
         __unsafe_unretained _YYModelMeta *meta = (__bridge _YYModelMeta *)(context->modelMeta);
         //根据key在mapper中查找对应的propertyMeta，如果没有，不进行后续操作
         __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;
         };
     }
     

  2. 如果Model中存在_keyPathPropertyMetas属性或者_multiKeysPropertyMetas属性，说明_keyPathPropertyMetas数组或者_multiKeysPropertyMetas数组中维护了一组Model中的属性，这些属性的名称存在映射关系，这种情况下调用CFArrayApplyFunction方法对keyPathPropertyMetas数组或者multiKeysPropertyMetas数组进行遍历，并调用ModelSetWithPropertyMetaArrayFunction方法对每个属性元素进行处理，该方法最终也会调用ModelSetValueForProperty方法进行属性赋值。代码注释如下：

     static void ModelSetWithPropertyMetaArrayFunction(const void *_propertyMeta, void *_context) {
         ...
         //根据映射关系找到JSON中的value
         if (propertyMeta->_mappedToKeyArray) {
             value = YYValueForMultiKeys(dictionary, propertyMeta->_mappedToKeyArray);
         } else if (propertyMeta->_mappedToKeyPath) {
             value = YYValueForKeyPath(dictionary, propertyMeta->_mappedToKeyPath);
         } else {
             value = [dictionary objectForKey:propertyMeta->_mappedToKey];
         }
         //进行属性赋值
         if (value) {
             __unsafe_unretained id model = (__bridge id)(context->model);
             ModelSetValueForProperty(model, value, propertyMeta);
         }
     }
     

  上述两种情况最终会调用ModelSetValueForProperty方法在赋值的时候做了类型兼容，下文中具体分析。

2. yy_modelToJSONObject方法

   该方法调用ModelToJSONObjectRecursive方法将Model对象转化成一个字典或者数组，需要转化的Model对象可以分为3类：

   第一类是一些基本类型，直接返回或者做一些处理返回，代码如下：

   if ([model isKindOfClass:[NSString class]]) return model;
   if ([model isKindOfClass:[NSNumber class]]) return model;
   if ([model isKindOfClass:[NSURL class]]) return ((NSURL *)model).absoluteString;
   if ([model isKindOfClass:[NSAttributedString class]]) return ((NSAttributedString *)model).string;
   

   第二类是NSDictionary、NSSet、NSArray等类型，它们不属于自定义的对象类型，代码如下：

   if ([model isKindOfClass:[NSDictionary class]]) { //如果是NSDictionary类型，遍历字典，用递归的方式赋值给新的字典，并返回新的字典。
        if ([NSJSONSerialization isValidJSONObject:model]) return model;
            NSMutableDictionary *newDic = [NSMutableDictionary new];
           [((NSDictionary *)model) enumerateKeysAndObjectsUsingBlock:^(NSString *key, id obj, BOOL *stop) {
               NSString *stringKey = [key isKindOfClass:[NSString class]] ? key : key.description;
               if (!stringKey) return;
               id jsonObj = ModelToJSONObjectRecursive(obj);
               if (!jsonObj) jsonObj = (id)kCFNull;
               newDic[stringKey] = jsonObj;
           }];
           return newDic;
   }
   //如果是NSSet类型，遍历NSSet，用递归的方式赋值给新的set，并返回新的set。
   if ([model isKindOfClass:[NSSet class]]) {
    NSArray *array = ((NSSet *)model).allObjects;
        if ([NSJSONSerialization isValidJSONObject:array]) return array;
    NSMutableArray *newArray = [NSMutableArray new];
    for (id obj in array) {
    if ([obj isKindOfClass:[NSString class]] || [obj isKindOfClass:[NSNumber class]]) {
        [newArray addObject:obj];
    } else {
        id jsonObj = ModelToJSONObjectRecursive(obj);
        if (jsonObj && jsonObj != (id)kCFNull) [newArray addObject:jsonObj];
               }
           }
        return newArray;
   }
   //如果是NSArray类型，遍历NSArray，用递归的方式赋值给新的array，并返回新的array。
   if ([model isKindOfClass:[NSArray class]]) {
           if ([NSJSONSerialization isValidJSONObject:model]) return model;
           NSMutableArray *newArray = [NSMutableArray new];
           for (id obj in (NSArray *)model) {
               if ([obj isKindOfClass:[NSString class]] || [obj isKindOfClass:[NSNumber class]]) {
                   [newArray addObject:obj];
               } else {
                   id jsonObj = ModelToJSONObjectRecursive(obj);
                   if (jsonObj && jsonObj != (id)kCFNull) [newArray addObject:jsonObj];
               }
           }
           return newArray;
   }
        ...
   

   第三种是自定义的Model对象类型，首先调用metaWithClass获取自定义Model的_YYModelMeta对象，通过上文知道_YYModelMeta内部维护了一个mapper字典，用于维护Model内部的属性类型信息，然后遍历mapper中的每一个元素（_YYModelPropertyMeta），根据元素的类型，进行相应的处理，如下：

   [modelMeta->_mapper enumerateKeysAndObjectsUsingBlock:^(NSString *propertyMappedKey, _YYModelPropertyMeta *propertyMeta, BOOL *stop) {
        if (propertyMeta->_isCNumber) { //数值类型
            value = ModelCreateNumberFromProperty(model, propertyMeta);
    } else if (propertyMeta->_nsType) {
            id v = ((id (*)(id, SEL))(void *) objc_msgSend)((id)model, propertyMeta->_getter);
            value = ModelToJSONObjectRecursive(v); //递归调用
        } else {
            ...
        }
   }]
   

   如果_YYModelPropertyMeta存在mappedToKeyPath属性，需要将属性名映射到指定的key上面。

3. yy_modelArrayWithClass:json:方法

   该方法通过JSON数组和Class创建Model数组，首先调用yy_modelArrayWithClass: array:方法，然后在该方法中遍历数组，数组中每个元素是字典类型，调用yy_modelWithDictionary:方法进行转化，然后将转化后的Model添加进新数组中，最后返回这个新数组。代码如下：

   + (NSArray *)yy_modelArrayWithClass:(Class)cls array:(NSArray *)arr {
       if (!cls || !arr) return nil;
       NSMutableArray *result = [NSMutableArray new];
       for (NSDictionary *dic in arr) { //遍历数组
           if (![dic isKindOfClass:[NSDictionary class]]) continue;
           NSObject *obj = [cls yy_modelWithDictionary:dic]; //dic->Model
           if (obj) [result addObject:obj]; //添加Model
       }
       return result;
   }
   

4. yy_modelDictionaryWithClass:json:方法

   该方法和上面的方法3类似，首先调用yy_modelDictionaryWithClass:dictionary:方法，然后在该方法中遍历JSON字典，字典中的每个元素同样是字典，调用yy_modelWithDictionary:方法进行转化，然后将转化后的Model加入新的字典中，key是之前JSON字典中的key。代码如下：

   + (NSDictionary *)yy_modelDictionaryWithClass:(Class)cls dictionary:(NSDictionary *)dic {
       if (!cls || !dic) return nil;
       NSMutableDictionary *result = [NSMutableDictionary new];
       for (NSString *key in dic.allKeys) { //遍历字典
           if (![key isKindOfClass:[NSString class]]) continue;
           NSObject *obj = [cls yy_modelWithDictionary:dic[key]]; //dic[key]->Model
           if (obj) result[key] = obj; //添加Model
       }
       return result;
   }
   

类型转化和兼容

YYModel的总体思想是以Model属性的类型为准，如果JSON中对应名称的value的类型和Model属性类型不一致，会对value的类型进行转化，保证和Model属性的类型一致。如果兼容不了，不进行属性赋值。下面分析一下ModelSetValueForProperty方法：

该方法上文中提到该方法是用来JSON转成Model的过程中对Model中的属性进行赋值的方法，该方法做了部分基本类型的兼容：

• 如果Model的属性是数值类型，与之对应的JSON的value是其它类型，会进行转化，如下：

  if (meta->_isCNumber) {
    NSNumber *num = YYNSNumberCreateFromID(value);
    ModelSetNumberToProperty(model, num, meta);
    if (num) [num class]; // hold the number
  }
  

  YYNSNumberCreateFromID会将value转化成NSNumber类型，有可能返回nil。

• 如果Model的属性是字符串类型，会判断value的类型，进一步处理：

  case YYEncodingTypeNSString:
  case YYEncodingTypeNSMutableString: {
    if ([value isKindOfClass:[NSString class]]) {
        ...
    } else if ([value isKindOfClass:[NSNumber class]]) {
        ... //转化成NSString
      } else if ([value isKindOfClass:[NSData class]]) {
        ... //转化成NSString
    } else if ([value isKindOfClass:[NSURL class]]) {
        ... //转化成NSString
      } else if ([value isKindOfClass:[NSAttributedString class]]) {
        ... //转化成NSString
      }
  break;
  

  根据value类型的不同，调用不得方法转成字符串类型。

• 如果Model的属性是NSNumber类型，需要将value转化成NSNumber类型。

• 如果Model的属性是NSData、NSDate、NSURL类型等，都需要value先转成这些类型。

• 不是所有的类型都可以转化，如果属性的对象是数组、集合或者字典类型，但是value不是对应的类型，不会转化，直接返回，不进行后续的属性赋值。例如字典类型，代码如下：

  case YYEncodingTypeNSDictionary:
  case YYEncodingTypeNSMutableDictionary: {
    if ([value isKindOfClass:[NSDictionary class]]) { //value为字典类型是，进行处理，否则不处理
        ... 
      }
  } break;
  

其它方法

YYModel还提供了一些工具方法，下面简单分析一下：

1. ModelDescription方法，用来描述该Model对象的相关信息，一般用于log输出。该方法主要是根据Model对象的类型，做不同的处理：

   如果是一些简单类型，做一些处理后直接输出，下面是代码注释：

   case YYEncodingTypeNSNumber:
   case YYEncodingTypeNSDecimalNumber:
   case YYEncodingTypeNSDate:
   case YYEncodingTypeNSURL: {
    return [NSString stringWithFormat:@"%@",model];
   }
   

   如果是集合、数组或者字典类型，需要遍历其中每个元素，递归调用ModelDescription，生成每个元素的输出信息，拼接成一个字符串输出，例如是NSArray：

   case YYEncodingTypeNSArray: case YYEncodingTypeNSMutableArray: {
    NSArray *array = (id)model;
    NSMutableString *desc = [NSMutableString new];
        if (array.count == 0) {
            return [desc stringByAppendingString:@"[]"];
        } else {
            [desc appendFormat:@"[\n"];
            for (NSUInteger i = 0, max = array.count; i < max; i++) {
                NSObject *obj = array[i];
                [desc appendString:@"    "];
                    //生成每个元素的输出信息，拼接字符串
                    [desc appendString:ModelDescriptionAddIndent(ModelDescription(obj).mutableCopy, 1)];
                    [desc appendString:(i + 1 == max) ? @"\n" : @";\n"];
                }
                [desc appendString:@"]"];
                return desc;
            }
        }
   

   如果是自定义Model对象，则遍历对象中每个属性，获取与之对应的_YYModelPropertyMeta对象，进一步判断_YYModelPropertyMeta对象的类型，做不同的处理。如果属于NSObject类型，递归调用ModelDescription方法。代码如下：

   for (NSUInteger i = 0, max = properties.count; i < max; i++) {
    _YYModelPropertyMeta *property = properties[i];
    NSString *propertyDesc;
    if (property->_isCNumber) {
        NSNumber *num = ModelCreateNumberFromProperty(model, property);
            propertyDesc = num.stringValue;
    } else {
            switch (property->_type & YYEncodingTypeMask) {
            case YYEncodingTypeObject: {
                id v = ((id (*)(id, SEL))(void *) objc_msgSend)((id)model, property->_getter);
                propertyDesc = ModelDescription(v);
                    if (!propertyDesc) propertyDesc = @"";
                } break;
    }
   }
   

2. YYNSDateFromString方法，用来将字符串类型转化成NSDate类型。因为NSDate是OC的对象，而JSON数据格式中不存在日期时间类型，因此需要进行转化。通常是将具有固定格式的字符串转成NSDate类型，例如："yyyy-MM-dd HH:mm:ss"。

   该方法的主要思路是创建不同类型的NSDateFormatter对象和一组block，然后根据传入的字符串参数的格式，执行相应的block，在block中再根据字符串参数调用相应的dateFormatter进行转化。代码注释如下：

   dispatch_once(&onceToken, ^{
     {
        NSDateFormatter *formatter1 = [[NSDateFormatter alloc] init];
               formatter1.locale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"];
               formatter1.timeZone = [NSTimeZone timeZoneForSecondsFromGMT:0];
               formatter1.dateFormat = @"yyyy-MM-dd'T'HH:mm:ss";
       ...
       blocks[19] = ^(NSString *string) {
                   if ([string characterAtIndex:10] == 'T') {
                       return [formatter1 dateFromString:string];
                   } else {
                       return [formatter2 dateFromString:string];
                   }
               };
       ...
       YYNSDateParseBlock parser = blocks[string.length]; //根据string选择相应的block
       if (!parser) return nil;
       return parser(string); //执行block，选取dateFormatter进行转化，输出NSDate对象
   }
   

结尾

YYModel作为一个负责JSON数据和Model转化的库，十分易用和高效，特别是做了一些类型的兼容和转化，避免了服务端接口数据类型和客户端Model对象类型不兼容导致的问题，例如执行了不存在的方法而导致崩溃。另一方面，对YYModel的学习在一定程度也促进了对runtime机制的学习和了解。

关于YYModel的分析到这儿先告一段落，由于本人的iOS基础有待提升，再加上表达能力有限，文中许多地方的分析和思路，表达的不是很准确和清楚，希望通过今后的学习和练习，提升自己的水平。