iOS開發中經常會用到數據和模型的互相轉換，大致有兩種轉換方式：1.手動寫轉換的代碼，2.利用開源庫進行轉換。常用的開源庫有：JSONModel、Mantle、MJExtension、YYModel等等，本文主要介紹一下MJExtension的底層實現，看一看小碼哥如何設計這個輕量級的數模轉換框架。

本著面向應用的角度，我覺得還是從一個字典轉模型的例子入手，來詳細介紹一下MJExtension的轉換過程。

待轉換的字典對象：

    NSDictionary *dict = @{
        @"name": @"kelvin",
        @"age": @18,
        @"married": @"false",
        @"computer": {
            @"type": @"AUSU",
            @"date": @"2012-01"
        },
        @"skills": @[
            @{
                @"type": @"C language"
                @"degree": @"proficient"
            },
            @{
                @"type": @"Python language",
                @"degree": @"grasp"
            }
        ],
    };

轉換流程

1.實現轉換的代碼

MJExtension的轉換十分方便，下面一行代碼就可以搞定，當然在轉換之前，要設置字典中數組對應的對象模型，因為在轉換過程中，需要根據模型類來創建模型數組。

    // Person.m
    + (NSDictionary*)mj_objectClassInArray
    {
        return @{@"skills": @"Skill"};
    }

    // 使用過程的轉換代碼
    Person *p = [Person mj_objectWithKeyValues:dict];

2.具體的轉換過程

在不考慮CoreData的情況下，我們直接來看轉換的核心代碼的方法，主要就是mj_setKeyValues:context:方法來完成字典轉模型的工作

/**
 核心代碼：
 */
- (instancetype)mj_setKeyValues:(id)keyValues context:(NSManagedObjectContext *)context

把傳進來的數據轉換為字典

可以看到，傳進來的數據還可以是NSString 和 NSData類型，最后都被轉換為JSON格式的數據

    // NSObject+MJKeyValue.m
    // 獲得JSON對象
    keyValues = [keyValues mj_JSONObject];
    
--->

    if ([self isKindOfClass:[NSString class]]) {
        return [NSJSONSerialization JSONObjectWithData:[((NSString *)self) dataUsingEncoding:NSUTF8StringEncoding] options:kNilOptions error:nil];
    } else if ([self isKindOfClass:[NSData class]]) {
        return [NSJSONSerialization JSONObjectWithData:(NSData *)self options:kNilOptions error:nil];
    }
    
    // 返回字典
    return self.mj_keyValues;

獲取轉換的白名單和黑名單

首先檢查名單是不是存在，如果存在，就直接返回；不存在，則根據方法mj_totalAllowedPropertyNames來獲取名單，然后返回

    // NSObject+MJKeyValue.m
    Class clazz = [self class];
    NSArray *allowedPropertyNames = [clazz mj_totalAllowedPropertyNames];
    NSArray *ignoredPropertyNames = [clazz mj_totalIgnoredPropertyNames];

--->
    // NSObject+MJClass.m
    + (NSMutableArray *)mj_totalObjectsWithSelector:(SEL)selector key:(const char *)key
    {
        NSMutableArray *array = [self dictForKey:key][NSStringFromClass(self)];
        if (array) return array;
        
        // 創建、存儲
        [self dictForKey:key][NSStringFromClass(self)] = array = [NSMutableArray array];
        
        if ([self respondsToSelector:selector]) {
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
            NSArray *subArray = [self performSelector:selector];
    #pragma clang diagnostic pop
            if (subArray) {
                [array addObjectsFromArray:subArray];
            }
        }
        
        [self mj_enumerateAllClasses:^(__unsafe_unretained Class c, BOOL *stop) {
            NSArray *subArray = objc_getAssociatedObject(c, key);
            [array addObjectsFromArray:subArray];
        }];
        return array;
    }

根據上述的名單，來判斷屬性是否需要被忽略

    // 檢測是否被忽略
    if (allowedPropertyNames.count && ![allowedPropertyNames containsObject:property.name]) return;
    if ([ignoredPropertyNames containsObject:property.name]) return;

遍歷成員變量

+ (void)mj_enumerateProperties:(MJPropertiesEnumeration)enumeration遍歷所有的屬性。屬性會先從緩存cachedProperties中取，如果存在，直接返回；如果不存在，就遍歷類來獲取屬性列表，創建MJProperty對象，并設置它的name(屬性名)、type(數據類型)、srcClass(來源類)等等；同時，還會設置propertyKeysDict(類對應的字典中的所有key) 和 objectClassInArrayDict(類對應的字典數組中的模型類)。

    // NSObject+MJProperty.m
    // 獲得成員變量
    NSArray *cachedProperties = [self properties];
    
    // 遍歷成員變量
    BOOL stop = NO;
    for (MJProperty *property in cachedProperties) {
        enumeration(property, &stop);
        if (stop) break;
    }
    
---->

    + (NSMutableArray *)properties
    {
        NSMutableArray *cachedProperties = [self dictForKey:&MJCachedPropertiesKey][NSStringFromClass(self)];
        
        if (cachedProperties == nil) {
            cachedProperties = [NSMutableArray array];
            
            [self mj_enumerateClasses:^(__unsafe_unretained Class c, BOOL *stop) {
                // 1.獲得所有的成員變量
                unsigned int outCount = 0;
                objc_property_t *properties = class_copyPropertyList(c, &outCount);
                
                // 2.遍歷每一個成員變量
                for (unsigned int i = 0; i<outCount; i++) {
                    MJProperty *property = [MJProperty cachedPropertyWithProperty:properties[i]];
                    
                    NSLog(@"%@ - %@", property.name, property.srcClass);
                    // 過濾掉Foundation框架類里面的屬性
                    if ([MJFoundation isClassFromFoundation:property.srcClass]) continue;
                    property.srcClass = c;
                    [property setOriginKey:[self propertyKey:property.name] forClass:self];
                    [property setObjectClassInArray:[self propertyObjectClassInArray:property.name] forClass:self];
                    [cachedProperties addObject:property];
                }
                
                // 3.釋放內存
                free(properties);
            }];
            
            [self dictForKey:&MJCachedPropertiesKey][NSStringFromClass(self)] = cachedProperties;
        }
        
        return cachedProperties;
    }    

在上述設置模型屬性時，會調用mj_replacedKeyFromPropertyName查看是否需要替換為新的鍵值。通常，特殊字符如：id、description不能作為對象屬性名，所以如果確實需要該屬性名時，可以用ID、desc等代替，然后就需要實現該方法做替換，使對象的ID屬性名對應字典中的id鍵。

    [property setOriginKey:[self propertyKey:property.name] forClass:self];
    
---->
    
    // NSObject+MJProperty.m
    + (id)propertyKey:(NSString *)propertyName
    {
        ...
        // 查看有沒有需要替換的key
        if ((!key || [key isEqual:propertyName]) && [self respondsToSelector:@selector(mj_replacedKeyFromPropertyName)]) {
            key = [self mj_replacedKeyFromPropertyName][propertyName];
        }
        ...
    }

取出字典中的屬性值

根據變量名獲取字典中對應的值

    // 取出屬性值
    id value;
    NSArray *propertyKeyses = [property propertyKeysForClass:clazz];
    for (NSArray *propertyKeys in propertyKeyses) {
        value = keyValues;
        for (MJPropertyKey *propertyKey in propertyKeys) {
            value = [propertyKey valueInObject:value];
        }
        if (value) break;
    }

過濾值

如果用戶需要對取得的字典中的值進行特殊處理，則需要實現mj_newValueFromOldValue:property:方法，并返回對應key的新值。如修改日期格式等等

    // NSObject+MJKeyValue.m
    // 值的過濾
    id newValue = [clazz mj_getNewValueFromObject:self oldValue:value property:property];
    if (newValue != value) { // 有過濾后的新值
        [property setValue:newValue forObject:self];
        return;
    }
    
---->

    // NSObject+MJProperty.m
    // 如果有實現方法
    if ([object respondsToSelector:@selector(mj_newValueFromOldValue:property:)]) {
        return [object mj_newValueFromOldValue:oldValue property:property];
    }
    // 兼容舊版本
    if ([self respondsToSelector:@selector(newValueFromOldValue:property:)]) {
        return [self performSelector:@selector(newValueFromOldValue:property:)  withObject:oldValue  withObject:property];
    }
    
    // 查看靜態設置
    __block id newValue = oldValue;
    [self mj_enumerateAllClasses:^(__unsafe_unretained Class c, BOOL *stop) {
        MJNewValueFromOldValue block = objc_getAssociatedObject(c, &MJNewValueFromOldValueKey);
        if (block) {
            newValue = block(object, oldValue, property);
            *stop = YES;
        }
    }];
    return newValue;    

獲取變量的類型

根據property屬性獲取屬性的類型（基本數據類型則為nil）和數組中的成員對象類型（如果屬性不是數組，則為空對象類型）

    // 復雜處理
    MJPropertyType *type = property.type;
    Class propertyClass = type.typeClass;
    Class objectClass = [property objectClassInArrayForClass:[self class]];

轉換為可變類型

如果對象的屬性是可變類型，但是從字典中取出的值都是不可變類型，那么需要把取出的值轉換為可變類型

    // 不可變 -> 可變處理
    if (propertyClass == [NSMutableArray class] && [value isKindOfClass:[NSArray class]]) {
        value = [NSMutableArray arrayWithArray:value];
    } else if (propertyClass == [NSMutableDictionary class] && [value isKindOfClass:[NSDictionary class]]) {
        value = [NSMutableDictionary dictionaryWithDictionary:value];
    } else if (propertyClass == [NSMutableString class] && [value isKindOfClass:[NSString class]]) {
        value = [NSMutableString stringWithString:value];
    } else if (propertyClass == [NSMutableData class] && [value isKindOfClass:[NSData class]]) {
        value = [NSMutableData dataWithData:value];
    }

模型屬性

這里用到了是不是Foundation的判斷，如果屬性是自定義屬性，就遞歸調用mj_objectWithKeyValues再次進行賦值

    if (!type.isFromFoundation && propertyClass) { // 模型屬性
        value = [propertyClass mj_objectWithKeyValues:value context:context];
    }

數組屬性

如果是NSURL的對象類型，就獲取它的url字符串，然后組合成數組；如果是其它對象類型，就調用mj_objectArrayWithKeyValuesArray::轉換為模型數組

    if (objectClass) {
        if (objectClass == [NSURL class] && [value isKindOfClass:[NSArray class]]) {
            // string array -> url array
            NSMutableArray *urlArray = [NSMutableArray array];
            for (NSString *string in value) {
                if (![string isKindOfClass:[NSString class]]) continue;
                [urlArray addObject:string.mj_url];
            }
            value = urlArray;
        } else { // 字典數組-->模型數組
            value = [objectClass mj_objectArrayWithKeyValuesArray:value context:context];
        }
    }

處理模型屬性和數組屬性之外的其它屬性

如果屬性的類型和字典中對應的值的類型不匹配，就進行轉換，如：NSNumber -> NSString，NSURL -> NSString，NSString -> NSURL, NSString -> NSURL。另外，針對屬性是布爾類型，而值是字符串：yes/true、no/false（忽略大小寫情況），則轉換為YES、NO的包裝類型。最后，如果屬性和值的類型依然不匹配，那么就把值設為空，給后面KVC使用

    if (propertyClass == [NSString class]) {
        if ([value isKindOfClass:[NSNumber class]]) {
            // NSNumber -> NSString
            value = [value description];
        } else if ([value isKindOfClass:[NSURL class]]) {
            // NSURL -> NSString
            value = [value absoluteString];
        }
    } else if ([value isKindOfClass:[NSString class]]) {
        if (propertyClass == [NSURL class]) {
            // NSString -> NSURL
            // 字符串轉碼
            value = [value mj_url];
        } else if (type.isNumberType) {
            NSString *oldValue = value;
            
            // NSString -> NSNumber
            if (type.typeClass == [NSDecimalNumber class]) {
                value = [NSDecimalNumber decimalNumberWithString:oldValue];
            } else {
                value = [numberFormatter_ numberFromString:oldValue];
            }
            
            // 如果是BOOL
            if (type.isBoolType) {
                // 字符串轉BOOL（字符串沒有charValue方法）
                // 系統會調用字符串的charValue轉為BOOL類型
                NSString *lower = [oldValue lowercaseString];
                if ([lower isEqualToString:@"yes"] || [lower isEqualToString:@"true"]) {
                    value = @YES;
                } else if ([lower isEqualToString:@"no"] || [lower isEqualToString:@"false"]) {
                    value = @NO;
                }
            }
        }
    }
    
    // value和property類型不匹配
    if (propertyClass && ![value isKindOfClass:propertyClass]) {
        value = nil;
    }

賦值

利用KVC賦值

    [property setValue:value forObject:self];

歸檔

MJExtensionCodingImplementation這個宏表明對象支持歸檔，通過分類支持NSCoding協議，實現歸檔和解檔的方法，我們可以直接把對象歸檔和解檔，十分方便

宏定義函數

這個宏可以構建錯誤日志并輸出，方便調試。同時，對于宏替換不是十分了解的時候，可以使用預處理命令，把文件的宏全部替換后，就可以十分方便的看到宏被替換后的代碼模樣：

# clang -E 源文件 [-o 目標文件]

    // 判斷參數是不是字典
    MJExtensionAssertError([keyValues isKindOfClass:[NSDictionary class]], self, [self class], @"keyValues參數不是一個字典");

---->
    // MJExtensionConst.h
    #define MJExtensionAssertError(condition, returnValue, clazz, msg) \
    [clazz setMj_error:nil]; \
    if ((condition) == NO) { \
        MJExtensionBuildError(clazz, msg); \
        return returnValue;\
    }

MJExtension的分析到此結束，有不足之處，歡迎斧正。

參考資料

MJExtension源碼解析

MJExtension源碼閱讀

跟著MJExtension實現簡單的字典轉模型框架