網站首頁 編程語言 正文
引言
在寫 Objective-C 代碼的時候，如果想給沒法獲得源碼的類增加一些方法，Category 即分類是一種很好的方法，本文將帶你了解分類是如何實現為類添加方法的。
先說結論，分類中的方法會在編譯時變成 category_t 結構體的變量，在運行時合并進主類，分類中的方法會放在主類中方法的前面，主類中原有的方法不會被覆蓋。同時，同名的分類方法，后編譯的分類方法會“覆蓋”先編譯的分類方法。
編譯時
在編譯時，所有我們寫的分類，都會轉化為 category_t 結構體的變量，category_t 的源碼如下：
struct category_t {
const char *name; // 分類名
classref_t cls; // 主類
WrappedPtr<method_list_t, PtrauthStrip> instanceMethods; // 實例方法
WrappedPtr<method_list_t, PtrauthStrip> 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;
}
};
這個結構體主要是用來存儲分類中可表現的信息，同時也從側面說明了分類是不能創建實例變量的。
運行時
map_images_nolock 是運行時的開始，同時也決定了編譯順序對分類方法之間優先級的影響，后編譯的分類方法會放在先編譯的前面：
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);
...
在運行時，加載分類的起始方法是 loadAllCategories，可以看到，該方法從 FirstHeader 開始，遍歷所有的 header_info，并依次調用 load_categories_nolock 方法，實現如下：
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 切是否初始化完成，來決定分類到底附著在哪里，其實現如下：
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); // 獲取分類對應的主類
locstamped_category_t lc{cat, hi};
if (!cls) { // 獲取不到主類（可能因為弱鏈接），跳過本次循環
// 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()) { // 如果時 stubClass，當時無法確定元類對象是哪個，所以先附著在 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()) { // 表示類對象已經初始化完畢，會進入合并方法。
attachCategories(cls, &lc, 1, ATTACH_EXISTING);
} else {
objc::unattachedCategories.addForClass(lc, cls);
}
}
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
if (cls->ISA()->isRealized()) { // 表示元類對象已經初始化完畢，會進入合并方法。
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 方法進行的，對方法、屬性和協議分別進行附著。需要注意的是，在新版的運行時方法中不是將方法放到 rw 中，而是新創建了一個叫做 rwe 的屬性，目的是為了節約內存，方法的實現如下：
// 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); // 獲取實例方法或類方法列表
if (mlist) {
if (mcount == ATTACH_BUFSIZ) { // 達到容器的容量上限時
prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__); // 準備方法列表
rwe->methods.attachLists(mlists, mcount); // 附著方法到主類中
mcount = 0;
}
mlists[ATTACH_BUFSIZ - ++mcount] = mlist; // 將分類的方法列表放入準備好的容器中
fromBundle |= entry.hi->isBundle();
}
property_list_t *proplist =
entry.cat->propertiesForMeta(isMeta, entry.hi); // 獲取對象屬性或類屬性列表
if (proplist) {
if (propcount == ATTACH_BUFSIZ) { // 達到容器的容量上限時進行附著
rwe->properties.attachLists(proplists, propcount); // 附著屬性到類或元類中
propcount = 0;
}
proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
}
protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta); // 獲取協議列表
if (protolist) {
if (protocount == ATTACH_BUFSIZ) { // 達到容器的容量上限時進行附著
rwe->protocols.attachLists(protolists, protocount); // 附著遵守的協議到類或元類中
protocount = 0;
}
protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
}
}
// 將剩余的方法、屬性和協議進行附著
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);
}
而真正進行方法附著的 attachLists 方法，其作用是將分類的方法放置到類對象或元類對象中，且放在類和元類對象原有方法的前面，這也是為什么分類和類中如果出現同名的方法，會優先調用分類的，也從側面說明了，原有的類中的方法其實并沒有被覆蓋：
void attachLists(List* const * addedLists, uint32_t addedCount) {
if (addedCount == 0) return; // 數量為 0 直接返回
if (hasArray()) {
// many lists -> many lists
uint32_t oldCount = array()->count; // 原有的方法列表的個數
uint32_t newCount = oldCount + addedCount; // 合并后的方法列表的個數
array_t *newArray = (array_t *)malloc(array_t::byteSize(newCount)); // 創建新的數組
newArray->count = newCount;
array()->count = newCount;
for (int i = oldCount - 1; i >= 0; i--)
newArray->lists[i + addedCount] = array()->lists[i]; // 將原有的方法，放到新創建的數組的最后面
for (unsigned i = 0; i < addedCount; i++)
newArray->lists[i] = addedLists[i]; // 將分類中的方法，放到數組的前面
free(array()); // 釋放原有數組的內存空間
setArray(newArray); // 將合并后的數組作為新的方法數組
validate();
}
else if (!list && addedCount == 1) { // 如果原本不存在方法列表，直接替換
// 0 lists -> 1 list
list = addedLists[0];
validate();
}
else { // 如果原來只有一個列表，變為多個，走這個邏輯
// 1 list -> many lists
Ptr<List> oldList = list;
uint32_t oldCount = oldList ? 1 : 0;
uint32_t newCount = oldCount + addedCount; // 計算所有方法列表的個數
setArray((array_t *)malloc(array_t::byteSize(newCount))); // 分配新的內存空間并賦值
array()->count = newCount;
if (oldList) array()->lists[addedCount] = oldList; // 將原有的方法，放到新創建的數組的最后面
for (unsigned i = 0; i < addedCount; i++) // 將分類中的方法，放到數組的前面
array()->lists[i] = addedLists[i];
validate();
}
}原文鏈接：https://juejin.cn/post/7129075704292966413
相關推薦
- 2022-11-30 C語言中順序棧和鏈棧的定義和使用詳解_C 語言
- 2021-12-10 k8s部署ingress-nginx的方法步驟_nginx
- 2022-01-05 webpack——Loader示例：打包css文件
- 2022-10-31 C#實現HTTP訪問類HttpHelper的示例詳解_C#教程
- 2022-05-08 Python?matplotlib實現散點圖的繪制_python
- 2022-04-24 C語言的abs()函數和div()函數你了解嗎_C 語言
- 2022-03-23 解決plsql因事務未提交造成的鎖表問題_oracle
- 2022-07-30 .NetCore使用過濾器實現登錄權限認證的方法小結_實用技巧
- 最近更新
-
- window11 系統安裝 yarn
- 超詳細win安裝深度學習環境2025年最新版（
- Linux 中運行的top命令 怎么退出？
- MySQL 中decimal 的用法？ 存儲小
- get 、set 、toString 方法的使
- @Resource和 @Autowired注解
- Java基礎操作-- 運算符，流程控制 Flo
- 1. Int 和Integer 的區別，Jav
- spring @retryable不生效的一種
- Spring Security之認證信息的處理
- Spring Security之認證過濾器
- Spring Security概述快速入門
- Spring Security之配置體系
- 【SpringBoot】SpringCache
- Spring Security之基于方法配置權
- redisson分布式鎖中waittime的設
- maven:解決release錯誤：Artif
- restTemplate使用總結
- Spring Security之安全異常處理
- MybatisPlus優雅實現加密？
- Spring ioc容器與Bean的生命周期。
- 【探索SpringCloud】服務發現-Nac
- Spring Security之基于HttpR
- Redis 底層數據結構-簡單動態字符串（SD
- arthas操作spring被代理目標對象命令
- Spring中的單例模式應用詳解
- 聊聊消息隊列，發送消息的4種方式
- bootspring第三方資源配置管理
- GIT同步修改后的遠程分支
提供CDN加速