前言
現在越來越多的app都使用了JSPatch實現app熱修復，而JSPatch 能做到通過 JS 呼叫和改寫 OC 方法最根本的原因是 Objective-C 是動態語言，OC 上所有方法的呼叫/類的生成都通過 Objective-C Runtime 在執行時進行，我們可以通過類名/方法名反射得到相應的類和方法，也可以替換某個類的方法為新的實現，理論上你可以在執行時通過類名/方法名呼叫到任何 OC 方法，替換任何類的實現以及新增任意類。今天就來詳細解析一下OC中runtime最為吸引人的地方。
目錄
- 1.objc_msgSend函式簡介
- 2.訊息傳送Messaging階段—objc_msgSend原始碼解析
- 3.訊息轉發Message Forwarding階段
- 4.forwardInvocation的例子
- 5.入院考試
- 6.Runtime中的優化
一.objc_msgSend函式簡介
最初接觸到OC Runtime，一定是從[receiver message]這裡開始的。[receiver message]會被編譯器轉化為：
id objc_msgSend ( id self, SEL op, ... );複製程式碼這是一個可變引數函式。第二個引數型別是SEL。SEL在OC中是selector方法選擇器。
typedef struct objc_selector *SEL;複製程式碼objc_selector是一個對映到方法的C字串。需要注意的是@selector()選擇子只與函式名有關。不同類中相同名字的方法所對應的方法選擇器是相同的，即使方法名字相同而變數型別不同也會導致它們具有相同的方法選擇器。由於這點特性，也導致了OC不支援函式過載。
在receiver拿到對應的selector之後，如果自己無法執行這個方法，那麼該條訊息要被轉發。或者臨時動態的新增方法實現。如果轉發到最後依舊沒法處理，程式就會崩潰。
所以編譯期僅僅是確定了要傳送訊息，而訊息如何處理是要執行期需要解決的事情。
objc_msgSend函式究竟會幹什麼事情呢？從這篇「objc_msgSend() Tour」文章裡面可以得到一個比較詳細的結論。
- Check for ignored selectors (GC) and short-circuit.
- Check for nil target. If nil & nil receiver handler configured, jump to handler If nil & no handler (default), cleanup and return.
- Search the class’s method cache for the method IMP(use hash to find&store method in cache) -1. If found, jump to it. -2. Not found: lookup the method IMP in the class itself corresponding its hierarchy chain. If found, load it into cache and jump to it. If not found, jump to forwarding mechanism.
總結一下objc_msgSend會做一下幾件事情： 1.檢測這個 selector是不是要忽略的。 2.檢查target是不是為nil。
如果這裡有相應的nil的處理函式，就跳轉到相應的函式中。 如果沒有處理nil的函式，就自動清理現場並返回。這一點就是為何在OC中給nil傳送訊息不會崩潰的原因。
3.確定不是給nil發訊息之後，在該class的快取中查詢方法對應的IMP實現。
如果找到，就跳轉進去執行。 如果沒有找到，就在方法分發表裡面繼續查詢，一直找到NSObject為止。
4.如果還沒有找到，那就需要開始訊息轉發階段了。至此，傳送訊息Messaging階段完成。這一階段主要完成的是通過select()快速查詢IMP的過程。
二. 訊息傳送Messaging階段—objc_msgSend原始碼解析
在這篇文章Obj-C Optimization: The faster objc_msgSend中看到了這樣一段C版本的objc_msgSend的原始碼。
#include <objc/objc-runtime.h>
id c_objc_msgSend( struct objc_class /* ahem */ *self, SEL _cmd, ...)
{
struct objc_class *cls;
struct objc_cache *cache;
unsigned int hash;
struct objc_method *method;
unsigned int index;
if( self)
{
cls = self->isa;
cache = cls->cache;
hash = cache->mask;
index = (unsigned int) _cmd & hash;
do
{
method = cache->buckets[ index];
if( ! method)
goto recache;
index = (index + 1) & cache->mask;
}
while( method->method_name != _cmd);
return( (*method->method_imp)( (id) self, _cmd));
}
return( (id) self);
recache:
/* ... */
return( 0);
}複製程式碼該原始碼中有一個do-while迴圈，這個迴圈就是上一章裡面提到的在方法分發表裡面查詢method的過程。
不過在obj4-680裡面的objc-msg-x86_64.s檔案中實現是一段彙編程式碼。
/********************************************************************
*
* id objc_msgSend(id self, SEL _cmd,...);
*
********************************************************************/
.data
.align 3
.globl _objc_debug_taggedpointer_classes
_objc_debug_taggedpointer_classes:
.fill 16, 8, 0
ENTRY _objc_msgSend
MESSENGER_START
NilTest NORMAL
GetIsaFast NORMAL // r11 = self->isa
CacheLookup NORMAL // calls IMP on success
NilTestSupport NORMAL
GetIsaSupport NORMAL
// cache miss: go search the method lists
LCacheMiss:
// isa still in r11
MethodTableLookup %a1, %a2 // r11 = IMP
cmp %r11, %r11 // set eq (nonstret) for forwarding
jmp *%r11 // goto *imp
END_ENTRY _objc_msgSend
ENTRY _objc_msgSend_fixup
int3
END_ENTRY _objc_msgSend_fixup
STATIC_ENTRY _objc_msgSend_fixedup
// Load _cmd from the message_ref
movq 8(%a2), %a2
jmp _objc_msgSend
END_ENTRY _objc_msgSend_fixedup複製程式碼來分析一下這段彙編程式碼。
乍一看，如果從LCacheMiss:這裡上下分開，可以很明顯的看到objc_msgSend就幹了兩件事情—— CacheLookup 和 MethodTableLookup。
/////////////////////////////////////////////////////////////////////
//
// NilTest return-type
//
// Takes: $0 = NORMAL or FPRET or FP2RET or STRET
// %a1 or %a2 (STRET) = receiver
//
// On exit: Loads non-nil receiver in %a1 or %a2 (STRET), or returns zero.
//
/////////////////////////////////////////////////////////////////////
.macro NilTest
.if $0 == SUPER || $0 == SUPER_STRET
error super dispatch does not test for nil
.endif
.if $0 != STRET
testq %a1, %a1
.else
testq %a2, %a2
.endif
PN
jz LNilTestSlow_f
.endmacro複製程式碼NilTest是用來檢測是否為nil的。傳入引數有4種，NORMAL / FPRET / FP2RET / STRET。
objc_msgSend 傳入的引數是NilTest NORMAL objc_msgSend_fpret 傳入的引數是NilTest FPRET objc_msgSend_fp2ret 傳入的引數是NilTest FP2RET objc_msgSend_stret 傳入的引數是NilTest STRET
如果檢測方法的接受者是nil，那麼系統會自動clean並且return。
GetIsaFast巨集可以快速地獲取到物件的 isa 指標地址（放到 r11 暫存器，r10會被重寫；在 arm 架構上是直接賦值到 r9）
.macro CacheLookup
ldrh r12, [r9, #CACHE_MASK] // r12 = mask
ldr r9, [r9, #CACHE] // r9 = buckets
.if $0 == STRET || $0 == SUPER_STRET
and r12, r12, r2 // r12 = index = SEL & mask
.else
and r12, r12, r1 // r12 = index = SEL & mask
.endif
add r9, r9, r12, LSL #3 // r9 = bucket = buckets+index*8
ldr r12, [r9] // r12 = bucket->sel
2:
.if $0 == STRET || $0 == SUPER_STRET
teq r12, r2
.else
teq r12, r1
.endif
bne 1f
CacheHit $0
1:
cmp r12, #1
blo LCacheMiss_f // if (bucket->sel == 0) cache miss
it eq // if (bucket->sel == 1) cache wrap
ldreq r9, [r9, #4] // bucket->imp is before first bucket
ldr r12, [r9, #8]! // r12 = (++bucket)->sel
b 2b
.endmacro複製程式碼r12裡面存的是方法method，r9裡面是cache。r1，r2是SEL。在這個CacheLookup函式中，不斷的通過SEL與cache中的bucket->sel進行比較，如果r12 = = 0，則跳轉到LCacheMiss_f標記去繼續執行。如果r12找到了,r12 = =1，即在cache中找到了相應的SEL，則直接執行該IMP(放在r10中)。
程式跳到LCacheMiss，就說明cache中無快取，未命中快取。這個時候就要開始下一階段MethodTableLookup的查詢了。
/////////////////////////////////////////////////////////////////////
//
// MethodTableLookup classRegister, selectorRegister
//
// Takes: $0 = class to search (a1 or a2 or r10 ONLY)
// $1 = selector to search for (a2 or a3 ONLY)
// r11 = class to search
//
// On exit: imp in %r11
//
/////////////////////////////////////////////////////////////////////
.macro MethodTableLookup
MESSENGER_END_SLOW
SaveRegisters
// _class_lookupMethodAndLoadCache3(receiver, selector, class)
movq $0, %a1
movq $1, %a2
movq %r11, %a3
call __class_lookupMethodAndLoadCache3
// IMP is now in %rax
movq %rax, %r11
RestoreRegisters
.endmacro複製程式碼MethodTableLookup 可以算是個介面層巨集，主要用於儲存環境與準備引數，來呼叫 __class_lookupMethodAndLoadCache3函式（在objc-class.mm中）。具體是把receiver, selector, class三個引數傳給$0，$1，r11，然後再去呼叫lookupMethodAndLoadCache3方法。最後會將 IMP 返回（從 r11 挪到 rax）。最後在 objc_msgSend中呼叫 IMP。
/***********************************************************************
* _class_lookupMethodAndLoadCache.
* Method lookup for dispatchers ONLY. OTHER CODE SHOULD USE lookUpImp().
* This lookup avoids optimistic cache scan because the dispatcher
* already tried that.
**********************************************************************/
IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
{
return lookUpImpOrForward(cls, sel, obj,
YES/*initialize*/, NO/*cache*/, YES/*resolver*/);
}複製程式碼__class_lookupMethodAndLoadCache3函式也是個介面層（C編寫），此函式提供相應引數配置，實際功能在lookUpImpOrForward函式中。
再來看看lookUpImpOrForward函式實現
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
Class curClass;
IMP imp = nil;
Method meth;
bool triedResolver = NO;
/*
中間是查詢過程，詳細解析見下。
*/
// paranoia: look for ignored selectors with non-ignored implementations
assert(!(ignoreSelector(sel) && imp != (IMP)&_objc_ignored_method));
// paranoia: never let uncached leak out
assert(imp != _objc_msgSend_uncached_impcache);
return imp;
}複製程式碼接下來一行行的解析。
runtimeLock.assertUnlocked();複製程式碼runtimeLock.assertUnlocked(); 這個是加一個讀寫鎖，保證執行緒安全。
// Optimistic cache lookup
if (cache) {
imp = cache_getImp(cls, sel);
if (imp) return imp;
}複製程式碼lookUpImpOrForward第5個新參是是否找到cache的布林量，如果傳入的是YES，那麼就會呼叫cache_getImp方法去找到快取裡面的IMP。
/********************************************************************
* IMP cache_getImp(Class cls, SEL sel)
*
* On entry: a1 = class whose cache is to be searched
* a2 = selector to search for
*
* If found, returns method implementation.
* If not found, returns NULL.
********************************************************************/
STATIC_ENTRY _cache_getImp
// do lookup
movq %a1, %r11 // move class to r11 for CacheLookup
CacheLookup GETIMP // returns IMP on success
LCacheMiss:
// cache miss, return nil
xorl %eax, %eax
ret
LGetImpExit:
END_ENTRY _cache_getImp複製程式碼cache_getImp會把找到的IMP放在r11中。
if (!cls->isRealized()) {
rwlock_writer_t lock(runtimeLock);
realizeClass(cls);
}複製程式碼呼叫realizeClass方法是申請class_rw_t的可讀寫空間。
if (initialize && !cls->isInitialized()) {
_class_initialize (_class_getNonMetaClass(cls, inst));
}複製程式碼_class_initialize是類初始化的過程。
retry:
runtimeLock.read();複製程式碼runtimeLock.read();這裡加了一個讀鎖。因為在執行時中會動態的新增方法，為了保證執行緒安全，所以要加鎖。從這裡開始，下面會出現5處goto done的地方，和一處goto retry。
done:
runtimeLock.unlockRead();複製程式碼在done的地方，會完成IMP的查詢，於是可以開啟讀鎖。
// Ignore GC selectors
if (ignoreSelector(sel)) {
imp = _objc_ignored_method;
cache_fill(cls, sel, imp, inst);
goto done;
}複製程式碼緊接著GC selectors是為了忽略macOS中GC垃圾回收機制用到的方法，iOS則沒有這一步。如果忽略，則進行cache_fill，然後跳轉到goto done那裡去。
void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
#if !DEBUG_TASK_THREADS
mutex_locker_t lock(cacheUpdateLock);
cache_fill_nolock(cls, sel, imp, receiver);
#else
_collecting_in_critical();
return;
#endif
}
static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver)
{
cacheUpdateLock.assertLocked();
// Never cache before +initialize is done
if (!cls->isInitialized()) return;
// Make sure the entry wasn't added to the cache by some other thread
// before we grabbed the cacheUpdateLock.
if (cache_getImp(cls, sel)) return;
cache_t *cache = getCache(cls);
cache_key_t key = getKey(sel);
// Use the cache as-is if it is less than 3/4 full
mask_t newOccupied = cache->occupied() + 1;
mask_t capacity = cache->capacity();
if (cache->isConstantEmptyCache()) {
// Cache is read-only. Replace it.
cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
}
else if (newOccupied <= capacity / 4 * 3) {
// Cache is less than 3/4 full. Use it as-is.
}
else {
// Cache is too full. Expand it.
cache->expand();
}
bucket_t *bucket = cache->find(key, receiver);
if (bucket->key() == 0) cache->incrementOccupied();
bucket->set(key, imp);
}複製程式碼在cache_fill中還會去呼叫cache_fill_nolock函式，如果快取中的內容大於容量的 3/4就會擴充快取，使快取的大小翻倍。找到第一個空的 bucket_t，以 (SEL, IMP)的形式填充進去。
// Try this class's cache.
imp = cache_getImp(cls, sel);
if (imp) goto done;複製程式碼如果不忽略，則再次嘗試從類的cache中獲取IMP，如果獲取到，然後也會跳轉到goto done去。
// Try this class's method lists.
meth = getMethodNoSuper_nolock(cls, sel);
if (meth) {
log_and_fill_cache(cls, meth->imp, sel, inst, cls);
imp = meth->imp;
goto done;
}複製程式碼如果在cache快取中獲取失敗，則再去類方法列表裡面進行查詢。找到後跳轉到goto done。
// Try superclass caches and method lists.
curClass = cls;
while ((curClass = curClass->superclass)) {
// Superclass cache.
imp = cache_getImp(curClass, sel);
if (imp) {
if (imp != (IMP)_objc_msgForward_impcache) {
// Found the method in a superclass. Cache it in this class.
log_and_fill_cache(cls, imp, sel, inst, curClass);
goto done;
}
else {
// Found a forward:: entry in a superclass.
// Stop searching, but don't cache yet; call method
// resolver for this class first.
break;
}
}複製程式碼如果以上嘗試都失敗了，接下來就會迴圈嘗試父類的快取和方法列表。一直找到NSObject為止。因為NSObject的superclass為nil，才跳出迴圈。
如果在父類中找到了該方法method的IMP，接下來就應該把這個方法cache回自己的快取中。fill完之後跳轉goto done語句。
// Superclass method list.
meth = getMethodNoSuper_nolock(curClass, sel);
if (meth) {
log_and_fill_cache(cls, meth->imp, sel, inst, curClass);
imp = meth->imp;
goto done;
}
}複製程式碼如果沒有在父類的cache中找到IMP，繼續在父類的方法列表裡面查詢。如果找到，跳轉goto done語句。
static method_t *
getMethodNoSuper_nolock(Class cls, SEL sel)
{
runtimeLock.assertLocked();
assert(cls->isRealized());
// fixme nil cls?
// fixme nil sel?
for (auto mlists = cls->data()->methods.beginLists(),
end = cls->data()->methods.endLists();
mlists != end;
++mlists)
{
method_t *m = search_method_list(*mlists, sel);
if (m) return m;
}
return nil;
}複製程式碼這裡可以解析一下method的查詢過程。在getMethodNoSuper_nolock方法中，會遍歷一次methodList連結串列，從begin一直遍歷到end。遍歷過程中會呼叫search_method_list函式。
static method_t *search_method_list(const method_list_t *mlist, SEL sel)
{
int methodListIsFixedUp = mlist->isFixedUp();
int methodListHasExpectedSize = mlist->entsize() == sizeof(method_t);
if (__builtin_expect(methodListIsFixedUp && methodListHasExpectedSize, 1)) {
return findMethodInSortedMethodList(sel, mlist);
} else {
// Linear search of unsorted method list
for (auto& meth : *mlist) {
if (meth.name == sel) return &meth;
}
}
#if DEBUG
// sanity-check negative results
if (mlist->isFixedUp()) {
for (auto& meth : *mlist) {
if (meth.name == sel) {
_objc_fatal("linear search worked when binary search did not");
}
}
}
#endif
return nil;
}複製程式碼在search_method_list函式中，會去判斷當前methodList是否有序，如果有序，會呼叫findMethodInSortedMethodList方法，這個方法裡面的實現是一個二分搜尋，具體程式碼就不貼了。如果非有序，就呼叫線性的傻瓜式遍歷搜尋。
// No implementation found. Try method resolver once.
if (resolver && !triedResolver) {
runtimeLock.unlockRead();
_class_resolveMethod(cls, sel, inst);
// Don't cache the result; we don't hold the lock so it may have
// changed already. Re-do the search from scratch instead.
triedResolver = YES;
goto retry;
}複製程式碼如果父類找到NSObject還沒有找到，那麼就會開始嘗試_class_resolveMethod方法。注意，這些需要開啟讀鎖，因為開發者可能會在這裡動態增加方法實現，所以不需要快取結果。此處雖然鎖被開啟，可能會出現執行緒問題，所以在執行完_class_resolveMethod方法之後，會goto retry，重新執行一遍之前查詢的過程。
/***********************************************************************
* _class_resolveMethod
* Call +resolveClassMethod or +resolveInstanceMethod.
* Returns nothing; any result would be potentially out-of-date already.
* Does not check if the method already exists.
**********************************************************************/
void _class_resolveMethod(Class cls, SEL sel, id inst)
{
if (! cls->isMetaClass()) {
// try [cls resolveInstanceMethod:sel]
_class_resolveInstanceMethod(cls, sel, inst);
}
else {
// try [nonMetaClass resolveClassMethod:sel]
// and [cls resolveInstanceMethod:sel]
_class_resolveClassMethod(cls, sel, inst);
if (!lookUpImpOrNil(cls, sel, inst,
NO/*initialize*/, YES/*cache*/, NO/*resolver*/))
{
_class_resolveInstanceMethod(cls, sel, inst);
}
}
}複製程式碼這個函式首先判斷是否是meta-class類，如果不是元類，就執行_class_resolveInstanceMethod，如果是元類，執行_class_resolveClassMethod。這裡有一個lookUpImpOrNil的函式呼叫。
IMP lookUpImpOrNil(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
IMP imp = lookUpImpOrForward(cls, sel, inst, initialize, cache, resolver);
if (imp == _objc_msgForward_impcache) return nil;
else return imp;
}複製程式碼在這個函式實現中，還會去呼叫lookUpImpOrForward去查詢有沒有傳入的sel的實現，但是返回值還會返回nil。在imp == _objc_msgForward_impcache會返回nil。_objc_msgForward_impcache是一個標記，這個標記用來表示在父類的快取中停止繼續查詢。
IMP class_getMethodImplementation(Class cls, SEL sel)
{
IMP imp;
if (!cls || !sel) return nil;
imp = lookUpImpOrNil(cls, sel, nil,
YES/*initialize*/, YES/*cache*/, YES/*resolver*/);
// Translate forwarding function to C-callable external version
if (!imp) {
return _objc_msgForward;
}
return imp;
}複製程式碼再回到_class_resolveMethod的實現中，如果lookUpImpOrNil返回nil，就代表在父類中的快取中找到，於是需要再呼叫一次_class_resolveInstanceMethod方法。保證給sel新增上了對應的IMP。
// No implementation found, and method resolver didn't help.
// Use forwarding.
imp = (IMP)_objc_msgForward_impcache;
cache_fill(cls, sel, imp, inst);複製程式碼回到lookUpImpOrForward方法中，如果也沒有找到IMP的實現，那麼method resolver也沒用了，只能進入訊息轉發階段。進入這個階段之前，imp變成_objc_msgForward_impcache。最後再加入快取中。
三. 訊息轉發Message Forwarding階段
到了轉發階段，會呼叫id _objc_msgForward(id self, SEL _cmd,...)方法。在objc-msg-x86_64.s中有其彙編的實現。
STATIC_ENTRY __objc_msgForward_impcache
// Method cache version
// THIS IS NOT A CALLABLE C FUNCTION
// Out-of-band condition register is NE for stret, EQ otherwise.
MESSENGER_START
nop
MESSENGER_END_SLOW
jne __objc_msgForward_stret
jmp __objc_msgForward
END_ENTRY __objc_msgForward_impcache
ENTRY __objc_msgForward
// Non-stret version
movq __objc_forward_handler(%rip), %r11
jmp *%r11
END_ENTRY __objc_msgForward複製程式碼在執行_objc_msgForward之後會呼叫__objc_forward_handler函式。
// Default forward handler halts the process.
__attribute__((noreturn)) void
objc_defaultForwardHandler(id self, SEL sel)
{
_objc_fatal("%c[%s %s]: unrecognized selector sent to instance %p "
"(no message forward handler is installed)",
class_isMetaClass(object_getClass(self)) ? '+' : '-',
object_getClassName(self), sel_getName(sel), self);
}複製程式碼在最新的Objc2.0中會有一個objc_defaultForwardHandler，看原始碼實現我們可以看到熟悉的語句。當我們給一個物件傳送一個沒有實現的方法的時候，如果其父類也沒有這個方法，則會崩潰，報錯資訊類似於這樣：unrecognized selector sent to instance，然後接著會跳出一些堆疊資訊。這些資訊就是從這裡而來。
void *_objc_forward_handler = (void*)objc_defaultForwardHandler;
#if SUPPORT_STRET
struct stret { int i[100]; };
__attribute__((noreturn)) struct stret
objc_defaultForwardStretHandler(id self, SEL sel)
{
objc_defaultForwardHandler(self, sel);
}
void *_objc_forward_stret_handler = (void*)objc_defaultForwardStretHandler;
#endif
#endif
void objc_setForwardHandler(void *fwd, void *fwd_stret)
{
_objc_forward_handler = fwd;
#if SUPPORT_STRET
_objc_forward_stret_handler = fwd_stret;
#endif
}複製程式碼要設定轉發只要重寫_objc_forward_handler方法即可。在objc_setForwardHandler方法中，可以設定ForwardHandler。
但是當你想要弄清objc_setForwardHandler呼叫棧的情況的時候，你會發現列印不出來入口。因為蘋果在這裡做了點手腳。關於objc_setForwardHandler的呼叫，以及之後的訊息轉發呼叫棧的問題，需要用到逆向的知識。推薦大家看這兩篇文章就會明白其中的原理。
Objective-C 訊息傳送與轉發機制原理
Hmmm, What’s that Selector?
還是回到訊息轉發上面來。當前的SEL無法找到相應的IMP的時候，開發者可以通過重寫- (id)forwardingTargetForSelector:(SEL)aSelector方法來“偷樑換柱”，把訊息的接受者換成一個可以處理該訊息的物件。
- (id)forwardingTargetForSelector:(SEL)aSelector
{
if(aSelector == @selector(Method:)){
return otherObject;
}
return [super forwardingTargetForSelector:aSelector];
}複製程式碼當然也可以替換類方法，那就要重寫 + (id)forwardingTargetForSelector:(SEL)aSelector方法，返回值是一個類物件。
+ (id)forwardingTargetForSelector:(SEL)aSelector {
if(aSelector == @selector(xxx)) {
return NSClassFromString(@"Class name");
}
return [super forwardingTargetForSelector:aSelector];
}複製程式碼這一步是替訊息找備援接收者，如果這一步返回的是nil，那麼補救措施就完全的失效了，Runtime系統會向物件傳送methodSignatureForSelector:訊息，並取到返回的方法簽名用於生成NSInvocation物件。為接下來的完整的訊息轉發生成一個 NSMethodSignature物件。NSMethodSignature 物件會被包裝成 NSInvocation 物件，forwardInvocation: 方法裡就可以對 NSInvocation 進行處理了。
接下來未識別的方法崩潰之前，系統會做一次完整的訊息轉發。
我們只需要重寫下面這個方法，就可以自定義我們自己的轉發邏輯了。
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
if ([someOtherObject respondsToSelector:
[anInvocation selector]])
[anInvocation invokeWithTarget:someOtherObject];
else
[super forwardInvocation:anInvocation];
}複製程式碼實現此方法之後，若發現某呼叫不應由本類處理，則會呼叫超類的同名方法。如此，繼承體系中的每個類都有機會處理該方法呼叫的請求，一直到NSObject根類。如果到NSObject也不能處理該條訊息，那麼就是再無挽救措施了，只能丟擲“doesNotRecognizeSelector”異常了。
至此，訊息傳送和轉發的過程都清楚明白了。
四. forwardInvocation的例子
這裡我想舉一個好玩的例子，來說明一下forwardInvocation的使用方法。
這個例子中我們會利用runtime訊息轉發機制建立一個動態代理。利用這個動態代理來轉發訊息。這裡我們會用到兩個基類的另外一個神祕的類，NSProxy。
NSProxy類和NSObject同為OC裡面的基類，但是NSProxy類是一種抽象的基類，無法直接例項化，可用於實現代理模式。它通過實現一組經過簡化的方法，代替目標物件捕捉和處理所有的訊息。NSProxy類也同樣實現了NSObject的協議宣告的方法，而且它有兩個必須實現的方法。
- (void)forwardInvocation:(NSInvocation *)invocation;
- (nullable NSMethodSignature *)methodSignatureForSelector:(SEL)sel NS_SWIFT_UNAVAILABLE("NSInvocation and related APIs not available");複製程式碼另外還需要說明的是，NSProxy類的子類必須宣告並實現至少一個init方法，這樣才能符合OC中建立和初始化物件的慣例。Foundation框架裡面也含有多個NSProxy類的具體實現類。
- NSDistantObject類：定義其他應用程式或執行緒中物件的代理類。
- NSProtocolChecker類：定義物件，使用這話物件可以限定哪些訊息能夠傳送給另外一個物件。
接下來就來看看下面這個好玩的例子。
#import <Foundation/Foundation.h>
@interface Student : NSObject
-(void)study:(NSString *)subject andRead:(NSString *)bookName;
-(void)study:(NSString *)subject :(NSString *)bookName;
@end複製程式碼定義一個student類，裡面隨便給兩個方法。
#import "Student.h"
#import <objc/runtime.h>
@implementation Student
-(void)study:(NSString *)subject :(NSString *)bookName
{
NSLog(@"Invorking method on %@ object with selector %@",[self class],NSStringFromSelector(_cmd));
}
-(void)study:(NSString *)subject andRead:(NSString *)bookName
{
NSLog(@"Invorking method on %@ object with selector %@",[self class],NSStringFromSelector(_cmd));
}
@end複製程式碼在兩個方法實現裡面增加log資訊，這是為了一會列印的時候方便知道呼叫了哪個方法。
#import <Foundation/Foundation.h>
#import "Invoker.h"
@interface AspectProxy : NSProxy
/** 通過NSProxy例項轉發訊息的真正物件 */
@property(strong) id proxyTarget;
/** 能夠實現橫切功能的類（遵守Invoker協議）的例項 */
@property(strong) id<Invoker> invoker;
/** 定義了哪些訊息會呼叫橫切功能 */
@property(readonly) NSMutableArray *selectors;
// AspectProxy類例項的初始化方法
- (id)initWithObject:(id)object andInvoker:(id<Invoker>)invoker;
- (id)initWithObject:(id)object selectors:(NSArray *)selectors andInvoker:(id<Invoker>)invoker;
// 向當前的選擇器列表中新增選擇器
- (void)registerSelector:(SEL)selector;
@end複製程式碼定義一個AspectProxy類，這個類專門用來轉發訊息的。
#import "AspectProxy.h"
@implementation AspectProxy
- (id)initWithObject:(id)object selectors:(NSArray *)selectors andInvoker:(id<Invoker>)invoker{
_proxyTarget = object;
_invoker = invoker;
_selectors = [selectors mutableCopy];
return self;
}
- (id)initWithObject:(id)object andInvoker:(id<Invoker>)invoker{
return [self initWithObject:object selectors:nil andInvoker:invoker];
}
// 新增另外一個選擇器
- (void)registerSelector:(SEL)selector{
NSValue *selValue = [NSValue valueWithPointer:selector];
[self.selectors addObject:selValue];
}
// 為目標物件中被呼叫的方法返回一個NSMethodSignature例項
// 執行時系統要求在執行標準轉發時實現這個方法
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
return [self.proxyTarget methodSignatureForSelector:sel];
}
/**
* 當呼叫目標方法的選擇器與在AspectProxy物件中註冊的選擇器匹配時，forwardInvocation:會
* 呼叫目標物件中的方法，並根據條件語句的判斷結果呼叫AOP（面向切面程式設計）功能
*/
- (void)forwardInvocation:(NSInvocation *)invocation{
// 在呼叫目標方法前執行橫切功能
if ([self.invoker respondsToSelector:@selector(preInvoke:withTarget:)]) {
if (self.selectors != nil) {
SEL methodSel = [invocation selector];
for (NSValue *selValue in self.selectors) {
if (methodSel == [selValue pointerValue]) {
[[self invoker] preInvoke:invocation withTarget:self.proxyTarget];
break;
}
}
}else{
[[self invoker] preInvoke:invocation withTarget:self.proxyTarget];
}
}
// 呼叫目標方法
[invocation invokeWithTarget:self.proxyTarget];
// 在呼叫目標方法後執行橫切功能
if ([self.invoker respondsToSelector:@selector(postInvoke:withTarget:)]) {
if (self.selectors != nil) {
SEL methodSel = [invocation selector];
for (NSValue *selValue in self.selectors) {
if (methodSel == [selValue pointerValue]) {
[[self invoker] postInvoke:invocation withTarget:self.proxyTarget];
break;
}
}
}else{
[[self invoker] postInvoke:invocation withTarget:self.proxyTarget];
}
}
}複製程式碼接著我們定義一個代理協議
#import <Foundation/Foundation.h>
@protocol Invoker <NSObject>
@required
// 在呼叫物件中的方法前執行對功能的橫切
- (void)preInvoke:(NSInvocation *)inv withTarget:(id)target;
@optional
// 在呼叫物件中的方法後執行對功能的橫切
- (void)postInvoke:(NSInvocation *)inv withTarget:(id)target;
@end複製程式碼最後還需要一個遵守協議的類
#import <Foundation/Foundation.h>
#import "Invoker.h"
@interface AuditingInvoker : NSObject<Invoker>//遵守Invoker協議
@end
#import "AuditingInvoker.h"
@implementation AuditingInvoker
- (void)preInvoke:(NSInvocation *)inv withTarget:(id)target{
NSLog(@"before sending message with selector %@ to %@ object", NSStringFromSelector([inv selector]),[target className]);
}
- (void)postInvoke:(NSInvocation *)inv withTarget:(id)target{
NSLog(@"after sending message with selector %@ to %@ object", NSStringFromSelector([inv selector]),[target className]);
}
@end複製程式碼在這個遵循代理類裡面我們只實現協議裡面的兩個方法。
寫出測試程式碼
#import <Foundation/Foundation.h>
#import "AspectProxy.h"
#import "AuditingInvoker.h"
#import "Student.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
id student = [[Student alloc] init];
// 設定代理中註冊的選擇器陣列
NSValue *selValue1 = [NSValue valueWithPointer:@selector(study:andRead:)];
NSArray *selValues = @[selValue1];
// 建立AuditingInvoker
AuditingInvoker *invoker = [[AuditingInvoker alloc] init];
// 建立Student物件的代理studentProxy
id studentProxy = [[AspectProxy alloc] initWithObject:student selectors:selValues andInvoker:invoker];
// 使用指定的選擇器向該代理髮送訊息---例子1
[studentProxy study:@"Computer" andRead:@"Algorithm"];
// 使用還未註冊到代理中的其他選擇器，向這個代理髮送訊息！---例子2
[studentProxy study:@"mathematics" :@"higher mathematics"];
// 為這個代理註冊一個選擇器並再次向其傳送訊息---例子3
[studentProxy registerSelector:@selector(study::)];
[studentProxy study:@"mathematics" :@"higher mathematics"];
}
return 0;
}複製程式碼這裡有3個例子。裡面會分別輸出什麼呢？
before sending message with selector study:andRead: to Student object
Invorking method on Student object with selector study:andRead:
after sending message with selector study:andRead: to Student object
Invorking method on Student object with selector study::
before sending message with selector study:: to Student object
Invorking method on Student object with selector study::
after sending message with selector study:: to Student object複製程式碼例子1中會輸出3句話。呼叫Student物件的代理中的study:andRead:方法，會使該代理呼叫AuditingInvoker物件中的preInvoker:方法、真正目標（Student物件）中的study:andRead:方法，以及AuditingInvoker物件中的postInvoker:方法。一個方法的呼叫，呼叫起了3個方法。原因是study:andRead:方法是通過Student物件的代理註冊的；
例子2就只會輸出1句話。呼叫Student物件代理中的study::方法，因為該方法還未通過這個代理註冊，所以程式僅會將呼叫該方法的訊息轉發給Student物件，而不會呼叫AuditorInvoker方法。
例子3又會輸出3句話了。因為study::通過這個代理進行了註冊，然後程式再次呼叫它，在這次呼叫過程中，程式會呼叫AuditingInvoker物件中的AOP方法和真正目標（Student物件）中的study::方法。
這個例子就實現了一個簡單的AOP(Aspect Oriented Programming)面向切面程式設計。我們把一切功能"切"出去，與其他部分分開，這樣可以提高程式的模組化程度。AOP能解耦也能動態組裝，可以通過預編譯方式和執行期動態代理實現在不修改原始碼的情況下給程式動態統一新增功能。比如上面的例子三，我們通過把方法註冊到動態代理類中，於是就實現了該類也能處理方法的功能。
五. 入院考試
下面的程式碼會？Compile Error / Runtime Crash / NSLog…?
@interface NSObject (Sark) + (void)foo; @end @implementation NSObject (Sark) - (void)foo { NSLog(@"IMP: -[NSObject(Sark) foo]"); } @end int main(int argc, const char * argv[]) { @autoreleasepool { [NSObject foo]; [[NSObject new] foo]; } return 0; }複製程式碼
這道有兩處難點，難點一是給NSObject增加了一個分類，分類宣告的是一個加號的類方法，而實現中是一個減號的例項方法。在main中去NSObject去呼叫了這個foo方法，會編譯錯誤，還是會Crash呢？
難點二是會輸出什麼內容呢？
先來看難點一，這裡會牽扯到Category的知識。推薦文章還是美團的這篇經典的深入理解Objective-C：Category
void _objc_init(void)
{
static bool initialized = false;
if (initialized) return;
initialized = true;
// fixme defer initialization until an objc-using image is found?
environ_init();
tls_init();
lock_init();
exception_init();
// Register for unmap first, in case some +load unmaps something
_dyld_register_func_for_remove_image(&unmap_image);
dyld_register_image_state_change_handler(dyld_image_state_bound,
1/*batch*/, &map_images);
dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}複製程式碼OC在初始化的時候，會去載入map_images，map_images最終會呼叫objc-runtime-new.mm裡面的_read_images方法。_read_images方法裡面會去初始化記憶體中的map, 這個時候將會load所有的類，協議還有Category。NSOBject的+load方法就是這個時候呼叫的。
// Discover categories.
for (EACH_HEADER) {
category_t **catlist =
_getObjc2CategoryList(hi, &count);
for (i = 0; i < count; i++) {
category_t *cat = catlist[i];
class_t *cls = remapClass(cat->cls);
if (!cls) {
// Category's target class is missing (probably weak-linked).
// Disavow any knowledge of this category.
catlist[i] = NULL;
if (PrintConnecting) {
_objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
"missing weak-linked target class",
cat->name, cat);
}
continue;
}
// Process this category.
// First, register the category with its target class.
// Then, rebuild the class's method lists (etc) if
// the class is realized.
BOOL classExists = NO;
if (cat->instanceMethods || cat->protocols
|| cat->instanceProperties)
{
addUnattachedCategoryForClass(cat, cls, hi);
if (isRealized(cls)) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
getName(cls), cat->name,
classExists ? "on existing class" : "");
}
}
if (cat->classMethods || cat->protocols
/* || cat->classProperties */)
{
addUnattachedCategoryForClass(cat, cls->isa, hi);
if (isRealized(cls->isa)) {
remethodizeClass(cls->isa);
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
getName(cls), cat->name);
}
}
}
}複製程式碼在這個載入中，for迴圈中會反覆呼叫_getObjc2CategoryList 方法，這個方法的具體實現是：
// function name content type section name
GETSECT(_getObjc2CategoryList, category_t *, "__objc_catlist");複製程式碼最後一個引數__objc_catlist就是編譯器剛剛生成的category陣列。
載入完所有的category之後，就開始處理這些類別。大體思路還是分為2類來分開處理。
if (cat->instanceMethods || cat->protocols || cat->instanceProperties){
}複製程式碼第一類是例項方法
if (cat->classMethods || cat->protocols /* || cat->classProperties */) {
}複製程式碼第二類是類方法。
處理完之後的結果
1)、把category的例項方法、協議以及屬性新增到類上
2)、把category的類方法和協議新增到類的metaclass上
這兩種情況裡面的處理方式都差不多，先去呼叫addUnattachedCategoryForClass函式，申請記憶體，分配空間。remethodizeClass這個方法裡面會呼叫attachCategories方法。
attachCategories方法程式碼就不貼了，有興趣的可以自己去看看。這個方法裡面會用頭插法，把新加的方法從頭插入方法連結串列中。並且最後還會flushCaches。
這也就是為什麼我們可以在Category裡面覆蓋原有的方法的原因，因為頭插法，新的方法在連結串列的前面，會優先被遍歷到。
以上就是Category載入時候的流程。
再回到這道題目上面來，在載入NSObject的Category中，在編譯期會提示我們沒有實現+(void)foo的方法，因為在.m檔案中並沒有找到+的方法，而是一個-號的方法，所以會提示。
但是在實際載入Category的時候，會把-(void)foo載入進去，由於是例項方法，所以會放在NSObject的例項方法連結串列裡面。
根據第二章分析的objc_msgSend原始碼實現，我們可以知道：
在呼叫[NSObject foo]的時候，會先在NSObject的meta-class中去查詢foo方法的IMP，未找到，繼續在superClass中去查詢，NSObject的meta-class的superClass就是本身NSObject，於是又回到NSObject的類方法中查詢foo方法，於是乎找到了，執行foo方法，輸出
IMP: -[NSObject(Sark) foo]複製程式碼在呼叫[[NSObject new] foo]的時候，會先生成一個NSObject的物件，用這個NSObject例項物件再去呼叫foo方法的時候，會去NSObject的類方法裡面去查詢，找到，於是也會輸出
IMP: -[NSObject(Sark) foo]複製程式碼所以上面這題，不會Compile Error ，更不會 Runtime Crash ，會輸出兩個相同的結果。
六. Runtime中的優化
關於Runtime系統中，有3種地方進行了優化。
- 1.方法列表的快取
- 2.虛擬函式表vTable
- 3.dyld共享快取
1.方法列表的快取
在訊息傳送過程中，查詢IMP的過程，會優先查詢快取。這個快取會儲存最近使用過的方法都快取起來。這個cache和CPU裡面的cache的工作方式有點類似。原理是呼叫的方法有可能經常會被呼叫。如果沒有這個快取，直接去類方法的方法連結串列裡面去查詢，查詢效率實在太低。所以查詢IMP會優先搜尋飯方法快取，如果沒有找到，接著會在虛擬函式表中尋找IMP。如果找到了，就會把這個IMP儲存到快取中備用。
基於這個設計，使Runtime系統能能夠執行快速高效的方法查詢操作。
2.虛擬函式表
虛擬函式表也稱為分派表，是程式語言中常用的動態繫結支援機制。在OC的Runtime執行時系統庫實現了一種自定義的虛擬函式表分派機制。這個表是專門用來提高效能和靈活性的。這個虛擬函式表是用來儲存IMP型別的陣列。每個object-class都有這樣一個指向虛擬函式表的指標。
3.dyld共享快取
在我們的程式中，一定會有很多自定義類，而這些類中，很多SEL是重名的，比如alloc，init等等。Runtime系統需要為每一個方法給定一個SEL指標，然後為每次呼叫個各個方法更新後設資料，以獲取唯一值。這個過程是在應用程式啟動的時候完成。為了提高這一部分的執行效率，Runtime會通過dyld共享快取實現選擇器的唯一性。
dyld是一種系統服務，用於定位和載入動態庫。它含有共享快取，能夠使多個程式共用這些動態庫。dyld共享快取中含有一個選擇器表，從而能使執行時系統能夠通過使用快取訪問共享庫和自定義類的選擇器。
關於dyld的知識可以看看這篇文章dyld: Dynamic Linking On OS X
未完待續，請大家多多指教。