iOS崩溃处理机制：Unrecognized Selector

unrecognized selector类型的crash，通常是因为一个对象调用了一个不属于它方法的方法导致的。而我们可以从方法调用的过程中，寻找到避免程序崩溃的突破口。

方法调用的过程是哪样的呢？

方法调用的过程--调用实例方法
1.在对象的<缓存方法列表> 中去找要调用的方法，找到直接执行其实现。
2.对象的<缓存方法列表> 里没找到，就去<类的方法列表>里找，找到了就执行其实现。
3.还没找到，说明这个类自己没有了，就会通过isa去向其父类里执行1、2。
4.如果找到了根类还没找到，那么就是没有了，会转向一个拦截调用的方法，可以自己在拦截调用方法里面做一些处理。
5.如果没有在拦截调用里做处理，那么就会报错崩溃。

方法调用的过程--调用类方法
1.在类的<缓存方法列表> 中去找要调用的方法，找到直接执行其实现。
2.类的<缓存方法列表> 里没找到，就去<meta类的方法列表>里找，找到了就执行其实现。
3.还没找到，说明这个类自己没有了，就会通过isa去meta类的父类里执行1、2。
4.如果找到了根meta类还没找到，那么就是没有了，会转向一个拦截调用的方法，可以自己在拦截调用方法里面做一些处理。
5.如果没有在拦截调用里做处理，那么就会报错崩溃。

从上面的方法调用过程可以看出，在找不到调用的方法程序崩溃之前，我们可以通过重写NSObject方法进行拦截调用，阻止程序的crash。这里面就用到了消息的转发机制：

消息的转发机制

由上图我们不难发现，runtime提供了3种方式去补救：
1：调用resolveInstanceMethod给个机会让类添加这个实现这个函数
2：调用forwardingTargetForSelector让别的对象去执行这个函数
3：调用forwardInvocation(函数执行器)灵活的将目标函数以及其他形式执行。
如果都不行，系统才会调用doesNotRecognizeSelector抛出异常。

既然可以补救，我们完全也可以利用消息转发机制来做文章，但是我们选择哪一步比较合适呢？
1：resolveInstanceMethod需要在类的本身动态的添加它本身不存在的方法，这些方法对于该类本身来说是冗余的
2：forwardInvocation可以通过NSInvocation的形式将消息转发给多个对象，但是其开销比较大，需要创建新的 NSInvocation对象，并且forwardInvocation的函数经常被使用者调用来做消息的转发选择机制，不适合多次重写
3：forwardingTargetForSelector可以将消息转发给一个对象，开销较小，并且被重写的概率较低，适合重写

对于NSObject方法的重写，我们可以分为以下几步：
第一步：创建消息接受类，处理消息。
第二步：为NSObject添加分类，拦截NSObject的forwardingTargetForSelector:方法。并在分类中的自定义xz_forwardingTargetForSelector:方法中，将消息转发给该消息接受类。

解决方法：

1、创建一个消息接受类。（继承至NSObject）

当调用方法的消息转发给该类后，该类也没有这个方法，回调用resolveInstanceMethod:方法，在消息接受类中重写方法，返回YES，表明该消息已经处理，这样就不会崩溃了。
重写的resolveInstanceMethod:方法中一定要有动态添加方法的处理，不然会继续走消息转发的流程，从而造成死循环。

#import <Foundation/Foundation.h>


@interface XZUnrecognizedSelectorSolveObject : NSObject

@property (nonatomic, weak) NSObject *objc;

@end

#Import "XZUnrecognizedSelectorSolveObject.h"
#import <objc/runtime.h>

@interface XZUnrecognizedSelectorSolveObject ()

@end

@implementation XZUnrecognizedSelectorSolveObject

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    // 如果没有动态添加方法的话，还会调用forwardingTargetForSelector:方法，从而造成死循环
    class_addMethod([self class], sel, (IMP)addMethod, "v@:@");
    return YES;
}

id addMethod(id self, SEL _cmd) {
    NSLog(@"WOCrashProtector: unrecognized selector: %@", NSStringFromSelector(_cmd));
    return 0;
}

@end

2、为NSObject添加分类，拦截NSObject的forwardingTargetForSelector:方法。

实现原理：在分类中自定义一个xz_forwardingTargetForSelector:方法，然后替换掉系统的forwardingTargetForSelector:方法

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface NSObject (SelectorCrash)

+ (void)xz_enableSelectorProtector;

@end

NS_ASSUME_NONNULL_END

#import "NSObject+SelectorCrash.h"
#import <objc/runtime.h>
#import "NSObject+XZSwizzle.h"
#Import "XZUnrecognizedSelectorSolveObject.h"

@implementation NSObject (SelectorCrash)

+ (void)xz_enableSelectorProtector {
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSObject *object = [[NSObject alloc] init];
        [object xz_instanceSwizzleMethod:@selector(forwardingTargetForSelector:) replaceMethod:@selector(xz_forwardingTargetForSelector:)];
    });
}

- (id)xz_forwardingTargetForSelector:(SEL)aSelector {
    // 判断某个类是否有某个实例方法，有则返回YES，否则返回NO
    if (class_respondsToSelector([self class], @selector(forwardInvocation:))) {
        // 有forwardInvocation实例方法
        IMP impOfNSObject = class_getMethodImplementation([NSObject class], @selector(forwardInvocation:));
        IMP imp = class_getMethodImplementation([self class], @selector(forwardInvocation:));
        
        if (imp != impOfNSObject) {
            return nil;
        }
    }
    
    // 新建桩类转发消息
    XZUnrecognizedSelectorSolveObject *solveObject = [XZUnrecognizedSelectorSolveObject new];
    solveObject.objc = self;
    return solveObject;
}

@end

交换方法代码如下：

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface NSObject (XZSwizzle)

/**
 对类方法进行拦截并替换
 
 @param originalSelector 原有类方法
 @param replaceSelector 自定义类替换方法
 */
+ (void)xz_classSwizzleMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector;

/**
 对类方法进行拦截并替换
 
 @param kClass 具体的类
 @param originalSelector 原有类方法
 @param replaceSelector 自定义类替换方法
 */
+ (void)xz_classSwizzleMethodWithClass:(Class _Nonnull)kClass orginalMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector;



/**
 对实例方法进行拦截并替换
 
 @param originalSelector 原有实例方法
 @param replaceSelector 自定义实例替换方法
 */
- (void)xz_instanceSwizzleMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector;

/**
 对实例方法进行拦截并替换
 
 @param kClass 具体的类
 @param originalSelector 原有实例方法
 @param replaceSelector 自定义实例替换方法
 */
- (void)xz_instanceSwizzleMethodWithClass:(Class _Nonnull)kClass orginalMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector;

@end

NS_ASSUME_NONNULL_END

#import "NSObject+XZSwizzle.h"
#import <objc/runtime.h>

@implementation NSObject (XZSwizzle)


/**
 对类方法进行拦截并替换
 
 @param originalSelector 类原有方法
 @param replaceSelector 自定义替换方法
 */
+ (void)xz_classSwizzleMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector {
    Class class = [self class];
    
    [self xz_classSwizzleMethodWithClass:class orginalMethod:originalSelector replaceMethod:replaceSelector];
}

/**
 对类方法进行拦截并替换
 
 @param kClass 具体的类
 @param originalSelector 原有类方法
 @param replaceSelector 自定义类替换方法
 */
+ (void)xz_classSwizzleMethodWithClass:(Class _Nonnull)kClass orginalMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector {
    
    // Method中包含IMP函数指针，通过替换IMP，使SEL调用不同函数实现
    Method originalMethod = class_getClassMethod(kClass, originalSelector);
    Method replaceMethod = class_getClassMethod(kClass, replaceSelector);
    
    // 获取MetaClass (交换、添加等类方法需要用metaClass)
    Class metaClass = objc_getMetaClass(NSStringFromClass(kClass).UTF8String);
    
    // class_addMethod:如果发现方法已经存在，会失败返回，也可以用来做检查用,我们这里是为了避免源方法没有实现的情况;如果方法没有存在,我们则先尝试添加被替换的方法的实现
    BOOL didAddMethod = class_addMethod(metaClass, originalSelector, method_getImplementation(replaceMethod), method_getTypeEncoding(replaceMethod));
    
    if (didAddMethod) {
        // 添加成功（原方法未实现，为防止crash，需要将刚添加的原方法替换）
        class_replaceMethod(metaClass, replaceSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
    } else {
        // 添加失败（原本就有原方法, 直接交换两个方法）
        method_exchangeImplementations(originalMethod, replaceMethod);
    }
}


/**
 对实例方法进行拦截并替换
 
 @param originalSelector 原有实例方法
 @param replaceSelector 自定义实例替换方法
 */
- (void)xz_instanceSwizzleMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector {
    Class class = [self class];
    
    [self xz_instanceSwizzleMethodWithClass:class orginalMethod:originalSelector replaceMethod:replaceSelector];
}

/**
 对实例方法进行拦截并替换
 
 @param kClass 具体的类
 @param originalSelector 原有实例方法
 @param replaceSelector 自定义实例替换方法
 */
- (void)xz_instanceSwizzleMethodWithClass:(Class _Nonnull)kClass orginalMethod:(SEL _Nonnull)originalSelector replaceMethod:(SEL _Nonnull)replaceSelector {
    
    Method originalMethod = class_getInstanceMethod(kClass, originalSelector);
    Method replaceMethod = class_getInstanceMethod(kClass, replaceSelector);
    
    // class_addMethod:如果发现方法已经存在，会失败返回，也可以用来做检查用,我们这里是为了避免源方法没有实现的情况;如果方法没有存在,我们则先尝试添加被替换的方法的实现
    BOOL didAddMethod = class_addMethod(kClass, originalSelector, method_getImplementation(replaceMethod), method_getTypeEncoding(replaceMethod));
    
    if (didAddMethod) {
        // 添加成功（原方法未实现，为防止crash，需要将刚添加的原方法替换）
        class_replaceMethod(kClass, replaceSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
    } else {
        // 添加失败（原本就有原方法, 直接交换两个方法）
        method_exchangeImplementations(originalMethod, replaceMethod);
    }
}

@end

调用：

在AppDelegate调用[NSObject xz_enableSelectorProtector]; 就可以了。