OC底层探索之objc_msgSend我们探索了消息的快速查找和慢速查找。那如果都找不到会系统会怎么处理呢？本文是基于objc838进行探索的，准备探索如下：
- 方法找不到如何抛出异常
- 消息的动态决议
- 消息打印日志
- 消息的快速转发
- 消息的慢速转发
- resolveInstanceMethod方法调用2次的原因
方法找不到如何抛出异常
我们新建一个LGPerson类，在.h文件内声明一个test1实例方法和test2类方法，但是不去实现。
@interface LGPerson : NSObject
- (void)test1;
+ (void)test2;
@end
在main函数内部初始化一个LGPerson的实例对象，调用test1方法，当然我们都知道会抛出unrecognized selector sent to instance 0x100a0fdf0这个异常。系统是怎么抛出这个异常的呢？那接下来我们进入objc838源代码看看。
我们查看源码，当父类指向nil的时候，会进行imp = forward_imp，那我们看看这个forward_imp是啥？
我们可以看到
lookUpImpOrForward函数顶部有forward_imp = (IMP)_objc_msgForward_impcache;这行代码，它对forward_imp进行赋值，那我们再看看_objc_msgForward_impcache函数内部实现。
我们通过源码是看不到_objc_msgForward_impcache的具体实现的，那么我们就看看汇编。
我们直接搜索_objc_msgForward_impcache，直接看真机下arm64架构的，我们可以看到其实它只是调用了一个__objc_forward_handler。搜索__objc_forward_handler我们在汇编搜索不到它的实现。那我们就去掉_在源码内搜索_objc_forward_handler。我们可以看到它其实就是objc_defaultForwardHandler函数，其内部就会抛出"%c[%s %s]: unrecognized selector sent to instance %p " "(no message forward handler is installed)"这个异常。
消息的动态决议
找不到方法就会抛出异常，那抛出异常之前系统做了什么事情呢？我们回到lookUpImpOrForward内部，我们刚看到其实报异常的函数还没有调用，会走resolveMethod_locked函数，我们先看看(behavior & LOOKUP_RESOLVER)这个判断条件，LOOKUP_RESOLVER的值是2。
if (slowpath(behavior & LOOKUP_RESOLVER)) {
behavior ^= LOOKUP_RESOLVER;
return resolveMethod_locked(inst, sel, cls, behavior);
}
我们在
[p test1]函数打上断点，然后在if (slowpath(behavior & LOOKUP_RESOLVER)) {打上断点，运行可以看到behavior初始值是3，3&2=2，behavior ^= LOOKUP_RESOLVER = 3^2=1，(behavior & LOOKUP_RESOLVER)为真会调用resolveMethod_locked，然后依次调用lookUpImpOrForwardTryCache、_lookUpImpTryCache等函数，最后还是会调用lookUpImpOrForward函数，第二次来的时候behavior值为1,1&2=0，不为真就不调用resolveMethod_locked函数了，所以说它相当于一个单例，只会来执行一次resolveMethod_locked函数。
我们看到resolveMethod_locked函数内部是不是很熟悉？有一个resolveInstanceMethod方法和resolveClassMethod函数，就是说如果cls是不是元类就会走resolveInstanceMethod方法反之会走resolveClassMethod，其实也就是实例方法会调用resolveInstanceMethod，类方法会调用resolveClassMethod。
resolveMethod_locked(id inst, SEL sel, Class cls, int behavior)
{
runtimeLock.assertLocked();
ASSERT(cls->isRealized());
runtimeLock.unlock();
if (! cls->isMetaClass()) {
// try [cls resolveInstanceMethod:sel]
resolveInstanceMethod(inst, sel, cls);
}
else {
// try [nonMetaClass resolveClassMethod:sel]
// and [cls resolveInstanceMethod:sel]
resolveClassMethod(inst, sel, cls);
if (!lookUpImpOrNilTryCache(inst, sel, cls)) {
resolveInstanceMethod(inst, sel, cls);
}
}
// chances are that calling the resolver have populated the cache
// so attempt using it
return lookUpImpOrForwardTryCache(inst, sel, cls, behavior);
}
我们看到resolveInstanceMethod函数内部会看到objc_msgSend函数，可以看到消息的接受者是cls，所以说resolveInstanceMethod是一个类方法。当系统找不到方法，系统就会调用resolveInstanceMethod，好吧，那我们去实现它吧。
我们在LGPerson类的.m内部实现resolveInstanceMethod函数，并打印，运行：
@implementation LGPerson
+ (BOOL)resolveInstanceMethod:(SEL)sel {
NSLog(@"%s-----%@", __func__ , NSStringFromSelector(sel));
return [super resolveInstanceMethod:sel];
}
@end
从打印结果我们可以看到，系统在抛出异常之前会调用resolveInstanceMethod函数，但是会调用2次，它为什么会调用2次呢，我们在文章的结尾会进行探索。
我们知道
objc_msgSend本质就是通过方法名找具体实现的过程。那我们在resolveInstanceMethod函数内部去给该方法添加一个实现看看。我们首先实现一个method1方法，然后获取该方法的imp，添加到本类里面。
IMP imp = class_getMethodImplementation(self.class, @selector(method1));
class_addMethod(self.class, sel, imp, "v@:");
return YES;
运行我们可以看到不会抛出异常，调用了resolveInstanceMethod函数method1成功调用了。
那我们在实现一个resolveClassMethod函数，并[LGPerson test2]，运行,我们可以看到当找不到test2类方式，系统会抛出异常且调用resolveClassMethod函数
那我们也给它添加一个实现。再运行我们可以看到不会抛出异常，并且执行了method2函数。
+ (BOOL)resolveClassMethod:(SEL)sel {
NSLog(@"%s-----%@", __func__ , NSStringFromSelector(sel));
if (sel == @selector(test2)) {
IMP imp = class_getMethodImplementation(self.class, @selector(method2));
class_addMethod(objc_getMetaClass("LGPerson"), sel, imp, "v@:");
return YES;
}
return [super resolveClassMethod:sel];
}
- (void)method2 {
NSLog(@"%s", __func__);
}
消息打印日志
我们之前探索当方法找到的时候我们会goto done,done函数内部会调用一个log_and_fill_cache，log_and_fill_cache函数就是打印函数日志和把找到的方法存到cache里面。当objcMsgLogEnabled && implementer为真的时候就会通过logMessageSend函数日志打印到/tmp/msgSends-xx这个文件内，implementer是我们的LGPerson肯定是有值的，点击objcMsgLogEnabled我们可以看到它是一个静态变量，全局搜索一下可以看到在instrumentObjcMessageSends函数内部会对objcMsgLogEnabled进行赋值，那我们就重写一个instrumentObjcMessageSends函数。
重写instrumentObjcMessageSends函数,并添加test1方法的实现。然后运行：
LGPerson *person = [LGPerson alloc];
instrumentObjcMessageSends(YES);
[person test1];
instrumentObjcMessageSends(NO);
@implementation LGPerson
-(void)test1 {
}
@end
前往/tmp文件夹找到msgSends开头的文件打开。我们发现了一个msgSends-39378，打开可以看到- LGPerson LGPerson test1
函数调用日志了。
我们把test1的实现注释掉,运行。我们可以看到/tmp文件夹下多了一个msgSends-39459文件。打开msgSends-39459文件可以看到我们在抛出异常之前会依次调用resolveInstanceMethod、forwardingTargetForSelector、methodSignatureForSelector、resolveInstanceMethod等函数。resolveInstanceMethod是消息的动态决议，forwardingTargetForSelector是消息的快速转发，methodSignatureForSelector是消息的慢速转发。接下来我们就开始探索消息快速转发和慢速转发。
消息的快速转发
我们首先新建一个类CXPerson，定义一个test1方法并实现。
@interface CXPerson : NSObject
- (void)test1;
@end
@implementation CXPerson
- (void)test1 {
}
@end
消息的快速转发顾名思义就是一个转发的过程，如果CXPerson类没实现test1，但是CXPerson类实现了，我们就可以直接把消息的接受者从CXPerson类转发给CXPerson类让CXPerson类去实现test1方法。
- (id)forwardingTargetForSelector:(SEL)aSelector {
NSLog(@"%s-----%@", __func__ , NSStringFromSelector(aSelector));
if (aSelector == @selector(test1)) {
return [CXPerson new];
}
return nil;
}
运行我们可以发现，forwardingTargetForSelector：可以执行的，而且[CXPerson test1]函数也执行了，所以说我们消息转发成功了。
消息的慢速转发
首先我们在LGPerson类里面实现methodSignatureForSelector： 和forwardInvocation：2个方法，methodSignatureForSelector：返回的是一个方法签名 [NSMethodSignature signatureWithObjCTypes:"v@:"]，forwardInvocation：是重新设置方法的响应者。
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
NSLog(@"%s", __func__);
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation {
NSLog(@"%s", __func__);
CXPerson *p = [CXPerson alloc];
if ([self respondsToSelector:anInvocation.selector]) {
[anInvocation invokeWithTarget:self];
} else if ([p respondsToSelector:anInvocation.selector]){
[anInvocation invokeWithTarget:p];
} else {
NSLog(@"%@没有imp", NSStringFromSelector(anInvocation.selector));
}
}
我们还是调用test1,运行：methodSignatureForSelector：和forwardInvocation：这2个方法可以执行的，而且[CXPerson test1]函数也执行了，所以说我们消息慢速转发成功了。
resolveInstanceMethod方法调用2次的原因
我们在消息的动态决议发现resolveInstanceMethod方法调用了2次，我们来探索一下。
mian.m:
LGPerson *p = [[LGPerson alloc] init];
[p test1];
LGPerson.m:
+ (BOOL)resolveInstanceMethod:(SEL)sel {
NSLog(@"%s-----%@", __func__ , NSStringFromSelector(sel));
return [super resolveInstanceMethod:sel];
}
我们在resolveInstanceMethod函数内部打上断点。运行，我们来看堆栈信息。当第一次到断点的时候，我们可以看到是消息快速查找之后调用了_objc_msgSend_uncached函数，然后调用用lookUpImpOrForward函数，依次调用resolveMethod_locked、resolveInstanceMethod等函数。
跳过断点，我们可以发现第二次调用resolveInstanceMethod函数，我们看看堆栈信息。
我们可以发现先是汇编调用了__forward__和__methodDescriptionForSelector，然后调用了class_getInstanceMethod函数，class_getInstanceMethod内部调用了lookUpImpOrForward，所以resolveInstanceMethod函数就会走2次。
