在面试中有时候会被问到类拓展与分类的区别，我相信大多数开发者都能够答出类拓展可以添加属性而分类不可以，但是细究下去，具体的原因是什么呢，可能有部分开发者并不清楚，这次我们就来研究一下。

类拓展

在之前我们研究过类的加载，知道成员变量ivars是在编译期就确定了的，在ro中可以拿到，所以我们只需要创建一个类拓展并设置属性，查看源码在类的加载中能否从ro中拿到对应的属性，通过这种方法就可以确定类拓展是在什么时候加载的。

我们在类拓展文件中设置两个属性：

@property (nonatomic, copy) NSString *ext_name;
@property (nonatomic, copy) NSString *ext_subject;

然后在源码的read_images中打一个断点：

其中自己加了一步对比用来判断是我们自己写的这个类，运行程序然后在控制台操作可以看到如下结果：

我们可以看到在ro中已经有了我们设置的属性，其实对应的成员变量ivar和getter/setter方法也都有了，通过lldb调试都可以看的到。

通过这个例子我们可以得出结论：类拓展在编译时会作为类的一部分编译到相应的数据段中。

关联对象

通过上面的研究我们知道了为什么类拓展可以添加属性而分类不能，那么分类就完全不能够添加属性吗？答案是NO，分类可以通过运行时来向类中添加属性，这就需要通过runtime的关联对象objc_setAssociatedObject和objc_getAssociatedObject来处理了，我相信这两个函数大家并不陌生，所以这里主要还是探究其原理。

查看其源码：

void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) {
    _object_set_associative_reference(object, (void *)key, value, policy);
}

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // This code used to work when nil was passed for object and key. Some code
    // probably relies on that to not crash. Check and handle it explicitly.
    // rdar://problem/44094390
    if (!object && !value) return;
    
    assert(object);
    
    if (object->getIsa()->forbidsAssociatedObjects())
        _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
    
    // retain the new value (if any) outside the lock.
    // 在锁之外保留新值（如果有）。
    ObjcAssociation old_association(0, nil);
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        // 关联对象的管理类
        AssociationsManager manager;
        // 获取关联的 HashMap -> 存储当前关联对象
        AssociationsHashMap &associations(manager.associations());
        // 对当前的对象的地址做按位取反操作 - 就是 HashMap 的key (哈希函数)
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
            // break any existing association.
            // 获取 AssociationsHashMap 的迭代器 - (对象的) 进行遍历
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                ObjectAssociationMap *refs = i->second;
                // 根据key去获取关联属性的迭代器
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    // 替换设置新值
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    // 到最后了 - 直接设置新值
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
                // create the new association (first time).
                // 如果AssociationsHashMap从没有对象的关联信息表，
                // 那么就创建一个map并通过传入的key把value存进去
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // setting the association to nil breaks the association.
            // 如果传入的value是nil，并且之前使用相同的key存储过关联对象，
            // 那么就把这个关联的value移除（这也是为什么传入nil对象能够把对象的关联value移除）
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i !=  associations.end()) {
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    refs->erase(j);
                }
            }
        }
    }
    // release the old value (outside of the lock).
    // 最后把之前使用传入的这个key存储的关联的value释放（OBJC_ASSOCIATION_SETTER_RETAIN策略存储的）
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

我根据自己的理解写了比较详细的注释，这里再总结一下：

首先是有一个关联对象的管理者AssociationsManager。
通过这个管理者获取一个存储所有对象关联表ObjectAssociationMap的大表AssociationsHashMap。
遍历AssociationsHashMap，以对象为key去找对应的ObjectAssociationMap：
- 如果找到了，遍历ObjectAssociationMap，以属性为key去查找对应的值：
  - 找到了则调用ObjcAssociation直接设置新值和关联策略。
  - 遍历到表尾也没找到则使用对应的key去调用ObjcAssociation来存储值和关联策略。
- 如果遍历到表尾也没找到，则直接创建一张新的关联对象表，并把这张表同当前新对象关联起来，存入AssociationsHashMap中，然后同样通过对应的key调用ObjcAssociation把值和关联策略存储起来。

这里还有一点值得注意，就是我们如果传入的值为nil并且之前使用相同的key存储过关联对象，那么就会把这个关联的value移除，这也是为什么传入nil对象能够把对象的关联value移除。

以上就是objc_setAssociatedObject的源码流程与分析了。objc_getAssociatedObject也是差不多的，这里就不做详细讲解了，直接看源码：

id objc_getAssociatedObject(id object, const void *key) {
    return _object_get_associative_reference(object, (void *)key);
}

id _object_get_associative_reference(id object, void *key) {
    id value = nil;
    uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
    {
        // 关联对象的管理类
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        // 生成伪装地址。处理参数 object 地址
        disguised_ptr_t disguised_object = DISGUISE(object);
        // 所有对象关联表的迭代器
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            ObjectAssociationMap *refs = i->second;
            // 对应对象关联表的迭代器
            ObjectAssociationMap::iterator j = refs->find(key);
            if (j != refs->end()) {
                // 找到 - 把值和策略读取出来
                ObjcAssociation &entry = j->second;
                value = entry.value();
                policy = entry.policy();
                // OBJC_ASSOCIATION_GETTER_RETAIN - 就会持有一下
                if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
                    objc_retain(value);
                }
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        objc_autorelease(value);
    }
    return value;
}

以上就是关联对象的原理分析了。

iOS开发 — 类拓展&关联对象

类拓展

关联对象