Objective-C的Method Swizzle、对象模型、消息机制、消息转发的详解
先来引入一个话题
当项目有一个需求是，要对所有的UIViewController的viewWillApear:animte方法进行监听，而项目很大，.m的控制器文件很多，而且该项目已经开发好了，对这个方法监听不可能进入到控制器里一个一个的添加
此时Objective-C有一个运行时的方法特别好的解决这种问题，当然该方法不是说只能解决上述这种情况
比如，做统计，需要对系统的库的某个方法或多个方法进行监听，添加一些自定义的功能在此方法里，这就会用到运行时的Method swizzle
先来了解一下Objective-C语言的发展
本链接详细介绍了Objective-C语言
http://baike.baidu.com/link?url=3Jqn-qSTvdupQz8aCRcjBFuzy7eznY4Ko_fUgKtD6D6MCSfRR7m61wZz4yAkm5XP0heedN1rrC8YduCTdnl41_#reference-[1]-459423-wrap
Objective-C是扩充C的面向对象的编程语言，它是一门动态语言，它是使用C写成一套非常强大的运行时库，采用了smalltalk语言的消息机制，而且编译OC语言的编译器是LLVM(Low Level Virtual Machine 底层虚拟机），所有OC可以兼容C/C++语法
Objective-C
优点
1.完美支持C/C++
2.消息机制（采用smalltalk）
3.强大的运行时系统
4.所有的对象推迟到运行期间才定义类型
5.内存管理的方式（引用计数）
缺点
1.由于是动态语言，很多异常从运行期间抛出来，不是很容易的定位错误位置
2.没有GC（垃圾收集器），所以需要程序员理解内存管理，避免引起内存的循环引用，导致内存泄露
以下讲一个NSArray的案例，把lastObject与自定义的myLastObject方法交换，当项目中使用lastObject方法时，就相当于使用myLastObject方法，并且lastObject方法本身的功能还是存在的
代码：
#import <Foundation/Foundation.h>
@interface NSArray (Swizzle)
@end
@implementation NSArray (Swizzle)
- (id)myLastObject
{
id ret = [self myLastObject];
NSLog(@" 这是替换后的方法被打印了 *********** myLastObject ");
return ret;
}
@end使用
#import <Foundation/Foundation.h>
#import <objc/objc.h>
#import <objc/message.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
//1.这个替换操作只需要执行一遍
//原始NSArray方法 lastObject
Method ori_Method = class_getInstanceMethod([NSArray class], @selector(lastObject));
//替换后的方法 myLastObject
Method my_Method = class_getInstanceMethod([NSArray class], @selector(myLastObject));
//执行替换操作
method_exchangeImplementations(ori_Method, my_Method);
//2.以后使用NSArray的时候调用 lastObject方法就相当于执行myLastObject
//当再次使用NSArray的时候，就相当于执行了mylastObject方法
NSArray *array = @[@"0",@"1",@"2",@"3"];
NSString *string = [array lastObject];
NSLog(@"最终打印 : %@",string);
NSArray * arr = [array copy];
NSLog(@"arr最后 一个是：%@", [arr lastObject]);
}
return 0;
}这是打印结果
疑问：[self myLastObject]; 这不就造成递归了吗？
原理：当把lastObject和myLastObject交换，实际交换的是方法的IMP(后面会讲到)，当我们执行[self lastObject];时，实际上就是执行了lastObject(本身的作用)和myLastObject里注入的新内容，如下图：
method_exchangeImplementations(method *,method*)方法方法就是调换IMP
下面在举一个例子
代码：
#import <UIKit/UIKit.h>
@interface UIViewController (Swizzle)
@end
#import <objc/message.h>
@implementation UIViewController (Swizzle)
+ (void)load
{
NSString *strClass = NSStringFromClass(self.class);
NSLog(@"strClass=%@", strClass);
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalMethod = @selector(viewWillAppear:);
SEL destinateMethod = @selector(zr_viewWillAppear:);
Method originMethod = class_getInstanceMethod(class, originalMethod);
Method destMethod = class_getInstanceMethod(class, destinateMethod);
IMP imp = method_getImplementation(destMethod);
const char * conchar = method_getTypeEncoding(destMethod);
BOOL swizzleMethod = class_addMethod(class, originalMethod, imp, conchar);
if(swizzleMethod){
class_replaceMethod(class, destinateMethod, method_getImplementation(originMethod), method_getTypeEncoding(originMethod));
} else {
method_exchangeImplementations(originMethod, destMethod);
}
});
}
- (void)zr_viewWillAppear:(BOOL)animte
{
[self zr_viewWillAppear:animte];
NSLog(@"**** 替换后的方法 *****viewWillAppear:%@", self);
}
@end
执行
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
UIViewController *view = [[UIViewController alloc] init];
}
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
}
@end
结果是：
和上面的解释一样，读者自己领悟
这么好用的Method Swizzle有什么好处和坏处了
使用 Method Swizzling 编程就好比切菜时使用锋利的刀，一些人因为担心切到自己所以害怕锋利的刀具，可是事实上，使用钝刀往往更容易出事，而利刀更为安全。
Method swizzling 可以帮助我们写出更好的，更高效的，易维护的代码。但是如果滥用它，也将会导致难以排查的bug。
讨论
这里是一些 Method Swizzling的陷阱：- Method swizzling is not atomic
- Changes behavior of un-owned code
- Possible naming conflicts
- Swizzling changes the method's arguments
- The order of swizzles matters
- Difficult to understand (looks recursive)
- Difficult to debug
详细的讨论以下地址 有说明
http://blog.csdn.net/yiyaaixuexi/article/details/9374411
以下说说Objective-C的对象模型
我们都知道OC有强大的运行时系统，那么OC的对象模型是怎么一会事儿了？
C语言没有类，但是有结构体（是个程序员都知道
）
OC的很多库都是直接或者间接集成子NSObject类（即是协议也是类）
一个类，可以有多个属性，可以有多个方法（含类方法和实例方法）
OC的每个对象都有一个isa指针, 简单的意思isa指针指向这个类，
id是万能类型，它的运行时类型是objc_object
Class的运行时类型是objc_class
它们都是结构体
以下是一个类的构成部分在运行时
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
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;
} OBJC2_UNAVAILABLE;
我们可以在runtime.h头文件中看到这个
isa 每个类都有一个isa指针
super_class 父类是谁
instance_size 本类的实例大小
objc_ivar_list 本类的所有属性在这个列表中
objc_method_list 本类所有的方法在这个列表中
objc_cache 本类缓存
objc_protocal_list 本类所有协议列表
所以对于一个OC的类在运行时系统时是在objc_class这个结构体中很清楚的描述着
下面说说消息机制
学过其他的语言的同学都知道，除了Objective-C语言调用方法是发送消息机制外，基本上主流的语言都是通过实例调用方法
举个例子:
C#调用一个方法
object.console();
OC调用一个方法
[object console];
写法上有小点儿区别，原理可大不相同
C#是直接调用实例对象方法
OC是发送一个消息，一个消息是一个SEL类型，方法名就是一个字符串，编译时发送消息会转换成objc_msgSend方法
这个方法需提供两个参数，接收对象和消息名称
objc_msgSend(receiver, selector)
所有整个发送消息的过程都在这个方法里进行了
前面说过，每个对象都有一个isa指针代表着所属的类，每个类都有方法列表和属性列表，当接收到消息是，系统首先会根据isa指针查找相应的类，然后在这个类的方法列表去寻找对应的方法（这个方法可能在本类也可能在父类），如果找到了，那就会正常执行，如果没有找到，就会抛出异常
下面说说消息转发
当Objective-C发送消息时，在runtime去当前类和父类中去寻找对应的方法，找不到时，不会马上崩溃，而是可以做消息转发处理，如果没有做消息转发处理，那就会奔溃
有三种方式处理消息转发
第一种：
+ (BOOL)resolveInstanceMethod:(SEL)sel; 实例方法的消息转发
+ (BOOL)resolveClassMethod:(SEL)sel; 类方法的消息转发
第二种：
- (id)forwardingTargetForSelector:(SEL)aSelector;
第三种
先生成方法签名，在通过forwardInvocation来实现消息转发
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector;
- (void)forwardInvocation:(NSInvocation *)anInvocation
第一种：
+ (BOOL)resolveInstanceMethod:(SEL)sel; 实例方法的消息转发
+ (BOOL)resolveClassMethod:(SEL)sel; 类方法的消息转发
#import <Foundation/Foundation.h>
#import <objc/message.h>
@interface Person : NSObject
- (void)run;
@end
@implementation Person
void run(id self, SEL _cmd){
NSLog(@"%@ %s", self, sel_getName(_cmd));
}
//第一种：该方法是是实例方法的转发
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
//在这里给run方法添加一个实现
if(sel == @selector(run)){
//v@:意思是 v表示void无返回值，@表示self, :表示参数_cmd
class_addMethod(self, sel, (IMP)run, "v@:");
}
return [super resolveInstanceMethod:sel];
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
//1.实例方法run被声明了，但是没有实现
//被调用，会抛出异常, 若实现了消息转发，则会调用消息转发定义的方法
Person *p = [[Person alloc] init];
[p run];
}
return 0;
}
<span style="font-size:18px;"></span>
<span style="font-size:18px;"></span>
第二种消息转发
- (id)forwardingTargetForSelector:(SEL)aSelector;
#import <Foundation/Foundation.h>
#import <objc/message.h>
@interface Car : NSObject
@end
@implementation Car
- (void)run
{
NSLog(@"通过Person类的消息转发，调用Car类的方法");
}
@end
@interface Person : NSObject
- (void)run;
@end
@implementation Person
//第二种，消息转发
- (id)forwardingTargetForSelector:(SEL)aSelector
{
if(aSelector == @selector(run)){
return [[Car alloc] init];
} else {
return nil;
}
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
//第二种消息转发方式
//快速转发路径
Person *p = [[Person alloc] init];
[p run];
}
return 0;
}
第三种消息转发
先生成方法签名，在通过forwardInvocation来实现消息转发
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector;
- (void)forwardInvocation:(NSInvocation *)anInvocation
#import <Foundation/Foundation.h>
#import <objc/message.h>
@interface Car : NSObject
- (void)run;
@end
@implementation Car
- (void)run
{
NSLog(@"Car类中的run方法，第三种方法通过签名实现转发");
}
@end
@interface Person : NSObject
- (void)run;
@end
@implementation Person
//第三种，用来生成方法签名，然后这个签名就是给forwardInvocation中的参数NSInvocation调用的，用来转发消息
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
if([NSStringFromSelector(aSelector) isEqualToString:@"run"]){
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
SEL selector = [anInvocation selector];
Car *car = [[Car alloc] init];
if([car respondsToSelector:selector]){
[anInvocation invokeWithTarget:car];
}
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
//第三种, 先生成一个方法签名，然后通过forwardInvocation中的参数来实现转发消息
Person *p = [[Person alloc] init];
[p run];
}
return 0;
}
总结消息转发：当已声明方法，未实现方式时，可以通过消息转发来处理，避免直接奔溃，
消息转发有以上三种方式来处理，如果未实现以上三种转发方式，那就真的奔溃了，亲~~