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

OC 分類屬性的 getter/setter 自動生成全過程

編輯:iOS 開發基礎

本文記錄如何讓 Objective-C 分類裡的屬性自動生成存取方法,完整走一遍從編碼到 runtime 的實現過程。

背景

分類在 iOS 開發中經常用到,而在分類裡加屬性也是常事。問題是分類不能添加實例變量,編譯器也不會為分類中的屬性生成 getter 與 setter,通常只能手寫。如果只是拿來存值,關聯對象足以勝任:

@interface NSObject (db_sqlite)
@property (nonatomic, assign) int db_rowid;
@end

@implementation NSObject (db_sqlite)
- (int)db_rowid {
    return [objc_getAssociatedObject(self, _cmd) intValue];
}

- (void)setDb_rowid:(int)db_rowid {
    objc_setAssociatedObject(self, @selector(db_rowid), @(db_rowid), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
@end

這是很常見的寫法。但要是再加幾個屬性,就得再抄幾遍——差別無非方法名和關聯策略,純體力活。理想狀態是像普通類的 @property 一樣自動生成。

要做到這一點,可以從兩處入手:編碼期(寫個 Xcode 插件,按鍵自動生成代碼,類似 Eclipse 的模板,不在本文範圍)和運行期(編碼階段只寫少量代碼,方法在運行時動態生成)。本文走第二條路,最終代碼見:https://github.com/NathanLi/iOSCategoryPropertyDynamicSupport

需求細化

目標是運行時為分類屬性生成 getter/setter,模仿普通 @property。細化一下:

  1. 只生成分類中我想要的 getter 與 setter;
  2. 屬性類型支持基礎類型、對象、結構體,且自動存取;
  3. 支持 assign、strong、copy、weak;
  4. 支持自定義的方法名;
  5. 支持 KVC;
  6. 支持 KVO;
  7. 不支持 atomic,只做 nonatomic。

第一步:標記需要動態生成的屬性

約定以 nl_ 為前綴:

@property (nonatomic, strong) id nl_object;

因為分類裡沒有實現,編譯會警告:

Property 'nl_object' requires method 'nl_object' to be defined - use @dynamic
or provide a method implementation in this category
Property 'nl_object' requires method 'setNl_object:' to be defined - use @dynamic
or provide a method implementation in this category

在分類實現裡加一行 @dynamic nl_object 即可消除。

第二步:消息機制為什麼能兜住

@dynamic 只是告訴編譯器「這兩個方法不用管,當它們存在就行」。那明明沒實現,為什麼還能調用?這與 OC 的消息發送機制有關:消息不與方法實現綁定,而是在運行時才關聯。

編譯器會把消息表達式轉成 objc_msgSend 調用,它至少要知道「誰」發送了「哪條」消息,所以最少兩個參數:接收者與選擇子。

[receiver message]
// 等價於
objc_msgSend(receiver, message)
// 帶參數時
objc_msgSend(receiver, selector, arg1, arg2, ...)

objc_msgSend 的工作是動態綁定:依 selector 和 receiver 找到對應的函數實現地址(不同類的同名方法地址不同),調用它並傳入 receiver、selector、參數,最後返回結果。

@implementation NLPerson
- (instancetype)init {
    if (self = [super init]) {
        [self setName:@"name"];
    }
    return self;
}
- (void)setName:(NSString *)name {
    _name = name;
}
@end

編譯後大致長這樣:

static instancetype _I_NLPerson_init(NLPerson *self, SEL _cmd) {
    if (self...) {
        objc_msgSend((id)self, sel_registerName("setName:"), "name");
    }
    return self;
}

static void _I_NLPerson_setName_(NLPerson *self, SEL _cmd, NSString *name) {
    ...
}

可見每個方法都自帶一個選擇子參數 _cmd,所以才能這樣打印方法名:

- (void)setName:(NSString *)name {
    NSLog(@"%s", sel_getName(_cmd));
    _name = name;
}

SEL 本質就是 C 字符串,把它理解為方法名並無不可。

那 objc_msgSend 怎麼找到函數地址?OC 中所有對象與類最終都被處理為結構體,對象結構體裡有一個 isa 指針指向自己的類結構體,而類結構體裡有兩樣關鍵信息:指向 superclass 的指針,以及類的分發表——裡面存著方法名 selector 與對應的函數地址。

以 NLPerson 為例,分發表大致是:

selector → address
init → _I_NLPerson_init
setName: → _I_NLPerson_setName_

給對象發消息時,先去其 isa 指向的類結構體的分發表中找 selector,找不到就沿 superclass 指針往上,直到 NSObject。找到即調用對應函數。這就是運行時動態綁定。

第三步:動態添加方法

給對象發送無法響應也無法轉發的未知消息,最終會走到 doesNotRecognizeSelector: 並拋出 NSInvalidArgumentException。但在那之前,系統給了我們一次機會:resolveInstanceMethod:,可以用來為實例方法或類方法動態添加實現。

OC 方法對應的 C 函數最少兩個參數:self 與 _cmd。

void dynamicMethodIMP(id self, SEL _cmd) {
    // implementation ....
}

用 class_addMethod 就能把它掛到類上:

@implementation MyClass
+ (BOOL)resolveInstanceMethod:(SEL)aSEL {
    if (aSEL == @selector(resolveThisMethodDynamically)) {
        class_addMethod([self class], aSEL, (IMP)dynamicMethodIMP, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:aSEL];
}
@end

第四步:屬性元數據與類型編碼

要動態生成方法,得先拿到屬性的基本信息:類型、方法名、是 weak 還是 strong。這些都能在運行時取得,靠的是類型編碼(Type Encodings)。編譯器會用字符串表示類型,可用 @encode 取得:

char *buf1 = @encode(int);          // "i"
char *buf2 = @encode(long long);    // "q"
char *buf3 = @encode(unsigned int); // "I"

而描述屬性的,是編譯器為類、分類、協議中的屬性保存的元數據,用結構體 Property 表示:

typedef struct objc_property *Property;

獲取方式有兩組:

// 一次取全部
objc_property_t *class_copyPropertyList(Class cls, unsigned int *outCount);
objc_property_t *protocol_copyPropertyList(Protocol *proto, unsigned int *outCount);

// 按名字取單個
objc_property_t class_getProperty(Class cls, const char *name);
objc_property_t protocol_getProperty(Protocol *proto, const char *name,
                                     BOOL isRequiredProperty, BOOL isInstanceProperty);

拿到屬性結構體後可取出名字與元信息:

const char *property_getName(objc_property_t property);       // 屬性名
const char *property_getAttributes(objc_property_t property); // 元信息

遍歷打印的例子:

id PersonClass = objc_getClass("Person");
unsigned int outCount, i;
objc_property_t *properties = class_copyPropertyList(PersonClass, &outCount);
for (i = 0; i < outCount; i++) {
    objc_property_t property = properties[i];
    fprintf(stdout, "%s %s\n", property_getName(property), property_getAttributes(property));
    // 輸出:age Tf,D,N
}

Tf,D,N 含義是:T 表示類型編碼開始,f 是 float;D 表示 @dynamic;N 表示 nonatomic。各字段以逗號分隔,含義如下:

R 表示 readonly;C 表示 copy;& 表示 strong(retain);N 表示 nonatomic;以 G 開頭的是自定義 getter 名(如 GcustomGetter);以 S 開頭的是自定義 setter 名;D 表示 @dynamic;W 表示 __weak。

第五步:屬性解析

直接用元數據不好使,封裝成對象會清爽很多:

typedef NS_ENUM(NSUInteger, NLPropertyPolicy) {
    NLPropertyPolicyAssign,
    NLPropertyPolicyStrong,
    NLPropertyPolicyCopy,
    NLPropertyPolicyWeak,
};

@interface NLPropertyDescriptor : NSObject
@property (nonatomic, copy, readonly) NSString *name;          // 屬性名
@property (nonatomic, copy, readonly) NSString *getterName;    // getter 方法名
@property (nonatomic, copy, readonly) NSString *setterName;    // setter 方法名
@property (nonatomic, copy, readonly) NSString *variableName;  // 變量名
@property (nonatomic, copy, readonly) NSString *typeEncoding;  // 類型編碼
@property (nonatomic, assign, readonly) NLPropertyPolicy propertyPolicy;
- (instancetype)initWithObjcProperty:(objc_property_t)objcProperty;
@end

初始化方法把各項特性都解析好存起來:

- (instancetype)initWithObjcProperty:(objc_property_t)objcProperty {
    if (self = [super init]) {
        _propertyPolicy = NLPropertyPolicyAssign;

        const char *cPropertyName = property_getName(objcProperty);
        _name = [[NSString stringWithCString:cPropertyName encoding:NSUTF8StringEncoding] copy];
        _getterName = [_name copy];
        _variableName = [@"_" stringByAppendingString:_name];

        // 默認 setter 名:set + 首字母大寫 + 其餘 + ":"
        NSString *firstChar = [[_name substringToIndex:1] uppercaseString];
        NSString *subjectName = [_name substringFromIndex:1] ?: @"";
        subjectName = [subjectName stringByAppendingString:@":"];
        _setterName = [[NSString stringWithFormat:@"set%@%@", firstChar, subjectName] copy];

        const char *cPropertyAttributes = property_getAttributes(objcProperty);
        NSString *sPropertyAttributes = [NSString stringWithCString:cPropertyAttributes encoding:NSUTF8StringEncoding];
        NSArray *attributes = [sPropertyAttributes componentsSeparatedByString:@","];

        [attributes enumerateObjectsUsingBlock:^(NSString *obj, NSUInteger idx, BOOL *stop) {
            if (idx == 0) {
                _typeEncoding = [obj copy];   // 第一段一定是類型編碼
            }
            if ([obj hasPrefix:@"G"]) {
                _getterName = [[obj substringFromIndex:1] copy];
            } else if ([obj hasPrefix:@"S"]) {
                _setterName = [[obj substringFromIndex:1] copy];
            } else if ([obj hasPrefix:@"V"]) {
                _variableName = [[obj substringFromIndex:1] copy];
            } else if ([obj isEqualToString:@"&"]) {
                _propertyPolicy = NLPropertyPolicyStrong;
            } else if ([obj isEqualToString:@"C"]) {
                _propertyPolicy = NLPropertyPolicyCopy;
            } else if ([obj isEqualToString:@"W"]) {
                _propertyPolicy = NLPropertyPolicyWeak;
            } else if ([obj isEqualToString:@"R"]) {
                _setterName = nil;            // readonly
            }
        }];
    }
    return self;
}

再寫一個分類方法,過濾出「@dynamic 且以 nl_ 開頭」的屬性並緩存起來:

@implementation NSObject (nl_dynamicPropertyStore)

+ (BOOL)nl_validDynamicProperty:(objc_property_t)objProperty {
    const char *propertyAttributes = property_getAttributes(objProperty);
    // 必須是 @dynamic
    static char *const staticDynamicAttribute = ",D,";
    if (strstr(propertyAttributes, staticDynamicAttribute) == NULL) {
        return NO;
    }
    // 名字必須以 nl_ 開頭
    const char *propertyName = property_getName(objProperty);
    static char *const staticPropertyNamePrefix = "nl_";
    if (strstr(propertyName, staticPropertyNamePrefix) != propertyName) {
        return NO;
    }
    return YES;
}

+ (NSArray *)nl_dynamicPropertyDescriptors {
    NSMutableArray *descriptors = objc_getAssociatedObject(self, _cmd);
    if (nil == descriptors) {
        unsigned int outCount, index;
        descriptors = [NSMutableArray array];
        objc_setAssociatedObject(self, _cmd, descriptors, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

        objc_property_t *properties = class_copyPropertyList([self class], &outCount);
        for (index = 0; index < outCount; ++index) {
            objc_property_t property = properties[index];
            if ([self nl_validDynamicProperty:property]) {
                [descriptors addObject:[[NLPropertyDescriptor alloc] initWithObjcProperty:property]];
            }
        }
        free(properties);
    }
    return descriptors;
}
@end

方法裡要存的值也需要落腳點,用字典合適,同樣掛在這個分類下:

- (NSMutableDictionary *)nl_dynamicPropertyDictionary {
    NSMutableDictionary *dynamicProperties = objc_getAssociatedObject(self, _cmd);
    if (!dynamicProperties) {
        dynamicProperties = [NSMutableDictionary dictionary];
        objc_setAssociatedObject(self, _cmd, dynamicProperties, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }
    return dynamicProperties;
}

第六步:自動生成 getter 與 setter

前面提到,未實現的消息會走到 resolveInstanceMethod:。這個方法定義在 NSObject 上,我們不可能靠繼承去改,於是採取方法調配(method swizzling)——在 NSObject 的分類裡寫一個新方法替換原實現。

方法是動態綁定的,只有在運行時查找之後才知道消息對應哪個函數。所謂調配,就是把兩個方法各自關聯的實現互相交換:nameA→funcA、nameB→funcB,交換後 nameA→funcB。核心函數是 method_exchangeImplementations:

@implementation NSObject (nl_dynamicSupport)

+ (void)load {
    Method resolveInstanceMethod     = class_getClassMethod(self, @selector(resolveInstanceMethod:));
    Method nl_resolveInstanceMethod  = class_getClassMethod(self, @selector(nl_resolveInstanceMethod:));
    if (resolveInstanceMethod && nl_resolveInstanceMethod) {
        method_exchangeImplementations(resolveInstanceMethod, nl_resolveInstanceMethod);
    }
}

#pragma mark - swizzle +resolveInstanceMethod
+ (BOOL)nl_resolveInstanceMethod:(SEL)sel {
    // 記得調用原有的實現
    return [self nl_resolveInstanceMethod:sel];
}
@end

調配之後,原本調用 resolveInstanceMethod 實際執行的是 nl_resolveInstanceMethod 的方法體。我們把新增邏輯放進去,最後再回調原實現。

要添加方法,先得把對應的 C 函數寫出來。由於 getter、setter 的參數個數與返回值個數固定,它們的實現並不依賴具體屬性名;而且所有方法都自帶一個共同參數 SEL,正好用來定位是哪個屬性。先準備兩個輔助方法:

+ (NSString *)nl_dynamicPropertyNameWithSelctor:(SEL)selector {
    return [[self nl_descriptorWithSelector:selector] name];
}

+ (NLPropertyDescriptor *)nl_descriptorWithSelector:(SEL)selector {
    for (NLPropertyDescriptor *descriptor in [self nl_dynamicPropertyDescriptors]) {
        NSString *selectorName = NSStringFromSelector(selector);
        if ([descriptor.getterName isEqualToString:selectorName] ||
            [descriptor.setterName isEqualToString:selectorName]) {
            return descriptor;
        }
    }
    return nil;
}

以對象、int、CGRect 三種類型為例:

// 對象 setter
void __NL__object_dynamicSetterIMP(id self, SEL _cmd, id arg) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    [[self nl_dynamicPropertyDictionary] setObject:arg forKey:propertyName];
}
// 對象 getter
id __NL__object_dynamicGetterIMP(id self, SEL _cmd) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    return [[self nl_dynamicPropertyDictionary] objectForKey:propertyName];
}

// int setter / getter
void __NL__int_dynamicSetterIMP(id self, SEL _cmd, int arg) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    [[self nl_dynamicPropertyDictionary] setObject:@(arg) forKey:propertyName];
}
int __NL__int_dynamicGetterIMP(id self, SEL _cmd) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    return [[[self nl_dynamicPropertyDictionary] objectForKey:propertyName] intValue];
}

// CGRect setter / getter
void __NL__cgrect_dynamicSetterIMP(id self, SEL _cmd, CGRect arg) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    [[self nl_dynamicPropertyDictionary] setObject:[NSValue valueWithCGRect:arg] forKey:propertyName];
}
CGRect __NL__cgrect_dynamicGetterIMP(id self, SEL _cmd) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    return [[[self nl_dynamicPropertyDictionary] objectForKey:propertyName] CGRectValue];
}

最後一步:依未實現的方法名找到對應函數,掛進方法表:

+ (BOOL)nl_resolveInstanceMethod:(SEL)sel {
    NSArray *propertyDescriptors = [self nl_dynamicPropertyDescriptors];
    for (NLPropertyDescriptor *propertyDescriptor in propertyDescriptors) {
        if ([self nl_addMethodWithDescriptor:propertyDescriptor selector:sel]) {
            return YES;
        }
    }
    return [self nl_resolveInstanceMethod:sel];  // 記得調用原實現
}

+ (BOOL)nl_addMethodWithDescriptor:(NLPropertyDescriptor *)desciptor selector:(SEL)sel {
    NSString *selName = NSStringFromSelector(sel);
    if ([desciptor.setterName isEqualToString:selName]) {
        return [self nl_addSetterMethodWithDescriptor:desciptor];
    }
    if ([desciptor.getterName isEqualToString:selName]) {
        return [self nl_addGetterMethodWithDescriptor:desciptor];
    }
    return NO;
}

+ (BOOL)nl_addSetterMethodWithDescriptor:(NLPropertyDescriptor *)desciptor {
    IMP setterIMP = NULL;
    if ([desciptor isIntType])    { setterIMP = (IMP)__NL__int_dynamicSetterIMP; }
    if ([desciptor isObjectType]) { setterIMP = (IMP)__NL__object_dynamicSetterIMP; }
    if ([desciptor isRectType])   { setterIMP = (IMP)__NL__cgrect_dynamicSetterIMP; }

    if (setterIMP != NULL) {
        class_addMethod(self, NSSelectorFromString(desciptor.setterName), setterIMP, "v@:");
        return YES;
    }
    return NO;
}

+ (BOOL)nl_addGetterMethodWithDescriptor:(NLPropertyDescriptor *)desciptor {
    SEL selector = NSSelectorFromString(desciptor.getterName);
    if ([desciptor isIntType]) {
        class_addMethod(self, selector, (IMP)__NL__int_dynamicGetterIMP, "i@:");
        return YES;
    }

    // 去掉類型編碼前綴的 T,再拼上 "@:"(self 與 _cmd)
    NSString *typeEncoding = [desciptor typeEncoding];
    if ([typeEncoding hasPrefix:@"T"]) {
        typeEncoding = [typeEncoding substringFromIndex:1];
    }
    const char *cFuncationTypes = [[typeEncoding stringByAppendingString:@"@:"] cStringUsingEncoding:NSUTF8StringEncoding];

    if ([desciptor isObjectType]) {
        class_addMethod(self, selector, (IMP)__NL__object_dynamicGetterIMP, cFuncationTypes);
        return YES;
    }
    if ([desciptor isRectType]) {
        class_addMethod(self, selector, (IMP)__NL__cgrect_dynamicGetterIMP, cFuncationTypes);
        return YES;
    }
    return NO;
}

關於 class_addMethod(Class cls, SEL name, IMP imp, const char *types):types 用類型編碼描述方法簽名。由於任何方法的函數都必然帶 self(@)與 _cmd(:),這個字符串裡一定含 @: 子串——其前面是返回值類型,後面依次是其他參數類型。

實驗一下:

@interface ViewController (nl_ex)
@property (nonatomic, assign) int nl_int;
@property (nonatomic, strong) id nl_object;
@end

@implementation ViewController (nl_ex)
@dynamic nl_object;
@dynamic nl_int;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    self.nl_int = 20;
    self.nl_object = [UIView new];
    fprintf(stdout, "nl_int = %d\n", self.nl_int);
    fprintf(stdout, "nl_object = %s\n", [[self.nl_object description] cStringUsingEncoding:NSUTF8StringEncoding]);
    // 輸出:nl_int = 20 / nl_object = <UIView: ...>
}

跑通了。

第七步:加 KVO 支持時踩的坑

KVO 看似簡單,在 setter 裡包上 willChangeValueForKey: 與 didChangeValueForKey: 就行:

void __NL__object_dynamicSetterIMP(id self, SEL _cmd, id arg) {
    NSString *propertyName = [[self class] nl_dynamicPropertyNameWithSelctor:_cmd];
    [self willChangeValueForKey:propertyName];
    [[self nl_dynamicPropertyDictionary] setObject:arg forKey:propertyName];
    [self didChangeValueForKey:propertyName];
}

但驗證時直接崩潰:

*** Terminating app due to uncaught exception 'NSInvalidArgumentException',
reason: '*** setObjectForKey: key cannot be nil'

崩在 setObject:forKey:,原因是 propertyName 為 nil。屬性明明存在,怎麼會取不到?關鍵在這段:

[self addObserver:self forKeyPath:@"nl_object" options:NSKeyValueObservingOptionNew context:nil];
Class class         = [self class];             // ViewController
Class kvoClass      = object_getClass(self);    // NSKVONotifying_ViewController
Class kvoSuperClass = class_getSuperclass(kvoClass); // ViewController

一旦調用 addObserver:,對象所屬的類就變成了系統動態生成的子類 NSKVONotifying_XXX,系統只是重寫了 -class 讓它看起來還是原樣。而我們的 nl_dynamicPropertyDescriptors 只收集了當前類的屬性,自然取不到。修復辦法是沿繼承鏈把父類屬性也收進來:

+ (NSArray *)nl_dynamicPropertyDescriptors {
    NSMutableArray *descriptors = objc_getAssociatedObject(self, _cmd);
    if (nil == descriptors) {
        unsigned int outCount, index;
        descriptors = [NSMutableArray array];
        objc_setAssociatedObject(self, _cmd, descriptors, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

        objc_property_t *properties = class_copyPropertyList([self class], &outCount);
        for (index = 0; index < outCount; ++index) {
            objc_property_t property = properties[index];
            if ([self nl_validDynamicProperty:property]) {
                [descriptors addObject:[[NLPropertyDescriptor alloc] initWithObjcProperty:property]];
            }
        }
        free(properties);

        if (self != [NSObject class]) {
            // 加上父類的屬性描述器
            [descriptors addObjectsFromArray:[class_getSuperclass(self) nl_dynamicPropertyDescriptors]];
        }
    }
    return descriptors;
}

再驗證一次,回調與賦值都正常打印,KVO 通過。

結束

代碼量不小,KVC 與 weak 的支持屬於細枝末節,這裡沒有展開,完整實現可參考:https://github.com/NathanLi/iOSCategoryPropertyDynamicSupport

雖然 Objective-C 在 Swift 面前已顯過時,但這些 runtime 知識依然有價值。本文只講了屬性相關的一小块,實際上可發揮的空間還很大,比如 ORM(如 LKDBHelper)之類的東西。

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