iOS原理篇(三) Category/分类/类别

iOS KunPeng

于 2022-08-22 09:21:36 发布

阅读量980

点赞数

分类专栏： iOS开发原理篇文章标签： ios

本文链接：https://blog.csdn.net/zheshawanyier/article/details/126426505

版权

iOS开发原理篇专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、Category的实现原理

1、Category编译之后的底层结构是 struct _category_t ，里面存储着分类的对象方法、类方法、属性、协议信息

#import "Student+test.h"

@implementation Student (test)

- (void)study {
    
}

+ (void)attendClass {
    
}

@end

编译的C++代码为

Category编译之后的底层结构
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;
};
// 分类中定义的对象方法
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Student_$_test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"study", "v16@0:8", (void *)_I_Student_test_study}}
};

2、在程序运行的时候，通过runtime动态将category的属性、对象方法合并到类对象中，类属性、类方法合并到元类对象中。

源码 objc-runtime-new.mm
// 重新方法化
static void remethodizeClass(Class cls) 
{
    category_list *cats;
    bool isMeta;
    isMeta = cls->isMetaClass();
    // Re-methodizing: check for more categories
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        // cls：类对象、元类对象
        // cats：分类列表
        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}
// cls：类对象、元类对象
// cats：分类列表
static void attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    // 判断是类对象还是元类对象
    bool isMeta = cls->isMetaClass();
    // 方法数组
    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);
}

Category的加载处理过程：
通过runtime加载某个类的所有Category数据
把所有Category的方法、属性、协议数据，合并到一个大数组中
后面参与编译的Category数据，会在数组的前面
将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面
如果类、分类中有相同的方法，那么会先调用分类中的方法
多个分类的话会按后编译先调用

3、Class Extension/扩展简介

@interface Person ()
//私有属性
@property (nonatomic, strong)NSString *name;
//私有方法（如果不实现，编译时会报警,Method definition for 'XXX' not found）
- (void)study;
@end

扩展作用是

声明私有属性
声明私有方法
声明私有成员变量

扩展特点是

直接编译到类里面
只有形式，没有具体实现
不能为系统类添加扩展

4、Category和Class Extension的区别是什么？

Class Extension在编译的时候，它的数据就已经包含在类信息中
Category是在运行时，才会将数据合并到类信息中
分类可以为系统类添加分类；扩展不可以为系统类添加扩展；
分类原则上能增加属性，实例方法，类方法，协议；扩展一般给自己的类添加方法，实例变量

二、+load、+initialize、+alloc 、-init 加载过程及作用

1. - alloc

alloc方法是实例方法。alloc方法负责创建对象，这个过程包括：

分配足够的内存来保存对象
写入isa指针
初始化引用计数
重置对象中的所有实例变量

alloc方法会返回一个未被初始化的对象实例

2. - init

init方法是实例方法。负责初始化对象

对象在执行init方法后处于可用状态，即对象的实例变量可以被赋予合理有效值，这也是在自定义init方法时要先调用父类的init方法的原因。
子类初始化时，会先调用父类的初始化方法，然后调用自身的-init()方法，并且每次初始化都会调用
子类未实现-init()方法时，每初始化一个对象，只会调用一次父类的-init()方法

3. + load

load方法是类方法。其主要特点有：

调用在main()函数之前，并且不会主动调用，程序启动会把所有的文件加载（函数指针直接调用），文件如果重写了+load()方法，主类、子类、分类(category)都会加载调用+load()方法
调用顺序：主类 > 子类 > 分类
分类间的加载顺序取决于编译的顺序，先编译的先加载，后编译的后加载
因为+load()方法在main()函数之前调用，所以在这个方法中不宜做耗时或者阻塞操作，会影响启动速度
不要在+load()方法中做对象的初始化操作，因为+load()方法在main()函数之前自动调用，此时使用者根本就不能确定自己要使用的对象是否已经加载进来了
可以根据业务需求，在+load()方法中进行Method Swizzle操作，替换方法的默认实现

为什么类、分类里面的 +load 方法都会调用？

因为 +load 是通过函数指针直接调用

4. + initialize

initialize方法是类方法。

initialize方法在类或者它的子类收到第一条消息之前被调用（objc_msgSend）。这里所指的消息包括实例方法和类方法，也就是说+initialize()方法是以懒加载的方式调用的，若程序一直没有给某个类或它的子类发送消息，那么这个类的+initialize()方法是永远不会被调用的
父类的+initialize()方法会比子类先执行
(无需主动调用，复写即可)

例子：用NSString类创建了7个NSString对象

1> 调用了1次initialize方法；

2> 调用7次init方法

总结：

+load()和+initialize()都会在实例化对象之前调用，前者是在main()函数之前，后者是在main()函数之后
+load()和+initialize()方法都不会显式地调用父类的方法而是自动调用，即使子类没有+initialize()方法也会调用父类的方法，+load()方法不会调用父类方法；
+load()和+initialize()方法内部使用了锁，因此他们是线程安全的，实现时要尽可能简单，避免线程阻塞，不要再次使用锁
+load()方法常用来method swizzle，+initialize()常常用于初始化全局变量和静态变量