要想了解Runtime,需要线了解一些本质的知识

1.从上图中,我们可以看出,我们常见的类其本质就是一个结构体

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class super_class                                        OBJC2_UNAVAILABLE;
    const char *name                                         OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;
    struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache *cache                                 OBJC2_UNAVAILABLE;
    struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;

typedef struct objc_class *Class;

而Class 就是类的结构体的指针

struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

/// A pointer to an instance of a class.
typedef struct objc_object *id;

改变一个对象所属的类别

NSArray *tempAry = @[@"temp",@"temp2"];
NSLog(@"%@",tempAry);
object_setClass(tempAry,[NSObject class]);
NSLog(@"%@",tempAry);

类结构体中不同属性代表的意义

//类在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; 
/* Use `Class` instead of `struct objc_class *` */

获取属性列表

unsigned int count;
 //获取属性列表 
objc_property_t *propertyList = class_copyPropertyList([self class], &count); 
for (unsigned int i=0; i%@", [NSString stringWithUTF8String:propertyName]); 
}

获取方法列表

unsigned int count;
//获取方法列表 
Method *methodList = class_copyMethodList([self class], &count);
 for (unsigned int i; i%@",NSStringFromSelector(method_getName(method))); 
}

获取成员变量列表

unsigned int count;
//获取成员变量列表
 Ivar *ivarList = class_copyIvarList([self class], &count);
 for (unsigned int i; i%@", [NSString stringWithUTF8String:ivarName]); 
}

获取协议列表

unsigned int count;
//获取协议列表
 __unsafe_unretained Protocol **protocolList = class_copyProtocolList([self class], &count); 
for (unsigned int i; i%@", [NSString stringWithUTF8String:protocolName]);
 }

方法调用

让我们看一下方法调用在运行时的过程（参照前文类在runtime中的表示）
如果用实例对象调用实例方法，会到实例的isa指针指向的对象（也就是类对象）操作。如果调用的是类方法，就会到类对象的isa指针指向的对象（也就是元类对象）中操作。

首先，在相应操作的对象中的缓存方法列表中找调用的方法，如果找到，转向相应实现并执行。
如果没找到，在相应操作的对象中的方法列表中找调用的方法，如果找到，转向相应实现执行
如果没找到，去父类指针所指向的对象中执行1，2.
以此类推，如果一直到根类还没找到，转向拦截调用。
如果没有重写拦截调用的方法，程序报错。

拦截调用

当调用一个不存在的类方法或者实例方法的时候,会走下面两个方法

+ (BOOL)resolveClassMethod:(SEL)sel; 
+ (BOOL)resolveInstanceMethod:(SEL)sel;

将你调用的不存在的方法重定向到一个其他声明了这个方法的类，只需要你返回一个有这个方法的target

- (id)forwardingTargetForSelector:(SEL)aSelector;

将你调用的不存在的方法打包成NSInvocation传给你。做完你自己的处理后，调用invokeWithTarget:方法让某个target触发这个方法

- (void)forwardInvocation:(NSInvocation *)anInvocation;

动态添加方法

//隐式调用方法
[target performSelector:@selector(resolveAdd:) withObject:@"test"];

配合使用

void runAddMethod(id self, SEL _cmd, NSString *string){
 NSLog(@"add C IMP ", string); 
}
+ (BOOL)resolveInstanceMethod:(SEL)sel{
    //给本类动态添加一个方法
      if ([NSStringFromSelector(sel) isEqualToString:@"resolveAdd:"]) {
            class_addMethod(self, sel, (IMP)runAddMethod, "v@:*"); 
     } 
return YES;
 }

BOOL class_addMethod(Class cls, SEL name, IMP imp,
const char *types)

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

给类添加方法(关联对象)

objc_setAssociatedObject(<#id object#>, <#const void *key#>, <#id value#>, <#objc_AssociationPolicy policy#>)
objc_getAssociatedObject(<#id object#>, <#const void *key#>)

属性的几种特征

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

_cmd代表当前调用方法的地址。getAssociatedObject方法的地址作为唯一的key

//添加关联对象
 - (void)addAssociatedObject:(id)object{
      objc_setAssociatedObject(self, @selector(getAssociatedObject), object, OBJC_ASSOCIATION_RETAIN_NONATOMIC); 
}
 //获取关联对象 
- (id)getAssociatedObject{
       return objc_getAssociatedObject(self, _cmd);
 }

交换方法的实现

//load方法会在类第一次加载的时候被调用
//调用的时间比较靠前，适合在这个方法里做方法交换
+ (void)load{
    //方法交换应该被保证，在程序中只会执行一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        //获得viewController的生命周期方法的selector
        SEL systemSel = @selector(viewWillAppear:);
        //自己实现的将要被交换的方法的selector
        SEL swizzSel = @selector(swiz_viewWillAppear:);
        //两个方法的Method
        Method systemMethod = class_getInstanceMethod([self class], systemSel);
        Method swizzMethod = class_getInstanceMethod([self class], swizzSel);
        //首先动态添加方法，实现是被交换的方法，返回值表示添加成功还是失败
        BOOL isAdd = class_addMethod(self, systemSel, method_getImplementation(swizzMethod), method_getTypeEncoding(swizzMethod));
        if (isAdd) {
            //如果成功，说明类中不存在这个方法的实现
            //将被交换方法的实现替换到这个并不存在的实现
            class_replaceMethod(self, swizzSel, method_getImplementation(systemMethod), method_getTypeEncoding(systemMethod));
        }else{
            //否则，交换两个方法的实现
            method_exchangeImplementations(systemMethod, swizzMethod);
        }
    });
}
- (void)swiz_viewWillAppear:(BOOL)animated{
    NSLog(@"11111111111");
}
- (void)viewWillAppear:(BOOL)animated{
    NSLog(@"22222222222");
}
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
    [self swiz_viewWillAppear:YES];
}

iOS Runtime的使用