iOS开发AOP框架Aspects源码分析

Aspects解决的问题

Aspects是AOP（面向切面编程）思想在iOS下OC的实现。Aspects可以用于hook函数，让函数执行一些副操作。为嵌入不同函数中的功能相同的操作，每类功能相同的操作可以抽取出一个切面。

OOP针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。
AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。

基本原理

OC上，每个类都是这样一个结构体：

struct objc_class {
  struct objc_class * isa;
  const char *name;
  ….
  struct objc_method_list **methodLists; /*方法链表*/
};

其中 methodList 方法链表里存储的是 Method类型：

typedef struct objc_method *Method;
typedef struct objc_ method {
  SEL method_name;
  char *method_types;
  IMP method_imp;
};

Method 保存了一个方法的全部信息，包括 SEL 方法名，type各参数和返回值类型，IMP该方法具体实现的函数指针。

通过 Selector 调用方法时，会从methodList 链表里找到对应Method结构体进行调用，这个 methodList上的的元素是可以动态替换的，可以把某个Selector对应的函数指针IMP替换成新的，也可以拿到已有的某个 Selector 对应的函数指针IMP，让另一个Selector 跟它对应。

简单版实现思路

hook前

hook后

直接调用method_exchangeImplementations即可交替两个selector对应的函数IMP指针, 具体应用例如在UIViewController的category里, 写一个- (void)viewDidAppear等生命周期相关的方法, 从切面对控制器的生命周期进行干涉
但这种方法要求在编译时必须写好替换的函数, 如果你在需要在运行时获取一个类的method, 并动态地进行重定向和包装参数, 这个方法就显得局限了.

Aspects的原理


id objc_msgSend(id self, SEL op, ...) {
    if (!self) return nil;
    IMP imp = class_getMethodImplementation(self->isa, SEL op);
    imp(self, op, ...); //调用这个函数，伪代码...
}

//查找IMP
IMP class_getMethodImplementation(Class cls, SEL sel) {
    if (!cls || !sel) return nil;
    IMP imp = lookUpImpOrNil(cls, sel);
    if (!imp) return _objc_msgForward; //_objc_msgForward 用于消息转发
    return imp;
}

当我们对一个类对用它无法识别的selector时, 会抛出unrecogniezed selector的异常, 但是从runtime的伪代码中可以看到, 当一个类根据selector找不到对应的IMP函数指针时, 会返回_objc_msgForward这个函数指针, 而并不是直接就抛出异常, 而Aspects正是利用_objc_msgForward去进行方法重定向的

Aspects的思路

当对一个类调用无法识别selector时, 其实并不是马上就会触发异常, 而是会走进动态方法决议的流程, 如下图

动态方法决议流程

resolvedInstanceMethod: 适合给类/对象动态添加一个相应的实现，
forwardingTargetForSelector：适合将消息转发给其他对象处理,
forwardInvocation：是里面最灵活，最能符合需求的。

在这三个方法里, 都可以有机会重新去处理这个无法识别的selector, forwardingTargetForSelector中, 可以将selector交给别的对象处理, 如果仍然无法处理, 则进入最后一步forwardInvocation, 在此可以获得该次调用的所有参数和调用对象, 并随意重新组装. 在此依然无法处理方法, 才会抛出异常.
而Aspects正是利用其中最灵活的forwardInvocation进行封装的.
首先 , 将类的forwardInvocation的IMP替换为到Aspects里的__ASPECTS_ARE_BEING_CALLED__, 在该方法中统一处理hook过来的方法的逻辑处理
然后 , 在methodList链表里添加一个带有别名的selector (例如hook的是viewDidAppaer, 则会生成一个aspects_viewDidAppear的函数添加到该类的methodlist里), 并指向原来的IMP. 调用此别名selector, 其实相当于调用原函数
最后 , 原selector的IMP则会统一指向_objc_msgForward, 启动消息转发的流程, 并在__ASPECTS_ARE_BEING_CALLED__ 做截获处理

截获消息

核心代码分析一: hook part, 部署好方法之间的挂钩

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
    NSCParameterAssert(selector);
    
    //将class的forwardInvocation:方法hook走
    Class klass = aspect_hookClass(self, error);
    Method targetMethod = class_getInstanceMethod(klass, selector);
    IMP targetMethodIMP = method_getImplementation(targetMethod);
    if (aspect_isMsgForwardIMP(targetMethodIMP) == NO) {
        // Make a method alias for the existing method implementation, it not already copied.
        const char *typeEncoding = method_getTypeEncoding(targetMethod);
        
        //方法别名, 将原来的IMP放到此selector中, 并添加到class的method列表中
        SEL aliasSelector = aspect_aliasForSelector(selector);
        if (![klass instancesRespondToSelector:aliasSelector]) {
            __unused BOOL addedAlias = class_addMethod(klass, aliasSelector, method_getImplementation(targetMethod), typeEncoding);
            NSCAssert(addedAlias, @"Original implementation for %@ is already copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), klass);
        }

        //将原来的IMP替换为直接调用forwardInvocation:
        class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);
        AspectLog(@"Aspects: Installed hook for -[%@ %@].", klass, NSStringFromSelector(selector));
    }
}

该函数为swizzle的核心方法, 完成以下几件事

将原selector的各种属性, 封装到AspectsContainer中, 以aliasSelector作为key储存在字典中
aspect_hookClass将类的-forwardInvocation:函数统一hook到__ASPECTS_ARE_BEING_CALLED__里处理
抽出原selector的原IMP, 并生成一个带有别名的selector (例:原selector为viewWillAppear: , 则生成一个aspects_viewWillAppear:) , 将别名selector与原IMP挂钩, 添加到类的methodList中
替换类的methodList, 将原selector的IMP替换成-forwardInvocation:, 当调用原selector时, 将直接启动消息转发流程

核心代码分析: implement part, 实现转发后函数最终执行的逻辑

static void __ASPECTS_ARE_BEING_CALLED__(__unsafe_unretained NSObject *self, SEL selector, NSInvocation *invocation) {
    NSCParameterAssert(self);
    NSCParameterAssert(invocation);
    SEL originalSelector = invocation.selector;
    SEL aliasSelector = aspect_aliasForSelector(invocation.selector);
    invocation.selector = aliasSelector;
    AspectsContainer *objectContainer = objc_getAssociatedObject(self, aliasSelector);
    AspectsContainer *classContainer = aspect_getContainerForClass(object_getClass(self), aliasSelector);
    AspectInfo *info = [[AspectInfo alloc] initWithInstance:self invocation:invocation];
    NSArray *aspectsToRemove = nil;

    // Before hooks.
    aspect_invoke(classContainer.beforeAspects, info);
    aspect_invoke(objectContainer.beforeAspects, info);

    // Instead hooks.
    BOOL respondsToAlias = YES;
    if (objectContainer.insteadAspects.count || classContainer.insteadAspects.count) {
        aspect_invoke(classContainer.insteadAspects, info);
        aspect_invoke(objectContainer.insteadAspects, info);
    }else {
        Class klass = object_getClass(invocation.target);
        do {
            if ((respondsToAlias = [klass instancesRespondToSelector:aliasSelector])) {
                [invocation invoke];
                break;
            }
        }while (!respondsToAlias && (klass = class_getSuperclass(klass)));
    }

    // After hooks.
    aspect_invoke(classContainer.afterAspects, info);
    aspect_invoke(objectContainer.afterAspects, info);

    // If no hooks are installed, call original implementation (usually to throw an exception)
    if (!respondsToAlias) {
        invocation.selector = originalSelector;
        SEL originalForwardInvocationSEL = NSSelectorFromString(AspectsForwardInvocationSelectorName);
        if ([self respondsToSelector:originalForwardInvocationSEL]) {
            ((void( *)(id, SEL, NSInvocation *))objc_msgSend)(self, originalForwardInvocationSEL, invocation);
        }else {
            [self doesNotRecognizeSelector:invocation.selector];
        }
    }

    // Remove any hooks that are queued for deregistration.
    [aspectsToRemove makeObjectsPerformSelector:@selector(remove)];
}

该函数为swizzle后, 实现新IMP统一处理的核心方法 , 完成一下几件事

处理调用逻辑, 有before, instead, after, remove四种option
将block转换成一个NSInvocation对象以供调用, 如何实现, 后面会有详述
从AspectsContainer根据aliasSelector取出对象, 并组装一个AspectInfo, 带有原函数的调用参数和各项属性, 传给外部的调用者 (在这是block) .
调用完成后销毁带有removeOption的hook逻辑, 将原selector挂钩到原IMP上, 删除别名selector

block与NSInvocation的转换

在转发时, 需要调用的是NSInvocation, 而在hook的时候缓存起来的是block, 所以需要将block转换成NSInvocation.

static NSMethodSignature *aspect_blockMethodSignature(id block, NSError **error) {
    AspectBlockRef layout = (__bridge void *)block;
    if (!(layout->flags & AspectBlockFlagsHasSignature)) {
        NSString *description = [NSString stringWithFormat:@"The block %@ doesn't contain a type signature.", block];
        AspectError(AspectErrorMissingBlockSignature, description);
        return nil;
    }
    NSLog(@"AspectBlockFlagsHasSignature = %lu", (unsigned long)AspectBlockFlagsHasSignature);
    NSLog(@"AspectBlockFlagsHasCopyDisposeHelpers = %lu", (unsigned long)AspectBlockFlagsHasCopyDisposeHelpers);

    void *desc = layout->descriptor;
    desc += 2 * sizeof(unsigned long int);
    if (layout->flags & AspectBlockFlagsHasCopyDisposeHelpers) {
        desc += 2 * sizeof(void *);
    }
    
    if (!desc) {
        NSString *description = [NSString stringWithFormat:@"The block %@ doesn't has a type signature.", block];
        AspectError(AspectErrorMissingBlockSignature, description);
        return nil;
    }
    const char *signature = (*(const char **)desc);
    return [NSMethodSignature signatureWithObjCTypes:signature];
}

NSInvocation的创建, 需要signature, argument.
signature可以从block中转换过来, 而参数则可以从原来的AspectInfo对象中取出来做转换
void *desc = layout->descriptor这个指针就是用于获取block的签名了, 根据clang的源码, 签名位于descriptor结构体的第三个变量, 所以将指针移动两个单位.
flag用于判断block的具体类型BLOCK_HAS_COPY_DISPOSE, 代表这个block是否有捕获外部参数, 如果有捕获, 则descriptor中会多插入两个变量, 所以需要将desc指针再移动两个单位

枚举

block的结构体

与JSPatch的兼容问题

JSPatch先hook的情况

selector之间的转换

转发消息方法的转换

Aspects先hook的情况