方法替换，又称为method swizzling，是一个比较著名的runtime黑魔法。网上有很多的实现，我们这里直接讲最正规的实现方式以及其背后的原理。
Method Swizzling
在进行方法替换前，我们要考虑两种情况：
- 要替换的方法在target class中有实现
- 要替换的方法在target class中没有实现，而是在其父类中实现
对于第一种情况，很简单，我们直接调用method_exchangeImplementations即可达成方法。
而对于第二种情况，我们要仔细想想了。
因为在target class中没有对应的方法实现，方法实际上是在target class的父类中实现的，因此当我们要交换方法实现时，其实是交换了target class父类的实现。这样当其他地方调用这个父类的方法时，也会调用我们所替换的方法，这显然使我们不想要的。
比如，我想替换UIViewController类中的methodForSelector:方法，其实该方法是在其父类NSObject类中实现的。如果我们直接调用method_exchangeImplementations，则会替换掉NSObject的方法。这样当我们在别的地方，比如UITableView中再调用methodForSelector:方法时，其实会调用到父类NSObject，而NSObject的实现，已经被我们替换了。
为了避免这种情况，我们在进行方法替换前，需要检查target class是否有对应方法的实现，如果没有，则要讲方法动态的添加到class的method list中。
+(void)load{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//要特别注意你替换的方法到底是哪个性质的方法
// When swizzling a Instance method, use the following:
Class class = [self class];
// When swizzling a class method, use the following:
// Class class = object_getClass((id)self);
SEL originalSelector = @selector(systemMethod_PrintLog);
SEL swizzledSelector = @selector(ll_imageName);
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);
}
});
}
这是网上的一段代码例子，比较工整。
这里我们用class_addMethod方法来检查target class是否有方法实现。如果target class没有实现对应方法的话，则class_addMethod会返回true，同时，会将方法添加到target class中。如果target class已经有对应的方法实现的话，则class_addMethod调用失败，返回false，这时，我们直接调用
method_exchangeImplementations方法来对调originalMethod和swizzledMethod即可。
这里有两个细节，一个是在class_addMethod方法中，我们传入的SEL是originalSelector，而实现是swizzledMethodIMP，这样就等同于调换了方法。当add method成功后，我们又调用
if (didAddMethod) {
class_replaceMethod(class,
swizzledSelector,
method_getImplementation(originalMethod),
method_getTypeEncoding(originalMethod));
}
class_replaceMethod方法其实在内部会首先尝试调用class_addMethod，将方法添加到class中，如果添加失败，则说明class已经存在该方法，这时，会调用method_setImplementation来设置方法的IMP。
在if (didAddMethod)中，我们将swizzledMethod的IMP设置为了originalMethodIMP，完成了方法交换。
第二个细节是这段注释：
+(void)load {
//要特别注意你替换的方法到底是哪个性质的方法
// When swizzling a Instance method, use the following:
Class class = [self class];
// When swizzling a class method, use the following:
// Class class = object_getClass((id)self);
...
}
结合+(void)load方法的调用时机，它是由runtime在将class加载入内存中所调用的类方法。因此，我们一般会在这里面进行方法交换，因为时机是很靠前的。
这里要注意，在类方法中，self是一个类对象而不是实例对象。
当我们要替换类方法时，其实是要替换类对象所对应元类中的方法，要获取类对象的元类，需要调用
object_getClass方法，它会返回ISA()，而类对象的ISA(),恰好是元类。
当我们要替换实例方法时，需要找到实例所对应的类，这时，就需要调用[self class]，虽然self是类对象，但是+ class会返回类对象自身，也就是实例对象所对应的类。
这段话说的比较绕，如果模糊的同学可以结合上一章最后类，类和元类的关系进行理解。
附带class方法的实现源码：
NSObject.mm
+ (Class)class {
return self;
}
- (Class)class {
return object_getClass(self);
}
Method swizzling原理
就如之前所说，runtime中所谓的黑魔法，只不过是基于runtime底层数据结构的应用而已。
现在，我们就一次剖析在method swizzling中所用到的runtime函数以及其背后实现和所依赖的数据结构。
class & object_getClass
要进行方法替换，首先要清楚我们要替换哪个类中的方法，即target class：
// When swizzling a Instance method, use the following:
Class class = [self class];
// When swizzling a class method, use the following:
Class class = object_getClass((id)self);
我们有两种方式获取Class对象，NSObject的class方法以及runtime函数object_getClass。这两种方法的具体实现，还是有差别的。
class
先看NSObject的方法class，其实有两个版本，一个是实例方法，一个是类方法，其源码如下：
+ (Class)class {
return self;
}
- (Class)class {
return object_getClass(self);
}
当调用者是类对象时，会调用类方法版本，返回类对象自身。而调用者是实例对象时，会调用实例方法版本，在该版本中，又会调用runtime方法object_getClass。
那么在object_getClass中，又做了什么呢？
object_getClass
Class object_getClass(id obj)
{
if (obj) return obj->getIsa();
else return Nil;
}
实现很简单，就是调用了对象的getIsa()方法。这里我们可以简单的理解为就是返回了对象的isa指针。
如果对象是实例对象，isa返回实例对象所对应的类对象。
如果对象是类对象，isa返回类对象所对应的元类对象。
我们在回过头来看这段注释（注意这里的前提是在+load()方法中，self是类对象）：
// When swizzling a Instance method, use the following:
Class class = [self class];
// When swizzling a class method, use the following:
Class class = object_getClass((id)self);
当我们要调换实例方法，则需要修改实例对象所对应的类对象的方法列表，因为这里的self已经是一个类对象，所有调用class方法其实会返回其自身，即实例对象对应的类对象：
// When swizzling a Instance method, use the following:
Class class = [self class];
当我们要调换类方法，则需要修改类对象所对应的元类对象的方法列表，因此要调用object_class方法，它会返回对象的isa，而类对象的isa，则恰是类对象对应的元类对象:
// When swizzling a class method, use the following:
Class class = object_getClass((id)self);
class_getInstanceMethod
确认了class后，我们就需要准备方法调用的原材料：originalMethod method 和 swizzled method。Method数据类型在runtime中的定义为：
typedef struct method_t *Method;
struct method_t {
SEL name;
const char *types;
IMP imp;
struct SortBySELAddress :
public std::binary_function<const method_t&,
const method_t&, bool>
{
bool operator() (const method_t& lhs,
const method_t& rhs)
{ return lhs.name < rhs.name; }
};
};
我们所说的类的方法列表中，就是存储的method_t类型。
Method数据类型的实例，如果自己创建的话，会比较麻烦，尤其是如何填充IMP，但我们可以从现有的class 方法列表中取出一个method来。很简单，只需要调用class_getInstanceMethod方法。
class_getInstanceMethod方法究竟做了什么呢？就像我们刚才说的一样，它就是在指定的类对象中的方法列表中去取SEL所对应的Method。
/***********************************************************************
* class_getInstanceMethod. Return the instance method for the
* specified class and selector.
**********************************************************************/
Method class_getInstanceMethod(Class cls, SEL sel)
{
if (!cls || !sel) return nil;
lookUpImpOrNil(cls, sel, nil,
NO/*initialize*/, NO/*cache*/, YES/*resolver*/);
return _class_getMethod(cls, sel);
}
class_getInstanceMethod首先调用了lookUpImpOrNil，其实它的内部实现和普通的消息流程是一样的（内部会调用上一章中说所的消息查找函数lookUpImpOrForward），只不过对于消息转发得到的IMP，会替换为nil。
在进行了一波消息流程之后，调用_class_getMethod方法
static Method _class_getMethod(Class cls, SEL sel)
{
rwlock_reader_t lock(runtimeLock);
return getMethod_nolock(cls, sel);
}
static method_t *
getMethod_nolock(Class cls, SEL sel)
{
method_t *m = nil;
runtimeLock.assertLocked();
assert(cls->isRealized());
// 核心：沿着继承链，向上查找第一个SEL所对应的method
while (cls && ((m = getMethodNoSuper_nolock(cls, sel))) == nil) {
cls = cls->superclass;
}
return m;
}
// getMethodNoSuper_nolock 方法实质就是在查找class的消息列表
static method_t *
getMethodNoSuper_nolock(Class cls, SEL sel)
{
runtimeLock.assertLocked();
assert(cls->isRealized());
// fixme nil cls?
// fixme nil sel?
for (auto mlists = cls->data()->methods.beginLists(),
end = cls->data()->methods.endLists();
mlists != end;
++mlists)
{
method_t *m = search_method_list(*mlists, sel);
if (m) return m;
}
return nil;
}
class_addMethod
当我们获取到target class和swizzled method后，首先尝试调用class_addMethod方法将swizzled method添加到target class中。
这样做的目的在于：如果target class中没有要替换的original method，则会直接将swizzled method 作为original method的实现添加到target class中。如果target class中确实存在original method，则class_addMethod会失败并返回false，我们就可以直接调用method_exchangeImplementations 方法来实现方法替换。这就是下面一段逻辑代码的意义：
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);
}
我们先来看class_addMethod是怎么实现的。其实到了这里，相信大家不用看代码也能猜的出来，class_addMethod其实就是将我们提供的method，插入到target class的方法列表中。事实是这样的吗，看源码：
BOOL
class_addMethod(Class cls, SEL name, IMP imp, const char *types)
{
if (!cls) return NO;
rwlock_writer_t lock(runtimeLock);
return ! addMethod(cls, name, imp, types ?: "", NO);
}
static IMP
addMethod(Class cls, SEL name, IMP imp, const char *types, bool replace)
{
IMP result = nil;
runtimeLock.assertWriting();
assert(types);
assert(cls->isRealized());
method_t *m;
if ((m = getMethodNoSuper_nolock(cls, name))) {
// 方法已经存在
if (!replace) { // 如果选择不替换，则返回原始的方法，添加方法失败
result = m->imp;
} else { // 如果选择替换，则返回原始方法，同时，替换为新的方法
result = _method_setImplementation(cls, m, imp);
}
} else {
// 方法不存在, 则在class的方法列表中添加方法, 并返回nil
method_list_t *newlist;
newlist = (method_list_t *)calloc(sizeof(*newlist), 1);
newlist->entsizeAndFlags =
(uint32_t)sizeof(method_t) | fixed_up_method_list;
newlist->count = 1;
newlist->first.name = name;
newlist->first.types = strdupIfMutable(types);
newlist->first.imp = imp;
prepareMethodLists(cls, &newlist, 1, NO, NO);
cls->data()->methods.attachLists(&newlist, 1);
flushCaches(cls);
result = nil;
}
return result;
}
源码证明，我们的猜想是正确的:)
class_replaceMethod
如果class_addMethod返回成功，则说明我们已经为target class添加上了SEL为original SEL，并且其实现是swizzled method。至此，我们方法交换完成了一半，现在我们将swizzled method替换为original method。
if (didAddMethod) {
class_replaceMethod(class,
swizzledSelector,
method_getImplementation(originalMethod),
method_getTypeEncoding(originalMethod));
}
这里，我们调用了class_replaceMethod 方法。它的内部逻辑是这样的：1. 如果target class中没有SEL的对应实现，则会为target class添加上对应实现。 2. 如果target class中已经有了SEL对应的方法，则会将SEL对应的原始IMP，替换为新的IMP。
IMP
class_replaceMethod(Class cls, SEL name, IMP imp, const char *types)
{
if (!cls) return nil;
rwlock_writer_t lock(runtimeLock);
return addMethod(cls, name, imp, types ?: "", YES);
}
static IMP
addMethod(Class cls, SEL name, IMP imp, const char *types, bool replace)
{
IMP result = nil;
runtimeLock.assertWriting();
assert(types);
assert(cls->isRealized());
method_t *m;
if ((m = getMethodNoSuper_nolock(cls, name))) {
// 方法已经存在
if (!replace) { // 如果选择不替换，则返回原始的方法，添加方法失败
result = m->imp;
} else { // 如果选择替换，则返回原始方法，同时，替换为新的方法
result = _method_setImplementation(cls, m, imp);
}
} else {
// 方法不存在, 则在class的方法列表中添加方法, 并返回nil
method_list_t *newlist;
newlist = (method_list_t *)calloc(sizeof(*newlist), 1);
newlist->entsizeAndFlags =
(uint32_t)sizeof(method_t) | fixed_up_method_list;
newlist->count = 1;
newlist->first.name = name;
newlist->first.types = strdupIfMutable(types);
newlist->first.imp = imp;
prepareMethodLists(cls, &newlist, 1, NO, NO);
cls->data()->methods.attachLists(&newlist, 1);
flushCaches(cls);
result = nil;
}
return result;
}
通过源码对比可以发现，class_addMethod和class_replaceMethod其实都是调用的addMethod方法，区别只是bool replace参数，一个是NO，不会替换原始实现，另一个是YES，会替换原始实现。
method_exchangeImplementations
如果class_addMethod 失败，则说明target class中的original method是在target class中有定义的，这时候，我们直接调用method_exchangeImplementations交换实现即可。method_exchangeImplementations 实现很简单，就是交换两个Method的IMP:
void method_exchangeImplementations(Method m1, Method m2)
{
if (!m1 || !m2) return;
rwlock_writer_t lock(runtimeLock);
IMP m1_imp = m1->imp;
m1->imp = m2->imp;
m2->imp = m1_imp;
// RR/AWZ updates are slow because class is unknown
// Cache updates are slow because class is unknown
// fixme build list of classes whose Methods are known externally?
flushCaches(nil);
updateCustomRR_AWZ(nil, m1);
updateCustomRR_AWZ(nil, m2);
}
值得注意的地方
在写这篇博文的时候，笔者曾做过这个实验，在UIViewController的Category中，测试
- (void)exchangeImp {
Class aClass = object_getClass(self);
SEL originalSelector = @selector(viewWillAppear:);
SEL swizzledSelector = @selector(sw_viewWillAppearXXX:);
Method originalMethod = class_getInstanceMethod(aClass, originalSelector);
Method swizzledMethod = class_getInstanceMethod(aClass, swizzledSelector);
IMP result = class_replaceMethod(aClass, originalSelector,method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
NSLog(@"result is %p", result);
}
因为在class_replaceMethod方法中，如果target class已经存在SEL对应的方法实现，则会返回其old IMP，并替换为new IMP。本来以为result会返回viewWillAppear:的实现，但结果却是返回了nil。这是怎么回事呢？
究其根本，原来是因为我是在UIViewController的子类ViewController中调用的exchangeImp方法，那么object_getClass(self)，其实会返回子类ViewController而不是UIViewController。
在class_replaceMethod中，runtime仅会查找当前类aClass，即ViewController的方法列表，而不会向上查询其父类UIViewController的方法列表。这样自然就找不到viewWillAppear:的实现啦。
而对于class_getInstanceMethod，runtime除了查找当前类，还会沿着继承链向上查找对应的Method。
所以，这里就造成了，class_getInstanceMethod可以得到viewWillAppear:对应的Method，而在class_replaceMethod中，却找不到viewWillAppear:对应的IMP。
如果不了解背后的实现，确实很难理解这种看似矛盾的结果。
