引言

Category（类别）是Objective-C语言的重要特性之一，允许在不修改原有类的情况下为其添加方法。理解Category的底层实现原理，对于掌握OC动态特性、优化代码结构至关重要。本文将从以下维度展开深入分析：

一、Category的基础认知

1.1 基本用法

1
2
3
4
5
6
7
8
9
10
11
// NSString+Additions.h
@interface NSString (Additions)
- (NSString *)reverseString;
@end

// NSString+Additions.m
@implementation NSString (Additions)
- (NSString *)reverseString {
    // 实现字符串反转
}
@end

1.2 核心特性

  • 动态扩展：无需修改原类即可添加方法
  • 模块化设计：将类的功能拆分成多个文件
  • 方法覆盖：Category的方法会覆盖原类方法
  • 无实例变量：不能直接添加实例变量

二、Category的底层结构

2.1 objc_category结构体

1
2
3
4
5
6
7
8
9
// objc-runtime-new.h中的定义
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; // 实例属性
};

2.2 编译产物分析

通过clang -rewrite-objc生成C++代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 原始OC代码
@interface NSString (Additions)
@property (nonatomic, copy) NSString *desc;
- (void)print;
@end

// 转换后的C++代码
static 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;
} _OBJC_$_CATEGORY_NSString_$_Additions __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    "NSString",
    0, // &OBJC_CLASS_$_NSString,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_NSString_$_Additions,
    0,
    0,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_NSString_$_Additions
};

三、Category的加载与合并过程

3.1 加载流程

  1. 编译阶段生成category_t结构体
  2. 链接阶段合并到Mach-O文件的__objc_const段
  3. 运行时通过_read_images函数处理所有category

3.2 方法合并机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// objc-runtime-new.mm中的核心逻辑
void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses) {
    // 处理所有category
    for (EACH_HEADER) {
        category_t **catlist = _getObjc2CategoryList(hi, &count);
        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls);
            
            // 合并方法、协议、属性
            if (cat->instanceMethods) {
                addUnattachedCategoryForClass(cls, cat);
            }
        }
    }
    // 最终合并到类结构中
    attachCategories(..., cats_list, cats_count);
}

3.3 方法覆盖优先级

  1. Category方法（后编译的Category优先）
  2. 当前类方法
  3. 父类方法

四、Category的动态行为

4.1 方法决议

1
2
3
4
5
6
7
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(dynamicMethod)) {
        class_addMethod(self, sel, (IMP)dynamicMethodIMP, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}

4.2 消息转发

1
2
3
4
5
6
- (id)forwardingTargetForSelector:(SEL)aSelector {
    if ([self respondsToSelector:aSelector]) {
        return self;
    }
    return [super forwardingTargetForSelector:aSelector];
}

五、Category的内存管理

5.1 关联对象（Associated Object）

1
2
3
4
5
// 添加关联对象
objc_setAssociatedObject(self, &AssociatedKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

// 获取关联对象
id value = objc_getAssociatedObject(self, &AssociatedKey);

5.2 内存泄漏场景

1
2
// 错误用法：导致循环引用
objc_setAssociatedObject(self, &kAssociatedKey, self, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

六、Category与其他技术的对比

6.1 与继承的对比

特性 Category 继承
代码修改 无需修改原类 需要创建子类
方法覆盖 可覆盖原类方法 需重写父类方法
实例变量 不可添加 可添加新实例变量
编译依赖 动态加载 静态依赖

6.2 与Extension的对比

特性 Category Extension
声明位置 .h文件 .m文件
方法实现 必须在.m文件 可隐式实现
访问控制 公开方法 通常为私有方法
作用域 全局可见 仅限当前类

七、Category的应用场景

7.1 模块化开发

将类的不同功能拆分到多个Category：

1
2
3
4
5
6
7
@interface UIViewController (Network)
- (void)fetchData;
@end

@interface UIViewController (UI)
- (void)updateUI;
@end

7.2 修复系统类缺陷

为NSString添加安全处理方法：

1
2
3
@interface NSString (Safety)
- (NSString *)safeStringByTrimmingWhitespace;
@end

7.3 实现AOP

通过Category进行方法交换：

1
2
3
4
5
6
7
8
9
10
11
12
@implementation UIViewController (AOP)
+ (void)load {
    Method originalMethod = class_getInstanceMethod(self, @selector(viewDidLoad));
    Method swizzledMethod = class_getInstanceMethod(self, @selector(aop_viewDidLoad));
    method_exchangeImplementations(originalMethod, swizzledMethod);
}

- (void)aop_viewDidLoad {
    [self aop_viewDidLoad];
    NSLog(@"View did load");
}
@end

八、Category的常见问题

8.1 方法覆盖导致的问题

1
2
3
4
5
6
7
8
// 两个Category声明同名方法
@interface NSString (A)
- (void)log;
@end

@interface NSString (B)
- (void)log;
@end

8.2 内存泄漏

1
2
// 未正确释放关联对象
objc_setAssociatedObject(self, &key, [NSObject new], OBJC_ASSOCIATION_RETAIN_NONATOMIC);

8.3 二进制兼容性问题

1
2
3
// 跨版本添加方法导致崩溃
NSString *str = @"test";
[str newMethod]; // 旧版本不存在该方法

九、总结

Category的本质是：

  1. 运行时动态扩展机制
  2. 方法集合的动态合并
  3. OC语言动态特性的重要体现

掌握Category底层原理能帮助开发者：

  • 合理设计代码结构
  • 避免方法冲突
  • 正确使用关联对象
  • 实现高级编程技巧（如AOP）

建议通过以下方式深入学习：

  1. 分析objc源码中的_read_images函数
  2. 使用class-dump查看Category结构
  3. 通过LLDB调试方法合并过程
  4. 研究关联对象的内存管理策略

附录：关键技术点

  1. objc_category结构体：存储Category元数据
  2. 方法合并流程：_read_images -> attachCategories
  3. 关联对象API：objc_setAssociatedObject/objc_getAssociatedObject
  4. 编译命令：clang -rewrite-objc -fobjc-arc YourFile.m
  5. 调试工具：class-dump, LLDB, Dyld

通过对Category底层原理的深入探索，我们能更高效地利用这一强大特性，写出结构清晰、扩展性强的iOS代码。

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。