Method Swizzling的原理
- 在OC中调用方法:在类中都有一个选择子(SEL)列表,每个选择子都对应着一个IMP指针,意思就是每个选择子都有一个IMP指针唯一对应.IMP指针类似于函数指针,指向这个方法的具体实现,故而能执行.
- OC是运行时的动态语言,我们可以在运行时动态的修改每个选择子都对应的那个一个IMP指针,就能达到:
- 调用A方法名的时候去调用B方法. (交换两个已有IMP指针:method_exchangeImplementations)
- 直接设置某个方法的IMP. (method_setImplementation)
实践
- 首先创建一个继承于NSObject的类:HGSwizzling,实现两个普通的方法,代码如下:
.h文件
#import <Foundation/Foundation.h>
#ifdef DEBUG
#define HGLog(...) NSLog(__VA_ARGS__)
#else
#define HGLog(...)
#endif
@interface HGSwizzling : NSObject
// 方法一
- (void)hello;
// 方法二
- (void)hg_Hello;
@end
.m文件
#import "HGSwizzling.h"
#import <objc/runtime.h>
@implementation HGSwizzling
- (void)hello {
HGLog(@"Hello");
}
- (void)hg_Hello {
HGLog(@"HG,Hello.");
}
@end
上面只是声明与实现了两个普通的方法.现在我想交换一下这两个方法的实现:当调用hello的时候调用hg_Hello,反同.(接下)
- 这里将用到一个类方法load.这里对类的这个方法不做详细说明.自行查阅资料.这里有一个参考的博客:花园晓雨..代码实现如下:
// 用于交换hello与hg_Hello方法
+ (void)load {
// 获取方法
Method the_Method = class_getInstanceMethod(self, @selector(hello));
Method other_Method = class_getInstanceMethod(self, @selector(hg_Hello));
// 交换两个方法
method_exchangeImplementations(the_Method, other_Method);
// HGLog(@"HGSwizzling");
}
上面的代码,不难理解.就是用了两个runtime函数:1.通过sel获取各自的方法指针.2然后交换.
- 上面的已经实现了hg_Hello与hello的交换功能.
在控制器(HGViewController)中实现一下,代码如下:
#import "HGViewController.h"
#import "HGSwizzling.h"
@interface HGViewController ()
@end
@implementation HGViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 核心代码
HGSwizzling* hgSwizzle = [[HGSwizzling alloc] init];
[hgSwizzle hello]; // 输出结果:HG,Hello.
[hgSwizzle hg_Hello]; // 输出结果:Hello
}
@end
细心的同学,都发现了,当我调用hello的时候调用了 hg_Hello 的实现体,反同.
到这里, Swizzling 的简单实现就完成了.你理解了么???接下来,我再来实现一个版本.
实践二
- 在上面 HGSwizzling 类中,再添加一个方法,声明与实现代码如下:
// 实践二 声明
- (void)hg_Handsome;
// 实践二 实现
- (void)hg_Handsome {
HGLog(@"HG,Handsome.");
}
- 创建一个 HGSubSwizzling 继承于 HGSwizzling ,代码实现如下:
.h文件
#import "HGSwizzling.h"
@interface HGSubSwizzling : HGSwizzling
// 实践二
- (void)subHG_Handsome;
@end
.m文件
#import "HGSubSwizzling.h"
#import <objc/runtime.h>
@implementation HGSubSwizzling
+ (void)load {
// 获取方法
Method the_Method = class_getInstanceMethod(self, @selector(hg_Handsome));
Method other_Method = class_getInstanceMethod(self, @selector(subHG_Handsome));
// 交换两个方法
method_exchangeImplementations(the_Method, other_Method);
// HGLog(@"HGSubSwizzling");
}
// 实践二
- (void)subHG_Handsome {
[self subHG_Handsome];
HGLog(@"True.HG,Handsome.");
}
@end
- 不用解释,大家就能看出这个 HGSubSwizzling 类做了什么:本类的 subHG_Handsome 方法与父类的 hg_Handsome 做了交换.对,你太聪明了,就是这样的.
- 但是细心的小朋友已经看出来了: subHG_Handsome 的实现体重的代码不是已经递归了么?想想应该是递归了.但是不是这样的.你要清楚一点的是: subHG_Handsome 与 hg_Handsome 已经做了交换,所以实现体中的 [self subHG_Handsome]; 会去找到 hg_Handsome 的实现体....认真想想,也是对的.看看效果吧.
- 到 HGViewController 中再去看看实现吧,代码如下:
// 实践二(1)
HGSubSwizzling* subSwizzle = [[HGSubSwizzling alloc] init];
[subSwizzle hg_Handsome]; // 输出结果:HG,Handsome. True.HG,Handsome.
[subSwizzle subHG_Handsome]; // 输出结果:HG,Handsome.
如果你理解到这里了,其实你已经比我更优秀了.但是问题来了!不信?你往下看.....
实践二的升级版
在控制器(HGViewController)中直接实现如下代码,然后执行:
// 实践二(2)
HGSwizzling* hgSwizzle = [[HGSwizzling alloc] init];
[hgSwizzle hg_Handsome];
哎呦，Crash 了。主要是因为上面父类的 hg_Handsome 已经与子类中的 subHG_Handsome 做了交换。然而通过父类的对象调用 hg_Handsome 中的 subHG_Handsome，然后在子类中的subHG_Handsome方法中又调用了一个 [self subHG_Handsome]; ，问题就出现在这里了，父类中根本就没有这个 subHG_Handsome 方法，所以 Crash 了。如果将子类中的 [self subHG_Handsome]; 删除，是可以调用成功的。其实即使是调用成功了，也不符合我们程序设计的规范。应该是在子类中替换之后不要影响父类对象的使用才对。那么接下来就出现了很多大神的正确使用方法：
static inline void
ReplaceMethod(Class _class, SEL _originSelector, SEL _newSelector) {
Method oriMethod = class_getInstanceMethod(_class, _originSelector);
Method newMethod = class_getInstanceMethod(_class, _newSelector);
BOOL isAddedMethod = class_addMethod(_class, _originSelector, method_getImplementation(newMethod), method_getTypeEncoding(newMethod));
if (isAddedMethod) {
class_replaceMethod(_class, _newSelector, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
} else {
method_exchangeImplementations(oriMethod, newMethod);
}
}
以上的代码看上去确实有点复杂，但是也很好理解。主要就是添加了两个函数的调用，而不是直接交换。以上的方式解决了在上面出现的问题。
想要了解更多的信息，可以看一下源代码 objc4-750.tar.gz & objc-runtime-new
