OC 中的消息发送和消息转发

OC 中的动态绑定和消息转发

动态绑定

我们都知道OC是动态语言，表现为对象方法的调用实际上是对对象发送消息，编译时不确定这个对象执行什么方法，而在运行时由消息（方法选择器selector决定对象执行什么方法），这种消息发送的方式叫做动态绑定。通过编译我们知道，发送消息的底层API是objc_msgSend这个c函数，其工作流程大概是这样的（为了方便参考，这里也给出了相关数据结构的源码）：

// 类的数据结构
struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;
    
#if !__OBJC2__
    Class super_class                                        OBJC2_UNAVAILABLE;
    const char *name                                         OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;
    struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache *cache                                 OBJC2_UNAVAILABLE;
    struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;
#endif
    
} OBJC2_UNAVAILABLE;

//  方法的定义
typedef struct objc_method *Method;
struct objc_method {
    SEL method_name                                          OBJC2_UNAVAILABLE;
    char *method_types                                       OBJC2_UNAVAILABLE;
    IMP method_imp                                           OBJC2_UNAVAILABLE;
}

1. 获取传入对象所属的类。
2. 使用传入的selector在缓存cache列表中查询。
3. 如果找到了方法，则通过Method中的IMP（方法实现的地址）去调用方法。
4. 如果缓存中不存在，则开始在methodLists列表中查找。
5. 如果methodLists列表找不到，利用super_class指针去父类查找，
6. 递归地查找父类，一直查找到NSObject，如果还是找不到，则触发消息转发机制。

消息转发

简单的说，就是当对象通过selector找不到方法的时候，还有三次机会通过其他方式调用方法，避免程序崩溃（unrecognized selector），这三次机会分别是：

1. 动态方法解析：看消息接受者是否能动态添加方法
2. 备援的接收者：先看其他有没有对象能处理这条消息
3. 消息重定向：将所有信息封装到 NSInvocation 对象中处理

动态方法解析，其实就是调用对象类中的以下方法：

+ (BOOL)resolveInstanceMethod:(SEL)selector;  //当遇到无法解读的实例方法时调用这个方法
+ (BOOL)resolveClassMethod:(SEL)selector;     //当遇到无法解读的类方法时调用这个方法

例子：

@interface Person : NSObject
@end
  
@implementation Person

- (void) implementAppendString:(NSString *)aString {
    NSLog(@"%@", aString);
}

+ (BOOL) resolveInstanceMethod:(SEL)selName {
    
    if (selName == @selector(speak:)) {
        class_addMethod([self class], selName, class_getMethodImplementation([self class], @selector((implementSpeak:))), "v@:");
        return YES;
    }

    return [super resolveInstanceMethod:selName];
}

@end
 
int main(int argc, const char *argv[])
{
    @autoreleasepool {
        id person = [[Person alloc] init];
        [person performSelector: @selector(speak:) withObject:@"hello"];
    }
    return 0;
}

备援的接收者，当动态方法解析失败时（返回NO），可以通过以下方法询问在其他对象中可否处理消息，如果找到接收者，则返回接收者的对象，否则返回nil：

- (id)forwardingTargetForSelector:(SEL)aSelector;

例子：

@interface Person : NSObject
@end

@interface Father : NSObject
- (void)speak:(NSString *)aString;
@end


@implementation Person
- (id)forwardingTargetForSelector:(SEL)aSelector {
    return [[Father alloc] init];
}

@end

@implementation Father
- (void)speak:(NSString *)aString {
    NSLog(@"%@", aString);
}
@end
  
int main(int argc, const char *argv[])
{
    @autoreleasepool {
        id person = [[Person alloc] init];
        [person performSelector: @selector(speak:) withObject:@"hello"];  // hello
    }
    return 0;
}

消息重定向，当没有备援接收者时，就只剩下最后一次机会，那就是消息重定向。这个时候runtime会将未知消息的所有细节都封装为NSInvocation对象，然后先后调用下述方法:

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector;
- (void)forwardInvocation: (NSInvocation*)invocation;

例子：

@interface Person : NSObject
@end
  
@implementation Person

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

- (void)forwardInvocation:(NSInvocation *)invocation {
    if (invocation.selector == @selector(speak)) {
        NSLog(@"%s", __func__); 
    }
}

@end
  
int main(int argc, const char *argv[])
{
    @autoreleasepool {
        id person = [[Person alloc] init];
        [person performSelector: @selector(speak)]; // -[Person forwardInvocation:]
    }
    return 0;
}