经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » iOS » 查看文章
iOS底层原理（三）Category
来源：cnblogs　　作者：FunkyRay　　时间：2021/4/12 9:50:13　　对本文有异议

Category的本质

Category的底层结构

1.我们先给Person增加一个Person+Eat的分类

  1. @interface Person (Eat) <NSCopying, NSCoding>
  3. - (void)eat;
  5. @property (assign, nonatomic) int weight;
  6. @property (assign, nonatomic) double height;
  7. @end
  9. @implementation Person (Eat)
  11. - (void)eat
  12. {
  13.     NSLog(@"eat");
  14. }
  16. - (void)eat1
  17. {
  18.     NSLog(@"eat1");
  19. }
  21. + (void)eat2
  22. {
  23.     
  24. }
  26. + (void)eat3
  27. {
  28.     
  29. }
  31. @end

2.然后通过xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+Eat.m转换成Person+Eat.cpp文件，发现内部会生成一个_category_t类型的结构体

  1. struct _category_t {
  2. 	const char *name; // 类名
  3. 	struct _class_t *cls;
  4. 	const struct _method_list_t *instance_methods; // 对象方法
  5. 	const struct _method_list_t *class_methods; // 类方法
  6. 	const struct _protocol_list_t *protocols; // 协议列表
  7. 	const struct _prop_list_t *properties; // 属性列表
  8. };

3.我们还发现会生成一个_category_t结构体类型的变量，这个变量对应着该分类文件是Person+Eat，并且里面记录着所有的分类信息

  1. // 变量名对应着分类文件名
  2. static struct _category_t _OBJC_$_CATEGORY_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = 
  3. {
  4. 	"Person", // 类名
  5. 	0, // cls
  6. 	(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat, // 对象方法
  7. 	(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat, // 类方法
  8. 	(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat, // 协议列表
  9. 	(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_Eat, // 属性列表
  10. };

4._OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat这个变量里面记录着分类的对象方法eat和eat1

  1. static struct /*_method_list_t*/ {
  2. 	unsigned int entsize;  // sizeof(struct _objc_method)
  3. 	unsigned int method_count;
  4. 	struct _objc_method method_list[2];
  5. } _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
  6. 	sizeof(_objc_method),
  7. 	2,
  8. 	{{(struct objc_selector *)"eat", "v16@0:8", (void *)_I_Person_Eat_eat},
  9. 	{(struct objc_selector *)"eat1", "v16@0:8", (void *)_I_Person_Eat_eat1}}
  10. };

5._OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat这个变量里面记录着分类的类方法eat2和eat3

  1. static struct /*_method_list_t*/ {
  2. 	unsigned int entsize;  // sizeof(struct _objc_method)
  3. 	unsigned int method_count;
  4. 	struct _objc_method method_list[2];
  5. } _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
  6. 	sizeof(_objc_method),
  7. 	2,
  8. 	{{(struct objc_selector *)"eat2", "v16@0:8", (void *)_C_Person_Eat_eat2},
  9. 	{(struct objc_selector *)"eat3", "v16@0:8", (void *)_C_Person_Eat_eat3}}
  10. };

6. _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat这个变量里面记录着NSCopying和NSCoding两个协议

  1. static struct /*_protocol_list_t*/ {
  2. 	long protocol_count;  // Note, this is 32/64 bit
  3. 	struct _protocol_t *super_protocols[2];
  4. } _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
  5. 	2,
  6. 	&_OBJC_PROTOCOL_NSCopying,
  7. 	&_OBJC_PROTOCOL_NSCoding
  8. };

7._OBJC_$_PROP_LIST_Person_$_Eat这个变量里面记录着属性weight和height

  1. static struct /*_prop_list_t*/ {
  2. 	unsigned int entsize;  // sizeof(struct _prop_t)
  3. 	unsigned int count_of_properties;
  4. 	struct _prop_t prop_list[2];
  5. } _OBJC_$_PROP_LIST_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
  6. 	sizeof(_prop_t),
  7. 	2,
  8. 	{{"weight","Ti,N"}, 
  9. 	{"height","Td,N"}}
  10. 	// Ti,N和Td,N对应着int和double两个类型
  11. };

Category的加载处理过程

1.通过分析查找到objc-rumtime-new.mm文件里的attachCategories函数，将分类文件里的数据信息都附加到对应的类对象或者元类对象里，详细代码如下

  1. // 附加上分类的核心操作
  2. // cls:类对象或者元类对象，cats_list：分类列表
  3. static void attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
  4.                  int flags)
  5. {
  6.     if (slowpath(PrintReplacedMethods)) {
  7.         printReplacements(cls, cats_list, cats_count);
  8.     }
  9.     if (slowpath(PrintConnecting)) {
  10.         _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",
  11.                      cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",
  12.                      cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");
  13.     }
  15.     // 先分配固定内存空间来存放方法列表、属性列表和协议列表
  16.     constexpr uint32_t ATTACH_BUFSIZ = 64;
  17.     method_list_t   *mlists[ATTACH_BUFSIZ];
  18.     property_list_t *proplists[ATTACH_BUFSIZ];
  19.     protocol_list_t *protolists[ATTACH_BUFSIZ];
  21.     uint32_t mcount = 0;
  22.     uint32_t propcount = 0;
  23.     uint32_t protocount = 0;
  24.     bool fromBundle = NO;
  25.     
  26.     // 判断是否为元类
  27.     bool isMeta = (flags & ATTACH_METACLASS);
  28.     auto rwe = cls->data()->extAllocIfNeeded();
  30.     for (uint32_t i = 0; i < cats_count; i++) {
  31.         // 取出某个分类
  32.         auto& entry = cats_list[i];
  34.         // entry.cat就是category_t *cat
  35.         // 根据isMeta属性取出每一个分类的类方法列表或者对象方法列表
  36.         method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
  37.         
  38.         // 如果有方法则添加mlist数组到mlists这个大的方法数组中
  39.         // mlists是一个二维数组：[[method_t, method_t, ....], [method_t, method_t, ....]]
  40.         if (mlist) {
  41.             if (mcount == ATTACH_BUFSIZ) {
  42.                 prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__);
  43.                 rwe->methods.attachLists(mlists, mcount);
  44.                 mcount = 0;
  45.             }
  46. 			// 将分类列表里先取出来的分类方法列表放到大数组mlists的最后面（ATTACH_BUFSIZ - ++mcount），所以最后编译的分类方法列表会放在整个方法列表大数组的最前面            
  47. 			mlists[ATTACH_BUFSIZ - ++mcount] = mlist;
  48.             fromBundle |= entry.hi->isBundle();
  49.         }
  51.         // 同上面一样取出的是分类中的属性列表proplist加到大数组proplists中
  52.         // proplists是一个二维数组：[[property_t, property_t, ....], [property_t, property_t, ....]]
  53.         property_list_t *proplist =
  54.             entry.cat->propertiesForMeta(isMeta, entry.hi);
  55.         if (proplist) {
  56.             if (propcount == ATTACH_BUFSIZ) {
  57.                 rwe->properties.attachLists(proplists, propcount);
  58.                 propcount = 0;
  59.             }
  60.             proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
  61.         }
  63.         // 同上面一样取出的是分类中的协议列表protolist加到大数组protolists中
  64.         // protolists是一个二维数组：[[protocol_ref_t, protocol_ref_t, ....], [protocol_ref_t, protocol_ref_t, ....]]
  65.         protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);
  66.         if (protolist) {
  67.             if (protocount == ATTACH_BUFSIZ) {
  68.                 rwe->protocols.attachLists(protolists, protocount);
  69.                 protocount = 0;
  70.             }
  71.             protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
  72.         }
  73.     }
  75.     if (mcount > 0) {
  76.         prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
  77.                            NO, fromBundle, __func__);
  78.         
  79.         // 将分类的所有对象方法或者类方法，都附加到类对象或者元类对象的方法列表中
  80.         rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
  81.         if (flags & ATTACH_EXISTING) {
  82.             flushCaches(cls, __func__, [](Class c){
  83.                 return !c->cache.isConstantOptimizedCache();
  84.             });
  85.         }
  86.     }
  88.     // 将分类的所有属性附加到类对象的属性列表中
  89.     rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);
  91.     // 将分类的所有协议附加到类对象的协议列表中
  92.     rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
  93. }

2.上述的每步操作都会调用attachLists方法来进行元素分配，详细代码如下

  1. void attachLists(List* const * addedLists, uint32_t addedCount) {
  2.    if (addedCount == 0) return;
  4.    if (hasArray()) {
  5.        // 获取原本的个数
  6.        uint32_t oldCount = array()->count;
  7.        // 最新的个数 = 原本的个数 + 新添加的个数
  8.        uint32_t newCount = oldCount + addedCount;
  9.        
  10.        // 重新分配内存
  11.        array_t *newArray = (array_t *)malloc(array_t::byteSize(newCount));
  12.        // 将新数组的个数改为最新的个数
  13.        newArray->count = newCount;
  14.        // 将旧数组的个数改为最新的个数
  15.        array()->count = newCount;
  16.        
  17.        // 递减遍历，将旧数组里的元素从后往前的依次放到新数组里
  18.        for (int i = oldCount - 1; i >= 0; i--)
  19.            newArray->lists[i + addedCount] = array()->lists[i];
  20.        
  21.        // 将新增加的元素从前往后的依次放到新数组里
  22.        for (unsigned i = 0; i < addedCount; i++)
  23.            newArray->lists[i] = addedLists[i];
  24.        
  25.        // 释放旧数组数据
  26.        free(array());
  27.        
  28.        // 赋值新数组数据
  29.        setArray(newArray);
  30.        validate();
  31.    }
  32.    else if (!list  &&  addedCount == 1) {
  33.        // 0 lists -> 1 list
  34.        list = addedLists[0];
  35.        validate();
  36.    } 
  37.    else { .... }
  38. }

总结

  • 编译时
    • 每一个Category都会生成一个_category_t结构体对象，记录着所有的属性、方法和协议信息
  • 运行时
    • 通过Runtime加载某个类的所有Category数据
    • 把所有Category的对象方法、类方法、属性、协议数据，分别合并到一个二维数组中，并且后面参与编译的Category数据，会在数组的前面
    • 将合并后的Category数据（方法、属性、协议），插入到类原来数据的前面

面试题

1.如果几个分类中都有同样的方法，会调用哪个，调用顺序是什么

  • 有分类会先调用分类的方法，如果多个分类都有相同的方法，那么会根据编译顺序来决定执行哪个分类的方法，后参与编译的分类方法会放到整个方法列表数组的最前面，到时调用会遍历所有的方法列表数组，先找到的分类方法列表先执行。
  • 在Xcode中查看编译顺序：Build Phases->Compile Sources
  • 分类里面相同的方法会覆盖类原本的方法这种说法是错误的，根本就没有覆盖，只是最先遍历找到哪个就执行哪个，不存在覆盖的概念

2. Class Extension和Category的实现是一样的吗

  • 不一样。
  • 类扩展只是将.h文件中的声明放到.m中作为私有来使用，编译时就已经合并到该类中了。
  • 分类中的声明都是公开的，而且是利用运行时机制在程序运行时将分类里的数据合并到类中

3.Category中有load方法吗？load方法是什么时候调用的？load 方法能继承吗？

  • 有load方法
  • load方法在Runtime加载类、分类的时候调用，而且只调用一次
  • load方法可以继承，但是一般情况下不会主动去调用load方法，都是让系统自动调用

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

load方法

  • load方法会在Runtime加载类、分类时调用- 每个类、分类的load，在程序运行过程中只调用一次
源码分析

1.在objc-runtime-new.mm中load_images方法可以发现准备处理load方法和调用load方法的函数

  1. void load_images(const char *path __unused, const struct mach_header *mh) {
  2.    	....
  3.     
  4.     {
  5.         mutex_locker_t lock2(runtimeLock);
  6.         // 准备load方法
  7.         prepare_load_methods((const headerType *)mh);
  8.     }
  10.    	// 调用load方法
  11.     call_load_methods();
  12. }

2.在prepare_load_methods中发现，调用load方法前的类的处理和分类的处理

  1. void prepare_load_methods(const headerType *mhdr) {
  2.     size_t count, i;
  4.     runtimeLock.assertLocked();
  5.     
  6. 	// 按编译顺序拿到所有的类的list
  7.     classref_t const *classlist = 
  8.         _getObjc2NonlazyClassList(mhdr, &count);
  9.         
  10.     // 按添加进数组的顺序遍历处理类的列表
  11.     for (i = 0; i < count; i++) {
  12.         schedule_class_load(remapClass(classlist[i]));
  13.     }
  15. 	// 按编译顺序拿到所有的分类列表
  16.     category_t * const *categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
  17.     for (i = 0; i < count; i++) {
  18.         category_t *cat = categorylist[i];
  19.         Class cls = remapClass(cat->cls);
  20.         
  21.       	....
  22.  
  23. 	   // 按顺序直接添加
  24.        add_category_to_loadable_list(cat);
  25.     }
  26. }

3.递归调用schedule_class_load方法来优先添加父类放到列表中，然后再添加当前类，所以执行调用时肯定先执行父类的load方法

  1. static void schedule_class_load(Class cls) {
  2.     if (!cls) return;
  3.     ASSERT(cls->isRealized());  // _read_images should realize
  5.     if (cls->data()->flags & RW_LOADED) return;
  7.     // 递归调用，找到传进来的类的父类添加到列表中
  8.     schedule_class_load(cls->getSuperclass());
  10.    // 然后再调用当前传进来的类添加到列表中，所以父类肯定是在前面
  11.    add_class_to_loadable_list(cls);
  12.     cls->setInfo(RW_LOADED); 
  13. }

4.在objc-loadmethod.mm中call_load_methods方法可以发现，程序运行时会先调用类的load方法，然后调用分类的load方法，详细代码如下

  1. void call_load_methods(void)
  2. {
  3.     static bool loading = NO;
  4.     bool more_categories;
  6.     loadMethodLock.assertLocked();
  8.     // Re-entrant calls do nothing; the outermost call will finish the job.
  9.     if (loading) return;
  10.     loading = YES;
  12.     void *po ol = objc_autoreleasePoolPush();
  14.     do {
  15.         // 1. 优先调用类的load方法
  16.         while (loadable_classes_used > 0) {
  17.             call_class_loads();
  18.         }
  20.         // 2. 只调用一次分类的load方法
  21.         more_categories = call_category_loads();
  23.         // 3. Run more +loads if there are classes OR more untried categories
  24.     } while (loadable_classes_used > 0  ||  more_categories);
  26.     objc_autoreleasePoolPop(pool);
  28.     loading = NO;
  29. }

5.找到每个类的load方法的内存地址，然后直接调用

  1. static void call_class_loads(void) {
  2.     int i;
  3.     
  4.     // Detach current loadable list.
  5.     struct loadable_class *classes = loadable_classes;
  6.     int used = loadable_classes_used;
  7.     loadable_classes = nil;
  8.     loadable_classes_allocated = 0;
  9.     loadable_classes_used = 0;
  10.     
  11.     // Call all +loads for the detached list.
  12.     for (i = 0; i < used; i++) {
  13.         Class cls = classes[i].cls;
  14.         
  15.         // 取出类里面的load方法
  16.         // load_method_t：指向函数地址的指针
  17.         // 这里的method对应的结构体为loadable_class
  18.         load_method_t load_method = (load_method_t)classes[i].method;
  19.         if (!cls) continue; 
  21.         if (PrintLoading) {
  22.             _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
  23.         }
  24.         
  25.         // 直接调用load方法
  26.         (*load_method)(cls, @selector(load));
  27.     }
  28.     
  29.     // Destroy the detached list.
  30.     if (classes) free(classes);
  31. }
  33. // 找到的method对应的结构体
  34. struct loadable_class {
  35.     Class cls;  // may be nil
  36.     IMP method; // 这个就是load方法
  37. };

6.找到每个分类的load方法的内存地址，然后直接调用

  1. static bool call_category_loads(void) {
  2.     int i, shift;
  3.     bool new_categories_added = NO;
  4.     
  5.     // Detach current loadable list.
  6.     struct loadable_category *cats = loadable_categories;
  7.     int used = loadable_categories_used;
  8.     int allocated = loadable_categories_allocated;
  9.     loadable_categories = nil;
  10.     loadable_categories_allocated = 0;
  11.     loadable_categories_used = 0;
  13.     // Call all +loads for the detached list.
  14.     for (i = 0; i < used; i++) {
  15.         Category cat = cats[i].cat;
  16.         
  17.         // 取出每一个分类里的load方法
  18.         // 这里的method对应的结构体为loadable_category
  19.         load_method_t load_method = (load_method_t)cats[i].method;
  20.         Class cls;
  21.         if (!cat) continue;
  23.         cls = _category_getClass(cat);
  24.         if (cls  &&  cls->isLoadable()) {
  25.             if (PrintLoading) {
  26.                 _objc_inform("LOAD: +[%s(%s) load]\n", 
  27.                              cls->nameForLogging(), 
  28.                              _category_getName(cat));
  29.             }
  30.             
  31.             // 直接调用load方法
  32.             (*load_method)(cls, @selector(load));
  33.             cats[i].cat = nil;
  34.         }
  35.     }
  37.    ....
  38.  }
  39.  
  40. // 找到的method对应的结构体
  41. struct loadable_category {
  42.     Category cat;  // may be nil
  43.     IMP method; // 这个方法就是load方法
  44. };
调用顺序
  • 先调用类的load
    • 按照编译先后顺序调用（先编译，先调用）
    • 调用子类的load之前会先调用父类的load
  • 再调用分类的load
    • 按照编译先后顺序调用（先编译，先调用）
load方法系统调用和主动调用的区别
  • 系统调用load方法调用是直接找到类和分类中的方法的内存地址直接调用
  • 主动调用load方法是通过消息机制来发送消息的，会在对应的消息列表里按顺序遍历一层层查找，找到就调用

initialize方法

initialize方法会在类第一次接收到消息时调用

源码分析

1.由于在调用到这个类的时候才会执行initialize方法，那么说明是在发消息过程中来执行的，我们在objc-runtime-new.mm中调用class_getInstanceMethod或者class_getClassMethod方法，详细代码如下

  1. Method class_getClassMethod(Class cls, SEL sel)
  2. {
  3.     if (!cls  ||  !sel) return nil;
  5.     return class_getInstanceMethod(cls->getMeta(), sel);
  6. }
  8. Method class_getInstanceMethod(Class cls, SEL sel)
  9. {
  10.     if (!cls  ||  !sel) return nil;
  11.     lookUpImpOrForward(nil, sel, cls, LOOKUP_RESOLVER);
  13.     return _class_getMethod(cls, sel);
  14. }

2.一步步调用最后找到initializeNonMetaClass函数，先递归找到父类调用initialize方法，然后当前类调用initialize方法。可以在callInitialize里发现本质都是通过Runtime的消息机制进行的发送

  1. void initializeNonMetaClass(Class cls) {
  2. 	ASSERT(!cls->isMetaClass());
  4.     Class supercls;
  5.     bool reallyInitialize = NO;
  7.     // 如果存在父类，并且没有初始化父类，就去初始化父类
  8.     supercls = cls->getSuperclass();
  9.     if (supercls  &&  !supercls->isInitialized()) {
  10.         initializeNonMetaClass(supercls);
  11.     }
  12.   
  13.     SmallVector<_objc_willInitializeClassCallback, 1> localWillInitializeFuncs;
  14.     {
  15.         monitor_locker_t lock(classInitLock);
  16.         if (!cls->isInitialized() && !cls->isInitializing()) {
  17.         
  18.         // 未初始化的类通过setInitializing做了标记，下次就不会再调用了
  19.             cls->setInitializing();
  20.             reallyInitialize = YES;
  22.             // Grab a copy of the will-initialize funcs with the lock held.
  23.             localWillInitializeFuncs.initFrom(willInitializeFuncs);
  24.         }
  25.     }
  26.     
  27.     ....
  28.     
  29.     {
  30.        // 调用初始化
  31.        callInitialize(cls);
  32.        ....
  33.        
  34.    	}
  35.    	
  36.    	....
  37. }
  40. // 调用initialize的函数
  41. void callInitialize(Class cls) {
  42.     // 通过runtime消息机制发送initialize消息
  43.     ((void(*)(Class, SEL))objc_msgSend)(cls, @selector(initialize));
  44.     asm("");
  45. }
调用顺序
  • 先调用父类的initialize，再调用子类的initialize
  • (先初始化父类，再初始化子类，每个类只会初始化1次)
initialize和load的区别
  • initialize是通过objc_msgSend进行调用的，而load是找到函数地址直接调用的
  • 如果子类没有实现initialize，会调用父类的initialize
    • 所以父类的initialize可能会被调用多次，第一次是系统通过消息发送机制调用的父类initialize，后面多次的调用都是因为子类没有实现initialize，而通过superclass找到父类再次调用的
  • 如果分类实现了initialize，就覆盖类本身的initialize调用

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

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

实现方案

通过objc_setAssociatedObject设置关联对象来实现

  1. @interface Person (Test)
  3. @property (copy, nonatomic) NSString *name;
  4. @property (assign, nonatomic) int weight;
  5. @end
  7. @implementation Person (Test)
  9. - (void)setName:(NSString *)name
  10. {
  11.     /*
  12.      * object：关联的对象
  13.      * value：关联的值
  14.      * objc_AssociationPolicy：关联策略
  15.      */
  16.     objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);
  17. }
  19. - (NSString *)name
  20. {
  21.     // 隐式参数
  22.     // _cmd == @selector(name)
  23.     return objc_getAssociatedObject(self, _cmd);
  24. }
  26. - (void)setWeight:(int)weight
  27. {
  28.     objc_setAssociatedObject(self, @selector(weight), @(weight), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
  29. }
  31. - (int)weight
  32. {
  33.     // _cmd == @selector(weight)
  34.     return [objc_getAssociatedObject(self, _cmd) intValue];
  35. }
  36. @end
实现源码分析

1.在objc-references.mm中我们可以看到objc_setAssociatedObject的实现代码如下

  1. void _object_set_associative_reference(id object, const void *key, id value, uintptr_t policy) {
  2.     if (!object && !value) return;
  4.     if (object->getIsa()->forbidsAssociatedObjects())
  5.         _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
  6.     
  7.     // 通过传进来的object生成一个key
  8.     DisguisedPtr<objc_object> disguised{(objc_object *)object};
  9.     ObjcAssociation association{policy, value};
  11.     // retain the new value (if any) outside the lock.
  12.     association.acquireValue();
  14.     bool isFirstAssociation = false;
  15.     {
  16.         AssociationsManager manager;
  17.         // 取出AssociationsManager里的AssociationsHashMap这个属性
  18.         AssociationsHashMap &associations(manager.get());
  20.         // 如果value有值
  21.         if (value) {
  22.             // 根据传进来的object key的值disguised取出ObjectAssociationMap
  23.             auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
  24.             if (refs_result.second) {
  25.                 /* it's the first association we make */
  26.                 isFirstAssociation = true;
  27.             }
  29.             // 根据refs_result的key存放进association
  30.             // association就是ObjcAssociation
  31.             // 总之就是对应的每一个key一层层的赋值
  32.             auto &refs = refs_result.first->second;
  33.             auto result = refs.try_emplace(key, std::move(association));
  34.             if (!result.second) {
  35.                 association.swap(result.first->second);
  36.             }
  37.         } else { // 如果value为空
  38.             auto refs_it = associations.find(disguised);
  39.             if (refs_it != associations.end()) {
  40.                 auto &refs = refs_it->second;
  41.                 auto it = refs.find(key);
  42.                 if (it != refs.end()) {
  43.                     association.swap(it->second);
  44.                     refs.erase(it);
  45.                     if (refs.size() == 0) {
  46.                         // 也会找到associations进行擦除
  47.                         associations.erase(refs_it);
  49.                     }
  50.                 }
  51.             }
  52.         }
  53.     }
  55. 	....
  56. }

2.关联对象的取值函数objc_getAssociatedObject的实现代码如下

  1. void _object_get_associative_reference(id object, const void *key) {
  2.     ObjcAssociation association{};
  4.     {
  5.         AssociationsManager manager;
  6.         
  7.         // associations是manager里面所有的AssociationsHashMap的list
  8.         AssociationsHashMap &associations(manager.get());
  9.         // 根据object在list里找到对应的那个AssociationsHashMap类型的i
  10.         AssociationsHashMap::iterator i = associations.find((objc_object *)object);
  11.         if (i != associations.end()) {
  12.             
  13.             // 再取出所有的ObjectAssociationMap的list
  14.             ObjectAssociationMap &refs = i->second;
  15.             // 根据key在list里找到对应的ObjectAssociationMap类型的j
  16.             ObjectAssociationMap::iterator j = refs.find(key);
  17.             if (j != refs.end()) {
  18.                 // 取出ObjectAssociation类型的值association
  19.                 association = j->second;
  20.                 // 取出association里的value和策略
  21.                 association.retainReturnedValue();
  22.             }
  23.         }
  24.     }
  26.     return association.autoreleaseReturnedValue();
  27. }

3.关联对象的几个类的实现关系可以用下图表示

总结：
  • 关联对象并不是存储在被关联对象本身内存中
  • 关联对象存储在全局的统一的一个AssociationsManager中
  • 设置关联对象为nil，就相当于是移除关联对象
  • 当object对象被释放，关联对象的值也会对应的从内存中移除（内存管理自动做了处理）

原文链接：http://www.cnblogs.com/funkyRay/p/ios-di-ceng-yuan-li-sancategory.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

iOS热门文章

  • snapkit更新约束崩溃的问题
  • iOS 14 UDP收不到广播处理
  • iOS开发用如何用类&quot;SKStoreProductViewController&quot;跳转AppStore点赞评分？
  • Charles抓包iPhone注意点以及SSL Proxying enabled for this host
  • 笔记：long、longlong、int、float、NSString相互转换
  • ios开发UI篇—UITextfield
  • 自定义相机碰到的问题，比如常见的拍照录制视频方向，镜像左右颠倒等问题
  • C 和 Object-C中的 #ifdef #ifndef
  • 使用Hbuilder将自己app发布到App Store（一）
  • iOS开发 - 超级签名实现之描述文件

    • iOS推荐文章

  • iOS开发基础135-Core Data
  • uniapp-vue3-oadmin手机后台实例|vite5.x+uniapp多端仿ios管理系统
  • 苹果支付有哪些坑，为什么苹果支付比支付宝和微信容易丢单？
  • 带你走进灵动岛
  • vue3+ts Axios封装—重复请求拦截
  • axios详解以及完整封装方法
  • 关于 axios 是什么？以及怎么用？
  • iOS气泡提示工具BubblePopup的使用
  • 一篇文章带你详细了解axios的封装 - 公众号-web前端进阶
  • [MAUI]模仿iOS多任务切换卡片滑动的交互实现

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号