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

Method Swizzling 的各種姿勢:從基礎用法到可逆恢復

編輯:iOS 開發基礎

憑藉 Objective-C 的 runtime 機制,Method Swizzling 這門「黑魔法」解決了許多常規手段無能為力的問題:代碼插樁、Hook、Patch 等等。先從最經典的寫法說起——NSHipster 那篇 Method Swizzling 是不少人的入門材料,我們就以它的示例為起點。

#import

@implementation UIViewController (Tracking)

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = [self class];

        SEL originalSelector = @selector(viewWillAppear:);
        SEL swizzledSelector = @selector(xxx_viewWillAppear:);

        Method originalMethod = class_getInstanceMethod(class, originalSelector);
        Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);

        BOOL didAddMethod =
            class_addMethod(class,
                            originalSelector,
                            method_getImplementation(swizzledMethod),
                            method_getTypeEncoding(swizzledMethod));

        if (didAddMethod) {
            class_replaceMethod(class,
                                swizzledSelector,
                                method_getImplementation(originalMethod),
                                method_getTypeEncoding(originalMethod));
        } else {
            method_exchangeImplementations(originalMethod, swizzledMethod);
        }
    });
}

#pragma mark - Method Swizzling

- (void)xxx_viewWillAppear:(BOOL)animated {
    [self xxx_viewWillAppear:animated];
    NSLog(@"viewWillAppear: %@", self);
}

@end

幾個值得留意的細節:

  • 把 Swizzling 寫在 Category 的 +load 中,類加載時會自動執行。load 的調用順序是父類到子類、類自身到 Category。

  • 用 dispatch_once 包裹是一種防護措施,保證代碼塊只執行一次且線程安全。嚴格說這裡並非必需,因為同一個 Category 的 load 不會被多次調用。

  • 先嘗試 class_addMethod,是為了兼容 originalSelector 只在父類中實現的情況——只有這樣才能真正達成交換目的。

  • xxx_viewWillAppear: 內部調用 [self xxx_viewWillAppear:animated] 不會死循環,因為交換之後這個方法已經指向原 viewWillAppear: 的實現。

以上代碼可以進一步簡寫:

+ (void)load {
    Class class = [self class];

    SEL originalSelector = @selector(viewWillAppear:);
    SEL swizzledSelector = @selector(xxx_viewWillAppear:);

    Method originalMethod = class_getInstanceMethod(class, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);

    if (!originalMethod || !swizzledMethod) {
        return;
    }

    IMP originalIMP = method_getImplementation(originalMethod);
    IMP swizzledIMP = method_getImplementation(swizzledMethod);

    const char *originalType = method_getTypeEncoding(originalMethod);
    const char *swizzledType = method_getTypeEncoding(swizzledMethod);

    // 這兒的先後順序是有講究的,如果先執行後一句,那麼在執行完瞬間方法被調用容易引發死循環
    class_replaceMethod(class, swizzledSelector, originalIMP, originalType);
    class_replaceMethod(class, originalSelector, swizzledIMP, swizzledType);
}

之所以能簡化,是因為 class_replaceMethod 一個接口就覆蓋了 class_addMethod 與 method_setImplementation 兩種場景。第一句的行為是:若 viewWillAppear: 實現在父類,則等價於 class_addMethod;否則等價於把原方法的 IMP 指向新的代碼塊。第二句則把新方法的 IMP 指回原實現。

順序必須注意:先把新方法指向原 IMP,再修改原方法的 IMP,反過來會在交換的中間狀態被調用時引發死循環。

除此之外,還有幾類常見場景值得展開。

1. 跨類的 Method Swizzling

上面的示例藉助 Category 新增方法再交換。但有些情況並不適合用 Category,比如目標是私有類、拿不到頭文件聲明。此時該怎麼做?

假設有一個名為 Car 的類,其中有實例方法 - (void)run:(double)speed,我們希望只在速度小於 120 時才執行原邏輯。按交換流程,代碼如下:

#import

@interface MyCar : NSObject
@end

@implementation MyCar

+ (void)load {
    Class originalClass = NSClassFromString(@"Car");
    Class swizzledClass = [self class];

    SEL originalSelector = NSSelectorFromString(@"run:");
    SEL swizzledSelector = @selector(xxx_run:);

    Method originalMethod = class_getInstanceMethod(originalClass, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(swizzledClass, swizzledSelector);

    // 向 Car 類中新添加一個 xxx_run: 的方法
    BOOL registerMethod = class_addMethod(originalClass,
                                          swizzledSelector,
                                          method_getImplementation(swizzledMethod),
                                          method_getTypeEncoding(swizzledMethod));
    if (!registerMethod) {
        return;
    }

    // 需要更新 swizzledMethod 變量,獲取當前 Car 類中 xxx_run: 的 Method 指針
    swizzledMethod = class_getInstanceMethod(originalClass, swizzledSelector);
    if (!swizzledMethod) {
        return;
    }

    // 後續流程與之前的一致
    BOOL didAddMethod = class_addMethod(originalClass,
                                        originalSelector,
                                        method_getImplementation(swizzledMethod),
                                        method_getTypeEncoding(swizzledMethod));
    if (didAddMethod) {
        class_replaceMethod(originalClass,
                            swizzledSelector,
                            method_getImplementation(originalMethod),
                            method_getTypeEncoding(originalMethod));
    } else {
        method_exchangeImplementations(originalMethod, swizzledMethod);
    }
}

- (void)xxx_run:(double)speed {
    if (speed < 120) {
        [self xxx_run:speed];
    }
}

@end

相比之前的流程,前面多了兩個關鍵邏輯:

  • 用 runtime 向目標類 Car 動態添加新方法 xxx_run:,此時 Car 與 MyCar 都具備了這個方法,MyCar 的引導作用就此結束;

  • 為了完成後續 Car 內部 run: 與 xxx_run: 的交換,必須把 swizzledMethod 更新為 Car 中 xxx_run: 對應的 Method。

這一切同樣可以合併簡化:

+ (void)load {
    Class originalClass = NSClassFromString(@"Car");
    Class swizzledClass = [self class];

    SEL originalSelector = NSSelectorFromString(@"run:");
    SEL swizzledSelector = @selector(xxx_run:);

    Method originalMethod = class_getInstanceMethod(originalClass, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(swizzledClass, swizzledSelector);

    IMP originalIMP = method_getImplementation(originalMethod);
    IMP swizzledIMP = method_getImplementation(swizzledMethod);

    const char *originalType = method_getTypeEncoding(originalMethod);
    const char *swizzledType = method_getTypeEncoding(swizzledMethod);

    class_replaceMethod(originalClass, swizzledSelector, originalIMP, originalType);
    class_replaceMethod(originalClass, originalSelector, swizzledIMP, swizzledType);
}

簡化後的形態與 Category 版本幾乎一致,一套代碼就能覆蓋兩種場景。但要清楚此時兩句 class_replaceMethod 的職責已有所不同:

  • 第一句直接在 Car 中註冊 xxx_run:,並把 IMP 指定為原 run: 的實現;

  • 第二句行為與之前一致——run: 實現在 Car 自身時執行 method_setImplementation,實現在父類時執行 class_addMethod。

2. 類方法的 Swizzling

前面處理的都是實例方法,類方法如何做?直接看代碼:

@interface NSDictionary (Test)
@end

@implementation NSDictionary (Test)

+ (void)load {
    Class cls = [self class];

    SEL originalSelector = @selector(dictionary);
    SEL swizzledSelector = @selector(xxx_dictionary);

    // 使用 class_getClassMethod 來獲取類方法的 Method
    Method originalMethod = class_getClassMethod(cls, originalSelector);
    Method swizzledMethod = class_getClassMethod(cls, swizzledSelector);

    if (!originalMethod || !swizzledMethod) {
        return;
    }

    IMP originalIMP = method_getImplementation(originalMethod);
    IMP swizzledIMP = method_getImplementation(swizzledMethod);

    const char *originalType = method_getTypeEncoding(originalMethod);
    const char *swizzledType = method_getTypeEncoding(swizzledMethod);

    // 類方法添加,需要將方法添加到 MetaClass 中
    Class metaClass = objc_getMetaClass(class_getName(cls));

    class_replaceMethod(metaClass, swizzledSelector, originalIMP, originalType);
    class_replaceMethod(metaClass, originalSelector, swizzledIMP, swizzledType);
}

+ (id)xxx_dictionary {
    id result = [self xxx_dictionary];
    return result;
}

@end

與實例方法相比,只有兩處差異:

  • 獲取 Method 改用 class_getClassMethod(Class cls, SEL name),從命名上就能看出它與 class_getInstanceMethod 的區別;

  • 動態添加類方法時,必須添加到 MetaClass——實例方法記錄在 class 的 method-list 中,類方法則記錄在 meta-class 的 method-list 中。

3. 類簇中的 Swizzling

前文成功交換了 NSDictionary 的 + (id)dictionary,但若用同樣思路去交換 - (id)objectForKey:,你會發現毫無效果。

原因在於類簇。平時在 Xcode 調試時,Variables View 裡常會看到 __NSArrayI、__NSCFConstantString 這類 Class——它們是 Foundation 框架中廣泛使用的類簇私有實現,詳情可查閱 Apple 關於 class cluster 的文檔。

所以問題轉化為:如何對類簇中的私有類做 Swizzling。這正是第 1 節「跨類交換」要解決的場景。下面用交換 NSMutableDictionary 的 setObject:forKey: 為例,讓傳入 nil 時不再拋異常:

@interface MySafeDictionary : NSObject
@end

@implementation MySafeDictionary

+ (void)load {
    Class originalClass = NSClassFromString(@"__NSDictionaryM");
    Class swizzledClass = [self class];

    SEL originalSelector = @selector(setObject:forKey:);
    SEL swizzledSelector = @selector(safe_setObject:forKey:);

    Method originalMethod = class_getInstanceMethod(originalClass, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(swizzledClass, swizzledSelector);

    IMP originalIMP = method_getImplementation(originalMethod);
    IMP swizzledIMP = method_getImplementation(swizzledMethod);

    const char *originalType = method_getTypeEncoding(originalMethod);
    const char *swizzledType = method_getTypeEncoding(swizzledMethod);

    class_replaceMethod(originalClass, swizzledSelector, originalIMP, originalType);
    class_replaceMethod(originalClass, originalSelector, swizzledIMP, swizzledType);
}

- (void)safe_setObject:(id)anObject forKey:(id)aKey {
    if (anObject && aKey) {
        [self safe_setObject:anObject forKey:aKey];
    } else if (aKey) {
        [(NSMutableDictionary *)self removeObjectForKey:aKey];
    }
}

@end

4. Swizzling 之後如何恢復

用過這門黑魔法之後,有沒有想過怎麼回到交換之前的狀態?

最常見的方案是加一個開關標識符:邏輯上需要還原時把標志打開,方法體內判斷到標志就直接調用原實現,其餘什麼也不做。這是最安全的做法,也是目前多數代碼的選擇。缺點是優雅度不足——交換的方法一多,每個方法體都要塞進判斷邏輯,還要維護一大堆標志變量。

那有沒有更好的辦法?把前面所有場景歸納一下,Method Swizzling 的核心其實只有兩件事:

  • class_addMethod:添加一個新方法。可能是把別人類中的方法搬進目標類,也可能是把父類實現複製一份到子類,可能是實例方法也可能是類方法——總之是添加。

  • 交換 IMP:改寫方法的實現。除了 method_exchangeImplementations,也可以單獨調用 method_setImplementation,或者在 class_addMethod 時直接指定 IMP 順帶完成交換。

那這兩件事各自能否撤銷?

  • 關於添加:Objective-C 1.0 時代曾有 class_removeMethods,但 2.0 時已被禁用。這說明 Apple 並不鼓勵這樣做——想想也有道理,runtime 接口本就讓人心驚膽戰,又要添加又要刪除,實在容易出岔子。所以只能放棄 remove 的念頭;好在多掛幾個方法通常也無傷大雅。

  • 關於交換:要恢復只需再交換一次即可,完全可行。具體要解決兩個問題:其一,同一個類的同一個方法可能在不同位置被多次 Swizzling,因此必須記錄每一次交換時參與的兩個 IMP;其二,若已經歷多次交換,如何定位這兩個 IMP 所對應的 Method。runtime 提供了 class_copyMethodList,可以取出 Method 列表逐一遍歷比對 IMP。

下面在鍵盤安全字典的示例上補上完整的恢復邏輯:

#import

@interface MySafeDictionary : NSObject
@end

static NSLock *kMySafeLock = nil;
static IMP kMySafeOriginalIMP = NULL;
static IMP kMySafeSwizzledIMP = NULL;

@implementation MySafeDictionary

+ (void)swizzlling {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        kMySafeLock = [[NSLock alloc] init];
    });

    [kMySafeLock lock];

    do {
        if (kMySafeOriginalIMP || kMySafeSwizzledIMP) break;

        Class originalClass = NSClassFromString(@"__NSDictionaryM");
        if (!originalClass) break;

        Class swizzledClass = [self class];

        SEL originalSelector = @selector(setObject:forKey:);
        SEL swizzledSelector = @selector(safe_setObject:forKey:);

        Method originalMethod = class_getInstanceMethod(originalClass, originalSelector);
        Method swizzledMethod = class_getInstanceMethod(swizzledClass, swizzledSelector);

        if (!originalMethod || !swizzledMethod) break;

        IMP originalIMP = method_getImplementation(originalMethod);
        IMP swizzledIMP = method_getImplementation(swizzledMethod);

        const char *originalType = method_getTypeEncoding(originalMethod);
        const char *swizzledType = method_getTypeEncoding(swizzledMethod);

        kMySafeOriginalIMP = originalIMP;
        kMySafeSwizzledIMP = swizzledIMP;

        class_replaceMethod(originalClass, swizzledSelector, originalIMP, originalType);
        class_replaceMethod(originalClass, originalSelector, swizzledIMP, swizzledType);
    } while (NO);

    [kMySafeLock unlock];
}

+ (void)restore {
    [kMySafeLock lock];

    do {
        if (!kMySafeOriginalIMP || !kMySafeSwizzledIMP) break;

        Class originalClass = NSClassFromString(@"__NSDictionaryM");
        if (!originalClass) break;

        Method originalMethod = NULL;
        Method swizzledMethod = NULL;

        unsigned int outCount = 0;
        Method *methodList = class_copyMethodList(originalClass, &outCount);
        for (unsigned int idx = 0; idx < outCount; idx++) {
            Method aMethod = methodList[idx];
            IMP aIMP = method_getImplementation(aMethod);
            if (aIMP == kMySafeSwizzledIMP) {
                originalMethod = aMethod;
            } else if (aIMP == kMySafeOriginalIMP) {
                swizzledMethod = aMethod;
            }
        }

        // 盡可能使用 exchange,因為它是 atomic 的
        if (originalMethod && swizzledMethod) {
            method_exchangeImplementations(originalMethod, swizzledMethod);
        } else if (originalMethod) {
            method_setImplementation(originalMethod, kMySafeOriginalIMP);
        } else if (swizzledMethod) {
            method_setImplementation(swizzledMethod, kMySafeSwizzledIMP);
        }

        kMySafeOriginalIMP = NULL;
        kMySafeSwizzledIMP = NULL;
    } while (NO);

    [kMySafeLock unlock];
}

- (void)safe_setObject:(id)anObject forKey:(id)aKey {
    if (anObject && aKey) {
        [self safe_setObject:anObject forKey:aKey];
    } else if (aKey) {
        [(NSMutableDictionary *)self removeObjectForKey:aKey];
    }
}

@end

注意:這段代碼的 Swizzling 與恢復都需要主動調用,並額外引入了鎖來保護。示例以跨類方式實現,若改為 Category 或類方法,需按前文的差異點做相應調整。

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