Category分类

作者: 天空像天空一样蓝 | 来源:发表于2020-12-28 22:01 被阅读0次

一、Demo展示

创建一个Person类，在创建一个Person+eat和Person+test两个分类。

@implementation Person
- (void)run {
    NSLog(@"run");
}
@end

@implementation Person (test)
- (void)test {
    NSLog(@"test");
}
@end

@implementation Person (eat)
- (void)eat {
    NSLog(@"eat");
}
@end

// 运行下面代码
Person *person = [[Person alloc] init];

[person run];
[person test];
[person eat];

当然上面代码，会打印出”run“/"test"/"eat"
我们知道当我们调用一个方法是，底层会调用objc_msgSend(person, @selector(xxx))这个方法，根据OC对象的本质得知，具体的实现是person 的isa 找到类对象里面的实例方法，如果是类方法，则会去元类对象找类方法。

思考如上 Demo里面的两个分类会生成两个新的类吗？
不会，一个isa只会有一个类对象，程序会通过runtime动态将实例方法合并到类对象里面的对象方法中，类方法都会合并到元类对象的类方法中

二、Category 内部实现

（一）demo1

使用clang编译器把OC代码转成C++，在终端上cd到当前项目的目录，输入xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+eat.m会自动生成 .cpp 文件

打开上面生成的Person+eat.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; // 属性属性列表
};

// 生成的 Category
static struct _category_t _OBJC_$_CATEGORY_Person_$_eat __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "Person", // 给了我们上面的name
    0, // &OBJC_CLASS_$_Person,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_eat, // 就是我们的实例方法 instance_methods
    0,
    0,
    0,
};

// _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_eat
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_Person_$_eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"eat", "v16@0:8", (void *)_I_Person_eat_eat}}
};

（二）demo2

在Person+test.h类中添加

@property (assign, nonatomic) int weight;
@property (assign, nonatomic) double height;

在Person+test.m类中添加

+ (void)test {
    NSLog(@"+test");
}
- (void)test1
{
    NSLog(@"eat1");
}

+ (void)test2
{
    
}

+ (void)test3
{
    
}

然后同样运行上面 clang 代码xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+test.m 生成.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;
};

// 
static struct _category_t _OBJC_$_CATEGORY_Person_$_test __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "Person",
    0, // &OBJC_CLASS_$_Person,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_test,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_test,
    0,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_test,
};

// 实例，_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_test
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[2];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    2,
    {{(struct objc_selector *)"test", "v16@0:8", (void *)_I_Person_test_test},
    {(struct objc_selector *)"test1", "v16@0:8", (void *)_I_Person_test_test1}}
};
// 类方法 _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_test
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[3];
} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    3,
    {{(struct objc_selector *)"test", "v16@0:8", (void *)_C_Person_test_test},
    {(struct objc_selector *)"test2", "v16@0:8", (void *)_C_Person_test_test2},
    {(struct objc_selector *)"test3", "v16@0:8", (void *)_C_Person_test_test3}}
};
// 属性列表 _OBJC_$_PROP_LIST_Person_$_test
static struct /*_prop_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count_of_properties;
    struct _prop_t prop_list[2];
} _OBJC_$_PROP_LIST_Person_$_test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    2,
    {{"weight","Ti,N"},
    {"height","Td,N"}}
};

也就是说，我们写的分类都会变成_category_t这种结构体，在合适的时机合并到类的对象方法或元类的类方法中。

（三）Category 的加载处理过程

通过 Runtime 加载某个类的所有Category 数据

2.把所有 Category 的方法、属性、协议数据、合并到一个大数组中

后面参与编译的 Category 数据，会在数组的前面

3.将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面

所以，我们在开发过程中，如果分类和类中的方法名字相同，会调用分类里面的。

三、load函数在Category 中的加载

（一）demo

// Person
@implementation Person
+ (void)run {
    NSLog(@"Person +run");
}
+ (void)load {
    NSLog(@"Person +load");
}
@end

// Person+test
@implementation Person (test)

+ (void)load {
    NSLog(@"Person (test) +load");
}
+ (void)test {
    NSLog(@"Person (test) +test");
}
@end

// Person+eat
@implementation Person (eat)
+ (void)load {
    NSLog(@"Person (eat) +load");
}
+ (void)eat {
    NSLog(@"Person (eat) +eat");
}
@end

// 调用 Person 的 +run方法
[Person run];

我们运行程序发现

2020-06-11 23:18:48.786224+0800 TestDemo[18522:2035515] Person +load
2020-06-11 23:18:48.786723+0800 TestDemo[18522:2035515] Person (test) +load
2020-06-11 23:18:48.786785+0800 TestDemo[18522:2035515] Person (eat) +load
2020-06-11 23:18:48.786926+0800 TestDemo[18522:2035515] Person (eat) +run

思考在上面的 Category 内部实现证明了，如果该分类的方法和该类的方法名一样，会优先调用分类的方法，类里面的方法不会被调用。为什么 load 里面的方法都会被调用呢，而不是像 run 方法一样？

load 方法的调用，是因为在程序加载过程中，如果发现是分类，会直接指向分类的类方法列表，而不是去调用的组合后的方法列表。所以会调用三次。
+load方法是根据方法地址直接调用，并不是经过objc_msgSend函数调用
test 方法的调用，我们知道方法的调用实际就是调用 objc_megSend([Person class] @selector(test)) 会通过isa找到当前对应的类对象或元类对象，调用里面的方法列表。因为重新组装的方法列表，Person+eat 分类在最前面，所以会调用 Person+eat 这个类中的 run 方法
+load方法会在 Runtime 加载类、分类时间调用，并且每个类、分类的 +load 在程序运行过程中只会调用一次。

（二）load 调用顺序

1、先调用类的 +load 方法

按照编译先后顺序调用（先编译，先调用）
调用子类的 +load 之前会先调用父类的 +load

2、在调用分类的 +load 方法

按照编译先后顺序调用（先编译，先调用）

扩展

打印出某个类中的所有方法

- (void)printMethodNamesOfClass:(Class )cls {
    
    unsigned int count;
    // 获取方法数组
    Method *methodList = class_copyMethodList(cls, &count);
    // 存储方法名
    NSMutableString *methodNames = [NSMutableString string];
    
    // 遍历所有的方法
    for (int i = 0; i < count; i++) {
        // 获得方法
        Method method = methodList[i];
        
        // 获得方法名
        NSString *methodName = NSStringFromSelector(method_getName(method));
        // 拼接方法名
        [methodNames appendString:methodName];
        [methodNames appendString:@", "];
    }
    // 释放
    free(methodList);
    
    // 打印方法名
    NSLog(@"%@, %@", cls, methodNames);
}

问题

1、给一个存在的类添加两个分类，会生成两个新的类吗？

不会，一个isa只会有一个类对象，程序会通过runtime动态将实例方法合并到类对象里面的对象方法中，类方法都会合并到元类对象的类方法中。

2、Category 的使用场合

给一个类添加新的方法，可以为系统的类扩展功能。
分解体积庞大的类文件，可以将一个类按照功能拆解成多个模块，方便代码管理。
创建对私有方法的前向引用：声明私有方法，把Framework的私有方法公开等，直接调用其他类的私有方法时编译器会报错，这时候可以创建一个该类的分类，在分类中声明这些私有方法（不必提供方法实现），接着导入这个分类的头文件就可以正常调用这些私有方法。
向对象添加非正式协议：创建一个 NSObject 或其子类的分类称为 “创建一个非正式协议”。

正式协议是通过 protocol 指定的一系列方法的声明，然后由遵守该协议的类自己去实现这些方法。而非正式协议是通过给 NSObject 或其子类添加一个分类来实现。非正式协议已经渐渐被正式协议取代，正式协议最大的优点就是可以使用泛型约束，而非正式协议不可以。）

3、Category中都可以添加哪些内容

实例方法、类方法、协议、属性（只生成setter和getter方法的声明，不会生成setter和getter方法的实现以及下划线成员变量）。
默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中，但可以通过关联对象来间接实现这种效果。

4、Category的优缺点、特点、注意点

Category	描述
优点	1、使用场合, 2、可以按照需求加载不同的类。
缺点	1、不能直接添加成员变量，可以通过关联对象实现这种效果， 2、分类方法会“覆盖”同名的宿主类方法，如果使用不当会造成问题
特点	1、运行时决议， 2、可以有声明、可以有实现。 3、可以为系统的类添加分类，运行时决议：Category 编译之后的底层结构是struct category_t，里面存储着分类的对象方法、类方法、属性、协议信息，这时候分类中的数据还没有合并到类中，而是在程序运行的时候通过Runtime机制将所有分类数据合并到类（类对象、元类对象）中去。（这是分类最大的特点，也是分类和扩展的最大区别，扩展是在编译的时候就将所有数据都合并到类中去了）
注意点	1、分类方法会“覆盖”同名的宿主类方法，如果使用不当会造成问题； 2、同名分类方法谁能生效取决于编译顺序，最后参与编译的分类中的同名方法会最终生效； 3、名字相同的分类会引起编译报错。

5、Category 的实现原理

分类的实现原理取决于运行时决议；
同名分类方法谁能生效取决于编译顺序，最后参与编译的分类中的同名方法会最终生效；
分类方法会“覆盖”同名的宿主类（原类）方法，这里说的“覆盖”并不是指原来的方法没了。消息传递过程中优先查找宿主类中靠前的元素，找到同名方法就进行调用，但实际上宿主类中原有同名方法的实现仍然是存在的。我们可以通过一些手段来调用到宿主类原有同名方法的实现，如可以通过Runtime的class_copyMethodList方法打印类的方法列表，找到宿主类方法的imp，进行调用（可以交换方法实现）。

6、Category的加载处理过程

在编译时，Category 中的数据还没有合并到类中，而是在程序运行的时候通过Runtime机制将所有分类数据合并到类（类对象、元类对象）中去。下面我们来看一下 Category 的加载处理过程。

① 通过Runtime加载某个类的所有 Category 数据；
② 把所有的分类数据（方法、属性、协议），合并到一个大数组中；（后面参与编译的 Category 数据，会在数组的前面）
③ 将合并后的分类数据（方法、属性、协议），插入到宿主类原来数据的前面。（所以会优先调用最后参与编译的分类中的同名方法）

Category分类

一、Demo展示

二、Category 内部实现

（一）demo1

（二）demo2

（三）Category 的加载处理过程

三、load函数在Category 中的加载

（一）demo

（二）load 调用顺序

扩展

问题

1、给一个存在的类添加两个分类，会生成两个新的类吗？

2、Category 的使用场合

3、Category中都可以添加哪些内容

4、Category的优缺点、特点、注意点

5、Category 的实现原理

6、Category的加载处理过程

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS 底层原理