前言

维基百科对于切面编程(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 系统中所有类型的自旋锁都不能再使用了。当然这个也不确定，如果有同学知道可以告诉我一下，感谢。