本文继续研究类的加载--分类（类别）。
分类Category
在 类加载（一）category_list -> attachCategories中研究到，对分类操作处理了，那么就需要对分类是如何加载做一个探究。
1.研究方法：clang
在main.m中新建一个分类，定义一些方法，clang之得到main.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;
};
2.Documentation
分类解释
在objc源码中找寻category_t,也能查看到分类的底层结构
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;
// 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);
protocol_list_t *protocolsForMeta(bool isMeta) {
if (isMeta) return nullptr;
else return protocols;
}
};
分类本质
- 有两个属性：name（类的名称） 和 cls（类对象）
- 有两个 method_list_t类型的方法列表：分类中实现的实例方法+类方法
- 一个protocol_list_t类型的协议列表：分类中实现的协议
- 一个prop_list_t类型的属性列表：分类中定义的属性，一般在分类中添加的属性都是通- 过关联对象来实现
- 需要注意的是，分类中的属性是没有setter、getter方法
分类的数据加载
1)methodizeClass -> objc::unattachedCategories.attachToClass（加入两次时会进入attachCategories）-> attachCategories;
2)_read_images -> load_categories_nolock ->attachCategories;
会进入分类操作，会有这样一个方法attachCategories,它是将方法列表、属性和协议从分类附加到类，这里就对分类的数据进行加载。
attachToClass
void attachToClass(Class cls, Class previously, int flags)
{
runtimeLock.assertLocked();
ASSERT((flags & ATTACH_CLASS) ||
(flags & ATTACH_METACLASS) ||
(flags & ATTACH_CLASS_AND_METACLASS));
const char *mangledName = cls->mangledName();
auto &map = get();
auto it = map.find(previously);
if (it != map.end()) { // 两次加载类时会进入
category_list &list = it->second;
if (flags & ATTACH_CLASS_AND_METACLASS) {
int otherFlags = flags & ~ATTACH_CLASS_AND_METACLASS;
// 对象方法
attachCategories(cls, list.array(), list.count(), otherFlags | ATTACH_CLASS);
// 类方法
attachCategories(cls->ISA(), list.array(), list.count(), otherFlags | ATTACH_METACLASS);
} else {
// 元类情况
attachCategories(cls, list.array(), list.count(), flags);
}
map.erase(it);
}
}
循环中会执行两次attachCategories, 原因是会执行对象方法，类方法。
attachCategories
// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order,
// oldest categories first.
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(); // 初始化rwe
const char *mangledName = cls->mangledName();
const char *LGPersonName = "LGPerson";
if (strcmp(mangledName, LGPersonName) == 0) {
bool kc_isMeta = cls->isMetaClass();
auto kc_rw = cls->data();
auto kc_ro = kc_rw->ro();
if (!kc_isMeta) {
printf("%s: 这个是我要研究的 %s \n",__func__,LGPersonName);
}
}
for (uint32_t i = 0; i < cats_count; i++) {
auto& entry = cats_list[I];
// 会倒序查
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if (mlist) {
// 由上一章可知是调用了``prepareMethodLists``对方法进行了序列化的，按照方法的``sel``地址进行了排序。
if (mcount == ATTACH_BUFSIZ) {
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
rwe->methods.attachLists(mlists, mcount);
mcount = 0;
}
// ATTACH_BUFSIZ = 64; 允许容纳64，代表容量
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);
// mlists + ATTACH_BUFSIZ - mcount：进行内存平移，依次读取，再添加到rwe中
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->extAllocIfNeeded: 为rwe初始化，之前的流程没有值，从这里可以发现，原来本类中有分类需要加载时才会对rwe进行赋值。 - attachLists
void attachLists(List* const * addedLists, uint32_t addedCount) {
if (addedCount == 0) return;
if (hasArray()) {
// many lists -> many lists 加载非常多的list时
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时
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]));
}
}
当第二次情况发生时，会新建一个list，然后复制之前的oldList,把oldlist插入到新建list的后面，原因是为了性能，遍历oldlist再去添加newlist会比新建更耗费性能。
rwe->methods.attachLists、rwe->protocols.attachLists、rwe->properties.attachLists就是对rwe赋值操作，目的是为了把分类中的数据在本类中添加属性、方法、协议。
memmove将内容从oldcount位置挨个添加old数据，越后面添加的排最前面。
总结一下attachCategories流程
attachCategories流程
上一章中在类中实现了+load,就对懒加载类和非懒加载类进行了区别。现在定义两个分类LGPerson+LGA 、LGPerson+LGA。都在其中实现+load, 如下：
// LGPerson.h
@implementation LGPerson
+ (void)load{
}
- (void)kc_instanceMethod3{
NSLog(@"%s",__func__);
}
- (void)kc_instanceMethod1{
NSLog(@"%s",__func__);
}
- (void)kc_instanceMethod2{
NSLog(@"%s",__func__);
}
+ (void)kc_sayClassMethod{
NSLog(@"%s",__func__);
}
@end
// LGPerson+LGA.m 代码
@implementation LGPerson (LGA)
+ (void)load{
}
- (void)kc_instanceMethod1{
NSLog(@"%s",__func__);
}
- (void)cateA_2{
NSLog(@"%s",__func__);
}
- (void)cateA_1{
NSLog(@"%s",__func__);
}
- (void)cateA_3{
NSLog(@"%s",__func__);
}
@end
/* -------------------------------*/
// LGPerson+LGB.m 代码
@implementation LGPerson (LGB)
+ (void)load{
}
- (void)kc_instanceMethod1{
NSLog(@"%s",__func__);
}
- (void)cateB_2{
NSLog(@"%s",__func__);
}
- (void)cateB_1{
NSLog(@"%s",__func__);
}
- (void)cateB_3{
NSLog(@"%s",__func__);
}
@end
主类和分类是否实现load，就会有以下4种情况：
- 1.主类 实现load，分类 实现load：全部都从load_image加载到数据
遍历list
依次遍历时，就会打印出两个分类数据。就是上面分析attachCategories的load_iamges流程。具体调试下会是一下两个情况：
1）从map_images -> map_images_nolock -> _read_images -> readClass -> _getObjc2NonlazyClassList -> realizeClassWithoutSwift -> methodizeClass -> attachToClass,此时的mlists是一维数组，然后走到load_images部分。
2）从load_images --> loadAllCategories -> load_categories_nolock -> load_categories_nolock -> attachCategories -> attachLists，此时的mlists是二维数组
-
2.主类 实现load，分类未实现load：只要一个分类是非懒加载类，则该类的所有分类都会是非懒加载分类。在
read_images就加载数据 -
3.主类、分类均未实现load：则在第一次消息的时候再加载数据
read_class加载
当主类、分类均未实现load都未实现load时，read_class 的baseMethods有16个，（LGPerson的8个，包括了两属性的set，get方法，两个分类各4个），这说明在程序readClass时就能从Mach-O中读取data数据了。说明这是在编译时期就完成了方法的加载，在类第一次消息的流程中就加载了数据。 -
4.主类未实现load，分类实现load：迫使主类提前加载数据
在readClass的baseMethods读到了8个方法LGPerson的8个方法，分类的都没有。
image.png
四种情况总结分析
主类分类搭配加载
类加载总结：流程：在_read_images -> readClass过程中，realizeClassWithoutSwift之前获取到类的地址、name，进入realizeClassWithoutSwift之后，将data数据从ro传递到了rw,确定本类父类、元类的继承链关系过程，并在methodizeClass中对类的属性、方法、协议列表进行序列化，在经过attachCategories给rwe添加了分类属性、方法、协议，最后返回类的信息。由此完成了整个类的信息加载。
网友评论