OC底层探索12-消息动态决议，方法慢速、快速转发OC底层探索12-消息动态决议，方法慢速、快速转发

static NEVER_INLINE IMP
resolveMethod_locked(id inst, SEL sel, Class cls, int behavior)
{
    runtimeLock.assertLocked();
    ASSERT(cls->isRealized());

    runtimeLock.unlock();
    // 动态方法决议 : 给一次机会 重新查询
    if (! cls->isMetaClass()) {  // 对象 - 类
        resolveInstanceMethod(inst, sel, cls);
    } 
    else { // 类方法 - 元类
        resolveClassMethod(inst, sel, cls);
        if (!lookUpImpOrNil(inst, sel, cls)) { 
        // 此处cls已经是元类了。元类调用方法，根据isa关系会在根元类中查找方法。
        //通过根元类的继承链最终找到NSObject，在NSObject中查询`实例方法`的resolve的实现。巧妙的设计！！
            resolveInstanceMethod(inst, sel, cls);
        }
    }

    // 在调用一次查询
    return lookUpImpOrForward(inst, sel, cls, behavior | LOOKUP_CACHE);
}

static void resolveInstanceMethod(id inst, SEL sel, Class cls)
{
    runtimeLock.assertUnlocked();
    ASSERT(cls->isRealized());
    //生成动态解析的方法Sel
    SEL resolve_sel = @selector(resolveInstanceMethod:);

    //在当前类的元类中查找resolve方法是否找得到
    if (!lookUpImpOrNil(cls, resolve_sel, cls->ISA())) {
        return;
    }
    
    //resolveInstanceMethod消息发送
    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, resolve_sel, sel);

    //进行一次方法慢速查询，将当前方法插入缓存中，提高效率
    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 {
            _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));
        }
    }
}

static void resolveClassMethod(id inst, SEL sel, Class cls)
{
    runtimeLock.assertUnlocked();
    ASSERT(cls->isRealized());
    ASSERT(cls->isMetaClass());
    //判断resolveClassMethod方法是否实现
    if (!lookUpImpOrNil(inst, @selector(resolveClassMethod:), cls)) {
        return;
    }
    //判断类是否实现
    Class nonmeta;
    {
        mutex_locker_t lock(runtimeLock);
        //根据元类找到类
        nonmeta = getMaybeUnrealizedNonMetaClass(cls, inst);
        if (!nonmeta->isRealized()) {
            _objc_fatal("nonmeta class %s (%p) unexpectedly not realized",
                        nonmeta->nameForLogging(), nonmeta);
        }
    }
    //resolveClassMethod消息发送
    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(nonmeta, @selector(resolveClassMethod:), sel);

    //进行一次方法慢速查询，将当前方法插入缓存中，提高效率
    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 resolveClassMethod:%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));
        }
    }
}

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

+ (BOOL)resolveClassMethod:(SEL)sel{
    IMP imp           = class_getMethodImplementation(objc_getMetaClass("Person"), @selector(lgClassMethod));
        Method sayMMethod = class_getInstanceMethod(objc_getMetaClass("Person"), @selector(lgClassMethod));
        const char *type  = method_getTypeEncoding(sayMMethod);
        return class_addMethod(objc_getMetaClass("Person"), sel, imp, type);
}

static void
log_and_fill_cache(Class cls, IMP imp, SEL sel, id receiver, Class implementer)
{
#if SUPPORT_MESSAGE_LOGGING
    if (slowpath(objcMsgLogEnabled && implementer)) {
        bool cacheIt = logMessageSend(implementer->isMetaClass(), 
                                      cls->nameForLogging(),
                                      implementer->nameForLogging(), 
                                      sel);
        if (!cacheIt) return;
    }
#endif
    cache_fill(cls, sel, imp, receiver);
}

// 1: 快速转发
- (id)forwardingTargetForSelector:(SEL)aSelector{
    NSLog(@"%s - %@",__func__,NSStringFromSelector(aSelector));
    //此处返回一个实现该方法sel的对象
    return [super forwardingTargetForSelector:aSelector];
}

// 2: 慢速转发
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    NSLog(@"%s - %@",__func__,NSStringFromSelector(aSelector));
    //返回方法的参数编码
    return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s - %@",__func__,anInvocation);
    //更换方法接受者
    anInvocation.target = [LGStudent alloc];
    //更换方法索引
    anInvocation.selector = NSSelectorFromString(@"实现了该IMP的SEL");
    //更换方法参数编码
    anInvocation.methodSignature = [NSMethodSignature signatureWithObjCTypes:"v@:"]
    // anInvocation 保存 - 方法
    [anInvocation invoke];
}