iOS 无感知埋点的原理

iOS开发中，一般使用hook的方式实现无感知埋点，hook过程一般在load方法中，通过方法的exchange来实现。

1. 关于 load 方法

类的+ (void)load 方法的加载发生在main函数之前，即pre-main阶段。因此，load方法中的逻辑要尽可能的简单，尽量不影响到APP的启动速度。

如果父类、子类、Category都实现了load方法，load的执行顺序是什么呢？
答：父类 > 子类 > Category分类。

如果有父类/子类有多个Category分类，那么这多个Category分类的load的执行顺序是什么呢？
答：编译资源的顺序决定了Category的执行顺序。可在工程配置的Build Phases选项中，设置Compile Sources中拖动分类的编译顺序。

如果有多个父类/子类，且有多个Category分类呢，那么这多个父类/子类、多个Category分类的load的执行顺序是什么呢？
答：先所有的父类、子类的load，然后再执行分类的load。

1. +load方法是在加载类和分类时系统调用，一般不手动调用，如果想要在类或分类加载时做一些事情，可以重写类或者分类的+load方法方法；
2. 每个类、分类的+load，在程序运行过程中只调用一次;

1. 类要优先于分类调用+load方法；
2. 子类调用+load方法时，要先要调用父类的+load方法；(父类优先与子类，与继承不同)；
3. 不同的类按照编译先后顺序调用+load方法（先编译，先调用）；
4. 分类的按照编译先后顺序调用+load方法（先编译，先调用）。

2. load 特殊执行顺序的原因

在 runtime 底层，会调用 prepare_load_methods 方法来准备好要被调用的 load 方法，具体方法实现：

void prepare_load_methods(const headerType *mhdr)
{
    size_t count, i;
    runtimeLock.assertWriting();
    classref_t *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }
    category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
    for (i = 0; i < count; i++) {
        category_t *cat = categorylist[i];
        Class cls = remapClass(cat->cls);
        if (!cls) continue;  // category for ignored weak-linked class
        realizeClass(cls);
        assert(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}
//// 其中：
//classref_t *classlist = _getObjc2NonlazyClassList(mhdr, &count); //类列表
//category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count); //分类列表

static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized());  // _read_images should realize

if (cls->data()->flags & RW_LOADED) return;

// Ensure superclass-first ordering
schedule_class_load(cls->superclass);

add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED); 
}
//// 其中：
// schedule_class_load(cls->superclass); //在调度类的load方法前，要先跳用父类的load方法（递归），决定了父类优先于子类调用
// add_class_to_loadable_list(cls);  //添加到能够加载的类的列表中

void call_load_methods(void)
{
static bool loading = NO;
bool more_categories;

loadMethodLock.assertLocked();

// Re-entrant calls do nothing; the outermost call will finish the job.
if (loading) return;
loading = YES;

void *pool = objc_autoreleasePoolPush();

do {
// 1. Repeatedly call class +loads until there aren't any more
while (loadable_classes_used > 0) {
call_class_loads();
}

// 2. Call category +loads ONCE
more_categories = call_category_loads();

// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0  ||  more_categories);

objc_autoreleasePoolPop(pool);

loading = NO;
}

当prepare_load_methods函数执行完之后，所有满足+load方法调用条件的类和分类就被分别保持在全局变量中；

当prepare_load_methods执行完，准备好类和分类后，就该调用他们的+load方法啦，在call_load_methods中进行调用；注意图中红色圈内部分，两个关键函数：call_class_loads()、call_category_loads() ，就是这两个函数决定了类优先与分类调用+load方法；

说明：+load方法是系统根据方法地址直接调用，并不是objc_msgSend函数调用（isa，superClass）；这就决定了如果子类没有实现+load方法，那么当它被加载时runtime是不会调用父类的+load方法的，除非父类也实现了+load方法；

load、initialize方法的区别

• 调用方式
  load是根据函数地址直接调用
  initialize是通过objc_msgSend调用

• 调用时刻
  load是runtime加载类、分类的时候调用（只会调用1次）
  initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）

• 调用顺序
  load：
  先调用类的load
  先编译的类，优先调用load
  调用子类的load之前，会先调用父类的load
  再调用分类的load
  先编译的分类，优先调用load
  initialize：
  先初始化父类
  再初始化子类（可能最终调用的是父类的initialize方法）

3. 方法的交换

交换系统方法也属于runtime的一部分，需要导入<objc/runtime.h>。
取出系统方法与你写的方法

#import <objc/runtime.h>

// 取出系统方法与自定义的方法
Method systemMethod = class_getInstanceMethod(self, @selector(systemMethod));
Method my_Method = class_getInstanceMethod(self, @selector(my_Method));

// 方法的交换
method_exchangeImplementations(systemMethod, my_Method);

一般交换的过程放在load中，如交换系统方法layoutSubviews与自定义的my_layoutSubviews，过程如下：

+ (void)load {
  Method systemMethod = class_getInstanceMethod(self, @selector(layoutSubviews));
  Method my_Method = class_getInstanceMethod(self, @selector(my_layoutSubviews));
  method_exchangeImplementations(systemMethod, my_Method);
}

- (void)layoutSubviews {
  [super layoutSubviews];
}
    
- (void)my_layoutSubviews {
        
  // 如果这么写,调用的就是my_layoutSubviews.就会循环引用.
  //[self layoutSubviews];
        
  // 正确写法
  [self my_layoutSubviews];
}

4. 埋点

我想你已经猜到该如何埋点了。通过上述一番操作，基本可以对工程里的类进行无感知拦截，并在自定义的交换方法中，获取及记录相关信息，然后择时上报。

load方法的处理
由于load是NSObject的方法，因此我们可以对UIControl、UITablview、UITapGesture、UIViewController等任何类去实现他们的分类，从而hook相关方法，去拦截事件、pv等统计的点。

如，UIControl的sendAction方法，UITablview的代理方法didSelected等；
如，对UITapGesturehook其中的初始化方法，并在自定义的初始化方法中，再次hook其传入的action对应的originalSEL，将其交换为自定义的目标action，并在其中统计埋点。

load方法的注意事项
一般需要确保只调用一次交换：

+(void)load
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 交换操作
});
}

为不影响原代码调用逻辑，交换过的自定义方法中仍然要调用原方法：

- (void)my_layoutSubviews {
        
  // 如果这么写,调用的就是my_layoutSubviews.就会循环引用.
  //[self layoutSubviews];
        
  // 正确写法
  [self my_layoutSubviews];
}

埋点策略
首先是设计数据结构，一般是一个log后台统一的Json结构；其次是择时上报，根据log后台的上传格式、上传世纪策略准确处理文件；最后上报。