Runtime

作者: 大地瓜123 | 来源:发表于2018-01-22 16:48 被阅读0次

本文为大地瓜原创，欢迎知识共享，转载请注明出处。
虽然你不注明出处我也没什么精力和你计较。
作者微信号：christgreenlaw

方法（method）

Objective-C是C的扩展，在C的语言层面上加了一定的关键字和语法，其核心就是运行时、消息分发。
对于很多语言，编译器会执行优化和错误检查，因为调用关系很清楚。但是对于消息分发来说，事情就没那么简单了。发消息之前，你不用保证这个对象能够处理这个消息，发给这个对象消息后，对象可能会处理消息，也可能转发给其他的对象进行处理。消息和方法并不是一一对应关系，一个对象可以只用一个方法来处理多个消息。

在OC中，消息是通过objc_msgSend()这个runtime方法以及其他类似方法进行实现的。该方法需要target, selector以及一些必须的参数。理论上来说，编译器只是对发送消息进行了转化，将发送的消息变成objc_msgSend()来执行了。
可以大致理解成如下的代码：

[object doSomething: abc withNumber: 10];//转化为下面的这行
objc_msgSend(object, @selector(doSomething:withNumber), abc, 10];

对象、类、元类（object, class, metaclass）

在OC中，类也是对象。

什么意思呢？
一般在面向对象语言中，类和对象的概念是区分开来的，对象是所属类的实例。但OC中，类本身也是对象，也可以处理消息（所谓的类方法），也就是类方法和实例方法的区别。

如果我们纠结于源代码的话，可以看到OC中的对象其实本质是一个C语言结构体(struct)，其中有一个结构体成员是isa，类型是Class，指向自己的class。

NSObject的interface如下：

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

+ (void)load;

+ (void)initialize;
- (instancetype)init
#if NS_ENFORCE_NSOBJECT_DESIGNATED_INITIALIZER
    NS_DESIGNATED_INITIALIZER
#endif
    ;

+ (instancetype)new OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
+ (instancetype)allocWithZone:(struct _NSZone *)zone OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
+ (instancetype)alloc OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
- (void)dealloc OBJC_SWIFT_UNAVAILABLE("use 'deinit' to define a de-initializer");

- (void)finalize OBJC_DEPRECATED("Objective-C garbage collection is no longer supported");

- (id)copy;
- (id)mutableCopy;

+ (id)copyWithZone:(struct _NSZone *)zone OBJC_ARC_UNAVAILABLE;
+ (id)mutableCopyWithZone:(struct _NSZone *)zone OBJC_ARC_UNAVAILABLE;

+ (BOOL)instancesRespondToSelector:(SEL)aSelector;
+ (BOOL)conformsToProtocol:(Protocol *)protocol;
- (IMP)methodForSelector:(SEL)aSelector;
+ (IMP)instanceMethodForSelector:(SEL)aSelector;
- (void)doesNotRecognizeSelector:(SEL)aSelector;

- (id)forwardingTargetForSelector:(SEL)aSelector OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
- (void)forwardInvocation:(NSInvocation *)anInvocation OBJC_SWIFT_UNAVAILABLE("");
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector OBJC_SWIFT_UNAVAILABLE("");

+ (NSMethodSignature *)instanceMethodSignatureForSelector:(SEL)aSelector OBJC_SWIFT_UNAVAILABLE("");

- (BOOL)allowsWeakReference UNAVAILABLE_ATTRIBUTE;
- (BOOL)retainWeakReference UNAVAILABLE_ATTRIBUTE;

+ (BOOL)isSubclassOfClass:(Class)aClass;

+ (BOOL)resolveClassMethod:(SEL)sel OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
+ (BOOL)resolveInstanceMethod:(SEL)sel OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

+ (NSUInteger)hash;
+ (Class)superclass;
+ (Class)class OBJC_SWIFT_UNAVAILABLE("use 'aClass.self' instead");
+ (NSString *)description;
+ (NSString *)debugDescription;

@end

其中Class的定义是：

#if !OBJC_TYPES_DEFINED
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;

/// Represents an instance of a class.
struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

/// A pointer to an instance of a class.
typedef struct objc_object *id;
#endif

我们看到：

Class是一个结构体struct objc_class的指针，代表一个Objective-C类
结构体struct objc_object代表一个类的实例，而这个结构体内部又有Class属性，其实这个Class属性正是指向了该对象所属的类
id其实是struct objc_object的指针，这也解释了id为什么是任何对象的指针了

现在知道了，Class是一个结构体struct objc_class的指针，代表一个Objective-C类。那么objc_class的结构是怎样的呢？
如下：

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;
/* Use `Class` instead of `struct objc_class *` */

由于有typedef，Class和struct objc_class *其实是一回事，源代码中的注释也提示我们，使用Class而不要使用struct objc_class * 。

Class中保存了方法列表(methodLists)以及指向父类的指针(Class _Nullable super_class)。Class也是对象，也有isa变量，它指向哪里？？？
答案是metaclass。

此处引用一篇文章：[objc explain]: Classes and metaclasses
其中解释了类和元类等概念。这里是大地瓜的翻译。

方法、选择器、IMP（methods, selectors, IMPs）

我们已经知道了，运行时给对象发消息，对象的class保存了方法列表，那消息和方法的映射关系是怎样的？方法又是怎么执行的？

映射关系是怎样的？
class的方法列表其实是一个字典，是selectors和IMPs的键值对。IMP就是一个方法在内存中的实现。但这个映射关系是在运行时决定的，而不是编译时决定的，所以我们可以做出很多操作。
IMP一般是指向方法的指针，第一个参数是self，类型是id，第二个参数是cmd，类型为SEL，剩下的是方法的参数。

- (id)doSomethingWithInt:(int)aInt;//method
id doSomethingWithInt(id self, SEL _cmd, int aInt);//IMP

所以说运行时到底能干点什么呢？？？

创建、修改、自省class和object

class

方法如class_addIvar,class_addMethod, class_addProperty和class_addProtocol允许重建classes。
class_copyIvarList, class_copyMethodList, class_copyProtocolList和class_copyPropertyList能拿到一个class的所有内容。
而class_getClassMethod, class_getClassVariable, class_getInstanceMethod, class_getInstanceVariable, class_getMethodImplementation和class_getProperty返回单个内容。
也有一些通用的自省方法，如class_conformsToProtocol, class_respondsToSelector, class_getSuperclass。
最后，你可以使用class_createInstance来创建一个object。

ivar

这些方法能让你得到名字，内存地址和Objective-C type encoding。

method

这些方法主要用来自省，比如method_getName, method_getImplementation, method_getReturnType等等。也有一些修改的方法，包括method_setImplementation和method_exchangeImplementations。

objc

一旦拿到了object，你就可以对它做一些自省和修改。你可以get/set ivar, 使用object_copy和object_dispose来copy和free object的内存。最NB的不仅是拿到一个class，而是可以使用object_setClass来改变一个object的class。

property

属性保存了很大一部分信息。除了拿到名字，你还可以使用property_getAttributes来发现property的更多信息，如返回值、是否为atomic、getter/setter名字、是否为dynamic、背后使用的ivar名字、是否为弱引用。

protocol

Protocols有点像classes，但是精简版的，运行时的方法是一样的。你可以获取method, property, protocol列表, 检查是否实现了其他的protocol。

sel

最后我们有一些方法可以处理 selectors，比如获取名字，注册一个selector等等。

NSClassFromString/NSSelectorFromString

Class stringclass = NSClassFromString(@"NSString");
//于是我们就得到了一个string class。接下来：
NSString *myString = [stringclass stringWithString:@"Hello World"];

为什么不直接使用NSString???
有些情况下，不知道是否存在某个类。需要先判断某个类是否存在。

Class stringclass = NSClassFromString(@"NSString");
if (stringclass != nil) {
  NSString *str = [stringclass stringWithString:@"hello"];
  NSLog(@"%@", str);
}

另一个情景，就是根据不同的输入使用不同的class或method。比如解析数据，每个数据项都有不同的数据类型：

- (void)parseObject:(id)object {
    for (id data in object) {
        if ([data isKindOfClass:[NSString class]]) {
            NSLog(@"NSString = %@",data);
        } else if ([data isKindOfClass:[NSNumber class]]) {
            NSLog(@"NSNumber = %@",data);
        } else if ([data isKindOfClass:[NSDictionary class]]) {
            NSLog(@"NSDictionary = %@",data);
        }
    }
}
//runtime写法
- (void)parseObjectDynamic:(id)object { 
    for (id data in object) {
        Class dataClass = [data class];
        NSLog(@"%@ = %@", dataClass,data);
    }
}
//这里打印出来的dataClass可能并不是常见的类型，而是
2018-01-18 19:44:50.320272+0800 fuck[4975:4579429] __NSCFConstantString = 123
2018-01-18 19:44:50.320302+0800 fuck[4975:4579429] __NSCFNumber = 1
2018-01-18 19:44:50.320343+0800 fuck[4975:4579429] __NSSingleEntryDictionaryI = {
    key = value;
}
//不用担心，如果你把__NSCFConstantString和NSString进行比较的话，其实是同一个类型。

方法欺骗（Method Swizzling）

方法由两个部分组成：Selector和IMP。selector是方法的标识符（id），IMP是方法的实现，二者构成一个映射关系。这样的映射关系，一个好处就是可以进行修改。也就是selector与IMP的映射关系并不是写死的，多个selector可以指向同一个IMP。方法欺骗（method swizzling）可以进行两个方法的交换。

所以我们为什么要交换方法呢？？
首先，OC中的class有两种扩展方式，一个是继承，此时可以重写方法，也可以调用父类的实现。但是，如果你在subclass后重写了方法，你就再也无法使用子类调用原来的父类实现了。另一种方式是使用分类（category），但是即使你使用扩展，如果你扩展中重复命名了一个方法，你也只能使用重写后的方法了，原来的方法会在编译期被覆盖掉。

method swizzling就可以解决这个问题。你可以重写某个方法，而且你不用继承，还可以使用原来的实现。
这个做法就是在category中添加一个方法。通过method_exchangeImplementations这个运行时方法来交换实现。

#import "objc/runtime.h"
#import "NSString+myString.h"

@implementation NSString (myString)

+ (void)load {
    Method description = class_getInstanceMethod(self, @selector(description));
    Method myDescription = class_getInstanceMethod(self, @selector(myDescription));
    method_exchangeImplementations(description, myDescription);
}

- (NSString *)myDescription {
    return @"myDescription";
}

@end

#import <Foundation/Foundation.h>
#import "NSString+myString.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *str = @"1";
        NSLog(@"%@", [str description]);
        NSLog(@"%@", [str myDescription]);
    }
    return 0;
}
2018-01-20 12:08:10.409142+0800 fuck[6619:5768134] exchange in load
2018-01-20 12:08:10.409635+0800 fuck[6619:5768134] myDescription
2018-01-20 12:08:10.409678+0800 fuck[6619:5768134] 1

上述代码只是单纯的交换了方法的实现。
那么如何在不覆盖原来的方法的情况下，重写一个方法，还能调用原来的方法呢？

#import  <objc/runtime.h>

@interface NSMutableArray (LoggingAddObject)
- (void)logAddObject:(id)aObject;
@end

@implementation NSMutableArray (LoggingAddObject)

+ (void)load {
    Method addobject = class_getInstanceMethod(self, @selector(addObject:));
    Method logAddobject = class_getInstanceMethod(self, @selector(logAddObject:));
    method_exchangeImplementations(addObject, logAddObject);
}

- (void)logAddObject:(id)aobject {
    [self logAddObject:aObject];
    NSLog(@"Added object %@ to array %@", aObject, self);
}

@end

上述代码好像包含一个递归，但是，由于我们交换了实现，所以调用addObject时会跳转到logAddingObject中，然后代码中所包含的递归其实指向了addObject。所以，这样写的最终效果就是，先执行了addObject然后执行我们自定义的部分，在上述例子中，也就是打印出了一行log。
这个地方并不希望你直接调用logAddObject，而只是希望你在调用原来的addObject时有多出来的自定义实现。

另一篇国外文章，关于Method Swizzling。
这是大地瓜对于此文章的翻译。

动态继承、交换

运行时可以动态创建class，可以动态创建子类，添加新的方法。
object_setClass(myObject, [MySubclass class]);
内部是修改了isa指针，以更改其类型。

这里是KVO的更多解释。
这里是大地瓜的翻译。

动态方法处理

以上我们看到了方法交换，已有方法的处理。

那么object无法处理某个消息的时候呢？当然就崩了。大多数情况下我们的应用在这种情况就是会崩的。但是Cocoa和runtime是提供了一些处理方式的。

动态方法处理

一般情况下，处理一个方法的话，要根据selector找到对应的实现然后运行。但是有时候运行时才创建某个方法，或者运行时这个方法才能获得全部信息。那么需要重写+resolveInstanceMethod:或者+resolveClassMethod:，最后返回YES。

+ (BOOL)resolveInstanceMethod:(SEL)aSelector {
    if (aSelector == @selector(myDynamicMethod)) {
        class_addMethod(self, aSelector, (IMP)myDynamicIMP, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:aSelector];
}

Core Data用的比较多，平时不太用得到。
若返回了NO，说明没有在运行时获得需要的方法。此时要进行消息转发。

消息转发

将消息转发到另一个可以处理该消息的object
多个消息都转发到同一个方法上

消息转发的步骤：
首先运行时调用-forwadrTargetForSelector:，这个方法用于将消息传递给另一个对象。
如果要修改消息，使用-forwardInvocation:，运行时将把消息包装成NSInvocation，再返回给你（也就是开发者）处理。最后调用invokeWithTarget:。

用到消息转发的主要有这么两处：
代理(NSProxy)。NSProxy是一个class，可以转发消息到另一个object。NSUndoManager是截取消息再执行，并不进行转发。
响应链：处理事件或行为到响应的对象。某个消息收到后，若当前FirstResponder不能处理该消息，则转发到下一个responder，最后找到能处理的对象进行处理，若找不到则报错。

Block作为Method IMP

一个IMP是指向方法实现的指针，前两个参数为object(self)和selector(cmd)。
implementationWithBlock()可以允许我们将block作为IMP使用。

IMP myIMP = imp_implementationWithBlock(^(id _self, NSString *string) {
  NSLog(@"Hello %@", string);
});
class_addMethod([MYClass class], @selector(sayHello:), myIMP, "V@:@");

具体实现内部，参看这篇文章。
这里是大地瓜的翻译。

Runtime

方法（method）

对象、类、元类（object, class, metaclass）

在OC中，类也是对象。

方法、选择器、IMP（methods, selectors, IMPs）

创建、修改、自省class和object

class

ivar

method

objc

property

protocol

sel

方法欺骗（Method Swizzling）

动态继承、交换

动态方法处理

动态方法处理

消息转发

Block作为Method IMP

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读