问题作为引导：
1.category使用场合是什么？
2.category实现原理？
3.category 和 class extension 的区别是什么？
4.category 中有load 方法吗？ load 方法什么时候调用？ load 方法能继承吗？
5.+load、+initialize方法的区别是什么？他们在category中的调用顺序？出现继承时他们之间的调用过程？
6.category 分类能否添加成员变量？如果可以，如何给category添加成员变量？
1.category使用场合是什么？
一个类分解成多个模块时，使用分类。
Q:调用分类方法时，分类中的方法也是存在类对象中吗？
一个类只有一个类对象，分类不会另外生成分类对象，分类中的对象方法也是存在于类对象的方法列表中。分类中的类方法，也都合并到元类对象方法列表中。
Q:分类Category是如何合并到类对象结构中的？
A:首先需要了解，分类编译完成后的数据，其实就是一种结构体数据。
可以通过clang查看编译文件
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc NSObject+Test.m
分类编译后数据结构如下
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;//属性列表
};
Category源码加载处理过程
Runtime中Category源码解读顺序如下
objc-os.mm
- _objc_init
- map_images
- map_images_nolock
objc-runtime-new.mm
- _read_images
- remethodizeClass
- attachCategories
- attachLists
- realloc、memmove、 memcpy
objc-os.mm
//运行初始化
void _objc_init(void)
{
environ_init();
tls_init();
static_init();
lock_init();
exception_init();
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
//images 镜像、模块的意思。
//map 通常理解为k-v形式字典即可
//侧重读取&map_images即可
objc-runtime-new.mm
remethodieClass(); //重新组织方法列表
attachCategories(); //attach 附加。
// 此方法是将分类对象方法合并到一个数组
//属性合并到一个数组...
//C 语言中两个* 看成数组标志就行
// cls 类
// cats 分类列表
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);
}
Q:分类与类中同样方法，调用顺序？
A：同样的方法优先调用分类。如果两个分类有同一个方法，调用顺序则取决于编译顺序。调用后编译的分类，原因通过上面源码：while (i--) {}注意i--。
Q：分类的对象方法是如何添加到类对象方法列表中的？
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;
//array()->lists:原来类对象的方法列表
//内存移动
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
//addedLists:所有分类的方法列表
//内存拷贝
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]));
}
}
分类加入到类对象中核心代码：
uint32_t oldCount = array()->count;
uint32_t newCount = oldCount + addedCount;
//重新分配 内存大小
setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
array()->count = newCount;
//array()->lists:原来类对象的方法列表
//内存移动
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
//addedLists:所有分类的方法列表
//内存拷贝
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
流程：
- 首先内存扩充。扩展存对象方法的数组大小
- 其次内存移动。将原来类对象方法列表数据移到后面
- 最后内存拷贝。将分类中方法拷贝到原来列表指向位置。
演示图
记住此图，方法列表的时候，是通过一个中间数组来管理查找方法列表的。后面讲的load方法同此处会有差异。
总结：
- 类与分类中的同样的方法：会优先调用分类中的方法。
- 两个分类中的同样的方法：取决于编译顺序，调用后编译的。
Q：memmove和memcpy的区别？
A:memmove会根据内存大小，移动方向，数量来移动内存；memcpy是按照一定规则一个地址一个地址拷贝。memmove能保证原数据完整性，内部移动最好不要使用memcpy，外部内存移动可以使用。
Q:分类中的方法何时合并到类对象中去的呢？
A:并不是在编译时，而是在运行时，通过runtime动态将编译好的分类方法合并到类对象、元类对象中去。
Category加载说明:
Q:如何设置项目类的编译顺序？
A：BuildPhases --> compile source 里设编译顺序
2.category实现原理？
A:从两点回答：
- Category编译之后的底层结构是 struct _category_t, 里面存储着分类的对象方法、类方法、属性、协议信息。
- 程序运行时，runtime会将category的数据，合并到类信息中。（类对象、元类对象中）
类扩展 Class Extension有什么用处？
A: 类扩展，就是在对本该公开声明的信息，放在了.m文件中进行私有化。但是这些数据在编译时候也是存在类信息中的。
KCPerson.m文件
@interface KCPerson () {
int _age;
}
@property (nonatomic, assign) int height;
- (void)getFood;
@end
3.category 和 class extension 的区别是什么？
A:
category 是在运行时才会将数据合并到类信息中。
class extension 在编译时就会将数 据编译到类信息中
Category 中load源码解读
objc_os.mm
_objc_init
- load_images
prepare_load_methods
- schedule_class_load
- add_class_to_loadable_list
- add_category_to_loadable_list
call_load_methods
- call_class_loads
- call_category_loads
- (*load_method)(cls, SEL_load)
objc-loadmethod.mm
struct loadable_class {
Class cls; // may be nil
IMP method; // +load
};
struct loadable_category {
Category cat; // may be nil
IMP method; // 分类的+load
};
下面我们通过源码解读 类、分类中load方法的添加顺序
_objc_init方法是RunTime运行的入口
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);
}
images镜像的意思。我们在_objc_init方法中找到load_images，load_images是Load加载镜像的意思，所有我们可以猜测这个里面应该有我们load的加载方法的相关实现。
我们点击进入load_images方法
load_images(const char *path __unused, const struct mach_header *mh)
{
// Return without taking locks if there are no +load methods here.
if (!hasLoadMethods((const headerType *)mh)) return;
recursive_mutex_locker_t lock(loadMethodLock);
// Discover load methods
{
rwlock_writer_t lock2(runtimeLock);
prepare_load_methods((const headerType *)mh);
}
// Call +load methods (without runtimeLock - re-entrant)
call_load_methods();
}
里面有两个需要我们注意的
- 1、
prepare_load_methods((const headerType *)mh)准备加载Load方法，我们也可以看到上面的官方文档解释也是这个意思 - 2、
call_load_methods()加载load方法
我们点击进入prepare_load_methods((const headerType *)mh)准备加载Load方法
void prepare_load_methods(const headerType *mhdr)
{
size_t count, i;
runtimeLock.assertWriting();
classref_t *classlist =
_getObjc2NonlazyClassList(mhdr, &count);
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
for (i = 0; i < count; i++) {
category_t *cat = categorylist[i];
Class cls = remapClass(cat->cls);
if (!cls) continue; // category for ignored weak-linked class
realizeClass(cls);
assert(cls->ISA()->isRealized());
add_category_to_loadable_list(cat);
}
}
我们可以看到执行顺序
- 1、
schedule_class_load(remapClass(classlist[i]));,这个是把类中的Load方法添加到数组中。 - 2、
add_category_to_loadable_list(cat);这个是把分类中的load方法添加到数组中
查看类的load方法
我们查看schedule_class_load(remapClass(classlist[i]));方法里面还有哪些实现
static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized()); // _read_images should realize
if (cls->data()->flags & RW_LOADED) return;
// Ensure superclass-first ordering
schedule_class_load(cls->superclass);
add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED);
}
- 1、
schedule_class_load(cls->superclass);把父类load先添加到数组中 - 2、
add_class_to_loadable_list(cls);把自己的load方法添加到数组中
走到这里我们大概是清楚了类中load方法的加载添加过程，利用递归原理，先把父类添加带数组中，然后再把自己添加到数组中
查看分类的load方法
我们点击add_category_to_loadable_list(cat)进入查看方法实现
void add_category_to_loadable_list(Category cat)
{
IMP method;
loadMethodLock.assertLocked();
method = _category_getLoadMethod(cat);
// Don't bother if cat has no +load method
if (!method) return;
if (PrintLoading) {
_objc_inform("LOAD: category '%s(%s)' scheduled for +load",
_category_getClassName(cat), _category_getName(cat));
}
if (loadable_categories_used == loadable_categories_allocated) {
loadable_categories_allocated = loadable_categories_allocated*2 + 16;
loadable_categories = (struct loadable_category *)
realloc(loadable_categories,
loadable_categories_allocated *
sizeof(struct loadable_category));
}
loadable_categories[loadable_categories_used].cat = cat;
loadable_categories[loadable_categories_used].method = method;
loadable_categories_used++;
}
loadable_categories_used++;分类没有什么特殊的方法，应该就是按照编译顺序添加到数组的。
现在再来看看加载顺序,点击call_load_methods();进入相关实现
void call_load_methods(void)
{
static bool loading = NO;
bool more_categories;
loadMethodLock.assertLocked();
// Re-entrant calls do nothing; the outermost call will finish the job.
if (loading) return;
loading = YES;
void *pool = objc_autoreleasePoolPush();
do {
// 1. Repeatedly call class +loads until there aren't any more
while (loadable_classes_used > 0) {
call_class_loads();
}
// 2. Call category +loads ONCE
more_categories = call_category_loads();
// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0 || more_categories);
objc_autoreleasePoolPop(pool);
loading = NO;
}
- 1、
call_class_loads();加载类中load方法 - 2、
more_categories = call_category_loads()加载分类中load方法
根据上面源码，做一个总结：
load调用时机：在runtime加载类、分类时调用，每个类、分类load在程序中只调用一次。
load调用顺序：
- 1.先调用项目中所有类的load方法。（先编译，先调用）调用子类load之前先调用父类的load方法。
- 2.其次才调用分类 category的load方法。（先编译，先调用）
load方法调用本质：load方法是根据方法地址直接调用，所有本质load方法都会调用。并不是走的消息发送objc_msgSend, 消息发送情况下的方法会出现分类方法“覆盖”（本质类信息中方法排列顺序改变造成）。
关于load 的调用图
4.category 中有load 方法吗？ load 方法什么时候调用？ load 方法能继承吗？
A：有load，在runtime加载类、分类的时候调用。
load方法可以继承，但是通常我们不会主动调用。都是系统自动调用。
如果我们主动调用的，也就是[KCPerson load]手动调用，这样就变成消息发送机制流程了。
Category 中initialize源码解读
Q:什么时候调用initialize呢？
A:+initialize方法会在类第一次接收到消息时调用
Q:调用顺序是什么：
先调用父类的+initialize，再调用子类的+initialize(先初始化父类，再初始化子类，每个类只会初始化1次)
-
+initialize和+load的很大区别是，+initialize是通过objc_msgSend进行调用的，所以有以下特点
- 如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）
- 如果分类实现了+initialize，就覆盖类本身的+initialize调用
objc4源码解读过程
objc-runtime-new.mm
- class_getInstanceMethod
- lookUpImpOrNil
- lookUpImpOrForward
- _class_initialize
- callInitialize
- objc_msgSend(cls, SEL_initialize)
我们在objc-runtime-new.mm文件中找到class_getInstanceMethod，里面就有一个主要实现方法lookUpImpOrNil
Method class_getInstanceMethod(Class cls, SEL sel)
{
if (!cls || !sel) return nil;
#warning fixme build and search caches
lookUpImpOrNil(cls, sel, nil,
NO/*initialize*/, NO/*cache*/, YES/*resolver*/);
#warning fixme build and search caches
return _class_getMethod(cls, sel);
}
里面没有什么实现我们继续点击lookUpImpOrNil进入实现
IMP lookUpImpOrNil(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
IMP imp = lookUpImpOrForward(cls, sel, inst, initialize, cache, resolver);
if (imp == _objc_msgForward_impcache) return nil;
else return imp;
}
里面好像还是没有我们想要的具体实现，继续点击lookUpImpOrForward查看实现
if (initialize && !cls->isInitialized()) {
runtimeLock.unlockRead();
_class_initialize (_class_getNonMetaClass(cls, inst));
runtimeLock.read();
}
这个里面有一个if判断里面有一些东西，就是在没有实现isInitialized的时候，调用_class_initialize方法，我们点击进入查看相关实现
if (supercls && !supercls->isInitialized()) {
_class_initialize(supercls);
}
callInitialize(cls);
里面有这两个主要的函数
- 1、第一个是判断是否存在父类，以及父类是否实现
initialize方法，如果没有实现就去实现 - 2、去实现自己的
initialize方法。
我们在点击callInitialize发现具体是通过objc_msgSend来实现的。
void callInitialize(Class cls)
{
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
asm("");
}
模拟initialize内部伪代码实现
继承关系如下
KCStudent : KCPerson : NSObject
[KCStudent alloc]; //内部实现的伪代码应该如下
Bool personInitialize = NO；
Bool studentInitialize = NO；
if(!studentInitialize ) {
if(!personInitialize ) {
objc_msgSend([KCPerson class],@selector(initialize));
personInitialize = YES;
}
objc_msgSend([KCStudent class],@selector(initialize));
studentInitialize = YES;
}
5.+load、+initialize方法的区别是什么？他们在category中的调用顺序？出现继承时他们之间的调用过程？
- 1.调用方式
- 2.调用时刻
- 3.调用顺序
调用方式区别：
+Load方法：是根据函数地址直接调用的
+initialize方法：是通过objc_msgSend消息发送调用
调用时刻区别：
+Load方法：是runtime加载类、分类的时刻调用。（只调1次）
+initialize方法：是类第1次接收到消息的时候调用，每一个类只会initialize 1次（父类的initialize方法可能被调多次）。
调用顺序区别：
+Load方法：
先调用项目中所有类的load（哪个类先编译，哪个先调用。调用子类前先调用父类load）
再调用分类中load（分类中先编译，先调用Load）。
+initialize方法：
先初始化父类
再初始化子类（如果子类此方法不存在，则会再次调用父类的initialize方法）
第6个问题，下篇文章继续解读。
