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

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

前言

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

方法的本质

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

//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的参数会报错

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类

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

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

声明一个MyTeacher类继承自MyPerson类

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

#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

#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_msgSend主要是拿到接收者的isa信息
ENTRY _objc_msgSend 
//---- 无窗口UNWIND _objc_msgSend, NoFrame //---- p0 和空对比，即判断接收者是否存在，其中p0是objc_msgSend的第一个参数-消息接收者receivercmp p0, #0          // nil check and tagged pointer check 
//---- le小于 --支持taggedpointer（小对象类型）的流程
#if SUPPORT_TAGGED_POINTERSb.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 // taggedadrp    x10, _objc_debug_taggedpointer_classes@PAGEadd x10, x10, _objc_debug_taggedpointer_classes@PAGEOFFubfx    x11, x0, #60, #4ldr x16, [x10, x11, LSL #3]adrp    x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGEadd x10, x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGEOFFcmp x10, x16b.ne    LGetIsaDone// ext taggedadrp    x10, _objc_debug_taggedpointer_ext_classes@PAGEadd x10, x10, _objc_debug_taggedpointer_ext_classes@PAGEOFFubfx    x11, x0, #52, #8ldr x16, [x10, x11, LSL #3]b   LGetIsaDone
// SUPPORT_TAGGED_POINTERS
#endifLReturnZero:// x0 is already zeromov x1, #0movi    d0, #0movi    d1, #0movi    d2, #0movi    d3, #0retEND_ENTRY _objc_msgSend

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

1. 判断传入的第一个参数receiver是否为空。若不为空看这个receiver是否支持tagged pointer。
   • 如果支持再跳转到LNilOrTagged函数之中，处理这个小对象的isa指针
2. 如果不为空且指针不为tagged pointer，我们就直接将receiver的isa指针取出存入p13寄存器适中，然后再调用GetClassFromIsa_p16，使用掩码将isa之中的shiftcls位域的内容取出来。
3. 将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，留下bucketsand 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 = bucketsand p11, p11, #0xf          // p11 = maskShiftmov p12, #0xfffflsr p11, p12, p11               // p11 = mask = 0xffff >> p11and 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) 
//--- 如果不相等，即没有找到，请跳转至 2fb.ne    2f          //     scan more 
//--- 如果相等 即cacheHit 缓存命中，直接返回impCacheHit $0         // call or return imp 2:  // not hit: p12 = not-hit bucket
//--- 如果一直都找不到， 因为是normal ，跳转至__objc_msgSend_uncachedCheckMiss $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 与 cmdb   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_4add 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-p9ldp p17, p9, [x12]      // {imp, sel} = *bucket //--- 比较 sel 与 p1（传入的参数cmd）
1:  cmp p9, p1          // if (bucket->sel != _cmd) 
//--- 如果不相等，即走到第二步b.ne    2f          //     scan more 
//--- 如果相等 即命中，直接返回impCacheHit $0         // call or return imp  2:  // not hit: p12 = not-hit bucket
//--- 如果一直找不到，则CheckMissCheckMiss $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 与 cmdb   1b          // loop LLookupEnd$1:
LLookupRecover$1:
3:  // double wrap
//--- 跳转至JumpMiss 因为是normal ，跳转至__objc_msgSend_uncachedJumpMiss $0 
.endmacro//以下是最后跳转的汇编函数
.macro CacheHit
.if $0 == NORMALTailCallCachedImp x17, x12, x1, x16 // authenticate and call imp
.elseif $0 == GETIMPmov p0, p17cbz p0, 9f          // don't ptrauth a nil impAuthAndResignAsIMP 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 IMPret             // return imp via x17
.else
.abort oops
.endif
.endmacro.macro CheckMiss// miss if bucket->sel == 0
.if $0 == GETIMP 
//--- 如果为GETIMP ，则跳转至 LGetImpMisscbz p9, LGetImpMiss
.elseif $0 == NORMAL 
//--- 如果为NORMAL ，则跳转至 __objc_msgSend_uncachedcbz p9, __objc_msgSend_uncached
.elseif $0 == LOOKUP 
//--- 如果为LOOKUP ，则跳转至 __objc_msgLookup_uncachedcbz p9, __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro.macro JumpMiss
.if $0 == GETIMPb   LGetImpMiss
.elseif $0 == NORMALb   __objc_msgSend_uncached
.elseif $0 == LOOKUPb   __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro

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

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

慢速查找流程

__objc_msgSend_uncached汇编函数内容

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 searchMethodTableLookup // 开始查询方法列表
TailCallFunctionPointer x17END_ENTRY __objc_msgSend_uncached

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

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;}//当前类 = 当前类的父类，并判断父类是否为nilif (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;
}

流程：

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

实现和初始化的区别

实现：

• 分配类的可读写数据（class_rw_t 结构）。
• 解析并注册类的方法列表、属性和协议。
• 确定类的父类及元类关系，确保继承链完整。

初始化：

• 初始化静态变量或全局状态。
• 执行一次性的配置代码（如注册通知、加载资源）

4. for循环遍历继承链，根据getMethodNoSuper_nolock->getMethodFromListArray / getMethodFromRelativeList->search_method_list_inline函数进行进行寻找

   • 对于无序的方法列表，我们使用findMethodInUnsortedMethodList，使用for循环遍历对比sel

   • findMethodInSortedMethodList查找有序的方法列表，通过二分查找对比sel取出method_t

     

5. 当遍历发现父类链之中存在循环则报错，终止循环，如果找到对应选择子，则直接返回imp，执行写入流程

6. 判断是否执行过动态方法解析

   • 如果没有，执行动态方法解析
   • 如果执行过一次动态方法解析，则走到消息转发流程

findMethodInSortedMethodList查找流程探究

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 等于 say666uint32_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函数里，可以看到动态方法解析的入口逻辑：

    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，并且只会执行一次。

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 itreturn lookUpImpOrForwardTryCache(inst, sel, cls, behavior);
}

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

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

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

消息转发流程

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

快速转发forwardingTargetForSelector

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

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

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

适用场景

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

慢速转发——methodSignatureForSelector和forwardInvocation

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

// 生成方法签名
- (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];}
}

参考文章

iOS 消息发送、动态方法解析和消息转发 objc4-838.1源码

手撕iOS底层13 – 手摸手的助你理清objc_msgSend汇编源码

面试遇到Runtime的第三天-消息转发

iOS-底层原理 12：消息流程分析之快速查找

iOS-底层原理 14：消息流程分析之 动态方法决议 & 消息转发