分类做了哪些事情?
- 声明私有方法
- 分解体积庞大的类文件
- 把Framework的私有方法公开化
- 可以添加实例方法, 类方法, 协议, 属性(只添加了get/set方法, 没有添加实例变量)
分类的特点
- 分类运行时决议,在运行时通过runTime把方法等添加到宿主类上. [扩展是编译时决议, 这是扩展和分类的最大区别]
- 分类可以给系统类添加分类[不能给系统类添加扩展]
- 分类可以添加:
- 实例方法,
- 类方法,
- 协议,
- 属性(只添加了get/set方法, 没有添加实例变量)
- 可通过关联对象添加实例变量
分类的结构体
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);
};
- 注意: 结构体中没有关于实例变量的成员结构
分类加载调用栈
- 注意: image在这里表示镜像, 程序镜像或者内存镜像
static void remethodizeClass(Class cls)
{
category_list *cats;
bool isMeta;
runtimeLock.assertLocked();
/*
我们分析分类单重实例方法的添加逻辑
因此在这里我们假设 isMeta = NO
*/
isMeta = cls->isMetaClass();
// Re-methodizing: check for more categories
//获取cls中未完成整合的所有类
if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
if (PrintConnecting) {
_objc_inform("CLASS: attaching categories to class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
//将分类cats拼接到cls上
attachCategories(cls, cats, true /*flush caches*/);
free(cats);
}
}
static void
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;//如果无分类, 直接返回
if (PrintReplacedMethods) printReplacements(cls, cats);
/*
我们分析分类单重实例方法的添加逻辑
因此在这里我们假设 isMeta = NO
*/
bool isMeta = cls->isMetaClass();
/*二维数组
[[method_t, method_t...], [method_t],[method_t, method_t, method_t]]
*/
// 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--) {
//获取一个分类
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;
}
}
//获取宿主类当中rw数据, 其中包含宿主类的方法列表信息
auto rw = cls->data();
//主要针对分类中有关内存管理相关方法情况下的一些特殊处理
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
/*
rw:代表类
methods:类的方法列表
attachLists:将含有mcount个元素的mlists拼接到rw的methods上
[即添加到宿主类上, 这就是说为什么分类是运行时决议]
*/
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);
}
/*
addedLists:上一步传过来二维数组
[[method_t, method_t...], [method_t],[method_t, method_t, method_t]]
---------A分类方法列表----- ----B---- ---------C----------
addedCount = 3
*/
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;//重新设置元素个数
/*
内存移动
[[A], [B],[C],[原来第一个],[原来第二个]]
*/
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
/*
内存拷贝
[[A]-->[addedLists第一个元素]
[B],-->[addedLists第二个元素]
[C],-->[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]));
}
}
1. 分类方法会"覆盖"宿主类方法原因(其实分类方法和原宿主类方法都存在)
答: 通过memove和memcopy所做操作, 宿主类的方法任然存在, 只不过分类方法在宿主类方法之前, 在消息查找过程中, 根据选择器(selector)来查找, 一旦查到就返回, 由于分类方法在前, 故分类方法会优先实现, 从而会覆盖宿主类方法
2. 问:多个分类都有一个同名方法, 哪个生效?
答:后编译的生效
总结:
