iOS开发马甲包中的AOP利器 – Aspects 源码分析(一)

作者: IOS开发子 分类: iOS开发 发布时间: 2018-09-18 18:44

AOP简介

AOP全名为 Aspect Oriented Programming– 面向切面编程。AOPOOPObject-Oriented Programing – 面向对象编程)的补充和完善。 OOP引入封装继承多态等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

AOP技术其实是对OOP设计的对象,利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即方面。所谓“方面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。

举个例子,我们需要统计用户的行为,看下用户对app的兴趣分布热点,此时通常需要在多个控制器的 viewWillAppear:方法中加如处理统计的代码,这些代码都是与业务逻辑无关的,而且分散在多个模块中,此时我们可利用AOP技术,把这些重复、分散的代码提取出来成为一个独立的模块。这样既减少了系统的重复代码,也降低了模块的耦合度。好处还是十分明显的。

Aspects初步认识及使用

这是iOS开发中实现AOP的一个轻量级框架 , 它就提供了两个接口实现AOP ,这两个方法都是 NSObject的分类方法

//为某个所有类 对象的selector 进行切面  添加AOP实现
+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;

//为某个对象的selector 进行切面  添加AOP实现
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;

例如我要为所有继承自UIViewController的对象的viewWillAppear:添加切面实现

[UIViewController aspect_hookSelector:@selector(viewDidAppear:) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo  , BOOL animated ){
   NSLog(@"成功进行了切面");
 }error:NULL];

在程序执行完上面这句代码后,你就成功的所有控制器的viewWillAppear :方法hook, 在方法执行完原实现后,都会执行上面的Block中的打印 ,方法中返回的协议<AspectToken>对象,可用于移除你添加的hook(调用 协议对象的 -remove方法)。而Aspect的实例方法- (id<AspectToken>)aspect_hookSelector:(SEL)selector withOptions:(AspectOptions)options usingBlock:(id)block error:(NSError **)error; 是对单一对象的某个方法进行hook , 效果跟例子中的类方法差不多,这里就不在过多介绍。

Aspects内部实现分析

Apects框架涉及的底层只是比较多,建议先了解清楚一下几只知识点后再看源码实现可能会比较容易理解。

  • Block的内部结构及实现原理
  • runtime的消息转发机制
  • OC中对象的 isa 指针 + KVO的实现原理

由于这个框架的设计中,对象间关系的关系比较复杂,这里我先简单介绍一下,Aspects中定义的类的作用。

AspectInfo :用于在定义block时作为其第一个参数 , 并且原方法发起调用时 , 作为封装调用参数(实参,用NSInvocation包装)的对象。

AspectIdentifier :用于封装定义hook时传进来的block,方法的调用者target , selector ,切面时机选项(AspectOptions – 位移枚举) , 以及在调用完添加hook方法时作为返回值返回给调用者 ,遵守协议AspectToken 用于移除hook , 执行hook事件的执行处理

AspectTracker : 用于追踪或记录曾经hock过的Class(不包活实例对象的hock) , 以防止对同一个集继承体系的Class对同一个实例方法进行重复hook

AspectsContainer : 用三数组(beforeAspects , insteadAspects , afterAspects)分别记录对应时机进行 hock 的标识对象 AspectIdentifier ,为hock 提供数据存储及支持。

AspectToken : 用于移除hook的一个协议(只有一个方法 :-remove) , AspectIdentifier就是遵循该协议的类

先大概了解框架进行hook时对类的处理宏观处理图解,更有利于对细节处理的理解及分析。 下图是对某个Class的Selector进行了hook处理后的类内变化情况。

” alt=”Aspects分析.png” data-src=”https://user-gold-cdn.xitu.io/2018/9/12/165cd0686d8e7562?imageView2/0/w/1280/h/960/format/webp/ignore-error/1″ data-width=”787″ data-height=”628″ />

Asepcts的核心步骤:把要进行hook的selector的IMP直接更换为runtime中的消息转发的IMP (_objc_msgForward_objc_msgForward_stret) , 让外界调用改selector的时候直接进入到消息转发 (注意:这里的原理与热修复框架JSPatch的原理是一样的,因此这两个框架的共存是有问题的),从而调用到方法-forwardInvocation:方法中,此时Class的-forwardInvocation :的实现已经被框架替换为自定义函数 __ASPECTS_ARE_BEING_CALLED__ , 从而成功进行hock处理。

下面我们来分析Asepcts的具体实现 我们先看两个添加hook处理的方法 , 其中两个都是NSObjct的分类方法:

//NSObject的类方法
+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
                      withOptions:(AspectOptions)options
                       usingBlock:(id)block
                            error:(NSError **)error;

//NSObject的实例方法
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
                      withOptions:(AspectOptions)options
                       usingBlock:(id)block
                            error:(NSError **)error;

其中这两个方法都调用了下面函数

static id aspect_add(id self, SEL selector, AspectOptions options, id block, NSError * __autoreleasing *error) 

上面函数的 形参 id self ,为什么可以同时接受实例方法的对象和类方法中Class呢?其实理解这个问题的实质我觉得需要理解OC中对对象的定义。我们看来看下下面有关对象定义的源码:

其实OC中Class也是对象 ,我们可以看看他们三个(id , Class,NSObject *)在runtime中的定义

// Class其实是 结构体 objc_class * 的指针 
typedef struct objc_class *Class;

// id其实是 结构体 objc_object * 的指针 别名
typedef struct objc_object *id;

//OC的基类 NSObject 的声明 - 可以理解为其实可以看做是首地址为指向  objc_class *  (Isa)指针的内存 都可以看做是对象
@interface NSObject <NSObject> {
     Class isa  OBJC_ISA_AVAILABILITY;
}

struct objc_object {
private:
    isa_t isa;
}

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
}

通过上面的源码我盟可以总结出几点:

  • Class其实是 结构体 objc_class * 的指针 别名
  • id其实是 结构体 objc_object * 的指针 别名
  • 结构体objc_object与OC中的 NSObject 的首地址都是指向 isa ,可以理解为首地址为ISA指针的内存都可以称为对象。
  • objc_class 是继承自 objc_object ,也就是说,OC中 Class 也是一个对象。因此框架中无论是hook的实例方法还是hook的类方法,都可以统一把 调用的对象( ClassNSObject * ) 传参 给了id 类型。

添加hook的实现

static id aspect_add(id self, SEL selector, AspectOptions options, id block, NSError * __autoreleasing *error) {
    NSCParameterAssert(self);
    NSCParameterAssert(selector);
    NSCParameterAssert(block);

    __block AspectIdentifier *identifier = nil;
    //自璇锁 , 保证block中的线程安全
    aspect_performLocked(^{
        if (aspect_isSelectorAllowedAndTrack(self, selector, options, error)) {
            //类型懒加载 利用runtime 的属性关联 添加属性  __aspects__selector -> AspectsContainer
            AspectsContainer *aspectContainer = aspect_getContainerForObject(self, selector);
            //生成hook的对应标识 AspectIdentifier
            identifier = [AspectIdentifier identifierWithSelector:selector object:self options:options block:block error:error];
            if (identifier) {
                
                // 添加 identifier 到 aspectContainer 的相应数组
                [aspectContainer addAspect:identifier withOptions:options];

                // Modify the class to allow message interception.
                aspect_prepareClassAndHookSelector(self, selector, error);
            }
        }
    });
    return identifier;
}

上面方法中的加锁 aspect_performLocked 函数,保证了block中的资源在多线程下读取安全 ,实现如下

static void aspect_performLocked(dispatch_block_t block) {
    static OSSpinLock aspect_lock = OS_SPINLOCK_INIT;
    OSSpinLockLock(&aspect_lock);
    block();
    OSSpinLockUnlock(&aspect_lock);
}

注意 :但是OSSpinLock这个锁系统提示已经过期了,而且这个锁在多线程中如果线程的优先级不同,会造成锁无法释放等问题,详细可以看下这篇文章不再安全的 OSSpinLock

添加hook工作之一 : 检查能否 hook

aspect_isSelectorAllowedAndTrack 检查hook的可行性 , 并利用AspectTracker 处理防止对一个类的某个方法进行重复hook 。这个方法会分别过滤掉不能hook的黑名单方法 (retain , release ,autorelease ,forwardInvocation: ,retain ), 如果是对整个类的某个selector进行 hook (发生在调用Aspects框架的类方法进行 hook), 还会进行一个额外的处理 ,利用AspectTracker检查 、记录并追踪Classhook 情况,在一个Class 第一次被hook时,在其向上的继承关系中都会在全局的容器中保存下hook的记录具体的实现 ,为了避免在一个继承关系链中重复对同一个selector进行hook ,具体可以看下这段代码逻辑及注释

//查看 self 的 isa 指针是否是metaClass , 这下面的处理都是针对 对 整个class的所有实例对象的实例方法进行hock
if (class_isMetaClass(object_getClass(self))) {
    Class klass = [self class];
    //全局变量记录所有被hook的Class(系统或自定义的类)
    NSMutableDictionary *swizzledClassesDict = aspect_getSwizzledClassesDict();
    //获取类
    Class currentClass = [self class];
    
    do {
        AspectTracker *tracker = swizzledClassesDict[currentClass];
        if ([tracker.selectorNames containsObject:selectorName]) { //证明曾经 对selector hock 过

            //判断要hock的方法 , 在对应的子类是否有hock过同一个selector ,子类hock过了 ,就不能再对父类hock
            // Find the topmost class for the log.
            if (tracker.parentEntry) {  //证明子类已经对selector hock过了 ,下面的逻辑主要是找出具体那个子类被hook , 该类的 parentEntry = nil
                AspectTracker *topmostEntry = tracker.parentEntry;
                while (topmostEntry.parentEntry) {
                    topmostEntry = topmostEntry.parentEntry;
                }
                NSString *errorDescription = [NSString stringWithFormat:@"Error: %@ already hooked in %@. A method can only be hooked once per class hierarchy.", selectorName, NSStringFromClass(topmostEntry.trackedClass)];
                AspectError(AspectErrorSelectorAlreadyHookedInClassHierarchy, errorDescription);
                return NO;
            }else if (klass == currentClass) { //这里表示以前对class的selector进行过hook , 现在从新在该类中对selector定义hook事件
                // hook的已经是最顶曾的类了(oc中的子类 例如:UIButton , UIImagView ),进行行过hook,因此会  没有 parentEntry , 这里并没有执行下面的while语句
                // Already modified and topmost!
                return YES;
            }
        }
        
    }while ((currentClass = class_getSuperclass(currentClass)));

    // 执行到这里证明 selector 可以 hook , 在整个向上的继承体系中(父类)生成hook的记录  对应关系 : AspectTracker -> 进行hook的Class + selectorName
    currentClass = klass;
    AspectTracker *parentTracker = nil; //实际添加hook的类 没有这个parentTracker
    do {
        AspectTracker *tracker = swizzledClassesDict[currentClass];
        if (!tracker) {
            tracker = [[AspectTracker alloc] initWithTrackedClass:currentClass parent:parentTracker];
            swizzledClassesDict[(id<NSCopying>)currentClass] = tracker;
        }
        [tracker.selectorNames addObject:selectorName];
        // All superclasses get marked as having a subclass that is modified.
        parentTracker = tracker;
    }while ((currentClass = class_getSuperclass(currentClass)));
}

添加hook工作之二 : hook定义的参数存储 + Block 有效性验证

//类似懒加载 利用runtime 的属性关联 添加属性  __aspects__selector -> AspectsContainer
AspectsContainer *aspectContainer = aspect_getContainerForObject(self, selector);
//生成hook的对应标识 AspectIdentifier
identifier = [AspectIdentifier identifierWithSelector:selector object:self options:options block:block error:error];
if (identifier) {
    
    // 添加 identifier 到 aspectContainer 的相应数组
    [aspectContainer addAspect:identifier withOptions:options];

    // Modify the class to allow message interception.
    aspect_prepareClassAndHookSelector(self, selector, error);
}
复制代码

如果允许hook , 一个 hook的定义对应一个 AspectIdentifier。一个对象(类也是对象)的所有hook都存放在这个对象通过runtime的对象关联绑定的属性中 ,该属性类型为AspectsContainer,根据hook定义时传进来的options参数分别加入到 AspectContainer 对应的数组

  1. beforeAspects – selecter执行前进行的hook处理
  2. insteadAspects – 替换调selecter执行hook处理
  3. afterAspects – selecter执行后进行的hook处理

注意:我们看下AspectContainer中的属性声明 , 三个数组都是声明为 atomic ,来保证多线层的读取安全。这也是框架作者在开始时就提示我们,建议不要对调用频繁的方法进行hook的原因之一。

// AspectContainer数组属性声明
@property (atomic, copy) NSArray *beforeAspects;
@property (atomic, copy) NSArray *insteadAspects;
@property (atomic, copy) NSArray *afterAspects;

AspectIdentifier 这个类在初始化时还做了selector 和 执行hookBlock的参数校验

AspectIdentifier的初始化方法:主要是验证完blockhook sel ector的参数类型是否符合要求后,才完成初始化的操作 , 如果不符合要求直接返nil结束初始化,代码实现如下:

+ (instancetype)identifierWithSelector:(SEL)selector object:(id)object options:(AspectOptions)options block:(id)block error:(NSError **)error {
    NSCParameterAssert(block);
    NSCParameterAssert(selector);
    NSMethodSignature *blockSignature = aspect_blockMethodSignature(block, error); // TODO: check signature compatibility, etc.
    if (!aspect_isCompatibleBlockSignature(blockSignature, object, selector, error)) {
        return nil;
    }

    //selector 与 block 参数匹配后 生成 AspectIdentifier (参数的个数、类型一样)
    AspectIdentifier *identifier = nil;
    if (blockSignature) {
        identifier = [AspectIdentifier new];
        identifier.selector = selector;
        identifier.block = block;
        identifier.blockSignature = blockSignature;
        identifier.options = options;
        identifier.object = object; // weak
    }
    return identifier;
}

AspectIdentifier初始化方法中调用的获取Block签名字符的函数:这个函数主要是根据BlockBlock在编译成C语言后其实是一个结构体)的内部结构,操作指针的位移数来获取到签名参数字符串,并色很生成 NSMethodSignature返回。 更详细的原理 ,字符限制在这里就不说了,具体的可以私聊我

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;
    }
	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];
}

Blockhook selector的参数校验函数:主要是获取selector参数数量方法签名字符串跟Block的签名字符串比较它们是否一致,这里解析一下for循环为什么是从2开始遍历的

  • block执行调用时所传的参数: 0 . block本身(encodeType = @?) 1 . 其他自定义的参数(这里的Block 索引为1 的位置为 id aspectInfo)
  • selector 执行调用时所传的参数: 0.id object 方法调用者 1.selector 方法本省 2 .其他自定义的参数

所以这里要校对的是自定义参数的是否一致,这里Block的前两个参数分别是Block本身,以及一个id<ApsectInfo>类型的对象。所以从第二个索引开始比较自定义参数的类型。

static BOOL aspect_isCompatibleBlockSignature(NSMethodSignature *blockSignature, id object, SEL selector, NSError **error) {
    NSCParameterAssert(blockSignature);
    NSCParameterAssert(object);
    NSCParameterAssert(selector);

    BOOL signaturesMatch = YES;
    NSMethodSignature *methodSignature = [[object class] instanceMethodSignatureForSelector:selector];
    if (blockSignature.numberOfArguments > methodSignature.numberOfArguments) {
        signaturesMatch = NO;
    }else {
        if (blockSignature.numberOfArguments > 1) {
            const char *blockType = [blockSignature getArgumentTypeAtIndex:1];
            if (blockType[0] != '@') {
                signaturesMatch = NO;
            }
        }

        // Argument 0 is self/block, argument 1 is SEL or id<AspectInfo>. We start comparing at argument 2.
        // The block can have less arguments than the method, that's ok.
        if (signaturesMatch) {
            for (NSUInteger idx = 2; idx < blockSignature.numberOfArguments; idx++) {
                const char *methodType = [methodSignature getArgumentTypeAtIndex:idx];
                const char *blockType = [blockSignature getArgumentTypeAtIndex:idx];
                // Only compare parameter, not the optional type data.
                if (!methodType || !blockType || methodType[0] != blockType[0]) {
                    signaturesMatch = NO; break;
                }
            }
        }
    }

    if (!signaturesMatch) {
        NSString *description = [NSString stringWithFormat:@"Blog signature %@ doesn't match %@.", blockSignature, methodSignature];
        AspectError(AspectErrorIncompatibleBlockSignature, description);
        return NO;
    }
    return YES;
}

添加hook工作之三 : 方法的交换处理

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
    NSCParameterAssert(selector);
    
    //获取klass 获取进行hook处理的Class,主要是替换 forwardInvocation:方法的 IMP 。
    Class klass = aspect_hookClass(self, error);
    
    //获取原来方法的IMP
    Method targetMethod = class_getInstanceMethod(klass, selector);
    IMP targetMethodIMP = method_getImplementation(targetMethod);
    
    if (!aspect_isMsgForwardIMP(targetMethodIMP)) {
        
        //Make a method alias for the existing method implementation, it not already copied.
        //selector的IMP替换为 消息转发的IMP
        //aspects__selector的IMP替换为 最初selector的IMP
        
        const char *typeEncoding = method_getTypeEncoding(targetMethod);
        SEL aliasSelector = aspect_aliasForSelector(selector);
        if (![klass instancesRespondToSelector:aliasSelector]) { //判断klass 是否能响应aliasSelector ,不能的话就添加aliasSelector方法 , 实现为原来selector的实现IMP
            __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);
        }

        // We use forwardInvocation to hook in. 让原来的selector 直接进入消息转发 forwardInvocaction:
        class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);
        AspectLog(@"Aspects: Installed hook for -[%@ %@].", klass, NSStringFromSelector(selector));
    }
}

首先获取到要hookClass , 然后判断要hookselectorIMP是不是进入 消息转发的 IMP 是的话就默认已经完成了框架中进行hook的准备工作了。如果不是的话继续进行 if代码块里的处理逻辑

  1. 添加方法,名字为 aspects__selector(selector为要hook的方法名) , 使其 IMP指向selectorIMP
  2. selectorIMP指向消息转发的IMP, 这是外界调用这个 selector直接进入消息转发,从而调用到被处理过的 forwardInvocation: 经过处理后 ,外界调用selector是就可以进入了消息转发的 forwardInvocation:方法

接下来看下获取hook Class时的代码实现

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
    if ([className hasSuffix:AspectsSubclassSuffix]) { //className 如果有 _Aspects_  前缀 , 以前hock做的实例对象
        return baseClass;

        // We swizzle a class object, not a single object.
    }else if (class_isMetaClass(baseClass)) { //self 是 Class
        return aspect_swizzleClassInPlace((Class)self);
    
        // Probably a KVO'ed class. Swizzle in place. Also swizzle meta classes in place.
        //测试 :对UILabel对象进行kvo后  class == UILabel , get_class == NSKVONotifying_UILabel
        //Aspect在gitHub上的issues上有人已经解决了KVO冲突的方案  https://github.com/steipete/Aspects/pull/115

    }else if (statedClass != baseClass) { //self 是 被KVO的对象 , 需要把 NSKVONotifying_ClassName 的 forwardInvocation: 替换处理
        return aspect_swizzleClassInPlace(baseClass);
    }

    //self是普通object , 创建一个 aspect__前缀的子类 , 并把 self的 isa 指向新的子类
    //不用吧新建的class加入全局class中记录
    // Default case. Create dynamic subclass.
    const char *subclassName = [className stringByAppendingString:AspectsSubclassSuffix].UTF8String;
    Class subclass = objc_getClass(subclassName);
    //从来没有创建过这个类的话,就从新创建。创建过的话,在runtime中会有记录,Class类似单例
    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__ ,  __aspects_forwardInvocation -> originalImplementation(forwardInvocation)
        aspect_swizzleForwardInvocation(subclass);
        aspect_hookedGetClass(subclass, statedClass);
        aspect_hookedGetClass(object_getClass(subclass), statedClass);
        objc_registerClassPair(subclass);
    }

    //修改isa指针
    object_setClass(self, subclass);
    return subclass;
}

这个函数其实也是Aspect比较核心的部分,我们来详细分析一下方法接下来做的事情

分支else if (class_isMetaClass(baseClass) 证明self 是一个类(Class, 外界调用的是类方法,对整一个类进行hook),调用return aspect_swizzleClassInPlace((Class)self); ,随后调用到下面两个函数

static Class aspect_swizzleClassInPlace(Class klass) {
    NSCParameterAssert(klass);
    NSString *className = NSStringFromClass(klass);

    _aspect_modifySwizzledClasses(^(NSMutableSet *swizzledClasses) {
        if (![swizzledClasses containsObject:className]) {
            aspect_swizzleForwardInvocation(klass);
            [swizzledClasses addObject:className];
        }
    });
    return klass;
}

static NSString *const AspectsForwardInvocationSelectorName = @"__aspects_forwardInvocation:";
static void aspect_swizzleForwardInvocation(Class klass) {
    NSCParameterAssert(klass);
    // If there is no method, replace will act like class_addMethod.
    IMP originalImplementation = class_replaceMethod(klass, @selector(forwardInvocation:), (IMP)__ASPECTS_ARE_BEING_CALLED__, "v@:@");
    if (originalImplementation) {
        class_addMethod(klass, NSSelectorFromString(AspectsForwardInvocationSelectorName), originalImplementation, "v@:@");
    }
    AspectLog(@"Aspects: %@ is now aspect aware.", NSStringFromClass(klass));
}

上面两个函数是把传进来的Class做相应处理处理

  1. 修改 Class 的方法列表 forwardInvocation: 方法的IMP 指向自定义函数**ASPECTS_ARE_BEING_CALLED**
  2. 添加 __aspects_forwardInvocation 方法 , 其IMP 原来的 forwardInvocation指向的IMP
  3. 修改完后把 ClassName 存放到全局的集合中 记录 证明这个Class已经是修改过了 消息转发IMP了 , 避免以后重复对一个Class进行hook时重复做上面 1 ,2的步骤

如果执行到分支else if (statedClass != baseClass) , 证明self是一个实例对象 , 并且这个实例对象是先被添加了KVO处理 ,再调用Aspects框架添加hook处理的对象 。 注意 :Apsects现在是不支持实例对象先被KVO,再添加hook处理的。程序会提示unrecognized selector sent to instance 然后崩掉 , 框架作者在Demo的测试代码中也要相关说明

如果上面那几个if else都没有返回到hook class的话,证明要hook的对象是一个普通实例对象 ,不是一个 Class 。接下来将要类似实现KVO的处理。

  1. 尝试获取一个类 (名为 :_ Aspects _实例对象的类名) ,如果系统没有的话就生成这个类,并且让这个类继承自实例对象的类
  2. 调用函数 aspect_swizzleForwardInvocation,做消息转发方法IMP自定义处理(同上面3个步骤一样)
  3. 调用 aspect_hookedGetClass(subclass, statedClass); aspect_hookedGetClass(object_getClass(subclass), statedClass);修改对应实例对象 和 类 的 class 方法 返回对象hook之前Class。保持其行为与hook之前保持一致,从而不影响到外界的使用。

4.调用objc_registerClassPair(subclass); object_setClass(self, subclass); 把新生成的Class注册到系统中 ,并且把实例对象的isa指向新的Class

通过生成一个新的Class,并修改实例对象的isa指向新 Class , 这样处理的目的是,既为单个实例对象实现了hook处理 , 也不会影响到其他同类的实例对象 。其实KVO也是通过同样得原理实现的。

hook具体怎么执行将在第二文章分析。待续……

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

更多阅读