MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Objective-C消息传递机制与动态绑定原理

2022-03-211.7k 阅读

消息传递基础概念

在Objective-C编程中，消息传递是其核心机制之一。简单来说，当你向一个对象发送一条消息时，实际上是在请求该对象执行某个特定的方法。例如，在下面的代码片段中：

#import <Foundation/Foundation.h>

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

@implementation Person
- (void)sayHello {
    NSLog(@"Hello!");
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person = [[Person alloc] init];
        [person sayHello];
    }
    return 0;
}

在[person sayHello]这一行代码中，我们向person对象发送了sayHello消息。从表面上看，这类似于函数调用，但在底层实现上却有着很大的差异。

消息结构

在Objective-C中，消息是以SEL（选择器）来标识的。SEL本质上是一个指向方法名字符串的指针。当编译器遇到[person sayHello]这样的消息发送表达式时，它会将sayHello这个方法名转换为对应的SEL。我们可以通过@selector()指令来获取一个方法的SEL，如下所示：

SEL sayHelloSelector = @selector(sayHello);

SEL之所以使用指针的形式，是为了在运行时能够高效地查找和匹配方法。因为在运行时，通过指针比较来查找对应的方法实现会比字符串比较要快得多。

方法查找流程

当向一个对象发送消息时，Objective-C运行时系统会开始查找该消息对应的方法实现。这个查找过程首先从接收者对象所属的类的方法列表开始。例如，对于上面的Person类，运行时会在Person类的方法列表中查找sayHello方法的实现。

如果在当前类的方法列表中没有找到对应的方法，运行时会沿着继承体系向上查找，即查找其父类的方法列表。这个过程会一直持续，直到在某个类的方法列表中找到对应的方法，或者到达NSObject类仍然没有找到。如果到达NSObject类都没有找到对应的方法实现，就会进入动态方法解析阶段。

动态方法解析

动态方法解析机制

当运行时系统在方法列表中没有找到消息对应的方法实现时，首先会进入动态方法解析阶段。在这个阶段，运行时会给类一次机会，让其动态地添加方法实现。在Objective-C中，类可以通过实现+ (BOOL)resolveInstanceMethod:(SEL)sel（针对实例方法）或+ (BOOL)resolveClassMethod:(SEL)sel（针对类方法）方法来参与动态方法解析。

例如，我们可以对上面的Person类进行扩展，添加动态方法解析的相关代码：

#import <objc/runtime.h>

void dynamicSayHello(id self, SEL _cmd) {
    NSLog(@"Dynamic Hello!");
}

@implementation Person
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(sayHello)) {
        class_addMethod(self, sel, (IMP)dynamicSayHello, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}
@end

在上述代码中，我们定义了一个函数dynamicSayHello，它将作为sayHello方法的动态实现。在+ (BOOL)resolveInstanceMethod:(SEL)sel方法中，当检测到sel为@selector(sayHello)时，我们通过class_addMethod函数将dynamicSayHello函数添加为sayHello方法的实现。class_addMethod函数的参数依次为类对象、选择器、方法实现指针以及方法的类型编码。这里的类型编码"v@:"表示该方法返回值为void，第一个参数为id类型（即接收者对象），第二个参数为SEL类型（即方法选择器）。

方法签名与备用接收者

如果在动态方法解析阶段没有成功添加方法实现，运行时系统会进入备用接收者阶段。在这个阶段，运行时会调用对象的- (id)forwardingTargetForSelector:(SEL)aSelector方法，询问对象是否有其他对象可以作为该消息的备用接收者。

我们可以在Person类中添加如下实现：

@implementation Person
- (id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(sayHello)) {
        AnotherClass *anotherObject = [[AnotherClass alloc] init];
        return anotherObject;
    }
    return nil;
}
@end

在上述代码中，如果接收到的消息是sayHello，我们返回一个AnotherClass类的实例作为备用接收者。这样，运行时系统会尝试向这个备用接收者发送相同的消息，查找对应的方法实现。

完整的消息转发流程

如果在备用接收者阶段也没有找到合适的对象来处理消息，运行时系统会进入完整的消息转发流程。首先，运行时会调用- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector方法，该方法需要返回一个NSMethodSignature对象，用于描述即将转发的方法的参数和返回值类型。

例如：

@implementation Person
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (aSelector == @selector(sayHello)) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
    return [super methodSignatureForSelector:aSelector];
}
@end

这里我们针对sayHello方法返回了一个合适的方法签名。如果这个方法返回nil，运行时会发出unrecognized selector的错误。

接着，运行时会调用- (void)forwardInvocation:(NSInvocation *)anInvocation方法，在这个方法中，我们可以手动构建对其他对象的消息发送，以完成消息的转发。例如：

@implementation Person
- (void)forwardInvocation:(NSInvocation *)anInvocation {
    AnotherClass *anotherObject = [[AnotherClass alloc] init];
    if ([anotherObject respondsToSelector:anInvocation.selector]) {
        [anInvocation invokeWithTarget:anotherObject];
    }
}
@end

在上述代码中，我们创建了一个AnotherClass的实例，并检查该实例是否响应即将转发的消息。如果响应，我们通过[anInvocation invokeWithTarget:anotherObject]将消息转发给这个实例。

动态绑定原理深度剖析

动态绑定与静态类型语言的区别

在静态类型语言（如C++）中，函数调用在编译时就确定了具体要调用的函数实现。编译器会根据对象的静态类型来确定调用哪个函数版本。而在Objective-C中，消息传递和动态绑定使得方法的调用在运行时才确定。这意味着，同一个消息发送表达式，在不同的运行时状态下，可能会调用不同的方法实现。

例如，考虑下面的代码：

@interface Animal : NSObject
- (void)makeSound;
@end

@implementation Animal
- (void)makeSound {
    NSLog(@"Generic sound");
}
@end

@interface Dog : Animal
- (void)makeSound {
    NSLog(@"Woof!");
}
@end

@interface Cat : Animal
- (void)makeSound {
    NSLog(@"Meow!");
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Animal *animal1 = [[Dog alloc] init];
        Animal *animal2 = [[Cat alloc] init];
        [animal1 makeSound];
        [animal2 makeSound];
    }
    return 0;
}

在上述代码中，animal1和animal2的静态类型都是Animal，但由于动态绑定机制，[animal1 makeSound]会调用Dog类中的makeSound方法，而[animal2 makeSound]会调用Cat类中的makeSound方法。这体现了Objective-C动态绑定的灵活性。

动态绑定的实现基础

动态绑定之所以能够实现，依赖于Objective-C运行时系统对类、对象以及方法列表的管理。每个对象在内存中都包含一个指向其所属类的指针。类对象中除了包含元数据（如类名、继承关系等），还维护着一个方法列表。

当消息发送时，运行时系统首先根据对象的类指针找到对应的类对象，然后在类对象的方法列表中查找方法实现。由于对象的实际类型（通过isa指针确定）在运行时才完全确定，所以可以根据对象的实际类型来调用合适的方法实现，从而实现动态绑定。

动态绑定与多态

动态绑定是实现多态的关键机制。在Objective-C中，多态允许我们以统一的方式处理不同类型的对象，只要这些对象都响应相同的消息。例如，在上述的Animal、Dog和Cat的例子中，我们可以将Dog和Cat对象都当作Animal对象来处理，通过向它们发送makeSound消息，根据对象的实际类型来调用不同的实现，实现了多态性。

NSArray *animals = @[ [Dog alloc] init, [Cat alloc] init ];
for (Animal *animal in animals) {
    [animal makeSound];
}

在上述代码中，通过遍历animals数组，向每个Animal类型的对象发送makeSound消息，实际调用的是Dog或Cat类中各自的makeSound方法，展示了多态的效果。

动态绑定的优势与应用场景

优势

  1. 灵活性：动态绑定使得程序在运行时能够根据对象的实际类型来决定调用哪个方法实现，这为程序的设计带来了极大的灵活性。例如，在插件式架构中，可以在运行时动态加载不同的插件类，这些插件类都响应相同的接口消息，但实现各不相同。
  2. 可扩展性：由于方法的实现可以在运行时动态确定，这使得代码更容易扩展。比如，在开发一个大型的软件系统时，后期可能需要为某个类添加新的功能，通过动态方法解析和消息转发机制，可以在不修改原有代码结构的基础上实现功能扩展。

应用场景

  1. 框架设计：在iOS开发的许多框架中，如UIKit框架，广泛使用了动态绑定机制。例如，UITableView的数据源和代理模式，通过向不同的对象发送特定的消息，实现了高度可定制的表格视图功能。不同的视图控制器可以作为UITableView的数据源和代理，根据自身的需求实现不同的方法，以提供数据和处理用户交互。
  2. 单元测试：动态绑定使得在单元测试中可以方便地使用模拟对象。通过创建模拟对象并使其响应与真实对象相同的消息，测试代码可以控制模拟对象的行为，从而更准确地测试目标代码在不同情况下的表现。

消息传递和动态绑定的性能考量

虽然消息传递和动态绑定机制为Objective-C带来了强大的功能和灵活性，但它们也带来了一定的性能开销。与静态类型语言的函数调用相比，Objective-C的消息传递需要在运行时进行方法查找、动态方法解析以及可能的消息转发等操作，这些操作都需要消耗一定的时间和资源。

为了优化性能，在实际编程中可以采取一些措施。例如，尽量避免频繁的动态方法解析和消息转发，因为这些操作涉及到运行时系统的复杂处理。对于性能敏感的代码部分，可以考虑使用内联函数或基于C语言的优化技巧。同时，由于SEL的查找是基于哈希表的，合理设计方法名可以提高方法查找的效率，减少哈希冲突。

在对象继承层次较深的情况下，方法查找的时间可能会增加，因为运行时需要沿着继承体系向上遍历多个类的方法列表。因此，在设计类的继承结构时，应尽量保持层次结构的简洁，避免过深的继承层次。

与其他编程语言机制的对比

  1. 与C++虚函数的对比：C++的虚函数也实现了类似的多态性，但它是在编译时通过虚函数表来确定调用的函数实现。而Objective-C的消息传递和动态绑定是在运行时进行方法查找和确定实现，更加灵活，但也带来了额外的运行时开销。
  2. 与Java方法调用的对比：Java的方法调用分为静态绑定和动态绑定。对于非虚方法，在编译时进行静态绑定；对于虚方法，在运行时根据对象的实际类型进行动态绑定。Objective-C的动态绑定机制与之类似，但Objective-C的动态方法解析和消息转发机制更加灵活，提供了更多在运行时处理未识别消息的方式。

总结消息传递与动态绑定在Objective-C中的地位

消息传递和动态绑定机制是Objective-C语言的核心特性，它们为Objective-C带来了高度的灵活性、可扩展性和多态性。通过理解这些机制的原理和实现细节，开发者能够更好地编写高效、可维护的Objective-C代码，充分发挥该语言在iOS和macOS开发中的优势。同时，深入了解这些机制也有助于开发者在面对复杂的编程问题时，能够运用消息传递和动态绑定的特性找到创新性的解决方案。在实际开发中，合理运用这些机制，结合性能优化策略，能够开发出既功能强大又高效运行的应用程序。无论是开发小型的工具类应用，还是大型的企业级应用，消息传递和动态绑定机制都在其中发挥着至关重要的作用。