您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

Runtime 入門:用一條主線串起 Objective-C 的運行時機制

編輯:iOS 開發基礎

本文授權轉載,作者:楚天舒(簡書)

從 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 等


一、Runtime 是什麼

作用:在程式運行時操作編譯後的代碼,可以動態地創建、修改、內省「類」與「方法」,並完成消息傳遞。所有能力都圍繞這兩個中心:類的動態配置,以及消息傳遞。前者靠各類操作函數完成,後者靠 objc_msgSend 完成。

本質:libobjc.dylib,由 C 和匯編寫成(消息傳遞機制部分用匯編實現)。

二、類的本質

1. 類相關

數據結構上,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_ 為前綴。

class_ 系列

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

objc_ 系列

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

2. 實例變量與屬性

屬性的意義在於讓其他物件方便地訪問實例變量,同時可以拓展其作用範圍;可只讀可寫,存取方法也能自定義。

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

3. 方法與消息

消息傳遞機制是 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 異常。(利用消息轉發更換接收者,還能模擬多重繼承的效果。)

4. 協議相關

@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; }
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved