来源网络

什么是面向切面编程

Aspect Oriented Programming(AOP)，面向切面编程，是一个比较热门的话题。AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。

主要用来处理一些具有横切性质的系统性服务，如日志记录、权限管理、缓存、对象池管理等，AOP 已经成为一种非常常用的解决方案。

比如说我们在实现权限验证的时候，需要在每个业务的执行前对权限进行相应的判断，从而导致了大量的重复代码，不利于模块的复用。AOP则通过将每个业务的公共行为进行抽离，封装成一个可复用的模块，这个模块就叫做『切面』。

什么是Aspects

Aspects是一个轻量级的面向切面编程的库。它主要提供了三个切入点:before(在原始的方法前执行)/instead(替换原始的方法执行)/after(在原始的方法后执行,默认),通过Runtime消息转发实现Hook，同时这也会带来一定的负担，所以它不适合循环多次调用的方法。

Aspects扩展了NSObject类，对外提供如下两个方法:

///为指定的类的当前方法的before/instead/after切入点添加block代码+ (id)aspect_hookSelector:(SEL)selector                      withOptions:(AspectOptions)options                       usingBlock:(id)block                            error:(NSError **)error;///为指定实例的当前方法的before/instead/after切入点添加block代码- (id)aspect_hookSelector:(SEL)selector                      withOptions:(AspectOptions)options                       usingBlock:(id)block                            error:(NSError **)error;

Aspects初始化工作核心部分的解析

aspect_add方法:

static id aspect_add(id self, SEL selector, AspectOptions options, id block, NSError **error) {    NSCParameterAssert(self);    NSCParameterAssert(selector);    NSCParameterAssert(block);    //声明AspectIdentifier实例    __block AspectIdentifier *identifier = nil;    aspect_performLocked(^{        //判断当前XX方法是否允许被Hook,1.'retain'、'release'、'autorelease'、'forwardInvocation'这几个方法是不被允许的，所谓的黑名单。2.如果方法是dealloc,则他的切入点必须是Before。3.判断当前实例对象和类对象是否能响应方法4.是否是类对象，如果是则判断继承体系中方法是否已经被Hook,而实例则不用。        if (aspect_isSelectorAllowedAndTrack(self, selector, options, error)) {            //获得当前aspects__XX方法的AspectsContainer容器            AspectsContainer *aspectContainer = aspect_getContainerForObject(self, selector);            //初始化AspectIdentifier变量,方法内部通过toll-free bridged获取Block方法签名，并判断其兼容性            identifier = [AspectIdentifier identifierWithSelector:selector object:self options:options block:block error:error];            if (identifier) {                //通过options选项分别添加到容器中的beforeAspects,insteadAspects,afterAspects这三个数组                [aspectContainer addAspect:identifier withOptions:options];                //HookSelector的过程和HookClass的过程                aspect_prepareClassAndHookSelector(self, selector, error);            }        }    });    return identifier;}

HookClass过程:

static Class aspect_hookClass(NSObject *self, NSError **error) {    NSCParameterAssert(self);    Class statedClass = self.class;    Class baseClass = object_getClass(self);    NSString *className = NSStringFromClass(baseClass);    // 如果类名有_Aspects_前缀，说明Class已被Hook    if ([className hasSuffix:AspectsSubclassSuffix]) {        return baseClass;        // 判断是否为类对象，如果是，则直接在当前类中进行swizzle    }else if (class_isMetaClass(baseClass)) {        return aspect_swizzleClassInPlace((Class)self);        // 判断是否为KVO过的对象，因为KVO的对象ISA指针会指向一个中间类，则直接在这个中间类中进行swizzle    }else if (statedClass != baseClass) {        return aspect_swizzleClassInPlace(baseClass);    }    // 默认则会动态创建一个子类    const char *subclassName = [className stringByAppendingString:AspectsSubclassSuffix].UTF8String;    Class subclass = objc_getClass(subclassName);    if (subclass == nil) {        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;        }        //实现替换当前类forwardInvocation方法的实现为__ASPECTS_ARE_BEING_CALLED__        aspect_swizzleForwardInvocation(subclass);        //实现当前类的isa指针指向原生的类        aspect_hookedGetClass(subclass, statedClass);        //实现当前类的元类的isa指针指向原生的类        aspect_hookedGetClass(object_getClass(subclass), statedClass);        //注册当前类        objc_registerClassPair(subclass);    }    //将当前对象的isa指针指向刚生成的类    object_setClass(self, subclass);    return subclass;}

HookSelector过程

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {    NSCParameterAssert(selector);    //HookClass过程    Class klass = aspect_hookClass(self, error);    //此时的klass类为刚创建的具有_Aspects_后缀的子类，在创建的时候指定类他的父类，所以我们可以获取到selector这个方法    Method targetMethod = class_getInstanceMethod(klass, selector);    IMP targetMethodIMP = method_getImplementation(targetMethod);    //判断是否为消息转发    if (!aspect_isMsgForwardIMP(targetMethodIMP)) {        //获得原生方法的类型编码        const char *typeEncoding = method_getTypeEncoding(targetMethod);        SEL aliasSelector = aspect_aliasForSelector(selector);        if (![klass instancesRespondToSelector:aliasSelector]) {            //为klass添加aspects__XX方法，方法的实现为原生方法的实现。            __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);        }        // 将原生方法实现替换为_objc_msgForward或_objc_msgForward_stret，用来实现消息转发        class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);        AspectLog(@'Aspects: Installed hook for -[%@ %@].', klass, NSStringFromSelector(selector));    }}

Aspects执行工作核心部分的解析

当我们正式向某个接受者发送消息的时候,会进行消息转发，而之前HookClass的过程当中我们已经对forwardInvocation的实现替换为了__ASPECTS_ARE_BEING_CALLED__

static void __ASPECTS_ARE_BEING_CALLED__(__unsafe_unretained NSObject *self, SEL selector, NSInvocation *invocation) {    NSCParameterAssert(self);    NSCParameterAssert(invocation);    //获取原始方法XX    SEL originalSelector = invocation.selector;    //获取含有前缀的方法aspects_XX    SEL aliasSelector = aspect_aliasForSelector(invocation.selector);    //替换Sel    invocation.selector = aliasSelector;    //获得实例对象容器    AspectsContainer *objectContainer = objc_getAssociatedObject(self, aliasSelector);    //获得类对象容器    AspectsContainer *classContainer = aspect_getContainerForClass(object_getClass(self), aliasSelector);    //初始化AspectInfo，传入self、invocation参数    AspectInfo *info = [[AspectInfo alloc] initWithInstance:self invocation:invocation];    NSArray *aspectsToRemove = nil;    // 执行before切入点的调用    aspect_invoke(classContainer.beforeAspects, info);    aspect_invoke(objectContainer.beforeAspects, info);    // 执行Instead切入点的调用，判断当前insteadAspects是否有数据，如果没有数据则判断当前继承链是否能响应aspects_XX方法,如果能，则直接调用,此时的aspects_XX则为原生的实现。     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切入点的调用    aspect_invoke(classContainer.afterAspects, info);    aspect_invoke(objectContainer.afterAspects, info);    // 若Hook未被正确执行，则调用原生消息转发。    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方法    [aspectsToRemove makeObjectsPerformSelector:@selector(remove)];}

执行block的代码

- (BOOL)invokeWithInfo:(id)info {    //根据blockSignature获取Invocation    NSInvocation *blockInvocation = [NSInvocation invocationWithMethodSignature:self.blockSignature];    //获取原生方法的Invocation    NSInvocation *originalInvocation = info.originalInvocation;    //获取blockInvocation参数个数    NSUInteger numberOfArguments = self.blockSignature.numberOfArguments;    // 判断blockInvocation参数个数是否大于originalInvocation参数个数    if (numberOfArguments > originalInvocation.methodSignature.numberOfArguments) {        AspectLogError(@'Block has too many arguments. Not calling %@', info);        return NO;    }    // blockInvocation给索引为1的参数赋值    if (numberOfArguments > 1) {        [blockInvocation setArgument:&info atIndex:1];    }    //当所以大于1的时候进行遍历，把原生的参数值赋值给相应的blockInvocation中的参数    void *argBuf = NULL;    for (NSUInteger idx = 2; idx < numberofarguments;="" idx++)="" {="" const="" char="" *type="[originalInvocation.methodSignature" getargumenttypeatindex:idx];="" nsuinteger="" argsize;="" nsgetsizeandalignment(type,="" &argsize,="" null);="" if="" (!(argbuf="reallocf(argBuf," argsize)))="" {="" aspectlogerror(@'failed="" to="" allocate="" memory="" for="" block="" invocation.');="" return="" no;="" }="" [originalinvocation="" getargument:argbuf="" atindex:idx];="" [blockinvocation="" setargument:argbuf="" atindex:idx];="" }="" 执行block="" [blockinvocation="" invokewithtarget:self.block];="" if="" (argbuf="" !="NULL)" {="" free(argbuf);="" }="" return="">

流程图:

流程图

著作权归作者所有

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。