Runtime的特性主要是訊息(方法)傳遞，如果訊息(方法)在物件中找不到，就進行轉發，具體怎麼實現的呢。我們從下面幾個方面探尋Runtime的實現機制。
- Runtime介紹
- Runtime訊息傳遞
- Runtime訊息轉發
- Runtime應用
Runtime介紹
Objective-C 擴充套件了 C 語言，並加入了物件導向特性和 Smalltalk 式的訊息傳遞機制。而這個擴充套件的核心是一個用 C 和 編譯語言 寫的 Runtime 庫。它是 Objective-C 物件導向和動態機制的基石。
Objective-C 是一個動態語言，這意味著它不僅需要一個編譯器，也需要一個執行時系統來動態得建立類和物件、進行訊息傳遞和轉發。理解 Objective-C 的 Runtime 機制可以幫我們更好的瞭解這個語言，適當的時候還能對語言進行擴充套件，從系統層面解決專案中的一些設計或技術問題。瞭解 Runtime ，要先了解它的核心 - 訊息傳遞 （Messaging）。
Runtime其實有兩個版本: “modern” 和 “legacy”。我們現在用的 Objective-C 2.0 採用的是現行 (Modern) 版的 Runtime 系統，只能執行在 iOS 和 macOS 10.5 之後的 64 位程式中。而 macOS 較老的32位程式仍採用 Objective-C 1 中的（早期）Legacy 版本的 Runtime 系統。這兩個版本最大的區別在於當你更改一個類的例項變數的佈局時，在早期版本中你需要重新編譯它的子類，而現行版就不需要。
Runtime 基本是用 C 和彙編寫的，可見蘋果為了動態系統的高效而作出的努力。你可以在這裡下到蘋果維護的開原始碼。蘋果和GNU各自維護一個開源的 runtime 版本，這兩個版本之間都在努力的保持一致。
平時的業務中主要是使用官方Api，解決我們框架性的需求。
高階程式語言想要成為可執行檔案需要先編譯為組合語言再彙編為機器語言，機器語言也是計算機能夠識別的唯一語言，但是OC並不能直接編譯為組合語言，而是要先轉寫為純C語言再進行編譯和彙編的操作，從OC到C語言的過渡就是由runtime來實現的。然而我們使用OC進行物件導向開發，而C語言更多的是程式導向開發，這就需要將物件導向的類轉變為程式導向的結構體。
Runtime訊息傳遞
一個物件的方法像這樣[obj foo]，編譯器轉成訊息傳送objc_msgSend(obj, foo)，Runtime時執行的流程是這樣的：
- 首先，通過
obj的isa指標找到它的class; - 在
class的method list找foo; - 如果
class中沒到foo，繼續往它的superclass中找 ; - 一旦找到
foo這個函式，就去執行它的實現IMP。
但這種實現有個問題，效率低。但一個class 往往只有 20% 的函式會被經常呼叫，可能佔總呼叫次數的 80% 。每個訊息都需要遍歷一次objc_method_list 並不合理。如果把經常被呼叫的函式快取下來，那可以大大提高函式查詢的效率。這也就是objc_class 中另一個重要成員objc_cache 做的事情 - 再找到foo 之後，把foo 的method_name 作為key ，method_imp作為value 給存起來。當再次收到foo 訊息的時候，可以直接在cache 裡找到，避免去遍歷objc_method_list。從前面的原始碼可以看到objc_cache是存在objc_class 結構體中的。
objec_msgSend的方法定義如下：
OBJC_EXPORT id objc_msgSend(id self, SEL op, ...)
複製程式碼那訊息傳遞是怎麼實現的呢？我們看看物件(object)，類(class)，方法(method)這幾個的結構體：
//物件
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
//類
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE;
const char *name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
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;
//方法列表
struct objc_method_list {
struct objc_method_list *obsolete OBJC2_UNAVAILABLE;
int method_count OBJC2_UNAVAILABLE;
#ifdef __LP64__
int space OBJC2_UNAVAILABLE;
#endif
/* variable length structure */
struct objc_method method_list[1] OBJC2_UNAVAILABLE;
} OBJC2_UNAVAILABLE;
//方法
struct objc_method {
SEL method_name OBJC2_UNAVAILABLE;
char *method_types OBJC2_UNAVAILABLE;
IMP method_imp OBJC2_UNAVAILABLE;
}
複製程式碼- 系統首先找到訊息的接收物件，然後通過物件的
isa找到它的類。 - 在它的類中查詢
method_list，是否有selector方法。 - 沒有則查詢父類的
method_list。 - 找到對應的
method，執行它的IMP。 - 轉發
IMP的return值。
下面講講訊息傳遞用到的一些概念：
- 類物件(objc_class)
- 例項(objc_object)
- 元類(Meta Class)
- Method(objc_method)
- SEL(objc_selector)
- IMP
- 類快取(objc_cache)
- Category(objc_category)
類物件(objc_class)
Objective-C類是由Class型別來表示的，它實際上是一個指向objc_class結構體的指標。
typedef struct objc_class *Class;
複製程式碼檢視objc/runtime.h中objc_class結構體的定義如下：
struct objc_class {
Class _Nonnull isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class _Nullable super_class OBJC2_UNAVAILABLE;
const char * _Nonnull name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list * _Nullable ivars OBJC2_UNAVAILABLE;
struct objc_method_list * _Nullable * _Nullable methodLists OBJC2_UNAVAILABLE;
struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE;
struct objc_protocol_list * _Nullable protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
複製程式碼struct objc_class結構體定義了很多變數，通過命名不難發現，
結構體裡儲存了指向父類的指標、類的名字、版本、例項大小、例項變數列表、方法列表、快取、遵守的協議列表等，
一個類包含的資訊也不就正是這些嗎？沒錯，類物件就是一個結構體struct objc_class，這個結構體存放的資料稱為後設資料(metadata)，
該結構體的第一個成員變數也是isa指標，這就說明了Class本身其實也是一個物件，因此我們稱之為類物件，類物件在編譯期產生用於建立例項物件，是單例。
例項(objc_object)
/// Represents an instance of a class.
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
/// A pointer to an instance of a class.
typedef struct objc_object *id;
複製程式碼類物件中的後設資料儲存的都是如何建立一個例項的相關資訊，那麼類物件和類方法應該從哪裡建立呢？
就是從isa指標指向的結構體建立，類物件的isa指標指向的我們稱之為元類(metaclass)，
元類中儲存了建立類物件以及類方法所需的所有資訊，因此整個結構應該如下圖所示:
元類(Meta Class)
通過上圖我們可以看出整個體系構成了一個自閉環，struct objc_object結構體例項它的isa指標指向類物件，
類物件的isa指標指向了元類，super_class指標指向了父類的類物件，
而元類的super_class指標指向了父類的元類，那元類的isa指標又指向了自己。
元類(Meta Class)是一個類物件的類。
在上面我們提到，所有的類自身也是一個物件，我們可以向這個物件傳送訊息(即呼叫類方法)。
為了呼叫類方法，這個類的isa指標必須指向一個包含這些類方法的一個objc_class結構體。這就引出了meta-class的概念，元類中儲存了建立類物件以及類方法所需的所有資訊。
任何NSObject繼承體系下的meta-class都使用NSObject的meta-class作為自己的所屬類，而基類的meta-class的isa指標是指向它自己。
Method(objc_method)
先看下定義
runtime.h
/// An opaque type that represents a method in a class definition.代表類定義中一個方法的不透明型別
typedef struct objc_method *Method;
struct objc_method {
SEL method_name OBJC2_UNAVAILABLE;
char *method_types OBJC2_UNAVAILABLE;
IMP method_imp OBJC2_UNAVAILABLE;
複製程式碼Method和我們平時理解的函式是一致的，就是表示能夠獨立完成一個功能的一段程式碼，比如：
- (void)logName
{
NSLog(@"name");
}
複製程式碼這段程式碼，就是一個函式。
我們來看下objc_method這個結構體的內容：
- SEL method_name 方法名
- char *method_types 方法型別
- IMP method_imp 方法實現
在這個結構體重，我們已經看到了SEL和IMP，說明SEL和IMP其實都是Method的屬性。
我們接著來看SEL。
SEL(objc_selector)
先看下定義
Objc.h
/// An opaque type that represents a method selector.代表一個方法的不透明型別
typedef struct objc_selector *SEL;
複製程式碼objc_msgSend函式第二個引數型別為SEL，它是selector在Objective-C中的表示型別（Swift中是Selector類）。selector是方法選擇器，可以理解為區分方法的 ID，而這個 ID 的資料結構是SEL:
@property SEL selector;
複製程式碼可以看到selector是SEL的一個例項。
A method selector is a C string that has been registered (or “mapped“) with the Objective-C runtime. Selectors generated by the compiler are automatically mapped by the runtime when the class is loaded.
複製程式碼其實selector就是個對映到方法的C字串，你可以用 Objective-C 編譯器命令@selector()或者 Runtime 系統的sel_registerName函式來獲得一個 SEL 型別的方法選擇器。
selector既然是一個string，我覺得應該是類似className+method的組合，命名規則有兩條：
- 同一個類，selector不能重複
- 不同的類，selector可以重複
這也帶來了一個弊端，我們在寫C程式碼的時候，經常會用到函式過載，就是函式名相同，引數不同，但是這在Objective-C中是行不通的，因為selector只記了method的name，沒有引數，所以沒法區分不同的method。
比如：
- (void)caculate(NSInteger)num;
- (void)caculate(CGFloat)num;
複製程式碼是會報錯的。
我們只能通過命名來區別：
- (void)caculateWithInt(NSInteger)num;
- (void)caculateWithFloat(CGFloat)num;
複製程式碼在不同類中相同名字的方法所對應的方法選擇器是相同的，即使方法名字相同而變數型別不同也會導致它們具有相同的方法選擇器。
IMP
看下IMP的定義
/// A pointer to the function of a method implementation. 指向一個方法實現的指標
typedef id (*IMP)(id, SEL, ...);
#endif
複製程式碼就是指向最終實現程式的記憶體地址的指標。
在iOS的Runtime中，Method通過selector和IMP兩個屬性，實現了快速查詢方法及實現，相對提高了效能，又保持了靈活性。
類快取(objc_cache)
當Objective-C執行時通過跟蹤它的isa指標檢查物件時，它可以找到一個實現許多方法的物件。然而，你可能只呼叫它們的一小部分，並且每次查詢時，搜尋所有選擇器的類分派表沒有意義。所以類實現一個快取，每當你搜尋一個類分派表，並找到相應的選擇器，它把它放入它的快取。所以當objc_msgSend查詢一個類的選擇器，它首先搜尋類快取。這是基於這樣的理論：如果你在類上呼叫一個訊息，你可能以後再次呼叫該訊息。
為了加速訊息分發， 系統會對方法和對應的地址進行快取，就放在上述的objc_cache，所以在實際執行中，大部分常用的方法都是會被快取起來的，Runtime系統實際上非常快，接近直接執行記憶體地址的程式速度。
Category(objc_category)
Category是表示一個指向分類的結構體的指標，其定義如下：
struct category_t {
const char *name;
classref_t cls;
struct method_list_t *instanceMethods;
struct method_list_t *classMethods;
struct protocol_list_t *protocols;
struct property_list_t *instanceProperties;
};
複製程式碼name：是指 class_name 而不是 category_name。
cls：要擴充套件的類物件，編譯期間是不會定義的，而是在Runtime階段通過name對 應到對應的類物件。
instanceMethods：category中所有給類新增的例項方法的列表。
classMethods：category中所有新增的類方法的列表。
protocols：category實現的所有協議的列表。
instanceProperties：表示Category裡所有的properties，這就是我們可以通過objc_setAssociatedObject和objc_getAssociatedObject增加例項變數的原因，不過這個和一般的例項變數是不一樣的。
複製程式碼從上面的category_t的結構體中可以看出，分類中可以新增例項方法，類方法，甚至可以實現協議，新增屬性，不可以新增成員變數。
Runtime訊息轉發
前文介紹了進行一次傳送訊息會在相關的類物件中搜尋方法列表，如果找不到則會沿著繼承樹向上一直搜尋知道繼承樹根部（通常為NSObject），如果還是找不到並且訊息轉發都失敗了就回執行doesNotRecognizeSelector:方法報unrecognized selector錯。那麼訊息轉發到底是什麼呢？接下來將會逐一介紹最後的三次機會。
- 動態方法解析
- 備用接收者
- 完整訊息轉發
動態方法解析
首先，Objective-C執行時會呼叫 +resolveInstanceMethod:或者 +resolveClassMethod:，讓你有機會提供一個函式實現。如果你新增了函式並返回YES， 那執行時系統就會重新啟動一次訊息傳送的過程。
實現一個動態方法解析的例子如下：
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
//執行foo函式
[self performSelector:@selector(foo:)];
}
+ (BOOL)resolveInstanceMethod:(SEL)sel {
if (sel == @selector(foo:)) {//如果是執行foo函式，就動態解析，指定新的IMP
class_addMethod([self class], sel, (IMP)fooMethod, "v@:");
return YES;
}
return [super resolveInstanceMethod:sel];
}
void fooMethod(id obj, SEL _cmd) {
NSLog(@"Doing foo");//新的foo函式
}
複製程式碼列印結果： 2018-04-01 12:23:35.952670+0800 ocram[87546:23235469] Doing foo
可以看到雖然沒有實現foo:這個函式，但是我們通過class_addMethod動態新增fooMethod函式，並執行fooMethod這個函式的IMP。從列印結果看，成功實現了。
如果resolve方法返回 NO ，執行時就會移到下一步：forwardingTargetForSelector。
備用接收者
如果目標物件實現了-forwardingTargetForSelector:，Runtime 這時就會呼叫這個方法，給你把這個訊息轉發給其他物件的機會。
實現一個備用接收者的例子如下：
#import "ViewController.h"
#import "objc/runtime.h"
@interface Person: NSObject
@end
@implementation Person
- (void)foo {
NSLog(@"Doing foo");//Person的foo函式
}
@end
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
//執行foo函式
[self performSelector:@selector(foo)];
}
+ (BOOL)resolveInstanceMethod:(SEL)sel {
return YES;//返回YES，進入下一步轉發
}
- (id)forwardingTargetForSelector:(SEL)aSelector {
if (aSelector == @selector(foo)) {
return [Person new];//返回Person物件，讓Person物件接收這個訊息
}
return [super forwardingTargetForSelector:aSelector];
}
@end
複製程式碼列印結果： 2018-04-01 12:45:04.757929+0800 ocram[88023:23260346] Doing foo
可以看到我們通過forwardingTargetForSelector把當前ViewController的方法轉發給了Person去執行了。列印結果也證明我們成功實現了轉發。
完整訊息轉發
如果在上一步還不能處理未知訊息，則唯一能做的就是啟用完整的訊息轉發機制了。
首先它會傳送-methodSignatureForSelector:訊息獲得函式的引數和返回值型別。如果-methodSignatureForSelector:返回nil ，Runtime則會發出 -doesNotRecognizeSelector: 訊息，程式這時也就掛掉了。如果返回了一個函式簽名，Runtime就會建立一個NSInvocation 物件併傳送 -forwardInvocation:訊息給目標物件。
實現一個完整轉發的例子如下：
#import "ViewController.h"
#import "objc/runtime.h"
@interface Person: NSObject
@end
@implementation Person
- (void)foo {
NSLog(@"Doing foo");//Person的foo函式
}
@end
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
//執行foo函式
[self performSelector:@selector(foo)];
}
+ (BOOL)resolveInstanceMethod:(SEL)sel {
return YES;//返回YES，進入下一步轉發
}
- (id)forwardingTargetForSelector:(SEL)aSelector {
return nil;//返回nil，進入下一步轉發
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
if ([NSStringFromSelector(aSelector) isEqualToString:@"foo"]) {
return [NSMethodSignature signatureWithObjCTypes:"v@:"];//簽名，進入forwardInvocation
}
return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation {
SEL sel = anInvocation.selector;
Person *p = [Person new];
if([p respondsToSelector:sel]) {
[anInvocation invokeWithTarget:p];
}
else {
[self doesNotRecognizeSelector:sel];
}
}
@end
複製程式碼列印結果： 2018-04-01 13:00:45.423385+0800 ocram[88353:23279961] Doing foo
從列印結果來看，我們實現了完整的轉發。通過簽名，Runtime生成了一個物件anInvocation，傳送給了forwardInvocation，我們在forwardInvocation方法裡面讓Person物件去執行了foo函式。簽名引數v@:怎麼解釋呢，這裡蘋果文件Type Encodings有詳細的解釋。
以上就是Runtime的三次轉發流程。下面我們講講Runtime的實際應用。
Runtime應用
Runtime簡直就是做大型框架的利器。它的應用場景非常多，下面就介紹一些常見的應用場景。
- 關聯物件(Objective-C Associated Objects)給分類增加屬性
- 方法魔法(Method Swizzling)方法新增和替換和KVO實現
- 訊息轉發(熱更新)解決Bug(JSPatch)
- 實現NSCoding的自動歸檔和自動解檔
- 實現字典和模型的自動轉換(MJExtension)
關聯物件(Objective-C Associated Objects)給分類增加屬性
我們都是知道分類是不能自定義屬性和變數的。下面通過關聯物件實現給分類新增屬性。
關聯物件Runtime提供了下面幾個介面：
//關聯物件
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
//獲取關聯的物件
id objc_getAssociatedObject(id object, const void *key)
//移除關聯的物件
void objc_removeAssociatedObjects(id object)
複製程式碼引數解釋
id object：被關聯的物件
const void *key：關聯的key，要求唯一
id value：關聯的物件
objc_AssociationPolicy policy：記憶體管理的策略
複製程式碼記憶體管理的策略
typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
OBJC_ASSOCIATION_ASSIGN = 0, /**< Specifies a weak reference to the associated object. */
OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object.
* The association is not made atomically. */
OBJC_ASSOCIATION_COPY_NONATOMIC = 3, /**< Specifies that the associated object is copied.
* The association is not made atomically. */
OBJC_ASSOCIATION_RETAIN = 01401, /**< Specifies a strong reference to the associated object.
* The association is made atomically. */
OBJC_ASSOCIATION_COPY = 01403 /**< Specifies that the associated object is copied.
* The association is made atomically. */
};
複製程式碼下面實現一個UIView的Category新增自定義屬性defaultColor。
#import "ViewController.h"
#import "objc/runtime.h"
@interface UIView (DefaultColor)
@property (nonatomic, strong) UIColor *defaultColor;
@end
@implementation UIView (DefaultColor)
@dynamic defaultColor;
static char kDefaultColorKey;
- (void)setDefaultColor:(UIColor *)defaultColor {
objc_setAssociatedObject(self, &kDefaultColorKey, defaultColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (id)defaultColor {
return objc_getAssociatedObject(self, &kDefaultColorKey);
}
@end
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
UIView *test = [UIView new];
test.defaultColor = [UIColor blackColor];
NSLog(@"%@", test.defaultColor);
}
@end
複製程式碼列印結果： 2018-04-01 15:41:44.977732+0800 ocram[2053:63739] UIExtendedGrayColorSpace 0 1
列印結果來看，我們成功在分類上新增了一個屬性，實現了它的setter和getter方法。
通過關聯物件實現的屬性的記憶體管理也是有ARC管理的，所以我們只需要給定適當的記憶體策略就行了，不需要操心物件的釋放。
我們看看記憶體測量對於的屬性修飾。
| 記憶體策略 | 屬性修飾 | 描述 |
|---|---|---|
| OBJC_ASSOCIATION_ASSIGN | @property (assign) 或 @property (unsafe_unretained) | 指定一個關聯物件的弱引用。 |
| OBJC_ASSOCIATION_RETAIN_NONATOMIC | @property (nonatomic, strong) | @property (nonatomic, strong) 指定一個關聯物件的強引用，不能被原子化使用。 |
| OBJC_ASSOCIATION_COPY_NONATOMIC | @property (nonatomic, copy) | 指定一個關聯物件的copy引用，不能被原子化使用。 |
| OBJC_ASSOCIATION_RETAIN | @property (atomic, strong) | 指定一個關聯物件的強引用，能被原子化使用。 |
| OBJC_ASSOCIATION_COPY | @property (atomic, copy) | 指定一個關聯物件的copy引用，能被原子化使用。 |
方法魔法(Method Swizzling)方法新增和替換和KVO實現
方法新增
實際上新增方法剛才在講訊息轉發的時候，動態方法解析的時候就提到了。
//class_addMethod(Class _Nullable __unsafe_unretained cls, SEL _Nonnull name, IMP _Nonnull imp, const char * _Nullable types)
class_addMethod([self class], sel, (IMP)fooMethod, "v@:");
複製程式碼- cls 被新增方法的類
- name 新增的方法的名稱的SEL
- imp 方法的實現。該函式必須至少要有兩個引數，self,_cmd
- 型別編碼
方法替換
下面實現一個替換ViewController的viewDidLoad方法的例子。
@implementation ViewController
+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalSelector = @selector(viewDidLoad);
SEL swizzledSelector = @selector(jkviewDidLoad);
Method originalMethod = class_getInstanceMethod(class,originalSelector);
Method swizzledMethod = class_getInstanceMethod(class,swizzledSelector);
//judge the method named swizzledMethod is already existed.
BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
// if swizzledMethod is already existed.
if (didAddMethod) {
class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
}
else {
method_exchangeImplementations(originalMethod, swizzledMethod);
}
});
}
- (void)jkviewDidLoad {
NSLog(@"替換的方法");
[self jkviewDidLoad];
}
- (void)viewDidLoad {
NSLog(@"自帶的方法");
[super viewDidLoad];
}
@end
複製程式碼swizzling應該只在+load中完成。 在 Objective-C 的執行時中，每個類有兩個方法都會自動呼叫。+load 是在一個類被初始裝載時呼叫，+initialize 是在應用第一次呼叫該類的類方法或例項方法前呼叫的。兩個方法都是可選的，並且只有在方法被實現的情況下才會被呼叫。
swizzling應該只在dispatch_once 中完成,由於swizzling 改變了全域性的狀態，所以我們需要確保每個預防措施在執行時都是可用的。原子操作就是這樣一個用於確保程式碼只會被執行一次的預防措施，就算是在不同的執行緒中也能確保程式碼只執行一次。Grand Central Dispatch 的 dispatch_once滿足了所需要的需求，並且應該被當做使用swizzling 的初始化單例方法的標準。
實現圖解如下圖。
從圖中可以看出，我們通過swizzling特性，將selectorC的方法實現IMPc與selectorN的方法實現IMPn交換了，當我們呼叫selectorC，也就是給物件傳送selectorC訊息時，所查詢到的對應的方法實現就是IMPn而不是IMPc了。
KVO實現
全稱是Key-value observing，翻譯成鍵值觀察。提供了一種當其它物件屬性被修改的時候能通知當前物件的機制。再MVC大行其道的Cocoa中，KVO機制很適合實現model和controller類之間的通訊。
KVO的實現依賴於 Objective-C 強大的 Runtime，當觀察某物件 A 時，KVO 機制動態建立一個物件A當前類的子類，併為這個新的子類重寫了被觀察屬性 keyPath 的 setter 方法。setter 方法隨後負責通知觀察物件屬性的改變狀況。
Apple 使用了 isa-swizzling 來實現 KVO 。當觀察物件A時，KVO機制動態建立一個新的名為：NSKVONotifying_A的新類，該類繼承自物件A的本類，且 KVO 為 NSKVONotifying_A 重寫觀察屬性的 setter 方法，setter 方法會負責在呼叫原 setter 方法之前和之後，通知所有觀察物件屬性值的更改情況。
- NSKVONotifying_A 類剖析
NSLog(@"self->isa:%@",self->isa);
NSLog(@"self class:%@",[self class]);
複製程式碼在建立KVO監聽前，列印結果為：
self->isa:A
self class:A
複製程式碼在建立KVO監聽之後，列印結果為：
self->isa:NSKVONotifying_A
self class:A
複製程式碼在這個過程，被觀察物件的 isa 指標從指向原來的 A 類，被KVO 機制修改為指向系統新建立的子類NSKVONotifying_A 類，來實現當前類屬性值改變的監聽；
所以當我們從應用層面上看來，完全沒有意識到有新的類出現，這是系統“隱瞞”了對 KVO 的底層實現過程，讓我們誤以為還是原來的類。但是此時如果我們建立一個新的名為“NSKVONotifying_A”的類，就會發現系統執行到註冊 KVO 的那段程式碼時程式就崩潰，因為系統在註冊監聽的時候動態建立了名為 NSKVONotifying_A 的中間類，並指向這個中間類了。
- 子類setter方法剖析
KVO 的鍵值觀察通知依賴於 NSObject 的兩個方法:willChangeValueForKey:和 didChangeValueForKey: ，在存取數值的前後分別呼叫 2 個方法：
被觀察屬性發生改變之前，willChangeValueForKey:被呼叫，通知系統該 keyPath 的屬性值即將變更；
當改變發生後， didChangeValueForKey: 被呼叫，通知系統該keyPath 的屬性值已經變更；之後， observeValueForKey:ofObject:change:context:也會被呼叫。且重寫觀察屬性的setter 方法這種繼承方式的注入是在執行時而不是編譯時實現的。
KVO 為子類的觀察者屬性重寫呼叫存取方法的工作原理在程式碼中相當於：
- (void)setName:(NSString *)newName {
[self willChangeValueForKey:@"name"]; //KVO 在呼叫存取方法之前總呼叫
[super setValue:newName forKey:@"name"]; //呼叫父類的存取方法
[self didChangeValueForKey:@"name"]; //KVO 在呼叫存取方法之後總呼叫
}
複製程式碼訊息轉發(熱更新)解決Bug(JSPatch)
JSPatch 是一個 iOS 動態更新框架，只需在專案中引入極小的引擎，就可以使用 JavaScript 呼叫任何 Objective-C 原生介面，獲得指令碼語言的優勢：為專案動態新增模組，或替換專案原生程式碼動態修復 bug。
關於訊息轉發，前面已經講到過了，訊息轉發分為三級，我們可以在每級實現替換功能，實現訊息轉發，從而不會造成崩潰。JSPatch不僅能夠實現訊息轉發，還可以實現方法新增、替換能一系列功能。
實現NSCoding的自動歸檔和自動解檔
原理描述：用runtime提供的函式遍歷Model自身所有屬性，並對屬性進行encode和decode操作。
核心方法：在Model的基類中重寫方法：
- (id)initWithCoder:(NSCoder *)aDecoder {
if (self = [super init]) {
unsigned int outCount;
Ivar * ivars = class_copyIvarList([self class], &outCount);
for (int i = 0; i < outCount; i ++) {
Ivar ivar = ivars[i];
NSString * key = [NSString stringWithUTF8String:ivar_getName(ivar)];
[self setValue:[aDecoder decodeObjectForKey:key] forKey:key];
}
}
return self;
}
- (void)encodeWithCoder:(NSCoder *)aCoder {
unsigned int outCount;
Ivar * ivars = class_copyIvarList([self class], &outCount);
for (int i = 0; i < outCount; i ++) {
Ivar ivar = ivars[i];
NSString * key = [NSString stringWithUTF8String:ivar_getName(ivar)];
[aCoder encodeObject:[self valueForKey:key] forKey:key];
}
}
複製程式碼實現字典和模型的自動轉換(MJExtension)
原理描述：用runtime提供的函式遍歷Model自身所有屬性，如果屬性在json中有對應的值，則將其賦值。
核心方法：在NSObject的分類中新增方法
- (instancetype)initWithDict:(NSDictionary *)dict {
if (self = [self init]) {
//(1)獲取類的屬性及屬性對應的型別
NSMutableArray * keys = [NSMutableArray array];
NSMutableArray * attributes = [NSMutableArray array];
/*
* 例子
* name = value3 attribute = T@"NSString",C,N,V_value3
* name = value4 attribute = T^i,N,V_value4
*/
unsigned int outCount;
objc_property_t * properties = class_copyPropertyList([self class], &outCount);
for (int i = 0; i < outCount; i ++) {
objc_property_t property = properties[i];
//通過property_getName函式獲得屬性的名字
NSString * propertyName = [NSString stringWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
[keys addObject:propertyName];
//通過property_getAttributes函式可以獲得屬性的名字和@encode編碼
NSString * propertyAttribute = [NSString stringWithCString:property_getAttributes(property) encoding:NSUTF8StringEncoding];
[attributes addObject:propertyAttribute];
}
//立即釋放properties指向的記憶體
free(properties);
//(2)根據型別給屬性賦值
for (NSString * key in keys) {
if ([dict valueForKey:key] == nil) continue;
[self setValue:[dict valueForKey:key] forKey:key];
}
}
return self;
}
複製程式碼以上就是Runtime應用的一些場景，本文到此結束了。
關注我
歡迎關注公眾號：jackyshan，技術乾貨首發微信，第一時間推送。
