应用程序加载（五）-- 类扩展和关联对象

2020-10-21 本文已影响0人过气的程序员DZ

应用程序加载（一） -- dyld流程分析
 应用程序加载（二） -- dyld&objc关联以及类的加载初探
 应用程序加载（三）-- 类的加载
 应用程序加载（四）-- 分类的加载
 应用程序加载（五）-- 类扩展和关联对象

1、类扩展extension

类扩展需要对应着分类（category）比较研究。
分类的作用：

添加方法，可以添加实例方法和类方法
添加协议
添加属性（@property），只会生成getter和setter的声明，而不会生成方法的实现和带下划线的成员变量

类扩展的作用：

可以添加方法声明，需要在原类的.m中实现
可以添加属性
可以添加成员属性

扩展写法

通常在创建工程中时会有一个ViewController类或者创建自定义的UIViewController子类的时候，Xcode会在类中自动创建一个类扩展，如图：

我们经常把不想暴露的一些属性定义在这里，需要外部调用的属性写在.h文件中。

需要注意类扩展有一个位置要求，必须写在类的interface和implementation之间。写一个简单的例子，就在VierController.m文件中，写一个Person类，然后为Person添加一个类扩展。
正确的写法：

如果将类扩展写interface之前或者implementation之后，编译器会报错。
interface之前：

implementation之后：

扩展和分类的区别

分类中添加属性是没有getter和setter实现的，而扩展中是有的，我们可以通过c++层看到扩展添加属性会有什么效果。
首先在扩展中添加一个dzName属性

然后进入到ViewController.m文件所在的路径，执行xcrun -sdk iphonesimulator clang -rewrite-objc ViewController.m命令，生成ViewController.cpp文件，打开文件，搜索dzName

通过c++的代码可以看到，生成了属性对应的setter和getter方法，还有带有下划线的成员变量（_dzName）

在扩展中还写了一个ext_method方法，在c++中也能够看到

直接加入到方法列表中。这点可以说明，扩展是类的一部分，而且方法在编译期就加入到类中。

2、关联对象

上面了解了，扩展可以给类增加属性。但是分类添加属性的时候只是增加了getter和setter的声明。例如：

有如图中的分类，里面定义了一个属性cat_name。当我们调用的时候：

此时编译器是不会报错的，说明cat_name的setter方法的sel是可以找到的。当运行起来的时候，就会报错。因为找不到对应的imp。所以说分类中添加属性只是添加了getter和setter方法的声明，而没有方法的实现。

那么如何分类中的属性的实现呢？就是通过系统给我们提供的关联对象。

关联对象用法

#import <objc/runtime.h>
@interface Person (DZ)
@property (nonatomic, copy) NSString *cate_name;
@end

@implementation Person (DZ)
- (void)setCate_name:(NSString *)cate_name{
    /**
     1: 对象
     2: 标识符
     3: value
     4: 策略
     */
    objc_setAssociatedObject(self, "cate_name", cate_name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

- (NSString *)cate_name{
    return  objc_getAssociatedObject(self, "cate_name");
}
@end

分类中定义了一个属性cate_name
实现了cate_name的getter和setter方法，方法中调用了关联对象的两个方法:
- objc_setAssociatedObject：需要四个参数，分别是对象、标识符、值和关联策略
- objc_getAssociatedObject：相对简单，只有两个参数，分别是对象和标识符
- 注意，使用关联对象要引入runtime的头文件

用法很容易，但是底层是如何实现的呢？接下来我们来探索一下底层实现。

关联对象的底层实现

还是在objc的源码中，可以看到相关源码，先来看看关联对象的set实现：

关联对象set

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

此处与以往的objc开源代码不同，在“781”的这个版本的源码中，增加了一层代码封装，通过command点击SetAssocHook，能够看到这行代码：static ChainedHookFunction<objc_hook_setAssociatedObject> SetAssocHook{_base_objc_setAssociatedObject};
底层调用的就是_base_objc_setAssociatedObject函数

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

_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
    //1、相关的容错处理
    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));
    //2、包装了一下 对象
    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    //3、 包装一下 policy - value
    ObjcAssociation association{policy, value};

    //4、根据关联策略对值处理
    // retain the new value (if any) outside the lock.
    association.acquireValue();
    
    // 5、核心代码
    {
        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();
}

首先代码进行了相关的容错处理，这些不用关心，简单看看就好
将传入的参数object进行了一次包装。
对第三个参数value和第四个参数policy包装一下。

association.acquireValue();根据关联策略（policy参数），对值进行处理，看看源码实现：

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

此处根据关联策略对value进行retain或者copy的操作。

此处进入核心代码部分

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

                }
            }
        }
    }
}

初始化一个AssociationsManager变量manager，它不是一个单例，只是用它来给下面访问哈希表进行加锁

构造函数和析构函数就是加锁解锁操作。
- 通过manager.get()函数获取到关联对象的哈希表的引用&associations，类型是AssociationsHashMap
- 判断value存在时：
- 从哈希表中读取disguised对应的结果refs_result。disguised就是传入的object参数。
- 通过结果refs_result中的second判断是不是第一次来。如果第一次来就会调用object->setHasAssociatedObjects();函数
- setHasAssociatedObjects就是给对象object设置状态。代表这个对象是有关联对象存在的。如果object是nonpointer，那么这个关联状态就存储在isa中
- 然后根据参数key创建关联，如果之前关联过就进行替换关联。
- 此处就可以知道，是两层哈希表。第一层是以对象作为哈希函数，第二层是以闯入的参数key为哈希函数。
- value不存在时：传入的参数value为nil。就进行擦除。因为是双层哈希，所以得做两层擦除。

关联对象set流程图：

关联对象get

此时对关联对象的set有所了解了，再看看get实现就很简单，就是通过传入的两个参数，进行哈希的双层查找。源码如下：

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

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

关联对象双层哈希示意图

图中包含示例中的关联对象例子

关联对象表的移除

表的创建我们了解后，就得看看什么时候对表进行移除操作的。移除是在dealloc中处理的，看看源码：

- (void)dealloc {
    _objc_rootDealloc(self);
}

⏬⏬⏬

void
_objc_rootDealloc(id obj)
{
    ASSERT(obj);

    obj->rootDealloc();
}

⏬⏬⏬

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;  // fixme necessary?

    if (fastpath(isa.nonpointer  &&  
                 !isa.weakly_referenced  &&  
                 !isa.has_assoc  &&  
                 !isa.has_cxx_dtor  &&  
                 !isa.has_sidetable_rc))
    {
        assert(!sidetable_present());
        free(this);
    } 
    else {
        object_dispose((id)this);
    }
}

⏬⏬⏬

id 
object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

⏬⏬⏬

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        obj->clearDeallocating();
    }

    return obj;
}

⏬⏬⏬

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

通过代码的层层调用，最后调用到_object_remove_assocations函数
在_object_remove_assocations函数中，找到object为key的关联对象表（第二层哈希表），然后对表进行所有数据擦除