关联对象是主要是解决在分类中无法保存成员变量的方法;
基本使用
因为category中没有存储成员变量的地方，所以只能通过关联对象的方式关联把对象和属性关联起来存储。
关联对象
在runtime中所存在的关联方法
typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
OBJC_ASSOCIATION_ASSIGN = 0,
OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,
OBJC_ASSOCIATION_COPY_NONATOMIC = 3,
OBJC_ASSOCIATION_RETAIN = 01401,
OBJC_ASSOCIATION_COPY = 01403
};
OBJC_ASSOCIATION_ASSIGN 相当于 @property (nonatomic, weak)
OBJC_ASSOCIATION_RETAIN_NONATOMIC 相当于 @property (nonatomic, strong)
OBJC_ASSOCIATION_COPY_NONATOMIC 相当于 @property (nonatomic, copy)
OBJC_ASSOCIATION_RETAIN 相当于 @property (atomic, strong)
OBJC_ASSOCIATION_COPY 相当于 @property (atomic, copy)
根据对象的特点去选择
//关联对象设置
OBJC_EXPORT void
objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
id _Nullable value, objc_AssociationPolicy policy)
//第一个参数 和那个对象关联, 第二个参数 Key(通过Key进行存取), 第三个参数 存入的值,
//第四个参数 关联策略
//获取所关联对象
OBJC_EXPORT id _Nullable
objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)
//第一个参数 和那个对象关联, 第二个参数 Key(通过Key进行存取)
//清空该对象所有的关联对象
OBJC_EXPORT void
objc_removeAssociatedObjects(id _Nonnull object)
OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);使用
static const char *K_MEMBER_VARIABLE = "KMemberVriable";//命名规则 特殊前缀+属性名
//通过key 来存储对象 类似dictionary
-(void)setMemberVribale:(NSString *)memberVribale{
objc_setAssociatedObject(self, K_MEMBER_VARIABLE, memberVribale, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
//通过key 获取关联的key
-(NSString *)memberVribale{
return objc_getAssociatedObject(self, K_MEMBER_VARIABLE);
}分析源码
设置关联对象
//关联对象设置
OBJC_EXPORT void
objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
id _Nullable value, objc_AssociationPolicy policy)
//第一个参数 和那个对象关联, 第二个参数 Key(通过Key进行存取), 第三个参数 存入的值,
//第四个参数 关联策略
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) {
//存储旧值
ObjcAssociation old_association(0, nil);
//根据关联策略进行操作 retain 增加引用计数 copy copy一份
id new_value = value ? acquireValue(value, policy) : nil;
{
//关联对象管理结构体
AssociationsManager manager;
// AssociationsHashMap 存储object对应的ObjectAssociationMap
AssociationsHashMap &associations(manager.associations());
//object 地址
disguised_ptr_t disguised_object = DISGUISE(object);
if (new_value) {
//以对象地址为key 找到对应的迭代器
AssociationsHashMap::iterator i = associations.find(disguised_object);
//object是否已经含有关联对象
if (i != associations.end()) {
//ObjectAssociationMap key对应的ObjcAssociation
ObjectAssociationMap *refs = i->second;
//根据key查找ObjcAssociation的迭代器
ObjectAssociationMap::iterator j = refs->find(key);
//ObjectAssociationMap是否为空
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).
ObjectAssociationMap *refs = new ObjectAssociationMap;
associations[disguised_object] = refs;
(*refs)[key] = ObjcAssociation(policy, new_value);
//对object中添加含有关联对象的标记
object->setHasAssociatedObjects();
}
} else {
// setting the association to nil breaks the association.
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).
//release 旧的关联对象
if (old_association.hasValue()) ReleaseValue()(old_association);
}
//上面部分结类和函数的具体实现
//ObjcAssociation
class ObjcAssociation {
uintptr_t _policy; //关联策略
id _value; // 关联对象
...
};
// 更加关联策略对对象进行处理
static id acquireValue(id value, uintptr_t policy) {
switch (policy & 0xFF) {
case OBJC_ASSOCIATION_SETTER_RETAIN:
//增加引用计数器
return objc_retain(value);
case OBJC_ASSOCIATION_SETTER_COPY:
//copy value
return ((id(*)(id, SEL))objc_msgSend)(value, SEL_copy);
}
return value;
}
//AssociationsManager 关联对象管理类
class AssociationsManager {
// associative references: object pointer -> PtrPtrHashMap.
//存储关联对象的hashMap static修饰 所有的关联对象共用
static AssociationsHashMap *_map;
public:
AssociationsManager() { AssociationsManagerLock.lock(); }
~AssociationsManager() { AssociationsManagerLock.unlock(); }
AssociationsHashMap &associations() {
if (_map == NULL)
_map = new AssociationsHashMap();
return *_map;
}
};
// has_assoc 表示该对象拥有关联对象 在对象释放的时候使用 下面会详细讲解
inline void
objc_object::setHasAssociatedObjects()
{
if (isTaggedPointer()) return;
retry:
isa_t oldisa = LoadExclusive(&isa.bits);
isa_t newisa = oldisa;
if (!newisa.nonpointer || newisa.has_assoc) {
ClearExclusive(&isa.bits);
return;
}
newisa.has_assoc = true;
if (!StoreExclusive(&isa.bits, oldisa.bits, newisa.bits)) goto retry;
}可以根据上面代码注释已经写的很详细了。
获取关联对象
OBJC_EXPORT id _Nullable
objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)
OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
id _object_get_associative_reference(id object, void *key) {
id value = nil;
uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
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();
if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
objc_retain(value);
}
}
}
}
/*
位运算 当policy是
OBJC_ASSOCIATION_RETAIN_NONATOMIC
OBJC_ASSOCIATION_COPY_NONATOMIC
OBJC_ASSOCIATION_RETAIN
OBJC_ASSOCIATION_COPY
要对value进行retain操作
*/
if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
objc_autorelease(value);
}
return value;
}移除关联对象
OBJC_EXPORT void
objc_removeAssociatedObjects(id _Nonnull object)
OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
void _object_remove_assocations(id object) {
//保存object的关联对象
vector< ObjcAssociation,ObjcAllocator<ObjcAssociation> > elements;
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
if (associations.size() == 0) return;
disguised_ptr_t disguised_object = DISGUISE(object);
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
// copy all of the associations that need to be removed.
ObjectAssociationMap *refs = i->second;
for (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
elements.push_back(j->second);
}
// remove the secondary table.
delete refs;
associations.erase(i);
}
}
// the calls to releaseValue() happen outside of the lock.
//循环 release
for_each(elements.begin(), elements.end(), ReleaseValue());
}
struct ReleaseValue {
void operator() (ObjcAssociation &association) {
releaseValue(association.value(), association.policy());
}
};objc_removeAssociatedObjects调用时机在
//释放是
void *objc_destructInstance(id obj)
{
if (obj) {
// Read all of the flags at once for performance.
bool cxx = obj->hasCxxDtor();
//判断是否obj的是否有关联对象
bool assoc = obj->hasAssociatedObjects();
// This order is important.
if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_assocations(obj);//有关联对象 remove所有关联对象
obj->clearDeallocating();
}
return obj;
}整体图解如下(不太规范)
