方法调用（三）-- 动态方法决议&消息转发

方法调用（一）-- objc_msgSend快速查找流程
 方法调用（二）-- 慢速查找流程
 方法调用（三）-- 动态方法决议&消息转发

动态方法决议

上篇文章简单介绍了一下resolveInstanceMethod方法，这事系统给我们提供的一次再次查找方法的机会

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
    return lookUpImpOrForward(inst, sel, cls, behavior | LOOKUP_CACHE);
}

源码中可以看到，不只是有对象方法的决议，还有类方法的。
但是类方法在底层是元类的对象方法，所以类方法也可以用对象的方法。
元类在开发中是无法进行控制的，但是根据继承链，我们可以在NSObject中进行相关处理。可以创建NSObject的一个分类。

@interface NSObject (DZ)
@end

@implementation NSObject (DZ)
+ (BOOL)resolveInstanceMethod:(SEL)sel{
    
    if (sel == @selector(say666)) {
        NSLog(@"%@ 来了",NSStringFromSelector(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);
    } else if (sel == @selector(sayNB)) {
        
        IMP imp           = class_getMethodImplementation(objc_getMetaClass("Person"), @selector(ClassMethod));
        Method sayMMethod = class_getInstanceMethod(objc_getMetaClass("Person"), @selector(ClassMethod));
        const char *type  = method_getTypeEncoding(sayMMethod);
        return class_addMethod(objc_getMetaClass("Person"), sel, imp, type);
    }
    return NO;
}

@end

消息转发

动态方法决议可以解决相关找不到imp的处理，但是处理起来还是麻烦一些。接下来了解一下消息转发，这阶段分为两部分：快速消息转发和慢速消息转发

快速消息转发

通过重写- (id)forwardingTargetForSelector:(SEL)aSelector方法，实现快速转发流程。
这个方法是将无法处理的方法，转给其他对象来处理。可以看到返回值是id类型，参数也是一个sel。例如：

@interface Person : NSObject
- (void)sayHello;
@end

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

@interface Student : NSObject
- (void)sayHello;
@end
@implementation Student
- (void)sayHello{
    NSLog(@"%s",__func__);
}
@end

//调用
Person *person = [Person alloc];
[person sayHello];

定义两个类，Person和Student。两个类中都声明了sayHello，但是Person中没有实现
调用时，对象person调用sayHello方法。正常情况下回出现闪退，因为找不到相关imp。
但是在Person类中实现了forwardingTargetForSelector方法，将无法找到imp的方法转给了Student的对象，这样就不会出现闪退的情况。

打印结果

-[Person forwardingTargetForSelector:] - sayHello
-[Student sayHello]

这就是快速消息转发。

慢速消息转发

如果没有实现快速消息转发的方法，那么就会进入慢速消息转发。此过程需要重写两个方法：

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector：设置方法的签名
- (void)forwardInvocation:(NSInvocation *)anInvocation：字面意思是“转发调用”

还是利用上面的例子，在Person类中实现这两个方法

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

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

打印结果：

-[Person methodSignatureForSelector:] - sayHello
-[Person forwardInvocation:] - <NSInvocation: 0x10047ce10>
-[Student sayHello]

与快速的区别在于需要指定方法签名，并且在anInvocation参数中可以拿相关的调用信息，并且可以进行修改，例如示例中修改target属性。

反汇编查找消息转发流程

之前我们在看objc源码的时候，看到动态方法决议调用的相关代码，但是后续消息转发的代码是没有看到相关方法的调用。原因是此处是CoreFoundation处理的。
将上面的消息转发的相关代码注释掉，执行调用代码

Person *person = [Person alloc];
[person sayHello];

运行起来后会闪退，通过lldb的bt命令，查看当前的堆栈

在调用doesNotRecognizeSelector之前调用了CoreFoundation中的__forwarding_prep_0___和___forwarding___两个函数。
但是CoreFoundation没有开源，所以只能运用反汇编的方式进行查看。

找到CoreFoundation文件路径

lldb中执行image list命令，查看到CoreFoundation文件路径

访达（Finder）中前往到这个文件，快捷键⌘+shift+g，将地址复制进去

Hooper应用查看反汇编

利用Hopper应用进行反汇编查看CoreFoundation。

将CoreFoundation文件拖入到Hopper中。
全局搜索__forwarding_prep_0___，然后查看伪代码

图中能看到____forwarding___调用，双击点击可以进入实现。
相关代码：

int ____forwarding___(int arg0, int arg1) {

    .....//省略无关代码
    
    if (class_respondsToSelector(r12, @selector(forwardingTargetForSelector:)) == 0x0) goto loc_64a67;
    loc_649fc:
    rdi = rbx;
    rax = [rdi forwardingTargetForSelector:var_140];
    if ((rax == 0x0) || (rax == rbx)) goto loc_64a67;
    
    ......//省略无关代码
    
    loc_64a8a:
    rax = class_respondsToSelector(r12, @selector(methodSignatureForSelector:));
    r14 = var_138;
    var_148 = r15;
    if (rax == 0x0) goto loc_64dd7;
    loc_64ab2:
    rax = [r14 methodSignatureForSelector:var_140];
    rbx = var_158;
    if (rax == 0x0) goto loc_64e3c;
    
    ......//省略无关代码
    
    loc_64c19:
    if (class_respondsToSelector(object_getClass(r14), @selector(forwardInvocation:)) == 0x0) goto loc_64ec2;
    ......
    if (class_respondsToSelector(object_getClass(var_138), @selector(doesNotRecognizeSelector:)) == 0x0) {
            ____forwarding___.cold.2(var_138);
    }
    (*_objc_msgSend)(var_138, @selector(doesNotRecognizeSelector:));
    asm { ud2 };
    rax = loc_64ec2(rdi, rsi);
    return rax;
    
    ......//省略无关代码
}

通过伪代码可以看到____forwarding___相关实现，依次进行了判断和调用forwardingTargetForSelector、methodSignatureForSelector、forwardInvocation和doesNotRecognizeSelector方法。

消息转发的流程图

扩展 - 动态方法决议会执行两遍分析

示例代码

@interface Person : NSObject
- (void)say666;
@end

@implementation Person

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    NSLog(@"%s - %@ 来了",__func__,NSStringFromSelector(sel));
    return [super resolveInstanceMethod:sel];
}
//调用代码
Person *person = [Person alloc];
[person say666];
@end

在动态方法解析中没有进行imp的指定，所以代码运行起来会闪退。但是在闪退之前resolveInstanceMethod方法中的会打印两遍log：

之前的文章方法调用（二）-- 慢速查找流程中对lookUpImpOrForward函数的分析，会在static void resolveInstanceMethod(id inst, SEL sel, Class cls)函数中调用+ (BOOL)resolveInstanceMethod:(SEL)sel方法

研究方法：在消息发送之后打上断点，并且在log打印出来后，使用lldb中的bt命令查看当前的调用堆栈，如下图：

第一次bt：就是imp的查找流程，通过lookUpImpOrForward触发的
第二次bt：是methodSignatureForSelector触发的，经过__methodDescriptionForSelector中的class_getInstanceMethod再次到lookUpImpOrForward函数。通过反汇编CoreFoundation可以看到，如图：

以上就是只实现+ (BOOL)resolveInstanceMethod:(SEL)sel方法，但是不进行imp指定的情况下，会被调用两次的原因。