Objective-C RunTime机制(1)

最新推荐文章于 2023-11-07 14:57:33 发布

LeeBooL

最新推荐文章于 2023-11-07 14:57:33 发布

阅读量352

点赞数

分类专栏： ios-学习

本文链接：https://blog.csdn.net/u013570474/article/details/50067497

版权

ios-学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Objective-C 是面相运行时的语言（runtime oriented language），就是说它会尽可能的把编译和链接时要执行的逻辑延迟到运行时。这就给了你很大的灵活性，你可以按需要把消息重定向给合适的对象，你甚至可以交换方法的实现，等等（译注：在 Objective-C 中调用一个对象的方法可以看成向一个对象发送消息, Method Swizzling 具体实现可以参看 jrswizzle ）。这就需要使用 runtime。Runtime系统来动态创建类和对象，进行消息发送和转发。

OC 类处理
参考：
http://blog.csdn.net/lpstudy/article/details/21954711?utm_source=tuicool&utm_medium=referral

runtime是开源的。可以去down：http://opensource.apple.com/tarballs/objc4/objc4-437.1.tar.gz
我们可以Object.h从看对象的定义的实现其实是一个结构体


/*
    Object.h
    Copyright 1988-1996 NeXT Software, Inc.

    DEFINED AS: A common class
    HEADER FILES:   <objc/Object.h>
    #if __OBJC2__

@interface Object
{
    Class isa;  /* A pointer to the instance's class structure */
}

+class;
-(BOOL) isEqual:anObject;

@end

#else

@interface Object
{
    Class isa;  /* A pointer to the instance's class structure */
}

/* Initializing classes and instances */


*/

isa 是一个指向实例的类的指针，
然后接下来使一些方法，包括

/* Creating, copying, and freeing instances */
/* Identifying classes */
/* Identifying and comparing instances */
/* Testing inheritance relationships */

等还有指向父类的指针
其实Class 中的 *isa 本身就是一个指针类型

在 Objective-C 中的对象的一个重要的特性是，你可以向它们发送消息：当你向一个 Objective-C 的对象发送消息的时候，runtime 沿着对象的 isa 指针找到了这个对象的 Class结构体。 Class 结构体中包含了一个这个类的方法列表和一个指向父类的指针，用于查找继承的方法。

Class本身就是一个指针类型，是一个指向objc_class结构体指针。

lobjc_class是什么？就是类的定义
typedef  struct objc_class *Class；
struct objc_class

  {

      struct objc_class* isa;

      struct objc_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;

  };

同样的, struct objc_class 中让我们在 Class 上调用一个方法，Class 的 isa 指针必须指向一个 Class 结构体，并且那个 Class 结构体必须包含我们可以在那个 Class 上调用的方法的列表
这就引出了 meta-class 的定义：meta-class 是 Class 对象的类（the meta-class is the class for a Class object）。

cache用来缓存经常访问的方法，它指向objc_cache结构体，后面会重点讲到。
protocols表示类遵循哪些协议。
ivars表示多个成员变量，它指向objc_ivar_list结构体。在runtime.h可以看到它的定义

struct objc_ivar_list {
  int ivar_count                                           OBJC2_UNAVAILABLE;
#ifdef __LP64__
  int space                                                OBJC2_UNAVAILABLE;
#endif
  /* variable length structure */
  struct objc_ivar ivar_list[1]                            OBJC2_UNAVAILABLE;
}

methodLists表示方法列表，它指向objc_method_list结构体的二级指针，可以动态修改*methodLists的值来添加成员方法，也是Category实现原理，同样也解释Category不能添加属性的原因。在runtime.h可以看到它的定义：

struct objc_method_list {
  struct objc_method_list *obsolete                        OBJC2_UNAVAILABLE;

  int method_count                                         OBJC2_UNAVAILABLE;
#ifdef __LP64__
  int space                                                OBJC2_UNAVAILABLE;
#endif
  /* variable length structure */
  struct objc_method method_list[1]                        OBJC2_UNAVAILABLE;
}

同理，objc_method_list也是一个链表，存储多个objc_method，而objc_method结构体存储类的某个方法的信息。

Ivar
Ivar其实就是一个指向objc_ivar结构体指针，它包含了变量名(ivar_name)、变量类型(ivar_type)等信息。
Ivar表示类中的实例变量，在runtime.h文件中找到它的定义：

/// An opaque type that represents an instance variable.
typedef struct objc_ivar *Ivar;

struct objc_ivar {
    char *ivar_name                                          OBJC2_UNAVAILABLE;
    char *ivar_type                                          OBJC2_UNAVAILABLE;
    int ivar_offset                                          OBJC2_UNAVAILABLE;
#ifdef __LP64__
    int space                                                OBJC2_UNAVAILABLE;
#endif
}

Cache

顾名思义，Cache主要用来缓存，那它缓存什么呢？我们先在runtime.h文件看看它的定义：

typedef struct objc_cache *Cache                             OBJC2_UNAVAILABLE;

struct objc_cache {
    unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
    unsigned int occupied                                    OBJC2_UNAVAILABLE;
    Method buckets[1]                                        OBJC2_UNAVAILABLE;
};

ache其实就是一个存储Method的链表，主要是为了优化方法调用的性能。当对象receiver调用方法message时，首先根据对象receiver的isa指针查找到它对应的类，然后在类的methodLists中搜索方法，如果没有找到，就使用super_class指针到父类中的methodLists查找，一旦找到就调用方法。如果没有找到，有可能消息转发，也可能忽略它。但这样查找方式效率太低，因为往往一个类大概只有20%的方法经常被调用，占总调用次数的80%。所以使用Cache来缓存经常调用的方法，当调用方法时，优先在Cache查找，如果没有找到，再到methodLists查找。
这里写图片描述
meta-class 是 Class 对象的类。每个 Class 都有个不同的自己的 meta-class（因此每个 Class 都可以有一个自己不同的方法列表）。也就是说每个类的 Class 不完全相同。

meta-class 总是会保证 Class 对象会有从基类继承的所有的的实例和类方法，加上之后继承的类方法。如从 NSObject 继承的类，就意味着在所有的 Class（和 meta-class）对象中定义了所有从 NSObject 继承的实例和协议方法。

所有的 meta-class 使用基类的 meta-class（NSObject 的 meta-class 用于继承自 NSObject 的类）作为他们自己的类，包括在运行时自己定义的基础的 meta-class。

简单来说：
- 当你向一个对象发送消息，就在那个对象的方法列表中查找那个消息（就是 -（typename） methodname 。。。声明的实力方法
- 当你想一个类发送消息，就再那个类的 meta-class 中查找那个消息。（ + （typename) methodname 。。。声明的类方法。
- 并且meta-class 是必须的，因为它为一个 Class 存储类方法。每个类都必须有一个唯一的 meta-class，因为每个 Class 都有一个可能不一样的类方法。
和 Class 以 super_class 指针指向它的父类的方法一样，meta-class 以 super_class 指针指向 Class 的 super_class 的 meta-class。（译注：这句话有点绕，就是 super-class 一个指向 Class 的父类，一个指向 meta-class 的父类。Class 是一般对象的类型，meta-class 是 Class 的类型。）

消息机制
参考:
http://www.cocoachina.com/bbs/read.php?tid=189505
在runtime中Message也是一个结构体

struct objc_method {
    SEL method_name                                         OBJC2 _UNAVAILABLE;
    char *method_types                                       OBJC2_UNAVAILABLE;
    IMP method_imp                                           OBJC2_UNAVAILABLE;
}   
/*OBJC2_UNAVAILABLE是一个Apple对Objc系统运行版本进行约束的宏定义，主要为了兼容非Objective-C 2.0的遗留版本，但我们仍能从中获取一些有用信息。 */

IMP

在上面讲Method时就说过，IMP本质上就是一个函数指针，指向方法的实现，在objc.h找到它的定义：

/// A pointer to the function of a method implementation. 
#if !OBJC_OLD_DISPATCH_PROTOTYPES
typedef void (*IMP)(void /* id, SEL, ... */ ); 
#else
typedef id (*IMP)(id, SEL, ...); 
#endif

id objc_msgSend ( id self, SEL op, ... );

首先 SEL 类里面的方法都是被转换成SEL变量进行存储的。SEL其本身是一个Int类型的一个地址，地址中存放着方法的名字。对于一个类中。每一个方法对应着一个SEL。所以iOS类中不能存在2个名称相同的方法，即使参数类型不同，因为SEL是根据方法名字生成的，相同的方法名称只能对应一个SEL。SEL 可以用@selector()取类方法的编号,他的行为基本可以等同C语言的中函数指针,只不过C语言中，可以把函数名直接赋给一个函数指针，而Object-C的类不能直接应用函数指针，这样只能做一个@selector语法来取.

id其实就是一个指向objc_object结构体指针，它包含一个Class isa成员，根据isa指针就可以顺藤摸瓜找到对象所属的类。

/// 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;

C/C++ 函数指针

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;
int (* funcp)(int, int);
int func(int a, int b)
{
    return a + b;
}
int main()
{
    funcp = &func;
    cout<<funcp(1, 2)<<endl;
    return 0;
}

object-c的选择器

   SEL afun = @selector(someMethodName:::::);

在让我们看一下objc_msgSend它具体是如何发送消息：

首先根据receiver对象的isa指针获取它对应的class；
优先在class的cache查找message方法，如果找不到，再到methodLists查找；
如果没有在class找到，再到super_class查找；
一旦找到message这个方法，就执行它实现的IMP。
这里写图片描述

消息转发机制

receiver message]调用方法时，如果在message方法在receiver对象的类继承体系中没有找到方法，那怎么办？一般情况下，程序在运行时就会Crash掉，抛出unrecognized selector sent to…类似这样的异常信息。但在抛出异常之前，还有三次机会按以下顺序让你拯救程序。
这里写图片描述
Method Resolution

首先Objective-C在运行时调用+ resolveInstanceMethod:或+ resolveClassMethod:方法，让你添加方法的实现。如果你添加方法并返回YES，那系统在运行时就会重新启动一次消息发送的过程。

举一个简单例子，定义一个类Message，它主要定义一个方法sendMessage，下面就是它的设计与实现：

@interface Message : NSObject  
- (void)sendMessage:(NSString *)word;  
@end  
[cpp] view plaincopy
@implementation Message  
- (void)sendMessage:(NSString *)word  
{  
    NSLog(@"normal way : send message = %@", word);  
}  
@end

如果我在viewDidLoad方法中创建Message对象并调用sendMessage方法：

- (void)viewDidLoad {  
    [super viewDidLoad];  
    Message *message = [Message new];  
    [message sendMessage:@"Sam Lau"];  
}

控制台会打印以下信息：

normal way : send message = Sam Lau
但现在我将原来sendMessage方法实现给注释掉，覆盖resolveInstanceMethod方法：

#pragma mark - Method Resolution  
/// override resolveInstanceMethod or resolveClassMethod for changing sendMessage method implementation  
+ (BOOL)resolveInstanceMethod:(SEL)sel  
{  
    if (sel == @selector(sendMessage:)) {  
        class_addMethod([self class], sel, imp_implementationWithBlock(^(id self, NSString *word) {  
            NSLog(@"method resolution way : send message = %@", word);  
        }), "v@*");  
    }  
    return YES;  
}

控制台就会打印以下信息：

method resolution way : send message = Sam Lau
注意到上面代码有这样一个字符串”v@*，它表示方法的参数和返回值，详情请参考Type Encodings。

如果resolveInstanceMethod方法返回NO，运行时就跳转到下一步：消息转发(Message Forwarding)。

Fast Forwarding

如果目标对象实现- forwardingTargetForSelector:方法，系统就会在运行时调用这个方法，只要这个方法返回的不是nil或self，也会重启消息发送的过程，把这消息转发给其他对象来处理。否则，就会继续Normal Fowarding。

继续上面Message类的例子，将sendMessage和resolveInstanceMethod方法注释掉，然后添加forwardingTargetForSelector方法的实现：

#pragma mark - Fast Forwarding  
- (id)forwardingTargetForSelector:(SEL)aSelector  
{  
    if (aSelector == @selector(sendMessage:)) {  
        return [MessageForwarding new];  
    }  
    return nil;  
}

此时还缺一个转发消息的类MessageForwarding，这个类的设计与实现如下：

@interface MessageForwarding : NSObject  
- (void)sendMessage:(NSString *)word;  
@end  
[cpp] view plaincopy
@implementation MessageForwarding  
- (void)sendMessage:(NSString *)word  
{  
    NSLog(@"fast forwarding way : send message = %@", word);  
}  
@end

此时，控制台会打印以下信息：

fast forwarding way : send message = Sam Lau
这里叫Fast，是因为这一步不会创建NSInvocation对象，但Normal Forwarding会创建它，所以相对于更快点。

Normal Forwarding

如果没有使用Fast Forwarding来消息转发，最后只有使用Normal Forwarding来进行消息转发。它首先调用methodSignatureForSelector:方法来获取函数的参数和返回值，如果返回为nil，程序会Crash掉，并抛出unrecognized selector sent to instance异常信息。如果返回一个函数签名，系统就会创建一个NSInvocation对象并调用-forwardInvocation:方法。

继续前面的例子，将forwardingTargetForSelector方法注释掉，添加methodSignatureForSelector和forwardInvocation方法的实现：

#pragma mark - Normal Forwarding  
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector  
{  
    NSMethodSignature *methodSignature = [super methodSignatureForSelector:aSelector];  
    if (!methodSignature) {  
        methodSignature = [NSMethodSignature signatureWithObjCTypes:"v@:*"];  
    }  
    return methodSignature;  
}  
- (void)forwardInvocation:(NSInvocation *)anInvocation  
{  
    MessageForwarding *messageForwarding = [MessageForwarding new];  
    if ([messageForwarding respondsToSelector:anInvocation.selector]) {  
        [anInvocation invokeWithTarget:messageForwarding];  
    }  
}

三种方法的选择

Runtime提供三种方式来将原来的方法实现代替掉，那该怎样选择它们呢？

Method Resolution：由于Method Resolution不能像消息转发那样可以交给其他对象来处理，所以只适用于在原来的类中代替掉。
Fast Forwarding：它可以将消息处理转发给其他对象，使用范围更广，不只是限于原来的对象。
Normal Forwarding：它跟Fast Forwarding一样可以消息转发，但它能通过NSInvocation对象获取更多消息发送的信息，例如：target、selector、arguments和返回值等信息。
Associated Objects

当使用Category对某个类进行扩展时，有时需要存储属性，Category是不支持的，这时需要使用Associated Objects来给已存在的类Category添加自定义的属性。Associated Objects提供三个API来向对象添加、获取和删除关联值：

void objc_setAssociatedObject (id object, const void *key, id value, objc_AssociationPolicy policy )
id objc_getAssociatedObject (id object, const void *key )
void objc_removeAssociatedObjects (id object )

其中objc_AssociationPolicy是个枚举类型，它可以指定Objc内存管理的引用计数机制。

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {  
    OBJC_ASSOCIATION_ASSIGN = 0,           /**< Specifies a weak reference to the associated object. */  
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object.  
                                            *   The association is not made atomically. */  
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied.  
                                            *   The association is not made atomically. */  
    OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object. 
                                            *   The association is made atomically. */  
    OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied. 
                                            *   The association is made atomically. */  
};

个关于NSObject+AssociatedObject Category添加属性associatedObject的示例代码：

NSObject+AssociatedObject@interface NSObject (AssociatedObject)  
@property (strong, nonatomic) id associatedObject;  
@end  
NSObject+AssociatedObject.m
@implementation NSObject (AssociatedObject)  
- (void)setAssociatedObject:(id)associatedObject  
{  
    objc_setAssociatedObject(self, @selector(associatedObject), associatedObject, OBJC_ASSOCIATION_RETAIN_NONATOMIC);  
}  
- (id)associatedObject  
{  
    return objc_getAssociatedObject(self, _cmd);  
}  
@end

Associated Objects的key要求是唯一并且是常量，而SEL是满足这个要求的，所以上面的采用隐藏参数_cmd作为key。

LeeBooL

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Objective-C RunTime机制(1)

Objective-C 是面相运行时的语言（runtime oriented language），就是说它会尽可能的把编译和链接时要执行的逻辑延迟到运行时。这就给了你很大的灵活性，你可以按需要把消息重定向给合适的对象，你甚至可以交换方法的实现，等等（译注：在 Objective-C 中调用一个对象的方法可以看成向一个对象发送消息, Method Swizzling 具体实现可以参看 jrswizz
复制链接

扫一扫