iOS开发中的AOP利器 - Aspects 源码分析（一）

AOP简介

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

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

---- 想了解更详细的AOP思想可以查看这边文章 《团队开发框架实战—面向切面的编程 AOP》 ，以上总结也是摘自这篇文章。

举个例子,我们需要统计用户的行为，看下用户对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：
1. 作为私有对象 ：用于在定义block时作为其第一个参数 ， 并且原方法发起调用时 ， 作为封装调用参数（实参，用NSInvocation包装）的对象
2. 作为公有协议（面向接口调用） ： 为外界提供了一个协议，方便访问私有对象的属性 。

AspectIdentifier ：用于封装定义hook时传进来的block，方法的调用者target , selector ,切面时机选项（AspectOptions - 位移枚举） ， 以及在调用完添加hook方法时作为返回值返回给调用者 ，遵守协议AspectToken 用于移除hook ， 执行hook事件的执行处理。一个 hook事件对应一个AspectIdentifier对象。

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

AspectsContainer : 用三数组（beforeAspects , insteadAspects , afterAspects）分别记录对应时机进行 hock 的标识对象 AspectIdentifier ，为hock 提供数据存储及支持 , 作为一个对象的属性（通过runtime 关联对象绑定在被hook的对象（实例对象 或 类型对象））。

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

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

Aspects分析.png

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的类方法，都可以统一把 调用的对象（ Class 或 NSObject * ） 传参 给了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检查 、记录并追踪Class的 hook 情况，在一个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 和 执行hook的Block的参数校验。

AspectIdentifier的初始化方法：主要是验证完block与hook 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签名字符的函数：这个函数主要是根据Block（ Block在编译成C语言后其实是一个结构体）的内部结构，操作指针的位移数来获取到签名参数字符串，并色很生成 NSMethodSignature返回。 更详细的原理 ，可以看下我之前写的《浅析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;
    }
    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];
}

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

  • block执行调用时所传的参数：
    0 . block本身（encodeType = @?）
    1 . 其他自定义的参数(这里的Block 索引为1 的位置为 id<ApsectInfo> 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));
    }
}

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

  1. 添加方法，名字为 aspects__selector(selector为要hook的方法名) ， 使其 IMP指向selector的 IMP 。
  2. 把selector的IMP指向消息转发的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的测试代码中也要相关说明 ， 也有人在github上给作者提了issue 详细可以点击这里查看

如果上面那几个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也是通过同样得原理实现的。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,324评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,303评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,192评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,555评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,569评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,566评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,927评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,583评论 0赞 257
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,827评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,590评论 2赞 320
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,669评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,365评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,941评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,928评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,159评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,880评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,399评论 2赞 342

推荐阅读更多精彩内容

  • 无标题文章
    转至元数据结尾创建： 董潇伟，最新修改于： 十二月 23, 2016 转至元数据起始第一章:isa和Class一....
    40c0490e5268阅读 1,678评论 0赞 9
  • Runtime窥探 （六）| AOP与Aspects核心源码
    前言 如何把这个世界变得美好？把你自己变得更美好 我们这篇博客继续来介绍Runtime在开发中的实际应用，通过开源...
    Dely阅读 2,144评论 4赞 16
  • 面向切面编程之 Aspects 源码解析及应用
    转摘自面向切面编程 1. 背景 最近在做项目的打点统计的时候，发现业务逻辑和打点逻辑经常耦合在一起，这样一方面影响...
    Arthurcsh阅读 632评论 1赞 1
  • 走进非洲之一
    肯尼亚 我读《走出非洲》时间应该是十年前，那时是因为电影《走出非洲》，所以去书店看这本书。 今年...
    九宫格格阅读 542评论 0赞 0
  • 你们入安好便是晴天
    大家好，我叫蒋翠英，两个孩子妈妈，男七女二，刚好凑成一个好字。 跟老公相恋4年就怀上大宝，结束了恋爱长...
    英英_7a2a阅读 252评论 0赞 0