一，应用程序加载回顾
通过前面的学习我们对iOS应用程序的加载有了一个大致的认识，
- 1 系统调用
exec()会让我们的应用程序映射到信的地址空间 - 2 然后通过
dyld进行加载、链接、初始化主程序和应用程序所依赖的各种动态库 - 3 最后在
initializeMainExecutable方法中进过一系列的初始化调用notifySingle函数，该函数会执行一个load_images的回调 - 4 然后在
doModInitFunctions函数内部调用__attribute__((contrustor))的c++ 函数 - 5 然后
dyld返回主程序的入口函数，开始进入主程序的main函数。
在main函数执行过程中，其实dyld还会在流程中初始化libSystem,而libSystem又会去初始化libDispatch,在libDispatch初始化方法里面又会调用os_object_int,在os_object_int内部就会调用objc_init,从而才会进入我们相隔的类的加载过程。这就是整个应用程序加载的大致过程。
二，类的加载
通过上一章节应用程序加载回顾的流程可知，我们知道相关的加载，编译在main函数之前，所以在此我们进入libObjc开源的代码中全局搜索read_image字段。、进入到相关的定义如下 ：摘取片段展示
void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
{
header_info *hi;
uint32_t hIndex;
size_t count;
size_t i;
Class *resolvedFutureClasses = nil;
size_t resolvedFutureClassCount = 0;
static bool doneOnce;
bool launchTime = NO;
TimeLogger ts(PrintImageTimes);
。。。。。。。。。。。
既然本文重点是研究类的加载，那么我们就在read_images中找到关于类的信息，从而重点的进行研究和学习，进行一个深刻的了解。从而达到我们想要的目的，我们会发现在此方法中存在一个关于非懒加载 Realize non-lazy classes (for +load methods and static instances)代码如下
for (EACH_HEADER) {
classref_t const *classlist =
_getObjc2NonlazyClassList(hi, &count);
for (i = 0; i < count; i++) {
Class cls = remapClass(classlist[i]);
const char *mangledName = cls->mangledName();
if (!cls) continue;
addClassTableEntry(cls);
if (cls->isSwiftStable()) {
if (cls->swiftMetadataInitializer()) {
_objc_fatal("Swift class %s with a metadata initializer "
"is not allowed to be non-lazy",
cls->nameForLogging());
}
} // alloc init - 类存在 完备 实例
realizeClassWithoutSwift(cls, nil);
}
}
从此段代码就知道只是针对非懒加载实现的类才走到这个方法中，那么懒加载类又如何进行加载的，那么就让我们分别对这两种情况进行明确和详细的学习和探索。
2.1、非懒加载类
在此方法中我们用断点调试相关的程序，我们知道系统类的实现对我们来说是不可见的，所所以我们研究系统类的实现以及加载难度太大以及成本太高并且是得不偿失。所以我们研究自己定义的类最好不过，我们在自己实现的类中实现+load方法，
+ (void)load{
NSLog(@"%s",__func__);
}
再次通过mangledName,断点筛选出我们所定义的类的实现，定位到当前类
通过控制台打印出相关结果：
(lldb) p/x LGPersonName
(const char *) $0 = 0x000000010032ad3e "LGPerson"
此时我们知道，此处的LGPersonName 还是一个带地址的名字，并不是一个类，所以我们继续探索究竟是什么时候我们所定义的类加载到内存中，从而进行相关的方法调用？
顺着代码查找到相关的realizeClassWithoutSwift定义下
static Class realizeClassWithoutSwift(Class cls, Class previously)
在中途通过mangledName筛选到我们当前的类
if (!cls) return nil;
if (cls->isRealized()) return cls;
ASSERT(cls == remapClass(cls));
auto ro = (const class_ro_t *)cls->data();
auto isMeta = ro->flags & RO_META;
if (ro->flags & RO_FUTURE) {
// This was a future class. rw data is already allocated.
rw = cls->data();
ro = cls->data()->ro();
ASSERT(!isMeta);
cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
} else {
// Normal class. Allocate writeable class data.
rw = objc::zalloc();
rw->set_ro(ro);
rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
cls->setData(rw);
}
以及
supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);
以上代码主要的作用就是
- 1 通过
macho文件里的data返回一个类的class_ro_t从而赋值到相应的ro中 即clean-memory - 2 判断是否是元类，通过第一步的
ro数据，读取到rw; - 3 如果非元类，寄进行相应的数据从
ro到rw中，通过rw->set_ro(ro);操作完成 - 4 完成相关类的继承链，从而为以后的方法查找以及后续的初始化埋下伏笔
虽然此时我们的类还只是带地址的一个名字，并没有实现，但是我们相关的ro 和rw 是有值的，验证如下；
通过以上的方法我们知道实现了相关的类的信息，并且成功的将数据映射到内存，包括ro 和rw的赋值都在此时实现，所以在此去实现相关的元类meta信息,从而在此进入到最后的
methodizeClass(cls, previously); 中；
跟着断点调试进入到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();
const char *LGPersonName = "LGPerson";
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);
}
从而进行相关的类的方法、协议、的实现；
2.2、懒加载类
在+load方法没有实现的时候，我们会发现程序的执行和之前的流程不太一样，程序会先进入到底层的objc_msgSent,因为我们在创建
LGPerson *person = [LGPerson alloc];
程序的底层会进行一次消息转发，从而进入到消息的查找从而进入到lookUpImpOrForward
然后进入程序实现的判断
if (slowpath(!cls->isRealized())) {
cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
// runtimeLock may have been dropped but is now locked again
}
进入到realizeClassMaybeSwiftAndLeaveLocked 方法实现如下：
realizeClassMaybeSwiftMaybeRelock(Class cls, mutex_t& lock, bool leaveLocked)
{
lock.assertLocked();
const char *mangledName = cls->mangledName();
const char *LGPersonName = "LGPerson";
if (strcmp(mangledName, LGPersonName) == 0) {
auto kc_ro = (const class_ro_t *)cls->data();
printf("%s: 这个是我要研究的 %s \n",__func__,LGPersonName);
}
if (!cls->isSwiftStable_ButAllowLegacyForNow()) {
// Non-Swift class. Realize it now with the lock still held.
// fixme wrong in the future for objc subclasses of swift classes
realizeClassWithoutSwift(cls, nil);
if (!leaveLocked) lock.unlock();
} else {
// Swift class. We need to drop locks and call the Swift
// runtime to initialize it.
lock.unlock();
cls = realizeSwiftClass(cls);
ASSERT(cls->isRealized()); // callback must have provoked realization
if (leaveLocked) lock.lock();
}
return cls;
}
从而和非懒加载类一样 执行realizeClassWithoutSwift 和 methodizeClass的流程，从而实现了该类的信息。
总结：通过以上两个类的对比和学习的过程，对iOS开发过程中的类的懒加载 和非懒加载有了一个深刻的认知，
三，分类的加载
3.1、分类的概念和结构
在main.mm文件中我们通过手写分类实现相关的定义
@interface LGPerson (LG)
@property (nonatomic, copy) NSString *cate_name;
@property (nonatomic, assign) int cate_age;
- (void)cate_instanceMethod1;
- (void)cate_instanceMethod3;
- (void)cate_instanceMethod2;
+ (void)cate_sayClassMethod;
@end
@implementation LGPerson (LG)
- (void)cate_instanceMethod1{
NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod3{
NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod2{
NSLog(@"%s",__func__);
}
+ (void)cate_sayClassMethod{
NSLog(@"%s",__func__);
}
@end
通过clang命令生成相关的cpp文件
进入到这个文件中查询到分类的结构定义
// 分类 : 方法 - attachtoclass
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;
};
- 1
name代表分类的名字 - 2
cls代表分类的类 - 3
instance_methods实例方法，也即是对象方法 - 4
class_methods类方法 - 5
protocols协议列表 - 6
properties属性列表
通过以上我们清楚的知道了一个分类的内部结构，那么分类是如何同类的加载载入到内存的，接下来就进入源码分析流程；
3.2、分类何时加载到应用程序
随即我们进入到类的加载执行的methodizeClass(cls, previously);
随着代码的注释我们知道，这就是程序加载分类的机制和时机
// Attach categories - 分类
methodizeClass(cls, previously)
通过定位到我们的类然后进行打印相关的列表
通过list 如果无序的时候我们可以进行相关的排序操作
method_list_t *list = ro->baseMethods();
if (list) {
prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
if (rwe) rwe->methods.attachLists(&list, 1);
}
没有进行prepareMethodLists的结果是
(lldb) p list->get(0)
(method_t) $5 = {
name = "cate_instanceMethod1"
types = 0x0000000100001dfb "v16@0:8"
imp = 0x0000000100001a00 (KCObjc`-[LGPerson(LG) cate_instanceMethod1] at main.m:29)
}
p list->get(1)
(method_t) $6 = {
name = "cate_instanceMethod3"
types = 0x0000000100001dfb "v16@0:8"
imp = 0x0000000100001a30 (KCObjc`-[LGPerson(LG) cate_instanceMethod3] at main.m:33)
}
p list->get(2)
(method_t) $7 = {
name = "cate_instanceMethod2"
types = 0x0000000100001dfb "v16@0:8"
imp = 0x0000000100001a60 (KCObjc`-[LGPerson(LG) cate_instanceMethod2] at main.m:37)
}
而进行prepareMethodLists的结果是
p list->get(0)
(method_t) $8 = {name = "cate_instanceMethod1"
types = 0x0000000100001dfb "v16@0:8"
imp = 0x0000000100001a00 (KCObjc`-[LGPerson(LG) cate_instanceMethod1] at main.m:29)
}
p list->get(1)
(method_t) $10 = {
name = "cate_instanceMethod2"
types = 0x0000000100001dfb "v16@0:8"
imp = 0x0000000100001a60 (KCObjc`-[LGPerson(LG) cate_instanceMethod2] at main.m:37)
}
p list->get(2)
(method_t) $9 = {
name = "cate_instanceMethod3"
types = 0x0000000100001dfb "v16@0:8"
imp = 0x0000000100001a30 (KCObjc`-[LGPerson(LG) cate_instanceMethod3] at main.m:33)
}
从而去加载相关的分类的属性，方法，协议等
if (rwe && proplist) {
rwe->properties.attachLists(&proplist, 1);
}
protocol_list_t *protolist = ro->baseProtocols;
if (rwe && protolist) {
rwe->protocols.attachLists(&protolist, 1);
}
if (cls->isRootMetaclass()) {
// root metaclass
addMethod(cls, @selector(initialize), (IMP)&objc_noop_imp, "", NO);
}
通过以上想分类的实现，从而对内存中的rwe进行调用和开辟
for (uint32_t i = 0; i < cats_count; i++) {
auto& entry = cats_list[i];
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if (mlist) {
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;
}
}
通过以上的attachList方法，从而循环对分类的属性，协议,方法等操作具体实现如下
- 1 判断要添加的数量是否为0，如果是0 ，则直接返回
- 2 然后对
ATTACH_BUFSIZ - ++mcount所有的方法进行倒序插入 - 3判断 attachLists的list_array_tt 二维数组有多个一位数组；
如果是，说明多对多的关系
通过realloc对容器进行重新分配，大小是原来的大小加上新增的大小
通过memmove把原来的数据移动到尾部
最后把新的数据拷贝到容器的起始位置，
- 4 如果调用的attachLists的list_array_tt二维数组为空并且新增空间大小数目是1，则直接取attachList的第一个list
- 5 如果当前调用的attachLists的list_array_tt二维数组只有一个一位数组，
如果是，说明是一对多的关系
通过realloc对容器进行重新分配，大小是原来的大小加上新增的大小
因为原来只有一个一位数组，所以直接赋值到新array的最后一个位置
最后把新的数据拷贝到容器的起始位置
四，总结
这就是整个类、分类的加载大致过程，虽然很多地方理解还不是很到位，但是我相信只要坚持下去，总会有收获的。