关联对象使用及实现原理

关联对象 API

objc_setAssociatedObject

/** 
 * Sets an associated value for a given object using a given key and association policy.
 * 
 * @param object The source object for the association.
 * @param key The key for the association.
 * @param value The value to associate with the key key for object. Pass nil to clear an existing association.
 * @param policy The policy for the association.
 */
OBJC_EXPORT void
objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key, id _Nullable value, objc_AssociationPolicy policy);

objc_getAssociatedObject

/** 
 * Returns the value associated with a given object for a given key.
 * 
 * @param object The source object for the association.
 * @param key The key for the association.
 * 
 * @return The value associated with the key for the object.
 */
OBJC_EXPORT id _Nullable
objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key);

objc_removeAssociatedObjects

/** 
 * Removes all associations for a given object.
 * 
 * @param object An object that maintains associated objects.
 * 
 * @note The main purpose of this function is to make it easy to return an object 
 *  to a "pristine state”. You should not use this function for general removal of
 *  associations from objects, since it also removes associations that other clients
 *  may have added to the object. Typically you should use objc_setAssociatedObject 
 *  with a nil value to clear an association.
 */
OBJC_EXPORT void
objc_removeAssociatedObjects(id _Nonnull object);

objc_AssociationPolicy

/**
 * Policies related to associative references.
 * These are options to objc_setAssociatedObject()
 */
typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,           /**< Specifies a weak reference to the associated object. */
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object. 
                                            *   The association is not made atomically. */
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied. 
                                            *   The association is not made atomically. */
    OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object.
                                            *   The association is made atomically. */
    OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied.
                                            *   The association is made atomically. */
};

关联对象使用

//NSObject+AssociatedObject.h 
@interface NSObject (AssociatedObject)
@property (nonatomic, strong) id associatedObject;
@end

//NSObject+AssociatedObject.m
@implementation NSObject (AssociatedObject)

- (void)setAssociatedObject:(id)object {
     objc_setAssociatedObject(self, @selector(associatedObject), object, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (id)associatedObject {
    return objc_getAssociatedObject(self, @selector(associatedObject));
}

关联对象实现源码解析

与关联对象实现相关的类

ObjcAssociation 类

class ObjcAssociation {
    uintptr_t _policy;
    id _value;
public:
    ObjcAssociation(uintptr_t policy, id value) : _policy(policy), _value(value) {}
    ObjcAssociation() : _policy(0), _value(nil) {}

    inline uintptr_t policy() const { return _policy; }
    inline id value() const { return _value; }

    inline void swap(ObjcAssociation &other) {
        std::swap(_policy, other._policy);
        std::swap(_value, other._value);
    }

    inline void acquireValue() {
        if (_value) {
            switch (_policy & 0xFF) {
            case OBJC_ASSOCIATION_SETTER_RETAIN:
                _value = objc_retain(_value);
                break;
            case OBJC_ASSOCIATION_SETTER_COPY:
                _value = ((id(*)(id, SEL))objc_msgSend)(_value, @selector(copy));
                break;
            }
        }
    }

    inline void releaseHeldValue() {
        if (_value && (_policy & OBJC_ASSOCIATION_SETTER_RETAIN)) {
            objc_release(_value);
        }
    }

    inline void retainReturnedValue() {
        if (_value && (_policy & OBJC_ASSOCIATION_GETTER_RETAIN)) {
            objc_retain(_value);
        }
    }
};

AssociationsHashMap 与 ObjectAssociationMap

typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;

// DisguisedPtr<T> acts like pointer type T*, except the 
// stored value is disguised to hide it from tools like `leaks`.
typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;

AssociationsManager 类

spinlock_t AssociationsManagerLock;


// class AssociationsManager manages a lock / hash table singleton pair.
// Allocating an instance acquires the lock

class AssociationsManager {
    using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
    // 单例，用于获取 AssociationsHashMap
    static Storage _mapStorage;

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

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

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

// 实例化 Storage 静态对象，在 main 函数之前执行，只执行一次
AssociationsManager::Storage AssociationsManager::_mapStorage;

调用 init 方法初始化 Storage

void
_objc_associations_init()
{
    AssociationsManager::init();
}

AssociationsManager 维护着 AssociationsHashMap 和 spinlock_t
get 方法用于获取 AssociationsHashMap 对象，该对象是为关联对象哈希表，存储着运行时全部关联对象，key 为对象指针，value 为 ObjectAssociationMap 对象，即单个关联对象信息

AssociationsManager 使用方式如下：

{
    //初始化 AssociationsManager 时，调用构造方法，加锁
    AssociationsManager manager;
    AssociationsHashMap &associations(manager.get());
    AssociationsHashMap::iterator i = associations.find((objc_object *)object);
    ...
    //作用域结束时，调用析构方法，解锁
}

AssociationsManager 初始化时，会在构造方法会调用 spinlock_t 的 lock() 方法加锁，析构时会调用 unlock() 方法解锁。

setAssociatedObject 实现逻辑

objc_setAssociatedObject 方法

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

_object_set_associative_reference 方法

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    if (!object && !value) return;

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

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

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());

        if (value) {
            // refer llvm-DenseMap.h
            // Inserts key,value pair into the map if the key isn't already in the map.
            // The value is constructed in-place if the key is not in the map, otherwise
            // it is not moved.
            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();
}

getAssociatedObject 实现逻辑

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

removeAssociatedObjects 实现逻辑

objc_removeAssociatedObjects

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

_object_remove_assocations

// Unlike setting/getting an associated reference,
// this function is performance sensitive because of
// raw isa objects (such as OS Objects) that can't track
// whether they have associated objects.
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();
    }
}

关联对象与 `isa`

//TODO: 关联对象与 isa 的关系

关联对象释放时机

//TODO: 关联对象的释放时机

参考资料

ObjC

C++

内存布局与虚函数

设计模式

C++ 单例

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

关联对象使用及实现原理

关联对象 API

objc_AssociationPolicy

关联对象使用

关联对象实现源码解析

与关联对象实现相关的类

setAssociatedObject 实现逻辑

getAssociatedObject 实现逻辑

removeAssociatedObjects 实现逻辑

关联对象与 `isa`

关联对象释放时机

参考资料

ObjC

C++

内存布局与虚函数

设计模式

标准库

Python

iOS 逆向与加固

资源整理

其他

Clone this wiki locally

关联对象使用及实现原理

关联对象 API

objc_AssociationPolicy

关联对象使用

关联对象实现源码解析

与关联对象实现相关的类

setAssociatedObject 实现逻辑

getAssociatedObject 实现逻辑

removeAssociatedObjects 实现逻辑

关联对象与 isa

关联对象释放时机

参考资料

ObjC

C++

内存布局与虚函数

设计模式

标准库

Python

iOS 逆向与加固

资源整理

其他

Clone this wiki locally

关联对象与 `isa`