Objective-C 的运行时以及 Swift 的动态性
栏目: Objective-C · 发布时间: 6年前
内容简介：Objective-C 的运行时以及 Swift 的动态性
自 Swift 推出以来，人们总是不断希望 Swift 能够「更加动态化」。但是「动态化 (dynamic)」又是什么意思呢？为什么 Objective-C 比 Swift 更加动态化呢？如果我们无法使用动态化的语言，那么该如何去构建以往那些依赖于动态性的东西呢？在本次 Mobilization 2016 大会上，Roy Marmelstein 详细阐述了这些问题。
今天我讲演的题目是「Objective-C 的运行时以及 Swift 的动态性」。这里我添加了一条「2016 年的观点」的限定性标注，因为我讲的很多内容都将在未来几年内发生改变。
让我们回到五个月前，大概是五月中旬吧，阳光明媚，春暖花开，著名的 Objective-C 和 iOS 开发者——Brent Simmons 发表了一系列博文。在这些博文当中，他记录了各种开发者们借助 Objective-C 的运行时机制而解决的问题。他试图证明的是，Swift 作为一门编程语言，竟然没有这些问题的原生解决方案。即便时至今日，Swift 仍然捆绑了 Objective-C 的运行时机制，就算未来 Swift 完全将 Objective-C 取而代之，我们仍然不知道该如何解决这些问题。
接下来，便是 Twitter 上的一场宏大的战役，人们开始站队。过去 20 年来一直在为 Mac 开发 Objective-C 应用的人们被视为保守派，而 Swift 开发人员则被视为改革派。一方代表了经验和灵活性，而另一方则代表了理想化和类型安全。网上充斥着各种各样针锋相对的推文和 Medium 文章，最终事态变得无法控制，甚至为此你都能够买相关 T-shirt 来声援自己的阵营。
因此，我觉得是时候应该来谈论一下这个敏感的话题了。今日，我们将一起来探索运行时函数，并且谈论一下所谓的「动态性」到底是什么意思。我们将看一下 Swift 如今所处的位置，探究其缺陷，并展望未来。这些内容可能会有些纷繁复杂，因此我保证最后会放上一只很酷的猫咪 GIF 图作为结束。是不是很值得期待呢？
在我们开始之前，需要强调一点，Objective-C 是一门基于运行时的编程语言，这意味着所有方法、变量、类之间的链接，都会推迟到应用实际运行的最后一刻才会建立。这将给开发人员极高的灵活性，因为我们可以修改这些链接。而不同的是，Swift 绝大多数时候是一门面向编译时的语言。因此在 Swift 当中，灵活性受到了限制，不过您会因此得到更多的安全性。
这就是本次辩论的核心内容。所以不用多说，让我们开始吧！
Objective-C 的运行时本质上是一个库。它负责了 “Objective” 这个部分，因此您所知、所爱的面向对象编程，都是在这里实现的。如果您想要访问里面的函数的话，只需要导入这个库即可：
#import <objc/runtime.h>
它主要由 C 和汇编编写而成，其实现了诸如类、对象、方法调度、协议等等这些东西。它是 完全开源的 ，并且开源了很长一段时间了。您可以将源码下载下来，查看一下面向对象的这些特性是如何实现的，从而更深、更好地掌握我们用于开发的这门语言。
运行时负责 Objective-C 中的面向对象编程这个部分。让我们从基本的构建模块开始。那么什么是对象呢？对象在 runtime.h
当中是这样定义的：
typedef struct objc_class *Class;
struct objc_object {
Class isa;
};
对象只与一个类建立引用关联，也就是这个 isa
的意思所在。这也就是 Objective-C 当中的所有对象都需要实现的。那么类又是什么呢？类的定义要稍微复杂一些。
struct objc_class {
Class isa;
Class super_class;
const char *name;
long version;
long info;
long instance_size;
struct objc_ivar_list *ivars;
struct objc_method_list **methodLists;
struct objc_cache *cache;
struct objc_protocol_list *protocols;
};
Get more development news like this
类当中同样有 isa
这个值。它与 super_class
这个值进行关联。除了 NSObject
这个类之外， super_class
的值永远不会为 nil
，因为 Objective-C 当中的其余类都是以某种方式继承自 NSObject
的。之后，我们还有 name
、 version
、 info
之类的值，不过这些并不是我们感兴趣的内容。
对于我们而言，更多的应该是关注变量列表 ( ivars
)、方法列表 ( methodLists
) 和这个协议列表 ( protocols
)。这些就是我们能在运行时修改和读取的。可以看到，对象其实本质上是一个非常简单的结构体，类同样也是。我们可以借助运行时函数，从而在运行时动态创建类。
我们为什么要这么做呢？因为这个函数被大量运用在库提供者制作的框架当中。如果您无法知道用户将会创建什么样的数据，那么您就需要在运行时进行类的创建了。Core Data 就使用了这个功能。此外，如果您愿意的话，它还可以用在 JSON 解析当中。
Class myClass = objc_allocateClassPair([NSObject class], "MyClass", 0); // 在这里添加变量、方法和协议 objc_registerClassPair(myClass); // 当类注册之后，变量列表将会被锁定 [[myClass alloc] init];
这就是我们要用的 Objective-C 运行时函数： allocateClassPair
。我们为其提供一个 isa
，在本例当中我们提供了 NSObject
，然后为其命名。第三个参数则是额外字节的定义，通常我们都直接赋值 0 即可。随后我们就可以添加变量、方法以及协议了，之后就注册这个 ClassPair
。注册之后，我们就无法修改变量列表了，不过其余的内容仍然可以修改。
结束~我们所创建的这个类和其余的 Objective-C 类毫无区别。
如果您想要扩展一个不是自己创建的类，想要向其中添加函数，有一个便捷的方法便是使用 Objective-C 的类别 (Category) 特性。Swift 的扩展与之非常相似。类别的一个问题便在于，它无法添加存储属性。您可以添加一个计算属性，但是存储属性是无法添加的。
运行时的另一个特性便是：我们 可以
借助 setAssociatedObject
和 getAssociatedObject
这两个函数，向既有的类当中添加存储属性。
@implementation NSObject (AssociatedObject)
@dynamic associatedObject;
- (void)setAssociatedObject:(id)object {
objc_setAssociatedObject(self,
@selector(associatedObject), object,
OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (id)associatedObject {
return objc_getAssociatedObject(self,
@selector(associatedObject));
}
对于不是自己创建的类而言，使用这个方法进行扩展无疑是非常好用的。
接下来我们要介绍的，便是判别这个类能执行何种操作。这就是所谓的「内省 (introspection)」机制。通常，我们所使用的往往是最基础的内省功能。
[myObject isMemberOfClass:NSObject.class]; [myObject respondsToSelector:@selector(doStuff:)]; // isa == class class_respondsToSelector(myObject.class, @selector(doStuff:));
首先是这个 isMemberOfClass
，这是 Foundation 当中的一部分，这里我们查看 myObject
是否是 NSObject
的子类。接下来是这个 respondsToSelector:
，当我们使用了一个带有可选方法的协议时，为了避免崩溃发生，可以借助这个函数来判断这个对象是否可以调用此可选方法。在运行时层面， isMemberOfClass
对比两者的 isa
是否相同。 respondsToSelector"
则封装了一个 Objective-C 运行时函数： respondsToSelector
，其接受 Selector 和类为参数。
如果您写过单元测试的话，您就会知道当我们在编写 XCTestCase
的时候，需要完成 setUp
和 tearDown
的设定，随后才能编写相关的 test
函数。当测试运行的时候，系统会自行遍历所有的测试函数，并自动运行。这个功能是借助 Objective-C 的运行时机制实现的。
unsigned int count;
Method *methods = class_copyMethodList(myObject.class,
&count);
//Ivar *list = class_copyIvarList(myObject.class,
&count);
for(unsigned i = 0; i < count; i++) {
SEL selector = method_getName(methods[i]);
NSString *selectorString =
NSStringFromSelector(selector);
if ([selectorString containsString:@"test"]) {
[myObject performSelector:selector];
}
}
free(methods);
我们可以复制方法列表，如果需要的话，还可以复制变量列表。可以获取方法名，然后将其转换为字符串，检查其是否包含有 “test”，如果有便可以运行。现在我们便搭建好了 XCTest
的最简单版本！
那么变量和方法是由什么组成的呢？
struct objc_ivar {
char *ivar_name;
char *ivar_type;
int ivar_offset;
}
struct objc_method {
SEL method_name;
char *method_types;
IMP method_imp;
}
变量的组成与我们实际在代码当中所定义差别不大。其中包含了变量类型和变量名称。偏移量 (offset) 则是内存管理方面的内容。
Objective-C 方法的名称则是通过 Selector 来表示的，这也就是我们在 performSelector
当中所匹配的内容。同样，方法还用编码字符串来表示其类型。之后便是方法的实现，它使用了一种特定的表示方式，对此我们不必去深究。
因此，方法是非常简单的，我们同样可以在运行时向对象当中添加方法。
Method doStuff = class_getInstanceMethod(self.class, @selector(doStuff)); IMP doStuffImplementation = method_getImplementation(doStuff); const char *types = method_getTypeEncoding(doStuff); //“v@:@" class_addMethod(myClass.class, @selector(doStuff:), doStuffImplementation, types);
实现这个功能，我们需要用到 class_addMethod
这个函数。它所需的参数全都是我们之前所说的，方法结构体当中的那三个值：Selector、方法实现和方法类型。具体的方法实现部分我们取了个巧，因为我们使用了既有的 doStuff
方法，因此能够很简单地获取其方法实现和方法类型，不过我们还可以用其他方法来完成。
当然，我们添加了方法目的就是要使用它们。我们可以使用 [self doStuff]
或者 [self performSelector:@selector(doStuff)]
来进行调用，实际上在运行时级别，它们都是借助 objc_msgSend
向对象发送了一个消息。
[self doStuff]; [self performSelector:@selector(doStuff)]; objc_msgSend(self, @selector(message));
但是如果调用方法所在的对象为 nil
的时候，我们就会得到一个异常，应用便会崩溃。但事实证明，在崩溃之前会预留几个步骤，从而允许我们对某个不存在的函数进行一些操作。
我们可以将方法转发 (forward) 给其余目标。当我们试图桥接两个不同的框架的时候，这个功能便非常有用。当我们调用某个未实现的方法时，这便是会发生的操作。
// 1
+(BOOL)resolveInstanceMethod:(SEL)sel{
// 添加实例方法并返回 YES 的一次机会，它随后会再次尝试发送消息
}
// 2
- (id)forwardingTargetForSelector:(SEL)aSelector{
// 返回可以处理 Selector 的对象
}
// 3
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
// 您需要实现它来创建 NSInvocation
}
- (void)forwardInvocation:(NSInvocation *)invocation {
// 在您所选择的目标上调用 Selector
[invocation invokeWithTarget:target];
}
当您调用了某个不存在的方法时，运行时首先会调用一个名为 resolveInstanceMethod
的类方法，如果所调用的方法是类方法的话，则为调用 resolveClassMethod
。这时候我们便有机会来添加方法了，步骤的话我们之前就已经展示过了。如果我们返回了 YES
，就意味着原始方法将会再次被调用。
如果您不想创建新方法的话，我们还有 forwardingTargetForSelector
。您可以直接返回需要调用方法的目标对象即可，之后这个对象就会调用 Selector。
此外还有一个略为复杂的 forwardInvocation
。所有的调用过程都被封装到 NSInvocation
对象当中，之后您便可以使用特定的对象进行调用了。如果您需要这么做，那么还需要实现 methodSignatureForSelector
。
因此，我们便可以将方法转发给其他对象，但是您也可以替换或者交换方法的实现。您可以使用运行时当中最著名的动态特性：方法混淆 (swizzling)。混淆的基本方法如下所示：
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalSelector = @selector(doSomething);
SEL swizzledSelector = @selector(mo_doSomething);
Method originalMethod = class_getInstanceMethod(class,
originalSelector);
Method swizzledMethod = class_getInstanceMethod(class,
swizzledSelector);
BOOL didAddMethod = class_addMethod(class, originalSelector,
method_getImplementation(swizzledMethod),
method_getTypeEncoding(swizzledMethod));
if (didAddMethod) {
class_replaceMethod(class,
swizzledSelector,
method_getImplementation(originalMethod),
method_getTypeEncoding(originalMethod));
} else {
method_exchangeImplementations(originalMethod, swizzledMethod);
}
});
}
当类加载之后，会调用一个名为 load
的类函数。由于我们只打算混淆一次，因此我们需要使用 dispatch_once
。接着我们便可以得到该方法，然后使用 class_replaceMethod
或者 method_exchangeImplementations
来替换方法。之所以想要混淆，是因为它可以用于日志记录和 Mock 测试。
从运行时的层面，我们往上一层，便来到了 Foundation 框架。Foundation 框架实现了基于运行时的一个特性： 键值编码 (key-value-coding, KVC) 以及 键值观察 (key-value observing, KVO)。KVC 和 KVO 允许我们将 UI 和数据进行绑定。这也是 Rx 以及其他响应式框架实现的基础，这个基本的功能是内含在 Foundation 当中的。KVC 的工作方式如下所示：
@property (nonatomic, strong) NSNumber *number; [myClass valueForKey:@"number"]; [myClass setValue:@(4) forKey:@"number"];
例如，假设我们有这个 number
属性，您可以将属性名称作为键，来获取属性值或者设置属性值。这个功能可以用在此前我们所看到的获取变量列表、协议列表，以及危险的混淆功能当中。
接下来是 KVO，您可以对状态的变化进行注册。
[myClass addObserver:self
forKeyPath:@"number"
options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
context:nil];
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary<NSKeyValueChangeKey,id> *)change
context:(void *)context{
// Respond to observation.
}
在观察的值发生变更之后，KVO 会调用此方法立即通知观察者。通过这个方法，我们便可以按需更新 UI。
我们通常所说的 Objective-C 「动态性」，往往都是指 KVO。虽然还有其余的函数，但是这些是最常见、最常用的。这也就是人们所说的，Swift 缺失的部分。
话说回来，所有的这些操作都存有隐患。比方说 KVO，特别是当我们对某个不是自己所创建的类进行观察时，往往会发现有出乎意料的变化发生。通常而言，这些问题是非常难以调试的，也很难去理解为什么出错。在实际产品当中，我并不建议使用它们，尽管它们非常好用。但是在实际产品当中，我会很谨慎地去使用这些功能。
Apple 也是如此认为的，因此它们在视图控制器当中添加了这个私有方法，可以使用 class-dump 来查看。
+ (void) attentionClassDumpUser:
yesItsUsAgain:
althoughSwizzlingAndOverridingPrivateMethodsIsFun:
itWasntMuchFunWhenYourAppStoppedWorking:
pleaseRefrainFromDoingSoInTheFutureOkayThanksBye:
的确，很让人抓狂。
现在让我们来谈谈 Swift 吧。Swift 是一种强类型语言。类型静态，也就是说 Swift 的默认类型是非常安全的。如果需要的话，不安全类型也是存在的，但是 Swift 仍然是尽力推动我们使用安全的静态类型。Swift 中的动态性可以通过 Objective-C 运行时来获得。
本来这是很好的，但是 Swift 开源并迁移到 Linux 之后，由于 Linux 上的 Swift 并不提供 Objective-C 运行时，事情就大条了。社区的关键点在于，让 Swift 未来能够自己配备动态性，而不是依赖于 Apple。
也就是说，Swift 当中存在有这两个修饰符 @objc
和 @dynamic
，此外我们同样还可以访问 NSObject
。 @objc
将您的 Swift API 暴露给 Objective-C 运行时，但是它仍然不能保证编译器会尝试对其进行优化。如果您真的想使用动态功能的话，就需要使用 @dynamic
。一旦您使用了 @dynamic
修饰符之后，就不需要添加 @objc
了，因为它已经隐含在其中。
回到我们的动态特性当中，让我们来看一看 Swift 当中这些动态特性是什么样的。假设我们需要使用内省机制、转发方法、替换和绑定方法。方法的转发实际上变化不大：
// 1
override class func resolveInstanceMethod(_ sel: Selector!)
-> Bool {
// 添加实例方法并返回 true 的一次机会，它随后会再次尝试发送消息
}
// 2
override func forwardingTarget(for aSelector: Selector!) ->
Any? {
// 返回可以处理 Selector 的对象
}
// 3 - Swift 不支持 NSInvocation
resolveInstanceMethod
同样会被调用， forwardingTarget
看起来似乎更贴近于 Swift 3 风格的 API。但是 NSInvocation
并不能在 Swift 当中使用。我们同样可以实现方法转发，因此看起来也不算太坏。
方法混淆变得有些困难。 load
在 Swift 不再会被调用，因此我们需要在 initialize
中进行混淆。在 Objective-C 当中，我们使用 dispatch_once
，但是自 Swift 3 之后， dispatch_once
便不复存在于 Swift 当中了。事情变得略为复杂。虽然对于特定类型的函数而言，我们仍然可以将其定义为动态函数，但是它会消除大部分混淆的功能。
对于内省而言，我们有了一些新的东西。
if self is MyClass {
// YAY
}
let myString = "myString";
let mirror = Mirror(reflecting: myString)
print(mirror.subjectType) // “String"
let string = String(reflecting: type(of:
myString)) // Swift.String
// No native method introspection
is
替代了 isMemberOfClass
，它同样也可以对 Swift 值类型使用。我们可以对结构体、枚举以及其他 Swift 当中的新类型使用 is
。此外还有一个新的映射 API，它主要针对于管道 (pipe) 和数据。
目前，我们没有原生的办法来实现内省。这也预示着这个功能未来可能会出现，但是目前我们还无法实现。这很令人沮丧，特别是当您想到我们此前所实现的 XCTestCase
。如果您打算为 Linux 编写单元测试的时候，就无法自动遍历所有的函数。您必须实现 static var allTests
，然后手动列出所有的测试函数。这很糟糕。
那么 KVO 和 KVC 呢？KVO 的魅力在于，您可以在不是自己所创建的类当中使用它，也可以只对您想要监听变化的类使用。KVO 和 KVC 在 Swift 被极大地削弱了。您所观察的对象必须要继承自 NSObject
，并且使用一个 Objective-C 类型。您所观察的变量必须要生命为 dynamic
。您必须要对想要观察的事务了如指掌。
问题是 Swift 并没有很好的替代方案。您可以使用 Rx 或者基于协议来观察对象。但是语言自身是没有原生的解决方案的。
Swift 是一个让人兴奋的语言，此外也有一个好消息。最近，在 Swift 邮件列表 中，Chris Lattner 认为为 Swift 添加动态功能是非常重要的。他还说，即便人们不同意「动态性」的功能是什么，我们的关键在于要找一个原生的、流畅的、符合 Swift 风格的方法来解决这些问题。
如今我们所知道的是，更丰富的动态性被安排在了 Swift 4 的第二阶段。我们目前正处于 Swift 4 的第一阶段，他们的重点是保证 API 的稳定性。他们会在 iOS 11 之前尽量完成，这是核心团队的重点之一，他们可能会首先考虑引入内省开始。
还有一件事，也就是我所启动的一个开源项目。目前我正在开发一个名为 ObjectiveKit 的开源库。我的想法是用一些符合 Swift 风格的方法来暴露一些运行时函数，我觉得这将是一件很有趣的事。
总而言之，Objective-C 的动态性无疑是非常强大的、极其有用，虽然也存在危险性。Swift 目前没有足够的替代方案来解决这些问题，但是可以预见在不久的将来 Swift 的动态性将会出现，这是值得我们期待的。我一开始所承诺的 猫咪 GIF 图 在这里，我觉得以它作为结尾是很好的想法。感谢大家！
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持 码农网
猜你喜欢:
- 运行过程+运行效率
- dotnet 判断程序当前使用管理员运行降低权使用普通权限运行
- Flink 集群运行原理兼部署及Yarn运行模式深入剖析-Flink牛刀小试
- MapReduce运行流程分析
- 浅析Docker运行安全
- JavaScript运行原理分析
本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。
