在开发中有时会用到Category，类别有三个作用：
- 可以将类的实现分散到多个不同文件或多个不同框架中，方便代码管理。也可以对框架提供类的扩展（因为框架类没有源码，不能修改）。
- 创建对私有方法的前向引用：如果其他类中的方法未实现，在你访问其他类的私有方法时编译器报错这时使用类别，在类别中声明这些方法（不必提供方法实现），编译器就不会再产生警告
- 向对象添加非正式协议：创建一个NSObject的类别称为“创建一个非正式协议”，因为可以作为任何类的委托对象使用。有两个方面的局限性：
- 无法向类中添加新的实例变量，类别没有位置容纳实例变量。
- 名称冲突，即当类别中的方法与原始类方法名称冲突时，类别具有更高的优先级。类别方法将完全取代初始方法从而无法再使用初始方法。这个类似于方法的重载，但是这里是直接覆盖了原方法。
Category的结构体
当我们声明一个Category的时候，通过Clang编译之后，我们获得.mm文件，可以看到
将.m文件转成clang
首先安装Xcode，然后到这个下载地址安装Command Line Tools for Xcode，选择对应的版本，之后在中选选择你的Xcode路径，之后执行命令即可
xcode-select --print-path
/Applications/Xcode.app/Contents/Developer
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc MJPerson.m
category结构体
struct _category_t {
const char *name; //类名
struct _class_t *cls; //类对象isa
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; //属性列表
};
声明一个MJPerson+Test的Category，在runtime中的文件结构如下
static struct _category_t _OBJC_$_CATEGORY_MJPerson_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"MJPerson",
0, // &OBJC_CLASS_$_MJPerson,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_MJPerson_$_Test,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_MJPerson_$_Test,
0,
0,
};
对应起来
_CATEGORY_INSTANCE_METHODS_MJPerson_ 是实例方法列表
_CATEGORY_CLASS_METHODS_MJPerson_ 是类方法列表
在Category中声明实例方法和类方法在Category中分别生成
- (void)test {
}
实例方法列表
static struct /*_method_list_t*/ {
unsigned int entsize; // sizeof(struct _objc_method)
unsigned int method_count;
struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_MJPerson_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"test", "v16@0:8", (void *)_I_MJPerson_Test_test}}
};
+ (void)test2 {
}
类方法列表
static struct /*_method_list_t*/ {
unsigned int entsize; // sizeof(struct _objc_method)
unsigned int method_count;
struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_CLASS_METHODS_MJPerson_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"test2", "v16@0:8", (void *)_C_MJPerson_Test_test2}}
};
Category中的方法会合并到类对象中，从源码中可以看到最终调用了attachCategories(cls, &lc, 1, ATTACH_EXISTING); 方法，将分类中的数据附加到类对象中，或者附加到元类对象中，通过
rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount); 方法，将分类中的方法列表附加上去，
rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount); 将分类中的属性列表附加上去，
rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount); 将分类中的协议列表附加上去，
rw就是类对象中的bits获取到的class_rw_t表，过程中会重新分配内存，将原有内存加上新增的内存
新增内存的处理过程是，先拿到addmethod的内存大小size1，然后操作memmov，将现有的数据向后移动size1个位置，最后将addmethod的方法列表放到原来方法的位置，这就导致了，我们调用方法的时候会先从Category中查找，但是有个问题需要注意下，如果有多个分类有同一个方法，这个时候的查找顺序是取决于编译的，最后面编译的分类会优先调用
分类合并的方法列表在 rw_t 里面的 methods 中，而原来的方法列表则在 rw_t 中的 ro 里面，因为是原有的所以是只读的
memmov和memcpy的区别是：memmov会考虑是往那边移动，而根据地址的大小决定先移动那边的；memcpy则没有判断会直接将内存从小地址到大地址的拷贝
load()
+load方法会在runtime加载类、分类时调用，每个类、分类的+load，在程序运行过程中只调用一次
调用顺序
先调用类的+load，按照编译先后顺序调用（先编译，先调用），调用子类的+load之前会先调用父类的+load
再调用分类的+load，按照编译先后顺序调用（先编译，先调用）
如果我们在两个分类中分别写了load()方法，并打印类名，可以看到每个类都打印了，这就出现一个问题，不是说在category里面的重名方法会优先响应，原有类的方法则不会响应么？
可以看到runtime入口处的代码，其中 load_images 就是加载镜像模块的意思
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();
static_init();
runtime_init();
exception_init();
#if __OBJC2__
cache_t::init();
#endif
_imp_implementationWithBlock_init();
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
#if __OBJC2__
didCallDyldNotifyRegister = true;
#endif
}
在objc-runtime-new中可以找到这个方法，可以看到里面调用了 call_load_methods 方法
load_images(const char *path __unused, const struct mach_header *mh)
{
if (!didInitialAttachCategories && didCallDyldNotifyRegister) {
didInitialAttachCategories = true;
loadAllCategories();
}
// Return without taking locks if there are no +load methods here.
if (!hasLoadMethods((const headerType *)mh)) return;
recursive_mutex_locker_t lock(loadMethodLock);
// Discover load methods
{
mutex_locker_t lock2(runtimeLock);
prepare_load_methods((const headerType *)mh);
}
// Call +load methods (without runtimeLock - re-entrant)
call_load_methods();
}
这个方法中会先调用类的load方法，然后再调用Category的load方法
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;
}
loadable_classes这个结构体就是下面的，只装载了load()方法
struct loadable_class {
Class cls; // may be nil
IMP method;
};
在call_class_loads()中会直接找到原来类中的load方法指针去直接调用
在call_category_loads()中会直接找到某一个分类中的load方法指针去直接调用
这个步骤相当于是指定了一个方法，然后直接找到方法的地址去调用；
常规意义上是sendMessage，然后在方法列表里面找，一旦涉及到这个步骤，就是优先分类方法了，所以不同之处就在这里
无论编译顺序如何都会先调用父类的load()方法，在调用子类的load()方法，最后调用Category的load()方法，当没有继承关系的时候，才会按照编译顺序决定调用顺序
initialize(�)
+initialize方法会在类第一次接收到消息时调用，是通过objc_sendMessage方式调用，和常规方法是一种调用方式
调用顺序
先调用父类的+initialize，再调用子类的+initialize(先初始化父类，再初始化子类，每个类只会初始化1次)
以class_getInstanceMethod为例，这个方法是寻找实例方法和类方法的，区别在于传入的是类对象还是元类对象，可以看到下面流程
Method class_getInstanceMethod(Class cls, SEL sel)
{
if (!cls || !sel) return nil;
// This deliberately avoids +initialize because it historically did so.
// This implementation is a bit weird because it's the only place that
// wants a Method instead of an IMP.
#warning fixme build and search caches
// Search method lists, try method resolver, etc.
lookUpImpOrForward(nil, sel, cls, LOOKUP_RESOLVER);
#warning fixme build and search caches
return _class_getMethod(cls, sel);
}
继续跳转到 lookUpImpOrForward 方法
一路下来，我们最终看到了判断逻辑
1.自己有没有初始化
2.存在父类，并且父类没有初始化
3.然后将自己传进去
void initializeNonMetaClass(Class cls)
{
supercls = cls->getSuperclass();
if (supercls && !supercls->isInitialized()) {
initializeNonMetaClass(supercls); //递归
}
initializeNonMetaClass(self);
}
最终的调用还是发送消息
void callInitialize(Class cls)
{
((void(*)(Class, SEL))objc_msgSend)(cls, @selector(initialize));
asm("");
}
总结：
load、initialize方法的区别什么？
-
调用方式
- load是根据函数地址直接调用
- initialize是通过objc_msgSend调用
-
调用时刻
- load是runtime加载类、分类的时候调用（只会调用1次）
- initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）
- +initialize是通过objc_msgSend进行调用的，所以有以下特点，如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次），如果分类实现了+initialize，就覆盖类本身的+initialize调用
load、initialize的调用顺序？
-
load
- 先调用类的load
- 先编译的类，优先调用load
- 调用子类的load之前，会先调用父类的load
- 再调用分类的load
- 先编译的分类，优先调用load
-
initialize
- 先初始化父类
- 再初始化子类（可能最终调用的是父类的initialize方法）
Category添加属性
分类中添加属性只会生成setter、getter方法的成声明，没有方法的实现，不会生成成员变量；
默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中。但可以通过关联对象来间接实现
关联对象提供了以下API
添加关联对象
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)
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
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))
举例说明
在Category中声明一个属性
@property (assign, nonatomic) int weight;
外部调用的时候赋值，因为没有成员变量，无法保存属性，所以 是无法成功的
MJPerson *person = [[MJPerson alloc] init];
person.weight = 40;
方法一
在分类中添加setter和getter方法，再写一个全局变量去保存赋的值，但是存在一个问题，全局变量的情况下，多个对象都能访问到这个全局变量，所有的对象都可以改变这个值
@implementation Person (Test)
int weight_;
- (void)setWeight:(int)weight {
weight_ = weight;
}
- (int)weight {
return weight_;
}
- (void)setWeight:(int)weight {
_weight = weight;
}
- (int)weight {
return _weight;
}
@end
方法二
优化了第一种方法，声明一个全局的字典，在load()方法中实例化，因为字典是唯一key的，可以把当前的对象当做key（拿到对象的内存地址转成字符串），属性作为value，这样的话可以保证每个对象都有自己的这个属性。但是这个方法也有问题，因为是全局变量，所以为一直在内存中存放，还有可能会有线程安全的问题，而且每次新增属性都会要写很多冗余代码。
#define MJKey [NSString stringWithFormat:@"%p", self]
@implementation Person (Test)
NSMutableDictionary *names_;
+ (void)load {
names_ = [NSMutableDictionary dictionary];
}
- (void)setName:(NSString *)name {
names_[MJKey] = name;
}
- (NSString *)name {
return names_[MJKey];
}
@end
方法三
使用关联对象的方法可以直接在Category中达到在元类中写属性的效果
static const void *MJNameKey = &MJNameKey;
也可以直接是一个字符串，因为字符串在静态变量区，所以相通的字符串地址也是一样的
- (void)setName:(NSString *)name {
objc_setAssociatedObject(self, MJNameKey, name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)name {
return objc_getAssociatedObject(self, MJNameKey);
}
上面代码中说明了可以用一个指针地址，所以还可以优化为
- (void)setName:(NSString *)name {
objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)name {
// 隐式参数
// _cmd == @selector(name)
return objc_getAssociatedObject(self, _cmd);
}
这里的Category和类本身都是只有一个类对象，只是生成了不同的 _category_t 结构体
关联对象的原理
实现关联对象技术的核心对象有以下四个：
AssociationsManager
class AssociationsManager {
using Storage = ExplicitInitDenseMap, ObjectAssociationMap>;
static Storage _mapStorage;
public:
AssociationsManager() { AssociationsManagerLock.lock(); }
~AssociationsManager() { AssociationsManagerLock.unlock(); }
AssociationsHashMap &get() {
return _mapStorage.get();
}
static void init() {
_mapStorage.init();
}
};
AssociationsHashMap
typedef DenseMap, ObjectAssociationMap> AssociationsHashMap;
ObjectAssociationMap
typedef DenseMap ObjectAssociationMap;
ObjcAssociation
这个结构体和在Category里面写的方法一样，一个是值，一个是策略
class ObjcAssociation {
uintptr_t _policy;
id _value;
}
void objc_setAssociatedObject(id object,
const void * key,
id value,
objc_AssociationPolicy policy)
擦除所有的关联对象，删除某个hashMap
void objc_removeAssociatedObjects(id object)
对应结构如下图：
维护了一个区别于类对象里面的的属性列表的结构，可以根据对象的不同，key的不用，找到对应的值，setter和getter都是一样的寻找流程，区别是一个赋值，一个取值。拿到ObjcAssociation后，使用map的erase()擦除掉，相当于字典的删除某个键值对
总结：
关联对象并不是存储在被关联对象本身内存中，关联对象存储在全局的统一的一个AssociationsManager中，设置关联对象为nil，就相当于是移除关联对象，关联对象的属性石没有弱引用的概念的，不会置为nil