
關注倉庫,及時獲得更新:iOS-Source-Code-Analyze
本文是《神奇的 BlocksKit》系列的第二篇,第一篇的內容可以參考:神奇的 BlocksKit(一)。
如果要挑出 BlocksKit 裡最精彩的部分,那一定是動態代理。它用一堆 block 屬性接管了 UIKit 中所有原本要靠 delegate 才能完成的事件,把「設置代理對象」和「實現代理方法」這兩件麻煩事一併省掉,讓控件自己就把回調處理完了。
嚴格來說,代理方法並不是控件自己實現的,而是框架在幕後替我們生成了一套便捷入口——不需要額外構造任何代理對象,方法就已經具備了。更妙的是,這一切的實現過程完全發生在運行時。
先認識這部分涉及的幾個關鍵角色:
A2BlockInvocation:負責存儲與轉發 block
A2DynamicDelegate:真正承擔代理與數據源職責的類,它是 NSProxy 的子類
NSObject+A2DynamicDelegate:對外提供 bk_dynamicDelegate、bk_dynamicDataSource 等接口,返回 A2DynamicDelegate 的實例
NSObject+A2BlockDelegate:把代理方法與 block 一一映射起來
各個 UIKit 分類:暴露對應的 block 屬性,並在相應的 A2DynamicDelegate 子類中落地代理方法
整體的類結構大致如下:

接下來先自頂向下把工作原理串一遍,再自底向上拆解每個模塊。
我們拿 UIImagePickerController 開刀,因為它相關的代碼量最少,能過濾掉大量無關的實現細節。
頭文件裡只聲明了兩個 block 屬性,分別對應兩個代理方法:
@property (nonatomic, copy) void (^bk_didFinishPickingMediaBlock)(UIImagePickerController *, NSDictionary *); @property (nonatomic, copy) void (^bk_didCancelBlock)(UIImagePickerController *);
實現文件則用 @dynamic 把存取方法交給運行時去生成:
@dynamic bk_didFinishPickingMediaBlock; @dynamic bk_didCancelBlock;
整個 BlocksKit 分類裡只多了一個 load 方法:
+ (void)load {
@autoreleasepool {
[self bk_registerDynamicDelegate];
[self bk_linkDelegateMethods:@{
@"bk_didFinishPickingMediaBlock": @"imagePickerController:didFinishPickingMediaWithInfo:",
@"bk_didCancelBlock": @"imagePickerControllerDidCancel:"
}];
}
}把這些工作放在 load 裡,好處是整個生命周期只執行一次;再套一層 autoreleasepool,則是為了讓註冊代理、鏈接方法過程中產生的臨時對象不污染外部環境。
bk_registerDynamicDelegate 來自 NSObject+A2BlockDelegate,它的任務是改寫原有 delegate 存取方法的實現,把真正的代理對象換成 A2DynamicUIImagePickerControllerDelegate(這個私有類與分類同處一個文件,後文會講)。
再往下一層,NSObject+A2DynamicDelegate 中的 bk_registerDynamicDelegateNamed:forProtocol: 會把 @selector(delegate) 與 @selector(setDelegate:) 的實現整體替換掉:
IMP setterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject, id delegate) {
A2DynamicDelegate *dynamicDelegate = getDynamicDelegate(delegatingObject, protocol, infoAsPtr, YES);
if ([delegate isEqual:dynamicDelegate]) {
delegate = nil;
}
dynamicDelegate.realDelegate = delegate;
});
IMP getterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject) {
return [delegatingObject bk_dynamicDelegateForProtocol:a2_protocolForDelegatingObject(delegatingObject, protocol)];
});也就是說,此後讀取 delegate 拿到的是 A2DynamicUIImagePickerControllerDelegate,而開發者原本設置的代理被搬到了 realDelegate 上。
load 中的第二步 bk_linkDelegateMethods: 負責把代理方法的選擇子與 block 屬性掛鉤,之後就能靠選擇子反查 block:
IMP getterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject) {
A2DynamicDelegate *delegate = getDynamicDelegate(delegatingObject, protocol, info, NO);
return [delegate blockImplementationForMethod:selector];
});
IMP setterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject, id block) {
A2DynamicDelegate *delegate = getDynamicDelegate(delegatingObject, protocol, info, YES);
[delegate implementMethod:selector withBlock:block];
});兩個方法最終都落到 A2DynamicDelegate 的 blockImplementationForMethod: 與 implementMethod:withBlock: 上,block 的存取就此變成了動態行為。
當系統真正觸發 imagePickerController:didFinishPickingMediaWithInfo: 時,由於 A2DynamicUIImagePickerControllerDelegate 才是名義上的代理,因此進入的是它的實現:
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info {
id realDelegate = self.realDelegate;
if (realDelegate && [realDelegate respondsToSelector:@selector(imagePickerController:didFinishPickingMediaWithInfo:)]) {
[realDelegate imagePickerController:picker didFinishPickingMediaWithInfo:info];
}
void (^block)(UIImagePickerController *, NSDictionary *) = [self blockImplementationForMethod:_cmd];
if (block) block(picker, info);
}先問一句 realDelegate 要不要響應,然後用 _cmd 反查 block,取出來帶上參數執行。
把整條鏈路濃縮成四步:
load 裡註冊動態代理並建立代理方法與 block 的映射
運行時改寫 delegate 的存取方法,用 A2DynamicDelegate 頂替原代理,原代理轉存到 realDelegate
為 block 屬性動態生成存取方法,讀寫都落在對應 A2DynamicDelegate 子類內部
代理方法觸發時,先看 realDelegate 是否響應,再無論如何都按選擇子查出 block 並執行

下面按從底層到頂層的順序推進(以 UITextField 為例,換成別的類同理):
A2BlockInvocation
A2DynamicDelegate
NSObject+A2DynamicDelegate
A2DynamicUITextFieldDelegate
UITextField+BlocksKit
A2BlockInvocation 的定位很單一:存儲與轉發 block。之所以先講它,是因為它足夠底層,涉及不少「奇技淫巧」,一次說完比反覆跳轉更清爽。
在 Objective-C 裡,方法乃至 block 都帶有類型簽名:
@interface NSMethodSignature : NSObject {
...
@property (readonly) NSUInteger numberOfArguments;
...
@property (readonly) const char *methodReturnType NS_RETURNS_INNER_POINTER;
...
}
@end返回類型、參數個數、參數類型,一應俱全。
沒有任何系統 API 能直接給出 block 的簽名,它藏在 block 的內存結構裡:
typedef NS_OPTIONS(int, BKBlockFlags) {
BKBlockFlagsHasCopyDisposeHelpers = (1 << 25),
BKBlockFlagsHasSignature = (1 << 30)
};
typedef struct _BKBlock {
__unused Class isa;
BKBlockFlags flags;
__unused int reserved;
void (__unused *invoke)(struct _BKBlock *block, ...);
struct {
unsigned long int reserved;
unsigned long int size;
// requires BKBlockFlagsHasCopyDisposeHelpers
void (*copy)(void *dst, const void *src);
void (*dispose)(const void *);
// requires BKBlockFlagsHasSignature
const char *signature;
const char *layout;
} *descriptor;
// imported variables
} *BKBlockRef;這基本就是 block 在內存中的真實模樣,可以與 runtime 源碼相互印證。
拿到結構體之後,取簽名就是一次指針偏移:
+ (NSMethodSignature *)typeSignatureForBlock:(id)block __attribute__((pure, nonnull(1))) {
BKBlockRef layout = (__bridge void *)block;
// 如果 block 沒有簽名直接返回空
if (!(layout->flags & BKBlockFlagsHasSignature))
return nil;
void *desc = layout->descriptor;
desc += 2 * sizeof(unsigned long int);
if (layout->flags & BKBlockFlagsHasCopyDisposeHelpers)
desc += 2 * sizeof(void *);
if (!desc)
return nil;
const char *signature = (*(const char **)desc);
return [NSMethodSignature signatureWithObjCTypes:signature];
}依據 flag 逐段跳過 descriptor 的前置字段,最後抵達 signature 所在的地址,邏輯直白。
值得牢記的一點:Unlike a typical method signature, a block type signature has no self ('@') or _cmd (':') parameter, but instead just one parameter for the block itself ('@?').
也就是說,block 的類型簽名裡沒有 self(@)與 _cmd(:),只有一個代表 block 自身的參數(@?)。@、:、@? 的含義可查閱 Objective-C 的類型編碼文檔。
對比一下就很清楚:
^(UIActionSheet *) {}
// 參數類型:@?(@"UIActionSheet")
// 返回類型:v
- (void)willPresentActionSheet:(UIActionSheet *)actionSheet
// 參數類型:@:@
// 返回類型:v之所以給 @"UIActionSheet" 套上括號,是因為它和前面的 @ 屬於同一個參數;而 UIActionSheet 本身也是 id 的派生類型,編碼同樣是 @。
於是 initWithBlock: 的實現順理成章——先取 block 簽名,再構造一個兼容的方法簽名:
- (instancetype)initWithBlock:(id)block {
NSParameterAssert(block);
NSMethodSignature *blockSignature = [[self class] typeSignatureForBlock:block];
NSMethodSignature *methodSignature = [[self class] methodSignatureForBlockSignature:blockSignature];
NSAssert(methodSignature, @"Incompatible block: %@", block);
return (self = [self initWithBlock:block methodSignature:methodSignature blockSignature:blockSignature]);
}+ (NSMethodSignature *)methodSignatureForBlockSignature:(NSMethodSignature *)original {
// 構造方法簽名
NSMutableString *signature = [[NSMutableString alloc] initWithCapacity:original.numberOfArguments + 1];
// 返回類型,id 類型(self @),選擇子類型(SEL :)
const char *retTypeStr = original.methodReturnType;
[signature appendFormat:@"%s%s%s", retTypeStr, @encode(id), @encode(SEL)];
// signature = (返回類型)@:
for (NSUInteger i = 1; i < original.numberOfArguments; i++) {
const char *typeStr = [original getArgumentTypeAtIndex:i];
NSString *type = [[NSString alloc] initWithBytesNoCopy:(void *)typeStr
length:strlen(typeStr)
encoding:NSUTF8StringEncoding
freeWhenDone:NO];
[signature appendString:type];
}
// signature = (返回類型)@:(參數類型)
return [NSMethodSignature signatureWithObjCTypes:signature.UTF8String];
}本質上就是把 @?(@"UIActionSheet") 這種 block 簽名翻譯成 @:@ 形式的方法簽名。代碼中的 @encode 用法可參考相關文檔。
這個類最後一塊重要拼圖,是判斷 block 與方法簽名能否匹配:
+ (BOOL)isSignature:(NSMethodSignature *)signatureA
compatibleWithSignature:(NSMethodSignature *)signatureB __attribute__((pure)) {
// 1. 參數檢查,省略
// 2. 判斷返回值是否相同
if (signatureA.methodReturnType[0] != signatureB.methodReturnType[0])
return NO;
// 3. 設置 methodSignature 和 blockSignature
// 4. 比較 methodSignature 和 blockSignature
return YES;
}第 3 步的關鍵在於:方法簽名天生比 block 簽名多一個隱含參數(self 與 SEL),所以把參數更多的當作 methodSignature。
NSMethodSignature *methodSignature = nil, *blockSignature = nil;
if (signatureA.numberOfArguments > signatureB.numberOfArguments) {
methodSignature = signatureA;
blockSignature = signatureB;
} else if (signatureB.numberOfArguments > signatureA.numberOfArguments) {
methodSignature = signatureB;
blockSignature = signatureA;
} else {
return NO;
}第 4 步則是逐位比對,注意索引錯位一即可:
NSUInteger numberOfArguments = methodSignature.numberOfArguments;
for (NSUInteger i = 2; i < numberOfArguments; i++) {
if ([methodSignature getArgumentTypeAtIndex:i][0] != [blockSignature getArgumentTypeAtIndex:i - 1][0])
return NO;
}這一節看 A2BlockInvocation 真正去執行一個 NSInvocation 時的所作所為:
- (BOOL)invokeWithInvocation:(NSInvocation *)outerInv
returnValue:(out NSValue **)outReturnValue
setOnInvocation:(BOOL)setOnInvocation {
// 1. 參數以及類型簽名是否匹配的檢查,省略
NSInvocation *innerInv = [NSInvocation invocationWithMethodSignature:self.blockSignature];
// 2. 設置 innerInv 參數
// 3. 獲取返回值
free(argBuf);
return YES;
}第 2、3 步的細節如下:
void *argBuf = NULL;
for (NSUInteger i = 2; i < sig.numberOfArguments; i++) {
const char *type = [sig getArgumentTypeAtIndex:i];
NSUInteger argSize;
NSGetSizeAndAlignment(type, &argSize, NULL);
if (!(argBuf = reallocf(argBuf, argSize))) {
return NO;
}
[outerInv getArgument:argBuf atIndex:i];
[innerInv setArgument:argBuf atIndex:i - 1];
}
// 執行 block
NSUInteger retSize = sig.methodReturnLength;
if (retSize) {
if (outReturnValue || setOnInvocation) {
if (!(argBuf = reallocf(argBuf, retSize))) {
return NO;
}
[innerInv getReturnValue:argBuf];
if (setOnInvocation) {
[outerInv setReturnValue:argBuf];
}
if (outReturnValue) {
*outReturnValue = [NSValue valueWithBytes:argBuf objCType:sig.methodReturnType];
}
}
} else {
if (outReturnValue) {
*outReturnValue = nil;
}
}把外層 invocation 的參數一個個搬進 innerInv(索引整體前移一位),執行 block,再把返回值按需要寫回外層或包裝成 NSValue。A2BlockInvocation 到此結束。
A2DynamicDelegate 是 BlocksKit 動態代理的核心樞紐,它用 block 把各類代理與數據源協議給實現了。
它的父類是 NSProxy——一個天生為「替別人代理」而存在的類。
@interface NSProxy
NSProxy 的細節這裡不展開,有興趣可自行查閱。作為其子類,A2DynamicDelegate 必須覆寫 methodSignatureForSelector: 與 forwardInvocation: 才能完成消息轉發,這一點蘋果官方文檔有明確要求。
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
A2BlockInvocation *invocation = nil;
if ((invocation = [self.invocationsBySelectors bk_objectForSelector:aSelector]))
return invocation.methodSignature;
else if ([self.realDelegate methodSignatureForSelector:aSelector])
return [self.realDelegate methodSignatureForSelector:aSelector];
else if (class_respondsToSelector(object_getClass(self), aSelector))
return [object_getClass(self) methodSignatureForSelector:aSelector];
return [[NSObject class] methodSignatureForSelector:aSelector];
}查找順序分四層:
先看 invocationsBySelectors 裡有沒有對應的 A2BlockInvocation,有就說明這個方法已由 block 實現,直接返回它的簽名
再問真正的 realDelegate 是否實現了該選擇子,並取其簽名
接著在自己的類(即 A2DynamicDelegate 子類)裡找
全都不命中,退回 NSObject 的簽名,可能為 nil
realDelegate 就是開發者心裡想的那個代理對象。比如:
self.tableView.delegate = [[UIViewController alloc] init];
這裡的 realDelegate 本該是視圖控制器,但用了 BlocksKit 之後你不需要這麼寫:
self.tableView.realDelegate = [[UIViewController alloc] init];
因為 NSObject+A2BlockDelegate 已經做了方法調劑,你對 delegate 的賦值會被自動轉送到 realDelegate 上。
- (void)forwardInvocation:(NSInvocation *)outerInv {
SEL selector = outerInv.selector;
A2BlockInvocation *innerInv = nil;
if ((innerInv = [self.invocationsBySelectors bk_objectForSelector:selector])) {
[innerInv invokeWithInvocation:outerInv];
} else if ([self.realDelegate respondsToSelector:selector]) {
[outerInv invokeWithTarget:self.realDelegate];
}
}思路與簽名查找如出一轍:命中 block 就交給 invokeWithInvocation: 執行,否則看 realDelegate 是否響應,響應則把消息轉發過去。
這對方法相當於 block 版的 getter 與 setter:
- (id)blockImplementationForMethod:(SEL)selector {
A2BlockInvocation *invocation = nil;
if ((invocation = [self.invocationsBySelectors bk_objectForSelector:selector]))
return invocation.block;
return NULL;
}block 始終被 A2BlockInvocation 包著,所以按選擇子取 block,實則是取出对应的 invocation 再拿它的 block。
- (void)implementMethod:(SEL)selector withBlock:(id)block {
// 1. 參數檢查,省略
if (!block) {
[self.invocationsBySelectors bk_removeObjectForSelector:selector];
return;
}
// 2. 實例化 A2BlockInvocation
[self.invocationsBySelectors bk_setObject:inv forSelector:selector];
}inv 的構造會先看協議裡有沒有該方法的描述,有則用協議簽名,沒有則退回 block 自身簽名:
struct objc_method_description methodDescription =
protocol_getMethodDescription(self.protocol, selector, YES, !isClassMethod);
if (!methodDescription.name)
methodDescription = protocol_getMethodDescription(self.protocol, selector, NO, !isClassMethod);
A2BlockInvocation *inv = nil;
if (methodDescription.name) {
NSMethodSignature *protoSig = [NSMethodSignature signatureWithObjCTypes:methodDescription.types];
inv = [[A2BlockInvocation alloc] initWithBlock:block methodSignature:protoSig];
} else {
inv = [[A2BlockInvocation alloc] initWithBlock:block];
}這兩個方法的存在,是為了讓各個子類能順利把代理方法接到 block 上。
這個分類向所有對象開放一組便捷接口,用來取得對應的動態代理:
@property (readonly, strong) id bk_dynamicDataSource; @property (readonly, strong) id bk_dynamicDelegate; - (id)bk_dynamicDelegateForProtocol:(Protocol *)protocol;
以 UITableView 為例:訪問 tableView.bk_dynamicDataSource 會拿到 A2DynamicUITableViewDataSource 的實例,訪問 tableView.bk_dynamicDelegate 則拿到 A2DynamicUITableViewDelegate 的實例。
這些對象都是後台線程裡惰性初始化的:
- (id)bk_dynamicDelegateWithClass:(Class)cls forProtocol:(Protocol *)protocol {
__block A2DynamicDelegate *dynamicDelegate;
dispatch_sync(a2_backgroundQueue(), ^{
dynamicDelegate = objc_getAssociatedObject(self, (__bridge const void *)protocol);
if (!dynamicDelegate) {
dynamicDelegate = [[cls alloc] initWithProtocol:protocol];
objc_setAssociatedObject(self, (__bridge const void *)protocol, dynamicDelegate, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
});
return dynamicDelegate;
}概述部分其實已經見過這個分類裡最重要的 bk_linkProtocol:methods:,它為所有新增的 block 屬性動態生成存取方法:
IMP getterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject) {
A2DynamicDelegate *delegate = getDynamicDelegate(delegatingObject, protocol, info, NO);
return [delegate blockImplementationForMethod:selector];
});
IMP setterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject, id block) {
A2DynamicDelegate *delegate = getDynamicDelegate(delegatingObject, protocol, info, YES);
[delegate implementMethod:selector withBlock:block];
});調劑之後的效果是:getter 以選擇子為鍵去動態代理裡查 block;setter 則把 block 以 A2BlockInvocation 的形式存進去。
另一個方法 bk_registerDynamicDelegateNamed:forProtocol: 負責改寫 delegate 本身的存取方法,把原有代理轉存到 realDelegate:
IMP setterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject, id delegate) {
A2DynamicDelegate *dynamicDelegate = getDynamicDelegate(delegatingObject, protocol, infoAsPtr, YES);
if ([delegate isEqual:dynamicDelegate]) {
delegate = nil;
}
dynamicDelegate.realDelegate = delegate;
});
IMP getterImplementation = imp_implementationWithBlock(^(NSObject *delegatingObject) {
return [delegatingObject bk_dynamicDelegateForProtocol:a2_protocolForDelegatingObject(delegatingObject, protocol)];
});於是最後的行為是:getter 永遠返回動態代理;setter 並不改動 delegate 槽位裡的動態代理,只更新 realDelegate。
至此,block 的存取方法與 delegate 的指向都已經被 runtime 接管,剩下的工作就是讓動態代理的子類把各個代理方法逐一實現出來。
這個私有類與 UITextField+BlocksKit 同文件。挑一個簡單的代理方法來看:
- (void)textFieldDidEndEditing:(UITextField *)textField {
id realDelegate = self.realDelegate;
if (realDelegate && [realDelegate respondsToSelector:@selector(textFieldDidEndEditing:)]) {
[realDelegate textFieldDidEndEditing:textField];
}
void (^block)(UITextField *) = [self blockImplementationForMethod:_cmd];
if (block) block(textField);
}先讓 realDelegate 有機會響應,再執行關聯的 block,兩條路互不排斥。
頂層只剩最後一步調用:
+ (void)load {
[self bk_registerDynamicDelegate];
[self bk_linkDelegateMethods: @{
@"bk_shouldBeginEditingBlock": @"textFieldShouldBeginEditing:",
@"bk_didBeginEditingBlock": @"textFieldDidBeginEditing:",
@"bk_shouldEndEditingBlock": @"textFieldShouldEndEditing:",
@"bk_didEndEditingBlock" : @"textFieldDidEndEditing:",
@"bk_shouldChangeCharactersInRangeWithReplacementStringBlock" : @"textField:shouldChangeCharactersInRange:replacementString:",
@"bk_shouldClearBlock" : @"textFieldShouldClear:",
@"bk_shouldReturnBlock" : @"textFieldShouldReturn:",
}];
}選在 load 裡做,理由有兩個:一是它天然只執行一次,二是只有文件被引用時才觸發,避免無謂的註冊開銷。而 @autoreleasepool 的作用前面已經說過。
這些 UIKit 分類的另一職責,就是聲明 block 屬性並用 @dynamic 標記為動態生成:
@property (nonatomic, copy, nullable) BOOL (^bk_shouldBeginEditingBlock)(UITextField *textField); @property (nonatomic, copy, nullable) void (^bk_didBeginEditingBlock)(UITextField *textField); ... @dynamic bk_shouldBeginEditingBlock, bk_didBeginEditingBlock ...;
寫這篇文章大概花了七天。若有任何疑問,歡迎來信或留言交流。