[iOS] 消息流程分析之动态方法决议&消息转发

1. 前提

在objc_msgSend的快速查找和慢速查找都没有找到方法实现的情况下，苹果给了两个建议：

动态方法决议：慢速流程未找到后，会执行一次动态方法决议
消息转发：如果动态方法决议仍然没有找到实现，则进行消息转发

如果这两个建议都没有做任何操作，就会报我们日常开发中常见的方法未实现的崩溃报错，其步骤如下：

1.1 定义 Person 类，其中 say666 实例方法和 sayNB 类方法均没有实现:

@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, strong) NSString *nickName;

- (void)sayHello;
- (void)sayMaster;
- (void)say666;
- (void)sayNB;


+ (void)sayNB;
+ (void)sayGoodBye;

@end

@implementation Person

- (void)sayHello{
    NSLog(@"%s",__func__);
}
- (void)sayMaster{
    NSLog(@"%s",__func__);
}
- (void)sayNB{
    NSLog(@"%s",__func__);
}

+ (void)sayGoodBye{
    NSLog(@"%s",__func__);
}

@end

1.2 `main`中分别调用 `Person` 的实例方法 `say666`和类方法 `sayNB`，运行程序，都会报错，提示方法未实现，如下所示：

调用实例方法 say666 报错

截屏2021-01-10 下午11.01.03.png
调用类方法 sayNB 报错

截屏2021-01-10 下午11.01.39.png

1.3 方法未实现报错源码

根据慢速查找的源码，我们发现，其报错最后都是走到__objc_msgForward_impcache方法，以下是报错流程的源码：

STATIC_ENTRY __objc_msgForward_impcache

// No stret specialization.
b   __objc_msgForward

END_ENTRY __objc_msgForward_impcache

//👇
ENTRY __objc_msgForward

adrp    x17, __objc_forward_handler@PAGE
ldr p17, [x17, __objc_forward_handler@PAGEOFF]
TailCallFunctionPointer x17
    
END_ENTRY __objc_msgForward

汇编实现中查找__objc_forward_handler，并没有找到，在源码中去掉一个下划线进行全局搜索_objc_forward_handler，有如下实现，本质是调用的objc_defaultForwardHandler方法:

// Default forward handler halts the process.
__attribute__((noreturn, cold)) void
objc_defaultForwardHandler(id self, SEL sel)
{
    _objc_fatal("%c[%s %s]: unrecognized selector sent to instance %p "
                "(no message forward handler is installed)", 
                class_isMetaClass(object_getClass(self)) ? '+' : '-', 
                object_getClassName(self), sel_getName(sel), self);
}
void *_objc_forward_handler = (void*)objc_defaultForwardHandler;

看着objc_defaultForwardHandler有没有很眼熟，这就是我们在日常开发中最常见的错误：没有实现函数，运行程序，崩溃时报的错误提示。

下面，我们来讲讲如何在崩溃前，如何操作，可以防止方法未实现的崩溃。

2. 三次方法查找的挽救机会

根据苹果的两个建议，我们一共有三次挽救的机会：

1.动态方法决议
消息转发流程：
- 2.快速转发
- 3.慢速转发

在慢速查找流程未找到方法实现时，首先会尝试一次动态方法决议，就是给我们一个机会，将方法实现在运行时动态的添加到当前的类中，其源码实现如下：

static NEVER_INLINE IMP
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 (!lookUpImpOrNil(inst, sel, cls)) {
            resolveInstanceMethod(inst, sel, cls);
        }
    }

    // chances are that calling the resolver have populated the cache
    // so attempt using it
    // 如果方法解析中将其实现指向其他方法，也就是说给 sel 添加了对应的 imp， 则继续走方法查找流程
    return lookUpImpOrForward(inst, sel, cls, behavior | LOOKUP_CACHE);
}

主要分为以下几步：

判断类是否是元类
- 如果是类，执行实例方法的动态方法决议resolveInstanceMethod
- 如果是元类，执行类方法的动态方法决议resolveClassMethod，如果在元类中没有找到或者为空，则执行元类的实例方法的动态方法决议 resolveInstanceMethod，主要是因为类方法在元类中是实例方法，所以还需要查找元类中实例方法的动态方法决议
如果动态方法决议中，将其实现指向了其他方法，则继续查找指定的 imp，即继续慢速查找lookUpImpOrForward流程。

其流程图如下：

image.png

2.1 实例方法(第一次机会，动态方法决议)

针对实例方法调用，在快速&慢速查找均没有找到实例方法的实现时，我们有一次挽救的机会，即尝试一次动态方法决议，由于是实例方法，所以会走到resolveInstanceMethod方法，其源码如下：

static void resolveInstanceMethod(id inst, SEL sel, Class cls)
{
    runtimeLock.assertUnlocked();
    ASSERT(cls->isRealized());
    SEL resolve_sel = @selector(resolveInstanceMethod:);

    // 查找的是 resolveINstanceMethod - 发送前的容错处理，判断是否实现这个方法
    if (!lookUpImpOrNil(cls, resolve_sel, cls->ISA())) {
        // Resolver not implemented.
        return;
    }

    // 这里去调用resolveInstanceMethod方法
    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, resolve_sel, sel);

    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveInstanceMethod adds to self a.k.a. cls
    //
    IMP imp = lookUpImpOrNil(inst, sel, cls);

    if (resolved  &&  PrintResolving) {
        if (imp) {
            _objc_inform("RESOLVE: method %c[%s %s] "
                         "dynamically resolved to %p", 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel), imp);
        }
        else {
            // Method resolver didn't add anything?
            _objc_inform("RESOLVE: +[%s resolveInstanceMethod:%s] returned YES"
                         ", but no new implementation of %c[%s %s] was found",
                         cls->nameForLogging(), sel_getName(sel), 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel));
        }
    }
}

主要分为以下几步：

在发送resolveInstanceMethod消息前，需要查找 cls 类是否实现了这个方法，即通过lookUpImpOrNil 方法又会进入 lookUpImpOrForward 慢速查找流程查找resolveInstanceMethod方法
- 如果没有，则直接返回
- 如果有，则发送resolveInstanceMethod 消息
再次慢速查找实例方法的实现，即通过 lookUpImpOrNil方法又会进入lookUpImpOrForward慢速查找流程查找实例方法

2.1.1 崩溃处理

针对实例方法 say666 未实现的报错崩溃，可以通过在类中重写 resolveInstanceMethod类方法，并将其指向其他方法的实现，即在 Perosn中重写resolveInstanceMethod类方法，将实例方法 say666 的实现指向 sayMaster 方法实现，如下所示：

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if(sel == @selector(say666)){
        IMP imp = class_getMethodImplementation(self, @selector(sayMaster));
        Method sayMethod = class_getInstanceMethod(self, @selector(sayMaster));
        const char *type = method_getTypeEncoding(sayMethod);
        return class_addMethod(self, sel, imp, type);
    }
    return [super resolveInstanceMethod:sel];
}

打印结果如下：

2021-01-11 10:02:50.907278+0800 DebugTest[7994:456820] -[Person sayMaster]

2.2 类方法

针对类方法，与实例方法类似，同样可以通过重写 resolveClassMethod类方法来解决前文的崩溃问题，在 Person 类中重写该方法，并将 sayNB类方法的实现指向类方法sayGoodBye:

+ (BOOL)resolveClassMethod:(SEL)sel{
    if(sel == @selector(sayNB)){
        NSLog(@"类方法 resolveClassMethod");
        IMP imp = class_getMethodImplementation(objc_getMetaClass("Person"), @selector(sayGoodBye));
        Method classMethod = class_getInstanceMethod(objc_getMetaClass("Person"), @selector(sayGoodBye));
        const char *type = method_getTypeEncoding(classMethod);
        return class_addMethod(objc_getMetaClass("Person"), @selector(sayNB), imp, type);
    }
    return [super resolveClassMethod:sel];
}

注意：
resolveClassMethod 类方法的重写需要注意一点，传入的cls是元类，可以通过objc_getMetaClass方法获取类的元类，原因是因为类方法在元类中是实例方法。

2.3 优化

上面的方式都是在每个类中重写，那么有没有更好的方法呢？其实通过方法的慢速查找流程可以发现其查找路径有两条：

实例方法：类 - 父类 - 根类 - nil
类方法：元类 - 根元类 - 根类 - nil

它们的共同点是如果没有找到，都会去根类即 NSObject 中查找，所以我们可以将上面的两个方法统一整合在一起。
给 NSObject 添加一个分类来实现统一处理，而且由于类方法的查找，在其继承链，查找的也是实例方法，所以可以将实例方法和类方法的统一处理写在NSObject 分类的resolveInstanceMethod方法中，如下所示：

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if (sel == @selector(say666)) {
        NSLog(@"%@ 来了", NSStringFromSelector(sel));
        
        IMP imp = class_getMethodImplementation(self, @selector(sayMaster));
        Method sayMethod  = class_getInstanceMethod(self, @selector(sayMaster));
        const char *type = method_getTypeEncoding(sayMethod);
        return class_addMethod(self, sel, imp, type);
    }else if (sel == @selector(sayNB)) {
        NSLog(@"%@ 来了", NSStringFromSelector(sel));
        
        IMP imp = class_getMethodImplementation(objc_getMetaClass("Person"), @selector(sayGoodBye));
        Method classMethod  = class_getInstanceMethod(objc_getMetaClass("Person"), @selector(sayGoodBye));
        const char *type = method_getTypeEncoding(classMethod);
        return class_addMethod(objc_getMetaClass("Person"), sel, imp, type);
    }
    return NO;
}

这种方式的实现，与源码中针对类方法的处理逻辑是一致的，即完美阐述了为什么调用了类方法的动态方法决议，还要调用对象方法的动态方法决议，其根本原因还是类方法是在元类中的实例方法。

当然，上面这种写法还是会有其他的问题，比如系统方法也会被更改，针对这一点，是可以优化的，即我们可以针对自定义类中方法统一方法名的前缀，根据前缀来判断是否是自定义方法，然后统一处理自定义方法，例如可以在崩溃前pop到首页，主要是用于app线上防崩溃的处理，提升用户的体验。

3. 消息转发流程

在慢速查找的流程中，我们了解到，如果快速+慢速查找没有找到方法实现，动态方法决议也不行，那么就会使用消息转发，所谓消息转发，就是当前消息转发到其他对象进行处理。
相关的方法有三个：
-【快速转发】：forwardingTargetForSelector
-【慢速转发】：methodSignatureForSelector & forwardInvocation

大体流程如下：

image.png

当快速&慢速查找以及动态方法决议之后还没有找到方法实现，之后消息转发的处理主要分为两部分：

首先是快速消息转发，即走到forwardingTargetForSelector方法
- 如果返回消息接收者，在消息接收者中还是没有找到，则进入另一个方法的查找流程
- 如果返回 nil，则进入慢速消息转发
慢速转发执行 methodSignatureForSelector 方法
- 如果返回的方法签名为 nil，则直接崩溃报错
- 如果返回的方法签名不为nil，走到 forwardInvocation方法中，对invocation事务进行处理，如果不处理也不会报错

3.1 快速消息转发(第二次机会)

针对于实例方法和类方法，快速消息转发提供了两个方法：

- (id)forwardingTargetForSelector:(SEL)aSelector  // 转发实例方法
+ (id)forwardingTargetForSelector:(SEL)aSelector  // 转发类方法，id需要返回类对象

针对前文的崩溃问题，如果动态方法决议也没有找到实现，则需要在 Person中重写forwardingTargetForSelector方法，将 Person 的实例方法的接收者指定为 Student 对象（Student 类中有 say666 的具体实现），如下所示：

- (id)forwardingTargetForSelector:(SEL)aSelector{
    NSLog(@"Person forwardingTargetForSelector: %@",NSStringFromSelector(aSelector));
    return [Student alloc];
}

执行结果如下：

2021-01-11 10:55:52.420783+0800 DebugTest[8350:480424] Person forwardingTargetForSelector: say666
2021-01-11 10:55:52.421230+0800 DebugTest[8350:480424] Student say666
Program ended with exit code: 0

当然也可以不指定消息接收者，直接调用父类的该方法，如果还是没有找到，则直接报错。

注意：类方法的快速转发需要重写的是forwardingTargetForSelector类方法。

3.2 慢速转发(第三次机会)

针对第二次机会即快速转发中，还是没有找到，则进入最后一次挽救的机会，在 Person 中重写methodSignatureForSelector和forwardInvocation，如下所示：

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    NSLog(@"%s - %@",__func__,NSStringFromSelector(aSelector));
    return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s - %@",__func__,anInvocation);
}

打印结果如下，发现forwardInvocation方法中不对invocation 进行处理，也不会崩溃：

2021-01-11 11:00:52.889662+0800 DebugTest[8380:482847] -[Person methodSignatureForSelector:] - say666
2021-01-11 11:00:52.890443+0800 DebugTest[8380:482847] -[Person forwardInvocation:] - <NSInvocation: 0x10077b040>
Program ended with exit code: 0

当然也可以处理invocation 事务，如下所示，修改invocation的 target为[Student alloc]，调用[anInvocation invoke] 触发，即 Person 类的say666 实例方法的调用会调用Student 的 say666 方法：

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s - %@",__func__,anInvocation);
    anInvocation.target = [Student alloc];
    [anInvocation invoke];
}