Objective-C 是一个动态语言，这意味着它不仅需要一个编译器，也需要一个运行时系统来动态得创建类和对象、进行消息传递和转发。理解 Objective-C 的 Runtime 机制可以帮我们更好的了解这个语言，适当的时候还能对语言进行扩展，从系统层面解决项目中的一些设计或技术问题。了解 Runtime ，要先了解它的核心 - 消息传递 （Messaging）。

目录

  1. 消息传递（Messaging）
  2. objc_object, objc_class 以及 Ojbc_method
    1. 类对象(objc_class)
    2. 实例(objc_object)
    3. 元类(Meta Class)
    4. Method(objc_method)
      1. SEL(objc_selector)
      2. IMP
    5. 类缓存(objc_cache)
    6. Category(objc_category)
  3. 动态方法解析和转发
    1. Method Resolution
    2. Fast forwarding
    3. Normal forwarding
  4. Method Swizzling和AOP
    1. Aspect Oriented Programming （面向切面编程）
  5. 最后

消息传递（Messaging）

在很多语言，比如 C ，调用一个方法其实就是跳到内存中的某一点并开始执行一段代码。没有任何动态的特性，因为这在编译时就决定好了。而在 Objective-C 中，[object foo] 语法并不会立即执行 foo 这个方法的代码。它是在运行时给 object 发送一条叫 foo 的消息。这个消息，也许会由 object 来处理，也许会被转发给另一个对象，或者不予理睬假装没收到这个消息。多条不同的消息也可以对应同一个方法实现。这些都是在程序运行的时候决定的。

事实上，在编译时你写的 Objective-C 函数调用的语法都会被翻译成一个 C 的函数调用 - objc_msgSend() 。比如，下面两行代码就是等价的：

1
2
[array insertObject:foo atIndex:5];
objc_msgSend(array, @selector(insertObject:atIndex:), foo, 5);

消息传递的关键藏于 objc_object 中的 isa 指针和 objc_class 中的 class dispatch table。

objc_object, objc_class 以及 Ojbc_method

在 Objective-C 中，类、对象和方法都是一个 C 的结构体，从 objc/objc.h 头文件中，我们可以找到他们的定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
struct objc_object {  
    Class isa  OBJC_ISA_AVAILABILITY;
};
struct objc_class {  
    Class isa  OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
    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;
#endif
};
struct objc_method_list {  
    struct objc_method_list *obsolete;
    int method_count;
#ifdef __LP64__
    int space;
#endif
    /* variable length structure */
    struct objc_method method_list[1];
};
struct objc_method {  
    SEL method_name;
    char *method_types;    /* a string representing argument/return types */
    IMP method_imp;
};

objc_method_list 本质是一个有 objc_method 元素的可变长度的数组。一个 objc_method 结构体中有函数名，也就是SEL，有表示函数类型的字符串 (见 Type Encoding) ，以及函数的实现IMP。

从这些定义中可以看出发送一条消息也就 objc_msgSend 做了什么事。举 objc_msgSend(obj, testMethod) 这个例子来说：

1.首先，通过 obj 的 isa 指针找到它的 class ;//找到类对象
2.在 class 的 method list 找 testMethod ;
3.如果 class 中没到 testMethod，继续往它的 superclass 中找 ;
4.一旦找到 testMethod 这个函数，就去执行它的实现IMP .
5.转发IMP的return值

但这种实现有个问题，效率低。但一个 class 往往只有 20% 的函数会被经常调用，可能占总调用次数的 80% 。每个消息都需要遍历一次 objc_method_list 并不合理。如果把经常被调用的函数缓存下来，那可以大大提高函数查询的效率。这也就是 objc_class 中另一个重要成员 objc_cache 做的事情 - 再找到 testMethod 之后，把 testMethod 的 method_name 作为 key ，method_imp 作为 value 给存起来。当再次收到 testMethod 消息的时候，可以直接在 cache 里找到，避免去遍历 objc_method_list.

下面讲讲消息传递用到的一些概念：

  • 类对象(objc_class)
  • 实例(objc_object)
  • 类(Meta Class)
  • Method(objc_method)
  • SEL(objc_selector)
  • IMP
  • 类缓存(objc_cache)
  • Category(objc_category)

类对象(objc_class)

Objective-C类是由Class类型来表示的，它实际上是一个指向objc_class结构体的指针。

1
typedef struct objc_class *Class;

struct objc_class结构体定义了很多变量，通过命名不难发现，
结构体里保存了指向父类的指针、类的名字、版本、实例大小、实例变量列表、方法列表、缓存、遵守的协议列表等，
一个类包含的信息也不就正是这些吗？没错，类对象就是一个结构体struct objc_class，这个结构体存放的数据称为元数据(metadata)，
该结构体的第一个成员变量也是isa指针，这就说明了Class本身其实也是一个对象，因此我们称之为类对象，类对象在编译期产生用于创建实例对象，是单例。

实例(objc_object)

1
2
3
4
5
6
/// Represents an instance of a class. 
struct objc_object { 
	Class isa OBJC_ISA_AVAILABILITY; 
}; 
/// A pointer to an instance of a class. 
typedef struct objc_object *id;

类对象中的元数据存储的都是如何创建一个实例的相关信息，那么类对象和类方法应该从哪里创建呢？
就是从isa指针指向的结构体创建，类对象的isa指针指向的我们称之为元类(metaclass)，
元类中保存了创建类对象以及类方法所需的所有信息，因此整个结构应该如下图所示:

结构

元类(Meta Class)

通过上图我们可以看出整个体系构成了一个自闭环，struct objc_object结构体实例它的isa指针指向类对象，类对象的isa指针指向了元类，super_class指针指向了父类的类对象，而元类的super_class指针指向了父类的元类，那元类的isa指针又指向了自己。

元类(Meta Class)是一个类对象的类。在上面我们提到，所有的类自身也是一个对象，我们可以向这个对象发送消息(即调用类方法)。为了调用类方法，这个类的isa指针必须指向一个包含这些类方法的一个objc_class结构体。这就引出了meta-class的概念，元类中保存了创建类对象以及类方法所需的所有信息。

任何NSObject继承体系下的meta-class都使用NSObject的meta-class作为自己的所属类，而基类的meta-class的isa指针是指向它自己。

Method(objc_method)

1
2
3
4
5
6
7
runtime.h
/// An opaque type that represents a method in a class definition.代表类定义中一个方法的不透明类型
typedef struct objc_method *Method;
struct objc_method {
   SEL method_name                                          OBJC2_UNAVAILABLE;//方法名
   char *method_types                                       OBJC2_UNAVAILABLE;//方法类型
   IMP method_imp                                           OBJC2_UNAVAILABLE;//方法实现

在这个结构体中，我们已经看到了SEL和IMP，说明SEL和IMP其实都是Method的属性。

SEL(objc_selector)

1
2
3
Objc.h
/// An opaque type that represents a method selector.代表一个方法的不透明类型
typedef struct objc_selector *SEL;

objc_msgSend函数第二个参数类型为SEL，它是selector在Objective-C中的表示类型（Swift中是Selector类）。selector是方法选择器，可以理解为区分方法的 ID，而这个 ID 的数据结构是SEL:

1
@property SEL selector;

可以看到selector是SEL的一个实例。

A method selector is a C string that has been registered (or “mapped“) with the Objective-C runtime. Selectors generated by the compiler are automatically mapped by the runtime when the class is loaded.

其实selector就是个映射到方法的C字符串，你可以用 Objective-C 编译器命令@selector()或者 Runtime 系统的sel_registerName函数来获得一个 SEL 类型的方法选择器。

selector既然是一个string，我觉得应该是类似className+method的组合，命名规则有两条：

  • 同一个类，selector不能重复
  • 不同的类，selector可以重复

这也带来了一个弊端，我们在写C代码的时候，经常会用到函数重载，就是函数名相同，参数不同，但是这在Objective-C中是行不通的，因为selector只记了method的name，没有参数，所以没法区分不同的method。

在不同类中相同名字的方法所对应的方法选择器是相同的，即使方法名字相同而变量类型不同也会导致它们具有相同的方法选择器。

IMP

就是指向最终实现程序的内存地址的指针。

1
2
3
/// A pointer to the function of a method implementation.  指向一个方法实现的指针
typedef id (*IMP)(id, SEL, ...); 
#endif

在iOS的Runtime中，Method通过selector和IMP两个属性，实现了快速查询方法及实现，相对提高了性能，又保持了灵活性。

类缓存(objc_cache)

当Objective-C运行时通过跟踪它的isa指针检查对象时，它可以找到一个实现许多方法的对象。然而，你可能只调用它们的一小部分，并且每次查找时，搜索所有选择器的类分派表没有意义。所以类实现一个缓存，每当你搜索一个类分派表，并找到相应的选择器，它把它放入它的缓存。所以当objc_msgSend查找一个类的选择器，它首先搜索类缓存。这是基于这样的理论：如果你在类上调用一个消息，你可能以后再次调用该消息。

为了加速消息分发， 系统会对方法和对应的地址进行缓存，就放在上述的objc_cache，所以在实际运行中，大部分常用的方法都是会被缓存起来的，Runtime系统实际上非常快，接近直接执行内存地址的程序速度。

Category(objc_category)

Category是表示一个指向分类的结构体的指针，其定义如下：

1
2
3
4
5
6
7
8
struct category_t {
   const char *name;//是指 class_name 而不是 category_name。
   classref_t cls;//要扩展的类对象，编译期间是不会定义的，而是在Runtime阶段通过name对 应到对应的类对象。
   struct method_list_t *instanceMethods;//category中所有给类添加的实例方法的列表
   struct method_list_t *classMethods;//category中所有添加的类方法的列表。
   struct protocol_list_t *protocols;//category实现的所有协议的列表
   struct property_list_t *instanceProperties;//表示Category里所有的properties，这就是我们可以通过objc_setAssociatedObject和objc_getAssociatedObject增加实例变量的原因，不过这个和一般的实例变量是不一样的。
};

从上面的category_t的结构体中可以看出，分类中可以添加实例方法，类方法，甚至可以实现协议，添加属性，不可以添加成员变量。

动态方法解析和转发

在上面的例子中，如果 testMethod 没有找到会发生什么？通常情况下，程序会在运行时挂掉并抛出 unrecognized selector sent to … 的异常。但在异常抛出前，Objective-C 的运行时会给你三次拯救程序的机会：

1.Method resolution
2.Fast forwarding
3.Normal forwarding

首先，Objective-C 运行时会调用 +resolveInstanceMethod: 或者 +resolveClassMethod:，让你有机会提供一个函数实现。如果你添加了函数并返回 YES， 那运行时系统就会重新启动一次消息发送的过程。还是以 testMethod 为例，你可以这么实现：

Method Resolution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void testMethodIMP(id obj, SEL _cmd){
    NSLog(@"Doing testMethod");//新的testMethod函数
}
+ (BOOL)resolveInstanceMethod:(SEL)sel {
     if (sel == @selector(testMethod:)) {
     //https://www.jianshu.com/p/54c190542aa8  为什么object_getClass(obj)与[OBJ class]返回的指针不同
     
     Class _clsA = object_getClass(self);//返回isa指针
     Class _clsB = [self class];//返回自己
     const char *types = @encode(typeof(@selector(testMethod:)));
     class_addMethod([self class], sel, (IMP)testMethodIMP, types);
     return YES;
     }
     return [super resolveInstanceMethod:sel];
}

如果 resolve 方法返回 NO ，运行时就会移到下一步：消息转发（Message Forwarding）。

Fast forwarding

如果目标对象实现了 -forwardingTargetForSelector: ，Runtime 这时就会调用这个方法，给你把这个消息转发给其他对象的机会。

1
2
3
4
5
6
7
8
- (id)forwardingTargetForSelector:(SEL)aSelector {
     if (aSelector == @selector(testMethod:)) {
     return [Person new];//返回Person对象，让Person对象接收这个消息
     }
     return [super forwardingTargetForSelector:aSelector];
     
    //return nil;//返回nil，进入下一步转发
}

只要这个方法返回的不是 nil 和 self，整个消息发送的过程就会被重启，当然发送的对象会变成你返回的那个对象。否则，就会继续 Normal Fowarding 。

这里叫 Fast ，只是为了区别下一步的转发机制。因为这一步不会创建任何新的对象，但下一步转发会创建一个 NSInvocation 对象，所以相对更快点。

Normal forwarding

这一步是 Runtime 最后一次给你挽救的机会。首先它会发送 -methodSignatureForSelector: 消息获得函数的参数和返回值类型。如果 -methodSignatureForSelector: 返回 nil ，Runtime 则会发出 -doesNotRecognizeSelector: 消息，程序这时也就挂掉了。如果返回了一个函数签名，Runtime 就会创建一个 NSInvocation 对象并发送 -forwardInvocation: 消息给目标对象。

NSInvocation 实际上就是对一个消息的描述，包括selector 以及参数等信息。所以你可以在 -forwardInvocation: 里修改传进来的 NSInvocation 对象，然后发送 -invokeWithTarget: 消息给它，传进去一个新的目标：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (aSelector == @selector(testMethod:)) {
        const char *types = method_getTypeEncoding(class_getInstanceMethod(object_getClass([Person new]), @selector(testMethod:)));
        return [NSMethodSignature signatureWithObjCTypes:types];
    }
    return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation {
    SEL sel = anInvocation.selector;
    Person *p = [Person new];
    if ([p respondsToSelector:sel]) {
        [anInvocation invokeWithTarget:p];
    }
    else {
        [self doesNotRecognizeSelector:sel];
    }
}

Cocoa 里很多地方都利用到了消息传递机制来对语言进行扩展，如 Proxies、NSUndoManager 跟 Responder Chain。NSProxy 就是专门用来作为代理转发消息的；NSUndoManager 截取一个消息之后再发送；而 Responder Chain 保证一个消息转发给合适的响应者。

Method Swizzling和AOP

下面实现一个替换ViewController的viewDidLoad方法的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
+ (void)load {
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
     Class class = [self class];
     //SEL originalSelector = @selector(viewDidLoad);
     SEL originalSelector = @selector(viewDidLoad);
     SEL swizzledSelector = @selector(wxdViewDidLoad);
     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);
     }
     });
}

Aspect Oriented Programming （面向切面编程）

在 Objective-C 的世界里，这句话意思就是利用 Runtime 特性给指定的方法添加自定义代码。有很多方式可以实现 AOP ，Method Swizzling 就是其中之一。而且幸运的是，目前已经有一些第三方库可以让你不需要了解 Runtime ，就能直接开始使用 AOP 。
Aspects 就是一个不错的 AOP 库，封装了 Runtime ， Method Swizzling 这些黑色技巧，只提供两个简单的API：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#pragma mark - Public Aspects API
+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
                      withOptions:(AspectOptions)options
                       usingBlock:(id)block
                            error:(NSError **)error {
    return aspect_add((id)self, selector, options, block, error);
}
/// @return A token which allows to later deregister the aspect.
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
                      withOptions:(AspectOptions)options
                       usingBlock:(id)block
                            error:(NSError **)error {
    return aspect_add(self, selector, options, block, error);
}

使用 Aspects 提供的 API，我们之前的例子会进化成这个样子：

1
2
3
4
5
[self aspect_hookSelector:@selector(viewDidLoad) withOptions:AspectPositionBefore usingBlock:^(id<AspectInfo> aspectInfo){
   NSString *className = NSStringFromClass([[aspectInfo instance] class]);
   NSLog(@"");
   [[aspectInfo instance] wxdViewDidLoad];
} error:NULL];

最后

文中 Demo 我已放在了 Github 上，Demo 链接：Demo
利用 objective-C Runtime 特性和 Aspect Oriented Programming ，我们可以把琐碎事务的逻辑从主逻辑中分离出来，作为单独的模块。它是对面向对象编程模式的一个补充。