代码中我们难免会遇到未实现方法的情况(比如动使用方法名称字符串冬天调用方法的情况)，能不能避免unrecognized selector这种crash呢。答案当然是肯定的，苹果给我们提供了消息的动态转发机制。下面我们来探究消息的转发。
首先我们回到前面的lookUpImpOrForward方法。在方法查找过程中如果没有找到方法的实现，就会走到下面的一段代码：

// No implementation found. Try method resolver once.

    if (resolver  &&  !triedResolver) {
        runtimeLock.unlock();
        _class_resolveMethod(cls, sel, inst);
        runtimeLock.lock();
        // Don't cache the result; we don't hold the lock so it may have 
        // changed already. Re-do the search from scratch instead.
        triedResolver = YES;
        goto retry;
    }

其中调用了_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);
        }
    }
}

如果不是元类，那么就是实例方法，否则就是类方法。
我们先进入实例方法的流程查看：

static void _class_resolveInstanceMethod(Class cls, SEL sel, id inst)
{
    if (! lookUpImpOrNil(cls->ISA(), SEL_resolveInstanceMethod, cls, 
                         NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
    {
        // Resolver not implemented.
        return;
    }

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, SEL_resolveInstanceMethod, 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(cls, sel, inst, 
                             NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

    if (resolved  &&  PrintResolving) {...}
}

我们看到以上代码中调用了两次lookUpImpOrNil。
第一次是针对resolveInstanceMethod，如果没有实现就直接返回了，所以OC底层肯定给我们实现了该方法。我们在源码中搜索到了该方法的默认实现：

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    return NO;
}

然后下面给对象发送了resolveInstanceMethod消息，实际上此时resolveInstanceMethod方法已经可以在缓存中查到了。

第二次是针对我们自己未实现的方法。此时又开始查找目标方法的实现。 所以我们可以感觉到前面的resolveInstanceMethod方法应该是为我们提供了实现方法的机会。我们只需要在自己的对象中去实现resolveInstanceMethod方法，然后在这个方法中动态的添加目标方法的实现。这样的话在下面的lookUpImpOrNil方法查找中就能找到我们动态添加的方法实现了。

我们在我们的对象中添加resolveInstanceMethod的实现：

- (void)sayHello{
    NSLog(@"%s",__func__);
}
+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if (sel == @selector(saySomething)) {
        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);
    }
    return [super resolveInstanceMethod:sel];
}

这样处理后，假设我们未实现saySomething方法，然后调用了saySomething方法。就会调用sayHello方法，而不会直接unrecognized selector崩溃了。

上面我们讲的是实例方法的动态决议，下面我们再看下类方法的动态决议。
在_class_resolveMethod方法中，如果是类方法的话，就会走下面的代码：

        _class_resolveClassMethod(cls, sel, inst);
        if (!lookUpImpOrNil(cls, sel, inst, 
                            NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
        {
            // 对象方法 决议
            _class_resolveInstanceMethod(cls, sel, inst);
        }

其中_class_resolveClassMethod对应着实例方法中的_class_resolveInstanceMethod。但是下面还可能会调用_class_resolveInstanceMethod。为什么类方法动态解析还会调用_class_resolveInstanceMethod呢？我们可以联想下ISA的走位图，类方法存在元类中，那么类方法的查找顺序就：
元类---父元类---根元类---NSObject。所以不管是实例方法还是类方法，最后都会找到NSObject。系统可能是为了容错处理，如果我们没有在_class_resolveClassMethod方法中动态添加未实现的类方法，就会继续走一遍_class_resolveInstanceMethod。
既然所有的方法(不管是实例方法还是类方法)，如果未实现的话，都会走_class_resolveInstanceMethod方法。那么我们就可以在NSObject的该方法中做统一的处理。例如可以在此处做一个统一的容错处理。比如我们可以在这里根据不同类别的方法(可以用方法前缀来区分)，做出不同的容错处理(可以跳转到不同容错界面)。但是在这里统一做容错处理也有些弊端：
1、所以的处理都是在NSObject中统一处理，耦合度比较高；
2、如果具体的类实现了该方法，那么就会别拦截，走不到NSObject的这个方法了。

消息转发

如果方法的动态解析没有处理的话，就会进入消息的转发阶段，消息转发又分为快速转发阶段和慢速转发阶段。
1、快速转发：转给另外一个对象去处理；

- (id)forwardingTargetForSelector:(SEL)aSelector{
    if (aSelector == @selector(saySomething)) {
        return [OtherObjc alloc];
    }
    return [super forwardingTargetForSelector:aSelector];
}

如果没有实现方法的动态解析，接下来就会走到上面这个方法。这个方法需要返回一个对象，由该对象去实现该方法。这样就会转发给OtherObjc对象，去调用OtherObjc对象的saySomething方法。

@interface OtherObjc : NSObject

@end

@implementation OtherObjc

- (void)saySomething{
    NSLog(@"%s",__func__);
}

@end

2、慢速转发：将所有未实现的方法封装成NSInvocation，放在统一的一个地方，你可以选择进行处理，也可以选择不处理。
首先我们需要实现methodSignatureForSelector,只有实现了该方法，并且在该方法中返回对应的签名，后面才会走forwardInvocation方法。

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

上面的方法返回了v@:的方法签名，该签名表示方法返回值为void,并且有一个参数。
然后就会调用下面的方法

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    // 系统本质
   SEL aSelector = [anInvocation selector];
    
   if ([[LGTeacher alloc] respondsToSelector:aSelector])
       [anInvocation invokeWithTarget:[LGTeacher alloc]];
   else
       [super forwardInvocation:anInvocation];
}

我们通过Invocation可以获取到方法的相关信息，然后针对不同方法进行相应的处理。可以将不同类别的方法交于不同的对象去处理。如果在这里我们只是实现了forwardInvocation方法，但是没有针对未实现的Selector做出相应的处理。调用未实现的方法的时候，也是不会报错“unRecognize selector”的。

疑问一

我们调用一个未实现的OC实例方法saySomething，可以通过在resolveInstanceMethod方法中添加实现，从而实现OC方法的动态解析。该方法只会调用一次。

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    NSLog(@"===== %s - %@",__func__,NSStringFromSelector(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);
    }

    return [super resolveInstanceMethod:sel];
}

但是如果实现了resolveInstanceMethod:方法。但是没有在该方法中添加方法saySomething的实现，就会调用两次resolveInstanceMethod:方法，为什么呢？
resolveInstanceMethod:实现内容如下

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

我们可以推理，如果在resolveInstanceMethod:方法中添加了方法saySomething实现，然后就会返回YES，此时resolveInstanceMethod:调用了一次。而如果未添加方法saySomething实现，就会第二次调用resolveInstanceMethod:，那么第二次的调动肯定是在后面的流程。后面的流程是什么呢？
首先下面调用了[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__);
    [super forwardInvocation:anInvocation];
}

使用以上代码流程继续跟踪，发现第二次调用的时机位于methodSignatureForSelector和forwardInvocation之间。
然后再怎么追踪第二次方法的调用呢？只能通过汇编了。我们运行项目，此时会crash，因为我们此时我们没有在动态解析中添加方法实现。crash后我们可以看到崩溃前的调用堆栈，类似下图

image.png