本文繼續(xù)研究類的加載--分類(類別)润梯。
分類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類型的方法列表:分類中實現(xiàn)的實例方法+類方法
- 一個protocol_list_t類型的協(xié)議列表:分類中實現(xiàn)的協(xié)議
- 一個prop_list_t類型的屬性列表:分類中定義的屬性,一般在分類中添加的屬性都是通- 過關聯(lián)對象來實現(xiàn)
- 需要注意的是是尔,分類中的屬性是沒有setter、getter方法
分類的數(shù)據(jù)加載
1)methodizeClass -> objc::unattachedCategories.attachToClass(加入兩次時會進入attachCategories)-> attachCategories
;
2)_read_images -> load_categories_nolock ->attachCategories
;
會進入分類操作蝶溶,會有這樣一個方法attachCategories
,它是將方法列表嗜历、屬性和協(xié)議從分類附加到類,這里就對分類的數(shù)據(jù)進行加載抖所。
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);
}
}
循環(huán)中會執(zhí)行兩次attachCategories
, 原因是會執(zhí)行對象方法梨州,類方法。
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初始化帮掉,之前的流程沒有值,從這里可以發(fā)現(xiàn)窒典,原來本類中有分類需要加載時才會對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,第二次加載有很多l(xiāng)ist時
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]));
}
}
當?shù)诙吻闆r發(fā)生時瀑志,會新建一個list涩搓,然后復制之前的oldList
,把oldlist
插入到新建list
的后面,原因是為了性能劈猪,遍歷oldlist
再去添加newlist
會比新建更耗費性能昧甘。
rwe->methods.attachLists
、rwe->protocols.attachLists
战得、rwe->properties.attachLists
就是對rwe
賦值操作充边,目的是為了把分類中的數(shù)據(jù)在本類中添加屬性、方法常侦、協(xié)議浇冰。
memmove
將內容從oldcount位置挨個添加old數(shù)據(jù),越后面添加的排最前面刮吧。
總結一下attachCategories
流程
上一章中在類中實現(xiàn)了+load
,就對懶加載類和非懶加載類進行了區(qū)別『ィ現(xiàn)在定義兩個分類LGPerson+LGA
、LGPerson+LGA
杀捻。都在其中實現(xiàn)+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
主類和分類是否實現(xiàn)load井厌,就會有以下4種情況:
- 1.主類 實現(xiàn)load,分類 實現(xiàn)load:全部都從load_image加載到數(shù)據(jù)
依次遍歷時墓拜,就會打印出兩個分類數(shù)據(jù)氯夷。就是上面分析attachCategories
的load_iamges
流程雇毫。具體調試下會是一下兩個情況:
1)從map_images -> map_images_nolock -> _read_images -> readClass -> _getObjc2NonlazyClassList -> realizeClassWithoutSwift -> methodizeClass -> attachToClass
,此時的mlists是一維數(shù)組,然后走到load_images部分捞蛋。
2)從load_images --> loadAllCategories -> load_categories_nolock -> load_categories_nolock -> attachCategories -> attachLists
,此時的mlists是二維數(shù)組
- 2.主類 實現(xiàn)load,分類未實現(xiàn)load:在
read_images
流程加載數(shù)據(jù),在編譯時期就完成了data的讀取
-
3.主類呕诉、分類均未實現(xiàn)load:則在第一次消息的時候再加載數(shù)據(jù)
當主類、分類均未實現(xiàn)load都未實現(xiàn)load
時亦渗,read_class 的baseMethods有16個,(LGPerson的8個兑牡,包括了兩屬性的set央碟,get方法,兩個分類各4個),這說明在程序readClass時就能從Mach-O中讀取data
數(shù)據(jù)了亿虽。說明這是在編譯時期就完成了方法的加載菱涤,在類第一次消息的流程中就加載了數(shù)據(jù)。 -
4.主類未實現(xiàn)load洛勉,分類實現(xiàn)load:迫使主類提前加載數(shù)據(jù)
在readClass
的baseMethods
讀到了8個方法LGPerson的8個方法粘秆,分類的都沒有。
四種情況總結分析
類加載總結:流程:在_read_images -> readClass
過程中收毫,realizeClassWithoutSwift
之前獲取到類的地址
攻走、name
,進入realizeClassWithoutSwift
之后此再,將data數(shù)據(jù)從ro
傳遞到了rw
,確定本類父類昔搂、元類的繼承鏈關系過程,并在methodizeClass
中對類的屬性输拇、方法摘符、協(xié)議列表進行序列化,在經(jīng)過attachCategories
給rwe
添加了分類屬性策吠、方法逛裤、協(xié)議,最后返回類的信息猴抹。由此完成了整個類的信息加載带族。