前言
本文不是「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;
}
@endHHClassInfo 描述某個類所有需要解析的變量信息,構造時從該類一直遍歷到基類收集變量;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;
}
@end2. 根據具體類的變量信息進行賦值。
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;
}
@endJava 後台對空字段默認返回 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,越界返回 nullHHArray 是 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;
}
@endHHNotifier 對外提供添加/移除代理的接口,內部用 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 就會導致主線程休眠?知道具體原因的朋友,歡迎在評論區留言或私信交流。