在上一篇 iOS 底层原理 - 消息查找流程中，我们知道OC消息机制分为三个阶段，消息发送，动态解析和消息转发，如果消息发送阶段没有找到方法，则会进入动态解析阶段，负责动态的添加方法实现。我们先分析下动态解析阶段。

动态方法决议阶段

我们先来到_class_resolveMethod

void _class_resolveMethod(Class cls, SEL sel, id inst)
{
    if (! cls->isMetaClass()) {
        // try [cls resolveInstanceMethod:sel]

        _class_resolveInstanceMethod(cls, sel, inst);
    } 
    else {
        // try [nonMetaClass resolveClassMethod:sel]
        // and [cls resolveInstanceMethod:sel]
        _class_resolveClassMethod(cls, sel, inst);  // 已经处理
        if (!lookUpImpOrNil(cls, sel, inst, 
                            NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
        {
              // 对象方法 决议
            _class_resolveInstanceMethod(cls, sel, inst);
        }
    }
}

首先会判断cls是不是元类，如果cls不是元类的话，说明调用的是实例方法，那就会调用_class_resolveInstanceMethod函数，如果是元类的话，说明调用的是类方法，那么就会调用_class_resolveClassMethod函数，并且调用完后会再次查找一下sel的指针，找到了就会返回，如果还是找不到的话会调用_class_resolveInstanceMethod函数，这里可以用上面的isa走位图解释。然后进入_class_resolveInstanceMethod方法

static void _class_resolveInstanceMethod(Class cls, SEL sel, id inst)
{
//这里是一种容错处理，判断有没有resolveInstanceMethod这个方法，没有就return，有就进行下一步，如果一个类没有继承NSObject，是自己写的resolveInstanceMethod这个方法，这行就不会通过
    if (! lookUpImpOrNil(cls->ISA(), SEL_resolveInstanceMethod, cls, 
                         NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
    {
        // Resolver not implemented.
        return;
    }
// 如果找到，则通过objc_msgSend调用一下+(BOOL)resolveInstanceMethod:(SEL)sel方法
    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, SEL_resolveInstanceMethod, sel);
// 再次寻找方法的IMP
    // 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(cls, sel, inst, 
                             NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

    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里处理，给一个没有实现的方法一个已经实现的方法的IMP，就可以实现动态解析。
我们先调用一个对象方法，在这里我们调用一个不存在的saySomething方法，给它sayHello方法的imp

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    
    if (sel == @selector(saySomething)) {
        NSLog(@"说话了");
        
        IMP sayHIMP = class_getMethodImplementation(self, @selector(sayHello));
    
        Method sayHMethod = class_getInstanceMethod(self, @selector(sayHello));
        
        const char *sayHType = method_getTypeEncoding(sayHMethod);
        
        return class_addMethod(self, sel, sayHIMP, sayHType);
    }
    
    NSLog(@"来了  老弟 - %p",sel);
    return [super resolveInstanceMethod:sel];
}

打印结果

2020-03-08 15:24:21.590396+0800 LGTest[7487:301370] 说话了
2020-03-08 15:24:21.590947+0800 LGTest[7487:301370] -[LGStudent sayHello]
Program ended with exit code: 0

然后看下类方法，需要实现_class_resolveClassMethod，这里要注意类方法在元类里面，需要把上面的self改为objc_getMetaClass("LGStudent")，这里划重点。。。

+ (BOOL)resolveClassMethod:(SEL)sel{
    
    NSLog(@"来了类方法:%s - %@",__func__,NSStringFromSelector(sel));

     if (sel == @selector(sayLove)) {
         NSLog(@"说- 说你你爱我");
         IMP sayHIMP = class_getMethodImplementation(objc_getMetaClass("LGStudent"), @selector(sayObjc));
         Method sayHMethod = class_getClassMethod(objc_getMetaClass("LGStudent"), @selector(sayObjc));
         const char *sayHType = method_getTypeEncoding(sayHMethod);
         // 类方法在元类 objc_getMetaClass("LGStudent")
         return class_addMethod(objc_getMetaClass("LGStudent"), sel, sayHIMP, sayHType);
     }
     return [super resolveClassMethod:sel];
}

打印结果为

2020-03-08 17:14:18.911042+0800 LGTest[8481:346767] 来了类方法:+[LGStudent resolveClassMethod:] - sayLove
2020-03-08 17:14:18.911631+0800 LGTest[8481:346767] 说- 说你你爱我
2020-03-08 17:14:18.911793+0800 LGTest[8481:346767] +[LGStudent sayObjc]
Program ended with exit code: 0

我们在验证一下类方法找不到就会走_class_resolveInstanceMethod这个方法。
这里我们把上面的方法实现注释掉，然后在NSObject中添加一个对象方法sayLove，运行下面代码

+ (BOOL)resolveClassMethod:(SEL)sel{
    
    NSLog(@"来了类方法:%s - %@",__func__,NSStringFromSelector(sel));

//     if (sel == @selector(sayLove)) {
//         NSLog(@"说- 说你你爱我");
//         IMP sayHIMP = class_getMethodImplementation(objc_getMetaClass("LGStudent"), @selector(sayObjc));
//         Method sayHMethod = class_getClassMethod(objc_getMetaClass("LGStudent"), @selector(sayObjc));
//         const char *sayHType = method_getTypeEncoding(sayHMethod);
//         // 类方法在元类 objc_getMetaClass("LGStudent")
//         return class_addMethod(objc_getMetaClass("LGStudent"), sel, sayHIMP, sayHType);
//     }
     return [super resolveClassMethod:sel];
}

打印结果为

2020-03-08 17:13:15.772444+0800 LGTest[8446:345707] 对象方法-[NSObject(LG) sayLove]
Program ended with exit code: 0

消息转发

如果没有做动态解析，就会来到消息转发阶段。
我们先看一下找不到方法的崩溃信息，发现中间还经过了forwarding和_CF_forwarding_prep_0，那我们可以猜想系统在消息转发时可能做了其他的处理。

*** First throw call stack:
(
    0   CoreFoundation                      0x00007fff447412fd __exceptionPreprocess + 256
    1   libobjc.A.dylib                     0x000000010035306a objc_exception_throw + 42
    2   CoreFoundation                      0x00007fff447bb056 __CFExceptionProem + 0
    3   CoreFoundation                      0x00007fff446e318f ___forwarding___ + 1485
    4   CoreFoundation                      0x00007fff446e2b38 _CF_forwarding_prep_0 + 120
    5   LGTest                              0x0000000100000d29 main + 89
    6   libdyld.dylib                       0x00007fff706043d5 start + 1
)
libc++abi.dylib: terminating with uncaught exception of type NSException

下面开始验证，我们在之前的方法消息查找流程中注意到填充缓存的时候我们会走log_and_fill_cache这个方法，是打印消息的这种形式。这里我们看到只有objcMsgLogEnabled为true的时候才会打印，那么继续找它什么时候为ture，

bool logMessageSend(bool isClassMethod,
                    const char *objectsClass,
                    const char *implementingClass,
                    SEL selector)
{
    char    buf[ 1024 ];

    // Create/open the log file
    if (objcMsgLogFD == (-1))
    {
        snprintf (buf, sizeof(buf), "/tmp/msgSends-%d", (int) getpid ());
        objcMsgLogFD = secure_open (buf, O_WRONLY | O_CREAT, geteuid());
        if (objcMsgLogFD < 0) {
            // no log file - disable logging
            objcMsgLogEnabled = false;
            objcMsgLogFD = -1;
            return true;
        }
    }

    // Make the log entry
    snprintf(buf, sizeof(buf), "%c %s %s %s\n",
            isClassMethod ? '+' : '-',
            objectsClass,
            implementingClass,
            sel_getName(selector));

    objcMsgLogLock.lock();
    write (objcMsgLogFD, buf, strlen(buf));
    objcMsgLogLock.unlock();

    // Tell caller to not cache the method
    return false;
}

通过instrumentObjcMessageSends这个方法来对objcMsgLogEnabled进行赋值，也就是flag为true才会打印日志

void instrumentObjcMessageSends(BOOL flag)
{
    bool enable = flag;

    // Shortcut NOP
    if (objcMsgLogEnabled == enable)
        return;

    // If enabling, flush all method caches so we get some traces
    if (enable)
        _objc_flush_caches(Nil);

    // Sync our log file
    if (objcMsgLogFD != -1)
        fsync (objcMsgLogFD);

    objcMsgLogEnabled = enable;
}

那么我们通过在代码中暴露instrumentObjcMessageSends方法，并定位在要崩溃的方法中，可以打上日志，来查看调用

 instrumentObjcMessageSends(true);
 [student saySomething];
instrumentObjcMessageSends(false);

之后前往/tmp/msgSends 然后生成了文件 msgSends-，查看打印日志

屏幕快照 2020-03-14 下午3.32.09.png

发现经过了resolveInstanceMethod，forwardingTargetForSelector，methodSignatureForSelector，doesNotRecognizeSelector,这就是我们要寻找的处理方法。forwardingTargetForSelector，methodSignatureForSelector也就是我们下面要说的快速转发流程和慢速转发流程。

快速转发流程 forwardingTargetForSelector

我们先找一下官方文档，我们可以得到它的返回参数是一个对象，如果这个对象非nil，非self的话，系统会将运行的消息转发给这个对象执行。否则，继续查找其他流程。意思就是一个无法识别的消息可以让其他的对象来处理这个消息，系统给了个将这个sel转给其他对象的机会。

16f64591d863f64f.png

那么我们可以做以下处理，在LGTeacher中实现方法saySomething，然后交给LGTeacher去处理。

- (id)forwardingTargetForSelector:(SEL)aSelector{
    NSLog(@"%s -- %@",__func__,NSStringFromSelector(aSelector));
    if (aSelector == @selector(saySomething)) {
        return [LGTeacher alloc];
    }
    return [super forwardingTargetForSelector:aSelector];
}

打印结果如下：

2020-03-14 15:37:30.290247+0800 008-方法查找-消息转发[999:27953] -[LGStudent forwardingTargetForSelector:] -- saySomething
2020-03-14 15:37:30.291713+0800 008-方法查找-消息转发[999:27953] -[LGTeacher saySomething]
Program ended with exit code: 0

慢速转发流程

如果快速转发阶段没有实现，就会进入到慢速转发阶段，也就是methodSignatureForSelector。我们先找一下methodSignatureForSelector方法的文档。

16f6471630fe64f2.png

这个方法会返回SEL方法的签名，返回的签名是根据方法的参数来封装的，这个函数让重载方有机会抛出一个函数的签名，再由后面的forwardInvocation去执行。也就是forwardInvocation和methodSignatureForSelector必须是同时存在的。forwardInvocation这个函数可以将NSInvocation多次转发到多个对象中，这也是这个方式灵活的地方。forwardingTargetForSelector只能通过Selector 的形式转向一个对象。

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

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s ",__func__);
    
   SEL aSelector = [anInvocation selector];

   if ([[LGTeacher alloc] respondsToSelector:aSelector])
       [anInvocation invokeWithTarget:[LGTeacher alloc]];
   else
       [super forwardInvocation:anInvocation];
}

打印结果如下

2020-03-14 15:52:28.392549+0800 008-方法查找-消息转发[1117:34015] -[LGStudent methodSignatureForSelector:] -- saySomething
2020-03-14 15:52:28.394561+0800 008-方法查找-消息转发[1117:34015] -[LGStudent forwardInvocation:]
2020-03-14 15:52:28.395346+0800 008-方法查找-消息转发[1117:34015] -[LGTeacher saySomething]
Program ended with exit code: 0

总结

1.objc_msgSend 从缓存中查找imp
2.慢速递归查找方法列表
3.没有找到imp，那么看你有没有进行特殊处理，也就是消息动态解析，如果没有进行特殊处理，就来到消息转发阶段。
4.快速消息转发 forwardingTargetForSelector，有没有交给别人处理，如果没有，就进入慢速消息转发
5.慢速消息转发，意味着你不想处理，谁想要处理就去处理。methodSignatureForSelector 实现方法签名，forwardInvocation 来对消息处理
6.doesNotRecognizeSelector 系统不会分发这个事务，报错。

最后附上流程图

屏幕快照 2020-03-14 下午6.06.09.png

补充

探究的过程中，我们发现在动态方法决议阶段，如果我们没有处理动态方法决议，会进来两次。

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

打印结果为

2020-03-14 18:11:50.658224+0800 LGTest[2037:82739] 来了老弟:+[LGStudent resolveInstanceMethod:] - saySomething
2020-03-14 18:11:50.659050+0800 LGTest[2037:82739] 来了老弟:+[LGStudent resolveInstanceMethod:] - saySomething
2020-03-14 18:11:50.659287+0800 LGTest[2037:82739] -[LGStudent saySomething]: unrecognized selector sent to instance 0x100f50650

这里为什么回来两次呢，我们观察一下控制台打印：

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


- (id)forwardingTargetForSelector:(SEL)aSelector{
    NSLog(@"%s -- %@",__func__,NSStringFromSelector(aSelector));
    
    return [super forwardingTargetForSelector:aSelector];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    NSLog(@"%s -- %@",__func__,NSStringFromSelector(aSelector));
    if (aSelector == @selector(saySomething)) { // v @ :
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
    return [super methodSignatureForSelector:aSelector];
}
//
////
- (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s ",__func__);

       
}

结果如下：

2020-03-14 18:20:45.339901+0800 008-方法查找-消息转发[2117:86023] +[LGStudent resolveInstanceMethod:]
2020-03-14 18:20:45.340428+0800 008-方法查找-消息转发[2117:86023] -[LGStudent forwardingTargetForSelector:] -- saySomething
2020-03-14 18:20:45.340584+0800 008-方法查找-消息转发[2117:86023] -[LGStudent methodSignatureForSelector:] -- saySomething
2020-03-14 18:20:45.340665+0800 008-方法查找-消息转发[2117:86023] +[LGStudent resolveInstanceMethod:]
2020-03-14 18:20:45.340736+0800 008-方法查找-消息转发[2117:86023] -[LGStudent forwardInvocation:]
Program ended with exit code: 0

从打印结果看出在methodSignatureForSelector和forwardInvocation之间还做了其他的操作，methodSignatureForSelector会返回一个方法签名，之后会有一步去匹配签名的过程，会调用class_getInstanceMethod方法。