category 概述
category 是 Objective-C 2.0 之后新添加的语言特性，主要作用是为已经存在的类添加方法，除此之外， Apple 还推荐了另外两个使用场景
- 可以把类的实现分开在几个不同的文件里面。这样做的好处是
- 可以减少单个文件的体积
- 把不同的功能组织到不同的 category 里
- 可以由多个开发者共同完成一个类
- 可以按需加载想要的 category
- 声明私有方法
category 与 extension
extension 与 category 差别很大。extension 在编译期决议，它是类的一部分，在编译期和头文件里的 @interface 以及实现文件里的 @implement 一起形成一个完整的类，它伴随类的产生而产生，亦随之一起消亡。 extension 一般用来隐藏类的私有信息，必须有一个类的源码才能为一个类添加 extension，所以你无法为系统的类例如 NSString 添加 extension
但是 category 则完全不一样，它是在运行期决议的。一起明显的事实是，extension 可以添加实例变量，而 category 无法添加实例变量（因为运行期，对象的内存布局已经确定）
category 真面目
OC 类和对象，在 runtime 层都是 struct 表示的。category 用结构体 category_t(在 objc-runtime-new.h 中可以找到)
struct category_t {
const char *name; // 类的名字
classref_t cls; // 类
struct method_list_t *instanceMethods; // category 中所有给类添加的实例方法类表
struct method_list_t *classMethods; // category 中所有添加的类方法类表
struct protocol_list_t *protocols; // 实现的协议列表
struct property_list_t *instanceProperties; // 添加的属性类表
// Fields below this point are not always present on disk.
struct property_list_t *_classProperties;
method_list_t *methodsForMeta(bool isMeta) {
if (isMeta) return classMethods;
else return instanceMethods;
}
property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};
从 category 的定义可以看出 category 的可为(添加实例方法、类方法、属性，实现协议) 和不可为(无法添加实例变量)
我们先去写一个 category
// TestModel.h
#import <Foundation/Foundation.h>
@interface TestModel : NSObject
@end
// TestModel+Success.h
#import "TestModel.h"
@interface TestModel (Success)
@property (nonatomic, strong) NSString *MyCountry;
@end
// TestModel+Success.m
#import "TestModel+Success.h"
@implementation TestModel (Success)
- (void)hahah {
NSLog(@"11123132");
}
@end
使用 clang 的命令clang -rewrite-objc MyClass.m去看看 category 到底会变成什么
我们得到了一个差不多10w 行的 .cpp 文件，在文件的最后，我们找到了如下代码
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;
};
extern "C" __declspec(dllimport) struct objc_cache _objc_empty_cache;
#pragma warning(disable:4273)
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_TestModel_$_Success __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"hahah", "v16@0:8", (void *)_I_TestModel_Success_hahah}}
};
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_TestModel_$_Success __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
1,
{{"MyCountry","T@\"NSString\",&,N"}}
};
extern "C" __declspec(dllimport) struct _class_t OBJC_CLASS_$_TestModel;
static struct _category_t _OBJC_$_CATEGORY_TestModel_$_Success __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"TestModel",
0, // &OBJC_CLASS_$_TestModel,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_TestModel_$_Success,
0,
0,
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_TestModel_$_Success,
};
static void OBJC_CATEGORY_SETUP_$_TestModel_$_Success(void ) {
_OBJC_$_CATEGORY_TestModel_$_Success.cls = &OBJC_CLASS_$_TestModel;
}
#pragma section(".objc_inithooks$B", long, read, write)
__declspec(allocate(".objc_inithooks$B")) static void *OBJC_CATEGORY_SETUP[] = {
(void *)&OBJC_CATEGORY_SETUP_$_TestModel_$_Success,
};
static struct _category_t *L_OBJC_LABEL_CATEGORY_$ [1] __attribute__((used, section ("__DATA, __objc_catlist,regular,no_dead_strip")))= {
&_OBJC_$_CATEGORY_TestModel_$_Success,
};
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
category 如何加载
Objective-C 的运行依赖 OC 的 runtime 的，而 OC 的 runtime 和其他系统库一样，是 OS X 和 iOS 通过 dyld 动态加载的。对于 OC runtime，入口方法如下(在 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();
static_init();
lock_init();
exception_init();
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
category 被附加到类上面是在 map_images 时发生的，_objc_init 里面调用的 map_images 最终会调用 objc-runtime-new.mm 里面的 objc-runtime-new.mm 里面的 _read_images 方法，而 _read_images 方法的结尾有如下代码片段：
// 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);
}
}
}
}
首先，我们拿到的 catlist 就是前文讲到的编译器为我们准备的 category_t 数组。略去 PrintConnecting 这个用于 log 的东西，这段代码很容易理解：
- 把 category 的实例方法、协议、属性添加到类上
- 把 category 的类方法和协议添加到类的 metaclass 上
我们接着往里看，category 的各种列表是怎么最终添加到类上的，就拿实例方法来说吧：
上述代码片段里，addUnattachedCategoryForClass 只是把类和 category 做一个关联映射，而 remethodizeClass 才是真正去处理添加事宜的功臣。remethodizeClass 内部会调用到 attachCategories 函数，
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_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);
}
主要就是把所有的 category 的方法、属性、协议列表各自拼成一个大的列表，然后与类中的方法类表、属性类表、协议列表组合在一起，接着调用 attachLists 函数
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]));
}
}
有两点需要注意：
- category 方法没有完全替换掉原来类已有的方法，也就是说通过category 和原来类都有 methodA，那么 category 附加完成后，类的方法列表里会有两个 methodA。由于 category 中的方法被合并到了类方法列表中给，因此 category 添加的方法，子类也可以调用
- category 的方法被放到了新方法列表的前面，而原来类的方法被放到了新方法列表的后面（通过调用了 memmove、memcpy 函数实现），这也就是我们平常说说的 category 的方法会覆盖掉原来类的同名方法，这是因为运行时在查找方法的时候总是顺着方法列表的顺序查找的，它只要找到对应名字的方法，就会停止。
category 和关联对象
在 category 里面无法为 category 添加实例变量，但是很多时候我们需要在 category 中添加和对象关联的值，这个时候可以求助关联对象来实现
- (void)setMyCountry:(NSString *)MyCountry {
objc_setAssociatedObject(self, "name", MyCountry, OBJC_ASSOCIATION_COPY);
}
但是关联对象又是存在是什么地方呢？如何存储？对象销毁时如何处理关联对象？
在 objc-references.mm 文件中有个方法 _object_set_associative_reference 函数，所有的关联对象都由一个 AssociationsManager 对象管理，AssociationsManager 里面有一个静态的 AssociationsHashMap 来存储所有的关联对象。这相当于把所有对象的关联对象都存在一个全局 map 里面，而 map 的key 是这个对象的指针，而这个 map 的value 又是另一个 AssociationsHashMap，里面保存了关联对象的 kv 对。
而对象的销毁逻辑在 objc-runtime-new.mm 中 void objc_destructInstance (id obj) 。runtime 的销毁对象函数 会判断这个对象有没有关联对象，如果有，会调用 _object_remove_assocations 做对象的清理工作。
其他问题
-
在类的 +load 方法调用的时候，我们可以调用 category 中声明的方法么？
可以调用。附加 category 到类的工作会先于 +load 方法的执行，并且 load 的执行顺序是先类，后 category，而 category 的 load 执行顺序是根据编译顺序决定的
-
怎么调用到原来类中被 category 覆盖掉的方法？
category 起始并不是完全替换掉原来类的同名方法，只是 category 在方法列表的前面而已，所以只要顺着方法列表找到最后一个对应名字的方法，就可以调用原来类的方法
Class currentClass = [MyClass class]; MyClass *my = [[MyClass 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(my,lastSel); } free(methodList); }
网友评论