分类及其底层实现

作者: 高思阳 | 来源:发表于2019-03-03 23:58 被阅读0次

分类的作用

给现有的类添加方法；
将一个类的实现拆分成多个独立的源文件;

好处:
a)可以减少单个文件的体积
b)可以把不同的功能组织到不同的category里
c)可以由多个开发者共同完成一个类
d)可以按需加载想要的category 等等

声明私有的方法。

分类的特点：

运行时决议（编译的时候，分类中的内容还没有添加到宿主类中，而是在运行时，通过runtime把分类中的方法、属性、协议等添加到宿主类中）
可以为系统类添加分类（比如常用的布局分类自定义frame、center等）

分类可以添加以下内容：

类方法和实例方法
协议
属性

分类数据结构的定义

通过下面分类的数据结构，可以知道为什么分类不可以添加实例变量，而可以添加类方法和实例方法以及协议和属性。在category中可以有属性（property），但是该属性只是生成了getter和setter方法的声明，并没有产生对应的实现，更不会添加对应的实例变量。如果想为实例对象添加实例变量，可以尝试使用关联引用技术。

struct category_t {
    const char *name;
    classref_t cls;
    struct method_list_t *instanceMethods;
    struct method_list_t *classMethods;
    struct protocol_list_t *protocols;
    struct property_list_t *instanceProperties;

    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }

    property_list_t *propertiesForMeta(bool isMeta) {
        if (isMeta) return nil; // classProperties;
        else return instanceProperties;
    }
};

分类内容与宿主类合并的相关源码

/***********************************************************************
* remethodizeClass
* Attach outstanding categories to an existing class.
* Fixes up cls's method list, protocol list, and property list.
* Updates method caches for cls and its subclasses.
* Locking: runtimeLock must be held by the caller
**********************************************************************/
static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;

    runtimeLock.assertWriting();
    
    /*
      只分析分类当中实例方法添加逻辑
      因此这里假设 isMeta = NO
    */
    isMeta = cls->isMetaClass();

    // Re-methodizing: check for more categories
    //获取cls中未完成整合的所有分类
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }
        //将分类cats拼接到类cls上
        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

//maptable.h
/***********************************************************************
* unattachedCategoriesForClass
* Returns the list of unattached categories for a class, and 
* deletes them from the list. 
* The result must be freed by the caller. 
* Locking: runtimeLock must be held by the caller.
* 获取cls中未完成整合的所有分类哈希表

**********************************************************************/
static category_list *
unattachedCategoriesForClass(Class cls, bool realizing)
{
    runtimeLock.assertWriting();
    return (category_list *)NXMapRemove(unattachedCategories(), cls);
}

static NXMapTable *unattachedCategories(void)
{
    runtimeLock.assertWriting();
    //全局对象
    static NXMapTable *category_map = nil;
    if (category_map) return category_map;
    // fixme initial map size
    category_map = NXCreateMapTable(NXPtrValueMapPrototype, 16);
    return category_map;
}

//相似的结构，可以在runtime相关的数据结构sideTable等里面看到
//可以看出就是一个hash表
typedef struct _NXMapTable {
    /* private data structure; may change */
    const struct _NXMapTablePrototype   *prototype;    //包含三个结构体指针,用于表中的数据处理和比较
    unsigned    count;                                                    //记录表中数据数量
    unsigned    nbBucketsMinusOne;                            //数组长度减一
    void    *buckets;                                                       //具体的表数据数组
} NXMapTable OBJC_MAP_AVAILABILITY;

typedef struct _NXMapTablePrototype {
    unsigned    (*hash)(NXMapTable *, const void *key);
    int     (*isEqual)(NXMapTable *, const void *key1, const void *key2);
    void    (*free)(NXMapTable *, void *key, void *value);
    int     style; /* reserved for future expansion; currently 0 */
} NXMapTablePrototype OBJC_MAP_AVAILABILITY;

NXMapTable具体结构

//将分类cats的方法列表、属性列表、协议列表拼接到类cls上
//假定cats中的分类已全部加载并且是按照编译顺序排序
//最后编译的分类排在最先
// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order, 
// oldest categories first.
static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;
    if (PrintReplacedMethods) printReplacements(cls, cats);

    /*
      只分析分类当中实例方法添加逻辑
      因此这里假设 isMeta = NO
    */
    bool isMeta = cls->isMetaClass();

    /*mlists 是二维数组
      method_list_t **相当于一维数组里面保存着method_list_t *类型的数据
      而method_list_t *相当于一维数组里面保存着method_list_t类型的数据
      因此，是如下结构：
      [[method_t , method_t , ...], [method_t], [method_t , method_t ], ...] 
    */
    // fixme rearrange to remove these intermediate allocations，
    // 重新分配空间
    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));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    int i = cats->count;
    bool fromBundle = NO;
    while (i--) { // 倒序遍历分类列表，因此最后编译的最先添加
        //获取一个分类
        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;
        }
    }

    // 获取宿主类当中的rw数据，其中包含宿主类的方法列表信息（https://draveness.me/method-struct）
    auto rw = cls->data();
    // 主要是对分类中有关于内存管理相关方法的情况做特殊处理
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    /*
        rw代表类
        methods代表类的方法列表
        attachLIsts方法：将含有mcount个元素的mlists拼接到rw的methods上
    */
    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);
}

/*
  addedLists传过来的二维数组
  [[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()) {
            // 列表中原有元素总数 oldCount = 2
            // many lists -> many lists
            uint32_t oldCount = array()->count;
            // 拼接之后的元素总数
            uint32_t newCount = oldCount + addedCount;
            //根据新的总数重新分配内存
            setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
            //重新设置元素总数
            array()->count = newCount;

            /* 内存移动
                [ [ ] , [ ] , [ ], [原有的第一个元素], [原有的第二个元素] ]
            */
            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]));
        }
    }

总结：

分类添加的方法可以“覆盖”袁磊方法
同名分类方法生效取决于编译顺序，最后编译的分类方法会生效
名字相同的分类会引起编译报错

分类及其底层实现

分类的作用

分类的特点：

分类可以添加以下内容：

分类数据结构的定义

分类内容与宿主类合并的相关源码

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读