iOS面试题（七）Objective-C语言 -分类的实现机制、原理（Runtime源码分析）

Objective-C语言

1.  分类（什么是分类？分类的实现机制、原理是怎样的？我们应该怎样为一个分类提供实例变量呢？--涉及到第2点关联对象的考察）
2. 关联对象（Runtime分析和查看 分类和关联对象的实现机制、原理）
3. 扩展、代理怎么使用（分类和扩展的区别在哪里？）
4. KVO、KVC（ KVO、KVC的实现机制、原理、包括涉及到了哪些设计思想）
5. NSNotification（通知的实现机制和原理）
6. 属性关键字（声明属性时，会用到一些关键字的实际问题）
    

分类（Category）：

1.1你用分类都做了哪些事  -作用？

1. ​​​声明私有方法 - 把分类的头文件放到对应数组类的.m中,就满足了私有方法的一个声明和使用,又对外不暴露
2. 分解体积庞大的类文件
3. 把Framework的私有方法公开

  分类的特点：（更好的回答分类和扩展的区别在哪里）​​​​  

1. 在运行时决议 
   - 在编写完分类文件之后,并没有把分类中添加的内容附加到宿主类中
   - 也就说宿主中还没有分类中的方法，而是在运行时通过runtime把分类内容真实的添加到对应的宿主类上
2. 可以为系统类添加分类（关于UIView的一些获取坐标的分类方法，实际上是我们在工程中植入了对应UI系统文件的一个分类，而不能给系统类添加扩展）

1.2 分类中都可以添加哪些内容？

1. 实例方法
2. 类方法
3. 协议
4. 实例属性(实例属性只声明了对应的get和set方法,但没有在分类中添加上相应的实例变量)
5. 想要添加实例变量，可以通过关联对象来为分类添加实例变量

1.3 <--分类结构体-->

1.4 加载调用栈(了解)

 

备注：

• _objc_init：runtime初始化方法。
• images：指的是镜像。

1.5 源码分析

这里以添加实例方法举例：
从remethodizeClass开始入手分析：

1. 我们只分析分类当中实例方法添加的逻辑，因此在这里我们假设 isMeta = NO
2. 生成一个新的二维数组，用来存放分类中的方法
3. 遍历分类数组，采用倒叙遍历
4. 获取宿主类当中的rw数据，其中包含宿主类的方法列表信息
5. 将分类方法拼接到rw的methods上--->
6. 具体如何拼接 rw->methods.attachLists(mlists, mcount)-->attachLists方法详解

static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;

    runtimeLock.assertWriting();
    /*
     分类可以添加实例方法、类方法、属性、协议等等
     我们只分析分类当中实例方法添加的逻辑，
     因此在这里我们假设添加的是实例方法， isMeta = NO
     */
     /*
        <--------------1.isMeta = NO---------------->
     */
    isMeta = cls->isMetaClass();//判断当前类是否为元类对象，这取决于我们添加的方法是实例方法还是类方法

    //从对应的类（cls）当中获取还没有拼接整合的所有分类   cats是获取分类的列表
    if ((cats = unattachedCategoriesForClass(cls, false))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }
        //将分类cats拼接到cls上面
        attachCategories(cls, cats, true );        
        free(cats);
    }
}

  2.3.4.5.6 将分类cats拼接到cls上面-->attachCategories方法详解：
         通过rw->methods.attachLists(mlists, mcount)这句话，分类的方法才真正添加到了宿主类上面。所以，分类是在运行时决议

static void attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return; //分类的判空操作
    if (PrintReplacedMethods) printReplacements(cls, cats);//打印的内容或者debug调试的东西，可以忽略
    /*
     分类可以添加实例方法、类方法、属性、协议等等
     我们只分析分类当中实例方法添加的逻辑，
     因此在这里我们假设添加的是实例方法， isMeta = NO
     */
    bool isMeta = cls->isMetaClass();//又进行了一次当前分类当中，添加的方法是实例方法还是类方法。或者说是为类添加分类，还是为元类添加分类。
   
    //声明了三个局部变量，对应的都是二维数组，  我们主要分析关于方法添加的一个逻辑

    /*二维数组
     [[method_t,method_t,...],[method_t],[method_t,method_t,method_t]...]
     */
   
      /*
       <--------------2.生成一个新的二维数组，用来存放分类中的方法---------------->
     */ 
   
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));//方法列表
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));//属性列表
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));//协议列表

    int mcount = 0; //方法参数
    int propcount = 0;//属性参数
    int protocount = 0;//协议参数
    int i = cats->count;//宿主类分类的总数，不是方法的总数
    bool fromBundle = NO;
    while (i--) {
     /*
       <--------------3.遍历分类数组，采用倒叙遍历---------------->
     */ 
     //这里是倒序遍历，最先访问最后编译的分类，也就是说attachCategories函数中传递过来的分类列表的参数，category_list *cats里面最后一个元素，是最后参加编译的。  最后编译的同名方法会生效，前面的会被覆盖掉。
        //获取一个分类
        auto& entry = cats->list[i];
        //获取该分类的方法列表
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            //最后编译的分类最先添加到分类数组中
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }
        //属性列表添加规则 同方法添加规则
        property_list_t *proplist = entry.cat->propertiesForMeta(isMeta);
        if (proplist) {
            proplists[propcount++] = proplist;
        }
       //协议列表添加规则 同方法添加规则
        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }
   
    /*
       <--------------4.获取宿主类当中的rw数据，其中包含宿主类的方法列表信息---------------->
     */ 
    //根据当前类，获取它的读写信息
    auto rw = cls->data();
    //主要是针对 分类中实现了一些内存管理相关方法情况下的  一些特殊处理（覆盖掉系统的一些内存管理方法）
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
   
     /*
       <--------------5.将分类方法拼接到rw的methods上---------------->
     */ 

    /*
     rw代表类
     methods代表类的方法列表
     attachLists 方法的含义是 将含有mcount个元素的mlists拼接到rw的methods上面
     
     分类添加的关键位置：就是将我们刚才处理过的一个二维数组的分类数据mlists，拼接到对应的宿主类的方法列表上面。
     rw类的结构当中有一个方法列表的成员methods，然后通过调用methods的attachLists函数，来把含有mcount个元素的二维数组mlists拼接到宿主类rw的对应方法methods上面。
     通过rw->methods.attachLists(mlists, mcount)这句话，分类的方法才真正添加到了宿主类上面。所以，分类是在运行时决议
     */
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);

    rw->properties.attachLists(proplists, propcount);
    free(proplists);

    rw->protocols.attachLists(protolists, protocount);
    free(protolists);
}

6.1 rw->methods.attachLists(mlists, mcount);方法解析

  [ A ---> [addedLists中的第一个元素],B ---> [addedLists中的第二个元素], C ---> [addedLists中的第三个元素],[原有的第一个元素],  [原有的第二个元素] ]
经过调用memmove-->把原有列表中的元素移动到数组后面的位置，把前面留出来addedCount个新添加的位置，
memcpy（内容拷贝）： 这也是分类方法会“覆盖”宿主类的方法的原因，如果分类的方法有和宿主类方法同名的现象，分类的方法会被优先实现。

 /*
     addedLists 传递过来的二维数组   （准备拼接的分类列表）
     
     [[method_t,method_t,...],[method_t],[method_t,method_t,method_t]...]
     ------------------------  --------   ------------------------------
       分类A中的方法列表（A）         B                      C
     addedCount = 3   二维数组列表的个数
     */
    void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return;//判空操作

        if (hasArray()) { //有数组的情况下
            // many lists -> many lists
            //列表中原有元素总数  oldCount = 2
            uint32_t oldCount = array()->count;
            //拼接之后的元素总数
            uint32_t newCount = oldCount + addedCount;
            //根据新总数重新分配内存
            setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
            //重新设置元素总数
            array()->count = newCount;
            /*
             内存移动
             调用memmove-->把原有列表中的元素移动到数组后面的位置，把前面留出来addedCount个新添加的位置
             [[],[],[],[原有的第一个元素]，[原有的第二个元素]]
             */
            memmove(array()->lists + addedCount, array()->lists, 
                    oldCount * sizeof(array()->lists[0]));
            /*
             内存拷贝
             [
               A ---> [addedLists中的第一个元素],
               B ---> [addedLists中的第二个元素],
               C ---> [addedLists中的第三个元素],
               [原有的第一个元素],
               [原有的第二个元素]
               这也是分类方法会“覆盖”宿主类的方法的原因，如果分类的方法有和宿主类方法同名的现象，分类的方法会被优先实现。
             ]
             */
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
        else if (!list  &&  addedCount == 1) {
            // 0 lists -> 1 list
            list = addedLists[0];
        } 
        else {
            // 1 list -> many lists
            List* oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount;
            setArray((array_t *)malloc(array_t::byteSize(newCount)));
            array()->count = newCount;
            if (oldList) array()->lists[addedCount] = oldList;
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
    }

"重要总结"

分类实现原理由运行时决议,不同分类中含有同名分类方法,谁最终生效,取决于谁最后参与编译

假如分类中添加的方法恰好是宿主类中的同名方法,分类方法会"覆盖"同名的宿主类方法

(消息传递过程中会优先查找数组靠前的元素,若找到了就会调用,但宿主类的同名方法仍然存在)

 

1. 分类添加的同名方法可以"覆盖"原宿主类方法

   -效果上是覆盖的，实际上呢宿主类的同名方法仍然存在，只是memmove移动到了后面。

   -在我们消息发送过程中,是根据选择器名称来查找的,一旦查找到对应的实现就会返回

   -由于分类方法位于数组靠前的位置,若分类和宿主类方法重名,会先查找到分类的方法

2. 最后编译的分类同名方法才会最终生效,其他分类都会被覆盖掉

   -若我们添加两个分类,两个分类中都有同名方法,哪个会生效,取决于分类的编译顺序

   -因为是倒序编译,最后编译的分类同名方法才会最终生效,其他都会被覆盖掉

3. 名字相同的分类会引起编译报错

   -因为在生成具体分类的时候,经过runtime在编译过程中，会把我们添加的分类名字以下划线方式拼接到宿主类上

   -或者更复杂的命名规则，总之名字相同,就会类似于我们定义了两个同名变量,会引起编译报错