iOS 面向切面编程(AOP)开源框架Aspects源码解读

前言

维基百科对于切面编程(AOP)的解释是这样的:面向切面的程序设计(aspect-oriented programming,AOP,又译作面向侧面的程序设计、观点导向编程、剖面导向程序设计)是计算机科学中的一个术语,指一种程序设计范型。该范型以一种称为切面的语言构造为基础,切面是一种新的模块化机制,用来描述分散在对象、类、函数)中的横切关注点。

读起来很生硬的解释,其实通俗来讲就是切面编程把程序理解为一个立体的物体,立体的物体都会有切面,比如物体的上面、下面、左右面,这种编程思想就是针对于不同程序的切面来进行考虑而设计的。

iOS这边切面编程思想最出名的第三方开源库就是Aspects。当你对iOS的各方面的理解到了一定阶段,你一定会在各种被动需求或者主动求知的指引下,接触到切面编程思想。它的主要功能是为你的代码里添加切面。

结构

Aspects结构.jpeg

本质上来看,Aspects是利用了OC的消息转发机制,使用runtime动态创建对象的子类,在子类中使用swizzling method的方式,把消息转发机制的最后一步forwardInvocation内,去转发SEL对应的IMP去我们动态生成的方法里。具体原理可以看一下iOS Runtime 消息转发机制原理和实际用途消息转发机制细分的话分3步,Aspects选择了最后一步来做,因为最后一步最合适,包含的信息最全面。

源码

Aspects是一个很轻量级的开源库,只有一个类,内部文件也没有超过1000行代码,但是里面有很多值得学习的地方。

typedef NS_OPTIONS(NSUInteger, AspectOptions) {
    AspectPositionAfter   = 0,            /// Called after the original implementation (default)
    AspectPositionInstead = 1,            /// Will replace the original implementation.
    AspectPositionBefore  = 2,            /// Called before the original implementation.
    
    AspectOptionAutomaticRemoval = 1 << 3 /// Will remove the hook after the first execution.
};

枚举分别对应前,替换,后。最后一个分类AspectOptionAutomaticRemoval=1 << 3 是使用到了移位运算符,带有这种运算符是为了让你在使用的时候可以使用或操作,类似这样AspectPositionAfter|AspectOptionAutomaticRemoval,这种写法相信你在KVO等枚举类型里也用到了,因为最后一种枚举AspectOptionAutomaticRemoval是特殊的状态,hook一次之后就移除,所以是可以与其他类别共存的,使用移位运算符是最合适的。

@protocol AspectToken <NSObject>
/// Deregisters an aspect.
/// @return YES if deregistration is successful, otherwise NO.
- (BOOL)remove;
@end
/// The AspectInfo protocol is the first parameter of our block syntax.
@protocol AspectInfo <NSObject>
/// The instance that is currently hooked.
- (id)instance;
/// The original invocation of the hooked method.
- (NSInvocation *)originalInvocation;
/// All method arguments, boxed. This is lazily evaluated.
- (NSArray *)arguments;
@end

声明了2种代理,其中AspectToken代理是为了提供给遵守的对象一个移除的权限。AspectInfo代理是存放了很多传入方法的信息,这个代理和内部的一个AspectInfo是两种东西,一个是代理一个是Class。注意区分。

@interface NSObject (Aspects)
//公开API
+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;

首先,Aspects相当于对NSObject添加了一个Aspects分类,对于所有继承自NSObject的对象都可以直接调用。其次,对外暴露的接口也非常简洁,一个对象方法和一个类方法,分别对应hook对象方法和类方法。

内部主要提供了4个内部访问的Class
@interface AspectInfo : NSObject <AspectInfo>
遵循AspectInfo协议的AspectInfo(Class)有点绕,包含了传入的Block的信息。

@interface AspectIdentifier : NSObject
记录了传入Block的签名信息,hook对应的SEL,hook的options等信息

@interface AspectsContainer : NSObject
追踪全部aspects处理过的object或者class

@interface AspectTracker : NSObject
追踪一个aspects处理的object或者class

关键逻辑在这个方法内:

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

    __block AspectIdentifier *identifier = nil;
    aspect_performLocked(^{
        //判断是否可以hook对应方法
        if (aspect_isSelectorAllowedAndTrack(self, selector, options, error)) {
            //记录操作的过程的数据结构
            AspectsContainer *aspectContainer = aspect_getContainerForObject(self, selector);
            identifier = [AspectIdentifier identifierWithSelector:selector object:self options:options block:block error:error];
            if (identifier) {
                [aspectContainer addAspect:identifier withOptions:options];
                // Modify the class to allow message interception.
                //swizzling对应的SEL
                aspect_prepareClassAndHookSelector(self, selector, error);
            }
        }
    });
    return identifier;
}

1.判断是否可以hook对应方法

Aspects把@"retain", @"release", @"autorelease", @"forwardInvocation:"这些不可以被hook的方法放入了一个NSSet内,然后去对比传入的SEL是否是其中的某个,如果有则返回NO。同时指定dealloc方法只能使用AspectPositionBefore模式,因为在dealloc方法内有不可确定性,如果hook的点不是在最前面,无法保证在运行时调用时的对应的地址是否还保留。其次,内部还判断是否能被响应,不能hook内部不存在的方法。判断内部只hook一个类的一个方法一次,如果重复hook会提示错误。

2.swizzling对应的SEL

这个地方是Aspects的核心部分,其中swizzling method其实进行了两步。第一步,swizzling 消息转发机制中的forwardInvocation,第二步,swizzling传入的method。

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
    NSCParameterAssert(selector);
    //第1步
    Class klass = aspect_hookClass(self, error);
    //第2步
    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.
        const char *typeEncoding = method_getTypeEncoding(targetMethod);
        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);
        }

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

        aspect_swizzleForwardInvocation(subclass);
        aspect_hookedGetClass(subclass, statedClass);
        aspect_hookedGetClass(object_getClass(subclass), statedClass);
        objc_registerClassPair(subclass);
    }
       //把class的isa指针指向新生成的子类,在后续再指回当前class
    object_setClass(self, subclass);

核心的原理就是:aspect_hookClass这个方法,动态生成了当前被hook类的子类,然后对子类进行swizzling method操作,hook住新生成类的forwardinvocation,用__aspects_forwardInvocation方法进行替换,在替换的forwardinvocation内,执行我们的要执行的方法。看到这里的方案,其实适合KVO的实现原理一样的,KVO是动态的生成了一个NSKVONotifying_Class的子类,然后在子类重写对应属性的set方法,然后用isa swizzling的方式,把isa还是指向当前class,然后神不知鬼不觉的在背后做了这些动态操作。本质上Aspects使用的也是这样的isa swizzling的方式。

收获

Aspects让我看到了一个优秀的轻量级开源工具的样板,内部有很多值得学习的点。它内部有很多安全性的操作,提供了很方便的接口,block的方式让添加操作更直观。让我对切面编程AOP有更深的理解。

疑问

在内部代码里面我看到了一个让我有点疑惑的地方,OSSpinLock,这个被苹果内部工程师否掉的自旋锁方案。

#import <libkern/OSAtomic.h>
static void aspect_performLocked(dispatch_block_t block) {
static OSSpinLock aspect_lock = OS_SPINLOCK_INIT;
OSSpinLockLock(&aspect_lock);
block();
OSSpinLockUnlock(&aspect_lock);
}

可以移步看一下这个不再安全的 OSSpinLock

应该是Aspects保证访问锁的线程全部都处于同一优先级,否则 iOS 系统中所有类型的自旋锁都不能再使用了。当然这个也不确定,如果有同学知道可以告诉我一下,感谢。