上一篇我们梳屡了消息的发送和查找流程，我们会发现对应类方法和对象方法的动态解析是分开的，这是为什么呢，原因两点：
1、因为sel方法名是无法区分类方法还是对象方法，所以只有通过判断调用者来区分，所以在转发时候也进行分开，并且类方法和对象方法的方法指针存储的地方是分开的
2、把类方法和对象方法存储地方分开，是为了不把所有东西都放一个地方，类似于不要把鸡蛋放在一个篮子里面，并且有个元类可以解耦合，灵活性更高
一、消息转发流程
通过方法调用流程，我们发现在找不到相应的IMP时候只做了一次_class_resolveMethod消息动态决议来处理异常，但是这不像苹果的风格，假如开发者在_class_resolveClassMethod方法中没处理好怎么办呢？我们一起来探索一下：
- 1、在lookUpImpOrForward方法查找流程中，我们发现当方法找到的时候都会调用log_and_fill_cache函数用来打印并缓存方法指针
然后我们进入到log_and_fill_cache方法里面看看
static void
log_and_fill_cache(Class cls, IMP imp, SEL sel, id receiver, Class implementer)
{
#if SUPPORT_MESSAGE_LOGGING
if (objcMsgLogEnabled) {//只有当objcMsgLogEnabled为yes时候会打印，
bool cacheIt = logMessageSend(implementer->isMetaClass(),
cls->nameForLogging(),
implementer->nameForLogging(),
sel);
if (!cacheIt) return;
}
#endif//缓存方法
cache_fill (cls, sel, imp, receiver);
}
在进到logMessageSend函数里面
bool logMessageSend(bool isClassMethod,
const char *objectsClass,
const char *implementingClass,
SEL selector)
{
char buf[ 1024 ];
// Create/open the log file--创建log日志文件
if (objcMsgLogFD == (-1))//此处为YES
{ //此处我们看到有个文件路径,猜测是日志的文件路径
snprintf (buf, sizeof(buf), "/tmp/msgSends-%d", (int) getpid ());
objcMsgLogFD = secure_open (buf, O_WRONLY | O_CREAT, geteuid());
if (objcMsgLogFD < 0) {
// no log file - disable logging
objcMsgLogEnabled = false;
objcMsgLogFD = -1;
return true;
}
}
// Make the log entry
snprintf(buf, sizeof(buf), "%c %s %s %s\n",
isClassMethod ? '+' : '-',
objectsClass,
implementingClass,
sel_getName(selector));
objcMsgLogLock.lock();
write (objcMsgLogFD, buf, strlen(buf));
objcMsgLogLock.unlock();
// Tell caller to not cache the method
return false;
}
我们发现在logMessageSend函数里面有一个路径，猜测是日志文件的路径，并且当objcMsgLogEnabled = YES时候才打印日志。
我们全局搜一下objcMsgLogEnabled在哪赋值，我们发现，只有在instrumentObjcMessageSends函数里值才等于传进来的值
void instrumentObjcMessageSends(BOOL flag)
{
bool enable = flag;
// Shortcut NOP
if (objcMsgLogEnabled == enable)
return;
// If enabling, flush all method caches so we get some traces
if (enable)
_objc_flush_caches(Nil);
// Sync our log file
if (objcMsgLogFD != -1)
fsync (objcMsgLogFD);
objcMsgLogEnabled = enable;
}
并且全局搜一下instrumentObjcMessageSends发现在.h里面公开出来了，所以我们可以通过在前面加extern方式，将它公开到我们的.m里面
extern void instrumentObjcMessageSends(BOOL flag);
通过逻辑已经函数名，我们可以猜测当objcMsgLogEnabled为YES时候可以将调用一个方法的前前后后发送的所有的消息都打印出来，然后我们调用一个不存在的方法，在调用前将objcMsgLogEnabled改为YES，调用后将objcMsgLogEnabled改回成NO：
instrumentObjcMessageSends(true);
[student saySomething];
instrumentObjcMessageSends(false);
运行完后我们进入到电脑的tem/文件夹下发现一个msgSends-52300文件
打开发现内容为：
我们发现当调用了一个不存在的方法时候，系统分别给我们调用了四个方法，并且每个方法掉两遍：
1、resolveInstanceMethod：
动态消息决议方法，前面我们已经分析过了2、forwardingTargetForSelector：
我们全局搜一下该方法，发现是NSObject实现的一个方法，但并不知道有什么用，我们按住option键，然后点击方法
- (id)forwardingTargetForSelector:(SEL)sel {
return nil;
}
会看到该方法的介绍：
或者按住control + option + command + /调出Search Documentation页面，搜索forwardingTargetForSelector方法：
从方法介绍中我们可以得知：
重写该方法后，方法的返回对象是执行sel的新对象，也就是自己处理不了会将消息转发给别的对象，让返回的对象去执行
该方法效率很高，如果不用此方法会有效率低的方法forwardInvocation给你用
所以我们称forwardingTargetForSelector为快速转发，forwardInvocation为慢速转发
代码
- (id)forwardingTargetForSelector:(SEL)sel {
if ([LGPerson respondsToSelector:sel]) {
return LGPerson.class;
}
return nil;
}
慢速转发 -- forwardInvocation
快速转发如果不行的话，从上面log文件里面我们可以看到系统会调用methodSignatureForSelector方法
通过Search Documentation搜索，我们可以看到该方法的方法介绍：
从介绍我们知道，该方法是给方法和对应的类返回一个方法签名NSMethodSignature：
代码：
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
NSLog(@"%s -- %@",__func__,NSStringFromSelector(aSelector));
if (aSelector == @selector(saySomething)) { // v @ :
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
return [super methodSignatureForSelector:aSelector];
}
我们查看一下NSMethodSignature描述，可以发现
关于方法签名可以看下这篇博客：NSMethodSignature
从上我们可以得知：
- 这个类是通过methodSignatureForSelector方法创建出来
- 然后用来创建NSInvocation对象后，将NSInvocation对象作为参数传给forwardInvocation方法的，
- 然后在forwardInvocation方法里面将消息给能处理该消息的对象，以避免对象调用didNotRecognizeSelector方法导致崩溃的
所以我们还要实现下面这个方法：
- (void)forwardInvocation:(NSInvocation *)anInvocation{
NSLog(@"%s %@",__func__,NSStringFromSelector(anInvocation.selector));
SEL aSelector = [anInvocation selector];
if ([[LGTeacher alloc] respondsToSelector:aSelector])
[anInvocation invokeWithTarget:[LGTeacher alloc]];
else
[super forwardInvocation:anInvocation];
}
这个方法类似于将消息当做事务堆放起来，在这里谁可以操作就在这里面操作，就算不操作也不会崩溃，这里也是防崩溃的最后处理机会
然后我们看下NSObject中forwardInvocation的实现：
+ (void)forwardInvocation:(NSInvocation *)invocation {
[self doesNotRecognizeSelector:(invocation ? [invocation selector] : 0)];
}
- (void)forwardInvocation:(NSInvocation *)invocation {
[self doesNotRecognizeSelector:(invocation ? [invocation selector] : 0)];
}
// Replaced by CF (throws an NSException)
+ (void)doesNotRecognizeSelector:(SEL)sel {
_objc_fatal("+[%s %s]: unrecognized selector sent to instance %p",
class_getName(self), sel_getName(sel), self);
}
// Replaced by CF (throws an NSException)
- (void)doesNotRecognizeSelector:(SEL)sel {
_objc_fatal("-[%s %s]: unrecognized selector sent to instance %p",
object_getClassName(self), sel_getName(sel), self);
}
发现异常是在doesNotRecognizeSelector方法里面抛出的，所以我们重写forwardInvocation方法后，如果不在里面执行父类的方法，程序是不会崩溃的，这个地方也验证了，在上面日志文件里面系统调用了doesNotRecognizeSelector的方法
总结：
当开发者调用了未实现的方法，苹果提供了三个解决途径：
1、resolveInstanceMethod：为发送消息的对象的添加一个IMP，然后再让该对象去处理
2、forwardingTargetForSelector：将该消息转发给能处理该消息的对象
3、methodSignatureForSelector和forwardInvocation：第一个方法生成方法签名，然后创建NSInvocation对象作为参数给第二个方法，
4、然后在第二个方法里面做消息处理，只要在第二个方法里面不执行父类的方法，即使不处理也不会崩溃
代码：
/****************第一流程：动态方法决议*******************/
/// 实例方法动态决议
/// @param sel 发送过来的消息
+(BOOL)resolveInstanceMethod:(SEL)sel{
NSLog(@"%s -- %@",__func__,NSStringFromSelector(sel));
if (sel == NSSelectorFromString(@"by_run1")) {
IMP sayHIMP = class_getMethodImplementation(self, @selector(sayHello1));
Method sayHMethod = class_getInstanceMethod(self, @selector(sayHello1));
const char *sayHType = method_getTypeEncoding(sayHMethod);
//给当前消息接受对象的类的方法名sel添加一个IMP
return class_addMethod(self, sel, sayHIMP, sayHType);
}
return NO;
}
-(void)sayHello1{
NSLog(@"消息转发过来的实例方法");
}
/// 类方法的动态决议
/// @param sel 发送过来的消息
+(BOOL)resolveClassMethod:(SEL)sel{
NSLog(@"%s -- %@",__func__,NSStringFromSelector(sel));
if (sel == NSSelectorFromString(@"by_run1")) {
IMP sayHIMP = class_getMethodImplementation(self, @selector(sayHello1));
Method sayHMethod = class_getClassMethod(self.class, @selector(sayHello1));
const char *sayHType = method_getTypeEncoding(sayHMethod);
//给当前消息接受者的元类的方法名sel添加一个IMP
return class_addMethod(object_getClass(self), sel, sayHIMP, sayHType);
}
return NO;
}
/*************第二步：消息转发********************/
/// 将消息转发给其他对象
/// @param sel 发送过来的消息
- (id)forwardingTargetForSelector:(SEL)sel {
if ([LGPerson respondsToSelector:sel]) {
//假如LGPerson类可以处理该 消息，那就将消息转发给LGPerson类对象
return LGPerson.class;
}
return nil;
}
/*************第三步：消息分发***************/
// 慢速转发 -- 类似漂流瓶
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
NSLog(@"%s -- %@",__func__,NSStringFromSelector(aSelector));
if (aSelector == @selector(saySomething)) { // v @ :
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
return [super methodSignatureForSelector:aSelector];
}
//将消息分到到这个方法里面，然后随意处理
- (void)forwardInvocation:(NSInvocation *)anInvocation{
NSLog(@"%s %@",__func__,NSStringFromSelector(anInvocation.selector));
// 事情 - 事务 - 秘书 - 失效
// 系统本质
SEL aSelector = [anInvocation selector];
if ([[LGTeacher alloc] respondsToSelector:aSelector]){
[anInvocation invokeWithTarget:[LGTeacher alloc]];
} else{
[super forwardInvocation:anInvocation];
}
}
以上三步，只要完成其中任意一步，都不会发生崩溃
附加一个消息转发流程图：
