Method Swizzling中的那点事

1386EEBF1D7C17C4C7B3E10690402A66.jpg
此文是在读者已经对 Method Swizzling 的使用和原理有一定的了解和基础上对网络中普遍的 Method Swizzling 方案进行解读。

方案一：

Method ori_Method =  class_getInstanceMethod([NSArray class], @selector(lastObject));  
Method my_Method = class_getInstanceMethod([NSArray class], @selector(myLastObject));  
method_exchangeImplementations(ori_Method, my_Method);  

方案二：

Class class = [self class]; 
 
        // When swizzling a class method, use the following: 
        // Class class = object_getClass((id)self); 
 
        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); 
        } 
    }); 

---

方案一我想大家必定都很熟悉，至于方案二也在不少相关文章中有提及，不过方案二中这一大坨的判断是干嘛的？我交换个方法有必要那么复杂吗/(ㄒoㄒ)/~~，而且这些判断里的方法调用和参数又是什么鬼？看不明白啊啊啊啊啊啊啊啊啊啊，不用担心接下来博主将为大家解读方案二的实现原委😎

首先来看看这行代码

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

在方法交换之前，我们首先为要交换的类 class 添加一个名为 originalSelector 实现内容与结构体 swizzledMethod 中一致的方法，这一步主要是为了防止方法交换时，交换到由父类中所继承的方法，原本你只是想交换具体子类中的方法实现却把原有父类的方法实现给替换了，这就造成了原本调用父类方法时的结果异常。

1.首先创建一个父类 Father 并在内部实现一个名为 test 的方法
Father.h

#import <Foundation/Foundation.h>

@interface Father : NSObject

- (void)test;

@end

Father.m

#import "Father.h"

@implementation Father

- (void)test {
    
    NSLog(@"Father test");
}

@end

2.创建一个 Father 的子类 Son，不做任何操作
Son.h

#import "Father.h"

@interface Son : Father

@end

Son.m

#import "Son.h"

@implementation Son

@end

Son+Swizzling.m

#import "Son+Swizzling.h"
#import <objc/runtime.h>

@implementation Son (Swizzling)

+ (void)load {
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
        Class class = [self class];
        
        SEL oriSEL = @selector(test);
        SEL swiSEL = @selector(swi_test);
        
        Method oriMethod = class_getInstanceMethod(class, oriSEL);
        Method swiMethod = class_getInstanceMethod(class, swiSEL);
        
        method_exchangeImplementations(oriMethod, swiMethod);
    });
}

- (void)swi_test {
    
   // [self swi_test];
    NSLog(@"Son swi_test");
}

@end

代码贴完了，现在让我们看看在此种情况下没有第一步的预防措施会造成怎么样的结果

屏幕快照 2019-02-07 下午9.16.57.png

我们在调用的 Father 的 test 方法时的打印结果和Son一致，同时这也证明了上面的猜想是正确的。

为什么会造成这样的结果呢？因为该函数所检索得到的Method是从当前类及其父类中进行自下而上的查找，所以直接进行方法替换可能会造成父类原本实现被替换也就能解释了

Method oriMethod = class_getInstanceMethod(class, oriSEL);

我们继续往下看

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

这里的判断大意：如果方法添加成功，则说明原类并不存在将要被替换的 originalMethod 或者父类已存在同名方法，此时我们再对名为 swizzledSelector方法进行整体结构替换，这样一来我们变向实现了方法交换，你在调用原类 originalSelector 时的实现为 swizzledMethod 结构中的具体内容，而原本用来交换的方法 swizzledSelector 的实现也变成了 originalMethod 的具体实现。如果方法添加失败，则说明原类中已经存在了要被替换的 originalSelector，可以安全的进行 method_exchangeImplementations 交换。