探秘Runtime - 深入剖析Category

该文章属于<简书 — 刘小壮>原创，转载请注明：

<简书 — 刘小壮> https://www.jianshu.com/p/0dc2513e117b

---

博客配图

---

Category

有了之前Runtime的基础，一些内部实现就很好理解了。在OC中可以通过Category添加属性、方法、协议，在Runtime中Class和Category都是通过结构体实现的。

和Category语法很相似的还有Extension，二者的区别在于，Extension在编译期就直接和原类编译在一起，而Category是在运行时动态添加到原类中的。

基于之前的源码分析，我们来分析一下Category的实现原理。

在_read_images函数中会执行一个循环嵌套，外部循环遍历所有类，并取出当前类对应Category数组。内部循环会遍历取出的Category数组，将每个category_t对象取出，最终执行addUnattachedCategoryForClass函数添加到Category哈希表中。

// 将category_t添加到list中，并通过NXMapInsert函数，更新所属类的Category列表
static void addUnattachedCategoryForClass(category_t *cat, Class cls, 
                                          header_info *catHeader)
{
    // 获取到未添加的Category哈希表
    NXMapTable *cats = unattachedCategories();
    category_list *list;

    // 获取到buckets中的value，并向value对应的数组中添加category_t
    list = (category_list *)NXMapGet(cats, cls);
    if (!list) {
        list = (category_list *)
            calloc(sizeof(*list) + sizeof(list->list[0]), 1);
    } else {
        list = (category_list *)
            realloc(list, sizeof(*list) + sizeof(list->list[0]) * (list->count + 1));
    }
    // 替换之前的list字段
    list->list[list->count++] = (locstamped_category_t){cat, catHeader};
    NXMapInsert(cats, cls, list);
}

Category维护了一个名为category_map的哈希表，哈希表存储所有category_t对象。

// 获取未添加到Class中的category哈希表
static NXMapTable *unattachedCategories(void)
{
    // 未添加到Class中的category哈希表
    static NXMapTable *category_map = nil;

    if (category_map) return category_map;

    // fixme initial map size
    category_map = NXCreateMapTable(NXPtrValueMapPrototype, 16);

    return category_map;
}

上面只是完成了向Category哈希表中添加的操作，这时候哈希表中存储了所有category_t对象。然后需要调用remethodizeClass函数，向对应的Class中添加Category的信息。

在remethodizeClass函数中会查找传入的Class参数对应的Category数组，然后将数组传给attachCategories函数，执行具体的添加操作。

// 将Category的信息添加到Class，包含method、property、protocol
static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;
    isMeta = cls->isMetaClass();

    // 从Category哈希表中查找category_t对象，并将已找到的对象从哈希表中删除
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

在attachCategories函数中，查找到Category的方法列表、属性列表、协议列表，然后通过对应的attachLists函数，添加到Class对应的class_rw_t结构体中。

// 获取到Category的Protocol list、Property list、Method list，然后通过attachLists函数添加到所属的类中
static void attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;
    if (PrintReplacedMethods) printReplacements(cls, cats);

    bool isMeta = cls->isMetaClass();

    // 按照Category个数，分配对应的内存空间
    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;
    
    // 循环查找出Protocol list、Property list、Method list
    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, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }

    auto rw = cls->data();

    // 执行添加操作
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    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);
}

这个过程就是将Category中的信息，添加到对应的Class中，一个类的Category可能不只有一个，在这个过程中会将所有Category的信息都合并到Class中。

方法覆盖

在有多个Category和原类的方法重复定义的时候，原类和所有Category的方法都会存在，并不会被后面的覆盖。假设有一个方法叫做method，Category和原类的方法都会被添加到方法列表中，只是存在的顺序不同。

排列顺序

在进行方法调用的时候，会优先遍历Category的方法，并且后面被添加到项目里的Category，会被优先调用。上面的例子调用顺序就是Category3 -> Category2 -> Category1 -> TestObject。如果从方法列表中找到方法后，就不会继续向后查找，这就是类方法被Category”覆盖”的原因。

问题

在有多个Category和原类方法重名的情况下，怎样在一个Category的方法被调用后，调用所有Category和原类的方法？

可以在一个Category方法被调用后，遍历方法列表并调用其他同名方法。但是需要注意一点是，遍历过程中不能再调用自己的方法，否则会导致递归调用。为了避免这个问题，可以在调用前判断被调动的方法IMP是否当前方法的IMP。

那怎样在任何一个Category的方法被调用后，只调用原类方法呢？

根据上面对方法调用的分析，Runtime在调用方法时会优先所有Category调用，所以可以倒叙遍历方法列表，只遍历第一个方法即可，这个方法就是原类的方法。

Category Associate

在项目中经常会用到Category，有时候会遇到给Category添加属性的需求，这时候就需要用到associated的Runtime API了。例如下面的例子中，需要在属性的set、get方法中动态添加实现。

// 声明文件
@interface TestObject (Category)
@property (nonatomic, strong) NSObject *object;
@end

// 实现文件
#import <objc/runtime.h>
#import <objc/message.h>
static void *const kAssociatedObjectKey = (void *)&kAssociatedObjectKey;

@implementation TestObject (Category)

- (NSObject *)object {
    return objc_getAssociatedObject(self, kAssociatedObjectKey);
}

- (void)setObject:(NSObject *)object {
    objc_setAssociatedObject(self, kAssociatedObjectKey, object, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

@end

在Category中添加属性后，默认是没有实现方法的，如果调用属性则会崩溃，而且还会提示下面两个警告信息。

Property 'object' requires method 'object' to be defined - use @dynamic or provide a method implementation in this category

Property 'object' requires method 'setObject:' to be defined - use @dynamic or provide a method implementation in this category

下面让我们看一下associated的源码，看Runtime是怎么通过Runtime动态添加set、get的。下面是objc_getAssociatedObject函数的实现代码，objc_setAssociatedObject实现也是类似，这里节省地方就不贴出来了。

id _object_get_associative_reference(id object, void *key) {
    id value = nil;
    uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            ObjectAssociationMap *refs = i->second;
            ObjectAssociationMap::iterator j = refs->find(key);
            if (j != refs->end()) {
                ObjcAssociation &entry = j->second;
                value = entry.value();
                policy = entry.policy();
                if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
                    objc_retain(value);
                }
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        objc_autorelease(value);
    }
    return value;
}

从源码可以看出，所有通过associated添加的属性，都被存在一个单独的哈希表AssociationsHashMap中。objc_setAssociatedObject和objc_getAssociatedObject函数本质上都是在操作这个哈希表，通过对哈希表进行映射来存取对象。

在associated的API中会设置一些内存管理的关键字，例如OBJC_ASSOCIATION_ASSIGN，这是用来指定对象的内存管理的，这些关键字在Runtime源码中也有对应的处理。

---

简书由于排版的问题，阅读体验并不好，布局、图片显示、代码等很多问题。所以建议到我Github上，下载Runtime PDF合集。把所有Runtime文章总计九篇，都写在这个PDF中，而且左侧有目录，方便阅读。

Runtime PDF

下载地址：Runtime PDF
麻烦各位大佬点个赞，谢谢！😁