您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

動手寫一個 YYModel 精簡版:Runtime 與 JSON 轉 Model 全過程

編輯:iOS 開發基礎

讀完這篇文章,你也能自己寫一個 YYModel 這樣的神器。它形式上像源碼解析,但不止於解析,更是實戰——因為我一直覺得,一個東西必須自己寫一遍才算真的學會,光讀源碼印象不會太深。所以,開始吧。

先說明兩點:為了簡單起見,本文只實現一個精簡版,YYModel 功能很多,這裡只做最核心的 JSON → Model;文章最後會給出完整代碼。

從 JSON 映射到 Model 的原理

回想一下我們平時是怎麼用這類庫的:拿到一份 JSON,把裡面的字段(name、page 等)聲明成 Model 的屬性,然後庫會自動把 JSON 裡對應字段的值賦給這些屬性。

屬性用 @property 聲明,編譯器會幫我們生成 get、set 方法,我們寫的點語法其實就是在調用這對方法。而在 Objective-C 裡,所有 [obj method] 形式的方法調用最終都會被轉換成 objc_msgSend(...) 的形式。

所以對一個庫來說,想調用你 Model 的 setter,用 objc_msgSend(...) 是最容易的路。JSON 映射到 Model 的原理,說白了就是調用這個函數。

整個流程因此非常清晰:你給我一個 Model 類,我用 runtime 的各種函數拿到它所有的屬性和對應的 get、set,判斷完類型之後,調用 objc_msgSend(...)。說起來真的簡單,做起來有點麻煩。

前期準備:封裝 runtime 信息

為了後續方便,需要把一些關鍵東西封裝起來:ivar、property、method,也就是實例變量、屬性和方法。嚴格說這個精簡版用不到 method 和 ivar 的封裝,但為了完整性我還是寫了。

YYModel 只有 4 個文件(兩對 .h/.m),我重寫時把所有能拆的類都拆成了獨立的 .h/.m,並把前綴換成 CP(copy 的意思),這樣代碼結構更清楚。

封裝 Ivar

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "CPCommon.h"

@interface CPClassIvarInfo : NSObject
@property (nonatomic, assign, readonly) Ivar ivar;
@property (nonatomic, strong, readonly) NSString *name;
@property (nonatomic, strong, readonly) NSString *typeEncoding;
@property (nonatomic, assign, readonly) CPEncodingType type;
- (instancetype)initWithIvar:(Ivar)ivar;
@end

Ivar 代表一個實例變量,所有和實例變量相關的操作都要把它傳進去。name 是變量名,typeEncoding 是類型編碼(比如 int 的編碼是 i,可以用 @encode(int) 查看),type 則是自定義枚舉,描述 YYModel 約定的類型。

一個強大的枚舉

新建一個公共文件 CPCommon,把 CPEncodingType 寫在這裡。這個枚舉要一口氣表示三種信息:普通類型(int、double、object)、關鍵詞修飾(const)、以及 Property 的屬性修飾(nonatomic、weak、retain)。

做法是用位運算:低 8 位表示第一種,中間 8 位表示第二種,高 8 位表示第三種,再分別定義三個 mask。想知道某個類型屬於哪一類,只要拿它和對應的 mask 做按位與(&)就行。

typedef NS_OPTIONS(NSUInteger, CPEncodingType) {
    CPEncodingTypeMask            = 0xFF,     // 8 bit
    CPEncodingTypeUnknown         = 0,
    CPEncodingTypeVoid            = 1,
    CPEncodingTypeBool            = 2,
    CPEncodingTypeInt8            = 3,
    CPEncodingTypeUInt8           = 4,
    CPEncodingTypeInt16           = 5,
    CPEncodingTypeUInt16          = 6,
    CPEncodingTypeInt32           = 7,
    CPEncodingTypeUInt32          = 8,
    CPEncodingTypeInt64           = 9,
    CPEncodingTypeUInt64          = 10,
    CPEncodingTypeFloat           = 11,
    CPEncodingTypeDouble          = 12,
    CPEncodingTypeLongDouble      = 13,
    CPEncodingTypeObject          = 14,
    CPEncodingTypeClass           = 15,
    CPEncodingTypeSEL             = 16,
    CPEncodingTypeBlock           = 17,
    CPEncodingTypePointer         = 18,
    CPEncodingTypeStruct          = 19,
    CPEncodingTypeUnion           = 20,
    CPEncodingTypeCString         = 21,
    CPEncodingTypeCArray          = 22,

    CPEncodingTypeQualifierMask   = 0xFF00,   // 16 bit
    CPEncodingTypeQualifierConst  = 1 << 8,
    CPEncodingTypeQualifierIn     = 1 << 9,
    CPEncodingTypeQualifierInout  = 1 << 10,
    CPEncodingTypeQualifierOut    = 1 << 11,
    CPEncodingTypeQualifierBycopy = 1 << 12,
    CPEncodingTypeQualifierByref  = 1 << 13,
    CPEncodingTypeQualifierOneway = 1 << 14,

    CPEncodingTypePropertyMask         = 0xFF0000,  // 24 bit
    CPEncodingTypePropertyReadonly     = 1 << 16,
    CPEncodingTypePropertyCopy         = 1 << 17,
    CPEncodingTypePropertyRetain       = 1 << 18,
    CPEncodingTypePropertyNonatomic    = 1 << 19,
    CPEncodingTypePropertyWeak         = 1 << 20,
    CPEncodingTypePropertyCustomGetter = 1 << 21,
    CPEncodingTypePropertyCustomSetter = 1 << 22,
    CPEncodingTypePropertyDynamic      = 1 << 23,
};

假設手上有一個類型 CPEncodingType type = CPEncodingTypeDouble,但不知道它是什麼,只要這樣問:

NSLog(@"%lu", type & CPEncodingTypeMask);   // 輸出 12

而枚舉裡 CPEncodingTypeDouble 恰好等於 12。如果多個值混在一起:

CPEncodingType type = CPEncodingTypeDouble | CPEncodingTypePropertyRetain;
NSLog(@"%lu", type & CPEncodingTypePropertyMask);   // 輸出 262144,即 1<<18
NSLog(@"%lu", type & CPEncodingTypeMask);           // 輸出 12

這種玩法在讀 YYModel 之前我沒見過,算是打開了新世界。

接著還需要一個函數,把類型編碼(Type Encoding)轉成上面的枚舉值。它很簡單,只是有點長:

CPEncodingType CPEncodingGetType(const char *typeEncoding) {
    char *type = (char *)typeEncoding;
    if (!type) return CPEncodingTypeUnknown;
    size_t len = strlen(type);
    if (len == 0) return CPEncodingTypeUnknown;

    CPEncodingType qualifier = 0;
    bool prefix = true;
    while (prefix) {
        switch (*type) {
            case 'r': { qualifier |= CPEncodingTypeQualifierConst;  type++; } break;
            case 'n': { qualifier |= CPEncodingTypeQualifierIn;     type++; } break;
            case 'N': { qualifier |= CPEncodingTypeQualifierInout;  type++; } break;
            case 'o': { qualifier |= CPEncodingTypeQualifierOut;    type++; } break;
            case 'O': { qualifier |= CPEncodingTypeQualifierBycopy; type++; } break;
            case 'R': { qualifier |= CPEncodingTypeQualifierByref;  type++; } break;
            case 'V': { qualifier |= CPEncodingTypeQualifierOneway; type++; } break;
            default:  { prefix = false; } break;
        }
    }

    len = strlen(type);
    if (len == 0) return CPEncodingTypeUnknown | qualifier;

    switch (*type) {
        case 'v': return CPEncodingTypeVoid | qualifier;
        case 'B': return CPEncodingTypeBool | qualifier;
        case 'c': return CPEncodingTypeInt8 | qualifier;
        case 'C': return CPEncodingTypeUInt8 | qualifier;
        case 's': return CPEncodingTypeInt16 | qualifier;
        case 'S': return CPEncodingTypeUInt16 | qualifier;
        case 'i': return CPEncodingTypeInt32 | qualifier;
        case 'I': return CPEncodingTypeUInt32 | qualifier;
        case 'l': return CPEncodingTypeInt32 | qualifier;
        case 'L': return CPEncodingTypeUInt32 | qualifier;
        case 'q': return CPEncodingTypeInt64 | qualifier;
        case 'Q': return CPEncodingTypeUInt64 | qualifier;
        case 'f': return CPEncodingTypeFloat | qualifier;
        case 'd': return CPEncodingTypeDouble | qualifier;
        case 'D': return CPEncodingTypeLongDouble | qualifier;
        case '#': return CPEncodingTypeClass | qualifier;
        case ':': return CPEncodingTypeSEL | qualifier;
        case '*': return CPEncodingTypeCString | qualifier;
        case '^': return CPEncodingTypePointer | qualifier;
        case '[': return CPEncodingTypeCArray | qualifier;
        case '(': return CPEncodingTypeUnion | qualifier;
        case '{': return CPEncodingTypeStruct | qualifier;
        case '@': {
            if (len == 2 && *(type + 1) == '?') return CPEncodingTypeBlock | qualifier;
            else return CPEncodingTypeObject | qualifier;
        }
        default: return CPEncodingTypeUnknown | qualifier;
    }
}

回到 CPClassIvarInfo 的實現:

- (instancetype)initWithIvar:(Ivar)ivar {
    if (!ivar) { return nil; }
    self = [super init];
    if (self) {
        _ivar = ivar;
        const char *name = ivar_getName(ivar);
        if (name) { _name = [NSString stringWithUTF8String:name]; }
        const char *typeEncoding = ivar_getTypeEncoding(ivar);
        if (typeEncoding) {
            _typeEncoding = [NSString stringWithUTF8String:typeEncoding];
            _type = CPEncodingGetType(typeEncoding);
        }
    }
    return self;
}

只有一個方法,用到兩個 runtime 函數:ivar_getName(ivar) 和 ivar_getTypeEncoding(ivar)。

封裝 Method

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

NS_ASSUME_NONNULL_BEGIN

@interface CPClassMethodInfo : NSObject
@property (nonatomic, assign, readonly) Method method;
@property (nonatomic, strong, readonly) NSString *name;
@property (nonatomic, assign, readonly) SEL sel;
@property (nonatomic, assign, readonly) IMP imp;
@property (nonatomic, strong, readonly) NSString *typeEncoding;
@property (nonatomic, strong, readonly) NSString *returnTypeEncoding;
@property (nullable, nonatomic, strong, readonly) NSArray *argumentTypeEncodings;
- (instancetype)initWithMethod:(Method)method;
@end

NS_ASSUME_NONNULL_END

順帶說一下 Objective-C 的 Optional。NS_ASSUME_NONNULL_BEGIN 和 NS_ASSUME_NONNULL_END 成對出現,因為 Swift 能和 Objective-C 混用,而 Swift 有 Optional 概念,Objective-C 沒有,於是有了 _Nullable 和 _Nonnull 這兩個關鍵字,可以標在變量、方法返回值和參數上:

@property (nonatomic, strong) NSString  * _Nonnull string;
- (NSString *_Nonnull)method:(NSString *_Nonnull)string;

也可以這樣用:

@property (nullable, nonatomic, strong) NSString  *string;
- (nullable NSString *)method:(nullable NSString *)string;

注意這些關鍵詞只能修飾指針。一旦你在某處寫了 nullable,編譯器就會對其他未標註的指針報警告:Pointer is missing a nullability type specifier。這時可以用 NS_ASSUME_NONNULL_BEGIN / END 把整個區域包起來,表示只有標了 nullable 的地方才可空。

回到 CPClassMethodInfo:method 表示一個方法;name 是方法名;sel 和 imp 是一對對應關係,對象的所有方法都存在一張方法表裡,通過 sel 能找到對應的 imp;typeEncoding 是參數和返回值的編碼;returnTypeEncoding 是返回值編碼;argumentTypeEncodings 是所有參數的編碼。

- (instancetype)initWithMethod:(Method)method {
    if (!method) { return nil; }
    self = [super init];
    if (self) {
        _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 *returnTypeEncoding = method_copyReturnType(method);
        if (returnTypeEncoding) {
            _returnTypeEncoding = [NSString stringWithUTF8String:returnTypeEncoding];
            free(returnTypeEncoding);
        }

        // 得到參數的數目,遍歷取得所有參數的類型
        unsigned int count = method_getNumberOfArguments(method);
        if (count > 0) {
            NSMutableArray *types = [[NSMutableArray alloc] initWithCapacity:10];
            for (unsigned int i = 0; i < count; i++) {
                char *argumentsType = method_copyArgumentType(method, i);
                NSString *type = argumentsType ? [NSString stringWithUTF8String:argumentsType] : nil;
                [types addObject:type ? type : @""];
                if (argumentsType) { free(argumentsType); }
            }
            _argumentTypeEncodings = types;
        }
    }
    return self;
}

封裝 Property

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "CPCommon.h"

NS_ASSUME_NONNULL_BEGIN

@interface CPClassPropertyInfo : NSObject
@property (nonatomic, assign, readonly) objc_property_t property;
@property (nonatomic, strong, readonly) NSString *name;
@property (nonatomic, assign, readonly) CPEncodingType type;
@property (nonatomic, strong, readonly) NSString *typdEncoding;
@property (nonatomic, strong, readonly) NSString *ivarName;
@property (nullable, nonatomic, assign, readonly) Class cls;
@property (nonatomic, assign, readonly) SEL getter;
@property (nonatomic, assign, readonly) SEL setter;
- (instancetype)initWithProperty:(objc_property_t)property;
@end

NS_ASSUME_NONNULL_END

這裡尤其要注意 type 和 typdEncoding 兩個屬性,建議自己動手調試一下。核心代碼如下:

CPEncodingType type = 0;
unsigned int outCount;
objc_property_attribute_t *attrs = property_copyAttributeList(property, &outCount);

// 遍歷所有的 Property 屬性
for (unsigned int i = 0; i < outCount; i++) {
    switch (attrs[i].name[0]) {
        case 'T':
            if (attrs[i].value) {
                _typdEncoding = [NSString stringWithUTF8String:attrs[i].value];
                type = CPEncodingGetType(attrs[i].value);
                if ((type & CPEncodingTypeMask) == CPEncodingTypeObject) {
                    // 如果該類型為一個對象,比如 @"NSString",截取中間部分得到 NSString
                    // 目的是拿到這個類的 Class
                    size_t len = strlen(attrs[i].value);
                    if (len > 3) {
                        char name[len - 2];
                        name[len - 3] = '\0';
                        memcpy(name, attrs[i].value + 2, len - 3);
                        _cls = objc_getClass(name);
                    }
                }
            }
            break;
        case 'V':
            if (attrs[i].value) {
                _ivarName = [NSString stringWithUTF8String:attrs[i].value];
            }
            break;
        case 'R': type |= CPEncodingTypePropertyReadonly;     break;
        case 'C': type |= CPEncodingTypePropertyCopy;         break;
        case '&': type |= CPEncodingTypePropertyRetain;       break;
        case 'N': type |= CPEncodingTypePropertyNonatomic;    break;
        case 'D': type |= CPEncodingTypePropertyDynamic;      break;
        case 'W': type |= CPEncodingTypePropertyWeak;         break;
        case 'G':
            type |= CPEncodingTypePropertyCustomGetter;
            if (attrs[i].value) {
                _getter = NSSelectorFromString([NSString stringWithUTF8String:attrs[i].value]);
            }
            break;
        case 'S':
            type |= CPEncodingTypePropertyCustomSetter;
            if (attrs[i].value) {
                _setter = NSSelectorFromString([NSString stringWithUTF8String:attrs[i].value]);
            }
            break;
        default: break;
    }
}

property_copyAttributeList 返回一個指向 objc_property_attribute_t 的指針,這個結構體是這樣的:

typedef struct {
    const char *name;    /**< The name of the attribute */
    const char *value;   /**< The value of the attribute (usually empty) */
} objc_property_attribute_t;

說是指針,實際上它指向的是一個結構體數組的第一個元素。每個元素描述 Property 的一條屬性。

想看具體存了什麼,可以跑這段代碼:

Class cls = objc_getClass("CPBook");
objc_property_t property = class_getProperty(cls, "name");
const char *attr = property_getAttributes(property);
NSLog(@"%s", attr);

假設 CPBook 有個 name 屬性,輸出會是:

T@"NSString",&,N,V_name

也就是說這個數組有 4 個元素:第一個 name = T、value = @"NSString";第二個 name = &、無值;第三個 name = N、無值;第四個 name = V、value = _name。可以自己驗證:

Class cls = objc_getClass("CPBook");
unsigned int acount;
objc_property_t *prop = class_copyPropertyList(cls, &acount);
objc_property_attribute_t *attr1 = property_copyAttributeList(prop[2], &acount);

NSLog(@"%s", attr1[0].name);   NSLog(@"%s", attr1[0].value);
NSLog(@"-------------------");
NSLog(@"%s", attr1[1].name);   NSLog(@"%s", attr1[1].value);
NSLog(@"-------------------");
NSLog(@"%s", attr1[2].name);   NSLog(@"%s", attr1[2].value);
NSLog(@"-------------------");
NSLog(@"%s", attr1[3].name);   NSLog(@"%s", attr1[3].value);

於是 switch 裡只要匹配到 T 就能拿到屬性的類型編碼,進而拿到 Class;匹配到 V 就能拿到實例變量名。這些字母的含義查一下文檔就很清楚。

加上 getter、setter 的兜底邏輯,整個初始化方法就完整了:

if (_name.length) {
    if (!_getter) {
        _getter = NSSelectorFromString(_name);
    }
    if (!_setter) {
        _setter = NSSelectorFromString([NSString stringWithFormat:@"set%@%@:",
                                        [_name substringToIndex:1].uppercaseString,
                                        [_name substringFromIndex:1]]);
    }
}

封裝 Class

#import <Foundation/Foundation.h>

@class CPClassInfo;
@class CPClassIvarInfo;
@class CPClassMethodInfo;
@class CPClassPropertyInfo;

NS_ASSUME_NONNULL_BEGIN

@interface CPClassInfo : NSObject
@property (nonatomic, assign, readonly) Class cls;
@property (nonatomic, assign, readonly) Class superClass;
@property (nonatomic, assign, readonly) Class metaClass;
@property (nonatomic, readonly) BOOL isMeta;
@property (nonatomic, strong, readonly) NSString *name;
@property (nullable, nonatomic, strong, readonly) CPClassInfo *superClassInfo;
@property (nullable, nonatomic, strong, readonly) NSDictionary *ivarInfos;
@property (nullable, nonatomic, strong, readonly) NSDictionary *methodInfos;
@property (nullable, nonatomic, strong, readonly) NSDictionary *propertyInfos;
- (void)setNeedUpadte;
- (BOOL)needUpdate;
+ (nullable instancetype)classInfoWithClass:(Class)cls;
@end

NS_ASSUME_NONNULL_END

獲取 Class 的方式有多種:model.class、[model class]、[CPTestModel class]、object_getClass(model),注意 object_getClass() 和其他幾種有些差別。最後三個 NSDictionary 用來存所有的 ivar、Method、Property。

類有可能在運行期被改變(增刪方法或屬性),所以提供了兩個方法用來通知 CPClassInfo 重新獲取信息:

- (void)setNeedUpadte;
- (BOOL)needUpdate;

初始化方法如下:

- (instancetype)initWithClass:(Class)cls {
    if (!cls) { return nil; }
    self = [super init];
    if (self) {
        _cls = cls;
        _superClass = class_getSuperclass(cls);
        _isMeta = class_isMetaClass(cls);
        if (_isMeta) {
            _metaClass = objc_getMetaClass(class_getName(cls));
        }
        _name = NSStringFromClass(cls);
        [self _update];
        _superClassInfo = [self.class classInfoWithClass:_superClass];
    }
    return self;
}

注意它和頭文件裡的 classInfoWithClass: 不是同一個方法,頭文件那個負責緩存——畢竟每次都實例化開銷不小。

_update 方法把「可能會變」的那部分邏輯單獨抽出來:

- (void)_update {
    _ivarInfos = nil;
    _propertyInfos = nil;
    _methodInfos = nil;

    unsigned int ivarCount = 0;
    Ivar *ivars = class_copyIvarList(self.cls, &ivarCount);
    if (ivars) {
        _ivarInfos = [NSMutableDictionary new];
        for (unsigned int i = 0; i < ivarCount; i++) {
            CPClassIvarInfo *ivarInfo = [[CPClassIvarInfo alloc] initWithIvar:ivars[i]];
            if (ivarInfo.name) {
                [_ivarInfos setValue:ivarInfo forKey:ivarInfo.name];
            }
        }
        free(ivars);
    }

    unsigned int propertyCount = 0;
    objc_property_t *properties = class_copyPropertyList(self.cls, &propertyCount);
    if (properties) {
        _propertyInfos = [NSMutableDictionary new];
        for (unsigned int i = 0; i < propertyCount; i++) {
            CPClassPropertyInfo *propertyInfo = [[CPClassPropertyInfo alloc] initWithProperty:properties[i]];
            if (propertyInfo.name) {
                [_propertyInfos setValue:propertyInfo forKey:propertyInfo.name];
            }
        }
        free(properties);
    }

    unsigned int methodCount = 0;
    Method *methods = class_copyMethodList(self.cls, &methodCount);
    if (methods) {
        _methodInfos = [NSMutableDictionary new];
        for (unsigned int i = 0; i < methodCount; i++) {
            CPClassMethodInfo *methodInfo = [[CPClassMethodInfo alloc] initWithMethod:methods[i]];
            if (methodInfo.name) {
                [_methodInfos setValue:methodInfo forKey:methodInfo.name];
            }
        }
        free(methods);
    }

    if (!_ivarInfos)     { _ivarInfos = @{}; }
    if (!_methodInfos)   { _methodInfos = @{}; }
    if (!_propertyInfos) { _propertyInfos = @{}; }

    _needUpdate = NO;
}

本質上就是拿到一個類所有的 ivar、Method、Property——一個類發生變化,主要也就是這三樣在變。

_needUpdate 是標識是否發生變化的全局變量,藏在 .m 的 ivar 裡,不對外暴露:

@implementation CPClassInfo {
    BOOL _needUpdate;
}

對外只暴露兩個方法:

- (BOOL)needUpdate { return _needUpdate; }
- (void)setNeedUpadte { _needUpdate = YES; }

最後是帶緩存的 classInfoWithClass::

+ (instancetype)classInfoWithClass:(Class)cls {
    if (!cls) { return nil; }

    static NSMutableDictionary *metaCache;
    static NSMutableDictionary *classCache;
    static dispatch_semaphore_t lock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        metaCache = [NSMutableDictionary dictionary];
        classCache = [NSMutableDictionary dictionary];
        lock = dispatch_semaphore_create(1);
    });

    dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
    CPClassInfo *info;
    if (class_isMetaClass(cls)) {
        info = [metaCache valueForKey:NSStringFromClass(cls)];
    } else {
        info = [classCache valueForKey:NSStringFromClass(cls)];
    }
    if (info && info->_needUpdate) {
        [info _update];
    }
    dispatch_semaphore_signal(lock);

    if (!info) {
        info = [[CPClassInfo alloc] initWithClass:cls];
        if (info) {
            dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
            if (info.isMeta) {
                [metaCache setValue:info forKey:NSStringFromClass(cls)];
            } else {
                [classCache setValue:info forKey:NSStringFromClass(cls)];
            }
            dispatch_semaphore_signal(lock);
        }
    }
    return info;
}

兩個 NSMutableDictionary 聲明在靜態區,用 dispatch_once 保證只初始化一次。因為可能在多線程場景下被調用,所以用信號量 dispatch_semaphore_t 保證線程安全。信號量就像停車場:車滿了就等,有空位就放行。線程進入臨界區前必須先獲取信號量,用 dispatch_semaphore_wait() 獲取,用 dispatch_semaphore_signal() 釋放。

邏輯是:先查緩存,命中就取出並判斷是否需要刷新;未命中則乖乖實例化,然後寫入緩存。

繼續封裝:CPModelPropertyMeta 與 CPModelMeta

新建 CPMeta.h / CPMeta.m,在裡面寫兩個類:一個是對 Property 的再次封裝,一個是對 Class 的再次封裝。

#import <Foundation/Foundation.h>
#import "CPCommon.h"

@class CPClassInfo;
@class CPClassPropertyInfo;

typedef NS_ENUM(NSUInteger, CPEncodingNSType) {
    CPEncodingTypeNSUnknown = 0,
    CPEncodingTypeNSString,
    CPEncodingTypeNSMutableString,
    CPEncodingTypeNSValue,
    CPEncodingTypeNSNumber,
    CPEncodingTypeNSDecimalNumber,
    CPEncodingTypeNSData,
    CPEncodingTypeNSMutableData,
    CPEncodingTypeNSDate,
    CPEncodingTypeNSURL,
    CPEncodingTypeNSArray,
    CPEncodingTypeNSMutableArray,
    CPEncodingTypeNSDictionary,
    CPEncodingTypeNSMutableDictionary,
    CPEncodingTypeNSSet,
    CPEncodingTypeNSMutableSet,
};

@interface CPModelMeta : NSObject {
    @package
    CPClassInfo *_clsInfo;
    NSDictionary *_mapper;
    NSArray *_allPropertyMetas;
    NSUInteger _keyMappedCount;
    CPEncodingNSType _nsType;
}
+ (instancetype)metaWithClass:(Class)cls;
@end

@interface CPModelPropertyMeta : NSObject {
    @package
    NSString *_name;
    CPEncodingType _type;
    CPEncodingNSType _nsType;
    BOOL _isCNumber;
    Class _cls;
    Class _genericCls;
    SEL _getter;
    SEL _setter;
    BOOL _isKVCCompatible;
    NSString *_mappedToKey;
    CPClassPropertyInfo *_info;
}
+ (instancetype)modelWithClassInfo:(CPClassInfo *)clsInfo
                     propresytInfo:(CPClassPropertyInfo *)propertyInfo
                           generic:(Class)generic;
@end

新增的 CPEncodingNSType 枚舉是為了細化對象類型。上一個枚舉裡對象只有 CPEncodingTypeObject 一個值,沒法區分是 NSString 還是別的,而類型判斷在 JSON 轉換時至關重要,判錯就直接崩。

(在 YYModel 裡,這兩個類是和 NSObject+YYModel 擴展放在一起的,我為了看清楚把它們拆了出來,並把 @package 成員變量直接寫進 interface,這麼做並不合理,僅為教學方便。)

CPModelPropertyMeta 裡幾個不太直觀的成員變量:

  • _isCNumber:是否為 C 語言的數值類型,比如 int

  • _genericCls:精簡版沒用到,YYModel 可以用它給容器型屬性做轉換

  • _isKVCCompatible:是否支持 KVC

  • _mappedToKey:映射的 key,JSON 轉 Model 時根據它把同名字段的值賦給該屬性

為了判斷 NS 類型和是否為 C 類型,.m 裡有兩個函數:

#define force_inline __inline__ __attribute__((always_inline))

static force_inline CPEncodingNSType CPClassGetNSType(Class cls) {
    if (!cls) return CPEncodingTypeNSUnknown;
    if ([cls isSubclassOfClass:[NSMutableString class]])       return CPEncodingTypeNSMutableString;
    if ([cls isSubclassOfClass:[NSString class]])              return CPEncodingTypeNSString;
    if ([cls isSubclassOfClass:[NSDecimalNumber class]])       return CPEncodingTypeNSDecimalNumber;
    if ([cls isSubclassOfClass:[NSNumber class]])              return CPEncodingTypeNSNumber;
    if ([cls isSubclassOfClass:[NSValue class]])               return CPEncodingTypeNSValue;
    if ([cls isSubclassOfClass:[NSMutableData class]])         return CPEncodingTypeNSMutableData;
    if ([cls isSubclassOfClass:[NSData class]])                return CPEncodingTypeNSData;
    if ([cls isSubclassOfClass:[NSDate class]])                return CPEncodingTypeNSDate;
    if ([cls isSubclassOfClass:[NSURL class]])                 return CPEncodingTypeNSURL;
    if ([cls isSubclassOfClass:[NSMutableArray class]])        return CPEncodingTypeNSMutableArray;
    if ([cls isSubclassOfClass:[NSArray class]])               return CPEncodingTypeNSArray;
    if ([cls isSubclassOfClass:[NSMutableDictionary class]])   return CPEncodingTypeNSMutableDictionary;
    if ([cls isSubclassOfClass:[NSDictionary class]])          return CPEncodingTypeNSDictionary;
    if ([cls isSubclassOfClass:[NSMutableSet class]])          return CPEncodingTypeNSMutableSet;
    if ([cls isSubclassOfClass:[NSSet class]])                 return CPEncodingTypeNSSet;
    return CPEncodingTypeNSUnknown;
}

static force_inline BOOL CPEncodingTypeIsCNumber(CPEncodingType type) {
    switch (type & CPEncodingTypeMask) {
        case CPEncodingTypeBool:
        case CPEncodingTypeInt8:
        case CPEncodingTypeUInt8:
        case CPEncodingTypeInt16:
        case CPEncodingTypeUInt16:
        case CPEncodingTypeInt32:
        case CPEncodingTypeUInt32:
        case CPEncodingTypeInt64:
        case CPEncodingTypeUInt64:
        case CPEncodingTypeFloat:
        case CPEncodingTypeDouble:
        case CPEncodingTypeLongDouble: return YES;
        default: return NO;
    }
}

force_inline 修飾的函數叫內聯函數,調用時不是常規的壓棧彈棧,而是在編譯期直接把函數體嵌入調用處,類似宏替換。這麼做的原因是效率:函數調用本身有開銷,如果函數很小,內聯能省下這部分成本。

CPModelPropertyMeta 的初始化:

+ (instancetype)modelWithClassInfo:(CPClassInfo *)clsInfo
                     propresytInfo:(CPClassPropertyInfo *)propertyInfo
                           generic:(Class)generic {
    CPModelPropertyMeta *meta = [self new];
    meta->_name = propertyInfo.name;
    meta->_type = propertyInfo.type;
    meta->_info = propertyInfo;
    meta->_genericCls = generic;

    if ((meta->_type & CPEncodingTypeMask) == CPEncodingTypeObject) {
        meta->_nsType = CPClassGetNSType(propertyInfo.cls);
    } else {
        meta->_isCNumber = CPEncodingTypeIsCNumber(meta->_type);
    }

    meta->_cls = propertyInfo.cls;

    if (propertyInfo.getter) {
        if ([clsInfo.cls instancesRespondToSelector:propertyInfo.getter]) {
            meta->_getter = propertyInfo.getter;
        }
    }
    if (propertyInfo.setter) {
        if ([clsInfo.cls instancesRespondToSelector:propertyInfo.setter]) {
            meta->_setter = propertyInfo.setter;
        }
    }

    if (meta->_setter && meta->_getter) {
        switch (meta->_type & CPEncodingTypeMask) {
            case CPEncodingTypeBool:
            case CPEncodingTypeInt8:
            case CPEncodingTypeUInt8:
            case CPEncodingTypeInt16:
            case CPEncodingTypeUInt16:
            case CPEncodingTypeInt32:
            case CPEncodingTypeUInt32:
            case CPEncodingTypeInt64:
            case CPEncodingTypeUInt64:
            case CPEncodingTypeFloat:
            case CPEncodingTypeDouble:
            case CPEncodingTypeObject:
            case CPEncodingTypeClass:
            case CPEncodingTypeBlock:
            case CPEncodingTypeStruct:
            case CPEncodingTypeUnion: {
                meta->_isKVCCompatible = YES;
            } break;
            default: break;
        }
    }
    return meta;
}

邏輯就是:判斷是否為對象類型並拿到具體 NS 類型,否則判斷是否 C 數值類型,再取 getter/setter,最後判斷能否 KVC。

CPModelMeta 主要負責生成映射表 _mapper,也需要緩存,套路和前面一樣:

+ (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);
    CPModelMeta *meta = CFDictionaryGetValue(cache, (__bridge const void *)(cls));
    dispatch_semaphore_signal(lock);

    if (!meta || meta->_clsInfo.needUpdate) {
        meta = [[CPModelMeta 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;
}

緩存未命中就調用 initWithClass::

- (instancetype)initWithClass:(Class)cls {
    if (!cls) { return nil; }
    self = [super init];
    if (self) {
        CPClassInfo *clsInfo = [CPClassInfo classInfoWithClass:cls];
        NSMutableDictionary *allPropertyMetas = [NSMutableDictionary new];
        CPClassInfo *curClsInfo = clsInfo;

        // 連同當前類和父類的屬性一起收集(NSObject 和 NSProxy 沒有父類)
        while (curClsInfo && curClsInfo.superClass != nil) {
            for (CPClassPropertyInfo *propertyInfo in curClsInfo.propertyInfos.allValues) {
                if (!propertyInfo.name) continue;
                CPModelPropertyMeta *meta = [CPModelPropertyMeta modelWithClassInfo:clsInfo
                                                                     propresytInfo:propertyInfo
                                                                           generic:nil];
                if (!meta || !meta->_name) continue;
                if (!meta->_setter || !meta->_getter) continue;
                if (allPropertyMetas[meta->_name]) continue;
                allPropertyMetas[meta->_name] = meta;
            }
            curClsInfo = clsInfo.superClassInfo;
        }

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

        NSMutableDictionary *mapper = [NSMutableDictionary new];
        [allPropertyMetas enumerateKeysAndObjectsUsingBlock:^(NSString * _Nonnull name,
                                                              CPModelPropertyMeta * _Nonnull meta,
                                                              BOOL * _Nonnull stop) {
            meta->_mappedToKey = name;
            mapper[name] = meta;
        }];
        if (mapper.count) _mapper = mapper;

        _clsInfo = clsInfo;
        _keyMappedCount = _allPropertyMetas.count;
        _nsType = CPClassGetNSType(cls);
    }
    return self;
}

把 CPClassInfo 裡所有 propertyInfo 實例化成 CPModelPropertyMeta,順帶把父類的屬性也收進來,這樣即使你的 Model 有父類,父類的屬性也能被賦值。最後生成一張映射表,它是後續所有 JSON 轉換的關鍵。

從 JSON 到 Model 的轉換

現在進入正餐。先建一個 Category,取名 CPModel,只暴露一個接口:

#import <Foundation/Foundation.h>

@interface NSObject (CPModel)
+ (instancetype)modelWithJSON:(id)json;
@end

使用方只需要調用 + modelWithJSON: 就能完成轉換:

+ (instancetype)modelWithJSON:(id)json {
    NSDictionary *dic = [self _cp_dictionaryWithJSON:json];
    if (!dic || dic == (id)kCFNull) { return nil; }
    if (![dic isKindOfClass:[NSDictionary class]]) { return nil; }

    Class cls = [self class];
    NSObject *one = [cls new];
    if ([one modelSetWithDictionary:dic]) {
        return one;
    }
    return nil;
}

先把 JSON 轉成 NSDictionary,再實例化 Model,然後調用 - modelSetWithDictionary:。

JSON 轉 NSDictionary 很簡單:

+ (NSDictionary *)_cp_dictionaryWithJSON:(id)json {
    if (!json || json == (id)kCFNull) { return nil; }

    NSDictionary *dic = nil;
    NSData *data = nil;

    if ([json isKindOfClass:[NSDictionary class]]) {
        dic = json;
    } else if ([json isKindOfClass:[NSString class]]) {
        data = [(NSString *)json dataUsingEncoding:NSUTF8StringEncoding];
    } else if ([json isKindOfClass:[NSData class]]) {
        data = json;
    }

    if (data) {
        dic = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableLeaves error:nil];
        if (![dic isKindOfClass:[NSDictionary class]]) {
            dic = nil;
        }
    }
    return dic;
}

接著是核心的 - modelSetWithDictionary::

- (BOOL)modelSetWithDictionary:(NSDictionary *)dic {
    if (!dic || dic == (id)kCFNull) { return NO; }
    if (![dic isKindOfClass:[NSDictionary class]]) { return NO; }

    CPModelMeta *meta = [CPModelMeta metaWithClass:object_getClass(self)];   // ①
    if (meta->_keyMappedCount == 0) { return NO; }

    ModelSetContext context = {0};
    context.modelMeta = (__bridge void *)(meta);
    context.model = (__bridge void *)(self);
    context.dictionary = (__bridge void *)(dic);

    if (meta->_keyMappedCount >= dic.count) {
        CFDictionaryApplyFunction((CFDictionaryRef)dic, ModelSetWithDictionaryFunction, &context);
    }
    return YES;
}

這裡有個結構體,用來承載賦值所需的全部上下文:model(要賦值的對象)、modelMeta(含映射表)、dictionary(JSON 轉來的字典)。

typedef struct {
    void *modelMeta;
    void *model;
    void *dictionary;
} ModelSetContext;

關鍵是這一行:

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

它的作用是遍歷字典裡每一對 Key-Value,對每一對調用你傳入的函數。為什麼不用普通循環?作者在博客裡解釋過:相對於 Foundation 的方法,CoreFoundation 的方法性能更高,用 CFArrayApplyFunction() 和 CFDictionaryApplyFunction() 遍歷容器能帶來可觀的性能提升,代價是代碼寫起來麻煩一些。

static void ModelSetWithDictionaryFunction(const void *key, const void *value, void *context) {
    ModelSetContext *ctx = context;
    __unsafe_unretained CPModelMeta *modelMeta = (__bridge CPModelMeta *)(ctx->modelMeta);
    __unsafe_unretained CPModelPropertyMeta *propertyMeta =
        [modelMeta->_mapper objectForKey:(__bridge id)(key)];
    __unsafe_unretained id model = (__bridge id)(ctx->model);

    if (propertyMeta->_setter) {
        ModelSetValueForProperty(model, (__bridge __unsafe_unretained id)value, propertyMeta);
    }
}

變量前都加了 __unsafe_unretained,作者也解釋了原因:ARC 下默認聲明的對象是 strong 類型,賦值時可能產生 retain/release 調用;如果一個變量在生命週期內不會被釋放,用 unsafe_unretained 能省下不少開銷。另外,訪問帶 weak 屬性的變量時會調用 objc_loadWeak() 和 objc_storeWeak(),開銷更大,所以要避免。

根據 key(也就是 JSON 裡的字段名,必須和 Model 的屬性名一致才能匹配上;YYModel 还支持自定義映射表,這裡簡化了)從映射表取出 propertyMeta。此時具備了所有條件:目標 model、對應的 propertyMeta、以及 JSON 裡的值。接下來只要調用 setter 把值傳進去,這部分由 ModelSetValueForProperty() 完成。它裡面有大量類型判斷,我這裡只處理了 NSString、NSNumber 和普通 C 類型:

static void ModelSetValueForProperty(__unsafe_unretained id model,
                                     __unsafe_unretained id value,
                                     __unsafe_unretained CPModelPropertyMeta *meta) {
    if (meta->_isCNumber) {
        NSNumber *num = CPNSNumberCreateFromID(value);
        ModelSetNumberToProperty(model, num, meta);
        if (num) [num class];
    } else if (meta->_nsType) {
        if (value == (id)kCFNull) {
            ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter, (id)nil);
        } else {
            switch (meta->_nsType) {
                case CPEncodingTypeNSString:
                case CPEncodingTypeNSMutableString: {
                    if ([value isKindOfClass:[NSString class]]) {
                        if (meta->_nsType == CPEncodingTypeNSString) {
                            ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter, value);
                        } else {
                            ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter, ((NSString *)value).mutableCopy);
                        }
                    } else if ([value isKindOfClass:[NSNumber class]]) {
                        ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter,
                            (meta->_nsType == CPEncodingTypeNSString)
                            ? ((NSNumber *)value).stringValue
                            : ((NSNumber *)value).stringValue.mutableCopy);
                    } else if ([value isKindOfClass:[NSData class]]) {
                        NSMutableString *string = [[NSMutableString alloc] initWithData:value encoding:NSUTF8StringEncoding];
                        ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter, string);
                    } else if ([value isKindOfClass:[NSURL class]]) {
                        ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter,
                            (meta->_nsType == CPEncodingTypeNSString)
                            ? ((NSURL *)value).absoluteString
                            : ((NSURL *)value).absoluteString.mutableCopy);
                    } else if ([value isKindOfClass:[NSAttributedString class]]) {
                        ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter,
                            (meta->_nsType == CPEncodingTypeNSString)
                            ? ((NSAttributedString *)value).string
                            : ((NSAttributedString *)value).string.mutableCopy);
                    }
                } break;

                case CPEncodingTypeNSNumber: {
                    if ([value isKindOfClass:[NSNumber class]]) {
                        if (meta->_nsType == CPEncodingTypeNSNumber) {
                            ((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter, value);
                        }
                    }
                } break;

                default: break;
            }
        }
    }
}

拿其中一行來解釋 objc_msgSend 的用法:

((void (*)(id, SEL, id))(void *)& objc_msgSend)((id)model, meta->_setter, value);

默認情況下 objc_msgSend 的形態是 objc_msgSend(id, SEL):id 是調用方法的對象(這裡就是你的 Model),SEL 是要調用的方法(這裡是 setter)。但 setter 是有參數的,參數怎麼傳?靠強制類型轉換:

((void (*)(id, SEL, id))(void *)& objc_msgSend)

這告訴編譯器:這是一個無返回值、有三個參數(id、SEL、id)的函數。前兩個參數含義不變,第三個就是 setter 需要的入參。轉換之後,這個「變異版」就變成了上面那行代碼的樣子。

剩下的都是些繁瑣但簡單的類型判斷,耐心一行行看就能讀懂。

驗證

全部搞定之後,和原版 YYModel 一樣,你可以這樣測試:

CPTestModel *model = [CPTestModel modelWithJSON:@"{\"name\": \"Harry Potter\",\"index\": 512,\"number\": 10,\"num\": 100}"];

結尾

如果你真的親手寫完了這個精簡版,再回頭看完整版的 YYModel 會輕鬆很多。這篇文章把我讀 YYModel 源碼時覺得有用的東西整理出來分享給大家,如果有寫錯的地方,歡迎指正。

完整代碼見文末鏈接。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved