iOS开发AOP框架Aspects源码分析

作者: Ryannnn | 来源:发表于2016-11-16 11:57 被阅读829次

    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的情况
    selector之间的转换
    转发消息方法的转换
    下图为JSPatch的hook路径
    JSPatch路径
    JSPatch先hook的情况会导致AspectsOption的先后顺序失效, 只能before地执行, 但保证能安全执行, 是目前两者融合使用时的一个折中的解决办法
    这篇文章中提供了一个修改Aspect源码的方法, 但我在修改后仍然遇到bug, 有兴趣的同学可以去看看

    结语

    从JSPatch的兼容性问题可以看出, hook方案虽然非常强大, 但不同第三方库之间并不相互兼容. 尤其大部分的核心逻辑都集中在了-forwardInvocation:上, 一旦hook的情况多了, 此类bug的表现将十分诡异而且难以排查.
    此类AOP库在整个项目中最好只能使用一个, 如果项目中有自己写swizzle的需求, 最好停留在sel和IMP一一对应的方式, 而不去触碰-forwardInvocation:的消息转发, 便可避免这类bug的发生

    相关文章

      网友评论

      本文标题:iOS开发AOP框架Aspects源码分析

      本文链接:https://www.haomeiwen.com/subject/kufrpttx.html