参考篇：iOS-分类（Category）
前言：本文简述Category原理，如有错误请留言指正。
第一部分：有关分类的本质、原理
Q：分类的对象方法，类方法都存在哪里？
一个类的所有分类的 对象方法放在类对象中，所有分类的类方法存放在元类中
clang查看编译文件
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc NSObject+Test.m
编译文件NSObject+Test.cpp中有关分类内容
//声明结构体
struct _category_t {
const char *name;
struct _class_t *cls;
const struct _method_list_t *instance_methods;
const struct _method_list_t *class_methods;
const struct _protocol_list_t *protocols;
const struct _prop_list_t *properties;
};
//对结构体赋值
static struct _category_t _OBJC_$_CATEGORY_NSObject_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"NSObject",
0, // &OBJC_CLASS_$_NSObject,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_NSObject_$_Test,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_NSObject_$_Test,
(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_NSObject_$_Test,
0,
};
Runtime中Category源码解读顺序
objc-os.mm
- _objc_init
- map_images
- map_images_nolock
objc-runtime-new.mm
- _read_images
- remethodizeClass
- attachCategories
- attachLists
- realloc、memmove、 memcpy
Runtime中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;
// Fields below this point are not always present on disk.
struct property_list_t *_classProperties;
method_list_t *methodsForMeta(bool isMeta) {
if (isMeta) return classMethods;
else return instanceMethods;
}
property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};
objc-runtime-new.mm
// cls 类
// cats 分类列表
static void
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
// fixme rearrange to remove these intermediate allocations
/*方法数组
[
[method_t,method_t]
[method_t,method_t]
]
*/
method_list_t **mlists = (method_list_t **)
malloc(cats->count * sizeof(*mlists));
//属性数组
property_list_t **proplists = (property_list_t **)
malloc(cats->count * sizeof(*proplists));
//协议数组
protocol_list_t **protolists = (protocol_list_t **)
malloc(cats->count * sizeof(*protolists));
// Count backwards through cats to get newest categories first
int mcount = 0;
int propcount = 0;
int protocount = 0;
int i = cats->count;
bool fromBundle = NO;
while (i--) {
//取出分类
auto& entry = cats->list[i];
//取出分类对象方法
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= entry.hi->isBundle();
}
property_list_t *proplist =
entry.cat->propertiesForMeta(isMeta, entry.hi);
if (proplist) {
proplists[propcount++] = proplist;
}
protocol_list_t *protolist = entry.cat->protocols;
if (protolist) {
protolists[protocount++] = protolist;
}
}
auto rw = cls->data();
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
rw->methods.attachLists(mlists, mcount);
free(mlists);
if (flush_caches && mcount > 0) flushCaches(cls);
rw->properties.attachLists(proplists, propcount);
free(proplists);
rw->protocols.attachLists(protolists, protocount);
free(protolists);
}
Q：分类的方法何时合并到类对象中？
通过runtime动态将分类的方法合并到类对象、元类对象中的
Q：分类的方法是如何添加到类对象方法列表中的？
runtime源码展示
void attachLists(List* const * addedLists, uint32_t addedCount) {
if (addedCount == 0) return;
if (hasArray()) {
// many lists -> many lists
uint32_t oldCount = array()->count;
uint32_t newCount = oldCount + addedCount;
setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
array()->count = newCount;
//array()->lists:原来类对象的方法列表
//内存移动
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
//addedLists:所有分类的方法列表
//内存拷贝
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
}
else if (!list && addedCount == 1) {
// 0 lists -> 1 list
list = addedLists[0];
}
else {
// 1 list -> many lists
List* oldList = list;
uint32_t oldCount = oldList ? 1 : 0;
uint32_t newCount = oldCount + addedCount;
setArray((array_t *)malloc(array_t::byteSize(newCount)));
array()->count = newCount;
if (oldList) array()->lists[addedCount] = oldList;
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
}
}
重要代码：
//array()->lists:原来类对象的方法列表
//内存移动
memmove(array()->lists + addedCount, array()->lists, oldCount * sizeof(array()->lists[0]));
//addedLists:所有分类的方法列表
//内存拷贝
memcpy(array()->lists, addedLists, addedCount * sizeof(array()->lists[0]));
演示图例
分类方法添加到对象方法列表中
大概流程
- 1.获取分类列表的
count，然后原来的类方法列表内存移动count - 2.分类列表内存拷贝到原来的类方法列表的前方
- 3.同样的方法，优先调用分类的方法
- 4.分类具有同样的方法，根据编译顺序决定，取最后编译分类的方法列表
Q：Category的加载处理过程？
- 1.通过Runtime加载某个类的所有Category数据
- 2.把所有Category的方法、属性、协议数据，合并到一个大数组中
- 3.后面参与编译的Category数据，会在数组的前面
- 4.将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面
Q：Category的实现原理
- Category编译之后的底层结构是struct category_t，里面存储着分类的对象方法、类方法、属性、协议信息
- 在程序运行的时候，runtime会将Category的数据，合并到类信息中（类对象、元类对象中）
Q：Category和Class Extension的区别是什么？
- Class Extension在编译的时候，它的数据就已经包含在类信息中
- Category是在运行时，才会将数据合并到类信息中
Q：memmove和memcpy的区别？
memmove会根据内存大小，移动方向，数量来移动内存；memcpy是按照一定规则一个地址一个地址拷贝。memmove能保证原数据完整性，内部移动最好不要使用memcpy，外部内存移动可以使用。
第二部分：+load 和 +initialize方法
Q: +load方法调用原理？
objc4源码解读过程：
objc-os.mm
_objc_init
load_images
prepare_load_methods
schedule_class_load
add_class_to_loadable_list
add_category_to_loadable_list
call_load_methods
call_class_loads
call_category_loads
(*load_method)(cls, SEL_load)
objc-loadmethod.mm
struct loadable_class {
Class cls; // may be nil
IMP method; // +load
};
struct loadable_category {
Category cat; // may be nil
IMP method; // 分类的+load
};
调用视图
调用视图
Q：+load方法调用顺序？
1. 先调用类的+load方法
- 1.1按照编译先后顺序调用（先编译，先调用）
- 1.2先调用父类的+load再调用子类的+load
2. 再调用分类的+load方法
- 2.1按照编译先后顺序调用（先编译，先调用）
// 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();
- 每个类、分类的+load，在程序运行过程中只调用一次，只有在加载类时候调用一次
- 不存在分类的+load方法覆盖类的+load方法
Q：+load方法为什么和其他的类方法调用方式不同？
其他分类类方法是通过消息转发机制调用的，isa和superclass来寻找的；而+load是通过函数指针指向函数，拿到函数地址，分开来直接调用的，直接通过内存地址查找调用的。
Q：Category中有load方法吗？load方法是什么时候调用的？load 方法能继承吗？
- 有load方法
- load方法在runtime加载类、分类的时候调用
- load方法可以继承，但是一般情况下不会主动去调用load方法，都是让系统自动调用
Q：+initialize方法是怎么调用的？
+initialize方法会在类第一次接收到消息时调用，消息转发机制调用的（objc_send）
Q：+initialize方法调用顺序？
先调用父类的+initialize，再调用子类的+initialize；(先初始化父类，再初始化子类，每个类只会初始化1次），子类内部+initialize会主动调用父类的+initialize
runtime探索objc_msgSend内部调用initialize
objc4源码解读过程
objc-msg-arm64.s
objc_msgSend
objc-runtime-new.mm
class_getInstanceMethod
lookUpImpOrNil
lookUpImpOrForward
_class_initialize
callInitialize
objc_msgSend(cls, SEL_initialize)
部分源码展示：
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
//.......中间省略一部分源码
//下面代码展示如果initialize需要初始化 && 类未被初始化过就执行以下函数
if (initialize && !cls->isInitialized()) {
runtimeLock.unlockRead();
_class_initialize (_class_getNonMetaClass(cls, inst));
runtimeLock.read();
// If sel == initialize, _class_initialize will send +initialize and
// then the messenger will send +initialize again after this
// procedure finishes. Of course, if this is not being called
// from the messenger then it won't happen. 2778172
}
}
Q：+initialize和+load的很大区别是？
- +initialize是通过objc_msgSend进行调用的
- 如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）
- 如果分类实现了+initialize，就覆盖类本身的+initialize调用
- +load是通过函数指针指向函数，拿到函数地址，分开来直接调用的，直接通过内存地址查找调用的。
Q：load、initialize方法的区别什么？
1.调用方式
1> load是根据函数地址直接调用
2> initialize是通过objc_msgSend调用2.调用时刻
1> load是runtime加载类、分类的时候调用（只会调用1次）
2> initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）
Q：load、initialize的调用顺序？
1.load
1> 先调用类的load
a) 先编译的类，优先调用load
b) 调用子类的load之前，会先调用父类的load2> 再调用分类的load
a) 先编译的分类，优先调用load
2.initialize
1> 先初始化父类
2> 再初始化子类（可能最终调用的是父类的initialize方法）
第三部分：关联对象
Q：分类声明属性，系统都做了什么？
分类声明属性，系统只生成setter和getter方法的声明，但是成员变量、setter和getter方法的实现均没有。
Q：为什么不能用字典为分类增加实例变量
- 字典为分类增加实例变量存在全局变量中，内存泄漏
- 多线程访问会存在同时访问变量的情况，还得加锁处理
- 每增加一个变量，字典、setter、getter方法就得重新编写
Q：Category能否添加成员变量？如果可以，如何给Category添加成员变量？
- 不能直接给Category添加成员变量，但是可以间接实现Category有成员变量的效果
- 默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中。但可以通过关联对象来间接实现
Q：如何给分类关联对象？
- 添加关联对象
// object：当前对象
// key：标记key
//value ：关联属性值
//objc_AssociationPolicy：关联对象策略
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)
关联对象策略
关联对象策略
关联对象代码示例：
#import "Person.h"
@interface Person (Test1)
@property (nonatomic, copy) NSString *name;
@end
#import "Person+Test1.h"
#import <objc/runtime.h>
@implementation Person (Test1)
//保证nameKey唯一即可
static void * nameKey = &nameKey;
- (void)setName:(NSString *)name{
objc_setAssociatedObject(self, nameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)name{
return objc_getAssociatedObject(self, nameKey);
}
@end
保证关联对象key唯一的其他方法
static void *MyKey = &MyKey;
objc_setAssociatedObject(obj, MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, MyKey)
//static char MyKey;
objc_setAssociatedObject(obj, &MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, &MyKey)
//使用属性名作为key
//直接使用的@"name"类似的变量是存在常量区的，所以地址会相同
objc_setAssociatedObject(obj, @"property", value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
objc_getAssociatedObject(obj, @"property");
//使用get方法的@selecor作为key
objc_setAssociatedObject(obj, @selector(getter), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, @selector(getter))
objc_getAssociatedObject(self, _cmd);
//_cmd：表示当前方法的selector方法
Q：关联对象的原理
实现关联对象技术的核心对象有
- AssociationsManager
- AssociationsHashMap
- ObjectAssociationMap
- ObjcAssociation
objc4源码解读：objc-references.mm
void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
// retain the new value (if any) outside the lock.
ObjcAssociation old_association(0, nil);
id new_value = value ? acquireValue(value, policy) : nil;
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
disguised_ptr_t disguised_object = DISGUISE(object);
if (new_value) {
// break any existing association.
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
// secondary table exists
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
old_association = j->second;
j->second = ObjcAssociation(policy, new_value);
} else {
(*refs)[key] = ObjcAssociation(policy, new_value);
}
} else {
// create the new association (first time).
ObjectAssociationMap *refs = new ObjectAssociationMap;
associations[disguised_object] = refs;
(*refs)[key] = ObjcAssociation(policy, new_value);
object->setHasAssociatedObjects();
}
} else {
// setting the association to nil breaks the association.
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
old_association = j->second;
refs->erase(j);
}
}
}
}
// release the old value (outside of the lock).
if (old_association.hasValue()) ReleaseValue()(old_association);
}
核心对象内部：
//AssociationsManager内包含AssociationsHashMap
class AssociationsManager {
static AssociationsHashMap *_map;
}
//AssociationsHashMap内包含ObjectAssociationMap
class AssociationsHashMap : public unordered_map<disguised_ptr_t, ObjectAssociationMap *, DisguisedPointerHash, DisguisedPointerEqual, AssociationsHashMapAllocator>
//ObjectAssociationMap内包含ObjcAssociation
class ObjectAssociationMap : public std::map<void *, ObjcAssociation, ObjectPointerLess, ObjectAssociationMapAllocator>
//ObjcAssociation 内包含策略和属性值
class ObjcAssociation {
uintptr_t _policy;
id _value;
}
关联对象原理
Q：关联对象是否储存在类对象内存中？
答案：不是的
- 关联对象并不是存储在被关联对象本身内存中
- 关联对象存储在全局的统一的一个AssociationsManager，AssociationsHashMap中
Q：设置关联对象为nil，会发生什么？
相当于是移除关联对象，内部会有一个erase操作
Q：如何移除所有关联对象？
移除所有的关联对象
void objc_removeAssociatedObjects(id object)
Q：如果类对象销毁，分类的关联对象会移除么？
会的
