iOS基础之Category（一）

• 
  
• extension 是在编译器决定的，它就是类的一部分，在编译期和头文件里的 @interface 和 实现文件里的 @implementation形成一个完整的类，它伴随类的的产生而产生，随着类的消亡而消亡。extension 一般用来隐藏类的私有信息，必须有类的源码才可以为一个类添加 extension。所以无法为系统的类添加 extension。
  
• category 是在运行期决定的，category 是无法添加实例变量的，extension 是可以添加的。
  

我们首先来看以下 category的基本使用：

// Person+Eat.h

#import "Person.h"

@interface Person (Eat) 


- (void)eatBread;


+ (void)eatFruit;

@property (nonatomic, assign) int count;

@end

// Person+Eat.m

#import "Person+Eat.h"

@implementation Person (Eat)


- (void)eatBread {
NSLog(@"eatBread");

}


+ (void)eatFruit {
NSLog(@"eatFruit");

}

@end
复制代码,>

• 
  
• 创建了一个 Person 的分类，专门实现吃这个功能
  
• 这个分类遵守了2个协议，分别为 NSCopying 和 NSCoding
  
• 声明了2个方法，一个实例方法，一个类方法
  
• 定义一个 count 属性
  

我们通过 clang 编译器来观察一下在编译期这些代码的本质是什么？

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc MyClass.m -o MyClass-arm64.cpp
复制代码

编译之后，我们可以发现 category 的本质是结构体 category_t，无论我们创建了多少个 category 最终都会生成 category_t 这个结构体，并且 category 中的方法、属性、协议都是存储在这个结构体里的。也就是说在编译期，分类中成员是不会和类合并在一起的。

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;

};
复制代码

• 
  
• name：类的名字
  
• cls：类
  
• instanceMethods ：category 中所有给类添加的实例方法的列表
  
• classMethods：category 中所有给类添加的类方法的列表
  
• protocols：category 中实现的所有协议的列表
  
• instanceProperties：category 中添加的所有属性
  

从 category 的定义中可以看到我们可以 添加实例方法，添加类方法，可以实现协议，可以添加属性。

不可以添加实例变量

我们继续研究下面的编译后的代码：

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_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,

	{{(struct objc_selector *)"eatBread", "v16@0:8", (void *)_I_Person_Eat_eatBread}}

};

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

} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,

	{{(struct objc_selector *)"eatFruit", "v16@0:8", (void *)_C_Person_Eat_eatFruit}}

};

static struct /*_protocol_list_t*/ {
long protocol_count;  // Note, this is 32/64 bit
struct _protocol_t *super_protocols[2];

} _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
2,

	&_OBJC_PROTOCOL_NSCopying,

	&_OBJC_PROTOCOL_NSCoding

};

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_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
1,

	{{"count","Ti,N"}}

};

static struct _category_t _OBJC_$_CATEGORY_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = 

{
"Person",
0, // &OBJC_CLASS_$_Person,

	(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat,

	(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat,

	(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat,

	(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_Eat,

};
复制代码

• 
  
• 首先看一下 _OBJC_$_CATEGORY_Person_$_Eat 结构体变量中的值，就是分别对应 category_t 的成员，第1个成员就是类名，因为我们声明了实例方法，类方法，遵守了协议，定义了属性，所以我们的结构体变量中这些都会有值。
  
• _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat 结构体表示实例方法列表，里面包含了 eatBread 实例方法
  
• _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat 结构体包含了 eatFruit 类方法
  
• _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat 结构体包含了 NSCoping 和 NSCoding 协议
  
• _OBJC_$_PROP_LIST_Person_$_Eat 结构体包含了 count 属性
  

在研究完编译时期的 category 后，我们进而研究运行时期的 category

在 objc-runtime-new.mm 的源码中，我们可以最终找到如何将 category 中的方法列表，属性列表，协议列表添加到类中。

static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
int flags)
{
if (slowpath(PrintReplacedMethods)) {

        printReplacements(cls, cats_list, cats_count);

    }
if (slowpath(PrintConnecting)) {

        _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",

                     cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",

                     cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");

    }

/*

     * Only a few classes have more than 64 categories during launch.

     * This uses a little stack, and avoids malloc.

     *

     * Categories must be added in the proper order, which is back

     * to front. To do that with the chunking, we iterate cats_list

     * from front to back, build up the local buffers backwards,

     * and call attachLists on the chunks. attachLists prepends the

     * lists, so the final result is in the expected order.

     */
constexpr uint32_t ATTACH_BUFSIZ = 64;
method_list_t   *mlists[ATTACH_BUFSIZ];
property_list_t *proplists[ATTACH_BUFSIZ];
protocol_list_t *protolists[ATTACH_BUFSIZ];

uint32_t mcount = 0;
uint32_t propcount = 0;
uint32_t protocount = 0;
bool fromBundle = NO;
bool isMeta = (flags & ATTACH_METACLASS);
auto rwe = cls->data()->extAllocIfNeeded();

for (uint32_t i = 0; i < cats_count; i++) {
auto& entry = cats_list[i];

method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if ( ) {
if (mcount == ATTACH_BUFSIZ) {

                prepareMethodLists(cls, mlists, mcount, NO, fromBundle);

                rwe->methods.attachLists(mlists, mcount);

                mcount = 0;

            }

            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;

            fromBundle |= entry.hi->isBundle();

        }

property_list_t *proplist =

            entry.cat->propertiesForMeta(isMeta, entry.hi);
if (proplist) {
if (propcount == ATTACH_BUFSIZ) {

                rwe->properties.attachLists(proplists, propcount);

                propcount = 0;

            }

            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;

        }

protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);
if (protolist) {
if (protocount == ATTACH_BUFSIZ) {

                rwe->protocols.attachLists(protolists, protocount);

                protocount = 0;

            }

            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;

        }

    }

if (mcount > 0) {

        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount, NO, fromBundle);

        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
if (flags & ATTACH_EXISTING) flushCaches(cls);

    }


    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);


    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);

}

复制代码

• 
  
• rwe->methods.attachLists(mlists, mcount);
  
• rwe->protocols.attachLists(protolists, protocount);
  
• rwe->properties.attachLists(proplists, propcount);
  

以上三个函数就是把 category 中的方法、属性和协议列表添加到类中的函数。

继续查看 attchLists 函数的实现：

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]));

    }

}

复制代码

• 
  
• 在这段源码中，主要关注2个函数 memmove 和 memcpy。
  
• memmove 函数的作用是移动内存，将之前的内存向后移动，将原来的方法列表往后移
  
• memcpy 函数的作用是内存的拷贝，将 category 中的方法列表复制到上一步移出来的位置。
  

从上述源码中，可以发现 category 的方法并没有替换原来类已有的方法，如果 category 和原来类中都有某个同名方法，只不过 category 中的方法被放到了新方法列表的前面，在运行时查找方法的时候是按照顺序查找的，一旦找到该方法，就不会向下继续查找了，产生了 category 会覆盖原类方法的假象。

所以我们在 category 定义方法的时候都要加上前缀，以避免意外的重名把类本身的方法”覆盖“掉。

• 
  
• 如果多个 category 中存在同名的方法，运行时最终调用哪个方法是由编译器决定的，最后一个参与编译的方法将会先被调用。