Objective-C Runtime概述

96
偏偏就是祢
2017.01.04 17:58* 字数 5178

引言

Objective-C是在C语言和汇编的基础上加入了面向对象特性消息转发机制的动态语言,这意味着它不仅需要一个编译器,还需要Runtime系统来动态创建类和对象,进行消息发送和转发。Objc 从三种不同的层级上与 Runtime 系统进行交互,分别是通过 Objective-C 源代码,通过 Foundation 框架的NSObject类定义的方法,通过对 runtime 函数的直接调用:

  • Objective-C源代码
    大部分情况下你就只管写你的Objc代码就行,runtime 系统自动在幕后辛勤劳作着。
    还记得引言中举的例子吧,消息的执行会使用到一些编译器为实现动态语言特性而创建的数据结构和函数,Objc中的类、方法和协议等在 runtime 中都由一些数据结构来定义,这些内容在后面会讲到。(比如objc_msgSend函数及其参数列表中的id和SEL都是啥)

  • NSObject的方法
    Cocoa 中大多数类都继承于NSObject类,也就自然继承了它的方法。最特殊的例外是NSProxy,它是个抽象超类,它实现了一些消息转发有关的方法,可以通过继承它来实现一个其他类的替身类或是虚拟出一个不存在的类,说白了就是领导把自己展现给大家风光无限,但是把活儿都交给幕后小弟去干。
    有的NSObject中的方法起到了抽象接口的作用,比如description方法需要你重载它并为你定义的类提供描述内容。NSObject还有些方法能在运行时获得类的信息,并检查一些特性,比如class返回对象的类;isKindOfClass:isMemberOfClass:则检查对象是否在指定的类继承体系中;respondsToSelector:检查对象能否响应指定的消息;conformsToProtocol:检查对象是否实现了指定协议类的方法;methodForSelector:则返回指定方法实现的地址。

  • Runtime的函数
    Runtime 系统是一个由一系列函数和数据结构组成,具有公共接口的动态共享库。头文件存放于/usr/include/objc目录下。许多函数允许你用纯C代码来重复实现 Objc 中同样的功能。虽然有一些方法构成了NSObject类的基础,但是你在写 Objc 代码时一般不会直接用到这些函数的,除非是写一些 Objc 与其他语言的桥接或是底层的debug工作。在Objective-C Runtime Reference中有对 Runtime 函数的详细文档。

下面通过分析Apple开源的Runtime代码来深入理解Objective-C的Runtime机制。

Runtime术语

在讲这块内容之前,我们看一下编译器如何将OC代码转化为运行时的代码,首先进入.m文件所在的文件路径,通过终端命令编译.m文件:clang -rewrite-objc xxx.m可以看到编译后的xxx.cpp(C++文件)。
比如我们创建了一个对象[[NSObject alloc] init]

#import "Maker.h"

@implementation Maker
- (void)dosome {
    id objc = [[NSObject alloc] init];
    NSLog(@"wshhsw");
}

int main(int argc, char * argv[]) {
    @autoreleasepool {
        id objc = [[NSObject alloc] init];
        return 0;
    }
}
@end

最终被转换为几万行代码,截取最关键的一句可以看到底层是通过runtime创建的对象

// - (void)dosome;

/* @end */

// @implementation Maker

static void _I_Maker_dosome(Maker * self, SEL _cmd) {
    id objc = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_4k_hh7kg7252wl_5zvbpzsx4nfc0000gn_T_Maker_df949a_mi_0);
}

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        id objc = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
        return 0;
    }
}
// @end

删除掉一些强制转换语句,可以看到调用方法本质就是发消息,[[NSObject alloc] init]语句发了两次消息,第一次发了alloc 消息,第二次发送init 消息。当我们在使用objc_msgSend()sel_registerName()方法时需要导入头文件<objc/message.h>, 设置build settings中的 ENABLE_STRICT_OBJC_MSGSEND为NO,如果你的项目是默认ARC模式的话请将相应的文件设置为-fno-objc-arc,下面是我的代码例子:

#import "SecondViewController.h"
#import <objc/message.h>

@interface SecondViewController ()

@end

@implementation SecondViewController


- (void)viewDidLoad {
    [super viewDidLoad];
    objc_msgSend(self , @selector(test));
}

- (void)test {
    NSLog(@"wwwwsssshhhh");
}
第二行就是控制台打印的结果

上面介绍了编译后和手动调用的情况,下面我们接着分析一下[receiver message]内部的一些东西,其实我们在使用[receiver message]语法并不会马上执行receiver对象的message方法的代码,而是向receiver发送一条message消息,如果接受者找到对应的selector,那么就相当于直接执行了这个对象的特定方法;否则,消息要么被转发,或者临时向接受者动态添加这个selector对应的实现内容;要么就干脆玩崩溃。其实[receiver message]被编译器转化为:

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

下面以上面提到的两个数据结构idSEL来逐步分析和理解Runtime中哪些重要的Runtime术语:

SEL

SEL Data Structure

查看到SEL数据结构如下:

typedef struct objc_selector *SEL;

其实它就是映射到方法的C字符串,你可以通过Objc编译器命令@selector()或者Runtime系统的sel_registerName函数来获取一个SEL类型的方法选择器。
如果你知道selector对应的方法名是什么,可以通过NSString* NSStringFromSelector(SEL aSelector)方法将SEL转化为字符串,再用NSLog打印。

id

接下来看objc_msgSend第一个参数的数据类型id,id是通用类型指针,能够表示任何对象。按下面路径打开objc.h文件

id Data Structure

查看到id数据结构如下:

struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

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

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

注意:根据Apple的官方文档Key-Value Observing Implementation Details提及,key-value observing是使用isa-swizzling的技术实现的,isa指针在运行时被修改,指向一个中间类而不是真正的类。所以,你不应该使用isa指针来确定类的关系,而是使用class方法来确定实例对象的类。

Class

isa指针的数据类型是Class,Class表示对象所属的类,按下面路径打开objc.h文件


Class Data Structure
typedef struct objc_class *Class;

可以查看到Class其实就是一个objc_class结构体指针,但这个头文件找不到它的定义,需要在runtime.h才能找到objc_class结构体的定义。

按下面路径打开runtime.h文件

objc_class Data Structure

查看到objc_class结构体定义如下:

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;

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

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

注意OBJC2_UNAVAILABLE 是一个Apple对Objc系统运行版本进行约束的宏定义,主要为了兼容非Objective-C 2.0的遗留版本,但我们仍能从中获取一些有用信息。

让我们分析一些重要的成员变量表示什么意思和对应使用哪些数据结构。

  • isa表示一个Class对象的Class,也就是Meta Class。在面向对象设计中,一切都是对象,Class在设计中本身也是一个对象。
    其实Meta Class也是一个Class,它也跟其他Class一样有自己的isasuper_class指针,关系如下:

    Class isa and superclass relationship from Google

    上图形象版的关系图

    有几个关键点需要解释以下:

  • 当我们对一个实例发送消息时(-开头的方法),会在该 instance 对应的类的 methodLists 里查找。

  • 当我们对一个类发送消息时(+开头的方法),会在该类的 MetaClass 的 methodLists 里查找。

  • 每个 Class 都有一个 isa 指针指向一个唯一的 Meta Class

  • 每一个 Meta Class 的 isa 指针都指向最上层的 Meta Class,即 NSObject 的 MetaClass,而最上层的 MetaClass 的 isa 指针又指向自己

  • super_class表示实例对象对应的父类

  • name表示类名

  • 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;
} 

objc_ivar_list其实就是一个链表,存储多个objc_ivar,而objc_ivar结构体存储类的单个成员变量信息。

  • 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结构体存储类的某个方法的信息。

  • cache用来缓存经常访问的方法,它指向objc_cache结构体,后面会重点讲到。
  • protocols表示类遵循哪些协议

Method

Method表示类中的某个方法,在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;
}

其实Method就是一个指向objc_method结构体指针,它存储了方法名(method_name)、方法类型(method_types)和方法实现(method_imp)等信息。而method_imp的数据类型是IMP,它是一个函数指针,后面会重点提及。
举个例子:

- (void)getMethodTest {
    unsigned int count;
    Method *methods = class_copyMethodList([ViewController class], &count);
   //Method *methods = class_copyMethodList([ViewController class]->isa, &count);   //这样就可以获取类方法了
    for (int i = 0; i < count; i++) {
        Method method = methods[i];
        SEL selector = method_getName(method);
        NSString *name = NSStringFromSelector(selector);
        NSLog(@"方法名字 === %@",name);
    }
    free(methods);
}

Ivar

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
}

Ivar其实就是一个指向objc_ivar结构体指针,它包含了变量名(ivar_name)、变量类型(ivar_type)等信息。
举个例子:

- (void)getIvarsTest {
    unsigned int count;
    Ivar *ivars = class_copyIvarList([ViewController class], &count);
    
    for (unsigned int i = 0; i < count; i++) {
        Ivar ivar = ivars[i];
        NSString *ivarName = [NSString stringWithUTF8String:ivar_getName(ivar)];
        
        ivarName = [ivarName substringFromIndex:1];
        
        //属性类型
        NSString *ivarType = [NSString stringWithUTF8String:ivar_getTypeEncoding(ivar)];
        NSLog(@"成员变量名字 === %@   类型名字 %@",ivarName,ivarType);
    }
    free(ivars);
}

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

当你向某个对象发送一条信息,可以由这个函数指针来指定方法的实现,它最终就会执行那段代码,这样可以绕开消息传递阶段而去执行另一个方法实现。

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

Cache其实就是一个存储Method的链表,主要是为了优化方法调用的性能。当对象receiver调用方法message时,首先根据对象receiver的isa指针查找到它对应的类,然后在类的methodLists中搜索方法,如果没有找到,就使用super_class指针到父类中的methodLists查找,一旦找到就调用方法。如果没有找到,有可能消息转发,也可能忽略它。但这样查找方式效率太低,因为往往一个类大概只有20%的方法经常被调用,占总调用次数的80%。所以使用Cache来缓存经常调用的方法,当调用方法时,优先在Cache查找,如果没有找到,再到methodLists查找。

Property

@property标记了类中的属性,这个不必多说大家都很熟悉,它是一个指向objc_property结构体的指针:

/// An opaque type that represents an Objective-C declared property.
typedef struct objc_property *objc_property_t;

可以通过class_copyPropertyListprotocol_copyPropertyList方法来获取类和协议中的属性:

OBJC_EXPORT objc_property_t *class_copyPropertyList(Class cls, unsigned int *outCount);

OBJC_EXPORT objc_property_t *protocol_copyPropertyList(Protocol *proto, unsigned int *outCount);

返回类型为指向数组的指针,因为属性列表是个数组,每个元素内容都是一个objc_property_t指针,而这两个函数返回的值是指向这个数组的指针。
举个例子:

- (void)getAllProperties {
    u_int count;
    
    //使用class_copyPropertyList及property_getName获取类的属性列表及每个属性的名称
    
    objc_property_t *properties = class_copyPropertyList([ViewController class], &count);
    for (int i = 0; i < count; i++) {
        const char* propertyName = property_getName(properties[i]);
        NSLog(@"属性 === %@",[NSString stringWithUTF8String:propertyName]);
    }
    free(properties);
}

消息发送

前面从objc_msgSend作为入口,逐步深入分析Runtime的数据结构,了解每个数据结构的作用和它们之间关系后,我们正式转入消息发送这个正题。

objc_msgSend函数
在前面已经演示过,当某个对象使用语法[receiver message]来调用某个方法时,其实[receiver message]被编译器转化为:

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

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

  • 首先根据receiver对象的isa指针获取它对应的class,如果找不到对应的,也不会Crash,会被忽略掉,因为ObjC 的特性是允许对一个 nil 对象执行任何一个方法的。
  • 优先在classcache查找message方法,如果找不到,再到methodLists查找。
  • 如果没有在class找到,再到super_class查找,一直找,直到找到NSObject类为止,一旦找到message这个方法,就执行它实现的IMP
  • 如果还找不到就要开始进入动态方法解析了,后面会提到。


    Objc Message.jpeg

self与super
为了让大家更好地理解self和super,借用sunnyxx博客的ios程序员6级考试一道题目:下面的代码分别输出什么?

@implementation Son : Father
- (id)init
{
    self = [super init];
    if (self)
    {
        NSLog(@"%@", NSStringFromClass([self class]));
        NSLog(@"%@", NSStringFromClass([super class]));
    }
    return self;
}
@end

self表示当前这个类的对象,而super是一个编译器标示符,和self指向同一个消息接受者。在本例中,无论是[self class]还是[super class],接受消息者都是Son对象,但super与self不同的是,self调用class方法时,是在子类Son中查找方法,而super调用class方法时,是在父类Father中查找方法。
当调用[self class]方法时,会转化为objc_msgSend函数,这个函数定义如下:

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

这时会从当前Son类的方法列表中查找,如果没有,就到Father类查找,还是没有,最后在NSObject类查找到。我们可以从NSObject.mm文件中看到- (Class)class的实现:

- (Class)class {
    return object_getClass(self);
}

所以NSLog(@"%@", NSStringFromClass([self class]));会输出Son

当调用[super class]方法时,会转化为objc_msgSendSuper,这个函数定义如下:

id objc_msgSendSuper(struct objc_super *super, SEL op, ...)

objc_msgSendSuper函数第一个参数super的数据类型是一个指向objc_super的结构体,从message.h文件中查看它的定义:

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained Class class;
#else
    __unsafe_unretained Class super_class;
#endif
    /* super_class is the first class to search */
};
#endif

结构体包含两个成员,第一个是receiver,表示某个类的实例。第二个是super_class表示当前类的父类。

这时首先会构造出objc_super结构体,这个结构体第一个成员是self,第二个成员是(id)class_getSuperclass(objc_getClass("Son")),实际上该函数会输出Father。然后在Father类查找class方法,查找不到,最后在NSObject查到。此时,内部使用objc_msgSend(objc_super->receiver, @selector(class))去调用,与[self class]调用相同,所以结果还是Son。

方法中隐藏的参数self和_cmd
[receiver message]调用方法时,系统会在运行时偷偷地动态传入两个隐藏参数self_cmd,之所以称它们为隐藏参数,是因为在源代码中没有声明和定义这两个参数。它们是在代码被编译时被插入实现中的。尽管这些参数没有被明确声明,在源代码中我们仍然可以引用它们。至于对于self的描述,上面已经解释非常清楚了,下面我们重点讲解_cmd

_cmd表示当前调用方法,其实它就是一个方法选择器SEL。一般用于判断方法名或在Associated Objects中唯一标识键名,后面在Associated Objects会讲到。

动态方法解析和消息转发

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

  • Method Resolution
  • Fast Forwarding
  • Normal Forwarding
动态方法解析和消息转发

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

现在举个简单的例子,定义一个类MethodForwardTest,它主要定义一个方法test,下面就是它的设计与实现:

@interface MethodForwardTest : NSObject
- (void)test;
@end

但是我在MethodForwardTest.m没有实现这个方法,此时我在别的地方调用这个累的方法,程序就会直接崩溃,我们在resolveInstanceMethod来实现这个方法。

id dynamicMethod(id self, SEL _cmd) {
    NSLog(@"首先尝试动态添加方法");
    return @"首先尝试动态添加方法";
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    NSString *selectorString = NSStringFromSelector(sel);
    
    if ([selectorString isEqualToString:@"test"]) {
        class_addMethod(self, sel, (IMP)dynamicMethod, "@@:");
    }
    return YES;
}

注意到上面代码有这样一个字符串"v@*,它表示方法的参数和返回值,详情请参考Type Encodings

如果resolveInstanceMethod方法也没有实现,运行时就跳转到下一步:消息转发(Message Forwarding)

Fast Forwarding
继续上面MethodForwardTest类的例子,将test和resolveInstanceMethod方法注释掉,然后添加forwardingTargetForSelector方法的实现:

- (id)forwardingTargetForSelector:(SEL)aSelector {
    return [[Replacement alloc] init];
}

此时还缺一个转发消息的类Replacement,这个类的设计与实现如下:

@interface Replacement : NSObject
- (void)test;
@end
@implementation Replacement

- (void)test {
    NSLog(@"备用实现者提供了test方法的实现");
}

@end

这里叫Fast,是因为这一步不会创建NSInvocation对象,但Normal Forwarding会创建它,所以相对于更快点。

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

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

- (void)anotherTest {
   NSLog(@"另一个test方法");
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
   NSMethodSignature *signature = [super methodSignatureForSelector:aSelector];
   
   if (!signature) {  // 如果不能处理这个方法
       if ([self respondsToSelector:@selector(anotherTest)]) {
           // 返回另一个函数的方法签名,这个函数不一定要定义在本类中
           signature =  [MethodForwardTest instanceMethodSignatureForSelector:@selector(anotherTest)];
       }
   }
   return signature;
}

/**
*  这个函数中可以修改很多信息,比如可以替换选方法的处理者,替换选择子,修改参数等等
*
*  @param anInvocation 被转发的选择子
*/
- (void)forwardInvocation:(NSInvocation *)anInvocation {
   [anInvocation setSelector:@selector(anotherTest)];  // 设置需要调用的选择子
   [anInvocation invokeWithTarget:self];  // 设置消息的接收者,不一定必须是self
}

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

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

Associated Objects

当想使用Category对已存在的类进行扩展时,一般只能添加实例方法或类方法,而不适合添加额外的属性。虽然可以在Category头文件中声明property属性,但在实现文件中编译器是无法synthesize任何实例变量和属性访问方法。这时需要自定义属性访问方法并且使用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. */
};

下面有个关于 UIButton+NMCategory Category 添加属性 dragEnableadsorbEnable 的示例代码:

@interface UIButton (NMCategory)

@property(nonatomic,assign,getter = isDragEnable)   BOOL dragEnable;
@property(nonatomic,assign,getter = isAdsorbEnable) BOOL adsorbEnable;

@end
static void *DragEnableKey = &DragEnableKey;
static void *AdsorbEnableKey = &AdsorbEnableKey;

@implementation UIButton (NMCategory)

- (void)setDragEnable:(BOOL)dragEnable {
    objc_setAssociatedObject(self, DragEnableKey,@(dragEnable), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (BOOL)isDragEnable {
    return [objc_getAssociatedObject(self, DragEnableKey) boolValue];
}

- (void)setAdsorbEnable:(BOOL)adsorbEnable {
    objc_setAssociatedObject(self, AdsorbEnableKey,@(adsorbEnable), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (BOOL)isAdsorbEnable {
    return [objc_getAssociatedObject(self, AdsorbEnableKey) boolValue];
}
@end

Method Swizzling

Method Swizzling就是在运行时将一个方法的实现代替为另一个方法的实现。如果能够利用好这个技巧,可以写出简洁、有效且维护性更好的代码。下面看一个例子:

- (void)testMethodSwizzling {
    NSLog(@"未进行Method Swizzling之前:");
    NSLog(@"小写字符串:%@", [mixedString lowercaseString]);
    NSLog(@"大写字符串:%@", [mixedString myLowercaseString]);
    
    [self startMethodSwizzling];
    
    NSLog(@"进行Method Swizzling之后:");
    NSLog(@"小写字符串:%@", [mixedString lowercaseString]);
    NSLog(@"大写字符串:%@", [mixedString myLowercaseString]);
}

- (void)startMethodSwizzling {
    Method originalLowercaseStringMethod = class_getInstanceMethod([NSString class], @selector(lowercaseString));
    Method newLowercaseStringMethod = class_getInstanceMethod([NSString class], @selector(myLowercaseString));
    
    method_exchangeImplementations(originalLowercaseStringMethod, newLowercaseStringMethod);
}

应用案例

参考这篇文章

危险性

Method Swizzling就像一把瑞士小刀,如果使用得当,它会有效地解决问题。但使用不当,将带来很多麻烦。在stackoverflow上有人已经提出这样一个问题:What are the Dangers of Method Swizzling in Objective C?,它的危险性主要体现以下几个方面:

  • Method swizzling is not atomic (Method swizzling不是原子的)
  • Changes behavior of un-owned code (更改代码所有权的行为)
  • Possible naming conflicts (可能的命名冲突)
  • Swizzling changes the method's arguments (Swizzling改变方法的参数)
  • The order of swizzles matters (swizzles的顺序很重要)
  • Difficult to understand (looks recursive) (很难理解)
  • Difficult to debug (难以调试)

总结

我们之所以让自己的类继承NSObject不仅仅因为苹果帮我们完成了复杂的内存分配问题,更是因为这使得我们能够用上 Runtime 系统带来的便利。可能我们平时写代码时可能很少会考虑一句简单的[receiver
message]背后发生了什么,而只是当做方法或函数调用,但当你阅读一些iOS开源项目时,你就会发现很多时候都会用到。所以深入理解 Runtime 系统的细节有利于我们更容易地阅读和学习开源项目,最终写出功能更强大的代码。

参考

原理集