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

Runtime 在實際開發中的七大落地應用

編輯:iOS 開發基礎

前言

本文不是「Runtime 原理從入門到精通」那類教程,不會糾纏過多原理概念,而是聚焦於在實際開發中如何用 Runtime 解決具體問題。文中案例在之前的網絡層博客及後續文章中都有體現。全文約八千字,預計閱讀 20 - 30 分鐘。

目錄

  • Protobuf 解析器

  • 消息轉發三部曲

  • 安全的 JSON

  • 安全的數組

  • 多代理

  • 通用打點器

  • ISA Swizzle 和 Method Swizzle

一、Protobuf 解析器

公司網絡層用的是 TCP + Protobuf 組合,請求與返回都是 Protobuf,市面上通用的 JSON 解析工具並不適用,於是作者自研了一套類似的解析工具。最終效果是:使用方法與現有 JSON 解析工具完全一致;在 iPhone 6 上對含 20 個屬性的 Model 做 10000 次解析,耗時約 0.085s ~ 0.95s(作為參考,同數據量下 YYModel 約 0.08 ~ 0.09s,MJExtension 約 3.2 ~ 3.3s)。

使用方式如下:

// SomeModel.h (正常 Property 略過)
@property (copy, nonatomic) NSString *HHavatar;      // 與 Protobuf 不一致
@property (assign, nonatomic) NSInteger HHuserId;    // 與 Protobuf 不一致
@property (strong, nonatomic) NSArray *albumArray;   // 數組裡又是 Model
@property (strong, nonatomic) NSArray *strangeAlbumArray; // 數組裡是 Model 且名稱不一致
// SomeModel.m
+ (NSDictionary *)replacedPropertyKeypathsForProtobuf {
    return @{@"HHavatar" : @"avatar", @"HHuserId" : @"userId"};
}
+ (NSDictionary *)containerPropertyKeypathsForProtobuf {
    return @{@"albumArray" : @"HHAlbum",
             @"strangeAlbumArray" : @{kHHObjectClassName : @"HHAlbum",
                                      kHHProtobufObjectKeyPath : @"result.albumArray"}};
}

實現思路很簡單:先用 class_copyPropertyList 獲取輸出對象的變量信息,再據此走 KVC 從輸入對象取值,最後用 objc_msgSend 逐個賦值給輸出對象。(因為本地 Model 都用屬性,所以 class_copyPropertyList 足矣;若是直接聲明實例變量 _iVar 的老項目,則需用 class_copyIvarList。)

具體到代碼,主要分幾步:

1. 獲取輸出對象的變量信息:

typedef enum : NSUInteger {
    HHPropertyTypeUnknown = 0, HHPropertyTypeVoid = 1, HHPropertyTypeBool = 2,
    HHPropertyTypeInt8 = 3, HHPropertyTypeUInt8 = 4, HHPropertyTypeInt16 = 5,
    HHPropertyTypeUInt16 = 6, HHPropertyTypeInt32 = 7, HHPropertyTypeUInt32 = 8,
    HHPropertyTypeInt64 = 9, HHPropertyTypeUInt64 = 10, HHPropertyTypeFloat = 11,
    HHPropertyTypeDouble = 12, HHPropertyTypeLongDouble = 13,
    HHPropertyTypeArray = 14, HHPropertyTypeCustomObject = 15, HHPropertyTypeFoundionObject = 16
} HHPropertyType;

@interface HHPropertyInfo : NSObject {
    @package
    SEL _setter; SEL _getter; Class _cls;
    NSString *_name; NSString *_getPath; HHPropertyType _type;
}
+ (instancetype)propertyWithProperty:(objc_property_t)property;
@end

@interface HHClassInfo : NSObject
+ (instancetype)classInfoWithClass:(Class)cls
                 ignoreProperties:(NSArray *)ignoreProperties
           replacePropertyKeypaths:(NSDictionary *)replacePropertyKeypaths;
- (NSArray *)properties;
@end
#define IgnorePropertyNames @[@"debugDescription", @"description", @"superclass", @"hash"]

@implementation HHClassInfo
+ (instancetype)classInfoWithClass:(Class)cls
                  ignoreProperties:(NSArray *)ignoreProperties
             replacePropertyKeypaths:(NSDictionary *)replacePropertyKeypaths {
    HHClassInfo *classInfo = [HHClassInfo new];
    classInfo.cls = cls;
    NSMutableArray *properties = [NSMutableArray array];
    while (cls != [NSObject class] && cls != [NSProxy class]) {
        [properties addObjectsFromArray:[self propertiesWithClass:cls
                                               ignoreProperties:ignoreProperties
                                          replacePropertyKeypaths:replacePropertyKeypaths]];
        cls = [cls superclass];
    }
    classInfo.properties = [properties copy];
    return classInfo;
}
+ (NSArray *)propertiesWithClass:(Class)cls
                ignoreProperties:(NSArray *)ignoreProperties
           replacePropertyKeypaths:(NSDictionary *)replacePropertyKeypaths {
    uint count;
    objc_property_t *properties = class_copyPropertyList(cls, &count);
    NSMutableArray *propertyInfos = [NSMutableArray array];
    NSMutableSet *ignorePropertySet = [NSMutableSet setWithArray:IgnorePropertyNames];
    [ignorePropertySet addObjectsFromArray:ignoreProperties];
    for (int i = 0; i < count; i++) {
        objc_property_t property = properties[i];
        NSString *propertyName = [NSString stringWithCString:property_getName(property)
                                                    encoding:NSUTF8StringEncoding];
        if ([ignorePropertySet containsObject:propertyName]) { continue; }
        HHPropertyInfo *propertyInfo = [HHPropertyInfo propertyWithProperty:property];
        if (replacePropertyKeypaths.count > 0) {
            NSString *replaceKey = replacePropertyKeypaths[propertyInfo->_name];
            if (replaceKey != nil) {
                propertyInfo->_getter = NSSelectorFromString(replaceKey);
                propertyInfo->_getPath = replaceKey;
            }
        }
        [propertyInfos addObject:propertyInfo];
    }
    free(properties);
    return propertyInfos;
}
@end

HHClassInfo 描述某個類所有需要解析的變量信息,構造時從該類一直遍歷到基類收集變量;ignoreProperties 中的變量會被忽略,replacePropertyKeypaths 中的變量會按映射字典進行映射。

HHPropertyInfo 描述具體某個變量的信息,包括類型、名稱、取值路徑等。針對公司情況,Type 只聲明了基本類型、系統對象、自定義對象和 Array。這裡 Array 並不包含在系統對象中,因為 Protobuf 用 PBArray 表示 int/bool/long 等基本類型集合,而系統的 NSArray 對基本類型統一包裝成 NSNumber,兩者不一致,需特殊處理。獲取屬性信息的具體實現如下:

@implementation HHPropertyInfo
NS_INLINE HHPropertyType getPropertyType(const char *type) {
    switch (*type) {
        case 'B': return HHPropertyTypeBool;
        case 'c': return HHPropertyTypeInt8;
        case 'C': return HHPropertyTypeUInt8;
        case 's': return HHPropertyTypeInt16;
        case 'S': return HHPropertyTypeUInt16;
        case 'i': return HHPropertyTypeInt32;
        case 'I': return HHPropertyTypeUInt32;
        case 'l': return HHPropertyTypeInt32;
        case 'L': return HHPropertyTypeUInt32;
        case 'q': return HHPropertyTypeInt64;
        case 'Q': return HHPropertyTypeUInt64;
        case 'f': return HHPropertyTypeFloat;
        case 'd': return HHPropertyTypeDouble;
        case 'D': return HHPropertyTypeLongDouble;
        case '@': {
            NSString *typeString = [NSString stringWithCString:type encoding:NSUTF8StringEncoding];
            if ([typeString rangeOfString:@"Array"].length > 0) { return HHPropertyTypeArray; }
            if ([typeString rangeOfString:@"NS"].length > 0) { return HHPropertyTypeFoundionObject; }
            return HHPropertyTypeCustomObject;
        };
        default: return 0;
    }
}
+ (instancetype)propertyWithProperty:(objc_property_t)property {
    HHPropertyInfo *info = [HHPropertyInfo new];
    char *propertyAttribute = property_copyAttributeValue(property, "T");
    info->_name = [NSString stringWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
    info->_type = getPropertyType(propertyAttribute);
    info->_setter = NSSelectorFromString([NSString stringWithFormat:@"set%@%@:",
        [[info->_name substringToIndex:1] uppercaseString], [info->_name substringFromIndex:1]]);
    info->_getter = NSSelectorFromString(info->_name);
    info->_getPath = info->_name;
    info->_property = property;
    if (info->_type >= 14) {
        NSString *propertyClassName = [NSString stringWithCString:propertyAttribute encoding:NSUTF8StringEncoding];
        if (![propertyClassName isEqualToString:@""]) { // id 類型沒有類名
            info->_cls = NSClassFromString([[propertyClassName componentsSeparatedByString:@"\""] objectAtIndex:1]);
        }
    }
    free(propertyAttribute);
    return info;
}
@end

2. 根據具體類的變量信息進行賦值。

2.1 獲取某類的變量信息列表:

+ (HHClassInfo *)classInfoToParseProtobuf:(Class)cls {
    static NSMutableDictionary *objectClasses;
    static dispatch_semaphore_t lock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        lock = dispatch_semaphore_create(1);
        objectClasses = [NSMutableDictionary dictionary];
    });
    HHClassInfo *classInfo = objectClasses[cls];
    if (!classInfo) {
        NSArray *ignoreProperties = [(id)cls respondsToSelector:@selector(igonrePropertiesForProtobuf)]
            ? [(id)cls igonrePropertiesForProtobuf] : nil;
        NSDictionary *replacePropertyKeypaths = [(id)cls respondsToSelector:@selector(replacedPropertyKeypathsForProtobuf)]
            ? [(id)cls replacedPropertyKeypathsForProtobuf] : nil;
        classInfo = [HHClassInfo classInfoWithClass:cls ignoreProperties:ignoreProperties
                             replacePropertyKeypaths:replacePropertyKeypaths];
        dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
        objectClasses[(id)cls] = classInfo;
        dispatch_semaphore_signal(lock);
    }
    return classInfo;
}

解析某類前,先調用此方法獲取該類變量信息列表。由於某類的變量信息與解析規則不變,沒必要每次重算,因此把結果緩存起來(這一緩存直接把解析效率提升了約 8 倍)。

2.2 根據變量信息列表賦值:

+ (instancetype)instanceWithProtoObject:(id)protoObject {
    if (!protoObject) { return nil; }
    static SEL toNSArraySEL; // PBArray 特殊處理
    if (toNSArraySEL == nil) { toNSArraySEL = NSSelectorFromString(@"toNSArray"); }
    Class cls = [self class];
    id instance = [self new];
    NSArray *properties = [NSObject classInfoToParseProtobuf:cls].properties; // 1. 獲取變量信息
    NSDictionary *containerPropertyKeypaths; // 2. 獲取數組套 Model 的映射字典
    if ([(id)cls respondsToSelector:@selector(containerPropertyKeypathsForProtobuf)]) {
        containerPropertyKeypaths = [(id)cls containerPropertyKeypathsForProtobuf];
    }
    for (HHPropertyInfo *property in properties) {
        if (containerPropertyKeypaths[property->_name]) { // 針對數組套 Model 的情況處理後賦值
            id propertyValue = [self propertyValueForKeypathWithProtoObject:protoObject propertyName:property->_name];
            if (propertyValue) {
                ((void (*)(id, SEL, id))(void *)&objc_msgSend)(instance, property->_setter, propertyValue);
            }
        } else if ([protoObject respondsToSelector:property->_getter]) {
            id propertyValue = [protoObject valueForKey:property->_getPath];
            if (propertyValue != nil) { // 3. 按類型賦值
                HHPropertyType type = property->_type;
                switch (type) {
                    case HHPropertyTypeBool:
                    case HHPropertyTypeInt8: {
                        if ([propertyValue respondsToSelector:@selector(boolValue)]) {
                            ((void (*)(id, SEL, bool))(void *)&objc_msgSend)(instance, property->_setter, [propertyValue boolValue]);
                        }
                    } break;
                    // ...其餘基本類型略
                    case HHPropertyTypeCustomObject: {
                        ((void (*)(id, SEL, id))(void *)&objc_msgSend)(instance, property->_setter,
                            [property->_cls instanceWithProtoObject:propertyValue]);
                    } break;
                    case HHPropertyTypeArray: {
                        if ([propertyValue respondsToSelector:toNSArraySEL]) { // PBArray 特殊處理
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
                            propertyValue = [propertyValue performSelector:toNSArraySEL];
#pragma clang diagnostic pop
                        }
                        ((void (*)(id, SEL, id))(void *)&objc_msgSend)(instance, property->_setter, propertyValue);
                    } break;
                    default: {
                        ((void (*)(id, SEL, id))(void *)&objc_msgSend)(instance, property->_setter, propertyValue);
                    } break;
                }
            }
        }
    }
    return instance;
}
// 解析容器類屬性
+ (id)propertyValueForKeypathWithProtoObject:(id)protoObject propertyName:(NSString *)propertyName {
    Class cls = self;
    id map = [[cls containerPropertyKeypathsForProtobuf] objectForKey:propertyName];
    NSString *keyPath;
    Class objectClass;
    if ([map isKindOfClass:[NSDictionary class]]) {
        keyPath = [map objectForKey:kHHProtobufObjectKeyPath];
        objectClass = NSClassFromString(map[kHHObjectClassName]);
    } else {
        keyPath = propertyName;
        objectClass = NSClassFromString(map);
    }
    id value = [protoObject valueForKeyPath:keyPath];
    if (![value isKindOfClass:[NSArray class]]) {
        return [objectClass instanceWithProtoObject:value];
    } else {
        NSMutableArray *mArr = [NSMutableArray array];
        for (id message in value) {
            [mArr addObject:[objectClass instanceWithProtoObject:message]];
        }
        return mArr;
    }
    return nil;
}

實際解析就是遍歷變量列表,按取值路徑走 KVC 取值,再按類型調用不同的 objc_msgSend 賦值:普通系統對象直接賦值;基本類型先把 NSNumber/NSString 轉成 int/bool/long 再賦值;自定義類型多走一次 instanceWithProtoObject;自定義容器類型則按 containerPropertyKeypathsForProtobuf 規則取出元素類名與取值路徑,多次調用 instanceWithProtoObject 解析成數組後賦值。

小結:HHClassInfo 描述某類的所有變量信息並負責忽略與映射;HHPropertyInfo 描述單個變量的具體信息;NSObject+ProtobufExtension 是解析的具體實現類,負責獲取並緩存類變量信息、走 KVC 取值、用 objc_msgSend 賦值,並處理自定義類與容器類。

二、消息轉發三部曲

接下來的內容都與消息轉發有關,先簡單介紹 OC 的消息轉發機制:

+ (BOOL)resolveInstanceMethod:(SEL)sel——當向對象發送消息而它沒有對應實現時,會先詢問接收類:能不能現在造一個實現出來?通常通過 class_addMethod 現場添加,返回 YES 則發送成功,否則進入下一步。

- (id)forwardingTargetForSelector:(SEL)aSelector——上一步沒結果時二次詢問:造不出來沒關係,告訴我誰有這個實現?返回一個能響應該消息的對象就轉發過去;返回 nil 或對象無法響應則進入最後一步。

- (void)forwardInvocation:(NSInvocation *)anInvocation——到這一步發送其實已算失敗,不再詢問,而是把消息的一切信息封裝進 NSInvocation 交給對象處理。構造 Invocation 時會調用 methodSignatureForSelector: 獲取方法簽名,所以通常還需實現它。若對象能對 Invocation 發起 [invocation invoke],實現仍能正常執行,只是稍麻煩耗時;否則觸發 unrecognized selector 異常。

三、安全的 JSON

#define NSNullObjects @[@"", @0, @{}, @[]]

@implementation NSNull (SafeJson)
- (id)forwardingTargetForSelector:(SEL)aSelector {
    for (id null in NSNullObjects) {
        if ([null respondsToSelector:aSelector]) { return null; }
    }
    return nil;
}
@end

Java 後台對空字段默認返回 null,若不做處理,OC 解析出來就是 NSNull。NSNull 只是佔位空對象,向其發消息會 crash。由於 JSON 中只有數字、字符串、數組、字典四種類型,只要在觸發轉發時返回其中一種即可解決。

四、安全的數組

數組越界是日常開發中常見的異常。常規做法每次取值前先判斷下標,也有人用 Method Swizzle 交換 __NSArrayI 和 NSArrayM 的 objectAtIndex:(作者並不推薦,原因見文末)。這裡給出另一種思路,先看效果:

NSMutableArray *array = [HHArray array];
[array addObject:@1];
[array addObject:@2];
[array addObject:@4];
[array addObjectsFromArray:@[@6, @8]];
[array addObject:nil];            // safe
[array removeObjectAtIndex:7];    // safe
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
    NSLog(@"e %@", obj);
}]; // log: 1 2 4 6 8
for (id x in array) { NSLog(@"- %@", x); } // log: 1 2 4 6 8
for (int i = 0; i < 10; i++) { NSLog(@"~ %@", [array objectAtIndex:i]); } // safe,越界返回 null

HHArray 是 NSArray/NSMutableArray 的裝飾類,對外只提供兩個構造方法,返回 HHArray 實例但聲明返回類型為 NSMutableArray,以此「騙過」編譯器,讓外部能調用各同名接口:

@interface HHArray : NSObject
+ (NSMutableArray *)array;
+ (NSMutableArray *)arrayWithArray:(NSArray *)array;
@end
@interface HHArray ()
@property (strong, nonatomic) NSMutableArray *store;
@end
@implementation HHArray
+ (NSMutableArray *)array { return [HHArray arrayWithArray:nil]; }
+ (NSMutableArray *)arrayWithArray:(NSArray *)arr {
    HHArray *array = (id)[super allocWithZone:NULL];
    return (id)[array initWithArray:arr];
}
- (instancetype)init { return [self initWithArray:nil]; }
- (instancetype)initWithArray:(NSArray *)array {
    self.store = [NSMutableArray array];
    [self.store addObjectsFromArray:array];
    return self;
}
#pragma mark - Override
- (ObjectType)objectAtIndex:(NSUInteger)index { IfValidIndexReturn(objectAtIndex:index); }
- (ObjectType)objectAtIndexedSubscript:(NSUInteger)index { IfValidIndexReturn(objectAtIndexedSubscript:index); }
- (void)addObject:(ObjectType)anObject { anObject == nil ?: [self.store addObject:anObject]; }
- (void)insertObject:(ObjectType)anObject atIndex:(NSUInteger)index { IfValidObjectAndIndexPerform(insertObject:anObject atIndex:index); }
- (void)removeObjectAtIndex:(NSUInteger)index { IfValidIndexPerform(removeObjectAtIndex:index); }
- (void)replaceObjectAtIndex:(NSUInteger)index withObject:(ObjectType)anObject { IfValidObjectAndIndexPerform(replaceObjectAtIndex:index withObject:anObject); }
#pragma mark - Forward
- (id)forwardingTargetForSelector:(SEL)aSelector { return self.store; }
@end

內部用一個 NSMutableArray 做實際存儲,對可能出錯的接口做參數判斷後再調用(此處只重寫了幾個典型接口);對不會出錯的接口(如 for-in、removeAllObjects)則通過 forwardingTargetForSelector: 直接轉發給內部 Array。

五、多代理

由於業務原因,項目裡有三個只能是單例的對象:全局音樂播放器、藍牙管理者、智能硬件遙控器。單例一般不宜走單代理——它會被多處訪問,任一處把代理設為自身就會覆蓋之前的代理,維護麻煩(UIApplication 是單例且單代理,但其代理不會被覆蓋,屬特例)。單例通常走通知或多代理向外回調,作者不喜歡繁瑣的通知,於是做了個多代理:

#define HHNotifObservers(action) if (self.observers.hasObserver) { [self.observers action]; }

@interface HHNotifier : NSProxy
+ (instancetype)notifier;
+ (instancetype)ratainNotifier;
- (BOOL)hasObserver;
- (void)addObserver:(id)observer;
- (void)removeObserver:(id)observer;
@end
@interface HHNotifier ()
@property (strong, nonatomic) NSHashTable *observers;
@end
@implementation HHNotifier
+ (instancetype)notifier:(BOOL)shouldRetainObserver {
    HHNotifier *notifier = [super alloc];
    notifier.observers = [NSHashTable hashTableWithOptions:shouldRetainObserver
        ? NSPointerFunctionsStrongMemory : NSPointerFunctionsWeakMemory];
    return notifier;
}
+ (id)alloc { return [HHNotifier notifier:NO]; }
+ (instancetype)notifier { return [HHNotifier notifier:NO]; }
+ (instancetype)ratainNotifier { return [HHNotifier notifier:YES]; }
#pragma mark - Interface
- (BOOL)hasObserver { return self.observers.allObjects.count > 0; }
- (void)addObserver:(id)observer {
    if (observer) {
        dispatch_semaphore_wait(self.lock, DISPATCH_TIME_FOREVER);
        [self.observers addObject:observer];
        dispatch_semaphore_signal(self.lock);
    }
}
- (void)removeObserver:(id)observer {
    if (observer) {
        dispatch_semaphore_wait(self.lock, DISPATCH_TIME_FOREVER);
        [self.observers removeObject:observer];
        dispatch_semaphore_signal(self.lock);
    }
}
#pragma mark - Override
- (BOOL)respondsToSelector:(SEL)aSelector {
    for (id observer in self.observers.allObjects) {
        if ([observer respondsToSelector:aSelector]) { return YES; }
    }
    return NO;
}
#pragma mark - Forward
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel {
    for (id observer in self.observers.allObjects) {
        NSMethodSignature *signature = [observer methodSignatureForSelector:sel];
        if (signature) { return signature; }
    }
    return [super methodSignatureForSelector:sel];
}
- (void)forwardInvocation:(NSInvocation *)invocation {
    for (id observer in self.observers.allObjects) {
        ![observer respondsToSelector:invocation.selector] ?: [invocation invokeWithTarget:observer];
    }
}
#pragma mark - Getter
- (dispatch_semaphore_t)lock {
    static dispatch_semaphore_t lock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{ lock = dispatch_semaphore_create(1); });
    return lock;
}
@end

HHNotifier 對外提供添加/移除代理的接口,內部用 NSHashTable 存儲代理的弱引用以確保不持有代理對象;向它發送消息時,會通過消息轉發把消息轉發給所有響應的代理。用法如下:

@interface ViewControllerNotifier : HHNotifier (ViewController) /* 此處用圓括號代替尖括號 */ @end
@implementation ViewControllerNotifier
@end
// 哪個類需要多代理,就在該類聲明一個 HHNotifier 子類並讓它遵守相應協議,主要是為了代碼提示;也可以直接聲明一個 id。
self.observers = [ViewControllerNotifier notifier];
for (int i = 0; i < 5; i++) {
    SomeObject *object = [SomeObject objectWithName:[NSString stringWithFormat:@"objcet%d", i]];
    [self.observers addObserver:object]; // 實際代理對象
}
[self.observers addObserver:self]; // 無所謂的代理對象,反正不響應
HHNotifObservers(doAnything); // 輸出 5 次
HHNotifObservers(doSomething); // 輸出 5 次

需要說明的是,HHNotifier 只是轉發器,本身沒有任何方法實現。當內部沒有可轉發對象或所有對象都不響應時仍會觸發異常,因此嚴謹的做法是在發送前先用 respondsToSelector: 判斷,或簡單地用 hasObserver 判斷。

六、通用打點器

關於打點,網上文章雖多,但幾乎都走 Method Swizzle,有多少類要打點就得建多少個 category,不夠通用。加之打點常是後期強加的需求,不同開發者方法名可能不同(如 send: 與 sendContent:)卻走同一套打點邏輯。因此有必要做一個通用打點器。先看效果:

+ (NSDictionary (NSString *, id)圓括號代替尖括號 *)observeItems {
    return @{@"UIControl" : @"sendAction:to:forEvent:",
             @"Person" : @"personFunc:",
             @"SecondViewController" : @[@"aFunc", @"aFunc:", @"aFunc1:", @"aFunc2:",
                 @"aFunc3:", @"aFunc4:", @"aFunc:objcet:", @"aFunc:frame:size:point:object:"]};
}
// 在這裡聲明需要打點的類與對應方法,多個方法放數組;不響應的方法不會被打點
+ (void)object:(id)object willInvokeFunction:(NSString *)function withArguments:(NSArray *)arguments {
    // 打點方法執行前調用:參數為執行對象、方法名、方法參數
}
+ (void)object:(id)object didInvokeFunction:(NSString *)function withArguments:(NSArray *)arguments {
    // 打點方法執行後調用
}

思路:forwardInvocation: 會在轉發時被調用,並帶回方法名、參數、執行對象等全部信息。所以只需讓被打點的方法先走一次消息轉發,在其中拿到信息後再調用原實現即可。具體:1. 按 observeItems 拿到被打點類與方法;2. 把 method 替換到 forwardInvocation:,同時添加一個指向原實現的 newMethod;3. 在 forwardInvocation: 中解析 invocation 取信息打點;4. 調用 newMethod 執行原實現。

說到這,看過 JSPatch 源碼的同學應該已想到——這正是 JSPatch.overrideMethod() 的原理。先看實現:

+ (void)load {
    _nilObject = [NSObject new];
    [[self observeItems] enumerateKeysAndObjectsUsingBlock:^(NSString *_Nonnull className, id _Nonnull selectors, BOOL *_Nonnull stop) {
        Class cls = NSClassFromString(className);
        if ([selectors isKindOfClass:[NSString class]]) {
            [self replaceClass:cls function:selectors];
        } else if ([selectors isKindOfClass:[NSArray class]]) {
            for (NSString *selectorName in selectors) {
                [self replaceClass:cls function:selectorName];
            }
        }
    }];
}
+ (void)replaceClass:(Class)cls function:(NSString *)selectorName {
    SEL selector = NSSelectorFromString(selectorName);       // 被打點的方法名
    SEL forwardSelector = HHOriginSeletor(selectorName);     // 指向原實現的新方法名
    Method method = class_getInstanceMethod(cls, selector);
    if (method != nil) {
        IMP msgForwardIMP = _objc_msgForward;
#if !defined(__arm64__)
        // 非 64 位架構下,返回大結構體的方法需用 _objc_msgForward_stret
#endif
        IMP originIMP = class_replaceMethod(cls, selector, msgForwardIMP, method_getTypeEncoding(method));
        class_addMethod(cls, forwardSelector, originIMP, method_getTypeEncoding(method));
        class_replaceMethod(cls, @selector(forwardInvocation:), (IMP)HHForwardInvocation, "v@:@");
    }
}
static void HHForwardInvocation(__unsafe_unretained id target, SEL selector, NSInvocation *invocation) {
    NSMutableArray *arguments = [NSMutableArray array];
    NSMethodSignature *methodSignature = [invocation methodSignature];
    for (NSUInteger i = 2; i < methodSignature.numberOfArguments; i++) {
        const char *argumentType = [methodSignature getArgumentTypeAtIndex:i];
        switch (argumentType[0] == 'r' ? argumentType[1] : argumentType[0]) {
            // ... 各種參數類型解析略
            HH_FWD_ARG_CASE('c', char)
            HH_FWD_ARG_CASE('C', unsigned char)
            HH_FWD_ARG_CASE('s', short)
            default: { NSLog(@"error type %s", argumentType); } break;
        }
    }
    NSString *selectorName = NSStringFromSelector(invocation.selector);
    [HHObserver object:target willInvokeFunction:selectorName withArguments:arguments];
    [invocation setSelector:HHOriginSeletor(selectorName)];
    [invocation invoke]; // 執行原實現
    [HHObserver object:target didInvokeFunction:selectorName withArguments:arguments];
}

簡單說明:1. +load 中獲取需打點的類與方法並調用 replaceClass:function:(load 保證只執行一次);2. replaceClass:function: 先 class_replaceMethod 把打點方法替換到 forwardInvocation:,再 class_addMethod 添加指向原實現的新方法,最後把該類的 forwardInvocation: 指向通用的 HHForwardInvocation;3. HHForwardInvocation 中解析 invocation、執行打點、把 selector 設為新方法後 [invocation invoke] 執行原實現。整個調用鏈為:class.method → class.forwardInvocation → HHForwardInvocation → class.newMethod → class.methodIMP。

此時通用打點器就完成了。但有一個問題:既然打點方法借鑑自 JSPatch,那在用 JSPatch 重寫打點方法時會衝突嗎?答案是——完全重寫不衝突,但在重寫方法中調用 ORIGFunc 執行原實現時會衝突。原因在於:我們的打點邏輯在類加載時執行,而 JSPatch 的熱修復在從網絡下載 JS 腳本後才執行,時間點晚得多,所以完全重寫時我們的邏輯會被 JSPatch 完全覆蓋,不衝突。而在 JSPatch 的 overrideMethod 中,它會添加一個 ORIGsomeFunction 指向被重寫方法的原實現——此時原實現已被我們替換成了 _objc_msgForward。因此 JS 端調用 class.ORIGfunc 時又會走回 forwardInvocation → JPForwardInvocation,由於方法名帶 ORIG 前綴在全局字典中找不到對應 JS 實現,便走 JPExecuteORIGForwardInvocation 調用原始轉發,而原始轉發早已被我們替換成 HHForwardInvocation,在那裡再拼上自己的前綴 HH_ORIG,變成 HH_ORIGORIGfunc,仍無實現,於是 crash。

找到原因後就好解決了:JS 調用 ORIGfunc 最終仍會走到我們的 HHForwardInvocation,只是方法名多了 ORIG 前綴,因此只需去掉該前綴再拼上自己的前綴即可:

NSString *selectorName = NSStringFromSelector(invocation.selector);
if ([selectorName hasPrefix:@"ORIG"]) { selectorName = [selectorName substringFromIndex:4]; }
[HHObserver object:target willInvokeFunction:selectorName withArguments:arguments];
[invocation setSelector:HHOriginSeletor(selectorName)];
[invocation invoke];
[HHObserver object:target didInvokeFunction:selectorName withArguments:arguments];

七、ISA Swizzle 和 Method Swizzle

ISA Swizzle 可能是 Runtime 中實際最少用到的。原因很簡單:通過 object_setClass(id, Class) 修改對象的 isa 時,該對象在內存中已加載完成,你能使用的新 class 內存只有原 class 那麼大,因此新 class 的 iVar/Property 不能多也不能少、類型還得一致,否則內存布局對不上,稍不留神就是野指針。iVar 不能亂用,只能打 Method 的主意,而 Method 又有更方便安全的 Method Swizzle。這種尷尬讓 ISA Swizzle 的出場幾乎只剩「KVO 的實現原理?——ISA Swizzle!」。不過它倒能在不改變類任何邏輯的前提下增加類的功能性,相比同樣能勝任的繼承與裝飾,顯得神不知鬼不覺,這或許就是它的優點。作者實際開發中沒用過,這裡略過。

反之,Method Swizzle 可能是 Runtime 系列用得最多、寫得最多的。這裡不贅述原理與實現,而是提出一個問題。先描述應用場景:

@implementation UIViewController (LogWhenDealloc)
+ (void)load {
    Method originDealloc = class_getInstanceMethod(self, NSSelectorFromString(@"dealloc"));
    Method swizzleDealloc = class_getInstanceMethod(self, @selector(swizzleDealloc));
    method_exchangeImplementations(originDealloc, swizzleDealloc);
}
- (void)swizzleDealloc {
    NSString *className = NSStringFromClass([self class]);
    if (![className hasPrefix:@"UI"] && ![className hasPrefix:@"_UI"]) {
        NSLog(@"------ Dealloc : %@ ------", className);
    }
    [self swizzleDealloc];
}
@end
@implementation UIControl (Statistic)
+ (void)load {
    Method originMethod = class_getInstanceMethod(self, @selector(sendAction:to:forEvent:));
    Method swizzleMethod = class_getInstanceMethod(self, @selector(swizzleSendAction:to:forEvent:));
    method_exchangeImplementations(originMethod, swizzleMethod);
}
- (void)swizzleSendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event {
    // 打點邏輯
    [self swizzleSendAction:action to:target forEvent:event];
}
@end

前者用來提示某 VC 是否在返回後正確釋放,後者則是統計 Button 點擊的打點工具。正常情況下大多數系統類都能通過 Method Swizzle 交換方法,在方法前後插入自己的邏輯,但對 NSArray/NSNumber/NSUUID 這類「類簇」卻行不通——它們通常只有一個暴露通用接口的基類,實現卻分散在各子類,所以要 Swizzle 就得找准具體實現類:

@implementation NSArray (SafeArray)
+ (void)load {
    Method originMethod = class_getInstanceMethod(objc_getClass("__NSArrayI"), @selector(objectAtIndex:));
    Method swizzleMethod = class_getInstanceMethod(objc_getClass("__NSArrayI"), @selector(swizzleObjectAtIndex:));
    method_exchangeImplementations(originMethod, swizzleMethod);
}
- (id)swizzleObjectAtIndex:(NSUInteger)index {
    // NSLog(@"1");
    return index < self.count ? [self swizzleObjectAtIndex:index] : nil;
}
@end

該 Category 交換了不可變數組 __NSArrayI 的 objectAtIndex:,並對 index 做判斷以防越界。注意這裡有一行被注釋的 NSLog——如果打開它,不可變數組調用 objectAtIndex: 後,控制台會輸出無數個 1,主線程隨之休眠,點擊屏幕後又開始輸出、再次休眠,如此反復,表現得就像用 runloop 刻意實現的不卡 UI 的線程阻塞。這正是本小節乃至本文的問題所在:為什麼僅僅一行簡單的 NSLog 就會導致主線程休眠?知道具體原因的朋友,歡迎在評論區留言或私信交流。

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