代码中我们难免会遇到未实现方法的情况(比如动使用方法名称字符串冬天调用方法的情况)，能不能避免unrecognized selector这种crash呢。答案当然是肯定的，苹果给我们提供了消息的动态转发机制。下面我们来探究消息的转发。
首先我们回到前面的lookUpImpOrForward方法。在方法查找过程中如果没有找到方法的实现，就会走到下面的一段代码：
// No implementation found. Try method resolver once.
if (resolver && !triedResolver) {
runtimeLock.unlock();
_class_resolveMethod(cls, sel, inst);
runtimeLock.lock();
// Don't cache the result; we don't hold the lock so it may have
// changed already. Re-do the search from scratch instead.
triedResolver = YES;
goto retry;
}
其中调用了_class_resolveMethod方法，继续跟踪：
void _class_resolveMethod(Class cls, SEL sel, id inst)
{
if (! cls->isMetaClass()) {
// try [cls resolveInstanceMethod:sel]
_class_resolveInstanceMethod(cls, sel, inst);
}
else {
// try [nonMetaClass resolveClassMethod:sel]
// and [cls resolveInstanceMethod:sel]
_class_resolveClassMethod(cls, sel, inst);
if (!lookUpImpOrNil(cls, sel, inst,
NO/*initialize*/, YES/*cache*/, NO/*resolver*/))
{
_class_resolveInstanceMethod(cls, sel, inst);
}
}
}
如果不是元类，那么就是实例方法，否则就是类方法。
我们先进入实例方法的流程查看：
static void _class_resolveInstanceMethod(Class cls, SEL sel, id inst)
{
if (! lookUpImpOrNil(cls->ISA(), SEL_resolveInstanceMethod, cls,
NO/*initialize*/, YES/*cache*/, NO/*resolver*/))
{
// Resolver not implemented.
return;
}
BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
bool resolved = msg(cls, SEL_resolveInstanceMethod, sel);
// Cache the result (good or bad) so the resolver doesn't fire next time.
// +resolveInstanceMethod adds to self a.k.a. cls
IMP imp = lookUpImpOrNil(cls, sel, inst,
NO/*initialize*/, YES/*cache*/, NO/*resolver*/);
if (resolved && PrintResolving) {...}
}
我们看到以上代码中调用了两次lookUpImpOrNil。
第一次是针对resolveInstanceMethod，如果没有实现就直接返回了，所以OC底层肯定给我们实现了该方法。我们在源码中搜索到了该方法的默认实现：
+ (BOOL)resolveInstanceMethod:(SEL)sel {
return NO;
}
然后下面给对象发送了resolveInstanceMethod消息，实际上此时resolveInstanceMethod方法已经可以在缓存中查到了。
第二次是针对我们自己未实现的方法。此时又开始查找目标方法的实现。 所以我们可以感觉到前面的resolveInstanceMethod方法应该是为我们提供了实现方法的机会。我们只需要在自己的对象中去实现resolveInstanceMethod方法，然后在这个方法中动态的添加目标方法的实现。这样的话在下面的lookUpImpOrNil方法查找中就能找到我们动态添加的方法实现了。
我们在我们的对象中添加resolveInstanceMethod的实现：
- (void)sayHello{
NSLog(@"%s",__func__);
}
+ (BOOL)resolveInstanceMethod:(SEL)sel{
if (sel == @selector(saySomething)) {
IMP sayHIMP = class_getMethodImplementation(self, @selector(sayHello));
Method sayHMethod = class_getInstanceMethod(self, @selector(sayHello));
const char *sayHType = method_getTypeEncoding(sayHMethod);
return class_addMethod(self, sel, sayHIMP, sayHType);
}
return [super resolveInstanceMethod:sel];
}
这样处理后，假设我们未实现saySomething方法，然后调用了saySomething方法。就会调用sayHello方法，而不会直接unrecognized selector崩溃了。
上面我们讲的是实例方法的动态决议，下面我们再看下类方法的动态决议。
在_class_resolveMethod方法中，如果是类方法的话，就会走下面的代码：
_class_resolveClassMethod(cls, sel, inst);
if (!lookUpImpOrNil(cls, sel, inst,
NO/*initialize*/, YES/*cache*/, NO/*resolver*/))
{
// 对象方法 决议
_class_resolveInstanceMethod(cls, sel, inst);
}
其中_class_resolveClassMethod对应着实例方法中的_class_resolveInstanceMethod。但是下面还可能会调用_class_resolveInstanceMethod。为什么类方法动态解析还会调用_class_resolveInstanceMethod呢？我们可以联想下ISA的走位图，类方法存在元类中，那么类方法的查找顺序就：
元类---父元类---根元类---NSObject。所以不管是实例方法还是类方法，最后都会找到NSObject。系统可能是为了容错处理，如果我们没有在_class_resolveClassMethod方法中动态添加未实现的类方法，就会继续走一遍_class_resolveInstanceMethod。
既然所有的方法(不管是实例方法还是类方法)，如果未实现的话，都会走_class_resolveInstanceMethod方法。那么我们就可以在NSObject的该方法中做统一的处理。例如可以在此处做一个统一的容错处理。比如我们可以在这里根据不同类别的方法(可以用方法前缀来区分)，做出不同的容错处理(可以跳转到不同容错界面)。但是在这里统一做容错处理也有些弊端：
1、所以的处理都是在NSObject中统一处理，耦合度比较高；
2、如果具体的类实现了该方法，那么就会别拦截，走不到NSObject的这个方法了。
消息转发
如果方法的动态解析没有处理的话，就会进入消息的转发阶段，消息转发又分为快速转发阶段和慢速转发阶段。
1、快速转发：转给另外一个对象去处理；
- (id)forwardingTargetForSelector:(SEL)aSelector{
if (aSelector == @selector(saySomething)) {
return [OtherObjc alloc];
}
return [super forwardingTargetForSelector:aSelector];
}
如果没有实现方法的动态解析，接下来就会走到上面这个方法。这个方法需要返回一个对象，由该对象去实现该方法。这样就会转发给OtherObjc对象，去调用OtherObjc对象的saySomething方法。
@interface OtherObjc : NSObject
@end
@implementation OtherObjc
- (void)saySomething{
NSLog(@"%s",__func__);
}
@end
2、慢速转发：将所有未实现的方法封装成NSInvocation，放在统一的一个地方，你可以选择进行处理，也可以选择不处理。
首先我们需要实现methodSignatureForSelector,只有实现了该方法，并且在该方法中返回对应的签名，后面才会走forwardInvocation方法。
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
if (aSelector == @selector(saySomething)) { // v @ :
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}
return [super methodSignatureForSelector:aSelector];
}
上面的方法返回了v@:的方法签名，该签名表示方法返回值为void,并且有一个参数。
然后就会调用下面的方法
- (void)forwardInvocation:(NSInvocation *)anInvocation{
// 系统本质
SEL aSelector = [anInvocation selector];
if ([[LGTeacher alloc] respondsToSelector:aSelector])
[anInvocation invokeWithTarget:[LGTeacher alloc]];
else
[super forwardInvocation:anInvocation];
}
我们通过Invocation可以获取到方法的相关信息，然后针对不同方法进行相应的处理。可以将不同类别的方法交于不同的对象去处理。如果在这里我们只是实现了forwardInvocation方法，但是没有针对未实现的Selector做出相应的处理。调用未实现的方法的时候，也是不会报错“unRecognize selector”的。
疑问一
我们调用一个未实现的OC实例方法saySomething，可以通过在resolveInstanceMethod方法中添加实现，从而实现OC方法的动态解析。该方法只会调用一次。
+ (BOOL)resolveInstanceMethod:(SEL)sel{
NSLog(@"===== %s - %@",__func__,NSStringFromSelector(sel));
if (sel == @selector(saySomething)) {
NSLog(@"说话了");
IMP sayHIMP = class_getMethodImplementation(self, @selector(sayHello));
Method sayHMethod = class_getInstanceMethod(self, @selector(sayHello));
const char *sayHType = method_getTypeEncoding(sayHMethod);
return class_addMethod(self, sel, sayHIMP, sayHType);
}
return [super resolveInstanceMethod:sel];
}
但是如果实现了resolveInstanceMethod:方法。但是没有在该方法中添加方法saySomething的实现，就会调用两次resolveInstanceMethod:方法，为什么呢？
resolveInstanceMethod:实现内容如下
+ (BOOL)resolveInstanceMethod:(SEL)sel{
NSLog(@"==== %s - %@",__func__,NSStringFromSelector(sel));
return [super resolveInstanceMethod:sel];
}
我们可以推理，如果在resolveInstanceMethod:方法中添加了方法saySomething实现，然后就会返回YES，此时resolveInstanceMethod:调用了一次。而如果未添加方法saySomething实现，就会第二次调用resolveInstanceMethod:，那么第二次的调动肯定是在后面的流程。后面的流程是什么呢？
首先下面调用了[super resolveInstanceMethod:sel];,我们可以跟踪该方法的调用是在第二次调用的前面还是后面，经过追踪，是在第二次调用的前面。然后我们继续追踪第二次调用的时机。
下面的流程就是消息的动态转发流程，
- (id)forwardingTargetForSelector:(SEL)aSelector {
NSLog(@"=====%s - %@",__func__,NSStringFromSelector(aSelector));
return [super forwardingTargetForSelector:aSelector];
}
- (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__);
[super forwardInvocation:anInvocation];
}
使用以上代码流程继续跟踪，发现第二次调用的时机位于methodSignatureForSelector和forwardInvocation之间。
然后再怎么追踪第二次方法的调用呢？只能通过汇编了。我们运行项目，此时会crash，因为我们此时我们没有在动态解析中添加方法实现。crash后我们可以看到崩溃前的调用堆栈，类似下图
image.png
然后我们就可以去右边的汇编代码中查找具体的汇编流程了。但是最后还是没有找到有用的信息，只能猜测是因为没有开源，所以编译器隐藏了这部分实现。
网友评论