动态方法决议

objc_msgSend发送消息会先从缓存里面imp缓存中查找，如果没有查找到会进入lookUpImpOrForward查找，先从当前类的methods()查找，没有就去父类缓存，不断循环查找。如果都没有则会进入动态方法决议流程。resolveMethod_locked

• resolveMethod_locked

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 (!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);
}

1. 判断当前是类还是元类，再执行resolveInstanceMethod，判断类是否实现了-(void)resolveInstanceMethod方法
2. 最后给一次机会lookUpImpOrForwardTryCache去处理

• objc->resolveInstanceMethod

static void resolveInstanceMethod(id inst, SEL sel, Class cls)
{
    runtimeLock.assertUnlocked();
    ASSERT(cls->isRealized());
    SEL resolve_sel = @selector(resolveInstanceMethod:);
      //判断当前类的缓存方法中没有resolveInstanceMethod
    if (!lookUpImpOrNilTryCache(cls, resolve_sel, cls->ISA(/*authenticated*/true))) {
        // Resolver not implemented.
        return;
    }

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    //向类的方法resolveInstanceMethod发送消息，并处理
    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 = lookUpImpOrNilTryCache(inst, sel, cls);

    .....
}

1. 判断当前类的缓存方法中没有resolveInstanceMethod
2. 没有就向resolveInstanceMethod发送消息，去处理
3. 执行lookUpImpOrNilTryCache

• _lookUpImpTryCache
  lookUpImpOrNilTryCache->_lookUpImpTryCache

ALWAYS_INLINE
static IMP _lookUpImpTryCache(id inst, SEL sel, Class cls, int behavior)
{
    runtimeLock.assertUnlocked();

    if (slowpath(!cls->isInitialized())) {
        // see comment in lookUpImpOrForward
        return lookUpImpOrForward(inst, sel, cls, behavior);
    }
   //缓存中有没有imp
    IMP imp = cache_getImp(cls, sel);
    if (imp != NULL) goto done;
#if CONFIG_USE_PREOPT_CACHES
    if (fastpath(cls->cache.isConstantOptimizedCache(/* strict */true))) {
        imp = cache_getImp(cls->cache.preoptFallbackClass(), sel);
    }
#endif
  //缓存没有imp，执行lookUpImpOrForward
    if (slowpath(imp == NULL)) {
        return lookUpImpOrForward(inst, sel, cls, behavior);
    }

done:
    if ((behavior & LOOKUP_NIL) && imp == (IMP)_objc_msgForward_impcache) {
        return nil;
    }
    return imp;
}

1. 缓存中有没有imp
2. 没有执行lookUpImpOrForward，有就返回imp
3. 此时lookUpImpOrForward会将我们在-(void)resolveInstanceMethod处理的消息，先去methodlist使用二分法查找，找出后添加进缓存
   此时resolveMethod_locked的objc->resolveInstanceMethod执行完毕，已经将我们需要调用的imp添加进methodlist中，并插入缓存
4. 在resolveMethod_locked执行完objc->resolveInstanceMethod，则又会执行_lookUpImpTryCache给了第二次机会，从而调用cache_getImp(cls, sel)->CacheLookup找出imp，如果没有再lookUpImpOrForward

消息转发

当resolveInstanceMethod/resolveClassMethod处理不了，会进入coreFoundation中的_CF_forwarding_prep_0处理。随后会调用下面几个方法：

• forwardingTargetForSelector
• methodSignatureForSelector
• forwardInvocation

备用接收者forwardingTargetForSelector
当前类处理不了，交给其他类处理，如果找到了imp就返回，如果没有就返回nil

-(id)forwardingTargetForSelector:(SEL)aSelector{

    return [LGStudent alloc];
}

forwardingTargetForSelector中还是没有找到，进入最后的次挽救机会，重写methodSignatureForSelector，如下所示

-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    
    return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    
    anInvocation.target = [LGStudent alloc];
    [anInvocation invoke];
}

image.png

在methodSignatureForSelector和forwardInvocation又调用了一次resolveInstanceMethod，即又进行了一次动态方法决议