+load 方法解析

分析load方法前先来做一个小测验：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// Animal 类
@interface Animal : NSObject
@end
@implementation Animal
+ (void)load {
    NSLog(@"Animal -- load");
}
@end

// Dog 类 (->superclass animal)
@interface Dog : Animal
@end
@implementation Dog
+ (void)load {
    NSLog(@"Dog -- load");
}
@end

// Cat 类 (->superclass animal)
@interface Cat : Animal
@end
@implementation Cat
+ (void)load {
    NSLog(@"Cat -- load");
}

// Animal 分类
@interface Animal (Eat)
@end
@implementation Animal (Eat)
+ (void)load {
    NSLog(@"Animal (Eat) -- load");
}
@end

// Dog 分类
@interface Dog (Eat)
@end
@implementation Dog (Eat)
+ (void)load {
    NSLog(@"Dog (Eat) -- load");
}
@end

// Cat 分类
@interface Cat (Eat)
@end
@implementation Cat (Eat)
+ (void)load {
    NSLog(@"Cat (Eat) -- load");
}
@end

我们来运行一下程序，发现没有调用这些类但是load方法都加载了，加载的结果如下：

1
2
3
4
5
6
2018-07-22 15:36:46.369503+0800 debug-objc[11354:638134] Animal -- load
2018-07-22 15:36:46.369954+0800 debug-objc[11354:638134] Cat -- load
2018-07-22 15:36:46.369965+0800 debug-objc[11354:638134] Dog -- load
2018-07-22 15:36:46.369981+0800 debug-objc[11354:638134] Cat (Eat) -- load
2018-07-22 15:36:46.369996+0800 debug-objc[11354:638134] Dog (Eat) -- load
2018-07-22 15:36:46.370009+0800 debug-objc[11354:638134] Animal (Eat) -- load

上一篇中我们讲到了category的原理，猜想这里的结果应该是只会调用分类的方法，可是为什么这里都调用了呢？还有看一下 PROJECT->TARGETS->Build Phases->Compole Source 的编译顺序，分类的编译顺序和调用顺序能对上，但是cat和dog都在animal的前面，为什么会是先调用的animal的load方法呢?

我们来分析一下load方法在runtime的源码，老规矩，先下载runtime源码，找到入口 _objc_init 的 load_images 方法，看一下上面的官方注解：Process +load in the given images which are being mapped in by dyld. ，可以发现load方法就是在这里面加载的，看源码：

1
2
3
4
5
6
7
8
9
10
load_images(const char *path __unused, const struct mach_header *mh) {
    /**
    * 准备 load methods
    */
    prepare_load_methods((const headerType *)mh);
    /**
    * 调用 load methods
    */
    call_load_methods();
}

这两个方法我们拿出来单独看一下：

a> prepare_load_methods：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void prepare_load_methods(const headerType *mhdr) {
    /**
    * 加载所有类
    */
    classref_t *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        /**
        * 调用 class 的 load 方法
        */    
        schedule_class_load(remapClass(classlist[i]));
    }
    /**
    * 加载所有分类
    */
    category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
    for (i = 0； i < count；i++) {
        category_t *cat = categorylist[i]；
        /**
        * 将category中的load方法加载到loadable的列表中
        */
        add_category_to_loadable_list(cat);
    }
}

可以看到，这里永远都是先加载类的load方法然后在加载分类的load方法，正好解释我们上面的小测试的结果，类的load方法会先与分类被调用。再把 schedule_class_load 方法拿出来看一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
static void schedule_class_load(Class cls) {
    /**
    * 判断如果已经加载过load方法则直接返回
    */
    if (cls->data()->flags & RW_LOADED) return;
    /**
    * Ensure superclass-first ordering
    * 这里是递归调用，优先加载 class的superclass的load方法，直到superclass为空
    */
    schedule_class_load(cls->superclass);
    /**
    * 将类的load方法加载到loadable的类表中
    */
    add_class_to_loadable_list(cls);
    /**
    * 设置此类的load方法标志位，表示已经加载过load方法
    */
    cls->setInfo(RW_LOADED); 
}

这里的调用非常巧妙，用递归调用优先加载superclass的load方法，这里就明白了原来在加载类的load方法时会优先加载superclass的load方法，到这里明白了上面的小测验为什么先回调 animal 的load方法了吗？
再看一下 add_class_to_loadable_list 方法：

1
2
3
4
5
6
7
8
9
10
11
12
void add_class_to_loadable_list(Class cls) {
    IMP method;
    method = cls->getLoadMethod();
    if (!method) return;  // Don't bother if cls has no +load method
    /**
    * 这里是将cls的method方法存放到 loadable_classes 数组中，
    * loadable_classes_used++ 可以看出这里是按编译时的顺序加载的
    */
    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    loadable_classes_used++;
}

注意：上面获取 method 的时候是获取的load method 的 IMP 。

prepare_load_methods 的分类加载的时候调用的就是 add_class_to_loadable_list 方法，所以分类的加载顺序就是按编译的顺序加载的。

到这里所有的类和分类的数据load完毕，并且加载顺序也已经确定。

b> call_load_methods：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void call_load_methods(void) {
    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);
}
/**
* call_class_loads 方法
*/
static void call_class_loads(void) {
    int i;
    /**
    * loadable_classes 就是我们上面 prepare 的加载完成的数据
    */
    struct loadable_class *classes = loadable_classes;
    /**
    * i ++  可以看到这里是按着顺序加载我们在 prepare 时准备的数据的
    */
    for (i = 0; i < used; i++) {
        Class cls = classes[i].cls;
        load_method_t load_method = (load_method_t)classes[i].method;
        if (!cls) continue; 
        /**
        * 调用 load 方法
        */	
        (*load_method)(cls, SEL_load);
    }
}

看上面的call_load_methods方法，先加载类在加载分类，在加载类的方法 call_class_loads 中是按着我们在 prepare_load_methods 方法中准备好的数据顺序执行的，所有prepare时加载的顺序就是load调用的顺序，可以查看分类的 call_category_loads 方法，跟加载类的方式是一样的。

到这里类和分类的所有load方法调用完毕。

关于load方法总结：

  1. 调用方式：根据函数的 IMP 直接调用。
  2. 调用时机：在runtime加载类、分类时调用（只调用一次）
  3. 调用顺序：”1、a> 先调用类的load(优先编译的优先调用)” “b> 调用子类的load方法之前会先调用父类的load方法” “1、a> 再调用分类的load方法(优先编译的分类优先调用)”

initialize 方法

我们知道 + initialize 方法会在类的第一次接收消息时调用。

将上面的小测试的所有load替换为initialize，然后分别调用如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
第一次调用：
[Animal class];

打印结果：
2018-07-22 16:52:15.039883+0800 debug-objc[12499:710327] Animal (Eat) -- initialize

第二次调用：
[Dog class];

打印结果：
2018-07-22 16:53:35.175441+0800 debug-objc[12534:711843] Animal (Eat) -- initialize
2018-07-22 16:53:35.175637+0800 debug-objc[12534:711843] Dog (Eat) -- initialize

第三次调用：
[Animal class];
[Dog class];

打印结果：
2018-07-22 16:54:04.664353+0800 debug-objc[12553:712521] Animal (Eat) -- initialize
2018-07-22 16:54:04.664578+0800 debug-objc[12553:712521] Dog (Eat) -- initialize

看到三次的打印结果可以推测 initialize 的方法的调用符合我们上一篇文章中讲解，最后加载的分类会优先类调用，并且类的方法不会再调用，第二次的调用可以推测在调用 initialize 时会先调用父类的 initialize 方法。

下面我们来把子类Dog和dog分类的 initialize 方式删除，再来打印看看结果：

1
2
3
4
5
6
调用：
[Dog class];

打印结果：
2018-07-22 17:08:29.497283+0800 debug-objc[12830:725499] Animal (Eat) -- initialize
2018-07-22 17:08:29.497558+0800 debug-objc[12830:725499] Animal (Eat) -- initialize

为什么 Animnal 的 initialize 会出现两次的调用呢？ initialize 不是只在第一次接收消息时调用吗？

initialize 是在发送消息时调用的，所以我们找到 objc_msgSend 方法，最终找到 class_getInstanceMethod 方法，根据调用：->class_getInstanceMethod -> lookUpImpOrNil ->lookUpImpOrForward 下面我们来分析一下runtime的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver) {
    /**
    * 如果cls还没有 Initialized 调用 _class_initialize
    */
    if (initialize  &&  !cls->isInitialized()) {
        _class_initialize (_class_getNonMetaClass(cls, inst));
    }
}

void _class_initialize(Class cls) {
    Class supercls;
    /**
    * 递归调用 cls父类的 callInitialize
    */
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        _class_initialize(supercls);
    }
    /**
    * 没有 initialize 时设置 reallyInitialize为true
    */
    if (!cls->isInitialized() && !cls->isInitializing()) {
        cls->setInitializing();
        reallyInitialize = YES;
    }
    if (reallyInitialize) {
        /**
        * 调用返送 SEL_initialize 消息方法
        */
        callInitialize(cls);
    }
}
/**
* 发送 SEL_initialize 消息
*/
void callInitialize(Class cls) {
    ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
}

分析源码可以看到，initialize 方法会先去查找父类，如果父类 initialize 没有调用过，会先向父类发送 SEL_initialize 消息，这里可以解释一下我们上面的小测试为什么 animal 的方法调用了两次，因为在 _class_initialize 方法中第一次由父类 animal 发送 SEL_initialize 消息，第二次由 dog 类发送 SEL_initialize 消息，而由于 dog 类没有 initialize 方法，所以会去调用父类 animal 的方法。

关于initialize方法总结：

  1. 调用方式：initialize是通过objc_msgSend调用。
  2. 调用时机：initialize时类在第一次接收到消息时调用，每个类只会initialize一次（父类的initialize方法可能会被多次调用）。
  3. 调用顺序：先初始化父类 再初始化子类（可能最终调用的是父类的initialize方法）