RunTime理解与实战（一）

什么是Runtime

Runtime 又叫运行时，是一套底层的 C 语言 API，其为 iOS 内部的核心之一，我们平时编写的 OC 代码，底层都是基于它来实现的

• 我们写的代码在程序运行过程中都会被转化成runtime的C代码执行，例如[target doSomething];会被转化成objc_msgSend(target, @selector(doSomething));。

• OC中一切都被设计成了对象，我们都知道一个类被初始化成一个实例，这个实例是一个对象。实际上一个类本质上也是一个对象，在runtime中用结构体表示。

// 通过类名获取类
Class catClass = objc_getClass("Cat"); 

//注意Class实际上也是对象，所以同样能够接受消息，向Class发送alloc消息
Cat *cat = objc_msgSend(catClass, @selector(alloc));

 //发送init消息给Cat实例cat
 cat = objc_msgSend(cat, @selector(init));

//发送eat消息给cat，即调用eat方法
objc_msgSend(cat, @selector(eat));

//汇总消息传递过程
objc_msgSend(objc_msgSend(objc_msgSend(objc_getClass("Cat"), sel_registerName("alloc")), sel_registerName("init")), sel_registerName("eat"));

/// 描述类中的一个方法
typedef struct objc_method *Method;
/// 实例变量
typedef struct objc_ivar *Ivar;
/// 类别Category
typedef struct objc_category *Category;
/// 类中声明的属性
typedef struct objc_property *objc_property_t;

//类在runtime中的表示
struct objc_class { Class isa;//指针，顾名思义，表示是一个什么，
 //实例的isa指向类对象，类对象的isa指向元类
#if !__OBJC2__ 
Class super_class;//指向父类
 const char *name;//类名
 long version;
 long info;
 long instance_size struct objc_ivar_list *ivars //成员变量列表
 struct objc_method_list **methodLists; //方法列表
 struct objc_cache *cache;//缓存
 //一种优化，调用过的方法存入缓存列表，下次调用先找缓存
 struct objc_protocol_list *protocols //协议列表
 #endif
}
 OBJC2_UNAVAILABLE;

objc_ivar_lis结构体用来存储成员变量的列表，而 objc_ivar则是存储了单个成员变量的信息；同理，objc_method_list 结构体存储着方法数组的列表，而单个方法的信息则由 objc_method结构体存储。

值得注意的时，objc_class中也有一个 isa 指针，这说明 Objc 类本身也是一个对象。为了处理类和对象的关系，Runtime 库创建了一种叫做 Meta Class(元类) 的东西，类对象所属的类就叫做元类。Meta Class 表述了类对象本身所具备的元数据。

我们所熟悉的类方法，就源自于 Meta Class。我们可以理解为类方法就是类对象的实例方法。每个类仅有一个类对象，而每个类对象仅有一个与之相关的元类。

当你发出一个类似 NSObject alloc 的消息时，实际上，这个消息被发送给了一个类对象(Class Object)，这个类对象必须是一个元类的实例，而这个元类同时也是一个根元类(Root Meta Class)的实例。所有元类的 isa 指针最终都指向根元类。

所以当 [NSObject alloc]这条消息发送给类对象的时候，运行时代码 objc_msgSend() 会去它元类中查找能够响应消息的方法实现，如果找到了，就会对这个类对象执行方法调用。

消息发送.png

上图实现是 super_class 指针，虚线时 isa 指针。而根元类的父类是 NSObject，isa指向了自己。而 NSObject 没有父类。最后 objc_class中还有一个 objc_cache，缓存，它的作用很重要，后面会提到。

获取列表

我们可以通过runtime的一系列方法获取类的一些信息（包括属性列表，方法列表，成员变量列表，和遵循的协议列表）。

 unsigned int count;
    //获取属性列表
    objc_property_t *propertyList = class_copyPropertyList([self class], &count);
    for (unsigned int i=0; i%@", [NSString stringWithUTF8String:propertyName]);
    }
    
    //获取方法列表
    Method *methodList = class_copyMethodList([self class], &count);
    for (unsigned int i; i%@", NSStringFromSelector(method_getName(method)));
    }
    
    //获取成员变量列表
    Ivar *ivarList = class_copyIvarList([self class], &count);
    for (unsigned int i; i%@", [NSString stringWithUTF8String:ivarName]);
    }
    
    //获取协议列表
    __unsafe_unretained Protocol **protocolList = class_copyProtocolList([self class], &count);
    for (unsigned int i; i%@", [NSString stringWithUTF8String:protocolName]);
    }

消息（方法）调用

消息调用.png

1.首先检测这个 selector是不是要忽略。比如 Mac OS X 开发，有了垃圾回收就不理会 retain，release 这些函数。
2.检测这个 selector的 target 是不是 nil，Objc 允许我们对一个 nil 对象执行任何方法不会 Crash，因为运行时会被忽略掉。
3.在相应操作的对象中的缓存方法列表中找调用的方法，如果找到，转向相应实现并执行。
4.如果没找到，在相应操作的对象中的方法列表中找调用的方法，如果找到，转向相应实现执行
5.如果没找到，去父类指针所指向的对象中执行3，4.
6.以此类推，如果一直到根类还没找到，转向拦截调用。
7.如果没有重写拦截调用的方法，程序报错。

• 重写父类的方法，并没有覆盖掉父类的方法，只是在当前类对象中找到了这个方法后就不会再去父类中找了。
• 如果想调用已经重写过的方法的父类的实现，只需使用super这个编译器标识，它会在运行时跳过在当前的类对象中寻找方法的过程。

1)拦截调用

在方法调用中说到了，如果没有找到方法就会转向拦截调用。那么什么是拦截调用呢。拦截调用就是，在找不到调用的方法程序崩溃之前，你有机会通过重写NSObject
的四个方法来处理。

+ (BOOL)resolveClassMethod:(SEL)sel;
+ (BOOL)resolveInstanceMethod:(SEL)sel;
//后两个方法需要转发到其他的类处理
- (id)forwardingTargetForSelector:(SEL)aSelector;
- (void)forwardInvocation:(NSInvocation *)anInvocation;

• 第一个方法是当你调用一个不存在的类方法的时候，会调用这个方法，默认返回NO，你可以加上自己的处理然后返回YES。
• 第二个方法和第一个方法相似，只不过处理的是实例方法。
• 第三个方法是将你调用的不存在的方法重定向到一个其他声明了这个方法的类，只需要你返回一个有这个方法的target。
• 第四个方法是将你调用的不存在的方法打包成NSInvocation传给你。做完你自己的处理后，调用invokeWithTarget:方法让某个target触发这个方法。

2)动态添加方法

当调用一个未实现的方法，或者说发送未知的消息给接收者时候，消息的接受者会调用resolveInstanceMethod

//An Objective-C method is simply a C function that take at least two arguments—self and _cmd.
 void run(id self, SEL _cmd, NSNumber *number){ NSLog(@"run for %@", number);}

//收到run:消息时候，为该类添加一个方法实现
+ (BOOL)resolveInstanceMethod:(SEL)sel{
 if(sel == NSSelectorFromString(@"run:")){ 
  class_addMethod(self, @selector(run:), run, "v@:*"); 
  return YES;
 }
 return [super resolveInstanceMethod:sel];}
//另外针对类方法的为 resolveClassMethod

其中class_addMethod的四个参数分别是：

• Class cls 给哪个类添加方法，本例中是self
• SEL name 添加的方法，本例中是重写的拦截调用传进来的selector。
• IMP imp 方法的实现，C方法的方法实现可以直接获得。如果是OC方法，可以用+ (IMP)instanceMethodForSelector:(SEL)aSelector;获得方法的实现。
• "v@:*"方法的签名，代表有一个参数的方法。

3）消息转发

// 第一步，消息接收者没有找到对应的方法时候，会先调用此方法，可在此方法实现中动态添加新的方法
// 返回YES表示相应selector的实现已经被找到，或者添加新方法到了类中，否则返回NO
+ (BOOL)resolveInstanceMethod:(SEL)sel { 
return YES;
}

// 第二步， 如果第一步的返回NO或者直接返回了YES而没有添加方法，该方法被调用
// 在这个方法中，我们可以指定一个可以返回一个可以响应该方法的对象， 注意如果返回self就会死循环
- (id)forwardingTargetForSelector:(SEL)aSelector {
 return nil;
}

// 第三步， 如果forwardingTargetForSelector:返回了nil，则该方法会被调用，
系统会询问我们要一个合法的『类型编码(Type Encoding)』
// 若返回 nil，则不会进入下一步，而是无法处理消息
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector { 
return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}

// 当实现了此方法后，-doesNotRecognizeSelector: 将不会被调用
// 在这里进行消息转发
- (void)forwardInvocation:(NSInvocation *)anInvocation { 
// 在这里可以改变方法选择器
 [anInvocation setSelector:@selector(unknown)]; 
// 改变方法选择器后，需要指定消息的接收者
 [anInvocation invokeWithTarget:self];
}
- (void)unknown {
 NSLog(@"unkown method.......");
}
// 如果没有实现消息转发 forwardInvocation 则调用此方法
- (void)doesNotRecognizeSelector:(SEL)aSelector {
 NSLog(@"unresolved method ：%@", NSStringFromSelector(aSelector));
}

重定向

消息转发机制执行前，Runtime 系统允许我们替换消息的接收者为其他对象。通过 - (id)forwardingTargetForSelector:(SEL)aSelector
方法。

- (id)forwardingTargetForSelector:(SEL)aSelector{
 if(aSelector == @selector(mysteriousMethod:)){
 return alternateObject;
 } 
return [super forwardingTargetForSelector:aSelector];}

如果此方法返回 nil 或者 self，则会计入消息转发机制(forwardInvocation:)，否则将向返回的对象重新发送消息。

转发

当动态方法解析不做处理返回 NO时，则会触发消息转发机制。这时 forwardInvocation:
方法会被执行，我们可以重写这个方法来自定义我们的转发逻辑：

- (void)forwardInvocation:(NSInvocation *)anInvocation{
 if ([someOtherObject respondsToSelector: [anInvocation selector]]) 
[anInvocation invokeWithTarget:someOtherObject];
 else [super forwardInvocation:anInvocation];}

唯一参数是个 NSInvocation类型的对象，该对象封装了原始的消息和消息的参数。我们可以实现 forwardInvocation:方法来对不能处理的消息做一些处理。也可以将消息转发给其他对象处理，而不抛出错误。

转发与继承

虽然转发可以实现继承的功能，但是 NSObject 还是必须表面上很严谨，像 respondsToSelector: 和 isKindOfClass:这类方法只会考虑继承体系，不会考虑转发链。
如果上图中的 Warrior对象被问到是否能响应 negotiate消息：
if ( [aWarrior respondsToSelector:@selector(negotiate)] ) ...

回答当然是 NO， 尽管它能接受 negotiate消息而不报错，因为它靠转发消息给 Diplomat类响应消息。如果你就是想要让别人以为 Warrior 继承到了 Diplomat 的 negotiate方法，你得重新实现 respondsToSelector:和 isKindOfClass:来加入你的转发算法：

- (BOOL)respondsToSelector:(SEL)aSelector{
 if ( [super respondsToSelector:aSelector] )
 return YES;
 else { /* Here, test whether the aSelector message can 
* * be forwarded to another object and whether that * *
 object can respond to it. Return YES if it can. */ }
 return NO;
}

除了 respondsToSelector:和 isKindOfClass:之外，instancesRespondToSelector: 中也应该写一份转发算法。如果使用了协议，conformsToProtocol:同样也要加入到这一行列中。
如果一个对象想要转发它接受的任何远程消息，它得给出一个方法标签来返回准确的方法描述 methodSignatureForSelector:，这个方法会最终响应被转发的消息。从而生成一个确定的 NSInvocation对象描述消息和消息参数。这个方法最终响应被转发的消息。它需要像下面这样实现：

- (NSMethodSignature*)methodSignatureForSelector:(SEL)selector{ 
NSMethodSignature* signature = [super methodSignatureForSelector:selector]; 
if (!signature) {
 signature = [surrogate methodSignatureForSelector:selector];
 }
 return signature;
}

4）关联对象

使用关联，我们可以不用修改类的定义而为其对象增加存储空间。这在我们无法访问到类的源码的时候或者是考虑到二进制兼容性的时候是非常有用。 关联是基于关键字的，因此，我们可以为任何对象增加任意多的关联，每个都使用不同的关键字即可。关联是可以保证被关联的对象在关联对象的整个生命周期都是可用的（在垃圾自动回收环境下也不会导致资源不可回收）。

//首先定义一个全局变量，用它的地址作为关联对象的key
static char associatedObjectKey;
//设置关联对象
objc_setAssociatedObject(target, &associatedObjectKey, @"添加的字符串属性", OBJC_ASSOCIATION_RETAIN_NONATOMIC); 
//获取关联对象
NSString *string = objc_getAssociatedObject(target, &associatedObjectKey);

objc_setAssociatedObject的四个参数：

• id object给谁设置关联对象。
• const void *key关联对象唯一的key，获取时会用到。
• id value关联对象。
• objc_AssociationPolicy关联策略，有以下几种策略：

enum { OBJC_ASSOCIATION_ASSIGN = 0, 
OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, 
OBJC_ASSOCIATION_COPY_NONATOMIC = 3, 
OBJC_ASSOCIATION_RETAIN = 01401, OBJC_ASSOCIATION_COPY = 01403 
};

• 关键字是一个void类型的指针。每一个关联的关键字必须是唯一的。通常都是会采用静态变量来作为关键字。
• 关联策略表明了相关的对象是通过赋值，保留引用还是复制的方式进行关联的；还有这种关联是原子的还是非原子的。这里的关联策略和声明属性时的很类似。这种关联策略是通过使用预先定义好的常量来表示的。

5）方法交换

方法交换，顾名思义，就是将两个方法的实现交换。例如，将A方法和B方法交换，调用A方法的时候，就会执行B方法中的代码，反之亦然。

- (void)viewDidLoad {
    [super viewDidLoad];
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
    
        SEL simpleness_Sel = @selector(simpleness_jsonToModle);
        SEL complex_Sel = @selector(complex_dicToObject);
        //两个方法的Method
        Method simpleMethod = class_getInstanceMethod([self class], simpleness_Sel);
        Method complexMethod = class_getInstanceMethod([self class], complex_Sel);
        
        //首先动态添加方法，实现是被交换的方法，返回值表示添加成功还是失败
        BOOL isAdd = class_addMethod([self class], simpleness_Sel, method_getImplementation(complexMethod), method_getTypeEncoding(complexMethod));
        if (isAdd) {
            //如果成功，说明类中不存在这个方法的实现
            //将被交换方法的实现替换到这个并不存在的实现
            class_replaceMethod([self class], simpleness_Sel, method_getImplementation(simpleMethod), method_getTypeEncoding(simpleMethod));
        }else{
            //否则，交换两个方法的实现
            method_exchangeImplementations(simpleMethod, complexMethod);
        }
        
    });
    
    
    //方法交换后 这里实际调的是complex_dicToObject 的实现
    [self simpleness_jsonToModle];
    
//    [self complex_dicToObject];
}

参考文档

runtime理解
runtime介绍

如果你都看到这里了，请给我点个赞吧，你的点赞是我装逼（～ 啊不，坚持原创）的不竭动力。

另外.....

我的愿望是.......

世界和平.........