iOS开发中的AOP利器 - Aspects 源码分析（一）
AOP简介
AOP全名为 Aspect Oriented Programming- 面向切面编程。AOP是OOP（Object-Oriented Programing - 面向对象编程）的补充和完善。 OOP引入封装、继承和多态等概念来创建一种对象层次结构，用以模拟公共行为的一个集合。当咱们须要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP容许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码每每水平地散布在全部对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其余类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它致使了大量代码的重复，而不利于各个模块的重用。ios
AOP技术实际上是对OOP设计的对象，利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减小系统的重复代码，下降模块间的耦合度，并有利于将来的可操做性和可维护性。git
---- 想了解更详细的AOP思想能够查看这边文章 《团队开发框架实战—面向切面的编程 AOP》 ，以上总结也是摘自这篇文章。github
举个例子,咱们须要统计用户的行为，看下用户对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 , 效果跟例子中的类方法差很少，这里就不在过多介绍。bash
Aspects内部实现分析
Apects框架涉及的底层只是比较多，建议先了解清楚一下几只知识点后再看源码实现可能会比较容易理解。多线程
- Block的内部结构及实现原理
- runtime的消息转发机制
- OC中对象的 isa 指针 + KVO的实现原理
因为这个框架的设计中，对象间关系的关系比较复杂,这里我先简单介绍一下，Aspects中定义的类的做用。app
AspectInfo： 1. 做为公有协议（面向接口调用） ： 为外界提供了一个协议（抽象接口），用于在定义block时做为其第一个参数的遵循协议， 方便访问对象的相关数据。2. 做为私有对象 ： 在原方法selector发起调用时 ， 做为封装调用参数（实参，用NSInvocation包装）的对象框架
AspectIdentifier：用于封装定义hook时传进来的block，方法的调用者target , selector ,切面时机选项（AspectOptions - 位移枚举） ， 以及在调用完添加hook方法时做为返回值返回给调用者 ，遵照协议AspectToken用于移除hook， 执行hook事件的执行处理
AspectTracker: 用于追踪或记录曾经hook过的Class(不包活实例对象的hook) , 以防止对同一个集继承体系的Class对同一个实例方法进行重复hook
AspectsContainer: 用三数组（beforeAspects , insteadAspects , afterAspects）分别记录对应时机进行hook的标识对象AspectIdentifier，为hook提供数据存储及支持。
AspectToken： 用于移除hook的一个协议(只有一个方法 ：-remove) ,AspectIdentifier就是遵循该协议的类
先大概了解框架进行hook时对类的处理宏观处理图解，更有利于对细节处理的理解及分析。 下图是对某个Class的Selector进行了hook处理后的类内变化状况。
Asepcts的核心步骤：把要进行hook的selector的IMP直接更换为runtime中的消息转发的IMP (_objc_msgForward 或 _objc_msgForward_stret) , 让外界调用改selector的时候直接进入到消息转发 （注意：这里的原理与热修复框架JSPatch的原理是同样的，所以这两个框架的共存是有问题的），从而调用到方法-forwardInvocation:方法中，此时Class的-forwardInvocation :的实现已经被框架替换为自定义函数 __ASPECTS_ARE_BEING_CALLED__ , 从而成功进行hook处理。
下面咱们来分析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的全部实例对象的实例方法进行hook
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 hook 过
//判断要hook的方法 ， 在对应的子类是否有hook过同一个selector ，子类hook过了 ，就不能再对父类hook
// Find the topmost class for the log.
if (tracker.parentEntry) { //证实子类已经对selector hook过了 ，下面的逻辑主要是找出具体那个子类被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 对应的数组
beforeAspects- selecter执行前进行的hook处理insteadAspects- 替换调selecter执行hook处理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 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代码块里的处理逻辑
- 添加方法，名字为 aspects__selector(selector为要hook的方法名) ， 使其
IMP指向selector的IMP。 - 把
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_ 前缀 ， 之前hook作的实例对象
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作相应处理处理
-
修改 Class 的方法列表 forwardInvocation: 方法的IMP 指向自定义函数 ASPECTS_ARE_BEING_CALLED
-
添加 __aspects_forwardInvocation 方法 ， 其IMP 原来的 forwardInvocation指向的IMP
-
修改完后把 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的处理。
-
尝试获取一个类 (名为 ：_ Aspects _实例对象的类名） ，若是系统没有的话就生成这个类，而且让这个类继承自实例对象的类
-
调用函数
aspect_swizzleForwardInvocation,作消息转发方法IMP自定义处理（同上面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具体怎么执行在第二文章分析
- 1. iOS开发中的AOP利器 - Aspects 源码分析（二）
- 2. iOS AOP 框架 - Aspects 源码解读
- 3. iOS 开源库系列 Aspects核心源码分析
- 4. iOS开发 面向切面编程之 Aspects 源码解析
- 5. AOP源码分析
- 6. Spring AOP源码分析（一）
- 7. spring AOP源码分析（一）
- 8. Aspects 源码学习
- 9. Aspects AOP 的实现
- 10. iOS开发中的神兵利器
- 更多相关文章...
- • 高并发系统的分析和设计 - 红包项目实战
- • Spring使用AspectJ开发AOP：基于XML和基于Annotation - Spring教程
- • PHP开发工具
- • 互联网组织的未来：剖析GitHub员工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Window下Ribbit MQ安装
- 2. Linux下Redis安装及集群搭建
- 3. shiny搭建网站填坑战略
- 4. Mysql8.0.22安装与配置详细教程
- 5. Hadoop安装及配置
- 6. Python爬虫初学笔记
- 7. 部署LVS-Keepalived高可用集群
- 8. keepalived+mysql高可用集群
- 9. jenkins 公钥配置
- 10. HA实用详解