编译时的 category
category 在编译后会得到 _category_t 的结构体. 多个 category 编译后得到多个 _category_t, 即使是同一个类不同的 category, 也会得到不同的 _category_t .
创建一个 DemoClass 类的分类
@interface DemoClass (Cate) <NSObject>
@property (nonatomic, strong) NSDictionary *dic;
@end
@implementation DemoClass (Cate)
- (void)demoCalssInstanceFuc {
NSLog(@"%#", __func__);
}
+ (void)demoCalssClassFuc {
NSLog(@"%#", __func__);
}
转成 C++ 文件, 挑了部分代码放出来...
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_DemoClass_$_Cate __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
// 赋值顺序与上面结构体顺序一一对应滴
"DemoClass", // 类名赋值
0, // &OBJC_CLASS_$_DemoClass,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_DemoClass_$_Cate, //实例方法数组赋值
(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_DemoClass_$_Cate, //类方法数组赋值
(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_DemoClass_$_Cate, //协议数组赋值
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_DemoClass_$_Cate, //属性数组赋值
};
运行时的 category
运行时, 会将分类里的实例方法合并到类的方法列表中, 将类方法合并到元类对象的方法列表中, 可读 runtime 的源码
阅读顺序... 入口为 objc-os.mm 文件
- 找到
void _objc_init(void)方法, 找到&map_images - 进入
&map_images方法 - 进入
map_images_nolock方法, 找到_read_images方法 - 进入
_read_images, 找到category_t... 在比较下面的位置, 2555行... 找到remethodizeClass(cls) - 在
remethodizeClass(cls)中再进入attachCategories方法 🤣
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_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--) { // 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 的方法列表中
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);
}
// 附加的方法
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;
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
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]));
}
}
注意:
遍历分类方法列表时, 是采用倒序,
while (i--), 所以编译在后的分类, 该分类方法会在前面.
- 分类的方法名和类的方法名一样的话, 会调用分类的方法.
- 有两个分类的方法名一样, 看编译顺序, 会调用后编译的
ps: 在 Build Phases -> Compile Sources 中排前面的文件先编译
ps: 同方法名这个不属于分类方法覆盖了类的方法, 只能说是先调用了分类的方法. 调用方法, 其实就是在类的方法列表里面遍历查找, 因为在附加方法里, 把分类的方法放前面, 类的方法放在了最后, 所以会先找到分类的方法, 返回方法之后就不会再放下查找了. 因而调用了分类的方法, 但是类方法还是在的, 只是走不到类方法那里而已
关联对象
在分类里面写属性, 不会生成成员变量和生成 setter & getter 方法实现, 只会声明 setter & getter. 也不能直接给分类添加成员变量, 但是可以通过关联对象来实现同样效果.
为什么不能给分类添加成员变量...
- 因为 category_t 结构里面没有存储成员变量的地方
关联对象最终存在哪, 存在类对象里面吗?
- 不不不, 另外有个关联对象的 manager 来存储管理.
通过 objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key) 和 objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key, id _Nullable value, objc_AssociationPolicy policy) 方法可以获取关联对象和设置关联对象.
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());
// object 经过 DISGUISE() 后作为 AssociationsHashMap 的 key
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;
// AssociationsHashMap 以 object 作为 key, ObjectAssociationMap 对象作为 value
associations[disguised_object] = refs;
// ObjectAssociationMap 以传入的 key 作为 key, ObjcAssociation 对象作为 value
// ObjcAssociation 保存了传入的 policy 和 value
(*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 managerAssociationsHashMap associations //类似manager的一个属性ObjectAssociationMap refs //associations里, 以 object 为 key 对应的一个 valueObjcAssociation //refs 里, 以传入的 key 为 key 对应的一个value, 存储着传入的policy 和 value
稍微捋捋几个类之间的关系:
- 关联对象会保存在一个叫 AssociationsManager 的类里面, 这个对象是全局的, 只有仅此的一份, 保管所有类的关联对象
- 不同的类会以类名 objectKey(这里并不是那么单纯的以类名为 key, 而是经过一个函数的转换啥的...) 作为 key, ObjectAssociationMap 作为 value, 存在 AssociationsHashMap 里
- ObjectAssociationMap 中存着以关联属性的 key 为 key, ObjcAssociation 作为 value 的键值对, 其中 ObjcAssociation 包含了关联属性的 policy 和 value
清晰明了了吗! 没看懂? 看下面! 尽力了... 画图水平就这样了...
以上关系图.png
+ load 和 + initiallze
+load (阅读源码还是在 objc-os.mm 里面)
- +load 在 runtime 加载类/分类时调用, 直接通过指针调用, 所以每个类/分类的 +load 都会调用,
- 每个 +load 只调用一次
- 调用顺序
1. 类的 + load (先调用父类再调子类)
2. 分类的 + load
ps: 类的和分类都看编译顺序, 先编译先调用
+ initialize (额.. 这里只说创建方法的源码吧... objc-initialize.mm)
- +initialize 方法在类第一次使用的时候调用, 通过 objc_msgSend 进行调用
- 先父类再子类
- 每个类只会初始化一次
ps: 父类的 +initialize 可能会被调用多次, 如果子类没有实现 +initialize, objc_msgSend 会找到父类的 +initialize 去调用
对于是用 +load 还是用 +initialize, 说说自己的看法...
+load 是在启动前跑的, +initialize 在启动后跑的. 很多优化 App 启动时间的文章里有说 不要把太多处理写在 +load 里面, 会造成启动慢!!! 嗯, 但是貌似很多第三方库还是写 +load, 这是为什么呢 🧐
可能是怕自己的方法被别人 hook 了, 导致一些数据没被初始化成功... 吧...
所以个人来说吧, hook 方法会放在 +load 里, 一些无关紧要的初始化就放在 +initialize 里
// 调用 load 方法 有些代码给删了... 专注重点... 也是不想篇幅过长 🤣
void call_load_methods(void)
{
do {
// 1. Repeatedly call class +loads until there aren't any more
// 先调用类的 load
while (loadable_classes_used > 0) {
call_class_loads();
}
// 2. Call category +loads ONCE
// 再调用分类的 load
more_categories = call_category_loads();
// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0 || more_categories);
}
// 类调用 load 方法源码
static void call_class_loads(void)
{
int i;
// Detach current loadable list.
struct loadable_class *classes = loadable_classes;
int used = loadable_classes_used;
loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;
// Call all +loads for the detached list.
for (i = 0; i < used; i++) {
Class cls = classes[i].cls;
load_method_t load_method = (load_method_t)classes[i].method;
if (!cls) continue;
if (PrintLoading) {
_objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
}
// 直接调用, 没有通过消息机制来发送
// 分类也是这样调用 load 的
// 所以虽然类的方法名和分类的方法名都叫 load, 但是不会只调用分类的而不调用类的
(*load_method)(cls, SEL_load);
}
// Destroy the detached list.
if (classes) free(classes);
}
// objc-initialize.mm
// 进入这个方法之前, 会先查看是否已经初始化, 如果没有初始化才会走这里
// initialize 的方法 又开始毫无人性的删掉代码了 🤣 请自行看源码
void _class_initialize(Class cls)
{
assert(!cls->isMetaClass());
Class supercls;
bool reallyInitialize = NO;
// 先调父类
supercls = cls->superclass;
// 判断是否有初始化, 没有初始化才会调 _class_initialize, 所以只有第一次使用的时候才会调用
if (supercls && !supercls->isInitialized()) {
_class_initialize(supercls);
}
// Try to atomically set CLS_INITIALIZING.
{
monitor_locker_t lock(classInitLock);
if (!cls->isInitialized() && !cls->isInitializing()) {
cls->setInitializing();
reallyInitialize = YES;
}
}
if (reallyInitialize) {
#if __OBJC2__
@try
#endif
{
// 调用 initialize
callInitialize(cls);
if (PrintInitializing) {
_objc_inform("INITIALIZE: thread %p: finished +[%s initialize]",
pthread_self(), cls->nameForLogging());
}
}
#if __OBJC2__
@catch (...) {
if (PrintInitializing) {
_objc_inform("INITIALIZE: thread %p: +[%s initialize] "
"threw an exception",
pthread_self(), cls->nameForLogging());
}
@throw;
}
@finally
#endif
{
// Done initializing.
lockAndFinishInitializing(cls, supercls);
}
return;
}
else {
// We shouldn't be here.
_objc_fatal("thread-safe class init in objc runtime is buggy!");
}
}
void callInitialize(Class cls)
{
// 消息机制调用 initialize
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
asm("");
}
网友评论