RunTime浅思

古城微笑少年丶 2021-09-20 00:46 345阅读 0赞

### RunTime ###

#### Class ####

struct objc_class { 
        Class _Nonnull isa
        
    #if !__OBJC2__
        Class _Nonnull super_class
        const char * _Nonnull name
        long version
        long info
        long instance_size
        
        struct objc_ivar_list * _Nullable ivars struct objc_method_list * _Nullable * _Nullable methodLists struct objc_cache * _Nonnull cache struct objc_protocol_list *_Nullable protocols #endif } 复制代码

objc\_class在<objc/runtime.h>中有此定义。

typdef struct objc_class *Class;
    
    struct objc_object { 
        Class _Nonnull isa
    };
    
    typedef struct objc_object *id;
    复制代码

在<objc/objc.h>中，有Class、id的定义。

数据结构是算法的基础，也包含了设计者最原初的理念。

有了以上定义后，我们试着从理论上分析一下OC中的消息机制。

从objc\_object和objc\_class的数据结构中我们看到了一个共同的属性: isa。这说明两者的本质是相同的。为什么这么说呢？这里我想举个例子。

小时候，每年的八月十五，家里都会做月饼，月饼有五仁的，有砂糖的。我们今天主要是探讨做月饼时用到的模具。我们把面团放进模具中，按压后把面团拿出来，面团就有了月饼的形状。

做月饼用到的模具是Class，我们通过模具做出的月饼是objc\_object。月饼的isa指向的是模具，换句话说，Class是规则，object是规则的实例化。

规则并不是凭空产生出来的，规则也是实例，是规则的规则实例化后的结果。《道德经》中有云：道生一，一生二，二生三，三生万物。由此我们可以认为，NSObject就是最终的'道'。

在OC编程中，通过实例调用方法时，通过实例的isa找到类，然后到类的objc\_cache中查找方法，找到后通过objc\_msgSend触发。如果没有，就到objc\_method\_list中查找，如果没有，通过super\_class到父类中查找。直到NSObject。通过类调用方法时，通过objc\_class的isa找到元类，方法的查找过程同上。

如果方法在走完上述流程后依然没有找到相应的方法实现，编译器就会报'unrecognized selector sent to instance'，这时候我们可以通过以下三种方式做最后处理：

1.  动态方法解析

+ (BOOL)resolveClassMethod:(SEL)sel{}
    + (BOOL)resolveInstanceMethod:(SEL)sel {}
    复制代码

+ (BOOL)resolveInstanceMethod:(SEL)sel {
        if ([NSStringFromSelector(sel) isEqualToString:@"Test"]) {
            class_addMethod(self, sel, class_getMethodImplementation([self class], @selector(customMethod)), "v");
            return YES;
        }
        return [super resolveClassMethod:sel];
    }
    
    - (void)customMethod {
        NSLog(@"Test");
    }
    复制代码

1.  重定向

- (id)forwardingTargetForSelector:(SEL)aSelector {}
    复制代码

- (id)forwardingTargetForSelector:(SEL)aSelector {
        if ([NSStringFromSelector(aSelector) isEqualToString:@"Test"]) {
            Person *person = [[Person alloc] init];
            return person;
        }
        
        return [super forwardingTargetForSelector:aSelector];
    }
    复制代码

1.  消息转发

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {}
    -(void)forwardInvocation:(NSInvocation *)anInvocation{}
    复制代码

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
        if ([NSStringFromSelector(aSelector) isEqualToString:@"Test"]) {
            Person *person = [[Person alloc] init];
            NSMethodSignature *signature = [person methodSignatureForSelector:aSelector];
            return signature;
        }
        
        return [super methodSignatureForSelector:aSelector];
    }
    
    - (void)forwardInvocation:(NSInvocation *)anInvocation {
        SEL sel = anInvocation.selector;
        if ([NSStringFromSelector(sel) isEqualToString:@"Test"]) {
            Person *person = [[Person alloc] init];
            [anInvocation invokeWithTarget:person];
        } else {
            [super forwardInvocation:anInvocation];
        }
    }
    复制代码

#### Method ####

typedef struct objc_method *Method;
    
    struct objc_method {
        SEL _Nonnull method_name
        char * _Nullable method_types
        IMP _Nonnull method_imp
    }
    复制代码

方法交换

+ (void)load {
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            Class class = [self class];
            SEL originSel = @selector(originFunction:);
            SEL newSel = @selector(newFunction:);
            
            Method originMethod = class_getInstanceMethod(class, originSel);
            Method newMethod = class_getInstanceMethod(class, newSel);
            
            BOOL addSuccess = class_addMethod(class, originSel, method_getImplementation(newMethod), method_getTypeEncoding(newMethod));
            
            if (addSuccess) {
                class_replaceMethod(class, newSel,method_getImplementation(originMethod), method_getTypeEncoding(originMethod));
            } else {
                method_exchangeImplementations(originMethod, newMethod);
            }
        })
    }
    复制代码

遍历属性

- (id)initWithCoder:(NSCoder *)aDecoder {
        self = [super init];
        if (self) {
            unsigned int ivarCount;
            Ivar *ivars = class_copyIvarList([self class], &ivarCount);
            for (int i = 0; i < ivarCount; i++) {
                Ivar ivar = ivars[i];
                NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];
                [self setValue:[aDecoder decodeObjectForKey:key] forKey:key];
            }
        }
        
        return self;
    }
    
    - (void)encodeWithCoder:(NSCoder *)aCoder {
        unsigned int ivarCount;
        Ivar *ivars = class_copyIvarList([self class], &ivarCount);
        for (int i = 0; i < ivarCount; i++) {
            Ivar ivar = ivars[i];
            NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];
            [aCoder encodeObject:[self valueForKey:key] forKey:key];
        }
    }
    复制代码

### KVC KVO ###

KVC(Key-Value Coding)，键值编码。

[self setValue:@"ArkMuValue" forKey:@"ArkMuKey"];
    [self valueForKey:@"ArkMuKey"];
    复制代码

objc_setAssociatedObject(self, "ArkMuKey", @"ArkMuValue", OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    objc_getAssociatedObject(self, "ArkMuKey");
    复制代码

KVO(Key-Value Observing)，键值观察。

Person *person = [[Person alloc] init];
    [self addObserver:person forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
    [self removeObserver:person forKeyPath:@"name"];
    复制代码

KVO的实现原理是子类化Person，重写name的setter和getter方法。同时重写class方法，依然返回Person的isa指针。

### Aspect ###

> AOP(Aspect-oriented Programming)，"面向切面编程"，是函数式编程的一种衍生泛型。与之对应的是OOP(Object-oriented Programming)。

> Aspects，基于AOP思想，使用Objective-C编写的框架。

Aspects框架中只有一个NSObject的Aspects类别。类别提供了两个方法:

+ (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源码，可以看出Aspects的核心实现是方法交换和isa-swizzling。我们在hook一个方法的时候，会动态创建当前类或对象的子类，通过方法交换添加我们自定义的代码，通过isa-swizzling，保证返回的isa指针依然是当前类或对象，这一点与苹果的KVO实现原理一致。

下面我们来看一下相关代码：

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
        NSCParameterAssert(selector);
        Class klass = aspect_hookClass(self, error);
        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);
            }
    
            // We use forwardInvocation to hook in.
            class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);
            AspectLog(@"Aspects: Installed hook for -[%@ %@].", klass, NSStringFromSelector(selector));
        }
    }
    复制代码

上述方法是Aspects的核心实现，其他的辅助部分这里就不多说了。

首先，我们来看一下isa-swizzling：

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]) {
        	return baseClass;
        	
            // We swizzle a class object, not a single object.
        }else if (class_isMetaClass(baseClass)) {
            return aspect_swizzleClassInPlace((Class)self);
            // Probably a KVO'ed class. Swizzle in place. Also swizzle meta classes in place.
        }else if (statedClass != baseClass) {
            return aspect_swizzleClassInPlace(baseClass);
        }
        
        // Default case. Create dynamic subclass.
        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);
        }
    
        object_setClass(self, subclass);
        return subclass;
    }
    复制代码

抛开其他判断部分，我们直接看Create dynamic subclass:

1.  `subclass = objc_allocateClassPair(baseClass, subclassName, 0);`
2.  `aspect_swizzleForwardInvocation(subclass);`
3.  `aspect_hookedGetClass(subclass, statedClass);`
4.  `objc_registerClassPair(subclass);`

通过objc\_allocateClassPair()生成一个Class。通过objc\_registerClassPair()完成注册。

static void aspect_hookedGetClass(Class class, Class statedClass) {
        NSCParameterAssert(class);
        NSCParameterAssert(statedClass);
        Method method = class_getInstanceMethod(class, @selector(class));
        IMP newIMP = imp_implementationWithBlock(^(id self) {
            return statedClass;
        });
        class_replaceMethod(class, @selector(class), newIMP, method_getTypeEncoding(method));
    }
    复制代码

通过上述方法，更换class方法的返回值(始终是当前类，而不是子类化后的类)。

接下来我们来看一下aspect\_swizzleForwardInvocation()

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));
    }
    复制代码

`forwardInvocation:`方法用于消息转发，是系统在遇到没有实现的方法时的最后一步操作，Aspects通过交换此方法，可以在最后一步统一对hook的方法进行处理，最小化对开发人员编写的代码的影响。

#define aspect_invoke(aspects, info) \
    for (AspectIdentifier *aspect in aspects) {\
        [aspect invokeWithInfo:info];\
        if (aspect.options & AspectOptionAutomaticRemoval) { \
            aspectsToRemove = [aspectsToRemove?:@[] arrayByAddingObject:aspect]; \
        } \
    }
    
    // This is the swizzled forwardInvocation: method.
    static void __ASPECTS_ARE_BEING_CALLED__(__unsafe_unretained NSObject *self, SEL selector, NSInvocation *invocation) {
        NSCParameterAssert(self);
        NSCParameterAssert(invocation);
        SEL originalSelector = invocation.selector;
        SEL aliasSelector = aspect_aliasForSelector(invocation.selector);
        invocation.selector = aliasSelector;
        AspectsContainer *objectContainer = objc_getAssociatedObject(self, aliasSelector);
        AspectsContainer *classContainer = aspect_getContainerForClass(object_getClass(self), aliasSelector);
        AspectInfo *info = [[AspectInfo alloc] initWithInstance:self invocation:invocation];
        NSArray *aspectsToRemove = nil;
    
        // Before hooks.
        aspect_invoke(classContainer.beforeAspects, info);
        aspect_invoke(objectContainer.beforeAspects, info);
    
        // Instead hooks.
        BOOL respondsToAlias = YES;
        if (objectContainer.insteadAspects.count || classContainer.insteadAspects.count) {
            aspect_invoke(classContainer.insteadAspects, info);
            aspect_invoke(objectContainer.insteadAspects, info);
        }else {
            Class klass = object_getClass(invocation.target);
            do {
                if ((respondsToAlias = [klass instancesRespondToSelector:aliasSelector])) {
                    [invocation invoke];
                    break;
                }
            }while (!respondsToAlias && (klass = class_getSuperclass(klass)));
        }
    
        // After hooks.
        aspect_invoke(classContainer.afterAspects, info);
        aspect_invoke(objectContainer.afterAspects, info);
    
        // If no hooks are installed, call original implementation (usually to throw an exception)
        if (!respondsToAlias) {
            invocation.selector = originalSelector;
            SEL originalForwardInvocationSEL = NSSelectorFromString(AspectsForwardInvocationSelectorName);
            if ([self respondsToSelector:originalForwardInvocationSEL]) {
                ((void( *)(id, SEL, NSInvocation *))objc_msgSend)(self, originalForwardInvocationSEL, invocation);
            }else {
                [self doesNotRecognizeSelector:invocation.selector];
            }
        }
    
        // Remove any hooks that are queued for deregistration.
        [aspectsToRemove makeObjectsPerformSelector:@selector(remove)];
    }
    #undef aspect_invoke
    复制代码

上述方法对说有包含在AspectsContainer中的类方法和实例方法进行invoke。有一点需要注意的是instead，当hook方法的时机不是instead时，要进行原方法的invoke。

到这里想要说的说完了，欢迎大神指正。

转载于:https://juejin.im/post/5af553686fb9a07aa925c6dc