iOS-RunTime在实际开发中的应用

什么是runtime？

runtime 是 OC底层的一套C语言的API（引入 或），编译器最终都会将OC代码转化为运行时代码，通过终端命令编译.m 文件：clang -rewrite-objcxxx.m可以看到编译后的xxx.cpp（C++文件）。 比如我们创建了一个对象 [[NSObject alloc]init]，最终被转换为几万行代码，截取最关键的一句可以看到底层是通过runtime创建的对象

1385290-e7f47ce0ecd97987.png

.cpp 文件

删除掉一些强制转换语句，可以看到调用方法本质就是发消息，[[NSObject alloc]init]语句发了两次消息，第一次发了alloc消息，第二次发送init 消息。利用这个功能我们可以探究底层，比如block的实现原理。 需要注意的是，使用objc_msgSend() sel_registerName()方法需要导入头文件

1385290-fe1270bad1a08784.png

RunTime中常用的基本概念

SEL

它是selector在 Objc 中的表示(Swift 中是 Selector 类)。selector是方法选择器，其实作用就和名字一样，日常生活中，我们通过人名辨别谁是谁，注意 Objc 在相同的类中不会有命名相同的两个方法。selector对方法名进行包装，以便找到对应的方法实现。它的数据结构是：

typedef struct objc_selector *SEL;

我们可以看出它是个映射到方法的 C 字符串，你可以通过 Objc 编译器器命令@selector() 或者 Runtime 系统的sel_registerName函数来获取一个 SEL 类型的方法选择器。

注意： 不同类中相同名字的方法所对应的 selector 是相同的，由于变量的类型不同，所以不会导致它们调用方法实现混乱。

id

id 是一个参数类型，它是指向某个类的实例的指针。定义如下：

typedef struct objc_object *id;
struct objc_object { Class isa; };

以上定义，看到 objc_object 结构体包含一个isa指针，根据 isa 指针就可以找到对象所属的类。

注意： isa 指针在代码运行时并不总指向实例对象所属的类型，所以不能依靠它来确定类型，要想确定类型还是需要用对象的 -class 方法。KVO 的实现机理就是将被观察对象的 isa 指针指向一个中间类而不是真实类型。

Class

typedef struct objc_class *Class;

Class 其实是指向 objc_class 结构体的指针。objc_class 的数据结构如下：

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;

从 objc_class 可以看到，一个运行时类中关联了它的父类指针、类名、成员变量、方法、缓存以及附属的协议。

其中 objc_ivar_list 和 objc_method_list分别是成员变量列表和方法列表：

// 成员变量列表
struct objc_ivar_list {
  int ivar_count                                           OBJC2_UNAVAILABLE;
#ifdef __LP64__
  int space                                               OBJC2_UNAVAILABLE;
#endif
  /* variable length structure */
  struct objc_ivar ivar_list[1]                           OBJC2_UNAVAILABLE;
}                                                           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;
}

由此可见，我们可以动态修改 *methodList 的值来添加成员方法，这也是 Category 实现的原理，同样解释了 Category不能添加属性的原因。

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

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

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

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

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

上图实现是 super_class 指针，虚线时 isa 指针。而根元类的父类是 NSObject，isa指向了自己。而 NSObject没有父类。

最后 objc_class 中还有一个 objc_cache ，缓存，它的作用很重要，后面会提到。

Method

Method 代表类中某个方法的类型

typedef struct objc_method *Method;
​
struct objc_method {
  SEL method_name                                         OBJC2_UNAVAILABLE;
  char *method_types                                       OBJC2_UNAVAILABLE;
  IMP method_imp                                           OBJC2_UNAVAILABLE;
}

objc_method 存储了方法名，方法类型和方法实现：

• 方法名类型为 SEL

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

• method_imp 指向了方法的实现，本质是一个函数指针

Ivar

Ivar 是表示成员变量的类型。

typedef struct objc_ivar *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
}

其中 ivar_offset 是基地址偏移字节

IMP

IMP在objc.h中的定义是：

typedef id (*IMP)(id, SEL, ...);

它就是一个函数指针，这是由编译器生成的。当你发起一个 ObjC 消息之后，最终它会执行的那段代码，就是由这个函数指针指定的。而 IMP这个函数指针就指向了这个方法的实现。

如果得到了执行某个实例某个方法的入口，我们就可以绕开消息传递阶段，直接执行方法，这在后面 Cache 中会提到。

你会发现 IMP指向的方法与 objc_msgSend 函数类型相同，参数都包含 id和SEL 类型。每个方法名都对应一个 SEL类型的方法选择器，而每个实例对象中的 SEL 对应的方法实现肯定是唯一的，通过一组 id和 SEL 参数就能确定唯一的方法实现地址。

而 一个确定的方法也只有唯一的一组 id 和 SEL 参数 。

Cache

Cache 定义如下：

typedef struct objc_cache *Cache
​
struct objc_cache {
  unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
  unsigned int occupied                                   OBJC2_UNAVAILABLE;
  Method buckets[1]                                       OBJC2_UNAVAILABLE;
};

Cache 为方法调用的 性能进行优化 ， 每当实例对象接收到一个消息时，它不会直接在 isa指针指向的类的方法列表中遍历查找能够响应的方法，因为每次都要查找效率太低了，而是优先在 Cache 中查找 。

Runtime 系统会把被调用的方法存到 Cache中，如果一个方法被调用，那么它有可能今后还会被调用，下次查找的时候就会效率更高。就像计算机组成原理中 CPU 绕过主存先访问 Cache 一样。

RunTime在实际开发中的应用

利用runtime 可以做一些OC不容易实现的功能

• 动态交换两个方法的实现（特别是交换系统自带的方法）

• 动态添加对象的成员变量和成员方法

• 获得某个类的所有成员方法、所有成员变量

*将某些OC代码转为运行时代码，探究底层，比如block的实现原理

*拦截系统自带的方法调用（Swizzle 黑魔法），比如拦截imageNamed:、viewDidLoad、alloc

*实现NSCoding的自动归档和自动解档

*实现字典和模型的自动转换。

下面通过demo 一个个来讲解具体应用

一、交换两个方法的实现，拦截系统自带的方法调用功能

需要用到的方法

• 获得某个类的类方法

  Method class_getClassMethod(Class cls , SEL name)

• 获得某个类的实例对象方法

  Method class_getInstanceMethod(Class cls , SEL name)

• 交换两个方法的实现

  void method_exchangeImplementations(Method m1 , Method m2)

想使用runtime，首先在写运行时代码之前，要先加上头文件：

#import  // 模拟器

或者

#import  // 真机
#import  // 真机

一、动态添加一个类

KVO的实现是利用了runtime能够动态添加类）

原来当你对一个对象进行观察时, 系统会自动新建一个类继承自原类, 然后重写被观察属性的setter方法.然后重写的setter方法会负责在调用原setter方法前后通知观察者. 然后把原对象的isa指针指向这个新类, 我们知道,对象是通过isa指针去查找自己是属于哪个类, 并去所在类的方法列表中查找方法的, 所以这个时候这个对象就自然地变成了新类的实例对象.

就像KVO一样, 系统是在程序运行的时候根据你要监听的类, 动态添加一个新类继承自该类, 然后重写原类的setter方法并在里面通知observer的.

那么, 如何动态添加一个类呢?

// 创建一个类(size_t extraBytes该参数通常指定为0, 该参数是分配给类和元类对象尾部的索引ivars的字节数。)
Class clazz = objc_allocateClassPair([NSObject class], "GoodPerson", 0);
​
// 添加ivar
// @encode(aType) : 返回该类型的C字符串
class_addIvar(clazz, "_name", sizeof(NSString *), log2(sizeof(NSString *)), @encode(NSString *));
​
class_addIvar(clazz, "_age", sizeof(NSUInteger), log2(sizeof(NSUInteger)), @encode(NSUInteger));
​
// 注册该类
objc_registerClassPair(clazz);
​
// 创建实例对象
id object = [[clazz alloc] init];
​
// 设置ivar
[object setValue:@"Tracy" forKey:@"name"];
​
Ivar ageIvar = class_getInstanceVariable(clazz, "_age");
object_setIvar(object, ageIvar, @18);
​
// 打印对象的类和内存地址
NSLog(@"%@", object);
​
// 打印对象的属性值
NSLog(@"name = %@, age = %@", [object valueForKey:@"name"], object_getIvar(object, ageIvar));
​
// 当类或者它的子类的实例还存在，则不能调用objc_disposeClassPair方法
object = nil;
​
// 销毁类
objc_disposeClassPair(clazz);

这样, 我们就在程序运行时动态添加了一个继承自NSObject的GoodPerson类, 并为该类添加了name和age成员变量.

二、通过runtime获取一个类的所有属性，我们可以做些什么？

1. 打印一个类的所有ivar, property 和 method（简单直接的使用）

Person *p = [[Person alloc] init];
[p setValue:@"Kobe" forKey:@"name"];
[p setValue:@18 forKey:@"age"];
//   p.address = @"广州大学城";
p.weight = 110.0f;
​
// 1.打印所有ivars
unsigned int ivarCount = 0;
// 用一个字典装ivarName和value
NSMutableDictionary *ivarDict = [NSMutableDictionary dictionary];
Ivar *ivarList = class_copyIvarList([p class], &ivarCount);
for(int i = 0; i < ivarCount; i++){
  NSString *ivarName = [NSString stringWithUTF8String:ivar_getName(ivarList[i])];
  id value = [p valueForKey:ivarName];
​
  if (value) {
      ivarDict[ivarName] = value;
  } else {
      ivarDict[ivarName] = @"值为nil";
  }
}
// 打印ivar
for (NSString *ivarName in ivarDict.allKeys) {
  NSLog(@"ivarName:%@, ivarValue:%@",ivarName, ivarDict[ivarName]);
}
​
// 2.打印所有properties
unsigned int propertyCount = 0;
// 用一个字典装propertyName和value
NSMutableDictionary *propertyDict = [NSMutableDictionary dictionary];
objc_property_t *propertyList = class_copyPropertyList([p class], &propertyCount);
for(int j = 0; j < propertyCount; j++){
  NSString *propertyName = [NSString stringWithUTF8String:property_getName(propertyList[j])];
  id value = [p valueForKey:propertyName];
​
  if (value) {
      propertyDict[propertyName] = value;
  } else {
      propertyDict[propertyName] = @"值为nil";
  }
}
// 打印property
for (NSString *propertyName in propertyDict.allKeys) {
  NSLog(@"propertyName:%@, propertyValue:%@",propertyName, propertyDict[propertyName]);
}
​
// 3.打印所有methods
unsigned int methodCount = 0;
// 用一个字典装methodName和arguments
NSMutableDictionary *methodDict = [NSMutableDictionary dictionary];
Method *methodList = class_copyMethodList([p class], &methodCount);
for(int k = 0; k < methodCount; k++){
  SEL methodSel = method_getName(methodList[k]);
  NSString *methodName = [NSString stringWithUTF8String:sel_getName(methodSel)];
​
  unsigned int argumentNums = method_getNumberOfArguments(methodList[k]);
​
  methodDict[methodName] = @(argumentNums - 2); // -2的原因是每个方法内部都有self 和 selector 两个参数
}
// 打印method
for (NSString *methodName in methodDict.allKeys) {
  NSLog(@"methodName:%@, argumentsCount:%@", methodName, methodDict[methodName]);
}

2. 动态变量控制

在程序中，XiaoMing的age是10，后来被runtime变成了20，来看看runtime是怎么做到的：

-(void)changeAge{
    unsigned int count = 0;
    //动态获取XiaoMing类中的所有属性[当然包括私有] 
    Ivar *ivar = class_copyIvarList([self.xiaoMing class], &count);
    //遍历属性找到对应age字段 
    for (int i = 0; i

3. 在NSObject的分类中增加方法来避免使用KVC赋值的时候出现崩溃

在有些时候我们需要通过KVC去修改某个类的私有变量，但是又不知道该属性是否存在，如果类中不存在该属性，那么通过KVC赋值就会crash，这时也可以通过运行时进行判断。同样我们在NSObject的分类中增加如下方法。

* 判断类中是否有该属性
*
* @param property 属性名称
*
* @return 判断结果
*/
-(BOOL)hasProperty:(NSString *)property {
  BOOL flag = NO;
  u_int count = 0;
  Ivar *ivars = class_copyIvarList([self class], &count);
  for (int i = 0; i < count; i++) {
      const char *propertyName = ivar_getName(ivars[I]);
      NSString *propertyString = [NSString stringWithUTF8String:propertyName];
      if ([propertyString isEqualToString:property]){
          flag = YES;
      }
  }
}

三、动态添加方法

开发使用场景 ：如果一个类方法非常多，加载类到内存的时候也比较耗费资源，需要给每个方法生成映射表，可以使用动态给某个类，添加方法解决。

经典面试题 ：有没有使用performSelector，其实主要想问你有没有动态添加过方法。

简单使用：

@implementation ViewController
​
- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
​
  Person *p = [[Person alloc] init];
​
  // 默认person，没有实现eat方法，可以通过performSelector调用，但是会报错。
  // 动态添加方法就不会报错
  [p performSelector:@selector(eat)];
​
}
@end

@implementation Person
// void(*)()
// 默认方法都有两个隐式参数，
void eat(id self,SEL sel)
{
  NSLog(@"%@ %@",self,NSStringFromSelector(sel));
}
​
// 当一个对象调用未实现的方法，会调用这个方法处理,并且会把对应的方法列表传过来.
// 刚好可以用来判断，未实现的方法是不是我们想要动态添加的方法
+ (BOOL)resolveInstanceMethod:(SEL)sel
{
​
  if (sel == @selector(eat)) {
      // 动态添加eat方法
​
      // 第一个参数：给哪个类添加方法
      // 第二个参数：添加方法的方法编号
      // 第三个参数：添加方法的函数实现（函数地址）
      // 第四个参数：函数的类型，(返回值+参数类型) v:void @:对象->self :表示SEL->_cmd
      class_addMethod(self, @selector(eat), eat, "v@:");
​
  }
​
  return [super resolveInstanceMethod:sel];
}
@end

---

四、方法简单的交换

创建一个Person类，类中实现以下两个类方法，并在.h 文件中声明

+ (void)run {
  NSLog(@"跑");
}
​
+ (void)study {
  NSLog(@"学习");
}

控制器中调用，则先打印跑，后打印学习

[Person run];
[Person study];

下面通过runtime 实现方法交换，类方法用class_getClassMethod ，对象方法用class_getInstanceMethod

// 获取两个类的类方法
Method m1 = class_getClassMethod([Person class], @selector(run));
Method m2 = class_getClassMethod([Person class], @selector(study));
// 开始交换方法实现
method_exchangeImplementations(m1, m2);
// 交换后，先打印学习，再打印跑！
[Person run];
[Person study];

五、拦截系统方法

需求：比如iOS6 升级 iOS7后需要版本适配，根据不同系统使用不同样式图片（拟物化和扁平化），如何通过不去手动一个个修改每个UIImage的imageNamed：方法就可以实现为该方法中加入版本判断语句？

步骤： 1、为UIImage建一个分类（UIImage+Category） 2、在分类中实现一个自定义方法，方法中写要在系统方法中加入的语句，比如版本判断

+ (UIImage *)xh_imageNamed:(NSString *)name {
  double version = [[UIDevice currentDevice].systemVersion doubleValue];
  if (version >= 7.0) {
      // 如果系统版本是7.0以上，使用另外一套文件名结尾是‘_os7’的扁平化图片
      name = [name stringByAppendingString:@"_os7"];
  }
  return [UIImage xh_imageNamed:name];
}

3、分类中重写UIImage的load方法，实现方法的交换（只要能让其执行一次方法交换语句，load再合适不过了）

+ (void)load {
  // 获取两个类的类方法
  Method m1 = class_getClassMethod([UIImage class], @selector(imageNamed:));
  Method m2 = class_getClassMethod([UIImage class], @selector(xh_imageNamed:));
  // 开始交换方法实现
  method_exchangeImplementations(m1, m2);
}

注意：自定义方法中最后一定要再调用一下系统的方法，让其有加载图片的功能，但是由于方法交换，系统的方法名已经变成了我们自定义的方法名（有点绕，就是用我们的名字能调用系统的方法，用系统的名字能调用我们的方法），这就实现了系统方法的拦截！

利用以上思路，我们还可以给 NSObject添加分类，统计创建了多少个对象，给控制器添加分类，统计有创建了多少个控制器，特别是公司需求总变的时候，在一些原有控件或模块上添加一个功能，建议使用该方法！

二、在分类中设置属性，给任何一个对象设置属性

众所周知，分类中是无法设置属性的，如果在分类的声明中写@property 只能为其生成get 和 set方法的声明，但无法生成成员变量，就是虽然点语法能调用出来，但程序执行后会crash，有人会想到使用全局变量呢？比如这样：

int _age;
​
- (int )age {
  return _age;
}
​
- (void)setAge:(int)age {
  _age = age;
}

但是全局变量程序整个执行过程中内存中只有一份，我们创建多个对象修改其属性值都会修改同一个变量，这样就无法保证像属性一样每个对象都拥有其自己的属性值。这时我们就需要借助runtime为分类增加属性的功能了。

需要用到的方法

• set方法，将值value 跟对象object 关联起来（将值value 存储到对象object 中） 参数 object：给哪个对象设置属性 参数 key：一个属性对应一个Key，将来可以通过key取出这个存储的值，key 可以是任何类型：double、int 等，建议用char 可以节省字节 参数 value：给属性设置的值 参数policy：存储策略 （assign 、copy 、 retain就是strong）

    void objc_setAssociatedObject(id object , const void *key ,id value ,objc_AssociationPolicy policy)

• 利用参数key 将对象object中存储的对应值取出来

    id objc_getAssociatedObject(id object , const void *key)

步骤： 1、创建一个分类，比如给任何一个对象都添加一个name属性，就是NSObject添加分类（NSObject+Category） 2、先在.h 中@property 声明出get 和 set 方法，方便点语法调用

NSString *name;

3、在.m 中重写set 和 get 方法，内部利用runtime 给属性赋值和取值

​
- (void)setName:(NSString *)name {
  // 将某个值跟某个对象关联起来，将某个值存储到某个对象中
  objc_setAssociatedObject(self, &nameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
​
- (NSString *)name {
  return objc_getAssociatedObject(self, &nameKey);
}

三、获得一个类的所有成员变量

最典型的用法就是一个对象在归档和解档的encodeWithCoder和initWithCoder:方法中需要该对象所有的属性进行decodeObjectForKey: 和encodeObject:，通过runtime我们声明中无论写多少个属性，都不需要再修改实现中的代码了。

需要用到的方法

• 获得某个类的所有成员变量（outCount 会返回成员变量的总数） 参数： 1、哪个类 2、放一个接收值的地址，用来存放属性的个数 3、返回值：存放所有获取到的属性，通过下面两个方法可以调出名字和类型

    Ivar *class_copyIvarList(Class cls , unsigned int *outCount)

• 获得成员变量的名字

    const char *ivar_getName(Ivar v)

• 获得成员变量的类型

    const char *ivar_getTypeEndcoding(Ivar v)

案例1：获取Person类中所有成员变量的名字和类型

unsigned int outCount = 0;
Ivar *ivars = class_copyIvarList([Person class], &outCount);
​
// 遍历所有成员变量
for (int i = 0; i < outCount; i++) {
  // 取出i位置对应的成员变量
  Ivar ivar = ivars[I];
  const char *name = ivar_getName(ivar);
  const char *type = ivar_getTypeEncoding(ivar);
  NSLog(@"成员变量名：%s 成员变量类型：%s",name,type);
}
// 注意释放内存！
free(ivars);

案例2：利用runtime 获取所有属性来重写归档解档方法

// 设置不需要归解档的属性
- (NSArray *)ignoredNames {
  return @[@"_aaa",@"_bbb",@"_ccc"];
}
​
// 解档方法
- (instancetype)initWithCoder:(NSCoder *)aDecoder {
  if (self = [super initWithCoder:aDecoder]) {
      // 获取所有成员变量
      unsigned int outCount = 0;
      Ivar *ivars = class_copyIvarList([self class], &outCount);

      for (int i = 0; i < outCount; i++) {
          Ivar ivar = ivars[I];
          // 将每个成员变量名转换为NSString对象类型
          NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

          // 忽略不需要解档的属性
          if ([[self ignoredNames] containsObject:key]) {
              continue;
          }

          // 根据变量名解档取值，无论是什么类型
          id value = [aDecoder decodeObjectForKey:key];
          // 取出的值再设置给属性
          [self setValue:value forKey:key];
          // 这两步就相当于以前的 self.age = [aDecoder decodeObjectForKey:@"_age"];
      }
      free(ivars);
  }
  return self;
}
​
// 归档调用方法
- (void)encodeWithCoder:(NSCoder *)aCoder {
    // 获取所有成员变量
  unsigned int outCount = 0;
  Ivar *ivars = class_copyIvarList([self class], &outCount);
  for (int i = 0; i < outCount; i++) {
      Ivar ivar = ivars[I];
      // 将每个成员变量名转换为NSString对象类型
      NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

      // 忽略不需要归档的属性
      if ([[self ignoredNames] containsObject:key]) {
          continue;
      }

      // 通过成员变量名，取出成员变量的值
      id value = [self valueForKeyPath:key];
      // 再将值归档
      [aCoder encodeObject:value forKey:key];
      // 这两步就相当于 [aCoder encodeObject:@(self.age) forKey:@"_age"];
  }
  free(ivars);
}

依据上面的原理我们就可以给NSObject做一个分类，让我们不需要每次都写这么一长串代码，只要实现一小段代码就可以让一个对象具有归解档的能力。

注意，下面的代码我换了一个方法名（不然会覆盖系统原来的方法！），加了一个忽略属性方法是否被实现的判断，并加上了对父类属性的归解档循环。

NSObject+Extension.h

#import 
​
@interface NSObject (Extension)
​
- (NSArray *)ignoredNames;
- (void)encode:(NSCoder *)aCoder;
- (void)decode:(NSCoder *)aDecoder;
​
@end

NSObject+Extension.m

#import "NSObject+Extension.h"
#import 
​
@implementation NSObject (Extension)
​
- (void)decode:(NSCoder *)aDecoder {
  // 一层层父类往上查找，对父类的属性执行归解档方法
  Class c = self.class;
  while (c &&c != [NSObject class]) {

      unsigned int outCount = 0;
      Ivar *ivars = class_copyIvarList(c, &outCount);
      for (int i = 0; i < outCount; i++) {
          Ivar ivar = ivars[I];
          NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

          // 如果有实现该方法再去调用
          if ([self respondsToSelector:@selector(ignoredNames)]) {
              if ([[self ignoredNames] containsObject:key]) continue;
          }

          id value = [aDecoder decodeObjectForKey:key];
          [self setValue:value forKey:key];
      }
      free(ivars);
      c = [c superclass];
  }

}
​
- (void)encode:(NSCoder *)aCoder {
  // 一层层父类往上查找，对父类的属性执行归解档方法
  Class c = self.class;
  while (c &&c != [NSObject class]) {

      unsigned int outCount = 0;
      Ivar *ivars = class_copyIvarList([self class], &outCount);
      for (int i = 0; i < outCount; i++) {
          Ivar ivar = ivars[I];
          NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

          // 如果有实现该方法再去调用
          if ([self respondsToSelector:@selector(ignoredNames)]) {
              if ([[self ignoredNames] containsObject:key]) continue;
          }

          id value = [self valueForKeyPath:key];
          [aCoder encodeObject:value forKey:key];
      }
      free(ivars);
      c = [c superclass];
  }
}
@end

上面分类使用方法：在需要归解档的对象中实现下面方法即可：

// 设置需要忽略的属性
- (NSArray *)ignoredNames {
  return @[@"bone"];
}
​
// 在系统方法内来调用我们的方法
- (instancetype)initWithCoder:(NSCoder *)aDecoder {
  if (self = [super init]) {
      [self decode:aDecoder];
  }
  return self;
}
​
- (void)encodeWithCoder:(NSCoder *)aCoder {
  [self encode:aCoder];
}

这样看来，我们每次又要写同样的代码，我们可以将归解档两个方法封装为宏，在需要的地方一句宏搞定，如果有不需要归解档的属性就实现ignoredNames方法，具体可以看我的demo，这个也是MJExtension中那个一句宏就可以解决归解档的实现原理。

案例3：利用runtime 获取所有属性来进行字典转模型

字典转模型的第一步：设计模型

• 模型属性，通常需要跟字典中的key一一对应

• 问题：一个一个的生成模型属性，很慢？

• 需求：能不能自动根据一个字典，生成对应的属性。

• 解决：提供一个分类，专门根据字典生成对应的属性字符串。

@implementation NSObject (Log)

// 自动打印属性字符串
+ (void)resolveDict:(NSDictionary *)dict{
​
  // 拼接属性字符串代码
  NSMutableString *strM = [NSMutableString string];
​
  // 1.遍历字典，把字典中的所有key取出来，生成对应的属性代码
  [dict enumerateKeysAndObjectsUsingBlock:^(id _Nonnull key, id _Nonnull obj, BOOL * _Nonnull stop) {
​
      // 类型经常变，抽出来
        NSString *type;
​
      if ([obj isKindOfClass:NSClassFromString(@"__NSCFString")]) {
          type = @"NSString";
      }else if ([obj isKindOfClass:NSClassFromString(@"__NSCFArray")]){
          type = @"NSArray";
      }else if ([obj isKindOfClass:NSClassFromString(@"__NSCFNumber")]){
          type = @"int";
      }else if ([obj isKindOfClass:NSClassFromString(@"__NSCFDictionary")]){
          type = @"NSDictionary";
      }
     // 属性字符串
      NSString *str;
      if ([type containsString:@"NS"]) {
          str = [NSString stringWithFormat:@"@property (nonatomic, strong) %@ *%@;",type,key];
      }else{
          str = [NSString stringWithFormat:@"@property (nonatomic, assign) %@ %@;",type,key];
      }
​
      // 每生成属性字符串，就自动换行。
      [strM appendFormat:@"\n%@\n",str];
​
  }];
​
  // 把拼接好的字符串打印出来，就好了。
  NSLog(@"%@",strM);
​
}
@end

(字典转模型的核心就是可以遍历出字典中的每个属性,json解析中大牛框架都用了这个特性,包括MJEXtension,YYModel，jsonModel都是将json转换为字典,再遍历字典中的每个属性来进行modle的转换)。

基本上主流的json 转model都少不了,使用运行时动态获取属性的属性名的方法,来进行字典转模型替换,字典转模型效率最高的(耗时最短的)的是KVC,其他的字典转模型是在KVC 的key和Value 做处理,动态的获取json 中的key 和value ,当然转换的过程中,第三方框架需要做一些判空啊,镶嵌的逻辑处理,再进行KVC 转模型.

无论JsonModle,YYKIt,MJextension 都少不了[xx setValue:valueforKey:key];这句代码的,这是字典转模型的核心方法。
以往我们都是利用KVC进行字典转模型，但是它还是有一定的局限性，例如：模型属性和键值对对应不上会crash（虽然可以重写setValue:forUndefinedKey:方法防止报错），模型属性是一个对象或者数组时不好处理等问题，所以无论是效率还是功能上，利用runtime进行字典转模型都是比较好的选择。

字典转模型我们需要考虑三种特殊情况： 1.当字典的key和模型的属性匹配不上 2.模型中嵌套模型（模型属性是另外一个模型对象） 3.数组中装着模型（模型的属性是一个数组，数组中是一个个模型对象）

根据上面的三种特殊情况，我们一个个处理，先是字典的key和模型的属性不对应的情况。 不对应有两种，一种是字典的键值大于模型属性数量，这时候我们不需要任何处理，因为runtime是先遍历模型所有属性，再去字典中根据属性名找对应值进行赋值，多余的键值对也当然不会去看了；另外一种是模型属性数量大于字典的键值对，这时候由于属性没有对应值会被赋值为nil，就会导致crash，我们只需加一个判断即可，JSON数据和sample如下：

image

JSON数据

- (void)setDict:(NSDictionary *)dict {

  Class c = self.class;
  while (c &&c != [NSObject class]) {

      unsigned int outCount = 0;
      Ivar *ivars = class_copyIvarList(c, &outCount);
      for (int i = 0; i < outCount; i++) {
          Ivar ivar = ivars[I];
          NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

          // 成员变量名转为属性名（去掉下划线 _ ）
          key = [key substringFromIndex:1];
          // 取出字典的值
          id value = dict[key];

          // 如果模型属性数量大于字典键值对数理，模型属性会被赋值为nil而报错
          if (value == nil) continue;

          // 将字典中的值设置到模型上
          [self setValue:value forKeyPath:key];
      }
      free(ivars);
      c = [c superclass];
  }
}

第二种情况是模型的属性是另外一个模型对象

image

JSON数据

这时候我们就需要利用runtime的ivar_getTypeEncoding方法获取模型对象类型，对该模型对象类型再进行字典转模型，也就是进行递归，需要注意的是我们要排除系统的对象类型，例如NSString，下面的方法中我添加了一个类方法方便递归。

image

打印可以看到各属性类型

#import "NSObject+JSONExtension.h"
#import 
​
@implementation NSObject (JSONExtension)
​
- (void)setDict:(NSDictionary *)dict {

  Class c = self.class;
  while (c &&c != [NSObject class]) {

      unsigned int outCount = 0;
      Ivar *ivars = class_copyIvarList(c, &outCount);
      for (int i = 0; i < outCount; i++) {
          Ivar ivar = ivars[I];
          NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

          // 成员变量名转为属性名（去掉下划线 _ ）
          key = [key substringFromIndex:1];
          // 取出字典的值
          id value = dict[key];

          // 如果模型属性数量大于字典键值对数理，模型属性会被赋值为nil而报错
          if (value == nil) continue;

          // 获得成员变量的类型
          NSString *type = [NSString stringWithUTF8String:ivar_getTypeEncoding(ivar)];

          // 如果属性是对象类型
          NSRange range = [type rangeOfString:@"@"];
          if (range.location != NSNotFound) {
              // 那么截取对象的名字（比如@"Dog"，截取为Dog）
              type = [type substringWithRange:NSMakeRange(2, type.length - 3)];
              // 排除系统的对象类型
              if (![type hasPrefix:@"NS"]) {
                  // 将对象名转换为对象的类型，将新的对象字典转模型（递归）
                  Class class = NSClassFromString(type);
                  value = [class objectWithDict:value];
              }
          }

          // 将字典中的值设置到模型上
          [self setValue:value forKeyPath:key];
      }
      free(ivars);
      c = [c superclass];
  }
}
​
+ (instancetype )objectWithDict:(NSDictionary *)dict {
  NSObject *obj = [[self alloc]init];
  [obj setDict:dict];
  return obj;
}

第三种情况是模型的属性是一个数组，数组中是一个个模型对象，例如下面的数据我就可以通过books[0].name获取到C语言程序设计

image

JSON数据

我们既然能获取到属性类型，那就可以拦截到模型的那个数组属性，进而对数组中每个模型遍历并字典转模型，但是我们不知道数组中的模型都是什么类型，我们可以声明一个方法，该方法目的不是让其调用，而是让其实现并返回模型的类型。 这块语言可能解释不太清楚，可以参考我的demo，直接运行即可。

NSObject+JSONExtension.h

// 返回数组中都是什么类型的模型对象
- (NSString *)arrayObjectClass ;

NSObject+JSONExtension.m

#import "NSObject+JSONExtension.h"
#import 
​
@implementation NSObject (JSONExtension)
​
- (void)setDict:(NSDictionary *)dict {

  Class c = self.class;
  while (c &&c != [NSObject class]) {

      unsigned int outCount = 0;
      Ivar *ivars = class_copyIvarList(c, &outCount);
      for (int i = 0; i < outCount; i++) {
          Ivar ivar = ivars[I];
          NSString *key = [NSString stringWithUTF8String:ivar_getName(ivar)];

          // 成员变量名转为属性名（去掉下划线 _ ）
          key = [key substringFromIndex:1];
          // 取出字典的值
          id value = dict[key];

          // 如果模型属性数量大于字典键值对数理，模型属性会被赋值为nil而报错
          if (value == nil) continue;

          // 获得成员变量的类型
          NSString *type = [NSString stringWithUTF8String:ivar_getTypeEncoding(ivar)];

          // 如果属性是对象类型
          NSRange range = [type rangeOfString:@"@"];
          if (range.location != NSNotFound) {
              // 那么截取对象的名字（比如@"Dog"，截取为Dog）
              type = [type substringWithRange:NSMakeRange(2, type.length - 3)];
              // 排除系统的对象类型
              if (![type hasPrefix:@"NS"]) {
                  // 将对象名转换为对象的类型，将新的对象字典转模型（递归）
                  Class class = NSClassFromString(type);
                  value = [class objectWithDict:value];

              }else if ([type isEqualToString:@"NSArray"]) {

                  // 如果是数组类型，将数组中的每个模型进行字典转模型，先创建一个临时数组存放模型
                  NSArray *array = (NSArray *)value;
                  NSMutableArray *mArray = [NSMutableArray array];

                  // 获取到每个模型的类型
                  id class ;
                  if ([self respondsToSelector:@selector(arrayObjectClass)]) {

                      NSString *classStr = [self arrayObjectClass];
                      class = NSClassFromString(classStr);
                  }
                  // 将数组中的所有模型进行字典转模型
                  for (int i = 0; i < array.count; i++) {
                      [mArray addObject:[class objectWithDict:value[i]]];
                  }

                  value = mArray;
              }
          }

          // 将字典中的值设置到模型上
          [self setValue:value forKeyPath:key];
      }
      free(ivars);
      c = [c superclass];
  }
}
​
+ (instancetype )objectWithDict:(NSDictionary *)dict {
  NSObject *obj = [[self alloc]init];
  [obj setDict:dict];
  return obj;
}
​
@end

实现push跳转可配

在你的开发过程中，是否遇到过如下的需求：

1. 在tableView类型的展示列表中，点击每个cell中人物头像都可以跳转到人物详情，可参见微博中的头像，同理包括转发、评论按钮、各种链接及linkcard。

2. 跳转到任意页面

（1）产品要求，某个页面的不同banner图，点击可以跳转到任何一个页面，可能是原生的页面A、页面B，或者是web页C。

（2）在web页面，可以跳转到任何一个原生页面。

（3）在远程推送中跳转到任意指定的页面。

以上2种需求，我想大多数开发者都遇到过，并且可以实现这种功能。毕竟，这是比较基础的功能。但是代码未必那么优雅。

一般处理办法

针对 1：一般初学者会用target或者block等方法在tableView的代理方法拿到事件，并把要执行的跳转写到controller里。功能是可以实现的，但问题是这种cell及相似的cell（布局有些变化，或者多几个少几个控件）一般出现在多个页面。这样的话相同的代码就会出现在多个地方。就算把跳转方法抽取出来写成category，但是target或者block总是每个地方都要写的。

针对 2： 初级的方法是每个地方写一坨判断及跳转，高级一些是抽取出来写在基类或者category。

优雅的解决办法（利用runtime）

利用runtime动态生成对象、属性、方法这特性，我们可以先跟服务端商量好，定义跳转规则，比如要跳转到A控制器，需要传属性id、type，那么服务端返回字典给我，里面有控制器名，两个属性名跟属性值，客户端就可以根据控制器名生成对象，再用kvc给对象赋值，这样就搞定了。

举例：比如根据推送规则跳转对应界面HSFeedsViewController

HSFeedsViewController.h：

进入该界面需要传的属性

@interface HSFeedsViewController : UIViewController
// 注：根据下面的两个属性，可以从服务器获取对应的频道列表数据
/** 频道ID */
@property (nonatomic, copy) NSString *ID;
/** 频道type */
@property (nonatomic, copy) NSString *type;
@end

AppDelegate.m 中添加以下代码片段：

推送过来的消息规则

// 这个规则肯定事先跟服务端沟通好，跳转对应的界面需要对应的参数
NSDictionary *userInfo = @{
                          @"class": @"HSFeedsViewController",
                          @"property": @{
                                      @"ID": @"123",
                                      @"type": @"12"
                                  }
                          };

接收推送消息

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
{
  [self push:userInfo];
}

跳转界面：

- (void)push:(NSDictionary *)params
{
  // 类名
  NSString *class =[NSString stringWithFormat:@"%@", params[@"class"]];
  const char *className = [class cStringUsingEncoding:NSASCIIStringEncoding];
  // 从一个字串返回一个类
  Class newClass = objc_getClass(className);
  if (!newClass)
  {
      // 创建一个类
      Class superClass = [UIViewController class];
      newClass = objc_allocateClassPair(superClass, className, 0);
      // 注册你创建的这个类
      objc_registerClassPair(newClass);
  }
  // 创建对象
  id instance = [[newClass alloc] init];
  // 对该对象赋值属性
  NSDictionary * propertys = params[@"property"];
  [propertys enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
      // 检测这个对象是否存在该属性
      if ([self checkIsExistPropertyWithInstance:instance verifyPropertyName:key]) {
          // 利用kvc赋值
          [instance setValue:obj forKey:key];
      }
  }];
  // 获取导航控制器
  UITabBarController *tabVC = (UITabBarController *)self.window.rootViewController;
  UINavigationController *pushClassStance = (UINavigationController *)tabVC.viewControllers[tabVC.selectedIndex];
  // 跳转到对应的控制器
  [pushClassStance pushViewController:instance animated:YES];
}

检测对象是否存在该属性：

- (BOOL)checkIsExistPropertyWithInstance:(id)instance verifyPropertyName:(NSString *)verifyPropertyName
{
  unsigned int outCount, I;
  // 获取对象里的属性列表
  objc_property_t * properties = class_copyPropertyList([instance
                                                          class], &outCount);
  for (i = 0; i < outCount; i++) {
      objc_property_t property =properties[I];
      // 属性名转成字符串
      NSString *propertyName = [[NSString alloc] initWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
      // 判断该属性是否存在
      if ([propertyName isEqualToString:verifyPropertyName]) {
          free(properties);
          return YES;
      }
  }
  free(properties);
  return NO;
}