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_catlistsection里保存了一个大小为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内部实现原理
