Category基本使用

分类和类一样都是在接口内声明，在类文件内实现。但是分类不可声明实例变量，只可声明属性和方法，并且分类的实现部分不能包含@synthesize。分类的接口中含有属性声明时，实现部分就要手动定义属性的访问方法。这样是为了防止随意访问同一个类的不同文件中定义的实例变量。

方法可以是实例方法也可为类方法。

语法：Category声明

注意：类名必须是已存在的类，不可定义未存在的类。

@interface 类名(分类名)

属性的声明

方法的声明

@end

语法：Category实现

@implementation 类名 (分类名)

属性的setter定义

属性的getter定义

方法的定义

@end

分类接口部分遵循原则：

1、分类的接口部分必须引用所属类的接口文件；

2、分类实现部分必须引用对应的接口文件；

3、使用分类中的方法时候，必须引用此方法所在的头文件；

例：MyModel.h

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface MyModel : NSObject
@property (nonatomic,copy)NSString *name;
@property (nonatomic,assign)NSInteger age;
@property (nonatomic,assign)CGFloat height;
- (void)work;
@end

NS_ASSUME_NONNULL_END  

MyModel.m

#import "MyModel.h"

@implementation MyModel

- (void)work{
    NSLog(@"-------MyModel work---------");
}

@end

MyModel+Test.h

#import "MyModel.h"

NS_ASSUME_NONNULL_BEGIN

@interface MyModel (Test)
- (void)walk;
@end

NS_ASSUME_NONNULL_END

MyModel+Test.m

#import "MyModel+Test.h"
@implementation MyModel (Test)
  
- (void)walk{
    NSLog(@"----Test walk--------");
}
@end

给已存在类追加分类

追加新方法

无论是自定义还是系统的类，皆可为已存在类追加新方法。

虽然分类不可用追加实例变量，但是新追加的方法可以访问类中属性和方法。借此，我们可以为已有类增加新功能。

当我们在使用继承来为已有类增加新功能感觉麻烦时候，可以通过分类来为正在使用的类增加新功能。

例：通过为系统的NSDate类来增加新方法，获取当前时间并返回一个指定格式的时间字符串。

NSDate+Format.h

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface NSDate (Format)
+(NSString *)getCurrentDayTimeDetail;
@end

NS_ASSUME_NONNULL_END

NSDate+Format.m

#import "NSDate+Format.h"

@implementation NSDate (Format)

+(NSString *)getCurrentDayTimeDetail {
    NSDate *now = [self date];
    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    [formatter setDateFormat:@"yyyy年MM月dd日 HH:mm:ss"];
    [formatter setLocale:[[NSLocale alloc]initWithLocaleIdentifier:@"zh_CN"]];
    NSTimeZone *timeZone = [[NSTimeZone alloc]initWithName:@"Asia/Shanghai"];
    [formatter setTimeZone:timeZone];
    NSString *current = [formatter stringFromDate:now];
    return current;
}

@end

覆盖现有方法

新定义分类中的方法如果和原有方法重名，新定义的方法会覆盖老的方法。通过此种方式，可以不使用继承来实现方法覆盖。但是如果不留意覆盖了原有方法，也是会引起不可预测的问题，尤其是覆盖了比较重要的方法，极有可能发生严重的问题。如果多个重复名称方法，就无法知道到底执行了哪个方法。覆盖并不提示警告，因此在使用过程中，一定要注意避免方法被覆盖掉。

关联引用

通过分类，我们可以为一个类追加新的方法，但是不能追加实例变量。但是，借助Objective-C 的运行时功能，可以为已经存在的实例对象增加实例变量。通过这种方式和分类合起来使用，不创建子类，也可以对类进行动态的扩展。关联引用在运行时中不仅可根据需要为对象添加关联，也可以对已添加关联进行移除。

添加关联

 void objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key, id _Nullable value, objc_AssociationPolicy policy);

object：所属类，即要增加关联的对象；

key：关键字，用来区分关联引用，必须使用确定的、不再改变的地址作为键值；

value ：引用对象；

policy：用来指定关联引用的存储策略。

此方法通过设置value 为nil，可以删除key 的关联。

检索关联

 id _Nullable objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key);

通过关键字key来检索关联对象object，如果没有关联到任何对象，则返回值为nil。

移除关联

Objective-C 运行时移除关联的方法如下，这个方法会移除object对象的所有关联，谨慎使用。

已存在代码可能已经使用了关联，因此不建议使用此方法，可使用objc_setAssociatedObject，设置参数为nil，以此来分别移除关联。

void objc_removeAssociatedObjects(id _Nonnull object);

关联策略

OBJC_ASSOCIATION_ASSIGN：

内存管理时，不给关联对象发送retain消息，仅仅通过赋值进行关联。弱引用。

OBJC_ASSOCIATION_RETAIN_NONATOMIC：

内存管理时，会给关联对象发送retain消息并持有，如果同样的key已经关联了其他对象，则会给其他对象发送release消息。释放关联对象的所有者时，会给所有的关联对象发送release消息。强引用。

OBJC_ASSOCIATION_COPY_NONATOMIC：

在进行对象关联引用时候会复制一份原对象，并用新复制的对象进行关联操作。

OBJC_ASSOCIATION_RETAIN：

在对象持有方面和 OBJC_ASSOCIATION_RETAIN_NONATOMIC一样，唯一区别是OBJC_ASSOCIATION_RETAIN是多线程安全的，支持排他性的关联操作。objc_getAssociatedObject的操作和OBJC_ASSOCIATION_RETAIN一样。

OBJC_ASSOCIATION_COPY：

在对象持有方面和 OBJC_ASSOCIATION_COPY_NONATOMIC一样，唯一区别是OBJC_ASSOCIATION_COPY是多线程安全的，支持排他性的关联操作。

例：MyModel+Test.h

#import "MyModel.h"

NS_ASSUME_NONNULL_BEGIN
@protocol MyModelProtocol <NSObject>

- (void)myModelProtocolAction;

@end
  
@interface MyModel (Test)<MyModelProtocol>
  //不会自动生成实例变量，在这里添加属性，其实是添加的setter和getter方法。
@property (nonatomic,copy)NSString *email;
- (void)walk;
@end

NS_ASSUME_NONNULL_END

MyModel+Test.m

#import "MyModel+Test.h"
#import <objc/runtime.h>
@implementation MyModel (Test)

- (void)setEmail:(NSString *)email{
    objc_setAssociatedObject(self, @"email",email, OBJC_ASSOCIATION_COPY);//添加关联
//    objc_setAssociatedObject(self, @"email",nil, OBJC_ASSOCIATION_COPY);//移除关联
}

- (NSString *)email{
    //检索关联
    return  objc_getAssociatedObject(self, @"email");
}

+(void)load{
    NSLog(@"----Test load-------");
}

//+ (void)initialize{
//    NSLog(@"----Test initialize-------");
//}
//

- (void)walk{
    NSLog(@"----Test walk-------%@",self.email);
}

- (void)myModelProtocolAction{
    NSLog(@"----myModelProtocolAction-------");
}


@end

底层结构

通过终端命令：clang -rewrite-objc MyModel+Test.m 生成.cpp格式的文件。

打开重写后生成的.cpp 文件，查找_category_t，在文件末尾找到如下结构体。

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[4];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_MyModel_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    4,
    {{(struct objc_selector *)"setEmail:", "v24@0:8@16", (void *)_I_MyModel_Test_setEmail_},
    {(struct objc_selector *)"email", "@16@0:8", (void *)_I_MyModel_Test_email},
    {(struct objc_selector *)"walk", "v16@0:8", (void *)_I_MyModel_Test_walk},
    {(struct objc_selector *)"myModelProtocolAction", "v16@0:8", (void *)_I_MyModel_Test_myModelProtocolAction}}
};

类方法结构体，存储着类的方法

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_CLASS_METHODS_MyModel_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"load", "v16@0:8", (void *)_C_MyModel_Test_load}}
};

协议列表结构体和属性列表结构体，存储着协议和属性，值得注意的是，在编译后的文件中，并没有找到像类文件编译后那样的_ivar_list_t成员变量结构体和setter和getter方法，这也证明了分类不可以添加成员变量。而属性的setter和getter 方法，编译后的是走的我们手动添加的相关的关联引用的方法。

//协议
static struct /*_protocol_list_t*/ {
    long protocol_count;  // Note, this is 32/64 bit
    struct _protocol_t *super_protocols[1];
} _OBJC_CATEGORY_PROTOCOLS_$_MyModel_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    1,
    &_OBJC_PROTOCOL_MyModelProtocol
};

//属性
static struct /*_prop_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count_of_properties;
    struct _prop_t prop_list[1];
} _OBJC_$_PROP_LIST_MyModel_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"email","T@\"NSString\",C,N"}}
};

//添加关联引用
static void _I_MyModel_Test_setEmail_(MyModel * self, SEL _cmd, NSString * _Nonnull email) {
    objc_setAssociatedObject(self, (NSString *)&__NSConstantStringImpl__var_folders_lc_jzfd703x2r1czsk56zjspmw40000gn_T_MyModel_Test_00509d_mi_0,email, OBJC_ASSOCIATION_COPY);

}

//检索关联引用
static NSString * _Nonnull _I_MyModel_Test_email(MyModel * self, SEL _cmd) {

    return objc_getAssociatedObject(self, (NSString *)&__NSConstantStringImpl__var_folders_lc_jzfd703x2r1czsk56zjspmw40000gn_T_MyModel_Test_00509d_mi_1);
}

下面是MyModel的分类的结构体赋值，依次分析各个变量对应的赋值。

第1个是类名，将MyModel 赋值给了name；

第2个cls，将0赋值给cls；

第3个是对象列表，将_OBJC$CATEGORY_INSTANCE_METHODS_MyModel$_Test变量赋值给对象方法列表_instance_methods；

第4个是类方法列表，将*_OBJC$CATEGORY_CLASS_METHODS_MyModel$_Test变量赋值给类方法列表class_methods；

第5个协议列表，_OBJC_CATEGORY_PROTOCOLS$MyModel$_Test变量赋值给了protocols；

最后是属性列表赋值，将_OBJC_$_PROP_LIST_MyModel_$_Test 变量赋值给了properties；

static struct _category_t _OBJC_$_CATEGORY_MyModel_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "MyModel",
    0, // &OBJC_CLASS_$_MyModel,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_MyModel_$_Test,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_MyModel_$_Test,
    (const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_MyModel_$_Test,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_MyModel_$_Test,
};

从上面编译后的代码分析，我们可以看出，编译器生成了一个_category_t结构体，并给结构内定义的变量进行了赋值。_category_t结构体里面存储着分类的对象方法、类方法、协议、和属性,但是没有成员变量。这就是_category_t重写后的底层结构。

源码分析

Category运行时加载过程

_objc_init->map_images->map_images_nolock->_read_images->realizeClassWithoutSwift->methodizeClass->attachToClass

在上面的执行过程中，map_images方法只执行一次，这个过程加载并缓存所有Mach-O镜像文件，并没有进行合并分类的相关操作。

load_images->loadAllCategories->load_categories_nolock->attachCategories->attachLists

在这个过程中，才正式合并分类。需要注意的是，load_images只有在map_images执行结束后，才会执行，会执行多次。但是load_images内的loadAllCategories方法，只在分类还没初始化并且_dyld_objc_notify_register 的调用已经完成时，即didInitialAttachCategories 为false， didCallDyldNotifyRegister为true，此时才启用,此时就不再走realizeClassWithoutSwift->methodizeClass->attachToClass这一部分了，因为类对象已经存在了，因此改换成loadAllCategories后面的过程了。

_objc_init

首先在objc（objc4-818.2）开源库中， objc-os.mm类文件内，查找_objc_init 方法，在此方法内的_dyld_objc_notify_register函数注册了3个方法；我们只关注前面两个重要的函数参数；

map_images：加载并缓存所有Mach-O镜像文件；

load_images：初始化类和分类时需要；

unmap_image：取消内存映射。

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;
    
    // fixme defer initialization until an objc-using image is found?
    environ_init();
    tls_init();
    static_init();
    runtime_init();
    exception_init();
#if __OBJC2__
    cache_t::init();
#endif
    _imp_implementationWithBlock_init();
     //
    _dyld_objc_notify_register(&map_images, load_images, unmap_image);

#if __OBJC2__
    didCallDyldNotifyRegister = true;
#endif
}

map_images

作用：加载并缓存所有Mach-O镜像文件，主要操作在map_images_nolock方法中。程序启动后只执行一次。

void
map_images(unsigned count, const char * const paths[],
           const struct mach_header * const mhdrs[])
{
    mutex_locker_t lock(runtimeLock);
    return map_images_nolock(count, paths, mhdrs);
}

map_images_nolock

作用：对所有的镜像列表执行addHeader，主要过滤重复的镜像。 该方法内调用了加载所有Mach-O镜像文件的_read_images方法。

void map_images_nolock(unsigned mhCount, const char * const mhPaths[],
                  const struct mach_header * const mhdrs[])
{
     /**
     *代码过长，省略部分代码
     */

    if (hCount > 0) {
        _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
    }
}

_read_images

在map_images方法调用过程中，最终会引用到 objc-runtime-new.mm 文件内的_read_images方法，_read_images方法的作用是从Mach-O镜像文件中读取所有类信息、方法信息、分类信息。

void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
{
    /**
    *省略了部分代码，只摘取重要代码
    */
 
    //搜索分类
    if (didInitialAttachCategories) {
        for (EACH_HEADER) {
            load_categories_nolock(hi);
        }
    }
    /**
     *当其他线程调用新分类代码之前，此线程完成其修复。分类搜索必须延迟以避免潜在的竞争。
     */
    for (EACH_HEADER) {
        classref_t const *classlist = hi->nlclslist(&count);
        for (i = 0; i < count; i++) {
            Class cls = remapClass(classlist[i]);
            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());
                }
            }
          ////对类 cls 执行第一次初始化，不含swift端初始化
            realizeClassWithoutSwift(cls, nil);
        }
    }
}

realizeClassWithoutSwift

作用：实现ClassWithoutSwift，对类 cls 执行第一次初始化，包括分配其读写数据。不执行任何 Swift 端初始化。

返回类的真实类结构。锁定：runtimeLock 读写锁必须被调用者上写锁，保证线程安全。

static Class realizeClassWithoutSwift(Class cls, Class previously)
{
   runtimeLock.assertLocked();
    /**
    *省略了部分代码，只摘取重要代码
    */
  // Connect this class to its superclass's subclass lists
    if (supercls) {
        addSubclass(supercls, cls);
    } else {
        addRootClass(cls);
    }
     //附加分类
    // Attach categories
    methodizeClass(cls, previously);

    return cls;
}

methodizeClass

作用： 修正 cls 的方法列表、协议列表和属性列表。将 cls 类的所有没有被 attach 的分类 attach 到 cls 上。即将分类中的方法、属性、协议添加到 methods、 properties 和 protocols 中。锁定：runtimeLock 读写锁必须被调用者上写锁，保证线程安全。

static void methodizeClass(Class cls, Class previously)
{
    /**
    *省略了部分代码，只摘取重要代码
    */
 
    runtimeLock.assertLocked();
  
    // Install methods and properties that the class implements itself.
  //添加类自身实现的方法和属性
    method_list_t *list = ro->baseMethods();
    if (list) {
        prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls), nullptr);
        if (rwe) rwe->methods.attachLists(&list, 1);
    }

    property_list_t *proplist = ro->baseProperties;
    if (rwe && proplist) {
        rwe->properties.attachLists(&proplist, 1);
    }

    protocol_list_t *protolist = ro->baseProtocols;
    if (rwe && protolist) {
        rwe->protocols.attachLists(&protolist, 1);
    }

    // Root classes get bonus method implementations if they don't have 
    // them already. These apply before category replacements.
  //// 如果是根元类
    if (cls->isRootMetaclass()) {
        // root metaclass
     // 对根元类的initialize方法进行交换，即给根元类发送 SEL_initialize 消息，但是走的是 objc_noop_imp方法，里面不做任何操作
        addMethod(cls, @selector(initialize), (IMP)&objc_noop_imp, "", NO);
    }

    // Attach categories.
    //给 cls 类附加分类
    if (previously) {//如果已存在类
        if (isMeta) {//如果是元类，给cls附加分类，并返回cls 类的没有被附加的类
            objc::unattachedCategories.attachToClass(cls, previously,
                                                     ATTACH_METACLASS);
        } else {
            // When a class relocates, categories with class methods
            // may be registered on the class itself rather than on
            // the metaclass. Tell attachToClass to look for those.
          //当一个类重新定位时，带有类方法的分类，可以在类自身而不是类之上的元类注册。通过attachToClass来添加这些。
            objc::unattachedCategories.attachToClass(cls, previously,
                                                     ATTACH_CLASS_AND_METACLASS);
        }
    }
    objc::unattachedCategories.attachToClass(cls, cls,
                                             isMeta ? ATTACH_METACLASS : ATTACH_CLASS);

}

load_images

作用： 当镜像的状态变化时，会回调load_images方法。只在map_images 结束后，分类没初始化时候启用。会多次调用。

extern bool hasLoadMethods(const headerType *mhdr);
extern void prepare_load_methods(const headerType *mhdr);

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    if (!didInitialAttachCategories && didCallDyldNotifyRegister) {
        didInitialAttachCategories = true;
        loadAllCategories();
    }

    // Return without taking locks if there are no +load methods here.
    if (!hasLoadMethods((const headerType *)mh)) return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods
    {
        mutex_locker_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}

loadAllCategories

作用：加载所有分类的入口

static void loadAllCategories() {
    mutex_locker_t lock(runtimeLock);

    for (auto *hi = FirstHeader; hi != NULL; hi = hi->getNext()) {
        load_categories_nolock(hi);
    }
}

load_categories_nolock

作用：加载分类的之前的区别判断。

static void load_categories_nolock(header_info *hi) {
    bool hasClassProperties = hi->info()->hasCategoryClassProperties();

    size_t count;
    auto processCatlist = [&](category_t * const *catlist) {
        for (unsigned i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls);
            locstamped_category_t lc{cat, hi};

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Ignore the category.
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class",
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category.
            if (cls->isStubClass()) {
                // Stub classes are never realized. Stub classes
                // don't know their metaclass until they're
                // initialized, so we have to add categories with
                // class methods or properties to the stub itself.
                // methodizeClass() will find them and add them to
                // the metaclass as appropriate.
                if (cat->instanceMethods ||
                    cat->protocols ||
                    cat->instanceProperties ||
                    cat->classMethods ||
                    cat->protocols ||
                    (hasClassProperties && cat->_classProperties))
                {
                    objc::unattachedCategories.addForClass(lc, cls);
                }
            } else {
                // First, register the category with its target class.
                // Then, rebuild the class's method lists (etc) if
                // the class is realized.
                if (cat->instanceMethods ||  cat->protocols
                    ||  cat->instanceProperties)
                {
                    //cls类已实现
                    if (cls->isRealized()) {
                        //合并分类的相关信息到类中
                        attachCategories(cls, &lc, 1, ATTACH_EXISTING);
                    } else {
                        objc::unattachedCategories.addForClass(lc, cls);
                    }
                }

                if (cat->classMethods  ||  cat->protocols
                    ||  (hasClassProperties && cat->_classProperties))
                {
                    if (cls->ISA()->isRealized()) {
                        attachCategories(cls->ISA(), &lc, 1, ATTACH_EXISTING | ATTACH_METACLASS);
                    } else {
                        objc::unattachedCategories.addForClass(lc, cls->ISA());
                    }
                }
            }
        }
    };

    processCatlist(hi->catlist(&count));
    processCatlist(hi->catlist2(&count));
}

attachCategories

作用：从分类列表中添加方法列表、属性和协议到 cls 类中， attachCategories 要求分类列表中是排好序的，新的在前面。

static void attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,int flags)
{
  /**
    *省略了部分代码，只摘取重要代码
    */
    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];

    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    //判断是否为元类
    bool isMeta = (flags & ATTACH_METACLASS);
    auto rwe = cls->data()->extAllocIfNeeded();

    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) {
              //准备 mlists 中的方法列表集合，mcount：列表个数，NO：排除基本方法，fromBundle：是否来自bundle
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__);
              // 将新mlist列表添加到 rwe 中的方法列表数组中
                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) {
              // 将新proplist列表添加到 rwe 中的属性列表数组中
                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) {
              // 将新protolist列表添加到 rwe 中的协议列表数组中
                rwe->protocols.attachLists(protolists, protocount);
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }

    if (mcount > 0) {
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
                           NO, fromBundle, __func__);
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
        if (flags & ATTACH_EXISTING) {
            flushCaches(cls, __func__, [](Class c){
                // constant caches have been dealt with in prepareMethodLists
                // if the class still is constant here, it's fine to keep
                return !c->cache.isConstantOptimizedCache();
            });
        }
    }

    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);

    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}

attachLists

作用：将新的list数据与原有的list 数据进行合并。

  void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return;

        if (hasArray()) {
            // many lists -> many lists
            uint32_t oldCount = array()->count;
            uint32_t newCount = oldCount + addedCount;
            array_t *newArray = (array_t *)malloc(array_t::byteSize(newCount));
            newArray->count = newCount;
            array()->count = newCount;

            for (int i = oldCount - 1; i >= 0; i--)
                newArray->lists[i + addedCount] = array()->lists[i];
            for (unsigned i = 0; i < addedCount; i++)
                newArray->lists[i] = addedLists[i];
            free(array());
            setArray(newArray);
            validate();
        }
        else if (!list  &&  addedCount == 1) {
            // 0 lists -> 1 list
            list = addedLists[0];
            validate();
        } 
        else {
            // 1 list -> many lists
            Ptr<List> oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount;
            setArray((array_t *)malloc(array_t::byteSize(newCount)));
            array()->count = newCount;
            if (oldList) array()->lists[addedCount] = oldList;
            for (unsigned i = 0; i < addedCount; i++)
                array()->lists[i] = addedLists[i];
            validate();
        }
    }

    void tryFree() {
        if (hasArray()) {
            for (uint32_t i = 0; i < array()->count; i++) {
                try_free(array()->lists[i]);
            }
            try_free(array());
        }
        else if (list) {
            try_free(list);
        }
    }

    template<typename Other>
    void duplicateInto(Other &other) {
        if (hasArray()) {
            array_t *a = array();
            other.setArray((array_t *)memdup(a, a->byteSize()));
            for (uint32_t i = 0; i < a->count; i++) {
                other.array()->lists[i] = a->lists[i]->duplicate();
            }
        } else if (list) {
            other.list = list->duplicate();
        } else {
            other.list = nil;
        }
    }
};

Category之 load

1、先编译的类，优先调用load；

2、先调用父类的load，再调用子类的load；

3、先调用类load，再调用分类load，然后先编译的分类先调用load；

4、调用时机最靠前，在main函数运行之前，load 方法就会调用，适合方法交换。

5、不是懒加载，只会在程序调用期间调用一次，谨记，若在类与分类中都实现了 load 方法，两者都会被调用，方法不会被覆盖，但是顺序不确定。

Category之 initialize

1、若是子类，会先走父类initialize，再走子类initialize,如果子类没有重写这个方法，父类里这个方法也会被调用；

2、initialize 是类第一次接收到消息的时候调用，每一个类只会initialize一次，父类可能不止调用一次；

3、和 load 不同，initialize 方法调用时，所有的类都load到了内存中；

4、initialize 的运行线程安全，一般只在 initialize中进行常量的初始化 。

总结：

Category运行时的加载过程，是通过动态的先初始化类和元类的相关信息，然后再将分类的实例方法、类方法、属性以及协议，合并到类对象和元类对象中。