Category 底层分析
- 一、Category 浅层分析
- 二、Category 底层结构
- 三、Category 源码分析(分类方法优先调用)
- 四、小结
一、Category 浅层分析
参照上图，思考关于分类的问题。分类有没有可能同上图的
class 或 meta-class 处于并列关系，每创建一个分类分别对应着一个 分类class 和 分类meta-class 对象？
这里先说出结论，在第二小节再做验证。实际情况并非如此，为了充分利用资源，一个类永远只存在一个类对象。Category 中的对象方法会合并到类(class)的对象方法列表中，类方法合并到元类(meta-class)的类方法列表中。方法合并的时机在运行时进行，而非编译期间。
二、Category 底层结构
@implementation Person
- (void)run{
NSLog(@"run");
}
@end
@implementation Person (Test)
- (void)test{
NSLog(@"test");
}
+ (void)test{
}
@end
@implementation Person (Eat)
- (void)eat{
NSLog(@"eat");
}
+ (void)eat{
}
@end
为验证上述问题，可以编写如上代码，即创建 Person 以及 Person + Test 和 Person + Eat 分类。然后借助xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件 命令将 Person + Test类转为 C/C++ 代码。
生成的 .cpp 文件中包含 _category_t 结构体，该结构体即为分类底层数据结构，主要包含类名、对象方法、类方法、协议以及属性。
struct _category_t {
const char *name;//类名，这里是Person
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;//属性列表
};
生成的.cpp 文件中还存在下下面一段代码，该段代码与 _category_t结构体对应，依次给_category_t 结构体内部成员赋值。其中第二、五、六三个参数均为 0。
static struct _category_t _OBJC_$_CATEGORY_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"Person",
0, // &OBJC_CLASS_$_Person,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test,
0,
0,
};
从上述验证可以看出，编译期间过后，每个分类唯一对应一个 _category_t 结构，与原有类是分开的。
三、Category 源码分析(分类方法优先调用)
为进一步理解 Category ，可以查看在该网站 查看 objc4-723 runtime 底层源码 。可以顺着如下顺序阅读源码，其中 objc-os.mm 文件为运行时的入口文件。
objc-os.mm ---> _objc_init ---> map_images ---> map_images_nolock --->objc-runtime-new.mm --->_read_images --->remethodizeClass --->attachCategories --->attachLists
在_read_images方法中可以发现这样一段代码，代码上方注释为 Discover categories , 另外还有个二维数组category_t ** catlist， catlist 数组中元素为结构体，存储着一堆 category_t 结构。remethodizeClass 方法被调用两次，从命名来看意思为：重新方法化，两次传入参数分别为 cls 和 cls->ISA, 即类对象的元类对象。
// Discover categories.
for (EACH_HEADER) {
category_t **catlist =
_getObjc2CategoryList(hi, &count);
bool hasClassProperties = hi->info()->hasCategoryClassProperties();
for (i = 0; i < count; i++) {
category_t *cat = catlist[I];
Class cls = remapClass(cat->cls);
if (!cls) {
// Category's target class is missing (probably weak-linked).
// Disavow any knowledge of this category.
catlist[i] = nil;
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 (cls->isRealized()) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
cls->nameForLogging(), cat->name,
classExists ? "on existing class" : "");
}
}
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
cls->nameForLogging(), cat->name);
}
}
}
}
remethodizeClass 方法内部调用了 attachCategories 方法，attachCategories 方法前两个参数分别为 class 和 分类数组cats。
static void remethodizeClass(Class cls)
{
category_list *cats;
bool isMeta;
runtimeLock.assertWriting();
isMeta = cls->isMetaClass();
// Re-methodizing: check for more categories
if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
if (PrintConnecting) {
_objc_inform("CLASS: attaching categories to class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
attachCategories(cls, cats, true /*flush caches*/);
free(cats);
}
}
attachCategories 方法内部创建了三个二维数组method_list_t **mlists,property_list_t **proplists,protocol_list_t **protolists, 分别用于保存方法、属性和协议。mlists[mcount++] = mlist; 表示取出每个分类中的方法列表放入到二维数组中；auto rw = cls->data(); 表示取出类对象中的数据；rw->methods.attachLists(mlists, mcount);表示将所有分类的对象方法附加到类对象方法列表中。
static void
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
// fixme rearrange to remove these intermediate allocations
//方法数组 [[method_t, method_t],[method_t, method_t]]
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, 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);
}
attachLists 方法中调用memmove方法将类中的原有方法方法放到数组末尾，调用memcpy方法将二维数组 addedLists 中的每个 Category 的方法列表放置到类中原有方法的前面。
void attachLists(List* const * addedLists, uint32_t addedCount) {
if (addedCount == 0) return;
if (hasArray()) {
// 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]));
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]));
}
}
四、小结
经过上述源码分析，最终方法在内存中的布局结构如下。该布局很好说明了分类方法调用顺序要优于原有类方法。因为调用方法时，会顺序遍历二维数组查找方法，当查找到目标方法后就无需再向后继续遍历查找方法。
