类扩展和分类

• category：类别、分类
  • 用来给类增加方法、属性、协议
  • 不能增加成员变量，在分类的结构体中并没有存储成员变量的数据结构
  • 需要注意的如果是增加属性的话，只会增加属性的声明，并不会生成成员变量和属性的setter和getter方法。我们可以通过runtime提供的Api为类增加关联对象。
• extension：类扩展
  • 可以说是一个特殊的分类，也被称为匿名分类
  • 可以给类增加成员变量和方法，但是都是私有的
  • 类的扩展在编译时会作为类的一部分，和类一起编译进来
  • 类的扩展只是声明，依赖于当前的主类，没有.m文件，可以理解为一个·h文件
  • 我们平常在.m文件中加入的@interface XXX ()就是类扩展

关联对象

关联对象主要通过以下三个函数进行实现

• 添加关联对象

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

• 获取关联对象

id objc_getAssociatedObject(id object, const void * key)

• 移除所有的关联对象

void objc_removeAssociatedObjects(id object)

• 举个🌰来看关联对象的实现

@interface Person (Test)

@property(nonatomic, copy) NSString *name;

@end

@implementation Person (Test)

- (NSString *)name{
    return objc_getAssociatedObject(self, _cmd);
}

- (void)setName:(NSString *)name{
    objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY);
}
@end

这里key需要传入一个内存地址，可以自己定义，只要保证在setter和getter中用的是相同的key就行。最常用的方式就是使用当前getter方法的内存地址，也就是上文中的@selector(name)，_cmd是编译器特性，_cmd其实和@selector(name)等同，都是表示指向name()方法的指针。

• 使用关联对象时会用到objc_AssociationPolicy，它其实和我们OC中的属性修饰符一一对应，使用什么修饰符，取决于你定义的属性的类型，对应关系如下

objc_AssociationPolicy	修饰符
OBJC_ASSOCIATION_ASSIGN	assign
OBJC_ASSOCIATION_RETAIN_NONATOMIC	strong, nonatomic
OBJC_ASSOCIATION_COPY_NONATOMIC	copy, nonatomic
OBJC_ASSOCIATION_RETAIN	strong, atomic
OBJC_ASSOCIATION_COPY	copy, atomic

关联对象的实现原理

objc_setAssociatedObject

• 了解了关联对象的使用，接着我们通过runtime源码来更深层次的了解关联对象的实现原理。

• 首先在objc-runtime.mm文件中找到objc_setAssociatedObject函数调用

void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    SetAssocHook.get()(object, key, value, policy);
}
---------------------------------------------------------------------------
static void
_base_objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
  _object_set_associative_reference(object, key, value, policy);
}
---------------------------------------------------------------------------
static ChainedHookFunction<objc_hook_setAssociatedObject> SetAssocHook{_base_objc_setAssociatedObject};

• 再次查看_object_set_associative_reference函数，就能看到完整的设置关联对象的流程

void
_object_set_associative_reference(id object, const 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;

    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));

    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();

    {
        //关联对象的管理类
        AssociationsManager manager;
        //关联对象的哈希表，里面存放着的key为object的地址，value为ObjectAssociationMap类型的映射表
        AssociationsHashMap &associations(manager.get());

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            if (refs_result.second) {
                /* it's the first association we make */
                object->setHasAssociatedObjects();
            }

            /* establish or replace the association */
            auto &refs = refs_result.first->second;
            auto result = refs.try_emplace(key, std::move(association));
            if (!result.second) {
                association.swap(result.first->second);
            }
        } else {
            auto refs_it = associations.find(disguised);
            if (refs_it != associations.end()) {
                auto &refs = refs_it->second;
                auto it = refs.find(key);
                if (it != refs.end()) {
                    association.swap(it->second);
                    refs.erase(it);
                    if (refs.size() == 0) {
                        associations.erase(refs_it);

                    }
                }
            }
        }
    }

    // release the old value (outside of the lock).
    association.releaseHeldValue();
}

• 上述源码中，有几个非常重要的类，AssociationsManager、AssociationsHashMap、ObjectAssociationMap、ObjcAssociation

• 首先AssociationsManager是一个关联对象的管理类，它内部有一个AssociationsHashMap类型的静态变量

class AssociationsManager {
    using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
    static Storage _mapStorage;

public:
    AssociationsManager()   { AssociationsManagerLock.lock(); }
    ~AssociationsManager()  { AssociationsManagerLock.unlock(); }

    AssociationsHashMap &get() {
        return _mapStorage.get();
    }

    static void init() {
        _mapStorage.init();
    }
};

• AssociationsHashMap是一个哈希表，通过当前的object调用DISGUISE(object)来得到索引值，然后通过索引值来获取或者存放ObjectAssociationMap类型的映射表。

typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;

• ObjectAssociationMap是一个映射表，是以参数中传过来的key值作为映射表的key，以ObjcAssociation类型的对象作为映射表的value

typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;

• ObjcAssociation对象中其实只有两个属性，_policy和_value，分别对应参数中的value和policy。

class ObjcAssociation {
    uintptr_t _policy;
    id _value;
}

objc_getAssociatedObject

• 相对于objc_setAssociatedObject函数来说，objc_getAssociatedObject的实现要简单的多

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

• 查看核心函数_object_get_associative_reference的实现如下

id
_object_get_associative_reference(id object, const void *key)
{
    ObjcAssociation association{};

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            ObjectAssociationMap &refs = i->second;
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                association = j->second;
                association.retainReturnedValue();
            }
        }
    }

    return association.autoreleaseReturnedValue();
}

objc_removeAssociatedObjects

• 之前说到调用objc_setAssociatedObject函数函数时如果value传nil，就会从映射表中移除关联对象，但是这一次只能移除一个关联对象，而objc_removeAssociatedObjects函数则可以移除一个object的所有关联对象。

void objc_removeAssociatedObjects(id object) 
{
    if (object && object->hasAssociatedObjects()) {
        _object_remove_assocations(object);
    }
}

• _object_remove_assocations中就是完整的移除关联对象的操作

void
_object_remove_assocations(id object)
{
    ObjectAssociationMap refs{};

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            refs.swap(i->second);
            associations.erase(i);
        }
    }

    // release everything (outside of the lock).
    for (auto &i: refs) {
        i.second.releaseHeldValue();
    }
}

关联对象总结

• 使用runtime的Api可以在分类中为类设置关联对象。
• 关联对象并不是存放在被关联对象本身的内存中，而是存储在一个全局统一的AssociationsManager中
• 每一个类都有一个对应的映射表ObjectAssociationMap，存放在全局的哈希表AssociationsHashMap中，通过类对象的内存地址计算出哈希表的索引。

• 类的每一个关联对象的值都封装成了一个ObjectAssociation对象，存放在映射表中。

  
  image.png