• Category的使用场合是什么？

    category是Objective-C 2.0之后添加的语言特性，category的主要作用是为已经存在的类添加方法。除此之外，apple还推荐了category的另外两个使用场景

    • 可以把类的实现分开在几个不同的文件里面。这样做有几个显而易见的好处，

    a)可以减少单个文件的体积
    b)可以把不同的功能组织到不同的category里
    c)可以由多个开发者共同完成一个类
    d)可以按需加载想要的category 等等。

    • 声明私有方法

    不过除了apple推荐的使用场景，广大开发者脑洞大开，还衍生出了category的其他几个使用场景：

    • 模拟多继承

    • 把framework的私有方法公开

    Objective-C的这个语言特性对于纯动态语言来说可能不算什么，比如javascript，你可以随时为一个“类”或者对象添加任意方法和实例变量。但是对于不是那么“动态”的语言而言，这确实是一个了不起的特性。

    • Category的实现原理
    1. //分类的内存结构，多个分类会对应的多个category_t。
    2. struct category_t {
    3.     const char *name;
    4.     classref_t cls;
    5.     struct method_list_t *instanceMethods; //对象方法
    6.     struct method_list_t *classMethods;    //类方法
    7.     struct protocol_list_t *protocols;     //协议信息
    8.     struct property_list_t *instanceProperties; //属性
    9.     // Fields below this point are not always present on disk.
    10.     struct property_list_t *_classProperties;
    12.     method_list_t *methodsForMeta(bool isMeta) {
    13.         if (isMeta) return classMethods;
    14.         else return instanceMethods;
    15.     }
    17.     property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
    18. };

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

    在程序运行的时候，runtime会将Category的数据，合并到类信息中（类对象、元类对象中）

    • Category的加载处理过程
    1. /***********************************************************************
    2. * _read_images
    3. * Perform initial processing of the headers in the linked 
    4. * list beginning with headerList. 
    5. *
    6. * Called by: map_images_nolock
    7. *
    8. * Locking: runtimeLock acquired by map_images
    9. **********************************************************************/
    10. void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
    11. {
    12.     ......
    13.     // add by chenjie
    14.     // Discover categories. 
    15.     for (EACH_HEADER) {
    16.         //获取系统的category列表
    17.         category_t **catlist = 
    18.             _getObjc2CategoryList(hi, &count);
    19.         bool hasClassProperties = hi->info()->hasCategoryClassProperties();
    21.         for (i = 0; i < count; i++) {
    22.             category_t *cat = catlist[i];
    23.             Class cls = remapClass(cat->cls);
    25.             if (!cls) {
    26.                 // Category's target class is missing (probably weak-linked).
    27.                 // Disavow any knowledge of this category.
    28.                 catlist[i] = nil;
    29.                 if (PrintConnecting) {
    30.                     _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
    31.                                  "missing weak-linked target class", 
    32.                                  cat->name, cat);
    33.                 }
    34.                 continue;
    35.             }
    37.             // Process this category. 
    38.             // First, register the category with its target class. 
    39.             // Then, rebuild the class's method lists (etc) if 
    40.             // the class is realized. 
    41.             bool classExists = NO;
    42.             if (cat->instanceMethods ||  cat->protocols  
    43.                 ||  cat->instanceProperties) 
    44.             {
    45.                 addUnattachedCategoryForClass(cat, cls, hi);
    46.                 if (cls->isRealized()) {
    47.                     //重新组织了类对象的方法。
    48.                     remethodizeClass(cls);
    49.                     classExists = YES;
    50.                 }
    51.                 if (PrintConnecting) {
    52.                     _objc_inform("CLASS: found category -%s(%s) %s", 
    53.                                  cls->nameForLogging(), cat->name, 
    54.                                  classExists ? "on existing class" : "");
    55.                 }
    56.             }
    58.             if (cat->classMethods  ||  cat->protocols  
    59.                 ||  (hasClassProperties && cat->_classProperties)) 
    60.             {
    61.                 addUnattachedCategoryForClass(cat, cls->ISA(), hi);
    62.                 if (cls->ISA()->isRealized()) {
    63.                     //重新组织了元类对象的方法。
    64.                     remethodizeClass(cls->ISA());
    65.                 }
    66.                 if (PrintConnecting) {
    67.                     _objc_inform("CLASS: found category +%s(%s)", 
    68.                                  cls->nameForLogging(), cat->name);
    69.                 }
    70.             }
    71.         }
    72.     }
    73. }
    75. // Attach method lists and properties and protocols from categories to a class.
    76. // Assumes the categories in cats are all loaded and sorted by load order, 
    77. // oldest categories first.
    78. static void 
    79. attachCategories(Class cls, category_list *cats, bool flush_caches)
    80. {
    81.     if (!cats) return;
    82.     if (PrintReplacedMethods) printReplacements(cls, cats);
    84.     bool isMeta = cls->isMetaClass();
    86.     // fixme rearrange to remove these intermediate allocations
    87.     // 方法数组
    88.     /*
    89.      [
    90.      [method_t, method_t],
    91.      [method_t, method_t]
    92.      ]
    93.      */
    94.     method_list_t **mlists = (method_list_t **)
    95.         malloc(cats->count * sizeof(*mlists));
    96.     //属性数组
    97.     property_list_t **proplists = (property_list_t **)
    98.         malloc(cats->count * sizeof(*proplists));
    99.     //协议数组
    100.     protocol_list_t **protolists = (protocol_list_t **)
    101.         malloc(cats->count * sizeof(*protolists));
    103.     // Count backwards through cats to get newest categories first
    104.     int mcount = 0;
    105.     int propcount = 0;
    106.     int protocount = 0;
    107.     int i = cats->count;
    108.     bool fromBundle = NO;
    109.     while (i--) {
    110.         //取出某得分类
    111.         auto& entry = cats->list[i];
    113.         //取出分类中的对象方法
    114.         method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
    115.         if (mlist) {
    116.             mlists[mcount++] = mlist;
    117.             fromBundle |= entry.hi->isBundle();
    118.         }
    120.         property_list_t *proplist = 
    121.             entry.cat->propertiesForMeta(isMeta, entry.hi);
    122.         if (proplist) {
    123.             proplists[propcount++] = proplist;
    124.         }
    126.         protocol_list_t *protolist = entry.cat->protocols;
    127.         if (protolist) {
    128.             protolists[protocount++] = protolist;
    129.         }
    130.     }
    132.     //得到类对象里面的数组
    133.     auto rw = cls->data();
    135.     prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    136.     // 将所有分类的对象方法，附加到类对象的方法列表中
    137.     rw->methods.attachLists(mlists, mcount);
    138.     free(mlists);
    139.     if (flush_caches  &&  mcount > 0) flushCaches(cls);
    141.     // 将所有分类的属性，附加到类对象的属性列表中
    142.     rw->properties.attachLists(proplists, propcount);
    143.     free(proplists);
    145.     // 将所有分类的协议，附加到类对象的协议列表中
    146.     rw->protocols.attachLists(protolists, protocount);
    147.     free(protolists);
    148. }
    150. void attachLists(List* const * addedLists, uint32_t addedCount) {
    151.         if (addedCount == 0) return;
    153.         if (hasArray()) {
    154.              uint32_t oldCount = array()->count;
    155.             uint32_t newCount = oldCount + addedCount;
    157.             //重新开辟内存空间
    158.             setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
    159.             array()->count = newCount;
    160.             //array()->lists 原来的方法列表
    161.             memmove(array()->lists + addedCount, array()->lists, 
    162.                     oldCount * sizeof(array()->lists[0]));
    163.             //addedLists 新增的方法列表
    164.             memcpy(array()->lists, addedLists, 
    165.                    addedCount * sizeof(array()->lists[0]));
    167.     }

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

    2. 把所有Category的方法、属性、协议数据，合并到一个大数组中后面参与编译的Category数据，会在数组的前面

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

    • Category和Class Extension的区别是什么？

    Class Extension在编译的时候，它的数据就已经包含在类信息中

    Category是在运行时，才会将数据合并到类信息中

    • +load方法

    Category - 图1

    1. //加载load方法的步骤
    2. void prepare_load_methods(const headerType *mhdr)
    3. {
    4.     size_t count, i;
    6.     classref_t *classlist = 
    7.         _getObjc2NonlazyClassList(mhdr, &count);
    8.     for (i = 0; i < count; i++) {
    9.         schedule_class_load(remapClass(classlist[i]));
    10.     }
    11. }
    13. static void schedule_class_load(Class cls)
    14. {
    15.     if (!cls) return;
    16.     assert(cls->isRealized());  // _read_images should realize
    18.     if (cls->data()->flags & RW_LOADED) return;
    20.     // Ensure superclass-first ordering
    21.     schedule_class_load(cls->superclass);
    23.     add_class_to_loadable_list(cls);
    24.     cls->setInfo(RW_LOADED); 
    25. }
    27. void add_class_to_loadable_list(Class cls)
    28. {
    29.     IMP method;
    31.     loadMethodLock.assertLocked();
    33.     method = cls->getLoadMethod();
    34.     if (!method) return;  // Don't bother if cls has no +load method
    36.     if (PrintLoading) {
    37.         _objc_inform("LOAD: class '%s' scheduled for +load", 
    38.                      cls->nameForLogging());
    39.     }
    41.     if (loadable_classes_used == loadable_classes_allocated) {
    42.         loadable_classes_allocated = loadable_classes_allocated*2 + 16;
    43.         loadable_classes = (struct loadable_class *)
    44.             realloc(loadable_classes,
    45.                               loadable_classes_allocated *
    46.                               sizeof(struct loadable_class));
    47.     }
    49.     //loadable_classes是保存load方法的列表
    50.     loadable_classes[loadable_classes_used].cls = cls;
    51.     loadable_classes[loadable_classes_used].method = method;
    52.     loadable_classes_used++;
    53. }
    56. //调用load方法
    57. void call_load_methods(void)
    58. {
    59.     static bool loading = NO;
    60.     bool more_categories;
    62.     loadMethodLock.assertLocked();
    64.     // Re-entrant calls do nothing; the outermost call will finish the job.
    65.     if (loading) return;
    66.     loading = YES;
    68.     void *pool = objc_autoreleasePoolPush();
    70.     do {
    71.         // 1. Repeatedly call class +loads until there aren't any more
    72.         while (loadable_classes_used > 0) {
    73.             call_class_loads();
    74.         }
    76.         // 2. Call category +loads ONCE
    77.         more_categories = call_category_loads();
    79.         // 3. Run more +loads if there are classes OR more untried categories
    80.     } while (loadable_classes_used > 0  ||  more_categories);
    82.     objc_autoreleasePoolPop(pool);
    84.     loading = NO;
    85. }
    87. static bool call_category_loads(void)
    88. {
    89.     int i, shift;
    90.     bool new_categories_added = NO;
    92.     // Detach current loadable list.
    93.     struct loadable_category *cats = loadable_categories;
    94.     int used = loadable_categories_used;
    95.     int allocated = loadable_categories_allocated;
    96.     loadable_categories = nil;
    97.     loadable_categories_allocated = 0;
    98.     loadable_categories_used = 0;
    100.     // Call all +loads for the detached list.
    101.     for (i = 0; i < used; i++) {
    102.         Category cat = cats[i].cat;
    103.         load_method_t load_method = (load_method_t)cats[i].method;
    104.         Class cls;
    105.         if (!cat) continue;
    107.         cls = _category_getClass(cat);
    108.         if (cls  &&  cls->isLoadable()) {
    109.             if (PrintLoading) {
    110.                 _objc_inform("LOAD: +[%s(%s) load]\n", 
    111.                              cls->nameForLogging(), 
    112.                              _category_getName(cat));
    113.             }
    114.             (*load_method)(cls, SEL_load);
    115.             cats[i].cat = nil;
    116.         }
    117.     }
    118. }

    应用场景

    在执行load方法时，整个应用程序都会阻塞等着所有类的load方法都执行完才继续，因此尽力减少在load函数中所做的操作。这个类真正的用途一般只用于调试程序，比如可以在分类中实现此方法，用来判断该分类是否已经正确载入系统。此外，一般在需要method swizzling时，一般是在load函数中实现，可保证程序一经加载方法就交换完成，且只执行一次。

    • +initialize方法

    Category - 图2

    1. Method class_getInstanceMethod(Class cls, SEL sel)
    2. {
    3.     // Search method lists, try method resolver, etc.
    4.     lookUpImpOrNil(cls, sel, nil, 
    5.                    NO/*initialize*/, NO/*cache*/, YES/*resolver*/);
    7.     return _class_getMethod(cls, sel);
    8. }
    10. /***********************************************************************
    11. * class_initialize.  Send the '+initialize' message on demand to any
    12. * uninitialized class. Force initialization of superclasses first.
    13. **********************************************************************/
    14. void _class_initialize(Class cls)
    15. {
    16.     assert(!cls->isMetaClass());
    18.     Class supercls;
    19.     bool reallyInitialize = NO;
    21.     // Make sure super is done initializing BEFORE beginning to initialize cls.
    22.     // See note about deadlock above.
    23.     //先调用父类的初始化方法
    24.     supercls = cls->superclass;
    25.     if (supercls  &&  !supercls->isInitialized()) {
    26.         _class_initialize(supercls);
    27.     }
    29.     // Try to atomically set CLS_INITIALIZING.
    30.     {
    31.         monitor_locker_t lock(classInitLock);
    32.         if (!cls->isInitialized() && !cls->isInitializing()) {
    33.             cls->setInitializing();
    34.             reallyInitialize = YES;
    35.         }
    36.     }
    37. }
    • Category中有load方法吗？load方法是什么时候调用的？load 方法能继承吗？

    有load方法

    load方法在runtime加载类、分类的时候调用

    load方法可以继承，但是一般情况下不会主动去调用load方法，都是让系统自动调用

    • load、initialize方法的区别什么？它们在category中的调用的顺序？以及出现继承时他们之间的调用过程？

    1.调用方式
    1> load是根据函数地址直接调用
    2> initialize是通过objc_msgSend调用

    2.调用时刻
    1> load是runtime加载类、分类的时候调用（只会调用1次）
    2> initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）

    load、initialize的调用顺序？
    1.load
    1> 先调用类的load
    a) 先编译的类，优先调用load
    b) 调用子类的load之前，会先调用父类的load

    2> 再调用分类的load
    a) 先编译的分类，优先调用load

    2.initialize
    1> 先初始化父类
    2> 再初始化子类（可能最终调用的是父类的initialize方法）

    • Category能否添加成员变量？如果可以，如何给Category添加成员变量？

    不能直接给Category添加成员变量，但是可以间接实现Category有成员变量的效果

    总结
    load和initialize方法都会在实例化对象之前调用，以main函数为分水岭，前者在main函数之前调用，后者在之后调用。这两个方法会被自动调用，不能手动调用它们。

    load和initialize方法都不用显示的调用父类的方法而是自动调用，即使子类没有initialize方法也会调用父类的方法，而load方法则不会调用父类。

    load方法通常用来进行Method Swizzle，initialize方法一般用于初始化全局变量或静态变量。

    load和initialize方法内部使用了锁，因此它们是线程安全的。实现时要尽可能保持简单，避免阻塞线程，不要再使用锁。