Aspects的源码分析问题点

最近又看了遍Aspects源码，可以说每一次细看都可以收获到一些东西吧！这次解决了我之前的几个疑惑，具体分析下吧！

一、之前说过，通过创建子类来实现，那么是怎样让方法调用定位到子类去呢？
我们知道有个isa指针，就是控制去哪个类寻找IMP，所以最终是通过改变isa指针来实现。我们重新分析下Aspects创建子类的方法：

static Class aspect_hookClass(NSObject *self, NSError **error) {
    NSCParameterAssert(self);
    Class statedClass = self.class;
    Class baseClass = object_getClass(self);
    NSString *className = NSStringFromClass(baseClass);

    // Already subclassed hook forwardInvocation这个方法
    if ([className hasSuffix:AspectsSubclassSuffix]) {
        return baseClass;

        // We swizzle a class object, not a single object.
    }else if (class_isMetaClass(baseClass)) {
        return aspect_swizzleClassInPlace((Class)self);
        // Probably a KVO'ed class. Swizzle in place. Also swizzle meta classes in place.
        //如果不等，就证明是self是类，不是对象
    }else if (statedClass != baseClass) {
        return aspect_swizzleClassInPlace(baseClass);
    }

    // Default case. Create dynamic subclass.
    const char *subclassName = [className stringByAppendingString:AspectsSubclassSuffix].UTF8String;
    Class subclass = objc_getClass(subclassName);

    //创建子类
    if (subclass == nil) {
        //继承与类baseClass的类
        subclass = objc_allocateClassPair(baseClass, subclassName, 0);
        if (subclass == nil) {
            NSString *errrorDesc = [NSString stringWithFormat:@"objc_allocateClassPair failed to allocate class %s.", subclassName];
            AspectError(AspectErrorFailedToAllocateClassPair, errrorDesc);
            return nil;
        }

        //hook forwardInvocation方法
        aspect_swizzleForwardInvocation(subclass);
        aspect_hookedGetClass(subclass, statedClass);
        aspect_hookedGetClass(object_getClass(subclass), statedClass);
        objc_registerClassPair(subclass);
    }
    //与object_getClass对应，object_getClass是获得isa指针，那么object_setClass是重定向isa执行subclass
    object_setClass(self, subclass);
    return subclass;
}

前面的判断是，如果是传入的是类，那么就直接进行hook，如果传入的是对象，就创建子类，然后hook子类的方法。也许这里创建子类也不是必要的吧，因为我直接调用：

return aspect_swizzleClassInPlace(baseClass);

好像也是可以的。
如果创建了子类，那么就得考虑重定向问题。我们在代码最后发现：

object_setClass(self, subclass);

与object_getClass对应，object_getClass是获得isa指针，那么object_setClass是重定向isa执行subclass。所以这就实现了重定向。

aspect_hookedGetClass(subclass, statedClass);
aspect_hookedGetClass(object_getClass(subclass), statedClass);

因为返回的是子类了，如果调用subclass.class或object_getClass(subclass).class，又让它返回的是原来的类。可能这样做是为了避免一些特殊的情况吧。

二、为什么没实现methodSignatureForSelector方法，最后也可以调用forwardInvocation
这里面，涉及到：

class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);

我之前认为aspect_getMsgForwardIMP是空实现，没实现后，就会最后走到forwardInvocation这个方法。但我又发现源码好像只实现了forwardInvocation方法，没实现methodSignatureForSelector返回签名的方法，按我的理解，没有签名的话是会崩溃的啊。
所以，答案是，我对aspect_getMsgForwardIMP理解有误。下面我通过实验验证一下。

@interface MyModel : NSObject

- (void)gainMoney:(NSString *)name;

@end
@implementation MyModel

- (void)gainMoney:(NSString *)name
{
    NSLog(@"MyModel money");
}

+ (BOOL)resolveInstanceMethod:(SEL)sel      //实现没实现的方法，有实现方法的话就不会走下面的方法了
{
    NSLog(@".........1...........");
    return [super resolveInstanceMethod:sel];
}
//消息转发
- (id)forwardingTargetForSelector:(SEL)aSelector        //没有重新实现方法（要是正确的实现方法），就会调用这个
{
    NSLog(@".........2...........");
    return nil;
}

//另外一种消息转发，手动生成方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector //没正确指向方法，就调用这个
{
    NSLog(@".........3...........");
    return [super methodSignatureForSelector:aSelector];
}
//生成签名成功后，就会调用下面的方法 NSInvocation *invocation是通过NSMethodSignature得到的
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
    NSLog(@".........4...........");
    NSString *str = @"";
    //参数
    [anInvocation getArgument:&str atIndex:2];
    NSLog(@"第一个参数：%@",str);
}
@end

上面定义了 MyModel类，下面是测试代码，使用的Aspects的源码部分，用于把gainMoney指向_objc_msgForward。

- (void)testMsgChange
{
    MyModel *model = [[MyModel alloc] init];
    //获得方法
    Method targetMethod = class_getInstanceMethod(model.class, @selector(gainMoney:));
    //获取原来方法参数
    const char *typeEncoding = method_getTypeEncoding(targetMethod);
    //重新指向方法，把方法直接指向forwardInvocation
    class_replaceMethod(model.class, @selector(gainMoney:), _objc_msgForward, typeEncoding);
    [model gainMoney:@"123"];
}

结果如下：
2018-08-16 11:50:30.997663+0800 SummaryTest[3068:2232826] .........2...........
2018-08-16 11:50:30.997844+0800 SummaryTest[3068:2232826] .........3...........
2018-08-16 11:50:30.997992+0800 SummaryTest[3068:2232826] .........4...........
2018-08-16 11:50:30.998127+0800 SummaryTest[3068:2232826] 第一个参数：123

可以看到，原方法指向_objc_msgForward，不是指向空，最后是可以走到forwardInvocation函数的。