OC底层探索之消息转发

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是啥？

imp = forward_imp

我们可以看到lookUpImpOrForward函数顶部有forward_imp = (IMP)_objc_msgForward_impcache;这行代码，它对forward_imp进行赋值，那我们再看看_objc_msgForward_impcache函数内部实现。

forward_imp = (IMP)_objc_msgForward_impcache

我们通过源码是看不到_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)"这个异常。

_objc_msgForward_impcache汇编

objc_defaultForwardHandler

消息的动态决议

找不到方法就会抛出异常，那抛出异常之前系统做了什么事情呢？我们回到lookUpImpOrForward内部，我们刚看到其实报异常的函数还没有调用，会走resolveMethod_locked函数，我们先看看(behavior & LOOKUP_RESOLVER)这个判断条件，LOOKUP_RESOLVER的值是2。

if (slowpath(behavior & LOOKUP_RESOLVER)) {
        behavior ^= LOOKUP_RESOLVER;
        return resolveMethod_locked(inst, sel, cls, behavior);
    }

LOOKUP_RESOLVER

我们在[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函数。

behavior值为3

resolveMethod_locked

lookUpImpOrForwardTryCache

_lookUpImpTryCache

我们看到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，好吧，那我们去实现它吧。

resolveInstanceMethod

我们在LGPerson类的.m内部实现resolveInstanceMethod函数，并打印，运行：

@implementation LGPerson

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    NSLog(@"%s-----%@", __func__ , NSStringFromSelector(sel));
    return [super resolveInstanceMethod:sel];
}

@end

从打印结果我们可以看到，系统在抛出异常之前会调用resolveInstanceMethod函数，但是会调用2次，它为什么会调用2次呢，我们在文章的结尾会进行探索。

image.png

我们知道objc_msgSend本质就是通过方法名找具体实现的过程。那我们在resolveInstanceMethod函数内部去给该方法添加一个实现看看。我们首先实现一个method1方法，然后获取该方法的imp，添加到本类里面。

        IMP imp = class_getMethodImplementation(self.class, @selector(method1));
        class_addMethod(self.class, sel, imp, "v@:");
        return YES;

运行我们可以看到不会抛出异常，调用了resolveInstanceMethod函数method1成功调用了。

resolveInstanceMethod

那我们在实现一个resolveClassMethod函数，并[LGPerson test2]，运行,我们可以看到当找不到test2类方式，系统会抛出异常且调用resolveClassMethod函数

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函数。

done

log_and_fill_cache

instrumentObjcMessageSends

logMessageSend

重写instrumentObjcMessageSends函数,并添加test1方法的实现。然后运行：

        LGPerson *person = [LGPerson alloc];
        instrumentObjcMessageSends(YES);
        [person test1];
        instrumentObjcMessageSends(NO);

@implementation LGPerson

-(void)test1 {
    
}

@end

重写instrumentObjcMessageSends函数

前往/tmp文件夹找到msgSends开头的文件打开。我们发现了一个msgSends-39378，打开可以看到- LGPerson LGPerson test1
函数调用日志了。

/tmp文件夹

msgSends-39378

我们把test1的实现注释掉,运行。我们可以看到/tmp文件夹下多了一个msgSends-39459文件。打开msgSends-39459文件可以看到我们在抛出异常之前会依次调用resolveInstanceMethod、forwardingTargetForSelector、methodSignatureForSelector、resolveInstanceMethod等函数。resolveInstanceMethod是消息的动态决议，forwardingTargetForSelector是消息的快速转发，methodSignatureForSelector是消息的慢速转发。接下来我们就开始探索消息快速转发和慢速转发。

/tmp文件夹

image.png

消息的快速转发

我们首先新建一个类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]函数也执行了，所以说我们消息转发成功了。

forwardingTargetForSelector

消息的慢速转发

首先我们在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]函数也执行了，所以说我们消息慢速转发成功了。

methodSignatureForSelector打印结果

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堆栈信息

跳过断点，我们可以发现第二次调用resolveInstanceMethod函数，我们看看堆栈信息。
我们可以发现先是汇编调用了__forward__和__methodDescriptionForSelector，然后调用了class_getInstanceMethod函数，class_getInstanceMethod内部调用了lookUpImpOrForward，所以resolveInstanceMethod函数就会走2次。

第二次调用resolveInstanceMethod堆栈信息

class_getInstanceMethod