Runtime ----- 带你上道

阅读原文时间：2023年07月12日阅读：2

在IOS开发和学习过程中，我们经常会接触到一个词： Runtime 。很多开发者对之既熟悉又陌生，基本都是浅尝辄止，达不到灵活使用的水平（话说开发中也确实不经常用。。）本文和大家一起研究一下，Runtime到底是什么，还有他的一些应用场景，毕竟Runtime是OC动态特性的核心，熟练掌握它可以帮助我们更好的控制类的属性及方法，编写出更高效的代码。

一、什么是Runtime

不管你之前如何理解的Runtime，先把他扔一边，我们从头梳理一下：

1、有一种大气而准确的说法：

Objective-C是C语言的扩展，并加入了面向对象特性和Smalltalk式的消息传递机制。OC中的Runtime实现了将C语言转化为面向对象语言的作用，实际上我们的每一条OC代码的执行都会转换为Runtime的函数调用。Runtime是OC底层的实现，其函数的调用是高效的，基于Runtime的代码编写也是高效的！

2、核心：

是一个用C和汇编语言写的Runtime库（开源），这个库所做的事情就是加载类信息，进行方法的分发和转发，正是这个库赋予了Objective-C动态特性。

3、所谓的“动态特性” ：

（1）我们比较下C++ 和OC，C++没有动态特性，编译时直接将代码转换为机器语言，而OC是在运行的时候，通过Runtime把程序转为可令计算机读懂的语言。两者都是对C进行了面向对象的扩展，但是实现机制不同。

（2）虽然RunTime赋予了OC动态特性，使得开发和使用变得相当灵活，但是归根结底OC还是一种编译型的语言，其具有一定的动态性，但是其动态特性也比不上JavaScript这种解释型的语言。

补充：

（3）编译型和解释型语言

编译型：先一次性的编译成平台相关的机器语言文件，运行时脱离开发环境，运行效率高；与特定平台相关，一般无法移植到其他平台。
解释型：不需要事先编译，直接将源代码解释成机器码并立即执行，只要平台提供了相应的解释器即可运行该程序。每次运行时编译，运行效率低，但是只要有解释器，跨平台方便。
JAVA的特殊：编译后（.class）运行在JVM上（解释器）。所以两种类型都属于，更倾向解释型。

4、Runtime 其实有两个版本（也就听听。。）:

（1）“Modern” 和 “Legacy”。我们现在用的 Objective-C 2.0 采用的是现行(Modern)版的 Runtime 系统，只能运行在 iOS 和 OS X 10.5 之后的64位程序中。而OS X较老的32位程序仍采用 Objective-C 1中得(早期) Legacy 版本的 Runtime 系统。这两个版本最大的区别在于当你更改一个类的实例变量的布局时，在早期版本中你需要重新编译它的子类，而现行版本就不需要。

（2）苹果开源了Runtime库的代码，同时GNU也维护着一个开源的版本，这两个版本之间都在努力的保持一致。

5、常见的简单使用场景，后面详细罗列：

（1）动态的创建、改变类

（2）动态的创建、改变、遍历属性

（3）动态的创建、改变、交互、遍历方法

扩展补充：

6、OC编译过程：

编译器：Clang（前端）+ LLVM（后端），前端完成语法语义分析，生成中间文件（和机器无关）。后端先代码优化（和机器无关），再生成机器语言并优化代码（和机器相关）。
bitcode：可以理解为上面说的前端输出产物“中间文件”。有独立的语法，和机器架构无关。在xcode7之后，允许在二进制后面嵌入bitcode（Archive打包），默认开启。
核心过程

<1> 预处理（Pre-process）：把宏替换，删除注释，展开头文件，产生.i文件。

<2> 编译（Compliling）：把之前的.i文件转换成汇编语言，产生.s文件。

<3> 汇编（Asembly）：把汇编语言文件转换为机器码文件，产生.o文件（目标文件）。

<4> 链接（Link）：对.o文件中的对于其他的库的引用的地方进行引用，生成最后的可执行文件（同时也包括多个.o文件进行 link）。

整体过程

<1>写入辅助文件：将项目的文件结构对应表、将要执行的脚本、项目依赖库的文件结构对应表写成文件，方便后面使用；并且创建一个 .app 包，后面编译后的文件都会被放入包中；

<2>运行预设脚本：Cocoapods 会预设一些脚本，当然你也可以自己预设一些脚本来运行。这些脚本都在 Build Phases 中可以看到；

<3>编译文件：针对每一个文件进行编译，生成可执行文件 Mach-O，这过程 LLVM 的完整流程，前端、优化器、后端；

<4>链接文件：将项目中的多个可执行文件合并成一个文件；

<5>拷贝资源文件：将项目中的资源文件拷贝到目标包；

<6>编译 storyboard 文件：storyboard 文件也是会被编译的；

<7>链接 storyboard 文件：将编译后的 storyboard 文件链接成一个文件；

<8>编译 Asset 文件：我们的图片如果使用 Assets.xcassets 来管理图片，那么这些图片将会被编译成机器码，除了 icon 和 launchImage；

　　图片管理方式(Asset和直接拖拽到项目里)的区别：

Asset：

* 1、Xcode创建了图片组，使用图片可省略@2x的后缀写法，直接用图片名来加载图片
- 2、使用imageNamed方法，有缓存，name相当于key。这样可以减少I/O操作，但是内存会一直占用。
- 3、有一定安全性，图片打包后无法轻易直接打开
- 4、适合icon类型小图片

拖拽（resource）：

* 1、图片名称是带有@2x扩展名的完整名称（没有图片组管理）。
- 2、在mainBundle里面，可以用imageWithContentsOfFile:path 加载，随着对象释放而释放，所以适合放大图

<9>运行 Cocoapods 脚本：将在编译项目之前已经编译好的依赖库和相关资源拷贝到包中。

<10>生成 .app 包

<11>将 Swift 标准库拷贝到包中

<12>对包进行签名

<13>完成打包

二、OC中的对象模型

真正开始了解Runtime，有个基础工作需要做，就是我们要重温一下OC的对象和类的结构

1、打开看看objc_object的定义（截图看起来比较清晰，呵呵）

总结一下上面的：

（1）常用的id类型实际上是一个指向objc_object（实例对象）结构体的指针，id通常指代一个对象，也就是说OC对象其实就一个指向objc_object结构体的指针

（2）看objc_object结构体定义，得知其结构体内有一个类型为Class的字段isa，这就是常说的isa指针了。

（3）Class声明为一个指向objc_class的指针

关于 SEL、IMP的补充

（1）SEL是selector在Objective-C中的表示类型。selector可以理解为区别“方法”的ID。

typedef struct objc\_selector \*SEL;  
struct objc\_selector {  
    char \*name;                       OBJC2\_UNAVAILABLE;// 名称  
    char \*types;                      OBJC2\_UNAVAILABLE;// 类型  
};

　　 name和types都是char类型。

（2）IMP是“implementation”的缩写，它是由编译器生成的一个函数指针。当你发起一个消息后，这个函数指针决定了最终执行哪段代码。

2、接下来打开，看看objc_class的定义

研究一下objc_class中的几个字段：

（1）isa：这里的isa指针同样是一个指向objc_class（类对象）的指针，表明该Class的类型，这里的isa指针指向的就是常说的meta-class（元类）了。不难看出，类本身也是一个对象。同样的，元类也是一个对象，为了设计上的完整，元类的isa指针都会指向一个root metaclass（根元类）。根元类本身的isa指针指向自己，这样就形成了一个闭环。

（2）super_class：这个指针就是指向该class的super class，即指向父类，如果该类已经是最顶层的根类(如NSObject或NSProxy)，则super_class为NULL。

（3）cache：用于缓存最近使用的方法。消息发送时，系统会根据isa指针去查找能够响应这个消息的对象。在实际使用中，这个对象只有一部分方法是常用的，如果每次消息来时，都是在methodLists中遍历一遍，性能一定很差。这时，在每次调用过一个方法后，这个方法就会被缓存到cache列表中，下次调用的时候runtime就会优先去cache中查找，如果cache没有，才去methodLists中查找方法。这样，对于那些经常用到的方法的调用，提高了调用的效率。

（4）version：我们可以使用这个字段来提供类的版本信息。这对于对象的序列化非常有用，它可以让我们识别出不同类定义版本中实例变量布局的改变（不太明白的作用。。。）

（5）objc_method_list：方法链表中存放的是该类的成员方法(-方法)，类方法(+方法)存在meta-class的objc_method_list链表中（就是元类的“实例方法”）。

关于结构体指针 Method、Ivar的补充

（1）Method代表类中的某个方法的类型

　声明： typedef struct objc_method *Method;

　objc_method的定义如下：

struct objc\_method {  
    SEL method\_name                   OBJC2\_UNAVAILABLE; // 方法名  
    char \*method\_types                OBJC2\_UNAVAILABLE; // 方法类型  
    IMP method\_imp                    OBJC2\_UNAVAILABLE; // 方法实现  
}

　　方法名method_name类型为SEL。

　　方法类型method_types是一个char指针，存储着方法的参数类型和返回值类型。

方法实现method_imp的类型为IMP

（2）Ivar代表类中实例变量的类型

声明：typedef struct objc_ivar *Ivar

　　 objc_ivar的定义如下：　　

struct objc\_ivar {  
    char \*ivar\_name                   OBJC2\_UNAVAILABLE; // 变量名  
    char \*ivar\_type                   OBJC2\_UNAVAILABLE; // 变量类型  
    int ivar\_offset                   OBJC2\_UNAVAILABLE; // 基地址偏移字节

#ifdef __LP64__
int space OBJC2_UNAVAILABLE; // 占用空间
#endif
}

3、经典配图展示：oc对象继承模型

（1）上图的几个注意点

注意竖直方向和虚线方向代表的不同意义
meta-class的isa指针指向的是root meta-class
root meta-class的isa指针指向的是其本身
root meta-class的super class指向的是root class（这里也是不明白意义所在。。）
root class的super class 指向的是nil

（2）举个方法查找过程的例子：

　调用respondsToSelector: 的时候，实例对象只需要根据其isa指针，找到其所属的class，然后遍历其methodLists，如果没有，那么根据这个类的super_class找到其父类，再看其父类是否能相应这个方法就可以了，直到super_class为nil时，就无法响应这个方法了，return NO。

（3）调用类方法的不同：

　　当我们使用类名调用类方法(+方法)时，只需要根据class的isa指针，找到其meta-class，然后通过meta-class的methodLists找到相应的方法既可（“类”是“元类”的对象）。

三、消息机制

1、OC中调用一个方法的本质就是在给对象发送消息，比如初始化一个NSObject对象：

　　NSObject *object = [[NSObject alloc] init];

事实上，在编译时这句话会翻译成一个C的函数调用，即：

　　objc_msgSend(objc_msgSend([NSObject?class],@selector(alloc)),@selector(init));

看看官方文档：

2、关于消息执行的时机问题：

（1）思考：就如上文所述，OC的代码翻译成C的函数调用之后，就是把OC代码转换成C代码了，那OC的动态特性体现在哪里？不就和C的静态特性一样了么？

（2）回答：对于C语言，函数的调用在编译的时候就会去决定调用哪个函数。而OC是一种动态语言，它会尽可能的把代码执行的决策从编译和链接的时候，推迟到运行时。给一个对象发送的一个消息并不会立即执行，而是在运行的时候再去寻找他对应的实现。这样就可以把消息转发给你想要的对象，或者随意交换一个方法的实现之类的。

3、所有使用objc_msgSend函数，会执行以下步骤（也体现了objc_cache的作用）

（1）通过对象（类）的isa指针去找到他的class

（2）在class的method list 找到该消息的实现

（3）如果class中没有该消息的实现，就继续到它的super_class中去找

（4）一旦找到这个这个消息的实现，那么就去执行他的IMP（函数指针，代码所在空间）

4、常见的函数、头文件

（1） #import : 主要包括成员变量、类、方法

class_copyIvarList : 获得某个类内部的所有成员变量
class_copyMethodList : 获得某个类内部的所有方法
class_getInstanceMethod : 获得某个实例方法（对象方法，减号-开头）
class_getClassMethod : 获得某个类方法（加号+开头）
class_addMethod ：添加方法
class_addProperty ：为类添加属性
class_respondsToSelector：类实例是否响应指定的selector
class_setSuperclass：调整一个类的继承关系
class_replaceProperty：替换类的属性
class_replaceMethod：替换类的方法
ivar_getTypeEncoding ：获得成员变量的类型
ivar_getName : 获得成员变量名
method_exchangeImplementations : 交换2个方法的具体实现

（2） #import : 消息机制

objc_msgSend(….)

四、RunTime的使用实例

RunTime可以很灵活的实现改变系统的方法及属性的效果，灵活度之大以至于也造成了一些隐患 ——— 破坏了系统的封装及代码的可读性，所以大家还是谨慎使用，也不要在开发过程中给队友挖坑（不要问我怎么知道的。。。）

下面搜罗了一些常用的场景：

1、动态创建一个类

#import
// 自定义一个方法
void reportFunction (id self, SEL _cmd) {
NSLog(@"This object is %p", self);
}
int main(int argc, const char * argv[]) {
@autoreleasepool {?? ? ? ?
// 1.动态创建对象创建一个Person 继承自 NSObject类
Class newClass = objc_allocateClassPair([NSObject class], “Person”, 0);?
// 为该类增加名为Report的方法
class_addMethod(newClass, @selector(report), (IMP)reportFunction, @"v@:");?? ? ? ?
// 注册该类
objc_registerClassPair(newClass);
// 创建一个 Student 类的实例
instantOfNewClass = [[newClass alloc] init];
// 调用方法
[instantOfNewClass report];
}
return 0;
}

2、关联对象（分类中动态添加成员变量）

（1）对象在内存中的排布可以看成是一个结构体，该结构体的大小并不能动态的变化，所以无法在运行时动态的给对象增加成员变量，但是我们可以通过关联对象的方法变相的给对象增加一个成员变量。

（2）比如，我们想给NSObject新增一个关联对象（就是添加成员变量）：

创建一个NSObject的分类AssociatedObject，并声明一个新属性

@interface NSObject (AssociatedObject)
@property (nonatomic, strong) id associatedObject;?
@end
在NSObject+AssociatedObject.m文件里面进行关联
#import "NSObject+AssociatedObject.h"
#import
@implementation NSObject (AssociatedObject)
@dynamic associatedObject;

(void)setAssociatedObject:(id)object {
// 设置关联对象
objc_setAssociatedObject(self, @selector(associatedObject), object, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
(id)associatedObject {
// 得到关联对象
return objc_getAssociatedObject(self, @selector(associatedObject));
}
@end

（3）我们可以通过上面的方法，给类动态的添加属性，不过我们更常用的是给一个类动态的添加block回调（想让这个类的实例实现什么业务逻辑，都可以通过赋值block，然后调用，来灵活的实现，使用起来也很方便，和添加属性类似）。

3、交换方法（可更改系统方法）

我们在开发过程中会遇到一种常见的错误：给数组元素赋值nil，系统会崩溃。下面我们参照这个案例，解释下runtime交换方法的实现

（1）先创建一个数组

NSMutableArray \*arrayM = \[NSMutableArray array\];  
\[arrayM addObject:@"1111"\];  
\[arrayM addObject:@"2222"\];  
\[arrayM addObject:nil\];  //这里会造成程序崩溃  
\[arrayM addObject:@"33333"\];

（2）交换方法，将系统的addObject和自定义的方法进行交换，我们先写一个NSMutableArray的分类，给其添加新的方法，然后在其中实现与系统方法交换。注意：“交换”不等同于“替换”

（3）这里有一个坑，addObject 实际上是调用 insertObject ：atIndex：方法，并且在运行过程中，可以看到这个方法是_NSArrayM的方法（不是NSMutableArray的方法，这里有点像KVO的情况），所以我们要拿到_NSArrayM类，然后和它交换方法。可以参照下面的代码：NSClassFromString(@"__NSArrayM”)就是动态过程中获取这个类。

（4）代码实现

@implementation NSMutableArray (XL)

(void)initialize //补充下这个方法只执行一次，类比load方法都是执行一次，但是后者编译完就会执行
{
//当前类被初始化的时候调用
Method m1 = class_getInstanceMethod(NSClassFromString(@"__NSArrayM"), @selector(addObject:));
Method m2 = class_getInstanceMethod(NSClassFromString(@"__NSArrayM"), @selector(new_AddObject:));

//下面这样写也可以
//Method m2 = class_getInstanceMethod([NSMutableArray class], @selector(new_AddObject:));

method_exchangeImplementations(m1, m2);

}

(void)new_AddObject:(id)objc
{
if (objc == nil) {
//这里的方法已经通过交换变成 addObject：
[self new_AddObject:@"此处为空"];

}else{
[self new_AddObject:objc];
}
}
@end

4、KVO的底层实现（自定义KVO）

（1）KVO的底层实现也是利用了RunTime机制，简单点说，KVO机制就是在运行时，动态派生出被检测对象的子类（NSKVONotifying_XXX），将被观察对象的isa指向该子类，然后在新子类中重写观察属性的set方法，接着在set方法里调用观察者的observeValueForKeyPath方法实现的监听机制（晕了吧，这就对了。。。看例子）

（2）给出示例（Person类就不写了，就一个属性age），在控制器中进行监测，下面代码执行结束，会显示监听到的age的变化

@implementation ViewController

(void)viewDidLoad
{
[super viewDidLoad];
Person *p = [[HMPerson alloc] init];
p.age = 20;
self.p = p;

//添加观察者
[p addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew context:nil];

//属性改变了！
p.age = 30;

}

(void)dealloc
{
[self.p removeObserver:self forKeyPath:@"age"];
}
(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
NSLog(@"%@对象的%@属性改变了：%@", object, keyPath, change);
}

@end

（3）分析上面的例子，系统在运行时动态的进行了四项操作：

<1> 生成了Person的子类 NSKVONotifying_Person

<2> 在该子类中重写了age的set方法

<3> 调用了观察者的 - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context 方法

<4> 在p.age = 30 的时候，修改了对象中的isa指针，指向子类NSKVONotifying_Person，这样，在调用set方法的时候就会去子类的空间中寻找方法的地址并调用（很关键的一步，大家可以打断点验证）

（4）模拟KVO过程，我们手动创建一个子类：NSKVONotifying_Person，注意，此时运行会报出“坏内存”的错误，因为你的创建的类和系统自动生成的子类重名了（这也是一种验证KVO原理的方式）

#import "NSKVONotifying_Person.h"

@implementation NSKVONotifying\_HMPerson

-(void)setAge:(int)age  
{  
    //必须先调用父类的setAge方法，保证父类的set方法正常运行  
    \[super setAge:age\];

    //伪代码，调用监听者的方法，实现监听到属性改变后的逻辑操作，并且传递参数  
    \[监听者  observeValueForKeyPath:@"age" ofObject:super change:@{ 监听属性的键值 } context:nil\];

}  
@end

5、模型归档（遍历成员属性的应用）

（1）Runtime可以动态获取成员属性名列表。

（2）下面代码中，Ivar表示的就是成员属性，ivars是指向属性的指针或者说地址（也可以理解为数组，但不是数组）。

（3）归档的实现可能会遇到对象中有很多属性，逐个手动去匹配归档哪些属性很麻烦，所以使用运行时，通过循环实现。

（4）代码示例：对于一个有很多属性的Person类，遵守了NSCoding协议之后，我们可以利用RunTime遍历模型对象的所有属性进行归档，关键代码如下：

// 利用runtime机制进行属性的归档接档

(void)encodeWithCoder:(NSCoder *)aCoder {
unsigned int count = 0;
Ivar *ivars = class_copyIvarList([Person class], &count);
for (int i = 0; i<count; i++) {
// 取出i位置对应的成员变量
Ivar ivar = ivars[i];
// 查看成员变量
const char *name = ivar_getName(ivar);
// 归档
NSString *key = [NSString stringWithUTF8String:name];

//KVC 获得对象属性值
id value = [self valueForKey:key];
[aCoder encodeObject:value forKey:key];
}

// 如果函数名中包含了copy\new\retain\create等字眼，那么这个函数返回的数据就需要手动释放
free(ivars);
}
(id)initWithCoder:(NSCoder *)aDecoder {
self = [super init];
if (self) {
unsigned int count = 0;
Ivar *ivars = class_copyIvarList([Person class], &count);
for (int i = 0; i<count; i++) {
// 取出i位置对应的成员变量
Ivar ivar = ivars[i];
// 查看成员变量
const char *name = ivar_getName(ivar);
// 归档
NSString *key = [NSString stringWithUTF8String:name];
id value = [aDecoder decodeObjectForKey:key];
// 设置到成员变量身上
[self setValue:value forKey:key];
}
free(ivars);
}
return self;
}

6、字典和对象模型之间的转换，例如MJExtension

（1）现在流行的很多字典转模型的框架，基本上都是利用Runtime原理实现（效率高）：遍历模型属性列表—>根据获得的属性名作为key去字典中取出value —>然后用KVC给模型对象属性赋值

（2）这只是简单原理，框架中还包含了很多情况的判断，比如模型套模型的情况，这就需要检测成员属性的类型是否是对象类型，那就继续转模型。

（3）一个简单的示例代码

-(void)modelToolWithDict:(NSDictionary *)dict andModel:(Model*)model
{
// Ivar : 成员变量
unsigned int count = 0;
// 获得所有的成员变量
Ivar *ivars = class_copyIvarList([HMPerson class], &count);
for (int i = 0; i<count; i++) {
// 取得i位置的成员变量
Ivar ivar = ivars[i];
const char *name = ivar_getName(ivar);
// 获得成员变量的类型，如果需要根据类型判断是否有模型嵌套，可以通过这个变量
const char *type = ivar_getTypeEncoding(ivar);

    //获得字典中的值  
    id value = dict\[\[NSString stringWithUTF8String:name\]\];

    //使用KVC给模型赋值（KVC底层也是Runtime）  
    \[model setValue:value forKeyPath:\[NSString stringWithUTF8String:name\]\];

    NSLog(@"%d %s %s", i, name, type);  
}

}

补充：value for key 和 object for key的区别

1、两者都是键值对应。

2、valueforkey是KVC的方法，只允许使用NSString类型。

3、objectforkey是NSDictionary的方法，可以是任意类型。

4、如果key不是以@开头，则这两个方法是“等价”的。但如果key以@开头，valueForKey去掉@符号后剩下部分作为key值去执行方法（可能会crash）

7、避免数组越界

开发中，数组在访问时如果越界会造成崩溃，为了避免这种潜在的崩溃风险，我们可以采用多种方法“强制”它不越界，比如重写get方法进行内部判断，这里我们用Runtime来做一个比较彻底的解决。

（1）越界的情况：names数组有10个元素，调用 self.names[10] ，崩溃；

这行代码的本质是： [self.names objectAtIndex:10]，所以，我们用运行时进行这个方法的交换。

（2）添加如下分类，后面出现数组访问越界的情况，将返回nil；

（3）因为是在load方法中实现的交换，所以，程序启动内存中加载了这个分类后，自动执行交换，不需要导入任何头文件了。

（4）核心代码

@implementation NSArray(Extension)

(void)load
{
Method otherMehtod = class_getInstanceMethod(class, otherSelector);
Method originMehtod = class_getInstanceMethod(class, originSelector);
// 交换2个方法的实现
method_exchangeImplementations(otherMehtod, originMehtod);
}
(id)new_ObjectAtIndex:(NSUInteger)index
{
if (index < self.count) {
return [self new_ObjectAtIndex:index];
} else {
return nil;
}
}
@end

8、自动显示“空”的tableView

当tableView的数据源为空时，我们一般会将tableView隐藏，同时贴上去一个“没有加载到内容”之类的提示视图；或者编写一个cell来显示“空”，来给用户一个友善的交互提示。这样写可以，但是比较麻烦，现在用运行时，直接给tableView添加特性，可以自动判断数据源是否为空，并且展示出用户想要展示的“空”视图。

@interface UIScrollView (YWEmptyView)

/** 空页面，开发者自定义*/
@property (nonatomic, strong) UIView *emptyView;

@end

#import "UIScrollView+YWEmptyView.h"
#import

static const char emptyKey;

@implementation UIScrollView (YWEmptyView)

(UIView *)emptyView {
return objc_getAssociatedObject(self, &emptyKey);
}
(void)setEmptyView:(UIView *)emptyView {
objc_setAssociatedObject(self, &emptyKey, emptyView, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
[self addSubview:self.emptyView];
}
//获取当前数据源数量
(NSInteger)getTotalCount {
NSInteger totalCount = ;
if ([self isKindOfClass:[UITableView class]]) {
UITableView *tableView = (UITableView *)self;
for (NSInteger section = ; section < tableView.numberOfSections; section++) {
totalCount += [tableView numberOfRowsInSection:section];
}
} else if ([self isKindOfClass:[UICollectionView class]]) {
UICollectionView *collectionView = (UICollectionView *)self;
for (NSInteger section = ; section < collectionView.numberOfSections; section++) {
totalCount += [collectionView numberOfItemsInSection:section];
}
}
return totalCount;
}

//判断是否显示“空”视图

(void)showEmptyView {
[self bringSubviewToFront:self.emptyView];
if ([self getTotalCount] > ) {
self.emptyView.hidden = YES;
}else {
self.emptyView.hidden = NO;
}
}

@end

@implementation UITableView (YWEmptyView)

(void)load {
SEL reloadSEL = @selector(reloadData);
SEL shareReloadSEL = @selector(shareReloadData);

Method reloadData = class_getInstanceMethod(self, reloadSEL);
Method shareReloadData = class_getInstanceMethod(self, shareReloadSEL);

BOOL success = class_addMethod(self, reloadSEL, method_getImplementation(shareReloadData), method_getTypeEncoding(shareReloadData));
if (success) {
class_replaceMethod(self, shareReloadSEL, method_getImplementation(reloadData), method_getTypeEncoding(reloadData));
} else {
method_exchangeImplementations(reloadData, shareReloadData);
}
}

//新的刷新方法，和原来的reload进行交换

(void)shareReloadData {
[self shareReloadData];
[self showEmptyView];
}

@end

@implementation UICollectionView (YWEmptyView)

(void)load {
Method reloadData = class_getInstanceMethod(self, @selector(reloadData));
Method shareReloadData = class_getInstanceMethod(self, @selector(shareReloadData));
method_exchangeImplementations(reloadData, shareReloadData);
}
(void)shareReloadData {
[self shareReloadData];
[self showEmptyView];
}

@end

9、按钮的防暴力点击

就是给按钮设置防暴力点击的方法，原理：设置一个时间clickInterval和一个标记位ignoreClick，点击按钮的时候标记位被设置“YES”，之后任何点击事件不再响应，直到过了clickInterval时长之后，还原标记位为“No”，并且按钮可以再次响应点击事件。

@interface UIControl (ClickRepeatedly)
/**
* 设置点击的间隔（防止反复点击）
*/
@property (nonatomic, assign)NSTimeInterval clickInterval;

@property (nonatomic, assign)BOOL ignoreClick;

@end

#import "UIControl+ClickRepeatedly.h"
#import

static const char *ClickIntervalKey;
static const char *IgnoreClick;
@implementation UIControl (ClickRepeatedly)

(void)setClickInterval:(NSTimeInterval)clickInterval{
objc_setAssociatedObject(self, &ClickIntervalKey, @(clickInterval), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
(NSTimeInterval)clickInterval{

return [objc_getAssociatedObject(self, &ClickIntervalKey) doubleValue];
}
(void)setIgnoreClick:(BOOL)ignoreClick{
objc_setAssociatedObject(self, &IgnoreClick, @(ignoreClick), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
(BOOL)ignoreClick{
return [objc_getAssociatedObject(self, &IgnoreClick) boolValue];
}
(void)load{
//替换点击事件
Method a = class_getInstanceMethod(self, @selector(sendAction:to:forEvent:));
Method b = class_getInstanceMethod(self, @selector(rc_sendAction:to:forEvent:));
method_exchangeImplementations(a, b);
}
(void)rc_sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event{
if (self.ignoreClick) {
return;
}
else{
[self rc_sendAction:action to:target forEvent:event];
}
if (self.clickInterval > )
{
self.ignoreClick = YES;
[self performSelector:@selector(setIgnoreClick:) withObject:@(NO) afterDelay:self.clickInterval];
}