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

神奇的 BlocksKit(一):從集合遍歷到 KVO 封裝的原始碼之旅

編輯:iOS 開發基礎

關注倉庫,及時獲得更新: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 上的魔法

NSObject 是 iOS 裡名副其實的「上帝類」。往它身上加方法,等於給幾乎所有 Cocoa Touch 類都開了後門。這部分拆成三塊來講:

  1. AssociatedObject

  2. BlockExecution

  3. BlockObservation

添加 AssociatedObject

只要和 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

靠這組接口,可以在任意對象上安全、異步地跑 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)。

用 Block 封裝 KVO

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} 存進字典。

在分類中調劑 dealloc

這一節值得細說,因為它戳中了寫框架時最棘手的老問題。

當你在分類裡註冊通知或添加 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

_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 做類型轉換,再把相應的參數遞進去,就完成了。

改造 UIKit

這一節看 BlocksKit 如何改造幾個簡單控件,分兩部分:

  • UIGestureRecognizer、UIBarButtonItem、UIControl

  • UIView

改造 UIGestureRecognizer、UIBarButtonItem 與 UIControl

先看一個 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

手勢那層已經鋪好路,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:,保證新手勢能正常觸發。

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