Objective-C之怎么使用Category實(shí)現(xiàn)分類

本篇內(nèi)容主要講解“Objective-C之怎么使用Category實(shí)現(xiàn)分類”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實(shí)用性強(qiáng)。下面就讓小編來帶大家學(xué)習(xí)“Objective-C之怎么使用Category實(shí)現(xiàn)分類”吧!

引言

在寫 Objective-C 代碼的時(shí)候，如果想給沒法獲得源碼的類增加一些方法，Category 即分類是一種很好的方法，本文將帶你了解分類是如何實(shí)現(xiàn)為類添加方法的。

先說結(jié)論，分類中的方法會在編譯時(shí)變成 category_t 結(jié)構(gòu)體的變量，在運(yùn)行時(shí)合并進(jìn)主類，分類中的方法會放在主類中方法的前面，主類中原有的方法不會被覆蓋。同時(shí)，同名的分類方法，后編譯的分類方法會“覆蓋”先編譯的分類方法。

編譯時(shí)

在編譯時(shí)，所有我們寫的分類，都會轉(zhuǎn)化為 category_t 結(jié)構(gòu)體的變量，category_t 的源碼如下：

struct category_t {
    const char *name; // 分類名
    classref_t cls; // 主類
    WrappedPtr<method_list_t, PtrauthStrip> instanceMethods; // 實(shí)例方法
    WrappedPtr<method_list_t, PtrauthStrip> classMethods; // 類方法
    struct protocol_list_t *protocols; // 協(xié)議
    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;
    }
};

這個(gè)結(jié)構(gòu)體主要是用來存儲分類中可表現(xiàn)的信息，同時(shí)也從側(cè)面說明了分類是不能創(chuàng)建實(shí)例變量的。

運(yùn)行時(shí)

map_images_nolock 是運(yùn)行時(shí)的開始，同時(shí)也決定了編譯順序?qū)Ψ诸惙椒ㄖg優(yōu)先級的影響，后編譯的分類方法會放在先編譯的前面：

void 
map_images_nolock(unsigned mhCount, const char * const mhPaths[],
                  const struct mach_header * const mhdrs[])
{
    ...
    {
        uint32_t i = mhCount;
        while (i--) { // 讀取 header_info 的順序，決定了后編譯的分類方法會放在先編譯的前面
            const headerType *mhdr = (const headerType *)mhdrs[i];
            auto hi = addHeader(mhdr, mhPaths[i], totalClasses, unoptimizedTotalClasses);
    ...

在運(yùn)行時(shí)，加載分類的起始方法是 loadAllCategories，可以看到，該方法從 FirstHeader 開始，遍歷所有的 header_info，并依次調(diào)用 load_categories_nolock 方法，實(shí)現(xiàn)如下：

static void loadAllCategories() {
    mutex_locker_t lock(runtimeLock);
    for (auto *hi = FirstHeader; hi != NULL; hi = hi->getNext()) {
        load_categories_nolock(hi);
    }
}

在 load_categories_nolock 方法中，會判斷類是不是 stubClass 切是否初始化完成，來決定分類到底附著在哪里，其實(shí)現(xiàn)如下：

static void load_categories_nolock(header_info *hi) {
    // 是否具有類屬性
    bool hasClassProperties = hi->info()->hasCategoryClassProperties();
    size_t count;
    auto processCatlist = [&](category_t * const *catlist) { // 獲取需要處理的分類列表
        for (unsigned i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls); // 獲取分類對應(yīng)的主類
            locstamped_category_t lc{cat, hi};
            if (!cls) { // 獲取不到主類（可能因?yàn)槿蹑溄樱^本次循環(huán)
                // Category's target class is missing (probably weak-linked).
                // Ignore the category.
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class",
                                 cat->name, cat);
                }
                continue;
            }
            // Process this category.
            if (cls->isStubClass()) { // 如果時(shí) stubClass，當(dāng)時(shí)無法確定元類對象是哪個(gè)，所以先附著在 stubClass 本身上
                // Stub classes are never realized. Stub classes
                // don't know their metaclass until they're
                // initialized, so we have to add categories with
                // class methods or properties to the stub itself.
                // methodizeClass() will find them and add them to
                // the metaclass as appropriate.
                if (cat->instanceMethods ||
                    cat->protocols ||
                    cat->instanceProperties ||
                    cat->classMethods ||
                    cat->protocols ||
                    (hasClassProperties && cat->_classProperties))
                {
                    objc::unattachedCategories.addForClass(lc, cls);
                }
            } else {
                // First, register the category with its target class.
                // Then, rebuild the class's method lists (etc) if
                // the class is realized.
                if (cat->instanceMethods ||  cat->protocols
                    ||  cat->instanceProperties)
                {
                    if (cls->isRealized()) { // 表示類對象已經(jīng)初始化完畢，會進(jìn)入合并方法。
                        attachCategories(cls, &lc, 1, ATTACH_EXISTING);
                    } else {
                        objc::unattachedCategories.addForClass(lc, cls);
                    }
                }
                if (cat->classMethods  ||  cat->protocols
                    ||  (hasClassProperties && cat->_classProperties))
                {
                    if (cls->ISA()->isRealized()) { // 表示元類對象已經(jīng)初始化完畢，會進(jìn)入合并方法。
                        attachCategories(cls->ISA(), &lc, 1, ATTACH_EXISTING | ATTACH_METACLASS);
                    } else {
                        objc::unattachedCategories.addForClass(lc, cls->ISA());
                    }
                }
            }
        }
    };
    processCatlist(hi->catlist(&count));
    processCatlist(hi->catlist2(&count));
}

合并分類的方法是通過 attachCategories 方法進(jìn)行的，對方法、屬性和協(xié)議分別進(jìn)行附著。需要注意的是，在新版的運(yùn)行時(shí)方法中不是將方法放到 rw 中，而是新創(chuàng)建了一個(gè)叫做 rwe 的屬性，目的是為了節(jié)約內(nèi)存，方法的實(shí)現(xiàn)如下：

// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order, 
// oldest categories first.
static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
                 int flags)
{
    if (slowpath(PrintReplacedMethods)) {
        printReplacements(cls, cats_list, cats_count);
    }
    if (slowpath(PrintConnecting)) {
        _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",
                     cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",
                     cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");
    }
    /*
     * Only a few classes have more than 64 categories during launch.
     * This uses a little stack, and avoids malloc.
     *
     * Categories must be added in the proper order, which is back
     * to front. To do that with the chunking, we iterate cats_list
     * from front to back, build up the local buffers backwards,
     * and call attachLists on the chunks. attachLists prepends the
     * lists, so the final result is in the expected order.
     */
    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];
    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    bool isMeta = (flags & ATTACH_METACLASS); // 是否是元類對象
    auto rwe = cls->data()->extAllocIfNeeded(); // 為 rwe 生成分配存儲空間
    for (uint32_t i = 0; i < cats_count; i++) { // 遍歷分類列表
        auto& entry = cats_list[i];
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta); // 獲取實(shí)例方法或類方法列表
        if (mlist) {
            if (mcount == ATTACH_BUFSIZ) { // 達(dá)到容器的容量上限時(shí)
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__); // 準(zhǔn)備方法列表
                rwe->methods.attachLists(mlists, mcount); // 附著方法到主類中
                mcount = 0;
            }
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist; // 將分類的方法列表放入準(zhǔn)備好的容器中
            fromBundle |= entry.hi->isBundle();
        }
        property_list_t *proplist =
            entry.cat->propertiesForMeta(isMeta, entry.hi); // 獲取對象屬性或類屬性列表
        if (proplist) {
            if (propcount == ATTACH_BUFSIZ) { // 達(dá)到容器的容量上限時(shí)進(jìn)行附著
                rwe->properties.attachLists(proplists, propcount); // 附著屬性到類或元類中
                propcount = 0;
            }
            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
        }
        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta); // 獲取協(xié)議列表
        if (protolist) {
            if (protocount == ATTACH_BUFSIZ) { // 達(dá)到容器的容量上限時(shí)進(jìn)行附著
                rwe->protocols.attachLists(protolists, protocount); // 附著遵守的協(xié)議到類或元類中
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }
    // 將剩余的方法、屬性和協(xié)議進(jìn)行附著
    if (mcount > 0) {
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
                           NO, fromBundle, __func__);
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
        if (flags & ATTACH_EXISTING) {
            flushCaches(cls, __func__, [](Class c){
                // constant caches have been dealt with in prepareMethodLists
                // if the class still is constant here, it's fine to keep
                return !c->cache.isConstantOptimizedCache();
            });
        }
    }
    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);
    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}

而真正進(jìn)行方法附著的 attachLists 方法，其作用是將分類的方法放置到類對象或元類對象中，且放在類和元類對象原有方法的前面，這也是為什么分類和類中如果出現(xiàn)同名的方法，會優(yōu)先調(diào)用分類的，也從側(cè)面說明了，原有的類中的方法其實(shí)并沒有被覆蓋：

void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return; // 數(shù)量為 0 直接返回
        if (hasArray()) {
            // many lists -> many lists
            uint32_t oldCount = array()->count; // 原有的方法列表的個(gè)數(shù)
            uint32_t newCount = oldCount + addedCount; // 合并后的方法列表的個(gè)數(shù)
            array_t *newArray = (array_t *)malloc(array_t::byteSize(newCount)); // 創(chuàng)建新的數(shù)組
            newArray->count = newCount;
            array()->count = newCount;
            for (int i = oldCount - 1; i >= 0; i--)
                newArray->lists[i + addedCount] = array()->lists[i]; // 將原有的方法，放到新創(chuàng)建的數(shù)組的最后面
            for (unsigned i = 0; i < addedCount; i++)
                newArray->lists[i] = addedLists[i]; // 將分類中的方法，放到數(shù)組的前面
            free(array()); // 釋放原有數(shù)組的內(nèi)存空間
            setArray(newArray); // 將合并后的數(shù)組作為新的方法數(shù)組
            validate();
        }
        else if (!list  &&  addedCount == 1) { // 如果原本不存在方法列表，直接替換
            // 0 lists -> 1 list
            list = addedLists[0];
            validate();
        } 
        else { // 如果原來只有一個(gè)列表，變?yōu)槎鄠€(gè)，走這個(gè)邏輯
            // 1 list -> many lists
            Ptr<List> oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount; // 計(jì)算所有方法列表的個(gè)數(shù)
            setArray((array_t *)malloc(array_t::byteSize(newCount))); // 分配新的內(nèi)存空間并賦值
            array()->count = newCount;
            if (oldList) array()->lists[addedCount] = oldList; // 將原有的方法，放到新創(chuàng)建的數(shù)組的最后面
            for (unsigned i = 0; i < addedCount; i++) // 將分類中的方法，放到數(shù)組的前面
                array()->lists[i] = addedLists[i]; 
            validate();
        }
    }

到此，相信大家對“Objective-C之怎么使用Category實(shí)現(xiàn)分類”有了更深的了解，不妨來實(shí)際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！