Method Swizzling被成为"黑魔法"，听起来很吊的样子，那么它吊要上天原因何在呢？其实，就是借助于Objective-C作为运行时语言的特点：在程序运行的时候，去修改某些方法的实现。
我们具体应用的时候也是非常简单，一般的做法：
+(void)load{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Method oriMethod = class_getClassMethod(self, @selector(viewWillAppear:));
Method newMethod = class_getClassMethod(self, @selector(lgj_viewWillAppear:));
if (!class_addMethod(self, @selector(viewWillAppear:), method_getImplementation(newMethod), method_getTypeEncoding(newMethod))) {
method_exchangeImplementations(oriMethod, newMethod);
}else{
class_replaceMethod(self, @selector(lgj_viewWillAppear:), method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
}
});
}
-(void)lgj_viewWillAppear:(BOOL)animated{
NSLog(@"lgj_viewWillAppear");
}
大致步骤：
1、先利用class_getClassMethod方法获取 oriMethod 和 newMethod 。
2、使用class_addMethod将oriMethod方法加到想要交换方法的类中（注意此时的 IMP 是 swizzledMethod 的 IMP ）
3、如果加入成功，执行method_exchangeImplementations用 oriMethod 的 IMP 替换掉 newMethod 的 IMP ；如果加入失败，执行class_replaceMethod直接交换 oriMethod 和 newMethod 的 IMP 。
在此，细心一点的都能看出来，我们多走了一小步，多了条判断。我们之所以不直接用method_exchangeImplementations来交换方法，是因为这样做的话会存在隐患。
比如我们在一个子类中，去交换一个父类中的方法，而这个方法在子类中没有实现，这个时候父类的方法就指向了子类的实现，当这个方法被调用的时候就会出问题。所以先采取添加方法的方式，如果添加失败，证明子类已经实现了这个方法，直接用 method_exchangeImplementations 来交换；如果添加成功，则说明没有实现这个方法，采取先添加后替换的方式。这样就能保证不影响父类了。
为了使用起来方便，可以把方法交换的逻辑代码，定义成一个宏，以后用起来就不用那么费劲的没次都去重新写一边。
#define SwizzleMethod(class, originalSelector, swizzledSelector) { \
Method originalMethod = class_getInstanceMethod(class, (originalSelector)); \
Method swizzledMethod = class_getInstanceMethod(class, (swizzledSelector)); \
if (!class_addMethod((class), \
(originalSelector), \
method_getImplementation(swizzledMethod), \
method_getTypeEncoding(swizzledMethod))) { \
method_exchangeImplementations(originalMethod, swizzledMethod); \
} else { \
class_replaceMethod((class), \
(swizzledSelector), \
method_getImplementation(originalMethod), \
method_getTypeEncoding(originalMethod)); \
} \
}
使用的时候：
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
SwizzleMethod([self class], @selector(viewWillAppear:), @selector(AA_viewWillAppear:));
});
}
我们要保证方法只会被交换一次。因为 +load 方法原则上只会被调用一次，所以一般将 Method Swizzling 放在 +load 方法中执行。但 +load 方法也可能被其他类手动调用，这时候就有可能会被交换多次，所以这里用 dispatch_once_t 来保证只执行一次。
通常情况下上面的交换不会出什么问题，但考虑下面一种场景。（注： ViewController 继承自 UIViewController ）
//UIViewController
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
SwizzleMethod([self class], @selector(viewWillAppear:), @selector(lgj_viewWillAppear:));
});
}
- (void)lgj_viewWillAppear:(BOOL)animated {
NSLog(@"UIViewController");
[self lgj_viewWillAppear:animated];
}
//ViewController
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
SwizzleMethod([self class], @selector(viewWillAppear:), @selector(lgjSub_viewWillAppear:));
});
}
- (void)lgjSub_viewWillAppear:(BOOL)animated {
NSLog(@"ViewController");
[self lgjSub_viewWillAppear:animated];
}
这里父类和子类同时对 viewWillAppear: 方法进行交换，每次交换都加入一句输出语句。则当 ViewController 调用 viewWillAppear: 时，我们期望输出下面结果：
ViewController
UIViewController
大部分情况的确是这样，但也有可能只输出：
ViewController
因为我们是在 +load 中做交换操作，而子类的 +load 却有可能先于父类执行。这样造成的结果是，子类先拷贝父类的 viewWillAppear: ，并进行交换，然后父类再进行交换。但这个时候父类的交换结果并不会影响子类，也无法将 NSLog(@"UIViewController") 写入子类的 viewWillAppear: 方法中，所以不会输出。
那么该如何解决呢？
子类的 swizzledMethod 中，动态地去查找父类替换后方法的实现。每次调用都会去父类重新查找，而不是拷贝写死在子类的新方法中。这样子类 viewWillAppear: 方法的执行结果就和 +load 的加载顺序无关了。
至于怎么实现动态查找，这里推荐 RSSwizzle ，这个库不仅解决了上面提到的问题，还保证了 Method Swizzling 的线程安全，是一种更安全优雅的解决方案。
RSSwizzle是一个轻量的线程安全的实现方法交换的库，runtime的method_exchangeImplementations函数来进行方法hook在特殊情况下会出现问题。
我们先看一下RSSwizzle的用法：
RSSwizzleInstanceMethod([UIViewController class],
@selector(viewWillAppear:),
RSSWReturnType(void),
RSSWArguments(BOOL animated),
RSSWReplacement({
NSLog(@"ViewController");
RSSWCallOriginal(animated);
}), RSSwizzleModeAlways, NULL);
如果想要更深层的了解RSSwizzle，请查看RSSwizzle源码解析 https://www.jianshu.com/p/c3444f64439f
