
關注倉庫,及時獲得更新:iOS-Source-Code-Analyze
高能預警:這是一篇長文。BlocksKit 的實現既複雜又有意思,值得慢慢拆。
先說清楚邊界:本文不打算講 block 本身在 iOS 中是如何實現、如何編譯、如何捕獲變量的。如果你想藉這篇文章理解 block 的底層原理,那它幫不上忙。
Block 究竟是什麼?這大概是很多 iOS 初學者共同的第一道坎。把這個問題丟進搜尋引擎,能檢索到幾十萬條結果——足以說明 block 在 iOS 開發中的地位,而且分量還在不斷加重。
本文分析的對象是 BlocksKit v2.2.5 的原始碼,目標是從框架內部看清以下能力是如何實現的:
為 NSArray、NSDictionary、NSSet 及其可變版本 NSMutableArray、NSMutableDictionary、NSMutableSet 添加 bk_each: 之類的方法,快速遍歷集合元素
用 block 完成 NSObject 上的 KVO
為 UIView 增加 bk_whenTapped: 等方法,一行代碼掛上手勢
用 block 取代 UIKit 中的 delegate,核心模塊是 DynamicDelegate
BlocksKit 的能力遠不止這些,本文只針對 v2.2.5,其他版本不在討論範圍內。
框架裡最簡單的一塊,就是給集合類型加遍歷方法:
[@[@1, @2, @3] bk_each:^(id obj) {
NSLog(@"%@", obj);
}];系統其實自帶了 enumerateObjectsUsingBlock:,功能等價:
[@[@1, @2, @3] enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
NSLog(@"%@", obj);
}];
// 2016-03-05 16:02:57.295 Draveness[10725:453402] 1
// 2016-03-05 16:02:57.296 Draveness[10725:453402] 2
// 2016-03-05 16:02:57.297 Draveness[10725:453402] 3而 bk_each: 的實現也只是薄薄一層包裝:
- (void)bk_each:(void (^)(id obj))block {
NSParameterAssert(block != nil);
[self enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
block(obj);
}];
}先擋掉空 block,再把每個元素交給外部傳入的 block。
這些方法在 Ruby、Haskell 等語言裡都能找到對應物,接觸過那些語言的讀者理解起來會更快。不過這並非本文重點。
// NSArray+BlocksKit.h - (void)bk_each:(void (^)(id obj))block; - (void)bk_apply:(void (^)(id obj))block; - (id)bk_match:(BOOL (^)(id obj))block; - (NSArray *)bk_select:(BOOL (^)(id obj))block; - (NSArray *)bk_reject:(BOOL (^)(id obj))block; - (NSArray *)bk_map:(id (^)(id obj))block; - (id)bk_reduce:(id)initial withBlock:(id (^)(id sum, id obj))block; - (NSInteger)bk_reduceInteger:(NSInteger)initial withBlock:(NSInteger(^)(NSInteger result, id obj))block; - (CGFloat)bk_reduceFloat:(CGFloat)inital withBlock:(CGFloat(^)(CGFloat result, id obj))block; - (BOOL)bk_any:(BOOL (^)(id obj))block; - (BOOL)bk_none:(BOOL (^)(id obj))block; - (BOOL)bk_all:(BOOL (^)(id obj))block; - (BOOL)bk_corresponds:(NSArray *)list withBlock:(BOOL (^)(id obj1, id obj2))block;
NSObject 是 iOS 裡名副其實的「上帝類」。往它身上加方法,等於給幾乎所有 Cocoa Touch 類都開了後門。這部分拆成三塊來講:
AssociatedObject
BlockExecution
BlockObservation
只要和 runtime 打過交道,就很難不知道 AssociatedObject。想給一個已存在的類添幾個屬性,通常就得靠它。BlocksKit 把這件事包得更順手,連分類都不用自己建:
NSObject *test = [[NSObject alloc] init]; [test bk_associateValue:@"Draveness" withKey:@" name"]; NSLog(@"%@", [test bk_associatedValueForKey:@"name"]); // 2016-03-05 16:02:25.761 Draveness[10699:452125] Draveness
- (void)bk_associateValue:(id)value withKey:(const void *)key {
objc_setAssociatedObject(self, key, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}這裡用的策略是 OBJC_ASSOCIATION_RETAIN_NONATOMIC,等價於 retain nonatomic。完整的枚舉如下:
typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
OBJC_ASSOCIATION_ASSIGN = 0,
OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,
OBJC_ASSOCIATION_COPY_NONATOMIC = 3,
OBJC_ASSOCIATION_RETAIN = OBJC_ASSOCIATION_RETAIN,
OBJC_ASSOCIATION_COPY = OBJC_ASSOCIATION_COPY,
};值得留意的是,這個枚舉裡沒有 weak 選項。
BlocksKit 繞了一圈,自己實現了「弱關聯」:
- (void)bk_weaklyAssociateValue:(__autoreleasing id)value withKey:(const void *)key {
_BKWeakAssociatedObject *assoc = objc_getAssociatedObject(self, key);
if (!assoc) {
assoc = [_BKWeakAssociatedObject new];
[self bk_associateValue:assoc withKey:key];
}
assoc.value = value;
}思路是:既然不能直接關聯一個弱引用,那就關聯一個中間對象,讓這個中間對象去持有 weak 屬性:
@interface _BKWeakAssociatedObject : NSObject @property (nonatomic, weak) id value; @end @implementation _BKWeakAssociatedObject @end
取值的 getter 也相應地多繞一層:
- (id)bk_associatedValueForKey:(const void *)key {
id value = objc_getAssociatedObject(self, key);
if (value && [value isKindOfClass:[_BKWeakAssociatedObject class]]) {
return [(_BKWeakAssociatedObject *)value value];
}
return value;
}靠這組接口,可以在任意對象上安全、異步地跑 block,並且支持執行前取消:
- (id)bk_performOnQueue:(dispatch_queue_t)queue
afterDelay:(NSTimeInterval)delay
usingBlock:(void (^)(id obj))block {
NSParameterAssert(block != nil);
return BKDispatchCancellableBlock(queue, delay, ^{
block(self);
});
}關鍵不是判空,而是返回了一個可取消的 block,它由靜態函數 BKDispatchCancellableBlock 造出來:
static id BKDispatchCancellableBlock(dispatch_queue_t queue, NSTimeInterval delay, void (^block)(void)) {
dispatch_time_t time = BKTimeDelay(delay);
#if DISPATCH_CANCELLATION_SUPPORTED
if (BKSupportsDispatchCancellation()) {
dispatch_block_t ret = dispatch_block_create(0, block);
dispatch_after(time, queue, ret);
return ret;
}
#endif
__block BOOL cancelled = NO;
void (^wrapper)(BOOL) = ^(BOOL cancel) {
if (cancel) {
cancelled = YES;
return;
}
if (!cancelled) block();
};
dispatch_after(time, queue, ^{
wrapper(NO);
});
return wrapper;
}先由 BKSupportsDispatchCancellation 判斷當前系統是否支持用 GCD 取消 block(一般來說都支持):
支持:派發後直接返回 dispatch_block_t
不支持:手工包一層可取消的 block
手工方案的巧妙之處在於,派發出去的那個 block 一定會執行,但執行與否由外部的 cancelled 標誌說了算:
__block BOOL cancelled = NO;
void (^wrapper)(BOOL) = ^(BOOL cancel) {
if (cancel) {
cancelled = YES;
return;
}
if (!cancelled) block();
};
dispatch_after(time, queue, ^{
wrapper(NO);
});
return wrapper;dispatch_after -> cancelled = NO wrapper(YES) -> cancelled = YES wrapper(NO) -> cancelled = YES,block 不會執行
取消入口就是這一段:
+ (void)bk_cancelBlock:(id)block {
NSParameterAssert(block != nil);
#if DISPATCH_CANCELLATION_SUPPORTED
if (BKSupportsDispatchCancellation()) {
dispatch_block_cancel((dispatch_block_t)block);
return;
}
#endif
void (^wrapper)(BOOL) = (void (^)(BOOL))block;
wrapper(YES);
}GCD 支持就調 dispatch_block_cancel,不支持就調一次 wrapper(YES)。
BlocksKit 的 KVO 封裝分兩層:
NSObject 的分類提供便利接口
私有類 _BKObserver 承擔真正的原生 KVO 工作
NSObject+BKBlockObservation 裡的絕大多數接口最終都彙到這個方法:
- (void)bk_addObserverForKeyPaths:(NSArray *)keyPaths
identifier:(NSString *)identifier
options:(NSKeyValueObservingOptions)options
context:(BKObserverContext)context
task:(id)task {
// 1. 檢查參數,省略
// 2. 使用神奇的方法在分類中覆寫 dealloc
NSMutableDictionary *dict;
_BKObserver *observer = [[_BKObserver alloc] initWithObservee:self
keyPaths:keyPaths
context:context
task:task];
[observer startObservingWithOptions:options];
// 3. 惰性初始化 bk_observerBlocks,省略
dict[identifier] = observer;
}核心就一句:造一個 _BKObserver,開始觀察,然後以 {identifier: observer} 存進字典。
這一節值得細說,因為它戳中了寫框架時最棘手的老問題。
當你在分類裡註冊通知或添加 KVO,往往找不到合適的時機去註銷。原因很直接:分類中無法實現 dealloc。在 iOS 8 及更早的系統上,對象釋放而通知未移除,事件再次觸發時就會向已釋放的對象發消息,直接崩潰。
BlocksKit 的解法相當漂亮:
Class classToSwizzle = self.class;
// 獲取所有修改過 dealloc 方法的類
NSMutableSet *classes = self.class.bk_observedClassesHash;
// 保證互斥,避免 classes 出現難以預測的結果
@synchronized (classes) {
// 判斷當前類是否已修改過 dealloc,減少重複調劑
NSString *className = NSStringFromClass(classToSwizzle);
if (![classes containsObject:className]) {
SEL deallocSelector = sel_registerName("dealloc");
__block void (*originalDealloc)(__unsafe_unretained id, SEL) = NULL;
id newDealloc = ^(__unsafe_unretained id objSelf) {
// 在 dealloc 之前移除所有 observer
[objSelf bk_removeAllBlockObservers];
if (originalDealloc == NULL) {
// 沒有找到原有 dealloc,則調用父類實現
struct objc_super superInfo = {
.receiver = objSelf,
.super_class = class_getSuperclass(classToSwizzle)
};
void (*msgSend)(struct objc_super *, SEL) = (__typeof__(msgSend))objc_msgSendSuper;
msgSend(&superInfo, deallocSelector);
} else {
originalDealloc(objSelf, deallocSelector);
}
};
IMP newDeallocIMP = imp_implementationWithBlock(newDealloc);
if (!class_addMethod(classToSwizzle, deallocSelector, newDeallocIMP, "v@:")) {
Method deallocMethod = class_getInstanceMethod(classToSwizzle, deallocSelector);
originalDealloc = (void (*)(__unsafe_unretained id, SEL))method_getImplementation(deallocMethod);
originalDealloc = (void (*)(__unsafe_unretained id, SEL))method_setImplementation(deallocMethod, newDeallocIMP);
}
[classes addObject:className];
}
}執行順序梳理如下:
先用 bk_observedClassesHash 拿到已調劑過的類集合
用 @synchronized 保證互斥,避免並發修改集合
判斷當前類是否調劑過 dealloc
若未調劑,用 sel_registerName("dealloc") 取得選擇子(此處並非真正註冊,而是取回已註冊的選擇子)
在新的 dealloc 中先移除 Observer,再走原有實現
新的 dealloc 本體:
id newDealloc = ^(__unsafe_unretained id objSelf) {
[objSelf bk_removeAllBlockObservers];
if (originalDealloc == NULL) {
struct objc_super superInfo = {
.receiver = objSelf,
.super_class = class_getSuperclass(classToSwizzle)
};
void (*msgSend)(struct objc_super *, SEL) = (__typeof__(msgSend))objc_msgSendSuper;
msgSend(&superInfo, deallocSelector);
} else {
originalDealloc(objSelf, deallocSelector);
}
};
IMP newDeallocIMP = imp_implementationWithBlock(newDealloc);兩件事:先移除所有觀察者(這才是目的),再根據 originalDealloc 是否為空,決定向父類發消息或直接調用原實現。
接著替換方法實現:
if (!class_addMethod(classToSwizzle, deallocSelector, newDeallocIMP, "v@:")) {
Method deallocMethod = class_getInstanceMethod(classToSwizzle, deallocSelector);
originalDealloc = (void (*)(__unsafe_unretained id, SEL))method_getImplementation(deallocMethod);
originalDealloc = (void (*)(__unsafe_unretained id, SEL))method_setImplementation(deallocMethod, newDeallocIMP);
}四步:嘗試添加方法(幾乎必然失敗,因為類裡本來就有 dealloc);取出原實現;先存一份 originalDealloc 以防設置過程中被調用;再執行替換並把返回值再存一次,防止實現已變。
_BKObserver 是真正承擔觀察職責的對象,接口中定義了四個屬性:
@property (nonatomic, readonly, unsafe_unretained) id observee; @property (nonatomic, readonly) NSMutableArray *keyPaths; @property (nonatomic, readonly) id task; @property (nonatomic, readonly) BKObserverContext context;
初始化方法足夠直白,這裡略過。重點在創建之後緊接著的這一句:
_BKObserver *observer = [[_BKObserver alloc] initWithObservee:self keyPaths:keyPaths context:context task:task]; [observer startObservingWithOptions:options];
- (void)startObservingWithOptions:(NSKeyValueObservingOptions)options {
@synchronized (self) {
if (_isObserving) return;
// 遍歷 keyPaths 實現 KVO
_isObserving = YES;
}
}其中核心片段是:
[self.keyPaths bk_each:^(NSString *keyPath) {
[self.observee addObserver:self forKeyPath:keyPath options:options context:BKBlockObservationContext];
}];遍歷自己的 keyPaths,讓 _BKObserver 以觀察者身份去監視 observee。停止觀察的 _stopObservingLocked 邏輯幾乎鏡像:
[keyPaths bk_each:^(NSString *keyPath) {
[observee removeObserver:self forKeyPath:keyPath context:BKBlockObservationContext];
}];最後是 KVO 必備的回调:
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context {
if (context != BKBlockObservationContext) return;
@synchronized (self) {
switch (self.context) {
case BKObserverContextKey: {
void (^task)(id) = self.task;
task(object);
break;
}
case BKObserverContextKeyWithChange: {
void (^task)(id, NSDictionary *) = self.task;
task(object, change);
break;
}
case BKObserverContextManyKeys: {
void (^task)(id, NSString *) = self.task;
task(object, keyPath);
break;
}
case BKObserverContextManyKeysWithChange: {
void (^task)(id, NSString *, NSDictionary *) = self.task;
task(object, keyPath, change);
break;
}
}
}
}按 context 對 task 做類型轉換,再把相應的參數遞進去,就完成了。
這一節看 BlocksKit 如何改造幾個簡單控件,分兩部分:
UIGestureRecognizer、UIBarButtonItem、UIControl
UIView
先看一個 UITapGestureRecognizer 的用法:
UITapGestureRecognizer *singleTap = [UITapGestureRecognizer bk_recognizerWithHandler:^(id sender) {
NSLog(@"Single tap.");
} delay:0.18];
[self addGestureRecognizer:singleTap];bk_recognizerWithHandler:delay: 最終都會走 bk_initWithHandler:delay:
- (instancetype)bk_initWithHandler:(void (^)(UIGestureRecognizer *sender, UIGestureRecognizerState state, CGPoint location))block
delay:(NSTimeInterval)delay {
self = [self initWithTarget:self action:@selector(bk_handleAction:)];
if (!self) return nil;
self.bk_handler = block;
self.bk_handlerDelay = delay;
return self;
}注意 target 就是 self,而 selector 在同分類裡實現:
- (void)bk_handleAction:(UIGestureRecognizer *)recognizer {
void (^handler)(UIGestureRecognizer *sender, UIGestureRecognizerState state, CGPoint location) = recognizer.bk_handler;
if (!handler) return;
NSTimeInterval delay = self.bk_handlerDelay;
// 封裝 block 並控制 block 是否可以執行
self.bk_shouldHandleAction = YES;
[NSObject bk_performAfterDelay:delay usingBlock:block];
}由於初始化時已把 block 存進 bk_handler,這裡直接複用 Block Execution 一節的 bk_performAfterDelay:usingBlock: 派發即可。
封裝的細節也沿用了「用標誌位控制執行」的套路:
CGPoint location = [self locationInView:self.view];
void (^block)(void) = ^{
if (!self.bk_shouldHandleAction) return;
handler(self, self.state, location);
};UIBarButtonItem 與 UIControl 用的是幾乎相同的機制:把 target 指向 self,在分類方法裡調用對應 block。
稍微特殊的是 UIControl,因為它有多種 UIControlEvents,所以另造了一個 UIControlWrapper 來打包 handler 與事件:
@property (nonatomic) UIControlEvents controlEvents; @property (nonatomic, copy) void (^handler)(id sender);
wrapper 以 {controlEvents, wrapper} 的形式存進 UIControl 的字典屬性裡。
手勢那層已經鋪好路,UIView 的改造就變得很輕:
- (void)bk_whenTouches:(NSUInteger)numberOfTouches
tapped:(NSUInteger)numberOfTaps
handler:(void (^)(void))block {
if (!block) return;
UITapGestureRecognizer *gesture = [UITapGestureRecognizer bk_recognizerWithHandler:^(UIGestureRecognizer *sender, UIGestureRecognizerState state, CGPoint location) {
if (state == UIGestureRecognizerStateRecognized) block();
}];
gesture.numberOfTouchesRequired = numberOfTouches;
gesture.numberOfTapsRequired = numberOfTaps;
[self.gestureRecognizers enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
if (![obj isKindOfClass:[UITapGestureRecognizer class]]) return;
UITapGestureRecognizer *tap = obj;
BOOL rightTouches = (tap.numberOfTouchesRequired == numberOfTouches);
BOOL rightTaps = (tap.numberOfTapsRequired == numberOfTaps);
if (rightTouches && rightTaps) {
[gesture requireGestureRecognizerToFail:tap];
}
}];
[self addGestureRecognizer:gesture];
}這個分類只有這一個核心方法,其餘都是換參數轉調。特別之處在於它會遍歷現有手勢,對衝突的那些調用 requireGestureRecognizerToFail:,保證新手勢能正常觸發。