Category详解(三)—— 源码层面解析关联对象

442 阅读4分钟

问题

首先来思考几个问题:

  1. 定义@property的时候做了系统为我们做了哪些事情?
  2. 我们能不能在分类中定义@property?
  3. 如果不能的话,怎么想办法实现?

@property

定义@property时做了哪些事情

先来回答第一个问题,定义@property的事情,系统为我们做了以下事情:

  1. 生成了属性 _property
  2. 声明了 getter 和 setter
  3. 实现了 getter 和 setter

Category中是否可以定义@property

我们可以尝试在分类中 定义 @property,会发现,getter 和 setter 仅仅是被声明,但是没有实现,而且成员变量 _property 也没有被声明。

那我们可以尝试自己声明 _property 并且重写 getter 和 setter,发现无法声明 _property,会报错。

因此可以得出结论:Category中无法定义@property

结构体

我们看一下 category_t 这个结构体

struct category_t {
    const char *name;
    classref_t cls;
    struct method_list_t *instanceMethods;
    struct method_list_t *classMethods;
    struct protocol_list_t *protocols;
    struct property_list_t *instanceProperties;
    // Fields below this point are not always present on disk.
    struct property_list_t *_classProperties;
 
    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }
 
    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
     
    protocol_list_t *protocolsForMeta(bool isMeta) {
        if (isMeta) return nullptr;
        else return protocols;
    }
};

很明显可以看出,这里没有存储成员变量的地方。

Getters & Setters

如果我们定义了一个 @property,然后直接对其进行赋值或者取值操作,程序会直接崩溃。

崩溃的原因是 unrecognized selector,可见 get 和 set 方法并没有被实现。

关联对象

用法

如果需要在分类中使用 @property,最简单的方法就是使用关联对象,大致用法如下:
这里对用法不作过多的介绍,不了解的同学可以自行查阅

- (NSString *)personParam {
    return objc_getAssociatedObject(self, _cmd);
}
 
- (void)setPersonParam:(NSString *)personParam {
    objc_setAssociatedObject(self, @selector(personParam), personParam, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

接下来我们还是从源码入手,解析一下原理

set方法原理

首先我们找到 objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) 函数,发现最后的实现调用的是 _object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)

这个函数。我们点进去一探究竟。

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
   // 防止crash
   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));

   // 这里对 objc_object 进行了一次封装,
   DisguisedPtr<objc_object> disguised{(objc_object *)object};
   ObjcAssociation association{policy, value};

   // retain the new value (if any) outside the lock.
   // 调用 retain 或者 copy 等
   association.acquireValue();

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

可以看出,存储关联对象的结构应该是 Map。

这里的代码较为复杂,我们可以换个思路,先把一些核心的类和结构体进行一次解析。我们可以找到几个关键的类

  1. AssociationsManager
  2. AssociationsHashMap
  3. ObjectAssociationMap
  4. ObjcAssociation

AssociationsManager

上文中声明了一个 AssociationsManager 类型的变量 manager,并且调用了 get() 方法,我们进入该类

class AssociationsManager {
    using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
    static Storage _mapStorage;
 
public:
    // 这里可以看到,在该对象的生命周期范围内,是加了锁的
    AssociationsManager()   { AssociationsManagerLock.lock(); }
    ~AssociationsManager()  { AssociationsManagerLock.unlock(); }
 
    // 这里是get方法,我们可以看到返回值是AssociationsHashMap类型
    AssociationsHashMap &get() {
        return _mapStorage.get();
    }
 
    static void init() {
        _mapStorage.init();
    }
};

AssociationsHashMap

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

ObjcAssociation

这个类的实现比较多,我们先看其中一部分


class ObjcAssociation {
    uintptr_t _policy;
    id _value;
public:
 
};

这两个值就非常眼熟了,就是我们调用runtime的api的时候传进来的 policy 和 value。

大致结构

至此,我们可以梳理一下大致的结构了:


get方法原理

同样的我们从runtime源码入手,搜索 objc_getAssociatedObject(id object, const void *key),最终会进入 id _object_get_associative_reference(id object, const void *key) 这个函数,让我们去这个函数里一探究竟。

id
_object_get_associative_reference(id object, const void *key)
{
    ObjcAssociation association{};
 
    {
        // 又是我们熟悉的manager
        AssociationsManager manager;
        // 又是我们熟悉的AssicuationsHashMap
        AssociationsHashMap &associations(manager.get());
        // 这里利用迭代器,先找到 object 对应的ObjectAssociationMap
        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();
}

很简单就可以看出,他是一层一层,取出最终的value,然后 return 出去。

写在后面

至此,Category 的系列文章都已经写完了,相信大家对分类都已经有了一个比较深的认识。但是希望大家可以多多上手,只有实践过才能把知识转化为自己的。

文中如有错误,欢迎指出。