Runtime重要知识点以及使用场景（编译过程和Runtime两者如何连接的）

Runtime概念介绍

Objective-C 扩展了 C 语言，并加入了面向对象特性和 Smalltalk 式的消息传递机制。而这个扩展的核心是一个用 C 和 编译语言 写的 Runtime 库。它是 Objective-C 面向对象和动态机制的基石，因此它是一门动态语言。

高级编程语言想要成为可执行文件需要先编译为汇编语言再汇编为机器语言，机器语言也是计算机能够识别的唯一语言，但是OC并不能直接编译为汇编语言，而是要先转写为纯C语言再进行编译和汇编的操作，从OC到C语言的过渡就是由runtime来实现的。然而我们使用OC进行面向对象开发，而C语言更多的是面向过程开发，这就需要将面向对象的类转变为面向过程的结构体。

首先语言需要编译，总结了一套编译全过程，可以看下Runtime是在什么时候参与的以及编译过程详细介绍 Command + B 编译全过程

总结：
dyld是动态链接器，启动编译后的二进制文件（所有.o文件的集合），然后dyld参与进来，初始化二进制，把一些动态库，例如Fundation，UIKit，Runtime
lib库，GCD，Block等链接进来，然后修正地址偏移（ASLR，Apple为了防止攻击，可执行文件和动态链接库的每次加载地址都不同），然后dyld把这些符号，类，方法等加载进内存，runtime向dyld注册了回调，当全部加载进内存的时候，交给runtime来处理，runtime根据加载进来的类递归层级遍历，根据runtime中的objc定义的结构体加载成对应的格式（例如Class结构体，Objc结构体，objc_msgSend方法调用等）以及调用+load方法完成初始化，至此，可执行文件中和动态链接库的符号（Class，Protocol，SEL，IMP）按runtime格式加载进内存了，后续的那些方法例如动态添加Class和Swizzle才会生效

底层结构（面向对象和消息分发）

类，对象，Method结构体介绍

//对象
struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};
//类
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;
//方法列表
struct objc_method_list {
    struct objc_method_list *obsolete                        OBJC2_UNAVAILABLE;
    int method_count                                         OBJC2_UNAVAILABLE;
#ifdef __LP64__
    int space                                                OBJC2_UNAVAILABLE;
#endif
    /* variable length structure */
    struct objc_method method_list[1]                        OBJC2_UNAVAILABLE;
}                                                            OBJC2_UNAVAILABLE;
//方法
struct objc_method {
    SEL method_name                                          OBJC2_UNAVAILABLE;
    char *method_types                                       OBJC2_UNAVAILABLE;
    IMP method_imp                                           OBJC2_UNAVAILABLE;
}

/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;
/// A pointer to an instance of a class.
typedef struct objc_object *id;

Class是一个指向objc_class（类）结构体的指针，而id是一个指向objc_object（对象）结构体的指针。 objec_objct（对象）中isa指针指向的类结构称为objc_class（该对象的类），其中存放着普通成员变量与对象方法 （“-”开头的方法）。 objc_class（类）中isa指针指向的类结构称为metaclass（该类的元类），其中存放着static类型的成员变量与static类型的方法 （“+”开头的方法）

/// Represents an instance of a class.
struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

objec_object（对象）结构体中只有isa一个成员属性，指向objec_class（该对象的类）。

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;   //isa指针，指向metaclass（该类的元类）
 
#if !__OBJC2__
 
    Class super_class   //指向objc_class（该类）的super_class（父类）
 
    const char *name    //objc_class（该类）的类名
 
    long version        //objc_class（该类）的版本信息，初始化为0，可以通过runtime函数class_setVersion和class_getVersion进行修改和读取
 
    long info           //一些标识信息，如CLS_CLASS表示objc_class（该类）为普通类。ClS_CLASS表示objc_class（该类）为metaclass（元类）
 
    long instance_size  //objc_class（该类）的实例变量的大小
 
    struct objc_ivar_list *ivars    //用于存储每个成员变量的地址
 
    struct objc_method_list **methodLists   //方法列表，与info标识关联
 
    struct objc_cache *cache        //指向最近使用的方法的指针，用于提升效率
 
    struct objc_protocol_list *protocols    //存储objc_class（该类）的一些协议
#endif
 
} OBJC2_UNAVAILABLE;

objec_class（类）比objec_object（对象）的结构体中多了很多成员，上面就是介绍各个成员的作用。

所有的metaclass（元类）中isa指针都是指向根metaclass（元类），而根metaclass（元类）中isa指针则指向自身。

根metaclass（元类）中的superClass指针指向根类，因为根metaclass（元类）是通过继承根类产生的。

作用

• 当我们调用某个对象的对象方法时，它会首先在自身isa指针指向的objc_class(类)的methodLists中查找该方法，如果找不到则会通过objc_class（类）的super_class指针找到其父类，然后从其methodLists中查找该方法，如果仍然找不到，则继续通过
  super_class向上一级父类结构体中查找，直至根class；
• 当我们调用某个类方法时，它会首先通过自己的isa指针找到metaclass（元类），并从其methodLists中查找该类方法，如果找不到则会通过metaclass（元类）的super_class指针找到父类的metaclass（元类）结构体，然后从methodLists中查找该方法，如果仍然找不到，则继续通过super_class向上一级父类结构体中查
  找，直至根metaclass（元类）；
• 这里有个细节就是要说运行的时候编译器会将代码转化为objc_msgSend(obj, @selector
  (makeText))，在objc_msgSend函数中首先通过obj（对象）的isa指针找到obj（对象）对应的class（类）。在class（类）中先去cache中通过SEL（方法的编号）查找对应method（方法），若cache中未找到，再去methodLists中查找，若methodists中未找到，则去superClass中查找，若能找到，则将method（方法）加入到cache中，以方便下次查找，并通过method（方法）中的函数指针跳转到对应的函数中去执行。

具体的理解就是网上那张图，理解的struct结构体就很容易理解了。这里写链接内容

类对象（objc_class）

Objective-C类是由Class类型来表示的，它实际上是一个指向objc_class结构体的指针。

typedef struct objc_class *Class;

objc/runtime.h中定义的结构如下

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

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

} OBJC2_UNAVAILABLE;

struct objc_class结构体定义了很多变量
结构体里保存了指向父类的指针、类的名字、版本、实例大小、实例变量列表、方法列表、缓存、遵守的协议列表等，
类对象就是一个结构体struct objc_class，这个结构体存放的数据称为元数据(metadata)，

凡是首地址是*isa的struct指针，都可以被认为是objc中的对象，因此我们称之为类对象，类对象在编译期产生用于创建实例对象，是单例。

实例对象（objc_object）

/// Represents an instance of a class.
struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

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

实例对象的结构很简单，就是一个指向类或者元类的isa指针。实例化信息都存放在类或者元类中。

元类（Meta Class）

元类(Meta Class)是一个类对象的类。
在上面我们提到，所有的类自身也是一个对象，我们可以向这个对象发送消息(即调用类方法)。
为了调用类方法，这个类的isa指针必须指向一个包含这些类方法的一个objc_class结构体。这就引出了meta-class的概念，元类中保存了创建类对象以及类方法所需的所有信息。
任何NSObject继承体系下的meta-class都使用NSObject的meta-class作为自己的所属类，而基类的meta-class的isa指针是指向它自己。

Method（objc_method）

struct objc_method {
    SEL _Nonnull method_name                                 OBJC2_UNAVAILABLE;
    char * _Nullable method_types                            OBJC2_UNAVAILABLE;
    IMP _Nonnull method_imp                                  OBJC2_UNAVAILABLE;
}      

我们来看下objc_method这个结构体的内容：

SEL method_name 方法名
char *method_types 方法类型
IMP method_imp 方法实现

在这个结构体重，我们已经看到了SEL和IMP，说明SEL和IMP其实都是Method的属性。

SEL(objc_selector)

objc.h
/// An opaque type that represents a method selector.
typedef struct objc_selector *SEL;

其实selector就是个映射到方法的C字符串，你可以用 Objective-C 编译器命令@selector()或者 Runtime 系统的sel_registerName函数来获得一个 SEL 类型的方法选择器。
selector既然是一个string，我觉得应该是类似className+method的组合，命名规则有两条：

同一个类，selector不能重复
不同的类，selector可以重复

这也带来了一个弊端，我们在写C代码的时候，经常会用到函数重载，就是函数名相同，参数不同，但是这在Objective-C中是行不通的，因为selector只记了method的name，没有参数，所以没法区分不同的method。

比如：

- (void)caculate(NSInteger)num;
- (void)caculate(CGFloat)num;

复制代码是会报错的。
我们只能通过命名来区别：

- (void)caculateWithInt(NSInteger)num;
- (void)caculateWithFloat(CGFloat)num;

复制代码在不同类中相同名字的方法所对应的方法选择器是相同的，即使方法名字相同而变量类型不同也会导致它们具有相同的方法选择器。

IMP

/// A pointer to the function of a method implementation. 
#if !OBJC_OLD_DISPATCH_PROTOTYPES
typedef void (*IMP)(void /* id, SEL, ... */ ); 
#else
typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...); 
#endif

就是指向最终实现程序的内存地址的指针。
在iOS的Runtime中，Method通过selector和IMP两个属性，实现了快速查询方法及实现，相对提高了性能，又保持了灵活性。

类缓存(objc_cache)

为了避免每次查找带来的性能问题，一般都会设计缓存结构，所以类实现一个缓存，每当你搜索一个类分派表，并找到相应的选择器，它把它放入它的缓存。所以当objc_msgSend查找一个类的选择器，它首先搜索类缓存。这是基于这样的理论：如果你在类上调用一个消息，你可能以后再次调用该消息。
为了加速消息分发， 系统会对方法和对应的地址进行缓存，就放在上述的objc_cache，所以在实际运行中，大部分常用的方法都是会被缓存起来的，Runtime系统实际上非常快，接近直接执行内存地址的程序速度。这里其实就是和NSDictionary一样，实现了Hash表来存储，如果用对象一样的开放定址法，他的时间复杂度可以达到O（1）

Category(objc_category)

/// An opaque type that represents a category.
typedef struct objc_category *Category;
struct objc_category {
    char * _Nonnull category_name                            OBJC2_UNAVAILABLE;
    char * _Nonnull class_name                               OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable instance_methods     OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable class_methods        OBJC2_UNAVAILABLE;
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
}             

清晰明了，其实某个角度看，这只能添加类方法和实例方法以及协议，单单根据底层结构来看，属性得用objc_setAssociatedObject挂载上去，不能添加成员变量

Runtime消息转发

根据上面面向对象中的消息分发，首先会根据类方法还是实例方法进行isa指针消息横向查找，然后在进行继承关系纵向查找，如果都没找到，doesNotRecognizeSelector:方法报unrecognized selector错，抛出异常，那么当横向纵向都没有的时候就会进入如下消息转发流程，进行最后的补救措施
1.动态方法解析
2.备用接收者
3.完整消息转发

第一步：动态方法解析并添加
首先，Objective-C运行时会调用 +resolveInstanceMethod:或者 +resolveClassMethod:，让你有机会提供一个函数实现。如果你添加了函数并返回YES， 那运行时系统就会重新启动一次消息发送的过程。

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    //执行foo函数
    [self performSelector:@selector(foo:)];
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(foo:)) {//如果是执行foo函数，就动态解析，指定新的IMP
        class_addMethod([self class], sel, (IMP)fooMethod, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}

void fooMethod(id obj, SEL _cmd) {
    NSLog(@"Doing foo");//新的foo函数
}

一样的例子可以看下面第五点，如果这里resolve返回NO，就会进入第二步forwardingTargetForSelector

第二步：备用接收者

#import "ViewController.h"
#import "objc/runtime.h"

@interface Person: NSObject

@end

@implementation Person

- (void)foo {
    NSLog(@"Doing foo");//Person的foo函数
}

@end

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    //执行foo函数
    [self performSelector:@selector(foo)];
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    return YES;//返回YES，进入下一步转发
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(foo)) {
        return [Person new];//返回Person对象，让Person对象接收这个消息
    }
    
    return [super forwardingTargetForSelector:aSelector];
}

@end

可以看到我们通过forwardingTargetForSelector把当前ViewController的方法转发给了Person去执行了。打印结果也证明我们成功实现了转发。

第三步：完整消息转发

#import "ViewController.h"
#import "objc/runtime.h"

@interface Person: NSObject

@end

@implementation Person

- (void)foo {
    NSLog(@"Doing foo");//Person的foo函数
}

@end

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    //执行foo函数
    [self performSelector:@selector(foo)];
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    return YES;//返回YES，进入下一步转发
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
    return nil;//返回nil，进入下一步转发
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if ([NSStringFromSelector(aSelector) isEqualToString:@"foo"]) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];//签名，进入forwardInvocation
    }
    
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation {
    SEL sel = anInvocation.selector;

    Person *p = [Person new];
    if([p respondsToSelector:sel]) {
        [anInvocation invokeWithTarget:p];
    }
    else {
        [self doesNotRecognizeSelector:sel];
    }

}

@end

从打印结果来看，我们实现了完整的转发。通过签名，Runtime生成了一个对象anInvocation，发送给了forwardInvocation，我们在forwardInvocation方法里面让Person对象去执行了foo函数。签名参数v@:怎么解释呢，这里苹果文档Type Encodings有详细的解释。
以上就是Runtime的三次转发流程

上面的流程摘录自掘金的一片文章

简单总结下Runtime

Runtime是用C++编写的运行时库，为 C 添加了面向对象的能力，这也是区别于C语言这样静态语言的重要特性，C语言函数调用在编译期间就已经决定了，在编译完成之后直接顺序执行。OC是动态语言(多态和运行时)，函数调用就是消息发送，在编译期间不知道具体调用哪个函数，所以Runtime就是去解决运行时找到调用哪个方法的问题
多态:OC中的多态是不同对象对同一消息的不同响应方式，子类通过重写父类的方法来改变同一方法的实现，体现多态性
总结：三个能力
首地址是isa的struct指针，都可以被认为是objc中的对象
1.面向对象能力 （继承，封装，多态）
2.动态加载类信息，进行消息的分发 （isa横向查找，继承纵向查找，找不到调用_objc_msgForward用于消息转发）
3.消息转发 1.动态方法解析并动态添加方法 2.备用接收者 3.完整消息转发 4.抛出异常

顺序：
instance—>class—->method—–>sel—(Cache)–>imp—->实现函数(找不到就进入转发流程)

实例对象中存放isa指针，有isa指针就可以找到实力变量对应的所属类，类中存放着实例方法列表，SEL为Key，IMP为value，在编译期间，根据方法名会生成一个唯一的int标识符，这就是SEL标识，IMP就是函数指针，指向最终函数实现。runtime核心就是objc_msgSend函数，通过给SEL传递消息，找到匹配的IMP

代码介绍

因为Objc是一门动态语言，所以它总是想办法把一些决定工作从编译连接推迟到运行时。也就是说只有编译器是不够的，还需要一个运行时系统 (runtime system) 来执行编译后的代码。这就是 Objective-C Runtime 系统存在的意义，它是整个Objc运行框架的一块基石。

1.OC代码如何转换成runtime运行时

/*
     * 以下代码runtime转换如下  clang -rewrite-objc 文件名，例如我们要转换的是FViewcontroller的文件，会出现一个.cpp后缀的文件，打开拉倒最后就是转换代码
     */
    People *p1 = [[People alloc] init];
    [p1 eat:@"屎"];
    
    People *p1 = ((People *(*)(id, SEL))(void *)objc_msgSend)((id)((People *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("People"), ), sel_registerName("init"));
    
    ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)p1, sel_registerName("eat:"), (NSString *)&__NSConstantStringImpl__var_folders_c2_z9kbf6xs7x3g3qc4vwt8b10w0000gn_T_main_c68e89_mi_1);

注：这里只是简单介绍下如何转换，如果需要详细的可以传送门

2.看下如何用runtime来创建对象

// 换这个方式创建下
    // 1.objc_getClass("People") 获取类
    // 2.sel_registerName("alloc") 注册表中拿方法 可以用成@selector
    // 3.objc_msgSend(类名, @selector(), 参数);
    
    // 根据类名获取到类
    Class class = objc_getClass("People");
    // 这里直接写会报错 请将 Build Setting -> Enable Strict Checking of objc_msgSend Calls 改为 NO
    People *people = objc_msgSend(class,@selector(alloc));
    // runtime初始化对象
    people = objc_msgSend(people, @selector(init));
    // 方法调用  这里的类方法不暴露都能调用到  但是这里会出现警告 最终还是能到方法列表里面找到该方法打印
    objc_msgSend(people, @selector(eat:),@"屎");
    
    // 单参数
    People *people2 = objc_msgSend(objc_msgSend(objc_getClass("People"), sel_registerName("alloc")), sel_registerName("init"));
    objc_msgSend(people2, sel_registerName("eat:"),@"香蕉");
    
    // 多参数
    People *people3 = objc_msgSend(objc_msgSend(objc_getClass("People"), sel_registerName("alloc")), sel_registerName("init"));
    objc_msgSend(people3, sel_registerName("play:age:block:"),@"美女",18,[^{NSLog(@"我来了");} copy]);
    
    // 打印如下
//    2016-12-19 16:45:34.974 RuntimeKJ[11526:324368] People eat 屎
//    2016-12-19 16:45:34.974 RuntimeKJ[11526:324368] People eat 香蕉
//    2016-12-19 16:45:34.975 RuntimeKJ[11526:324368] name = 美女,age = 18,<__NSGlobalBlock__: 0x10ecd90a0>
//    2016-12-19 16:45:34.975 RuntimeKJ[11526:324368] 我来了美女

这里的People对象是只是在.m文件中实现了方法而已，可以不在.h里面实现，都能进行runtime调用 从这些定义中可以看出发送一条消息也就 objc_msgSend 做了什么事。举 objc_msgSend(obj, play) 这个例子来说：

• 首先，通过 obj 的 isa 指针找到它的 class ;
• 在 class 的 method list 找 play ;
• 如果 class 中没到 play，继续往它的 superclass 中找 ;
• 一旦找到 play 这个函数，就去执行它的实现IMP .
  
  
  但这种实现有个问题，效率低。但一个 class 往往只有 20% 的函数会被经常调用，可能占总调用次数的 80% 。每个消息都需要遍历一次 objc_method_list 并不合理。如果把经常被调用的函数缓存下来，那可以大大提高函数查询的效率。这也就是 objc_class 中另一个重要成员 objc_cache 做的事情 - 再找到 play 之后，把 play 的 method_name 作为 key ，method_imp 作为 value 给存起来。当再次收到 play 消息的时候，可以直接在 cache 里找到，避免去遍历 objc_method_list.

4.动态交换两个方法（swizzle和KVO isa交换）

交换方法实现的需求场景：自己创建了一个功能性的方法，在项目中多次被引用，当项目的需求发生改变时，要使用另一种功能代替这个功能，要求是不改变旧的项目(也就是不改变原来方法的实现)。 可以在类的分类中，再写一个新的方法(是符合新的需求的),然后交换两个方法的实现。这样，在不改变项目的代码，而只是增加了新的代码 的情况下，就完成了项目的改进。 交换两个方法的实现一般写在类的load方法里面，因为load方法会在程序运行前加载一次，而initialize方法会在类或者子类在 第一次使用的时候调用，当有分类的时候会调用多次

// Load的时候如果下面的方法是-方法，那么是无效的，类方法对实例方法无法操作
+ (void)load
{
    Method eatM = class_getClassMethod(self, sel_registerName("eat:"));
    
    Method sleepM = class_getClassMethod(self, @selector(sleep:));
    
    method_exchangeImplementations(eatM, sleepM);
}

// 如果要在自己的方法里面调用另个一个方法，直接调用自己的方法名就好了
+ (void)eat:(NSString *)food
{
    
    NSLog(@"%@大口吃%@",NSStringFromClass([self class]),food);
}

// 如果这样调用直接死循环了
+ (void)sleep:(NSString *)name
{
//    [self eat:@"屎"]; 死循环
    
    NSLog(@"%@睡了%@",NSStringFromClass([self class]),name);
    
    [self sleep:@"屎"];
}
objc_msgSend(objc_getClass("Dog"), sel_registerName("eat:"),@"aaa");
    
    // 打印如下
    // 2016-12-19 17:25:15.699 RuntimeKJ[12219:363270] Dog睡了aaa
    // 2016-12-19 17:25:15.700 RuntimeKJ[12219:363270] Dog大口吃屎
    
    // 先是调用eat的方法，但是由于方法的调换，先调用了sleep方法，在sleep方法里面继续调用sleep，实际上调用的是eat方法，这样就完成的方法调换

动态交换方法，也可以交换isa指针，KVO实现就是这样的
KVO的实现依赖于 Objective-C 强大的 Runtime，当观察某对象 A 时，KVO 机制动态创建一个对象A当前类的子类，并为这个新的子类重写了被观察属性 keyPath 的 setter 方法。setter 方法随后负责通知观察对象属性的改变状况。
Apple 使用了 isa-swizzling 来实现 KVO 。当观察对象A时，KVO机制动态创建一个新的名为：NSKVONotifying_A的新类，该类继承自对象A的本类，且 KVO 为 NSKVONotifying_A 重写观察属性的 setter 方法，setter 方法会负责在调用原 setter 方法之前和之后，通知所有观察对象属性值的更改情况。

NSKVONotifying_A 类剖析

NSLog(@"self->isa:%@",self->isa);  
NSLog(@"self class:%@",[self class]);  

在建立KVO监听前，打印结果为：

self->isa:A
self class:A

建立之后打印

self->isa:NSKVONotifying_A
self class:A

在这个过程，被观察对象的 isa 指针从指向原来的 A 类，被KVO 机制修改为指向系统新创建的子类NSKVONotifying_A 类，来实现当前类属性值改变的监听；
所以当我们从应用层面上看来，完全没有意识到有新的类出现，这是系统“隐瞒”了对 KVO 的底层实现过程，让我们误以为还是原来的类。但是此时如果我们创建一个新的名为“NSKVONotifying_A”的类，就会发现系统运行到注册 KVO 的那段代码时程序就崩溃，因为系统在注册监听的时候动态创建了名为 NSKVONotifying_A 的中间类，并指向这个中间类了。
子类setter方法剖析
KVO 的键值观察通知依赖于 NSObject 的两个方法:willChangeValueForKey:和 didChangeValueForKey: ，在存取数值的前后分别调用 2 个方法：
被观察属性发生改变之前，willChangeValueForKey:被调用，通知系统该 keyPath 的属性值即将变更；
当改变发生后， didChangeValueForKey: 被调用，通知系统该keyPath 的属性值已经变更；之后， observeValueForKey:ofObject:change:context:也会被调用。且重写观察属性的setter 方法这种继承方式的注入是在运行时而不是编译时实现的。
KVO 为子类的观察者属性重写调用存取方法的工作原理在代码中相当于：

- (void)setName:(NSString *)newName { 
      [self willChangeValueForKey:@"name"];    //KVO 在调用存取方法之前总调用 
      [super setValue:newName forKey:@"name"]; //调用父类的存取方法 
      [self didChangeValueForKey:@"name"];     //KVO 在调用存取方法之后总调用
}

5.动态添加方法

<font color = black size = 4>通常做法都是在resolve方法内部指定sel的IMP，前提是该方法未实现会被拦截下来，就能实现动态创建的过程</font>
```objective-c
void run (id self, SEL _cmd,NSNumber *meter,NSString *name)
{
    // implementation .....
    NSLog(@"%@跑了%@",name,meter);
}


//对实现(abc)的前两个参数的说明
//每个方法的内部都默认包含两个参数，被称为隐式参数
//id类型self(代表类或对象)和SEL类型的_cmd(方法编号)
//class_addMethod函数参数的含义:
//第一个参数Class cls, 类型
//第二个参数SEL name, 被解析的方法
//第三个参数 IMP imp, 指定的实现
//第四个参数const char *types,方法的类型，具体参照类型的codeType那张图，但是要注意一点：Since the function must take at least two arguments—self and _cmd, the second and third characters must be “@:” (the first character is the return type).译为：因为函数必须至少有两个参数self和_cmd,第二个和第三个字符必须是“@:”。如果想要再增加参数，就可以从实现的第三个参数算起，看下面的例子就明白。
// 当调用有未实现的实例方法的时候会进到这里来
+ (BOOL) resolveInstanceMethod:(SEL)aSEL
{
    // 多参数就是"run:"无参数就是run
    if (aSEL == @selector(run:))
    {
        class_addMethod([self class], aSEL, (IMP) run, "v@:@:@");// 增加了2个对象类型参数 增加了@
        return YES;
    }
//    return [super resolveInstanceMethod:aSEL];
    return YES;
}

// 当调用类方法未实现的时候+ (BOOL)resolveClassMethod:(SEL)sel 在这里拦截
+ (BOOL)resolveClassMethod:(SEL)sel
{
    NSLog(@"类方法未实现");
    return NO;
}

## 6.由第五点衍生出动态消息转发 和上面一样我们创建的对象调用未实现的方法时，类和实例变量的内部是可以这样进行转发的

mark - 对象方法
// 没有实现firstMethod的方法

// 1. 在没有找到方法时，会先调用此方法，和DynicmicInsatance的方法一样就可以动态添加方法3
//    返回YES 表示响应的Selector的实现已经被找到并添加到子类中了
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
//    if (sel == @selector(touch)) {
//        class_addMethod([self class], sel, (IMP)touch, "v@:");
//    }
    return YES;
}

// 2.第二步
//   第一步里面返回之后没有添加新方法，该方法就会被调用，在这个方法中，我们可以指定一个可以返回一个响应方法的独享
//   不能返回Self 死循环
- (id)forwardingTargetForSelector:(SEL)aSelector
{
    return nil;
}

// 3.第三步
//   如果上面返回了nil则该方法会被调用，给系统一个需要的编码
//   如果这里放回的是nil，那是无法执行下一波的，下次无法得到处理
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
    return [NSMethodSignature signatureWithObjCTypes:"v@:"];
}

// 4.第四步
// 调用转发消息方法
- (void)second
{
    NSLog(@"对象方法first方法未被调用，消息转发成了second方法");
}

// 该方法不进行重写就直接进入第五步
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
    [anInvocation setSelector:@selector(second)];
    [anInvocation invokeWithTarget:self];
}

// 5.第五步
// 如果没有调用第四步的转发，那么会进入异常
- (void)doesNotRecognizeSelector:(SEL)aSelector
{
    
    NSLog(@"无法处理的消息:%@",NSStringFromSelector(aSelector));
}

• 先在这里拦截resolveInstanceMethod
• 第一步未动态添加的话就调用forwardingTargetForSelector
• 第二步返回nil来到这里调用methodSignatureForSelector签名
• 重定向消息指针，实现消息转发
• 如果没有实现第四步就doesNotRecognizeSelector异常
  
  
  这几个阶段特性都不太一样：resolvedInstanceMethod 适合给类/对象动态添加一个相应的实现，forwardingTargetForSelector 适合将消息转发给其他对象处理,相对而言，forwardInvocation 是里面最灵活，最能符合需求的。因此 Aspects 的方案就是，对于待 hook 的 selector，将其指向 objc_msgForward / _objc_msgForward_stret ,同时生成一个新的 aliasSelector 指向原来的 IMP，并且 hook 住 forwardInvocation 函数，使他指向自己的实现。按照上面的思路，当被 hook 的 selector 被执行的时候，首先根据 selector 找到了 objc_msgForward / _objc_msgForward_stret ,而这个会触发消息转发，从而进入 forwardInvocation。同时由于 forwardInvocation 的指向也被修改了，因此会转入新的 forwardInvocation 函数，在里面执行需要嵌入的附加代码，完成之后，再转回原来的 IMP。

面向切面Aspects项目应用

7.动态关联属性

// 获取成员变量信息
    unsigned count = 0;
    Ivar *ivarLists = class_copyIvarList(objc_getClass("Tree"), &count);
    for (NSInteger i = 0; i < count; i ++)
    {
        const char *name = ivar_getName(ivarLists[i]);
        NSString *str = [NSString stringWithUTF8String:name];
        NSLog(@"111%@",str);
    }
    
    // 获取属性
    objc_property_t *property = class_copyPropertyList(objc_getClass("Tree"), &count);
    for (NSInteger i = 0; i < count; i++)
    {
        const char *name = property_getName(property[i]);
        NSString *str  = [NSString stringWithUTF8String:name];
        NSLog(@"222%@",str);
    }
    
    // 获取方法
    Method *methods = class_copyMethodList(objc_getClass("Tree"), &count);
    for (NSInteger i = 0; i < count; i++) {
        Method method = methods[i];
        NSLog(@"333%@",NSStringFromSelector(method_getName(method)));
    }
    
    // 获取协议
    __unsafe_unretained Protocol **protocol = class_copyProtocolList([self class], &count);
    for (NSInteger i = 0; i < count; i ++) {
        Protocol *pro = protocol[i];
        const char *nameP = protocol_getName(pro);
        NSLog(@"444%@",[NSString stringWithUTF8String:nameP]);
    }

给Category添加属性以及方法，但是不能添加成员变量的理解 添加一个属性，调用的时候崩溃了，说是找不到getter、setter方法。查了下文档发现，OC的分类允许给分类添加属性，但不会自动生成getter、setter方法。有没有解决方案呢？有，通过运行时建立关联引用 第一个参数id object, 当前对象 第二个参数const void *key, 关联的key，可以是任意类型 第三个参数id value, 被关联的对象 第四个参数objc_AssociationPolicy policy关联引用的规则 关联对象不是为类\对象添加属性或者成员变量(因为在设置关联后也无法通过ivarList或者propertyList取得)

- (void)setSubName:(NSString *)subName
{
    objc_setAssociatedObject(self, "subname", subName, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}


- (NSString *)subName
{
    return objc_getAssociatedObject(self, "subname");
}

那么为什么不能添加成员变量能，但是能添加属性和方法呢？
意思是说，这个函数只能在“构建一个类的过程中”调用。一旦完成类定义，就不能再添加成员变量了。经过编译的类在程序启动后就runtime加载，没有机会调用addIvar。程序在运行时动态构建的类需要在调用objc_registerClassPair之后才可以被使用，同样没有机会再添加成员变量。那为什么可以在类别中添加方法和属性呢？
因为方法和属性并不“属于”类实例，而成员变量“属于”类实例。我们所说的“类实例”概念，指的是一块内存区域，包含了isa指针和所有的成员变量。所以假如允许动态修改类成员变量布局，已经创建出的类实例就不符合类定义了，变成了无效对象。但方法定义是在objc_class中管理的，不管如何增删类方法，都不影响类实例的内存布局，已经创建出的类实例仍然可正常使用。

8.使用Runtime和KVC字典转模型

+ (instancetype)configModelWithDict:(NSDictionary *)jsonDict replaceDict:(NSDictionary *)replaceDict
{
    id obj = [[self alloc] init];
    unsigned int count = 0;
    // 获取变量列表
    Ivar *ivarLists = class_copyIvarList(self, &count);
    // 遍历逐个进行使用
    for (NSInteger i = 0; i < count; i ++)
    {
        // 获取变量对象
        Ivar ivar = ivarLists[i];
        const char *name = ivar_getName(ivar);
        const char *coding = ivar_getTypeEncoding(ivar); // 判断类型
        // 获取自己写的属性变量字符串 _name
        NSString *nameStr = [[NSString stringWithUTF8String:name] substringFromIndex:1];
        NSString *codingstr = [NSString stringWithUTF8String:coding];
        // 根据字符串在原生字典取值
        id value = jsonDict[nameStr];
        // 如果未取到值  说明字段已经修改了
        if (!value) {
            if (replaceDict) {
                // 然后把修改之前的原生字段拿出来进行取值
                NSString *originValue = replaceDict[nameStr];
                // 再赋值
                value = jsonDict[originValue];
            }
        }
        // 避免属性数量大于数据数量的时候，如果多出来的属性是对象类型的那正好是null,无影响，如果多出来的属性是普通类型的，那会把nil赋值过去，直接崩溃
        if ([codingstr isEqualToString:@"f"] || [codingstr isEqualToString:@"d"]) {
            value = @(0.0);
        }
        // kvc进行模型组装 这里的value类型和property里面给的属性效果是一致的，如果属性是BOOL，你强行给字符串，实际类型还是BOOL
        [obj setValue:value forKey:nameStr];
    }
    return obj;
}

上面就是转换的核心代码,分析下主要功能参数
1.通过class_copyIvarList拿到属性列表的数组，ivar_getName这方法拿到属性C类型字符去掉_，转换成OC

2.这里会有个问题，如果自己建的model字段和Json返回的字段完全一致，那么就问题不大，但是由于可读性的关系，我们一般都会做一次映射，这就是replaceDict存在的意义，用例如下：
当你的属性名字是SubName，但是Json返回的字典key是sub_name,显然是不同的，需要映射，我们根据runtime拿到的key也是SubName，那么你根据字典取值，就会出现空值的问题，因此
replaceDict就用到了@{@"SubName":@"sub_name"}，只要映射好传进去，我们里面就能进一步做判断了

3.直接看代码注释

/*
 *  1.首先属性小于数据源的时候是肯定没问题的
 *  2.当属性大于数据源的时候，属性是对象，打印出来就是nil，但是如果属性是基本数据类型，直接崩溃
 *  一定要这么判断是否是基本数据类型
 *  避免属性数量大于数据数量的时候，如果多出来的属性是对象类型的那正好是null,无影响，如果多出来的属性是普通类型的，那会把nil赋值过去，直接崩溃
 *  if ([codingstr isEqualToString:@"f"] || [codingstr isEqualToString:@"d"]) {
 *  value = @(0.0);
 }
 */

这里的F,D什么类型可以参考官方文档类型[type类型文档](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html)

理解了字段和原理，调用代码如下

// 1.URL
    NSString *githubAPI = @"https://api.github.com/users/Tuccuay";
    
    // 2.创建请求对象
    // 对象内部已经包含了请求方法和请求头（GET）
    NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:githubAPI]];
    
    // 3.创建session单例
    NSURLSession *session = [NSURLSession sharedSession];
    
    // 4.根据会话对象发送请求
    NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        
        NSDictionary *jsonDict = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingAllowFragments error:nil];
        MKJModel *mkj = [MKJModel configModelWithDict:jsonDict replaceDict:@{@"mkjLogin":@"login",
                                                                             @"mkjID":@"id",
                                                                             @"mkjAvatar_url":@"avatar_url",
                                                                             @"mkjGravatar_id":@"gravatar_id",
                                                                             @"mkjUrl":@"url",
                                                                             @"mkjHtml_url":@"html_url",
                                                                             @"mkjFollowers_url":@"followers_url",
                                                                             @"mkjFollowing_url":@"following_url",
                                                                             @"mkjGists_url":@"gists_url",
                                                                             @"mkjStarred_url":@"starred_url",
                                                                             }];
        NSLog(@"%@",mkj);
        
    }];
    
    // 5.task resume
    [dataTask resume];

8.runtime实现归档和解档

self.fish = [NSKeyedUnarchiver unarchiveObjectWithFile:self.path];
    [NSKeyedArchiver archiveRootObject:self.fish toFile:self.path];

当外部调用上面归档解档的代码时会走如下方法

- (NSArray *)ignoredNames
{
    return @[];
}
// 解档的时候调用
- (instancetype)initWithCoder:(NSCoder *)aDecoder
{
    if (self == [super init]) {
        [self mkj_initWithCoder:aDecoder];
    }
    return self;
}
// 归档的时候调用
- (void)encodeWithCoder:(NSCoder *)aCoder
{
    [self mkj_encodeWithCoder:aCoder];
}

#pragma mark - 普通模式下的归档和解档
//实现NSCoding协议中的归档方法，需要一个个列出属性来
//- (void)encodeWithCoder:(NSCoder *)aCoder {
//    [aCoder encodeObject:self.name forKey:@"name"];
//    [aCoder encodeObject:self.age forKey:@"age"];
//}
//
//
实现NSCoding协议中的解档方法
//- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder {
//    if (self = [super init]) {
//        self.name = [aDecoder decodeObjectForKey:@"name"];
//        self.age = [aDecoder decodeObjectForKey:@"age"];
//    }
//    return self;
//}
- (NSArray *)ignoredProperty
{
    return @[];
}

- (void)mkj_encodeWithCoder:(NSCoder *)aCoder
{
    Class selfClass = self.class;
    while (selfClass && selfClass != [NSObject class]) {
        unsigned int count = 0;
        Ivar *ivars = class_copyIvarList(selfClass, &count);
        for (NSInteger i = 0; i < count; i ++)
        {
            Ivar ivar = ivars[i];
            const char *ivarName = ivar_getName(ivar);
            NSString *ivarStr = [[NSString stringWithUTF8String:ivarName] substringFromIndex:1];
            if ([self respondsToSelector:@selector(ignoredProperty)]) {
                // 如果归档key为空
                if ([[self ignoredProperty] containsObject:ivarStr]) {
                    continue;
                }
            }
            id value = [self valueForKey:ivarStr];
            [aCoder encodeObject:value forKey:ivarStr];
        }
        free(ivars);
        selfClass = [selfClass superclass];
    }
}

- (void)mkj_initWithCoder:(NSCoder *)aDecoder
{
    Class selfClass = self.class;
    while (selfClass && selfClass != [NSObject class]) {
        unsigned int count = 0;
        Ivar *ivars = class_copyIvarList(selfClass, &count);
        for (NSInteger i = 0; i < count; i ++)
        {
            Ivar ivar = ivars[i];
            const char *ivarName = ivar_getName(ivar);
            NSString *ivarStr = [[NSString stringWithUTF8String:ivarName] substringFromIndex:1];
            if ([self respondsToSelector:@selector(ignoredProperty)]) {
                // 如果归档key为空
                if ([[self ignoredProperty] containsObject:ivarStr]) {
                    continue;
                }
            }
            id value = [aDecoder decodeObjectForKey:ivarStr];
            [self setValue:value forKey:ivarStr];
            
        }
        free(ivars);
        selfClass = [selfClass superclass];
    }
    
}

Runtime动态关联的实际应用1cell值存取

点击每个cell的时候弹出Alert，然后根据不同cell拨打对应的电话

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    MKJTableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"MKJTableViewCell" forIndexPath:indexPath];
    
    MKJModel *model = self.dataSources[indexPath.row];
    cell.phoneNumber.text = model.phoneNumber;
    cell.callBack = ^(UIButton *button){
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"warning" message:model.phoneNumber delegate:self cancelButtonTitle:@"cancel" otherButtonTitles:@"call", nil];
        [alert show];
        // static const void *CallBack = &CallBack;
        // 动态关联
        objc_setAssociatedObject(alert, CallBack, model.phoneNumber, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    };
    return cell;
}

- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
{
    // 取值
    NSString *string = objc_getAssociatedObject(alertView, CallBack);
    NSLog(@"电话%@",string);
}

Runtime动态关联的实际应用2Button添加Block事件

// 声明
typedef void(^MKJBlock)(id sender);

@interface UIControl (MKJBlockEvent)

- (void)tapButtonWithAction:(UIControlEvents)events withBlock:(MKJBlock)block;
// 实现
// 静态变量
static const void *sMKJTouchUpInsideEventKey = "sMKJTouchUpInside";

@implementation UIControl (MKJBlockEvent)

- (void)tapButtonWithAction:(UIControlEvents)events withBlock:(MKJBlock)block
{
    objc_setAssociatedObject(self, sMKJTouchUpInsideEventKey, block, OBJC_ASSOCIATION_COPY_NONATOMIC);
    [self removeTarget:self action:@selector(tapAction:) forControlEvents:events];
    if (block) {
        [self addTarget:self action:@selector(tapAction:) forControlEvents:events];
    }
}

- (void)tapAction:(UIButton *)button
{
    MKJBlock block = objc_getAssociatedObject(self, sMKJTouchUpInsideEventKey);
    if (block) {
        block(button);
    }
}
// 调用自定义，不用系统的addtarget
self.mkjControl = [[UIControl alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];
    self.mkjControl.backgroundColor = [UIColor redColor];
    self.mkjControl.tag = 10086;
    [self.mkjControl tapButtonWithAction:UIControlEventTouchUpInside withBlock:^(UIButton * sender) {
        NSLog(@"custom Action %ld",sender.tag);
        
    }];
    [self.view addSubview:self.mkjControl];

RuntimeMethodSwizzle3给每个页面增加全屏拖反手势

//启用hook，自动对每个导航器开启拖返功能，整个程序的生命周期只允许执行一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        //设置记录type,并且执行hook
        __MLTransitionGestureRecognizerType = type;
        
        __MLTransition_Swizzle([UINavigationController class],@selector(viewDidLoad),@selector(__MLTransition_Hook_ViewDidLoad));
    });

// 具体实现
void __MLTransition_Swizzle(Class c, SEL origSEL, SEL newSEL)
{
    //获取实例方法
    Method origMethod = class_getInstanceMethod(c, origSEL);
    Method newMethod = nil;
	if (!origMethod) {
        //获取静态方法
		origMethod = class_getClassMethod(c, origSEL);
        newMethod = class_getClassMethod(c, newSEL);
    }else{
        newMethod = class_getInstanceMethod(c, newSEL);
    }
    
    if (!origMethod||!newMethod) {
        return;
    }
    
    //自身已经有了就添加不成功，直接交换即可
    if(class_addMethod(c, origSEL, method_getImplementation(newMethod), method_getTypeEncoding(newMethod))){
        //添加成功一般情况是因为，origSEL本身是在c的父类里。这里添加成功了一个继承方法。
        class_replaceMethod(c, newSEL, method_getImplementation(origMethod), method_getTypeEncoding(origMethod));
    }else{
        method_exchangeImplementations(origMethod, newMethod);
	}
}

// 实现Nvc的Category,实现交换之后的方法，然后再找个方法里面增加返回手势
#pragma mark - UINavigationController category interface
@interface UINavigationController(__MLTransition)<UIGestureRecognizerDelegate>

/**
 *  每个导航器都添加一个拖动手势
 */
@property (nonatomic, strong) UIPanGestureRecognizer *__MLTransition_panGestureRecognizer;

- (void)__MLTransition_Hook_ViewDidLoad;

@end

#pragma mark - UINavigationController category implementation
NSString * const k__MLTransition_GestureRecognizer = @"__MLTransition_GestureRecognizer";

@implementation UINavigationController(__MLTransition)

#pragma mark getter and setter
- (void)set__MLTransition_panGestureRecognizer:(UIPanGestureRecognizer *)__MLTransition_panGestureRecognizer
{
    [self willChangeValueForKey:k__MLTransition_GestureRecognizer];
	objc_setAssociatedObject(self, &k__MLTransition_GestureRecognizer, __MLTransition_panGestureRecognizer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    [self didChangeValueForKey:k__MLTransition_GestureRecognizer];
}

- (UIPanGestureRecognizer *)__MLTransition_panGestureRecognizer
{
	return objc_getAssociatedObject(self, &k__MLTransition_GestureRecognizer);
}

#pragma mark hook
- (void)__MLTransition_Hook_ViewDidLoad
{
    [self __MLTransition_Hook_ViewDidLoad];
    
    //初始化拖返手势
    if (!self.__MLTransition_panGestureRecognizer&&[self.interactivePopGestureRecognizer.delegate isKindOfClass:[UIPercentDrivenInteractiveTransition class]]) {
        UIPanGestureRecognizer *gestureRecognizer = nil;

#define kHandleNavigationTransitionKey [@"nTShMTkyGzS2nJquqTyioyElLJ5mnKEco246" __mlDecryptString]
        if (__MLTransitionGestureRecognizerType == MLTransitionGestureRecognizerTypeScreenEdgePan) {
            gestureRecognizer = [[UIScreenEdgePanGestureRecognizer alloc] initWithTarget:self.interactivePopGestureRecognizer.delegate action:NSSelectorFromString(kHandleNavigationTransitionKey)];
            ((UIScreenEdgePanGestureRecognizer*)gestureRecognizer).edges = UIRectEdgeLeft;
        }else{
            gestureRecognizer = [[UIPanGestureRecognizer alloc] initWithTarget:self.interactivePopGestureRecognizer.delegate action:NSSelectorFromString(kHandleNavigationTransitionKey)];
        }
        
        gestureRecognizer.delegate = self;
        gestureRecognizer.__MLTransition_NavController = self;
        
        self.__MLTransition_panGestureRecognizer = gestureRecognizer;
        
        self.interactivePopGestureRecognizer.enabled = NO;
    }
    
    [self.view addGestureRecognizer:self.__MLTransition_panGestureRecognizer];
}

#pragma mark GestureRecognizer delegate
- (BOOL)gestureRecognizerShouldBegin:(UIPanGestureRecognizer *)recognizer
{
    UINavigationController *navVC = self;
    if ([navVC.transitionCoordinator isAnimated]||
        navVC.viewControllers.count < 2) {
        return NO;
    }
    
    UIView* view = recognizer.view;
    if (view.disableMLTransition) {
        return NO;
    }
    CGPoint loc = [recognizer locationInView:view];
    UIView* subview = [view hitTest:loc withEvent:nil];
    UIView *superView = subview;
    while (superView!=view) {
        if (superView.disableMLTransition) { //这个view忽略了拖返
            return NO;
        }
        superView = superView.superview;
    }
    
    //普通拖曳模式，如果开始方向不对即不启用
    if (__MLTransitionGestureRecognizerType==MLTransitionGestureRecognizerTypePan){
        CGPoint velocity = [recognizer velocityInView:navVC.view];
        if(velocity.x<=0) {
            //NSLog(@"不是右滑的");
            return NO;
        }
        
        CGPoint translation = [recognizer translationInView:navVC.view];
        translation.x = translation.x==0?0.00001f:translation.x;
        CGFloat ratio = (fabs(translation.y)/fabs(translation.x));
        //因为上滑的操作相对会比较频繁，所以角度限制少点
        if ((translation.y>0&&ratio>0.618f)||(translation.y<0&&ratio>0.2f)) {
            //NSLog(@"右滑角度不在范围内");
            return NO;
        }
    }
    
    return YES;
}

runtime的基本介绍和使用案例最基本的差不多就这些了，简单概括下方法列表和用法

1、objc_getClass 获取类名

2、objc_msgSend 调用对象的sel

3、class_getClassMethod 获取类方法

4、method_exchangeImplementations 交换两个方法

5、class_addMethod 给类添加方法

6、class_copyIvarList 获取成员变量信息

7、class_copyPropertyList获取属性信息

8、class_copyMethodList获取方法信息

9、class_copyProtocolList获取协议信息

10、objc_setAssociatedObject 动态关联set方法

11、objc_getAssociatedObject 动态关联get方法

12、ivar_getName 获取变量名 char * 类型

13、ivar_getTypeEncoding 获取到属性变量的类型详情类型介绍

Demo传送门

用到过的案例
1.json转model
2.Category动态关联属性
3.MethodSwizzling （1.全局VC容器 2.无码埋点 3.全局拖翻手势 4.避免崩溃越界啥的替换原有方法 5.通过hook alloc new dealloc等，主要思路是在一个时间切片内检测对象的声明周期以观察内存是否会无限增长。通过 hook 掉 alloc，dealloc，retain，release 等方法，来记录对象的生命周期。）
这个hook可以操作很多东西
3.1.JSPatch AOP
3.2.手势返回 method swizziling
3.3.锚点支付返回，切换不同页面跳转
4.消息转发失败检测

新增一个功能，Hook sendAction:to:forEvent 给按钮动态设置连续点击触发的间隔
http://southpeak.github.io/2015/12/13/cocoa-uikit-uicontrol/
https://juejin.im/entry/58971b578d6d81005842867b
https://icetime17.github.io/page/4/

在新增一个 3D touch崩溃imagePicker的问题
https://icetime17.github.io/2016/03/19/2016-03/iOS-使用runtime解决3D-Touch导致UIImagePicker崩溃的问题/

参考：
isa
runtime详解