iOS底层-runtime应用之方法交换(method swiz

作者: Engandend | 来源:发表于2019-12-17 15:35 被阅读0次

method swizzling 就是常说的方法交换，也常被成为黑魔法。
简单点说就是定义并实现了方法A和B，在调用方法A的时候，执行的确实方法B

基本概念

在了解method swizzling之前先来了解几个概念：

SEL/@selector(方法名)

SEL 又叫选择器，但是一般我们将它称之为方法编号。源码中的定义为
typedef struct objc_selector *SEL;

以下关于方法编号的解释来自这篇文章 (未得专业验证)

方法以 selector 作为索引. selector 的数据类型是 SEL. 虽然 SEL 定义成 char*, 我们可以把它想象成 int. 每个方法的名字对应一个唯一的 int 值.比如, 方法 addObject: 可能对应的是 12. 当寻找该方法是, 使用的是 selector,而不是名字 @"addObject:"

Objective-C 数据结构中,存在一个 name - selector 的映射表如下图

映射关系

在编译的时候, 只要有方法的调用, 编译器都会通过 selector 来查找,所以 (假设 addObject 的 selector 为 12)

[myObject addObject:yourObject];
将会编译变成

objc_msgSend(myObject, 12, yourObject);

这里,objec_msgSend()函数将会使用 myObjec 的 isa 指针来找到 myObject 的类空间结构并在类空间结构中查找 selector 12 所对应的方法.如果没有找到,那么将使用指向父类的指针找到父类空间结构进行 selector 12 的查找. 如果仍然没有找到,就继续往父类的父类一直找,直到找到为止, 如果到了根类 NSObject 中仍然找不到,将会抛出异常.

我们可以看到, 这是一个很动态的查找过程.类的结构可以在运行的时候改变,这样可以很容易来进行功能扩展Objective-C 语言是动态语言, 支持动态绑定.

⬆️文章摘要结束

IMP

IMP指向方法实现的首地址，类似C语言的函数指针。IMP是消息最终调用的执行代码，是方法真正的实现代码。
源码中的定义：
#if !OBJC_OLD_DISPATCH_PROTOTYPES
typedef void (*IMP)(void /* id, SEL, ... */ );
#else
typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...);
#endif

每一个实现了的方法都存在一个SEL和IMP（这不废话，不然怎么可以成功调用？），写句的原因是可能刚理解这些概念的时候有些绕：

只有声明，没有实现的方法有没有SEL/IMP？比如只是在.h文件中写入- (void)test?
只有实现没有声明的方法，有没有SEL/IMP？比如只是在.m文件中写- (void)test{}?

上面问题的答案就是：
只有声明，没有实现：SEL和IMP都没有
没有声明，只有实现：SEL和IMP都有。
在只有声明，没有实现的情况下，打印类结构信息。在ro里面的信息是 baseMethodList = 0x0000000000000000

Method

主要包含三部分

方法名：方法名为此方法的签名，有着相同函数名和参数名的方法有着相同的方法名。
方法类型：方法类型描述了参数的类型。
IMP: IMP即函数指针，为方法具体实现代码块的地址，可像普通C函数调用一样使用IMP。
实际上相当于在SEL和IMP之间作了一个映射。有了SEL，我们便可以找到对应的IMP。
源码中的定义：
struct objc_method {
SEL _Nonnull method_name;
char * _Nullable method_types;
IMP _Nonnull method_imp;
}

method swizzling 的应用

在实际开发中，经常会遇到这样的情况

NSArray *array = @[@"1",@"2",@"3"];
NSLog(@"%@",array[4]);

一般来说，在使用下标取值之前，都需要先判断
if (array.count < 4) {
NSLog(@"%@",array[4]);
}
但是总有漏掉判断或其他情况导致crash
为了避免这种情况或者少写重复代码，我们可以使用动态方法交换的方式来处理
定义一个方法JERuntimeTool
在.h中定义方法并在.m中实现

#import <objc/runtime.h>
/**
交换方法

@param cls 交换对象
@param oriSEL 原始方法编号
@param swizzledSEL 交换的方法编号
*/
+ (void)je_methodSwizzlingWithClass:(Class)cls
                             oriSEL:(SEL)oriSEL
                        swizzledSEL:(SEL)swizzledSEL{
    
    if (!cls){
        NSLog(@"传入的交换类不能为空");
        return;
    }
    Method oriMethod = class_getInstanceMethod(cls, oriSEL);
    Method swiMethod = class_getInstanceMethod(cls, swizzledSEL);
    method_exchangeImplementations(oriMethod, swiMethod);
}

定义一个拓展NSArray的JE类NSArray+JE.h

针对下标取值的情况，有多个方法，都需要进行异常捕获

- (id)je_objectAtIndex:(NSUInteger)index{
    if (index > self.count-1) {
        //异常处理或记录打印
        return nil;
    }
    return [self lg_objectAtIndex:index];
}

- (id)je_objectAtIndexedSubscript:(NSUInteger)index{
     if (index > self.count-1) {
        //异常处理或记录打印
        return nil;
    }
    return [self lg_objectAtIndexedSubscript:index];
}

进行方法交换

+ (void)load{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
        [JERuntimeTool je_methodSwizzlingWithClass:objc_getClass("__NSArrayI")
                                            oriSEL:@selector(objectAtIndex:)
                                       swizzledSEL:@selector(je_objectAtIndex:)];
        
        [JERuntimeTool je_methodSwizzlingWithClass:objc_getClass("__NSArrayI")
                                            oriSEL:@selector(objectAtIndexedSubscript:)
                                       swizzledSEL:@selector(je_objectAtIndexedSubscript:)];
    });
}

这里有几点需要注意：
1、在+ (void)load 方法中调用
2、调用的时候，用单例的方式
3、对于系统的有些方法应该交换哪个方法？
4、交换的类应该是那个？
在crash的时候有一个错误信息，其中有一段：reason: '*** -[__NSArrayI objectAtIndexedSubscript:]: index 4 beyond bounds [0 .. 2],其中 __NSArrayI是需要交换的类， objectAtIndexedSubscript:是需要交换的方法。
对于我们自定义的类一般来说直接就是类名和自定义的方法SEL，但是系统的抽象类类是不能直接作为类对象传入的，比如NSArray/NSMutableArrya、NSDictionary/NSMutableDictionary、 NSData/NSMutableData等。

上面的方法看似很完美，但是下面坑就是在你不经意间就出现在脚下。

会出现的问题

问题1

背景：子类没有实现父类的方法但是对子类的方法进行了交换
比如：Person：NSObjec Student：Person
Person定义并实现了方法：-（void）personMethod;
Studen 没有实现 -（void）personMethod;

在Student的分类中中交换方法

Student+JE.h

+ (void)load{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [JERuntimeTool je_methodSwizzlingWithClass:self oriSEL:@selector(personInstanceMethod) swizzledSEL:@selector(je_studentInstanceMethod)];
    });
}

- (void)je_studentInstanceMethod{
    NSLog(@"do something");
    [self je_studentInstanceMethod];
}

执行代码

Student *s = [Student new];
[s personInstanceMethod];
    
Person *p = [Person new];
[p personInstanceMethod];

运行结果：

do something
person对象方法:-[Person personInstanceMethod]

do something
[Person je_studentInstanceMethod]: unrecognized selector sent to instance 0x600002e5c440

在person调用 personInstanceMethod 方法的时候出现了问题，原因是：

1、person 调用 personInstanceMethod（SEL），由于进行了交换，将执行
je_studentInstanceMethod（IMP）
2、继续调用[self je_studentInstanceMethod],person 调用 je_studentInstanceMethod （SEL）
3、由于je_studentInstanceMethod（SEL）属于Student（调用SEL需要执行相对应的IMP，这个时候，在Person中没有相应的IMP）所以person 调用的时候出现了 [Person je_studentInstanceMethod]: unrecognized的错误

知道了原因，我们需要针对性解决问题：
在Student中添加一个方法，对应关系为：swizzleSEL + Ori IMP。（可见下图）
在这里，采用的是：向Student中添加
je_studentInstanceMethod（SEL） + personInstanceMethod（IMP），如果添加成功，说明Student没有实现这个方法，这样来达到通用性，代码如下

+ (void)je_methodSwizzlingWithClass:(Class)cls
                             oriSEL:(SEL)oriSEL
                        swizzledSEL:(SEL)swizzledSEL{
    
    if (!cls){
        NSLog(@"传入的交换类不能为空");
        return;
    }
    
    Method oriMethod = class_getInstanceMethod(cls, oriSEL);
    Method swiMethod = class_getInstanceMethod(cls, swizzledSEL);
    
    BOOL didAddMethod = class_addMethod(cls, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));
    if (didAddMethod) {
        class_replaceMethod(cls, swizzledSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
    }else{
        method_exchangeImplementations(oriMethod, swiMethod);
    }
}

执行步骤如下图

交换代码中的执行过程

问题2

背景：父类和子类都没有实现
比如：子类Student 只申明一个方法readBook；

在Student的分类中中交换方法

Student+JE.h

+ (void)load{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [JERuntimeTool je_methodSwizzlingWithClass:self oriSEL:@selector(readBook) swizzledSEL:@selector(je_readBook)];
    });
}

- (void)je_readBook{
    NSLog(@"do something");
    [self je_readBook];
}

执行代码

Student *s = [Student new];
[s personInstanceMethod];

运行结果：

不停的调用   NSLog(@"do something"); 这一句

这里产生了递归，原因是交换不完全。

步骤解析：

1、交换前：

交换前

2、执行class_addMethod(cls, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));

执行添加方法后结构

3、执行 class_replaceMethod(cls, swizzledSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));

这里需要注意的是·将 swizzleSEL （也就是图中的5）对应的 swizzleIMP （图中的6）替换成一个nil，这里需要注意的是，从底层源码中看：
class_replaceMethod —>
addMethod —>
_method_setImplementation

如果reply一个nil IMP，那么是不会执行的，所以最终指向结构还是2图的结构

static IMP 
_method_setImplementation(Class cls, method_t *m, IMP imp)
{
    runtimeLock.assertLocked();

    if (!m) return nil;
    if (!imp) return nil;

    IMP old = m->imp;
    m->imp = imp;
....
    return old;
}

执行过程：
结合图2:
调用9 -》执行 10；
10 调用 5 -》执行 6
6 调用5 -》执行6
....
所以发生了递归

错误原因：查看替换后的结构

按照之前的方法替换后的结构

知道了原因，针对这个问题来解决：
解决思路就是：判断有没有IMP，如果没有IMP，就添加一个默认的IMP（在这里就是 - (void)readBook {}）
代码如下：

+ (void)je_methodSwizzlingWithClass:(Class)cls
                             oriSEL:(SEL)oriSEL
                        swizzledSEL:(SEL)swizzledSEL{
    
    if (!cls){
        NSLog(@"传入的交换类不能为空");
        return;
    }
    
    Method oriMethod = class_getInstanceMethod(cls, oriSEL);
    Method swiMethod = class_getInstanceMethod(cls, swizzledSEL);
    if (!oriMethod) {
        class_addMethod(cls, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));
        method_setImplementation(swiMethod, imp_implementationWithBlock(^(id self, SEL _cmd){ }));
    }

    BOOL didAddMethod = class_addMethod(cls, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));
    if (didAddMethod) {
        class_replaceMethod(cls, swizzledSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
    }else{
        method_exchangeImplementations(oriMethod, swiMethod);
    }
}

按照最终的方案替换后的结构

最终交换后的结构

类方法交换

上面说了这么多，都是针对对象方法（实例方法）来讲的，那么如果想交换类方法要怎么处理？
如果搞明白了对象 -> 类 —> 元类 —> 根源类的关系，并且知道实例方法和类方法的存储位置，这个问题就很容易解决。

知识点补充：
1、类的isa 指向元类，元类的isa指向根源类参照之前的文章
2、实例方法存储在类对象中，类方法存储在元类对象中

解决上面的问题，只需要在交换的时候传入的类传入元类就好了。
代码如下：

+ (void)load{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = object_getClass(self); 
        [JERuntimeTool je_methodSwizzlingWithClass:class oriSEL:@selector(personMethod) swizzledSEL:@selector(je_readBook)];
    });
}

method swizzling 总结和注意事项

一、方法交换的调用时机：

在+ (void)load方法中调用。
为什么：
1)、自动调用 2)、调用的早。 load方法在app启动的时候，就由系统自动调用了。
2、保证交换的唯一性(需要用单例的形式)

二、load方法的加载顺序

1)、有继承关系的类先加载父类（不包含其拓展）再加载子类
2)、不同类之间的load是按照编译顺序来决定的（即使是有继承关系的类他们的拓展之间也是按照编译顺序来的）
3)、推展类的调用是在所有的类加载完成之后，（可参照源码中的map_images方法: 类 > protocol > category）

iOS底层-runtime应用之方法交换(method swiz

基本概念

SEL/@selector(方法名)

IMP

Method

method swizzling 的应用

会出现的问题

问题1

问题2

步骤解析：

类方法交换

method swizzling 总结和注意事项

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读