category工作原理

摘要

在Objective-C 2.0中，提供了category这个语言特性，可以动态地为已有类添加新行为。如今category已经遍布于Objective-C代码的各个角落，从Apple官方的framework到各个开源框架，从功能繁复的大型APP到简单的应用，catagory无处不在。本文对category做了比较全面的整理，希望对读者有所裨益。

目录结构

1、 category简介
2、 category结构组成
3、 category加载过程
4、category和+load

1、 category简介

category是Objective-C 2.0之后添加的语言特性，category的主要作用是为已经存在的类添加方法。除此之外，apple还推荐了category的另外两个使用场景1

• 可以把类的实现分开在几个不同的文件里面。这样做有几个显而易见的好处，a)可以减少单个文件的体积 b)可以把不同的功能组织到不同的category里 c)可以由多个开发者共同完成一个类 d)可以按需加载想要的category 等等。
• 声明私有方法

不过除了apple推荐的使用场景，广大开发者脑洞大开，还衍生出了category的其他几个使用场景：

• 模拟多继承
• 把framework的私有方法公开

Objective-C的这个语言特性对于纯动态语言来说可能不算什么，比如JavaScript，你可以随时为一个“类”或者对象添加任意方法和实例变量。但是对于不是那么“动态”的语言而言，这确实是一个了不起的特性。

2、 category结构组成

struct _category_t {
    const char *name;
    struct _class_t *cls;
    const struct _method_list_t *instance_methods;
    const struct _method_list_t *class_methods;
    const struct _protocol_list_t *protocols;
    const struct _prop_list_t *properties;
};

• name: 分类名字
• cls: 所属的class类
• instance_methods: 实例方法列表
• class_methods: 类方法列表
• protocols: 协议列表
• properties: 属性列表

可见一个 category持有了一个method_list_t 类型的数组，method_list_t又继承自 entsize_list_tt，这是一种泛型容器:

struct method_list_t : entsize_list_tt<method_t, method_list_t, 0x3> {
    // 成员变量和方法
};
template <typename element, typename list, uint32_t flagmask>
struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
    Element first;
};</typename element, typename list, uint32_t flagmask></method_t, method_list_t, 0x3>

• entsize_list_tt: 可以理解为一个容器，拥有自己的迭代器用于遍历所有元素
• Element: 元素类型
• List: 用于指定容器类型
• uint32_t flagmask: 标记位

在category结构体构造中可以看到_method_list_t类型的方法列表，当类中有一个方法时的定义如下：

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
}

可以看到_method_list_t结构体中包含_objc_method类型方法列表,即存储方法的容器,_objc_method定义：

struct _objc_method {
    struct objc_selector * _cmd;
    const char *method_type;
    void  *_imp;
}

以上是category结构体构造，最后，我们还有一个结构体 category_list 用来存储所有的 category，它的定义如下:

struct locstamped_category_list_t {
    uint32_t count;
    locstamped_category_t list[0];
};
struct locstamped_category_t {
    category_t *cat;
    struct header_info *hi;
};
typedef locstamped_category_list_t category_list;

除了标记存储的 category 的数量外，locstamped_category_list_t 结构体还声明了一个长度为零的数组，这其实是 C99 中的一种写法，允许我们在运行期动态的申请内存。

3、category加载过程

在分析category加载过程之前，我们先通过一段代码看下category内部实现：
oc代码：

//.h
#import <Foundation/Foundation.h>

@interface Person : NSObject
- (void)printName;
@property(nonatomic, copy) NSString *name;
@end

@interface Person(PersonAddtion)
@property(nonatomic, copy) NSString *name;
- (void)printName;
@end

//.m
#import "Person.h"
@implementation Person
- (void)printName{
    NSLog(@"Person - printName");
}
@end

@implementation Person(PersonAddtion)
- (void)printName{
    NSLog(@"PersonAddtion - printName");
}
@end

我们使用clang的命令clang -rewrite-objc Person.m去看看category到底会变成什么。
我们得到了一个3M大小，1w行的.cpp文件，我们忽略掉所有和我们无关的东西，在文件的最后，我们找到了如下代码片段：

//这是Person类的代码
//这是Person类的代码
static struct /*_ivar_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count;
    struct _ivar_t ivar_list[1];
} _OBJC_$_INSTANCE_VARIABLES_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_ivar_t),
    1,
    {{(unsigned long int *)&OBJC_IVAR_$_Person$_name, "_name", "@\"NSString\"", 3, 8}}
};

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[3];
} _OBJC_$_INSTANCE_METHODS_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    3,
    {{(struct objc_selector *)"printName", "v16@0:8", (void *)_I_Person_printName},
    {(struct objc_selector *)"name", "@16@0:8", (void *)_I_Person_name},
    {(struct objc_selector *)"setName:", "v24@0:8@16", (void *)_I_Person_setName_}}
};

static struct /*_prop_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count_of_properties;
    struct _prop_t prop_list[1];
} _OBJC_$_PROP_LIST_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"name","T@\"NSString\",C,N,V_name"}}
};

static struct _class_ro_t _OBJC_METACLASS_RO_$_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    1, sizeof(struct _class_t), sizeof(struct _class_t), 
    (unsigned int)0, 
    0, 
    "Person",
    0, 
    0, 
    0, 
    0, 
    0, 
};

static struct _class_ro_t _OBJC_CLASS_RO_$_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    0, __OFFSETOFIVAR__(struct Person, _name), sizeof(struct Person_IMPL), 
    (unsigned int)0, 
    0, 
    "Person",
    (const struct _method_list_t *)&_OBJC_$_INSTANCE_METHODS_Person,
    0, 
    (const struct _ivar_list_t *)&_OBJC_$_INSTANCE_VARIABLES_Person,
    0, 
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person,
};

//这是PersonAddtion中实现代码
//这是PersonAddtion中实现代码
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_PersonAddtion __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"printName", "v16@0:8", (void *)_I_Person_PersonAddtion_printName}}
};

static struct /*_prop_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count_of_properties;
    struct _prop_t prop_list[1];
} _OBJC_$_PROP_LIST_Person_$_PersonAddtion __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"name","T@\"NSString\",C,N"}}
};

extern "C" __declspec(dllexport) struct _class_t OBJC_CLASS_$_Person;

static struct _category_t _OBJC_$_CATEGORY_Person_$_PersonAddtion __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "Person",
    0, // &OBJC_CLASS_$_Person,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_PersonAddtion,
    0,
    0,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_PersonAddtion,
};
static void OBJC_CATEGORY_SETUP_$_Person_$_PersonAddtion(void ) {
    _OBJC_$_CATEGORY_Person_$_PersonAddtion.cls = &OBJC_CLASS_$_Person;
}
#pragma section(".objc_inithooks$B", long, read, write)
__declspec(allocate(".objc_inithooks$B")) static void *OBJC_CATEGORY_SETUP[] = {
    (void *)&OBJC_CATEGORY_SETUP_$_Person_$_PersonAddtion,
};
static struct _class_t *L_OBJC_LABEL_CLASS_$ [1] __attribute__((used, section ("__DATA, __objc_classlist,regular,no_dead_strip")))= {
    &OBJC_CLASS_$_Person,
};
static struct _category_t *L_OBJC_LABEL_CATEGORY_$ [1] __attribute__((used, section ("__DATA, __objc_catlist,regular,no_dead_strip")))= {
    &_OBJC_$_CATEGORY_Person_$_PersonAddtion,
};

从以上两段代码可以看出：

• Person类中生成了_name变量、printName方法、name的getter方法、setName方法、name属性
• PersonAddtion类中仅仅有printName方法、name属性

以上就可以看出category中并不会生成实例变量，所以在category中不能使用实例变量.

接着对以上PersonAddtion代码分析:

• 首先编译器生成了实例方法列表_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_PersonAddtion和属性列表_OBJC_$_PROP_LIST_Person_$_PersonAddtion，两者的命名都遵循了公共前缀+类名+category名字的命名方式，而且实例方法列表里面填充的正是我们在PersonAddtion这个category里面写的方法printName，而属性列表里面填充的也正是我们在PersonAddtio里添加的name属性。还有一个需要注意到的事实就是category的名字用来给各种列表以及后面的category结构体本身命名，而且有static来修饰，所以在同一个编译单元里我们的category名不能重复，否则会出现编译错误。
• 编译器生成了category本身_OBJC_$_CATEGORY_Person_$_PersonAddtion，并用前面生成的列表来初始化category本身。
• 编译器在DATA段下的objc_catlist section里保存了一个大小为1的category_t的数组L_OBJC_LABEL_CATEGORY_$ [1]（当然，如果有多个category，会生成对应长度的数组，用于运行期category的加载。

接下来我们看下category如何加载？

我们知道，Objective-C的运行是依赖OC的runtime的，而OC的runtime和其他系统库一样，是OS X和iOS通过dyld动态加载的。
对于OC运行时，入口方法如下（在objc-os.mm文件中）：

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;

    // fixme defer initialization until an objc-using image is found?
    environ_init();
    tls_init();
    lock_init();
    exception_init();

    // Register for unmap first, in case some +load unmaps something
    _dyld_register_func_for_remove_image(&unmap_image);
    dyld_register_image_state_change_handler(dyld_image_state_bound,
                                             1/*batch*/, &map_images);
    dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}

以上方法加载过程：

void _objc_init(void)
└──const char *map_2_images(...)
    └──const char *map_images_nolock(...)
        └──void _read_images(header_info **hList, uint32_t hCount)

category被附加到类上面是在map_images的时候发生的，在new-ABI的标准下，_objc_init里面的调用的map_images最终会调用objc-runtime-new.mm里面的_read_images方法，而在_read_images方法的结尾，有以下的代码片段：

// Discover categories. 
    for (EACH_HEADER) {
        category_t **catlist =
            _getObjc2CategoryList(hi, &count);
        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            class_t *cls = remapClass(cat->cls);

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Disavow any knowledge of this category.
                catlist[i] = NULL;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class",
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category. 
            // First, register the category with its target class. 
            // Then, rebuild the class's method lists (etc) if 
            // the class is realized. 
            BOOL classExists = NO;
            if (cat->instanceMethods ||  cat->protocols 
                ||  cat->instanceProperties)
            {
                addUnattachedCategoryForClass(cat, cls, hi);
                if (isRealized(cls)) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s",
                                 getName(cls), cat->name,
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols 
                /* ||  cat->classProperties */)
            {
                addUnattachedCategoryForClass(cat, cls->isa, hi);
                if (isRealized(cls->isa)) {
                    remethodizeClass(cls->isa);
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)",
                                 getName(cls), cat->name);
                }
            }
        }
    }

这段代码很容易理解：

• 把category的实例方法、协议以及属性添加到类上
• 把category的类方法和协议添加到类的metaclass上

在上述的代码片段里，addUnattachedCategoryForClass只是把类和category做一个关联映射，而remethodizeClass才是真正去处理添加事宜的功臣，remethodizeClass实现：

static void remethodizeClass(class_t *cls)
{
    category_list *cats;
    BOOL isMeta;

    rwlock_assert_writing(&runtimeLock);

    isMeta = isMetaClass(cls);

    // Re-methodizing: check for more categories
    if ((cats = unattachedCategoriesForClass(cls))) {
        chained_property_list *newproperties;
        const protocol_list_t **newprotos;

        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s",
                         getName(cls), isMeta ? "(meta)" : "");
        }

        // Update methods, properties, protocols

        BOOL vtableAffected = NO;
        attachCategoryMethods(cls, cats, &vtableAffected);

        newproperties = buildPropertyList(NULL, cats, isMeta);
        if (newproperties) {
            newproperties->next = cls->data()->properties;
            cls->data()->properties = newproperties;
        }

        newprotos = buildProtocolList(cats, NULL, cls->data()->protocols);
        if (cls->data()->protocols  &&  cls->data()->protocols != newprotos) {
            _free_internal(cls->data()->protocols);
        }
        cls->data()->protocols = newprotos;

        _free_internal(cats);

        // Update method caches and vtables
        flushCaches(cls);
        if (vtableAffected) flushVtables(cls);
    }
}

而对于添加类的实例方法而言，又会去调用attachCategories这个方法，我们去看下attachCategories：

static void attachCategories(Class cls, category_list *cats, bool flush_caches) {
    if (!cats) return;
    bool isMeta = cls->isMetaClass();
    method_list_t **mlists = (method_list_t **)malloc(cats->count * sizeof(*mlists));
    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int i = cats->count;
    while (i--) {
        auto& entry = cats->list[i];
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            mlists[mcount++] = mlist;
        }
    }
    auto rw = cls->data();
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);
}

以上调用过程如下：

void _read_images(header_info **hList, uint32_t hCount)
└──static void remethodizeClass(Class cls)
    └──static void attachCategories(Class cls, category_list *cats, bool flush_caches)

首先，通过 while 循环，我们遍历所有的 category，也就是参数 cats 中的 list 属性。对于每一个 category，得到它的方法列表 mlist 并存入 mlists 中。

换句话说，我们将所有 category 中的方法拼接到了一个大的二维数组中，数组的每一个元素都是装有一个 category 所有方法的容器。这句话比较绕，但你可以把 mlists 理解为文章开头所说，旧版本的 objc_method_list **methodLists。

在 while 循环外，我们得到了拼接成的方法，此时需要与类原来的方法合并:

auto rw = cls->data();
rw->methods.attachLists(mlists, mcount);

这两行代码读不懂是必然的，因为在 Objective-C 2.0 时代，对象的内存布局已经发生了一些变化。我们需要先了解对象的布局模型才能理解这段代码。

Objective-C 2.0 对象布局模型

我们主要看下一下三个概念：

1、 objc_class
2、 class_data_bits_t
3、 class_rw_t

• objc_class

相信读到这里的大部分读者都学习过文章开头所说的对象布局模型，因此在这一部分，我们采用类比的方法，来看看 Objective-C 2.0 下发生了哪些改变。

首先，Class 和 id 指针的定义并没有发生改变，他们一个指向类对应的结构体，一个指向对象对应的结构体:

// objc.h
typedef struct objc_class *Class;
typedef struct objc_object *id;

比较有意思的一点是，objc_class 结构体是继承自 objc_object的:

struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};
struct objc_class : objc_object {
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
    class_rw_t *data() {
        return bits.data();
    }
};

这一点也很容易理解，早在 Objective-C 1.0 时代，我们就知道一个对象的结构体只有 isa 指针，指向它所属的类。而类的结构体也有 isa 指针指向它的元类.

可见 Objective-C 1.0 的布局模型中，cache和 super_class 被原封不动的移过来了，而剩下的属性则似乎消失不见。取而代之的是一个 bits属性，以及 data() 方法，这个方法调用的其实是 bits 属性的data()方法，并返回了一个 class_rw_t类型的结构体指针。

• class_data_bits_t

以下是简化版 class_data_bits_t 结构体的定义:

struct class_data_bits_t {
    uintptr_t bits;
public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
}

可见这个结构体只有一个 64 位的 bits 成员，存储了一个指向 class_rw_t 结构体的指针和三个标志位。它实际上由三部分组成。首先由于 Mac OS X 只使用 47 位内存地址，所以前 17 位空余出来，提供给 retain/release 和 alloc/dealloc 方法使用，做一些优化。其次，由于内存对齐，指针地址的后三位都是 0，因此可以用来做标志位:

// class is a Swift class
#define FAST_IS_SWIFT           (1UL<<0)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<1)
// class's instances requires raw isa
#define FAST_REQUIRES_RAW_ISA   (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL

如果计算一下就会发现，FAST_DATA_MASK 这个 16 进制常量的二进制表示恰好后三位为0，且长度为47位: 11111111111111111111111111111111111111111111000，我们通过这个掩码做按位与运算即可取出正确的指针地址。

引用 Draveness 在 深入解析 Objective-C 中方法的结构 中的图片做一个总结:

• class_rw_t

bits 中包含了一个指向 class_rw_t结构体的指针，它的定义如下:

struct class_rw_t {
    uint32_t flags;
    uint32_t version;
    const class_ro_t *ro;
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;
}

注意到有一个名字很类似的结构体 class_ro_t，这里的rw和 ro分别表示 readwrite 和 readonly。因为 class_ro_t存储了一些由编译器生成的常量。

正是由于 class_ro_t中的两个属性instanceStart 和 instanceSize的存在，保证了 Objective-C2.0 的 ABI 稳定性。因为即使父类增加方法，子类也可以在运行时重新计算 ivar 的偏移量，从而避免重新编译。

我们回头接着分析代码：

auto rw = cls->data();
rw->methods.attachLists(mlists, mcount);

现在来看，rw 是一个 class_rw_t 类型的结构体指针。根据 runtime 中的数据结构，它有一个 methods 结构体成员，并从父类继承了 attachLists 方法，用来合并 category 中的方法:

void attachLists(List* const * addedLists, uint32_t addedCount) {
    if (addedCount == 0) return;
    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]));
    memcpy(array()->lists, addedLists, addedCount * sizeof(array()->lists[0]));
}

在实际代码中，比上面略复杂一些。因为为了提高性能，苹果做了一些优化，比如当 List 处于第二种状态(只有一个指针，指向一个元数据的集合)时，其实并不需要在原地扩容空间，而是只要重新申请一块内存，并将最后一个位置留给原来的集合即可。

这样只多花费了很少的内存空间，也就是原来二维数组占用的内存空间，但是 malloc() 的性能优势会更加明显，这其实是一个空间换时间的权衡问题。

需要注意的是，无论执行哪种逻辑，参数列表中的方法都会被添加到二维数组的前面。而我们简单的看一下 runtime 在查找方法时的逻辑:

static method_t *getMethodNoSuper_nolock(Class cls, SEL sel){
    for (auto mlists = cls->data()->methods.beginLists(),
              end = cls->data()->methods.endLists();
         mlists != end;
         ++mlists) {
        method_t *m = search_method_list(*mlists, sel);
        if (m) return m;
    }
    return nil;
}
static method_t *search_method_list(const method_list_t *mlist, SEL sel) {
    for (auto& meth : *mlist) {
        if (meth.name == sel) return &meth;
    }
}

可见搜索的过程是按照从前向后的顺序进行的，一旦找到了就会停止循环。因此 category 中定义的同名方法不会替换类中原有的方法，但是对原方法的调用实际上会调用 category 中的方法。

4、-category和+load方法

我们知道，在类和category中都可以有+load方法，那么有两个问题：

• 在类的+load方法调用的时候，我们可以调用category中声明的方法么？
• 这么些个+load方法，调用顺序是咋样的呢？

鉴于上述几节我们看的代码太多了，对于这两个问题我们先来看一点直观的：

我们的代码里有Person和Person的两个category （Category1和Category2），Person和两个category都添加了+load方法，并且Category1和Category2都写了Person的printName方法。
在Xcode中点击Edit Scheme，添加如下两个环境变量（可以在执行load方法以及加载category的时候打印log信息，更多的环境变量选项可参见objc-private.h）:

即：OBJC_PRINT_LOAD_METHODS 和 OBJC_PRINT_REPLACED_METHODS
运行项目，我们会看到控制台打印很多东西出来，我们只找到我们想要的信息，顺序如下：

objc[85057]: REPLACED: -[Person printName]  by category Category1 
objc[85057]: REPLACED: -[Person printName]  by category Category2
objc[85057]: LOAD: class 'Person' scheduled for +load
objc[85057]: LOAD: category 'Person(Category1)' scheduled for +load
objc[85057]: LOAD: category 'Person(Category2)' scheduled for +load
objc[85057]: LOAD: +[Person load]
objc[85057]: LOAD: +[Person(Category1) load]
objc[85057]: LOAD: +[Person(Category2) load]

所以，对于上面两个问题，答案是很明显的：
1)、可以调用，因为附加category到类的工作会先于+load方法的执行
2)、+load的执行顺序是先类，后category，而category的+load执行顺序是根据编译顺序决定的。
目前的编译顺序是这样的：

我们调整一个Category1和Category2的编译顺序，run。ok，我们可以看到控制台的输出顺序变了：

objc[85494]: REPLACED: -[Person printName]  by category Category2
objc[85494]: REPLACED: -[Person printName]  by category Category1
objc[85494]: LOAD: class 'Person' scheduled for +load
objc[85494]: LOAD: category 'Person(Category2)' scheduled for +load
objc[85494]: LOAD: category 'Person(Category1)' scheduled for +load
objc[85494]: LOAD: +[Person load]
objc[85494]: LOAD: +[Person(Category2) load]
objc[85494]: LOAD: +[Person(Category1) load]

虽然对于+load的执行顺序是这样，但是对于“覆盖”掉的方法，则会先找到最后一个编译的category里的对应方法。
那么怎么调用到原来类中被category覆盖掉的方法？
对于这个问题，我们已经知道category其实并不是完全替换掉原来类的同名方法，只是category在方法列表的前面而已，所以我们只要顺着方法列表找到最后一个对应名字的方法，就可以调用原来类的方法：

Person currentClass = [Person class];
Person *per = [[Person alloc] init];

if (currentClass) {
    unsigned int methodCount;
    Method *methodList = class_copyMethodList(currentClass, &methodCount);
    IMP lastImp = NULL;
    SEL lastSel = NULL;
    for (NSInteger i = 0; i < methodCount; i++) {
        Method method = methodList[i];
        NSString *methodName = [NSString stringWithCString:sel_getName(method_getName(method)) 
                                        encoding:NSUTF8StringEncoding];
        if ([@"printName" isEqualToString:methodName]) {
            lastImp = method_getImplementation(method);
            lastSel = method_getName(method);
        }
    }
    typedef void (*fn)(id,SEL);

    if (lastImp != NULL) {
        fn f = (fn)lastImp;
        f(per,lastSel);
    }
    free(methodList);
}

参考资料：
结合 category 工作原理分析 OC2.0 中的 runtime
iOS category内部实现原理