iOSRuntime的理解

字数5000&＃43;,预计阅读时间 30分钟

主要参考自:

iOS运行时(Runtime)详解&＃43;Demo
Objective-C Runtime
神经病院Objective-C Runtime出院第三天——如何正确使用Runtime

运行时简介

Objective-C语言是一门动态语言&＃xff0c;它将很多静态语言在编译和链接时期做的事放到了运行时来处理。对于Objective-C来说&＃xff0c;这个运行时系统就像一个操作系统一样&＃xff1a;它让所有的工作可以正常的运行。Runtime基本上是用C和汇编写的&＃xff0c;这个库使得C语言有了面向对象的能力。在Runtime中&＃xff0c;对象可以用C语言中的结构体表示&＃xff0c;而方法可以用C函数来实现&＃xff0c;另外再加上了一些额外的特性。这些结构体和函数被runtime函数封装后&＃xff0c;让OC的面向对象编程变为可能。找出方法的最终执行代码&＃xff1a;当程序执行[object doSomething]时&＃xff0c;会向消息接收者(object)发送一条消息(doSomething)&＃xff0c;Runtime会根据消息接收者是否能响应该消息而做出不同的反应。

一、类与对象基础数据结构

1、object_class 类 Objective-C类是由Class类型来表示的&＃xff0c;它实际上是一个指向objc_class结构体的指针。

typedef struct object_class *Class

它的定义如下&＃xff1a;

struct object_class{Class isa OBJC_ISA_AVAILABILITY; #if !__OBJC2__Class super_class OBJC2_UNAVAILABLE; // 父类const char *name OBJC2_UNAVAILABLE; // 类名long version OBJC2_UNAVAILABLE; // 类的版本信息&＃xff0c;默认为0long info OBJC2_UNAVAILABLE; // 类信息&＃xff0c;供运行期使用的一些位标识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;

2、objc_object 实例 objc_object是表示一个类的实例的结构体它的定义如下&＃xff1a;

struct objc_object{Class isa OBJC_ISA_AVAILABILITY; }; typedef struct objc_object *id;

可以看到&＃xff0c;这个结构体只有一个字体&＃xff0c;即指向其类的isa指针。这样&＃xff0c;当我们向一个Objective-C对象发送消息时&＃xff0c;运行时库会根据实例对象的isa指针找到这个实例对象所属的类。Runtime库会在类的方法列表及父类的方法列表中去寻找与消息对应的selector指向的方法&＃xff0c;找到后即运行这个方法。

3、元类(Meta Class) meta-class是一个类对象的类。在上面我们提到&＃xff0c;所有的类自身也是一个对象&＃xff0c;我们可以向这个对象发送消息(即调用类方法)。既然是对象&＃xff0c;那么它也是一个objc_object指针&＃xff0c;它包含一个指向其类的一个isa指针。那么&＃xff0c;这个isa指针指向什么呢&＃xff1f;

答案是&＃xff0c;为了调用类方法&＃xff0c;这个类的isa指针必须指向一个包含这些类方法的一个objc_class结构体。这就引出了meta-class的概念&＃xff0c;meta-class中存储着一个类的所有类方法。

所以&＃xff0c;调用类方法的这个类对象的isa指针指向的就是meta-class 当我们向一个对象发送消息时&＃xff0c;runtime会在这个对象所属的这个类的方法列表中查找方法&＃xff1b;而向一个类发送消息时&＃xff0c;会在这个类的meta-class的方法列表中查找。

再深入一下&＃xff0c;meta-class也是一个类&＃xff0c;也可以向它发送一个消息&＃xff0c;那么它的isa又是指向什么呢&＃xff1f;为了不让这种结构无限延伸下去&＃xff0c;Objective-C的设计者让所有的meta-class的isa指向基类的meta-class&＃xff0c;以此作为它们的所属类。

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

通过上面的描述&＃xff0c;再加上对objc_class结构体中super_class指针的分析&＃xff0c;我们就可以描绘出类及相应meta-class类的一个继承体系了&＃xff0c;如下&＃xff1a;

4、Category Category是表示一个指向分类的结构体的指针&＃xff0c;其定义如下&＃xff1a;

typedef struct objc_category *Category struct objc_category{char *category_name OBJC2_UNAVAILABLE; // 分类名char *class_name OBJC2_UNAVAILABLE; // 分类所属的类名struct objc_method_list *instance_methods OBJC2_UNAVAILABLE; // 实例方法列表struct objc_method_list *class_methods OBJC2_UNAVAILABLE; // 类方法列表struct objc_protocol_list *protocols OBJC2_UNAVAILABLE; // 分类所实现的协议列表 }

这个结构体主要包含了分类定义的实例方法与类方法&＃xff0c;其中instance_methods列表是objc_class中方法列表的一个子集&＃xff0c;而class_methods列表是元类方法列表的一个子集。可发现&＃xff0c;类别中没有ivar成员变量指针&＃xff0c;也就意味着&＃xff1a;类别中不能够添加实例变量和属性,(!除非使用关联对象,而且Category中的属性&＃xff0c;只会生成setter和getter方法&＃xff0c;不会生成成员变量)例子如下

#import "UIButton&＃43;ClickBlock.h" #import static const void *associatedKey &＃61; "associatedKey"; &＃64;implementation UIButton (ClickBlock) //Category中的属性&＃xff0c;只会生成setter和getter方法&＃xff0c;不会生成成员变量 -(void)setClick:(clickBlock)click{objc_setAssociatedObject(self, associatedKey, click, OBJC_ASSOCIATION_COPY_NONATOMIC);[self removeTarget:self action:&＃64;selector(buttonClick) forControlEvents:UIControlEventTouchUpInside];if (click) {[self addTarget:self action:&＃64;selector(buttonClick) forControlEvents:UIControlEventTouchUpInside];} } -(clickBlock)click{return objc_getAssociatedObject(self, associatedKey); } -(void)buttonClick{if (self.click) {self.click();} } &＃64;end

然后在代码中&＃xff0c;就可以使用 UIButton 的属性来监听单击事件了&＃xff1a;

UIButton *button &＃61; [UIButton buttonWithType:UIButtonTypeCustom]; button.frame &＃61; self.view.bounds; [self.view addSubview:button]; button.click &＃61; ^{NSLog(&＃64;"buttonClicked"); };

关联对象的使用

1.设置关联值参数说明&＃xff1a; object&＃xff1a;与谁关联&＃xff0c;通常是传self key&＃xff1a;唯一键&＃xff0c;在获取值时通过该键获取&＃xff0c;通常是使用static const void *来声明 value&＃xff1a;关联所设置的值 policy&＃xff1a;内存管理策略&＃xff0c;比如使用copyvoid objc_setAssociatedObject(id object, const void *key, id value, objc _AssociationPolicy policy)

2.获取关联值参数说明&＃xff1a; object&＃xff1a;与谁关联&＃xff0c;通常是传self&＃xff0c;在设置关联时所指定的与哪个对象关联的那个对象 key&＃xff1a;唯一键&＃xff0c;在设置关联时所指定的键 id objc_getAssociatedObject(id object, const void *key)

3.取消关联 void objc_removeAssociatedObjects(id object)

关联策略使用场景&＃xff1a; 可以在类别中添加属性typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy){ OBJC_ASSOCIATION_ASSIGN &＃61; 0, // 表示弱引用关联&＃xff0c;通常是基本数据类型 OBJC_ASSOCIATION_RETAIN_NONATOMIC &＃61; 1, // 表示强引用关联对象&＃xff0c;是线程安全的 OBJC_ASSOCIATION_COPY_NONATOMIC &＃61; 3, // 表示关联对象copy&＃xff0c;是线程安全的 OBJC_ASSOCIATION_RETAIN &＃61; 01401, // 表示强引用关联对象&＃xff0c;不是线程安全的 OBJC_ASSOCIATION_COPY &＃61; 01403 // 表示关联对象copy&＃xff0c;不是线程安全的 };

二、方法与消息

1、SEL

SEL又叫选择器&＃xff0c;是表示一个方法的selector的指针&＃xff0c;其定义如下&＃xff1a;

typedef struct objc_selector *SEL&＃xff1b;

方法的selector用于表示运行时方法的名字。Objective-C在编译时&＃xff0c;会依据每一个方法的名字、参数序列&＃xff0c;生成一个唯一的整型标识(Int类型的地址)&＃xff0c;这个标识就是SEL。两个类之间&＃xff0c;只要方法名相同&＃xff0c;那么方法的SEL就是一样的&＃xff0c;每一个方法都对应着一个SEL。所以在Objective-C同一个类(及类的继承体系)中&＃xff0c;不能存在2个同名的方法&＃xff0c;即使参数类型不同也不行如在某一个类中定义以下两个方法: 错误

- (void)setWidth:(int)width; - (void)setWidth:(double)width;

当然&＃xff0c;不同的类可以拥有相同的selector&＃xff0c;这个没有问题。不同类的实例对象执行相同的selector时&＃xff0c;会在各自的方法列表中去根据selector去寻找自己对应的IMP。工程中的所有的SEL组成一个Set集合&＃xff0c;如果我们想到这个方法集合中查找某个方法时&＃xff0c;只需要去找到这个方法对应的SEL就行了&＃xff0c;SEL实际上就是根据方法名hash化了的一个字符串&＃xff0c;而对于字符串的比较仅仅需要比较他们的地址就可以了&＃xff0c;可以说速度上无语伦比&＃xff01; 本质上&＃xff0c;SEL只是一个指向方法的指针&＃xff08;准确的说&＃xff0c;只是一个根据方法名hash化了的KEY值&＃xff0c;能唯一代表一个方法&＃xff09;&＃xff0c;它的存在只是为了加快方法的查询速度。

通过下面三种方法可以获取SEL: a、sel_registerName函数 b、Objective-C编译器提供的&＃64;selector() c、NSSelectorFromString()方法

2、IMP

IMP实际上是一个函数指针&＃xff0c;指向方法实现的地址。其定义如下:

id (*IMP)(id, SEL,...)

第一个参数&＃xff1a;是指向self的指针(如果是实例方法&＃xff0c;则是类实例的内存地址&＃xff1b;如果是类方法&＃xff0c;则是指向元类的指针) 第二个参数&＃xff1a;是方法选择器(selector) 接下来的参数&＃xff1a;方法的参数列表。

前面介绍过的SEL就是为了查找方法的最终实现IMP的。由于每个方法对应唯一的SEL&＃xff0c;因此我们可以通过SEL方便快速准确地获得它所对应的IMP&＃xff0c;查找过程将在下面讨论。取得IMP后&＃xff0c;我们就获得了执行这个方法代码的入口点&＃xff0c;此时&＃xff0c;我们就可以像调用普通的C语言函数一样来使用这个函数指针了。

3、Method

Method用于表示类定义中的方法&＃xff0c;则定义如下&＃xff1a;

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&＃xff0c;实际上相当于在SEL和IMP之间作了一个映射。有了SEL&＃xff0c;我们便可以找到对应的IMP&＃xff0c;从而调用方法的实现代码。

4、消息

Objc 中发送消息是用中括号&＃xff08;[]&＃xff09;把接收者和消息括起来&＃xff0c;而直到运行时才会把消息与方法实现绑定。

有关消息发送和消息转发机制的原理&＃xff0c;可以查看这篇文章。

面对着 Cocoa 中大量 API&＃xff0c;只知道简单的查文档和调用。还记得初学 Objective-C 时把 [receiver message] 当成简单的方法调用&＃xff0c;而无视了“发送消息”这句话的深刻含义。其实 [receiver message] 会被编译器转化为&＃xff1a;

objc_msgSend(receiver, selector)

如果消息含有参数&＃xff0c;则为&＃xff1a;

objc_msgSend(receiver, selector, arg1, arg2, ...)

如果消息的接收者能够找到对应的 selector&＃xff0c;那么就相当于直接执行了接收者这个对象的特定方法&＃xff1b;否则&＃xff0c;消息要么被转发&＃xff0c;或是临时向接收者动态添加这个 selector 对应的实现内容&＃xff0c;要么就干脆玩完崩溃掉。

现在可以看出[receiver message]真的不是一个简简单单的方法调用。因为这只是在编译阶段确定了要向接收者发送 message这条消息&＃xff0c;而 receiver 将要如何响应这条消息&＃xff0c;那就要看运行时发生的情况来决定了。

这里看起来像是objc_msgSend返回了数据&＃xff0c;其实objc_msgSend从不返回数据而是你的方法被调用后返回了数据。下面详细叙述下消息发送步骤&＃xff1a;

1、检测这个 selector 是不是要忽略的。比如 Mac OS X 开发&＃xff0c;有了垃圾回收就不理会 retain, release 这些函数了。 2、检测这个 target 是不是 nil 对象。ObjC 的特性是允许对一个 nil 对象执行任何一个方法不会 Crash&＃xff0c;因为会被忽略掉。 3、如果上面两个都过了&＃xff0c;那就开始查找这个类的 IMP&＃xff0c;先从 cache 里面找&＃xff0c;完了找得到就跳到对应的函数去执行。 4、如果 cache 找不到就找一下方法分发表。 5、如果分发表找不到就到超类的分发表去找&＃xff0c;一直找&＃xff0c;直到找到NSObject类为止。 6、如果还找不到就要开始进入动态方法解析了&＃xff0c;后面会提到。 PS:这里说的分发表其实就是Class中的方法列表&＃xff0c;它将方法选择器和方法实现地址联系起来。

其实编译器会根据情况在objc_msgSend, objc_msgSend_stret, objc_msgSendSuper, 或 objc_msgSendSuper_stret四个方法中选择一个来调用。如果消息是传递给超类&＃xff0c;那么会调用名字带有”Super”的函数&＃xff1b;如果消息返回值是数据结构而不是简单值时&＃xff0c;那么会调用名字带有”stret”的函数。排列组合正好四个方法。

值得一提的是在i386 平台处理返回类型为浮点数的消息时&＃xff0c;需要用到objc_msgSend_fpret函数来进行处理&＃xff0c;这是因为返回类型为浮点数的函数对应的ABI(Application Binary Interface)与返回整型的函数的ABI不兼容。此时objc_msgSend不再适用&＃xff0c;于是objc_msgSend_fpret被派上用场&＃xff0c;它会对浮点数寄存器做特殊处理。不过在PPC 或 PPC64 平台是不需要麻烦它的。

PS&＃xff1a;有木有发现这些函数的命名规律哦&＃xff1f;带“Super”的是消息传递给超类&＃xff1b;“stret”可分为“st”&＃43;“ret”两部分&＃xff0c;分别代表“struct”和“return”&＃xff1b;“fpret”就是“fp”&＃43;“ret”&＃xff0c;分别代表“floating-point”和“return”。

5、动态方法解析

你可以动态地提供一个方法的实现。例如我们可以用&＃64;dynamic关键字在类的实现文件中修饰一个属性&＃xff1a;

&＃64;dynamic propertyName;

这表明我们会为这个属性动态提供存取方法&＃xff0c;也就是说编译器不会再默认为我们生成setPropertyName:和propertyName方法&＃xff0c;而需要我们动态提供。我们可以通过分别重载resolveInstanceMethod:和resolveClassMethod:方法分别添加实例方法实现和类方法实现。因为当Runtime系统在Cache和方法分发表中&＃xff08;包括超类&＃xff09;找不到要执行的方法时&＃xff0c;Runtime会调用resolveInstanceMethod:或resolveClassMethod:来给程序员一次动态添加方法实现的机会。我们需要用class_addMethod函数完成向特定类添加特定方法实现的操作&＃xff1a;

void dynamicMethodIMP(id self, SEL _cmd) {// implementation .... } &＃64;implementation MyClass &＃43; (BOOL)resolveInstanceMethod:(SEL)aSEL {if (aSEL &＃61;&＃61; &＃64;selector(resolveThisMethodDynamically)) {class_addMethod([self class], aSEL, (IMP) dynamicMethodIMP, "v&＃64;:");return YES;}return [super resolveInstanceMethod:aSEL]; } &＃64;end

上面的例子为resolveThisMethodDynamically方法添加了实现内容&＃xff0c;也就是dynamicMethodIMP方法中的代码。其中 “v&＃64;:” 表示返回值和参数&＃xff0c;这个符号涉及 Type Encoding

PS&＃xff1a;动态方法解析会在消息转发机制浸入前执行。如果 respondsToSelector: 或 instancesRespondToSelector:方法被执行&＃xff0c;动态方法解析器将会被首先给予一个提供该方法选择器对应的IMP的机会。如果你想让该方法选择器被传送到转发机制&＃xff0c;那么就让resolveInstanceMethod:返回NO。

备注: 解析类方法等具体做法例&＃xff1a; .h

#import &＃64;interface Student : NSObject &＃43; (void)learnClass:(NSString *) string; - (void)goToSchool:(NSString *) name; &＃64;end

#import "Student.h" #import &＃64;implementation Student &＃43; (BOOL)resolveClassMethod:(SEL)sel {if (sel &＃61;&＃61; &＃64;selector(learnClass:)) {class_addMethod(object_getClass(self), sel, class_getMethodImplementation(object_getClass(self), &＃64;selector(myClassMethod:)), "v&＃64;:");return YES;}return [class_getSuperclass(self) resolveClassMethod:sel]; }&＃43; (BOOL)resolveInstanceMethod:(SEL)aSEL {if (aSEL &＃61;&＃61; &＃64;selector(goToSchool:)) {class_addMethod([self class], aSEL, class_getMethodImplementation([self class], &＃64;selector(myInstanceMethod:)), "v&＃64;:");return YES;}return [super resolveInstanceMethod:aSEL]; }&＃43; (void)myClassMethod:(NSString *)string {NSLog(&＃64;"myClassMethod &＃61; %&＃64;", string); }- (void)myInstanceMethod:(NSString *)string {NSLog(&＃64;"myInstanceMethod &＃61; %&＃64;", string); } &＃64;end

需要深刻理解[self class] 与 object_getClass(self) 甚至 object_getClass([self class]) 的关系&＃xff0c;其实并不难&＃xff0c;重点在于 self 的类型&＃xff1a;

1、当 self 为实例对象时&＃xff0c;[self class] 与 object_getClass(self) 等价&＃xff0c;因为前者会调用后者。 object_getClass([self class]) 得到元类。2、当 self 为类对象时&＃xff0c;[self class] 返回值为自身&＃xff0c;还是 self。 object_getClass(self) 与 object_getClass([self class]) 等价。

6、消息转发

重定向

在消息转发机制执行前&＃xff0c;Runtime 系统会再给我们一次偷梁换柱的机会&＃xff0c;即通过重载- (id)forwardingTargetForSelector:(SEL)aSelector方法替换消息的接受者为其他对象&＃xff1a;

- (id)forwardingTargetForSelector:(SEL)aSelector {if(aSelector &＃61;&＃61; &＃64;selector(mysteriousMethod:)){return alternateObject;}return [super forwardingTargetForSelector:aSelector]; }

毕竟消息转发要耗费更多时间&＃xff0c;抓住这次机会将消息重定向给别人是个不错的选择&＃xff0c;如果此方法返回nil或self,则会进入消息转发机制(forwardInvocation:);否则将向返回的对象重新发送消息。

如果想替换类方法的接受者&＃xff0c;需要覆写 &＃43; (id)forwardingTargetForSelector:(SEL)aSelector方法&＃xff0c;并返回类对象&＃xff1a;

&＃43; (id)forwardingTargetForSelector:(SEL)aSelector {if(aSelector &＃61;&＃61; &＃64;selector(xxx)) {return NSClassFromString(&＃64;"Class name");}return [super forwardingTargetForSelector:aSelector]; }

当动态方法解析不作处理返回NO时&＃xff0c;消息转发机制会被触发。在这时forwardInvocation:方法会被执行&＃xff0c;我们可以重写这个方法来定义我们的转发逻辑&＃xff1a;

- (void)forwardInvocation:(NSInvocation *)anInvocation {if ([someOtherObject respondsToSelector:[anInvocation selector]])[anInvocation invokeWithTarget:someOtherObject];else[super forwardInvocation:anInvocation]; }

该消息的唯一参数是个NSInvocation类型的对象——该对象封装了原始的消息和消息的参数。我们可以实现forwardInvocation:方法来对不能处理的消息做一些默认的处理&＃xff0c;也可以将消息转发给其他对象来处理&＃xff0c;而不抛出错误。

这里需要注意的是参数anInvocation是从哪的来的呢&＃xff1f;其实在forwardInvocation:消息发送前&＃xff0c;Runtime系统会向对象发送methodSignatureForSelector:消息&＃xff0c;并取到返回的方法签名用于生成NSInvocation对象。所以我们在重写forwardInvocation:的同时也要重写methodSignatureForSelector:方法&＃xff0c;否则会抛异常。

当一个对象由于没有相应的方法实现而无法响应某消息时&＃xff0c;运行时系统将通过forwardInvocation:消息通知该对象。每个对象都从NSObject类中继承了forwardInvocation:方法。然而&＃xff0c;NSObject中的方法实现只是简单地调用了doesNotRecognizeSelector:。通过实现我们自己的forwardInvocation:方法&＃xff0c;我们可以在该方法实现中将消息转发给其它对象。

forwardInvocation:方法就像一个不能识别的消息的分发中心&＃xff0c;将这些消息转发给不同接收对象。或者它也可以象一个运输站将所有的消息都发送给同一个接收对象。它可以将一个消息翻译成另外一个消息&＃xff0c;或者简单的”吃掉“某些消息&＃xff0c;因此没有响应也没有错误。forwardInvocation:方法也可以对不同的消息提供同样的响应&＃xff0c;这一切都取决于方法的具体实现。该方法所提供是将不同的对象链接到消息链的能力。

注意&＃xff1a; forwardInvocation:方法只有在消息接收对象中无法正常响应消息时才会被调用。所以&＃xff0c;如果我们希望一个对象将negotiate消息转发给其它对象&＃xff0c;则这个对象不能有negotiate方法。否则&＃xff0c;forwardInvocation:将不可能会被调用。

转发与多继承

转发和继承相似&＃xff0c;可以用于为Objc编程添加一些多继承的效果。就像下图那样&＃xff0c;一个对象把消息转发出去&＃xff0c;就好似它把另一个对象中的方法借过来或是“继承”过来一样。

这使得不同继承体系分支下的两个类可以“继承”对方的方法&＃xff0c;在上图中Warrior和Diplomat没有继承关系&＃xff0c;但是Warrior将negotiate消息转发给了Diplomat后&＃xff0c;就好似Diplomat是Warrior的超类一样。

消息转发弥补了 Objc 不支持多继承的性质&＃xff0c;也避免了因为多继承导致单个类变得臃肿复杂。它将问题分解得很细&＃xff0c;只针对想要借鉴的方法才转发&＃xff0c;而且转发机制是透明的。

转发与继承

尽管转发很像继承&＃xff0c;但是NSObject类不会将两者混淆。像respondsToSelector:和 isKindOfClass:这类方法只会考虑继承体系&＃xff0c;不会考虑转发链。比如上图中一个Warrior对象如果被问到是否能响应negotiate消息&＃xff1a;

if ( [aWarrior respondsToSelector:&＃64;selector(negotiate)] )...

结果是NO&＃xff0c;尽管它能够接受negotiate消息而不报错&＃xff0c;因为它靠转发消息给Diplomat类来响应消息。

如果你为了某些意图偏要“弄虚作假”让别人以为Warrior继承到了Diplomat的negotiate方法&＃xff0c;你得重新实现 respondsToSelector:和 isKindOfClass:来加入你的转发算法&＃xff1a;

- (BOOL)respondsToSelector:(SEL)aSelector {if ( [super respondsToSelector:aSelector] )return YES;else {/* Here, test whether the aSelector message can ** be forwarded to another object and whether that ** object can respond to it. Return YES if it can. */}return NO; }

除了respondsToSelector: 和isKindOfClass:之外&＃xff0c;instancesRespondToSelector:中也应该写一份转发算法。如果使用了协议&＃xff0c;conformsToProtocol:同样也要加入到这一行列中。类似地&＃xff0c;如果一个对象转发它接受的任何远程消息&＃xff0c;它得给出一个methodSignatureForSelector:来返回准确的方法描述&＃xff0c;这个方法会最终响应被转发的消息。比如一个对象能给它的替代者对象转发消息&＃xff0c;它需要像下面这样实现methodSignatureForSelector:&＃xff1a;

- (NSMethodSignature*)methodSignatureForSelector:(SEL)selector {NSMethodSignature* signature &＃61; [super methodSignatureForSelector:selector];if (!signature) {signature &＃61; [surrogate methodSignatureForSelector:selector];}return signature; }

7、方法交换 Method Swizzling

之前所说的消息转发虽然功能强大&＃xff0c;但需要我们了解并且能更改对应类的源代码&＃xff0c;因为我们需要实现自己的转发逻辑。当我们无法触碰到某个类的源代码&＃xff0c;却想更改这个类某个方法的实现时&＃xff0c;该怎么办呢&＃xff1f;可能继承类并重写方法是一种想法&＃xff0c;但是有时无法达到目的。这里介绍的是 Method Swizzling &＃xff0c;它通过重新映射方法对应的实现来达到“偷天换日”的目的。跟消息转发相比&＃xff0c;Method Swizzling 的做法更为隐蔽&＃xff0c;甚至有些冒险&＃xff0c;也增大了debug的难度。

Swizzling原理在Objective-C中调用一个方法&＃xff0c;其实是向一个对象发送消息&＃xff0c;而查找消息的唯一依据是selector的名字。所以&＃xff0c;我们可以利用Objective-C的runtime机制&＃xff0c;实现在运行时交换selector对应的方法实现以达到我们的目的。每个类都有一个方法列表&＃xff0c;存放着selector的名字和方法实现的映射关系。 IMP有点类似函数指针&＃xff0c;指向具体的Method实现

这是参考Mattt大神在NSHipster上的文章自己写的代码。

#import &＃64;implementation UIViewController (Tracking) &＃43; (void)load { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ Class aClass &＃61; [self class]; // When swizzling a class method, use the following:// Class aClass &＃61; object_getClass((id)self);SEL originalSelector &＃61; &＃64;selector(viewWillAppear:); SEL swizzledSelector &＃61; &＃64;selector(xxx_viewWillAppear:); Method originalMethod &＃61; class_getInstanceMethod(aClass, originalSelector); Method swizzledMethod &＃61; class_getInstanceMethod(aClass, swizzledSelector); BOOL didAddMethod &＃61; class_addMethod(aClass, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod)); if (didAddMethod) { class_replaceMethod(aClass, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod)); } else { method_exchangeImplementations(originalMethod, swizzledMethod); } }); } #pragma mark - Method Swizzling - (void)xxx_viewWillAppear:(BOOL)animated { [self xxx_viewWillAppear:animated]; NSLog(&＃64;"viewWillAppear: %&＃64;", self); } &＃64;end

上面的代码通过添加一个Tracking类别到UIViewController类中&＃xff0c;将UIViewController类的viewWillAppear:方法和Tracking类别中xxx_viewWillAppear:方法的实现相互调换。Swizzling 应该在&＃43;load方法中实现&＃xff0c;因为&＃43;load是在一个类最开始加载时调用。dispatch_once是GCD中的一个方法&＃xff0c;它保证了代码块只执行一次&＃xff0c;并让其为一个原子操作&＃xff0c;线程安全是很重要的。

如果类中不存在要替换的方法&＃xff0c;那就先用class_addMethod和class_replaceMethod函数添加和替换两个方法的实现&＃xff1b;如果类中已经有了想要替换的方法&＃xff0c;那么就调用method_exchangeImplementations函数交换了两个方法的 IMP&＃xff0c;这是苹果提供给我们用于实现Method Swizzling的便捷方法。

可能有人注意到了这行:

// When swizzling a class method, use the following: // Class aClass &＃61; object_getClass((id)self); // ... // Method originalMethod &＃61; class_getClassMethod(aClass, originalSelector); // Method swizzledMethod &＃61; class_getClassMethod(aClass, swizzledSelector);

object_getClass((id)self) 与 [self class]返回的结果类型都是 Class,但前者为元类,后者为其本身,因为此时 self 为 Class 而不是实例.注意 [NSObject class] 与 [object class] 的区别&＃xff1a;

&＃43; (Class)class {return self; }- (Class)class {return object_getClass(self); }

PS: 如果类中没有想被替换实现的原方法时&＃xff0c;class_replaceMethod相当于直接调用class_addMethod向类中添加该方法的实现&＃xff1b;否则调用method_setImplementation方法&＃xff0c;types参数会被忽略。method_exchangeImplementations方法做的事情与如下的原子操作等价&＃xff1a;

IMP imp1 &＃61; method_getImplementation(m1); IMP imp2 &＃61; method_getImplementation(m2); method_setImplementation(m1, imp2); method_setImplementation(m2, imp1);

最后xxx_viewWillAppear:方法的定义看似是递归调用引发死循环&＃xff0c;其实不会的。因为[self xxx_viewWillAppear:animated]消息会动态找到xxx_viewWillAppear:方法的实现&＃xff0c;而它的实现已经被我们与viewWillAppear:方法实现进行了互换&＃xff0c;所以这段代码不仅不会死循环&＃xff0c;如果你把[self xxx_viewWillAppear:animated]换成[self viewWillAppear:animated]反而会引发死循环。 PS: 看到有人说&＃43;load方法本身就是线程安全的&＃xff0c;因为它在程序刚开始就被调用&＃xff0c;很少会碰到并发问题&＃xff0c;于是 stackoverflow 上也有大神去掉了dispatch_once 部分。

扩展阅读: 1、iOS---防止UIButton重复点击的三种实现方式 2、Swift Runtime分析&＃xff1a;还像OC Runtime一样吗&＃xff1f;