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

神奇的 BlocksKit(二):用 Runtime 打造動態代理的底層奧秘

編輯:iOS 開發基礎

關注倉庫,及時獲得更新: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 為例,換成別的類同理):

  1. A2BlockInvocation

  2. A2DynamicDelegate

  3. NSObject+A2DynamicDelegate

  4. A2DynamicUITextFieldDelegate

  5. UITextField+BlocksKit

A2BlockInvocation

A2BlockInvocation 的定位很單一:存儲與轉發 block。之所以先講它,是因為它足夠底層,涉及不少「奇技淫巧」,一次說完比反覆跳轉更清爽。

在 Objective-C 裡,方法乃至 block 都帶有類型簽名:

@interface NSMethodSignature : NSObject {
    ...
    @property (readonly) NSUInteger numberOfArguments;
    ...
    @property (readonly) const char *methodReturnType NS_RETURNS_INNER_POINTER;
    ...
}
@end

返回類型、參數個數、參數類型,一應俱全。

Block 結構體

沒有任何系統 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 源碼相互印證。

typeSignatureForBlock

拿到結構體之後,取簽名就是一次指針偏移:

+ (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]);
}

methodSignatureForBlockSignature

+ (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 用法可參考相關文檔。

isSignature:compatibleWithSignature:

這個類最後一塊重要拼圖,是判斷 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;
}

invokeWithInvocation:returnValue:outReturnValue:

這一節看 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

A2DynamicDelegate 是 BlocksKit 動態代理的核心樞紐,它用 block 把各類代理與數據源協議給實現了。

它的父類是 NSProxy——一個天生為「替別人代理」而存在的類。

@interface NSProxy

NSProxy 的細節這裡不展開,有興趣可自行查閱。作為其子類,A2DynamicDelegate 必須覆寫 methodSignatureForSelector: 與 forwardInvocation: 才能完成消息轉發,這一點蘋果官方文檔有明確要求。

覆寫 methodSignatureForSelector:

- (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 上。

覆寫 forwardInvocation:

- (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 是否響應,響應則把消息轉發過去。

blockImplementationForMethod: 與 implementMethod:withBlock:

這對方法相當於 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 上。

NSObject+A2DynamicDelegate

這個分類向所有對象開放一組便捷接口,用來取得對應的動態代理:

@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;
}

NSObject+A2BlockDelegate

概述部分其實已經見過這個分類裡最重要的 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 接管,剩下的工作就是讓動態代理的子類把各個代理方法逐一實現出來。

A2DynamicUITextFieldDelegate

這個私有類與 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,兩條路互不排斥。

UITextField+BlocksKit 與 load

頂層只剩最後一步調用:

+ (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 ...;

寫這篇文章大概花了七天。若有任何疑問,歡迎來信或留言交流。

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