
本文授權轉載,作者:楚天舒(簡書)
從 C 的面向過程過渡到 Objective-C 的物件與消息,初學階段總有那種「知其然不知其所以然」的糾結。相關教學大多是「有什麼」加「使用步驟一二三四」的套路,讀完仍然不清楚本質是什麼、能幹什麼、不能幹什麼、為什麼要選它。而真實的開發過程恰恰相反:先有要解決的問題,再去找實現手段。人腦更容易接受的,也是從主幹到分支的思維導圖式結構,綱舉目張。所以這裡嘗試用自己的粗淺理解,寫一點關於 Objective-C 運行時的東西。
代碼設計的思想,大致就是把重複且不變的部分封裝成可復用的共性,把易變的部分拆成獨立鬆耦合的變量。這些可以是數據類型,也可以是實現功能的代碼片段。類本身就是封裝的產物,同時也是被封裝的對象。被封裝起來的內容要能被找到並執行,就需要給它們加上關聯的映射標識:索引(數組)、字符串(字典)、指針、SEL(方法代號)、isa(物件)等等。一句話概括:用類和物件封裝父類指針與方法列表,再通過映射定位到真正的實現代碼。
主線思路:
實例物件 instance → 類 class → 方法 method(→ SEL → IMP)→ 實現函數
實例物件只保存 isa 指針和實例變量,通過 isa 找到所屬類;類維護一份運行時可接收的方法列表。方法列表裡每個條目是一個 Method,key 是特定名稱即選擇器 SEL,對應一個指向底層 C 實現函數的指針即 IMP。整套機制最核心的是 objc_msgSend 函數:給 target(類)發送 selector 傳遞消息,找到匹配的 IMP,最終指向真正的 C 函數。
得益於運行時的動態特性,編譯完成之後仍可在運行時通過 C 函數動態創建、修改類信息,動態綁定方法、重寫實現,靈活地做出各種自定義能力。
下面先列個目錄:
一、Runtime 介紹
二、類的本質(數據結構與操作函數)
三、動態實現:Method Swizzling、ISA Swizzling
四、其他概念:category、super 等
作用:在程式運行時操作編譯後的代碼,可以動態地創建、修改、內省「類」與「方法」,並完成消息傳遞。所有能力都圍繞這兩個中心:類的動態配置,以及消息傳遞。前者靠各類操作函數完成,後者靠 objc_msgSend 完成。
本質:libobjc.dylib,由 C 和匯編寫成(消息傳遞機制部分用匯編實現)。
數據結構上,Class 就是一個結構體。在 objc/runtime.h 中可以看到它的成員:
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE; // 父類
const char *name OBJC2_UNAVAILABLE; // 類名
long version OBJC2_UNAVAILABLE; // 類的版本信息,默認為 0
long info OBJC2_UNAVAILABLE; // 類信息,供運行期使用的一些位標識
long instance_size OBJC2_UNAVAILABLE; // 類的實例變量大小
struct objc_ivar_list *ivars OBJC2_UNAVAILABLE; // 成員變量鏈表
struct objc_method_list **methodLists OBJC2_UNAVAILABLE; // 方法定義的鏈表
struct objc_cache *cache OBJC2_UNAVAILABLE; // 方法緩存
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE; // 協議鏈表
#endif
} OBJC2_UNAVAILABLE;isa 與 super_class
不同的類中允許存在同名方法(同一個類內則不行,哪怕參數類型不同),所以調用時必須先確定是哪個類。isa 和 super_class 就是定位實現函數的關鍵映射:isa 用於自省確定所屬類,super_class 確定繼承關係。
實例物件的 isa 指向類,類的 isa 指向其元類(metaClass)。物件本質上就是一個含 isa 指針的結構體:
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
typedef struct objc_object *id;創建實例時,分配的內存包含一個 objc_object 結構,隨後依次是從類到父類、直到根類 NSObject 的實例變量。NSObject 的 alloc 與 allocWithZone: 內部調用 class_createInstance 來創建 objc_object。
向物件發送消息時,運行時庫先依據 isa 找到所屬類,再沿 super_class 一層層向上,直到根類 NSObject,在方法列表中尋找與 selector 匹配的方法,找到後執行。

上圖是 isa 與 super_class 指針的關係示意:
1、isa:實例物件 → 類 → 元類 →(不經過父元類)直接到根元類(NSObject 的元類),根元類的 isa 指向自己;
2、super_class:類 → 父類 → … → 根類 NSObject;元類 → 父元類 → … → 根元類 → 根類。NSObject 的 superclass 指向 nil。
操作函數命名規律:類對象以 class_ 為前綴,實例物件以 object_ 為前綴。
get:類名、父類、元類、實例變量、成員變量、屬性、實例方法、類方法、方法實現
// 獲取類的類名 const char * class_getName (Class cls); // 獲取類的父類 Class class_getSuperclass (Class cls); // 獲取實例大小 size_t class_getInstanceSize (Class cls); // 獲取類中指定名稱實例成員變量的信息 Ivar class_getInstanceVariable (Class cls, const char *name); // 獲取類成員變量的信息 Ivar class_getClassVariable (Class cls, const char *name); // 獲取指定的屬性 objc_property_t class_getProperty (Class cls, const char *name); // 獲取實例方法 Method class_getInstanceMethod (Class cls, SEL name); // 獲取類方法 Method class_getClassMethod (Class cls, SEL name); // 獲取方法的具體實現 IMP class_getMethodImplementation (Class cls, SEL name); IMP class_getMethodImplementation_stret (Class cls, SEL name);
copy:成員變量列表、屬性列表、方法列表、協議列表
// 獲取整個成員變量列表 Ivar * class_copyIvarList (Class cls, unsigned int *outCount); // 獲取屬性列表 objc_property_t * class_copyPropertyList (Class cls, unsigned int *outCount); // 獲取所有方法的列表 Method * class_copyMethodList (Class cls, unsigned int *outCount); // 獲取類實現的協議列表 Protocol * class_copyProtocolList (Class cls, unsigned int *outCount);
add:成員變量、屬性、方法、協議(添加成員變量只能在運行時創建的類上進行,且不能是元類)
// 添加成員變量 BOOL class_addIvar (Class cls, const char *name, size_t size, uint8_t alignment, const char *types); // 添加屬性 BOOL class_addProperty (Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount); // 添加方法 BOOL class_addMethod (Class cls, SEL name, IMP imp, const char *types); // 添加協議 BOOL class_addProtocol (Class cls, Protocol *protocol);
replace:替換屬性、替換方法實現
// 替換類的屬性 void class_replaceProperty (Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount); // 替代方法的實現 IMP class_replaceMethod (Class cls, SEL name, IMP imp, const char *types);
內省相關:判斷是否響應某個 selector、是否為元類、是否遵循某協議
// 類實例是否響應指定的 selector BOOL class_respondsToSelector (Class cls, SEL sel); // 判斷給定的 Class 是否是一個元類 BOOL class_isMetaClass (Class cls); // 返回類是否實現指定的協議 BOOL class_conformsToProtocol (Class cls, Protocol *protocol);
get:實例變量、類名、類、元類、關聯物件
// 獲取對象實例變量 Ivar object_getInstanceVariable (id obj, const char *name, void **outValue); // 獲取對象中實例變量的值 id object_getIvar (id obj, Ivar ivar); // 獲取對象的類名 const char * object_getClassName (id obj); // 獲取對象的類 Class object_getClass (id obj); Class objc_getClass (const char *name); // 返回指定類的元類 Class objc_getMetaClass (const char *name); // 獲取關聯對象 id objc_getAssociatedObject(self, &myKey);
copy:對象、類列表
// 獲取指定對象的一份拷貝 id object_copy (id obj, size_t size); // 創建並返回一個指向所有已註冊類的指針列表 Class * objc_copyClassList (unsigned int *outCount);
set:實例變量、關聯物件
// 設置類實例的實例變量的值 Ivar object_setInstanceVariable (id obj, const char *name, void *value); // 設置對象中實例變量的值 void object_setIvar (id obj, Ivar ivar, id value); // 設置關聯對象 void objc_setAssociatedObject(self, &myKey, anObject, OBJC_ASSOCIATION_RETAIN);
dispose:
// 釋放指定對象占用的內存 id object_dispose ( id obj );
動態創建/銷毀類與物件:
// 創建一個新類和元類 Class objc_allocateClassPair (Class superclass, const char *name, size_t extraBytes); // 銷毀一個類及其相關聯的類 void objc_disposeClassPair (Class cls); // 在應用中註冊由 objc_allocateClassPair 創建的類 void objc_registerClassPair (Class cls); // 創建類實例 id class_createInstance (Class cls, size_t extraBytes); // 在指定位置創建類實例 id objc_constructInstance (Class cls, void *bytes); // 銷毀類實例 void * objc_destructInstance (id obj);
屬性的意義在於讓其他物件方便地訪問實例變量,同時可以拓展其作用範圍;可只讀可寫,存取方法也能自定義。
typedef struct objc_ivar *Ivar;
struct objc_ivar {
char *ivar_name OBJC2_UNAVAILABLE; // 變量名
char *ivar_type OBJC2_UNAVAILABLE; // 變量類型
int ivar_offset OBJC2_UNAVAILABLE; // 基地址偏移字節
#ifdef __LP64__
int space OBJC2_UNAVAILABLE;
#endif
}typedef struct objc_property *objc_property_t;
屬性特性 objc_property_attribute_t 包含:返回值、是否 atomic、getter/setter 名字、是否 dynamic、背後使用的 ivar 名字、是否弱引用等。
typedef struct {
const char *name; // 特性名
const char *value; // 特性值
} objc_property_attribute_t;ivar_ 系列:
// 獲取成員變量名 const char * ivar_getName(Ivar v); // 獲取成員變量類型編碼 const char * ivar_getTypeEncoding(Ivar v); // 獲取成員變量的偏移量 ptrdiff_t ivar_getOffset (Ivar v);
property_ 系列:
// 獲取屬性名 const char * property_getName (objc_property_t property); // 獲取屬性特性描述字符串 const char * property_getAttributes (objc_property_t property); // 獲取屬性中指定的特性 char * property_copyAttributeValue (objc_property_t property, const char *attributeName); // 獲取屬性的特性列表 objc_property_attribute_t * property_copyAttributeList (objc_property_t property, unsigned int *outCount);
消息傳遞機制是 Runtime 的核心,也就是消息分派器 objc_msgSend。先厘清幾個概念。
SEL:又稱選擇器,是映射方法名字的指針。Objective-C 在編譯時會依據每個方法的名字與參數序列,生成唯一的整型標識,這就是 SEL。它的作用是作為 IMP 的 KEY 存起來,便於快速哈希查詢。SEL 不能相同,但對應的方法可以不同——所以在同一個類及其繼承體系中,不能存在兩個同名方法,哪怕參數類型不同;反過來,多個方法可以共用同一個 SEL。不同類的實例執行相同 selector 時,會各自在自己的方法列表中查找對應的 IMP。
相關概念是類型編碼(Type Encoding):編譯器把每個方法的返回值與參數類型編碼成一個字符串,並與 selector 關聯,可用 @encode 指令獲取。
typedef struct objc_selector *SEL;
objc_selector 的結構體成員並未公開,但從 log 可以看出 SEL 本質是個字符串。
IMP:指向實現函數的指針。通過 SEL 拿到 IMP,就拿到了最終要執行的函數入口。
typedef id (*IMP)(id, SEL, ...)
Method:它在 SEL 與 IMP 之間做了綁定,有了 SEL 就能找到對應的 IMP,從而調用實現代碼。綁定發生在運行時,這也是動態配置方法的基礎。
typedef struct objc_method *Method;
struct objc_method {
SEL method_name OBJC2_UNAVAILABLE; // 方法名
char *method_types OBJC2_UNAVAILABLE; // 參數類型
IMP method_imp OBJC2_UNAVAILABLE; // 方法實現
}objc_method_list 用來存儲當前類的方法鏈表,objc_method 存儲某個方法的具體信息。
方法緩存:方法調用會先在緩存裡找。方法是懶加載的,第一次調用時才裝入緩存池,之後直接走緩存。一個 Objective-C 程式啟動後,需要進行類的初始化與 cache 初始化。引申一下:+load 在類首次加載時調用,絕對只調一次;+initialize 在首次給類發消息時調用,通常只調一次,但若其子類未實現 initialize,則父類的會被再調用一次。
struct objc_cache {
unsigned int mask /* total = mask + 1 */ OBJC2_UNAVAILABLE; // 緩存 bucket 的總數
unsigned int occupied OBJC2_UNAVAILABLE; // 實際緩存 bucket 的總數
Method buckets[1] OBJC2_UNAVAILABLE; // 指向 Method 數據結構指針的數組
};method_ 系列
// 調用指定方法的實現 id method_invoke (id receiver, Method m, ...); // 調用返回一個數據結構的方法的實現 void method_invoke_stret (id receiver, Method m, ...); // 獲取方法名 SEL method_getName (Method m); // 返回方法的實現 IMP method_getImplementation (Method m); // 獲取描述方法參數和返回值類型的字符串 const char * method_getTypeEncoding (Method m); // 返回方法的參數個數 unsigned int method_getNumberOfArguments (Method m); // 通過引用返回方法指定位置參數的類型字符串 void method_getArgumentType (Method m, unsigned int index, char *dst, size_t dst_len); // 獲取方法的返回值類型的字符串 char * method_copyReturnType (Method m); // 獲取方法的指定位置參數的類型字符串 char * method_copyArgumentType (Method m, unsigned int index); // 通過引用返回方法的返回值類型字符串 void method_getReturnType (Method m, char *dst, size_t dst_len); // 設置方法的實現 IMP method_setImplementation ( Method m, IMP imp ); // 交換兩個方法的實現 void method_exchangeImplementations ( Method m1, Method m2 ); // 返回指定方法的方法描述結構體 struct objc_method_description * method_getDescription ( Method m );
sel_ 系列
// 返回給定選擇器指定方法的名稱 const char * sel_getName ( SEL sel ); // 在 Runtime 系統中註冊一個方法,將方法名映射到選擇器並返回 SEL sel_registerName ( const char *str ); // 在 Runtime 系統中註冊一個方法 SEL sel_getUid ( const char *str ); // 比較兩個選擇器 BOOL sel_isEqual ( SEL lhs, SEL rhs );
方法調用流程:向物件發送消息,實際就是調用 objc_msgSend,而它的動作就是找到函數指針並調用它。
id objc_msgSend(receiver self, selector _cmd, arg1, arg2, ...)
self 和 _cmd 是隱藏參數,在編譯期被插入實現代碼。self 指向消息接收者,作為占位參數,消息傳遞成功後即指向真正的 receiver;_cmd 是方法實現對應的 SEL。
向普通物件發消息走 objc_msgSend,向 super 發消息走 objc_msgSendSuper;若返回值是一個結構體,則分別對應 objc_msgSend_stret 與 objc_msgSendSuper_stret。
大致步驟:
0.1 檢查 target 是否為 nil。為 nil 則直接清理並返回——這就是我們能向 nil 發消息的原因。若返回值為物件,則返回 nil;若返回值是指針,且大小不大於 sizeof(void*),或者是 float、double、long double、long long 等整型標量,則返回 0;若返回值是結構體,各字段均為 0。不屬於以上幾種情況時,向 nil 發消息的返回值是未定義的。
0.2 若 target 非 nil,則依據接收者的類,用 Selector 去找 IMP(同一方法在不同類中可能有不同實現,所以必須依賴接收者的類)。
1 查找方法實現:1.1 先查類的方法緩存列表,命中則直接調用;1.2 再比對本類方法列表中的 selector;1.3 仍找不到就沿父類、爺類一路向上直到根類——這也是方法重寫能攔截父類實現的原理。
2 調用方法實現,並把接收者物件及全部參數傳入。
3 把實現函數的返回值作為自己的返回值返回。
動態方法解析與消息轉發:如果以上步驟都沒找到對應 selector(實務中通常先用 respondsToSelector: 做內省保護),還有三次補救機會:
Method Resolution(動態方法解析):實現所屬類的 +resolveInstanceMethod:(實例方法)或 +resolveClassMethod:(類方法),在其中調用 class_addMethod 動態補上實現。常用於 @dynamic 動態屬性——把屬性聲明為 @dynamic,等於向編譯器保證運行時一定會提供實現。
Fast Forwarding(快速轉發):實現 - (id)forwardingTargetForSelector:(SEL)aSelector,把消息轉給另一個物件(不能是 self,否則死循環)。
Normal Forwarding(普通轉發):先實現 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector,用方法簽名封裝參數類型與返回值;若返回非 nil,則創建 NSInvocation 物件封裝這條未處理的消息,傳給 - (void)forwardInvocation:(NSInvocation *)anInvocation。這一步相對耗時。
若消息傳遞與轉發之後仍無法響應,則觸發 doesNotRecognizeSelector:,拋出 unrecognized selector sent to instance 異常。(利用消息轉發更換接收者,還能模擬多重繼承的效果。)
@protocol 聲明了一組可被任何類實現的方法,它只定義接口,實現交給其他類。
typedef struct objc_object Protocol;
protocol_ 與 objc_ 系列:
// 返回指定的協議 Protocol * objc_getProtocol ( const char *name ); // 獲取運行時所知道的所有協議的數組 Protocol ** objc_copyProtocolList ( unsigned int *outCount ); // 創建新的協議實例 Protocol * objc_allocateProtocol ( const char *name ); // 在運行時中註冊新創建的協議 void objc_registerProtocol ( Protocol *proto ); // 返回協議名 const char * protocol_getName ( Protocol *p ); // 獲取協議的指定屬性 objc_property_t protocol_getProperty ( Protocol *proto, const char *name, BOOL isRequiredProperty, BOOL isInstanceProperty ); // 獲取協議中的屬性列表 objc_property_t * protocol_copyPropertyList ( Protocol *proto, unsigned int *outCount ); // 獲取協議採用的協議 Protocol ** protocol_copyProtocolList ( Protocol *proto, unsigned int *outCount ); // 為協議添加方法 void protocol_addMethodDescription ( Protocol *proto, SEL name, const char *types, BOOL isRequiredMethod, BOOL isInstanceMethod ); // 添加一個已註冊的協議到協議中 void protocol_addProtocol ( Protocol *proto, Protocol *addition ); // 為協議添加屬性 void protocol_addProperty ( Protocol *proto, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount, BOOL isRequiredProperty, BOOL isInstanceProperty ); // 測試兩個協議是否相等 BOOL protocol_isEqual ( Protocol *proto, Protocol *other ); // 查看協議是否採用了另一個協議 BOOL protocol_conformsToProtocol ( Protocol *proto, Protocol *other );
Method Swizzling:運行時修改類方法列表中 selector 對應的函數,或交換兩個方法的實現,從而動態替換行為。它能在不繼承的前提下重寫方法,同時仍保留調用原實現的能力,通常用於在 category 中添加方法。為避免方法混用引發衝突,應確保交換只執行一次,常見做法是把交換代碼放在 +load 或 dispatch_once 中。
ISA Swizzling:動態修改物件的 isa 指針,實質上是改變物件所屬的類,效果類似於動態生成子類來承載相同功能。KVO 就是基於 ISA Swizzling 實現的。
category
typedef struct objc_category *Category;
struct objc_category {
char *category_name OBJC2_UNAVAILABLE; // 分類名
char *class_name OBJC2_UNAVAILABLE; // 分類所屬的類名
struct objc_method_list *instance_methods OBJC2_UNAVAILABLE; // 實例方法列表
struct objc_method_list *class_methods OBJC2_UNAVAILABLE; // 類方法列表
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE; // 分類所實現的協議列表
}
// objc-runtime-new.h 中的定義:
struct category_t {
const char *name; // name 指的是 class_name 而不是 category_name
classref_t cls; // 要擴展的類對象,編譯期間不確定,而是在 Runtime 階段通過 name 對應到具體類
struct method_list_t *instanceMethods;
struct method_list_t *classMethods;
struct protocol_list_t *protocols;
struct property_list_t *instanceProperties; // Category 裡所有的 properties
};category 本質上是定義方法的結構體:instance_methods 是 objc_class 方法列表的子集,class_methods 是元類方法列表的子集。從結構成員也能看出,category 為什麼不能添加成員變量(但可以添加屬性,實際只有 get/set 方法,值需靠 objc_setAssociatedObject / objc_getAssociatedObject 存)。給 category 添加方法後會生成 method list,且是倒序插入的——新分類的方法會排在舊分類之前,因此分類中的同名方法會覆蓋類自身的實現。
super:它並不是隱藏參數,而只是一個「編譯器標識符」,用來告訴編譯器:調用方法時跳過當前類去父類找。self 是類的隱藏參數,每個方法實現的第一個參數就是 self。實際上給 super 發消息時,接收者仍然是同一個物件。
struct objc_super {
__unsafe_unretained id receiver;
__unsafe_unretained Class super_class;
};原理:使用 super 接收消息時,編譯器會生成一個 objc_super 結構體;發送消息不調用 objc_msgSend,而是調用 objc_msgSendSuper:
id objc_msgSendSuper ( struct objc_super *super, SEL op, ... );
它會從 objc_super 中 super_class 的方法列表開始查找 selector,找到後以 receiver 作為接收者執行。
開源源碼中的幾個實現
- (Class)class;
- (Class)class { return object_getClass(self); }
+ (Class)class;
+ (Class)class { return self; }
- (BOOL)isKindOf:aClass; // for 循環遍歷父類,每次判斷返回的結果可能不同
- (BOOL)isKindOf:aClass {
Class cls;
for (cls = isa; cls; cls = cls->superclass)
if (cls == (Class)aClass) return YES;
return NO;
}
- (BOOL)isMemberOf:aClass;
- (BOOL)isMemberOf:aClass { return isa == (Class)aClass; }