「OC」源码学习—— 消息发送、动态方法解析和消息转发

「OC」源码学习------ 消息发送、动态方法解析和消息转发

前言

前面我们在学习alloc源码的时候，就在callAlloc源码之中简单的探究过，类初始化缓存的问题，我们知道在一个类第一次被实例化的时候，会调用objc_msgSend去二次调用alloc方法，这篇文章就是探究我们在调用方法的时候，会需要经历一个什么流程。

方法的本质

我们可以通过clang编译main.m文件可以查看main函数之中方法的调用

objc 复制代码

//main.m中方法的调用
LGPerson *person = [LGPerson alloc];
[person sayNB];
[person sayHello];

//👇clang编译后的底层实现
LGPerson *person = ((LGPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("LGPerson"), sel_registerName("alloc"));
((void (*)(id, SEL))(void *)objc_msgSend)((id)person, sel_registerName("sayNB"));
((void (*)(id, SEL))(void *)objc_msgSend)((id)person, sel_registerName("sayHello"));

我们之前在小蓝书之中也学习过，方法的调用本质上就是进行消息发送

我们可以在编译器之中进行简单的尝试

1、直接调用objc_msgSend，需要导入头文件#import <objc/message.h>

2、需要将target --> Build Setting -->搜索msg -- 将enable strict checking of obc_msgSend calls由YES 改为NO，将严厉的检查机制关掉，否则objc_msgSend的参数会报错

objc 复制代码

GGObject *obj = [[GGObject alloc] init];
((void (*)(id, SEL))objc_msgSend)(obj, @selector(speak));
[obj speak];
[obj sayHello];

//结果

-[GGObject speak]
-[GGObject speak]
-[GGObject sayHello]

我们会发现，使用方法调用和使用它objc_msgSend得到的结果也是一样的

objc_msgSend和objc_msgSendSuper的区别

来看看这么一个案例：

声明一个MyPerson类

objectivec 复制代码

#import <Foundation/Foundation.h>
@interface MyPerson : NSObject
-(void)study;
@end

css 复制代码

#import "MyPerson.h"
@implementation MyPerson
-(void)study {
    NSLog(@"%s",__func__);
}
@end

声明一个MyTeacher类继承自MyPerson类

objectivec 复制代码

#import "MyPerson.h"
@interface MyTeacher : MyPerson
@end

objectivec 复制代码

#import "MyTeacher.h"
#import <objc/message.h>
@implementation MyTeacher
-(instancetype)init {
    if (self = [super init]) {
        NSLog(@"%@",[self class]);
        NSLog(@"%@",[super class]);
    }
    return self;
}
-(void)study {
     [super study];
}
@end

在ViewContriller里使用这个MyTeacher

objectivec 复制代码

#import "ViewController.h"
#import "MyTeacher.h"
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    MyTeacher *t = [[MyTeacher alloc] init];
    [t study];
}
@end

完整消息流程

`objc_msgSend`的汇编实现

我们点进Objc源码之中关于objc_msgSend的相关内容，会发现它是汇编实现的，这里借用一下大佬月月的给出的函数注释。iOS-底层原理 12：消息流程分析之快速查找

objc 复制代码

//---- 消息发送 -- 汇编入口--objc_msgSend主要是拿到接收者的isa信息
ENTRY _objc_msgSend 
//---- 无窗口
    UNWIND _objc_msgSend, NoFrame 
    
//---- p0 和空对比，即判断接收者是否存在，其中p0是objc_msgSend的第一个参数-消息接收者receiver
    cmp p0, #0          // nil check and tagged pointer check 
//---- le小于 --支持taggedpointer（小对象类型）的流程
#if SUPPORT_TAGGED_POINTERS
    b.le    LNilOrTagged        //  (MSB tagged pointer looks negative) 
#else
//---- p0 等于 0 时，直接返回 空
    b.eq    LReturnZero 
#endif 
//---- p0即receiver 肯定存在的流程
//---- 根据对象拿出isa ，即从x0寄存器指向的地址 取出 isa，存入 p13寄存器
    ldr p13, [x0]       // p13 = isa 
//---- 在64位架构下通过 p16 = isa（p13） & ISA_MASK，拿出shiftcls信息，得到class信息
    GetClassFromIsa_p16 p13     // p16 = class 
LGetIsaDone:
    // calls imp or objc_msgSend_uncached 
//---- 如果有isa，走到CacheLookup 即缓存查找流程，也就是所谓的sel-imp快速查找流程
    CacheLookup NORMAL, _objc_msgSend

#if SUPPORT_TAGGED_POINTERS
LNilOrTagged:
//---- 等于空，返回空
    b.eq    LReturnZero     // nil check 

    // tagged
    adrp    x10, _objc_debug_taggedpointer_classes@PAGE
    add x10, x10, _objc_debug_taggedpointer_classes@PAGEOFF
    ubfx    x11, x0, #60, #4
    ldr x16, [x10, x11, LSL #3]
    adrp    x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGE
    add x10, x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGEOFF
    cmp x10, x16
    b.ne    LGetIsaDone

    // ext tagged
    adrp    x10, _objc_debug_taggedpointer_ext_classes@PAGE
    add x10, x10, _objc_debug_taggedpointer_ext_classes@PAGEOFF
    ubfx    x11, x0, #52, #8
    ldr x16, [x10, x11, LSL #3]
    b   LGetIsaDone
// SUPPORT_TAGGED_POINTERS
#endif

LReturnZero:
    // x0 is already zero
    mov x1, #0
    movi    d0, #0
    movi    d1, #0
    movi    d2, #0
    movi    d3, #0
    ret

    END_ENTRY _objc_msgSend

我们再来探究一下objc_msgSend的整体流程

判断传入的第一个参数receiver是否为空。若不为空看这个receiver是否支持tagged pointer。
- 如果支持再跳转到LNilOrTagged函数之中，处理这个小对象的isa指针
如果不为空且指针不为tagged pointer，我们就直接将receiver的isa指针取出存入p13寄存器适中，然后再调用GetClassFromIsa_p16，使用掩码将isa之中的shiftcls位域的内容取出来。
将isa的信息提取出来之后，进入CacheLookup函数，进入快速流程查找

快速查找流程

复制代码

// CacheLookup的汇编源码
.macro CacheLookup 
    //
    // Restart protocol:
    //
    //   As soon as we're past the LLookupStart$1 label we may have loaded
    //   an invalid cache pointer or mask.
    //
    //   When task_restartable_ranges_synchronize() is called,
    //   (or when a signal hits us) before we're past LLookupEnd$1,
    //   then our PC will be reset to LLookupRecover$1 which forcefully
    //   jumps to the cache-miss codepath which have the following
    //   requirements:
    //
    //   GETIMP:
    //     The cache-miss is just returning NULL (setting x0 to 0)
    //
    //   NORMAL and LOOKUP:
    //   - x0 contains the receiver
    //   - x1 contains the selector
    //   - x16 contains the isa
    //   - other registers are set as per calling conventions
    //
LLookupStart$1:

//---- p1 = SEL, p16 = isa --- #define CACHE (2 * __SIZEOF_POINTER__)，其中 __SIZEOF_POINTER__表示pointer的大小 ，即 2*8 = 16
//---- p11 = mask|buckets -- 从x16（即isa）中平移16字节，取出cache 存入p11寄存器 -- isa距离cache 正好16字节：isa（8字节）-superClass（8字节）-cache（mask高16位 + buckets低48位）
    ldr p11, [x16, #CACHE]              
//---- 64位真机
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16 
//--- p11(cache) & 0x0000ffffffffffff ，mask高16位抹零，得到buckets 存入p10寄存器-- 即去掉mask，留下buckets
    and p10, p11, #0x0000ffffffffffff   // p10 = buckets 
    
//--- p11(cache)右移48位，得到mask（即p11 存储mask），mask & p1(msgSend的第二个参数 cmd-sel) ，得到sel-imp的下标index（即搜索下标） 存入p12（cache insert写入时的哈希下标计算是 通过 sel & mask，读取时也需要通过这种方式）
    and p12, p1, p11, LSR #48       // x12 = _cmd & mask 

//--- 非64位真机
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4 
    and p10, p11, #~0xf         // p10 = buckets
    and p11, p11, #0xf          // p11 = maskShift
    mov p12, #0xffff
    lsr p11, p12, p11               // p11 = mask = 0xffff >> p11
    and p12, p1, p11                // x12 = _cmd & mask
#else
#error Unsupported cache mask storage for ARM64.
#endif

//--- p12是下标 p10是buckets数组首地址，下标 * 1<<4(即16) 得到实际内存的偏移量，通过buckets的首地址偏移，获取bucket存入p12寄存器
//--- LSL #(1+PTRSHIFT)-- 实际含义就是得到一个bucket占用的内存大小 -- 相当于mask = occupied -1-- _cmd & mask -- 取余数
    add p12, p10, p12, LSL #(1+PTRSHIFT)   
                     // p12 = buckets + ((_cmd & mask) << (1+PTRSHIFT)) -- PTRSHIFT是3
                     
//--- 从x12（即p12）中取出 bucket 分别将imp和sel 存入 p17（存储imp） 和 p9（存储sel）
    ldp p17, p9, [x12]      // {imp, sel} = *bucket 
    
//--- 比较 sel 与 p1（传入的参数cmd）
1:  cmp p9, p1          // if (bucket->sel != _cmd) 
//--- 如果不相等，即没有找到，请跳转至 2f
    b.ne    2f          //     scan more 
//--- 如果相等 即cacheHit 缓存命中，直接返回imp
    CacheHit $0         // call or return imp 
    
2:  // not hit: p12 = not-hit bucket
//--- 如果一直都找不到， 因为是normal ，跳转至__objc_msgSend_uncached
    CheckMiss $0            // miss if bucket->sel == 0 
//--- 判断p12（下标对应的bucket） 是否 等于 p10（buckets数组第一个元素，），如果等于，则跳转至第3步
    cmp p12, p10        // wrap if bucket == buckets 
//--- 定位到最后一个元素（即第一个bucket）
    b.eq    3f 
//--- 从x12（即p12 buckets首地址）- 实际需要平移的内存大小BUCKET_SIZE，得到得到第二个bucket元素，imp-sel分别存入p17-p9，即向前查找
    ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket 
//--- 跳转至第1步，继续对比 sel 与 cmd
    b   1b          // loop 

3:  // wrap: p12 = first bucket, w11 = mask
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
//--- 人为设置到最后一个元素
//--- p11（mask）右移44位 相当于mask左移4位，直接定位到buckets的最后一个元素，缓存查找顺序是向前查找
    add p12, p12, p11, LSR #(48 - (1+PTRSHIFT)) 
                    // p12 = buckets + (mask << 1+PTRSHIFT) 
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    add p12, p12, p11, LSL #(1+PTRSHIFT)
                    // p12 = buckets + (mask << 1+PTRSHIFT)
#else
#error Unsupported cache mask storage for ARM64.
#endif

    // Clone scanning loop to miss instead of hang when cache is corrupt.
    // The slow path may detect any corruption and halt later.
//--- 再查找一遍缓存()
//--- 拿到x12（即p12）bucket中的 imp-sel 分别存入 p17-p9
    ldp p17, p9, [x12]      // {imp, sel} = *bucket 
    
//--- 比较 sel 与 p1（传入的参数cmd）
1:  cmp p9, p1          // if (bucket->sel != _cmd) 
//--- 如果不相等，即走到第二步
    b.ne    2f          //     scan more 
//--- 如果相等 即命中，直接返回imp
    CacheHit $0         // call or return imp  
    
2:  // not hit: p12 = not-hit bucket
//--- 如果一直找不到，则CheckMiss
    CheckMiss $0            // miss if bucket->sel == 0 
//--- 判断p12（下标对应的bucket） 是否 等于 p10（buckets数组第一个元素）-- 表示前面已经没有了，但是还是没有找到
    cmp p12, p10        // wrap if bucket == buckets 
    b.eq    3f //如果等于，跳转至第3步
//--- 从x12（即p12 buckets首地址）- 实际需要平移的内存大小BUCKET_SIZE，得到得到第二个bucket元素，imp-sel分别存入p17-p9，即向前查找
    ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket 
//--- 跳转至第1步，继续对比 sel 与 cmd
    b   1b          // loop 

LLookupEnd$1:
LLookupRecover$1:
3:  // double wrap
//--- 跳转至JumpMiss 因为是normal ，跳转至__objc_msgSend_uncached

    JumpMiss $0 
.endmacro

//以下是最后跳转的汇编函数
.macro CacheHit
.if $0 == NORMAL
    TailCallCachedImp x17, x12, x1, x16 // authenticate and call imp
.elseif $0 == GETIMP
    mov p0, p17
    cbz p0, 9f          // don't ptrauth a nil imp
    AuthAndResignAsIMP x0, x12, x1, x16 // authenticate imp and re-sign as IMP
9:  ret             // return IMP
.elseif $0 == LOOKUP
    // No nil check for ptrauth: the caller would crash anyway when they
    // jump to a nil IMP. We don't care if that jump also fails ptrauth.
    AuthAndResignAsIMP x17, x12, x1, x16    // authenticate imp and re-sign as IMP
    ret             // return imp via x17
.else
.abort oops
.endif
.endmacro

.macro CheckMiss
    // miss if bucket->sel == 0
.if $0 == GETIMP 
//--- 如果为GETIMP ，则跳转至 LGetImpMiss
    cbz p9, LGetImpMiss
.elseif $0 == NORMAL 
//--- 如果为NORMAL ，则跳转至 __objc_msgSend_uncached
    cbz p9, __objc_msgSend_uncached
.elseif $0 == LOOKUP 
//--- 如果为LOOKUP ，则跳转至 __objc_msgLookup_uncached
    cbz p9, __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro

.macro JumpMiss
.if $0 == GETIMP
    b   LGetImpMiss
.elseif $0 == NORMAL
    b   __objc_msgSend_uncached
.elseif $0 == LOOKUP
    b   __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro

前面我们已经通过objc_msgSend获取了消息发送的receiver的类信息，根据我们之前学习的内容可以知道，objc_class的首地址偏移16字节就是cache_t。

在objc_class偏移16字节 获取cache_t之中的内容
根据我们之前在cache_t的分析，在objc 838 的源码之中，_bucketsAndMaybeMask是一个指向64位内存的指针，高16位存储掩码，低48位作为存储buckets，在这个函数之中使用移位运算符将这两个内存取出
将我们objc_msgSend的第二个参数的选择子进行哈希运算，查找buckets的下标的位置的选择子和我们传入的选择子是否一样，如果不一样就不断的往前遍历（因为要考虑哈希冲突 ，系统解决哈希冲突的方法是使用开放寻址法 ），而当我们遍历到bucket到第一个元素，我们再把指针指向buckets到最后一个元素
- 如果找到匹配项，那么直接调用cacheHit方法
- 如果程序第二次到达bucket的首元素位置，则说明cache_t未存储相关信息，则直接跳转_objc_msgSend_uncached进入慢速查找流程

慢速查找流程

__objc_msgSend_uncached汇编函数内容

objc 复制代码

STATIC_ENTRY __objc_msgSend_uncached
UNWIND __objc_msgSend_uncached, FrameWithNoSaves

// THIS IS NOT A CALLABLE C FUNCTION
// Out-of-band p16 is the class to search
    
MethodTableLookup // 开始查询方法列表
TailCallFunctionPointer x17

END_ENTRY __objc_msgSend_uncached

此时这个MethodTableLookup最终都会跳转到lookUpImpOrForward，这里仍然借用月月的源码注释：iOS-底层原理 13：消息流程分析之慢速查找

objc 复制代码

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    // 定义的消息转发
    const IMP forward_imp = (IMP)_objc_msgForward_impcache; 
    IMP imp = nil;
    Class curClass;

    runtimeLock.assertUnlocked();

    // 快速查找，如果找到则直接返回imp
    //目的：防止多线程操作时，刚好调用函数，此时缓存进来了
    if (fastpath(behavior & LOOKUP_CACHE)) { 
        imp = cache_getImp(cls, sel);
        if (imp) goto done_nolock;
    }
    
    //加锁，目的是保证读取的线程安全
    runtimeLock.lock();
    
    //判断是否是一个已知的类：判断当前类是否是已经被认可的类，即已经加载的类
    checkIsKnownClass(cls); 
    
    //判断类是否实现，如果没有，需要先实现，此时的目的是为了确定父类链，方法后续的循环
    if (slowpath(!cls->isRealized())) { 
        cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
    }

    //判断类是否初始化，如果没有，需要先初始化
    if (slowpath((behavior & LOOKUP_INITIALIZE) && !cls->isInitialized())) { 
        cls = initializeAndLeaveLocked(cls, inst, runtimeLock);
    }

    runtimeLock.assertLocked();
    curClass = cls;

    //----查找类的缓存
    
    // unreasonableClassCount -- 表示类的迭代的上限
    //（猜测这里递归的原因是attempts在第一次循环时作了减一操作，然后再次循环时,仍在上限的范围内，所以可以继续递归）
    for (unsigned attempts = unreasonableClassCount();;) { 
        //---当前类方法列表（采用二分查找算法），如果找到，则返回，将方法缓存到cache中
        Method meth = getMethodNoSuper_nolock(curClass, sel);
        if (meth) {
            imp = meth->imp;
            goto done;
        }
        //当前类 = 当前类的父类，并判断父类是否为nil
        if (slowpath((curClass = curClass->superclass) == nil)) {
            //--未找到方法实现，方法解析器也不行，使用转发
            imp = forward_imp;
            break;
        }

        // 如果父类链中存在循环，则停止
        if (slowpath(--attempts == 0)) {
            _objc_fatal("Memory corruption in class list.");
        }

        // --父类缓存
        imp = cache_getImp(curClass, sel);
        if (slowpath(imp == forward_imp)) { 
            // 如果在父类中找到了forward，则停止查找，且不缓存，首先调用此类的方法解析器
            break;
        }
        if (fastpath(imp)) {
            //如果在父类中，找到了此方法，将其存储到cache中
            goto done;
        }
    }

    //没有找到方法实现，尝试一次方法解析

    if (slowpath(behavior & LOOKUP_RESOLVER)) {
        //动态方法决议的控制条件，表示流程只走一次
        behavior ^= LOOKUP_RESOLVER; 
        return resolveMethod_locked(inst, sel, cls, behavior);
    }

 done:
    //存储到缓存
    log_and_fill_cache(cls, imp, sel, inst, curClass); 
    //解锁
    runtimeLock.unlock();
 done_nolock:
    if (slowpath((behavior & LOOKUP_NIL) && imp == forward_imp)) {
        return nil;
    }
    return imp;
}

流程：

进入LookUpImpOrForward函数，首先就是再次检查缓存，这一步是为了在多线程的情况下，当我们进入这个函数的时候，新的混粗已经存入cache_t
接着就是给程序加锁，防止我们在程序之中查看buckets是，因为重复添加缓存导致指针错误
查看是否是已知类，且类是否实现再查看类是否进行初始化

实现和初始化的区别

实现：

分配类的可读写数据（class_rw_t 结构）。

解析并注册类的方法列表、属性和协议。

确定类的父类及元类关系，确保继承链完整。

初始化：

初始化静态变量或全局状态。

执行一次性的配置代码（如注册通知、加载资源）

for循环遍历继承链，根据getMethodNoSuper_nolock->getMethodFromListArray / getMethodFromRelativeList->search_method_list_inline函数进行进行寻找
- 对于无序的方法列表，我们使用findMethodInUnsortedMethodList，使用for循环遍历对比sel
- findMethodInSortedMethodList查找有序的方法列表，通过二分查找对比sel取出method_t
当遍历发现父类链之中存在循环则报错，终止循环，如果找到对应选择子，则直接返回imp，执行写入流程
判断是否执行过动态方法解析
- 如果没有，执行动态方法解析
- 如果执行过一次动态方法解析，则走到消息转发流程

`findMethodInSortedMethodList`查找流程探究

objc 复制代码

ALWAYS_INLINE static method_t *
findMethodInSortedMethodList(SEL key, const method_list_t *list)
{
    ASSERT(list);

    const method_t * const first = &list->first;
    const method_t *base = first;
    const method_t *probe;
    uintptr_t keyValue = (uintptr_t)key; //key 等于 say666
    uint32_t count;
    //base相当于low，count是max，probe是middle，这就是二分
    for (count = list->count; count != 0; count >>= 1) {
        //从首地址+下标 --> 移动到中间位置（count >> 1 右移1位即 count/2 = 4）
        probe = base + (count >> 1); 
        
        uintptr_t probeValue = (uintptr_t)probe->name;
        
        //如果查找的key的keyvalue等于中间位置（probe）的probeValue，则直接返回中间位置
        if (keyValue == probeValue) { 
            // -- while 平移 -- 排除分类重名方法
            while (probe > first && keyValue == (uintptr_t)probe[-1].name) {
                //排除分类重名方法（方法的存储是先存储类方法，在存储分类---按照先进后出的原则，分类方法最先出，而我们要取的类方法，所以需要先排除分类方法）
                //如果是两个分类，就看谁先进行加载
                probe--;
            }
            return (method_t *)probe;
        }
        
        //如果keyValue 大于 probeValue，就往probe即中间位置的右边查找
        if (keyValue > probeValue) { 
            base = probe + 1;
            count--;
        }
    }
    
    return nil;
}

从第一次查找开始就取中间位置，与想查找的value进行对比，如果相等，还需要使用while循环，逐步向前搜索，目的是排除分类方法（因为分类方法会被插入到方法的最前端）；若不相等，则继续进行二分查找，直到count为0

消息转发流程

在快慢两次查找都没有找到方法实现的情况下，我们会进行以下操作

动态方法决议：慢速查找流程未找到后，会执行一次动态方法决议
消息转发：如果动态方法决议仍然没有找到实现，则进行消息转发

动态方法解析`resolveMethod_locked`

我们在lookUpImpOrForward函数里，可以看到动态方法解析的入口逻辑：

objc 复制代码

    if (slowpath(behavior & LOOKUP_RESOLVER)) {
        //动态方法决议的控制条件，表示流程只走一次
        behavior ^= LOOKUP_RESOLVER; 
        return resolveMethod_locked(inst, sel, cls, behavior);
    }

当本类和本类继承链下的cache和method list都查找不到imp，imp被赋值成了_objc_msgForward_impcache但是它没有调用，会进入动态方法解析流程resolveMethod_locked，并且只会执行一次。

objc 复制代码

static NEVER_INLINE IMP
resolveMethod_locked(id inst, SEL sel, Class cls, int behavior)
{
    runtimeLock.assertLocked();
    ASSERT(cls->isRealized());

    runtimeLock.unlock();
    //判断是不是元类
    if (! cls->isMetaClass()) {
        // 不是元类，则是实例方法的动态方法解析
        // try [cls resolveInstanceMethod:sel]
        resolveInstanceMethod(inst, sel, cls);
    } 
    else {
        // 是元类，则是类方法的动态方法解析
        // try [nonMetaClass resolveClassMethod:sel]
        // and [cls resolveInstanceMethod:sel]
        resolveClassMethod(inst, sel, cls); // inst：类对象   cls： 元类
        if (!lookUpImpOrNilTryCache(inst, sel, cls)) {
            resolveInstanceMethod(inst, sel, cls);
        }
    }

    // chances are that calling the resolver have populated the cache
    // so attempt using it
    return lookUpImpOrForwardTryCache(inst, sel, cls, behavior);
}

如果是类，执行实例方法的动态方法决议resolveInstanceMethod
如果是元类，执行类方法的动态方法决议resolveClassMethod，如果在元类中没有找到其对应的类方法，则在元类的实例方法的动态方法决议resolveInstanceMethod中查找，主要是因为类方法在元类中是实例方法，所以还需要查找元类中实例方法的动态方法决议
在动态方法决议消息前，需要查找cls类中是否有该方法的实现，即通过lookUpImpOrNil方法又会进入lookUpImpOrForward慢速查找流程查找resolveInstanceMethod方法
- 如果没有，则直接返回
- 如果有，则发送resolveInstanceMethod消息（为了防止程序死循环，所以我们在一整个消息流程之中只会运行一次动态消息转发）

以下是如何实现动态方法决议

objc 复制代码

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if (sel == @selector(say666)) {
        NSLog(@"%@ 来了", NSStringFromSelector(sel));
        //获取sayMaster方法的imp
        IMP imp = class_getMethodImplementation(self, @selector(sayMaster));
        //获取sayMaster的实例方法
        Method sayMethod  = class_getInstanceMethod(self, @selector(sayMaster));
        //获取sayMaster的丰富签名
        const char *type = method_getTypeEncoding(sayMethod);
        //将sel的实现指向sayMaster
        return class_addMethod(self, sel, imp, type);
    }
    
    return [super resolveInstanceMethod:sel];
}

消息转发流程

在慢速查找的流程中，我们了解到，如果快速+慢速没有找到方法实现，动态方法决议也不行，就使用消息转发，这个流程同样被分为快速转发和慢速转发

快速转发`forwardingTargetForSelector`

首先我们要知道快速转发进入了一个什么函数

复制代码

objc 复制代码

- (id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(sayHello)) {
        return [LGPerson new]; // 返回其他类中实现过这个方法的方法.
    }
    return [super forwardingTargetForSelector:aSelector];
}

作用：将消息转发给LGPerson，由它响应消息。
特点：
- 无需生成方法签名或 NSInvocation 对象，性能较高。
- 转发后，消息的接收者变为LGPerson，对外透明

适用场景

伪多继承：通过转发实现多个对象的功能组合，例如将不同职责的消息分发给不同对象处理
代理模式：将消息转发给代理对象，简化主对象逻辑

慢速转发------`methodSignatureForSelector`和`forwardInvocation`

首先我们一定要重写methodSignatureForSelector，返回一个方法签名。在上一步我们返回了一个方法签名，那么在运行时系统就会创建一个NSInvocation 对象，传入forwardInvocation，再次进行转发。

objc 复制代码

// 生成方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (aSelector == @selector(unimplementedMethod)) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];  // 返回方法签名
    }
    return [super methodSignatureForSelector:aSelector];
}

// 处理转发逻辑
- (void)forwardInvocation:(NSInvocation *)anInvocation {
    if ([_backupObject respondsToSelector:anInvocation.selector]) {
        [anInvocation invokeWithTarget:_backupObject];  // 调用备用对象
    } else {
        [super forwardInvocation:anInvocation];
    }
}