iOS中Method swizzling的使用防止数组越界

前言

在iOS开发中，我们在非常非常多的地方用到了数组。而关于数组，有很多需要注意和优化的细节，需要我们潜入到下面，去了解。在开发过程中，我们遇到的最多的崩溃之一就是数组越界。针对这个问题，今天就让我们来详细分析如何处理数组越界导致的崩溃吧。

  在iOS中NSNumber、NSArray、NSDictionary等这些类都是类簇(Class Clusters)，一个NSArray的实现可能由多个类组成。
  所以如果想对NSArray进行Swizzling，必须获取到其“真身”进行Swizzling，直接对NSArray进行操作是无效的。

下面列举了NSArray和NSDictionary本类的类名，可以通过Runtime函数取出本类。

在使用了NSArray的alloc方法来获取实例时，该方法首先会分类一个属于某类的实例，此实例充当“占位数组”。该数组稍后会转为另一个类的实例，而那个类则是NSArray的实体子类。

话不多说，看代码：

NSArray *placeholder = [NSArray alloc];
NSArray *arr1 = [[NSArray alloc] init];
NSArray *arr2 = [[NSArray alloc] initWithObjects:@0, nil];
NSArray *arr3 = [[NSArray alloc] initWithObjects:@0, @1, nil];
NSArray *arr4 = [[NSArray alloc] initWithObjects:@0, @1, @2, nil];
NSLog(@"placeholder: %s", object_getClassName(placeholder));
NSLog(@"arr1: %s", object_getClassName(arr1));
NSLog(@"arr2: %s", object_getClassName(arr2));
NSLog(@"arr3: %s", object_getClassName(arr3));
NSLog(@"arr4: %s", object_getClassName(arr4));
NSMutableArray *mPlaceholder = [NSMutableArray alloc];
NSMutableArray *mArr1 = [[NSMutableArray alloc] init];
NSMutableArray *mArr2 = [[NSMutableArray alloc] initWithObjects:@0, nil];
NSMutableArray *mArr3 = [[NSMutableArray alloc] initWithObjects:@0, @1, nil];
NSLog(@"mPlaceholder: %s", object_getClassName(mPlaceholder));    
NSLog(@"mArr1: %s", object_getClassName(mArr1));
NSLog(@"mArr2: %s", object_getClassName(mArr2));
NSLog(@"mArr3: %s", object_getClassName(mArr3));

打印结果为：

2019-03-01 17:27:45.453903+0800 NSArrayTest[38098:24226779] placeholder: __NSPlaceholderArray
2019-03-01 17:27:45.454085+0800 NSArrayTest[38098:24226779] arr1: __NSArray0
2019-03-01 17:27:45.454170+0800 NSArrayTest[38098:24226779] arr2: __NSSingleObjectArrayI
2019-03-01 17:27:45.454243+0800 NSArrayTest[38098:24226779] arr3: __NSArrayI
2019-03-01 17:27:45.454315+0800 NSArrayTest[38098:24226779] arr4: __NSArrayI
2019-03-01 17:27:45.454459+0800 NSArrayTest[38098:24226779] mPlaceholder: __NSPlaceholderArray
2019-03-01 17:27:45.454558+0800 NSArrayTest[38098:24226779] mArr1: __NSArrayM
2019-03-01 17:27:45.454636+0800 NSArrayTest[38098:24226779] mArr2: __NSArrayM
2019-03-01 17:27:45.454749+0800 NSArrayTest[38098:24226779] mArr3: __NSArrayM

我们可以看到，不管创建的事可变还是不可变的数组，在alloc之后得到的类都是__NSPlaceholderArray。而当我们init一个不可变的空数组之后，得到的是__NSArray0；如果有且只有一个元素，那就是 __NSSingleObjectArrayI；有多个元素的，叫做 __NSArrayI；init出来一个可变数组的话，都是 __NSArrayM。

下面我们实现了防止NSArray因为调用objectAtIndex:方法，取下标时数组越界导致的崩溃：

NSObject+Swizzling.m

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

@implementation NSObject (Swizzling)

/**
 交换两个对象方法的实现
 
 @param srcClass 被替换方法的类
 @param srcSel 被替换的方法编号
 @param swizzledSel 用于替换的方法编号
 */
+ (void)ff_swizzleInstanceMethodWithSrcClass:(Class)srcClass
                                      srcSel:(SEL)srcSel
                                 swizzledSel:(SEL)swizzledSel{
    
    Method srcMethod = class_getInstanceMethod(srcClass, srcSel);
    Method swizzledMethod = class_getInstanceMethod(srcClass, swizzledSel);
    if (!srcClass || !srcMethod || !swizzledMethod) return;
    
    //加一层保护措施，如果添加成功，则表示该方法不存在于本类，而是存在于父类中，不能交换父类的方法,否则父类的对象调用该方法会crash；添加失败则表示本类存在该方法
    BOOL addMethod = class_addMethod(srcClass, srcSel, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
    if (addMethod){
        //添加方法实现IMP成功后，再将原有的实现替换到swizzledMethod方法上，从而实现方法的交换，并且未影响到父类方法的实现
        class_replaceMethod(srcClass, swizzledSel, method_getImplementation(srcMethod), method_getTypeEncoding(srcMethod));
    }else{
        //添加失败，调用交互两个方法的实现
        method_exchangeImplementations(srcMethod, swizzledMethod);
    }
}

@end

NSArray+safeArray.m

#import "NSArray+safeArray.h"
#import <objc/runtime.h>
#import "NSObject+Swizzling.h"

@implementation NSArray (safeArray)

+ (void)load {
    [super load];
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        //NSArray的真身
        NSString *initStr = @"__NSArray0";
        NSString *singleStr = @"__NSSingleObjectArrayI";
        NSString *oneMoreStr = @"__NSArrayI";
        
        //替换数组的 objectAtIndex 方法
        NSString *tmpStr = @"objectAtIndex:";
        NSString *tmpZeroStr = @"safe_zeroObjectAtIndex:";
        NSString *tmpSingleStr = @"safe_singleObjectAtIndex:";
        NSString *tmpOneMoreStr = @"safe_objectAtIndex:";
        
        //替换数组的 objectAtIndexedSubscript 方法
        NSString *tmpSubscriptStr = @"objectAtIndexedSubscript:";
        NSString *tmpSafeSubscriptStr = @"safe_objectAtIndexedSubscript:";
        
        [NSObject ff_swizzleInstanceMethodWithSrcClass:NSClassFromString(initStr) srcSel:NSSelectorFromString(tmpStr) swizzledSel:NSSelectorFromString(tmpZeroStr)];
        [NSObject ff_swizzleInstanceMethodWithSrcClass:NSClassFromString(singleStr) srcSel:NSSelectorFromString(tmpStr) swizzledSel:NSSelectorFromString(tmpSingleStr)];
        [NSObject ff_swizzleInstanceMethodWithSrcClass:NSClassFromString(oneMoreStr) srcSel:NSSelectorFromString(tmpStr) swizzledSel:NSSelectorFromString(tmpOneMoreStr)];
        [NSObject ff_swizzleInstanceMethodWithSrcClass:NSClassFromString(@"") srcSel:NSSelectorFromString(tmpSubscriptStr) swizzledSel:NSSelectorFromString(tmpSafeSubscriptStr)];
    });
}

/**
 取出NSArray 第index个 值 对应 __NSArray0
 
 @param index 索引 index
 @return 返回值
 */
- (id)safe_zeroObjectAtIndex:(NSUInteger)index {
    if (index >= self.count){
        return nil;
    }
    return [self safe_zeroObjectAtIndex:index];
}

/**
 取出NSArray 第index个 值 对应 __NSSingleObjectArrayI
 
 @param index 索引 index
 @return 返回值
 */
- (id)safe_singleObjectAtIndex:(NSUInteger)index {
    if (index >= self.count){
        return nil;
    }
    return [self safe_singleObjectAtIndex:index];
}

/**
 取出NSArray 第index个 值 对应 __NSArrayI
 
 @param index 索引 index
 @return 返回值
 */
- (id)safe_objectAtIndex:(NSUInteger)index {
    if (index >= self.count){
        return nil;
    }
    return [self safe_objectAtIndex:index];
}

/**
 objectAtIndexedSubscript
 取出NSArray 第index个 值 对应 __NSArrayI
 
 @param idx 索引 idx
 @return 返回值
 */
- (id)safe_objectAtIndexedSubscript:(NSUInteger)idx {
    if (idx >= self.count){
        return nil;
    }
    return [self safe_objectAtIndexedSubscript:idx];
}

@end

上面通过Method swizzling来hook拦截越界时的情况并处理来解决数组越界崩溃问题。