category的温故知新

最近接到一个很蛋疼的需求，公司的一款新设备需要支持蓝牙和网关两个功能，然后蓝牙和网关又分别是两个基类（旧代码逻辑）。那除了把之前的代码再复制粘贴一份外，就只能用多继承实现了。
但是iOS是没有多继承的，对于有共同特性的一些东西，我们习惯把这些共同的方法属性抽象成一个父类，然后不同的东西再分别子类化，已达到代码重用的目的，所以这里我们需要对之前的代码进行重构。
在Swift中，Swift是面向协议的一种语言，Swift采用的是struct+protocol的实现方式，我们知道struct是不能够被继承的，那么Swift里面对于共有的方法属性是通过protocol来实现，并且，protocol可以很友好的实现多继承，protocol支持默认实现。
相比于抽成基类的方式，protocol更为友好，解耦方面也更加彻底。因为对于抽离基类的方式，会有很多的不方便

《代码大全》上有提及大致因为：
1 继承会使子类会变得越来越臃肿，出现不需要的属性、方法
2 继承会使子类看到父类细节，破坏父类封装性
3 父类修改了内容，子类也必须修改，这就造成了高耦合

那么，oc有没有类似的方法，可以实现Swift的这种protocol的友好方式呢。通过Google，我们看到网上有用过runtime来实现protocol默认实现的方式，原理大致是在对象创建的时候，去查看对象的方法列表，如果没有protocol的方法，就去protocol的对象里面把对应的方法加载进去，如果有就return。

具体参考这个第三方类concreteprotocol

其实我们大可不必这么麻烦，对于oc来说，有一种和protocol差不多的实现方式的。就是category。

1、什么是Category?

category是Objective-C 2.0之后添加的语言特性，别人口中的分类、类别其实都是指的category。category的主要作用是为已经存在的类添加方法。除此之外，apple还推荐了category的另外两个使用场景。

可以把类的实现分开在几个不同的文件里面。这样做有几个显而易见的好处:

可以减少单个文件的体积
可以把不同的功能组织到不同的category里
可以由多个开发者共同完成一个类
可以按需加载想要的category
声明私有方法

apple 的SDK中就大面积的使用了category这一特性。比如UIKit中的UIView。apple把不同的功能API进行了分类，这些分类包括UIViewGeometry、UIViewHierarchy、UIViewRendering等。

不过除了apple推荐的使用场景，广大开发者脑洞大开，还衍生出了category的其他几个使用场景：

模拟多继承（另外可以模拟多继承的还有protocol）
把framework的私有方法公开

category的特点

category只能给某个已有的类扩充方法，不能扩充成员变量。
category可以添加属性，但是@property只会生成setter和getter的声明，不会实现setter和getter以及对应的成员变量。
如果category中的方法和类中原油的方法同名，运行时会偶遇先调用category中的方法。注意：但是这里并不是category会覆盖掉类中原有方法！
如果多个category中存在同名方法，运行时到底调用哪个方法是由编译器决定，最后一个参与编译的方法会被调用（原理和上一条其实是差不多的）。

为什么category只能给某个已有的类扩充方法，不能扩充成员变量？

我们知道oc类是由class类型表示的，实际上是一个指向objc_class的结构体指针。定义如下

typedef struct objc_class *Class;

objc_class结构体定义如下：

struct objc_class {
    Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
    Class super_class                                        OBJC2_UNAVAILABLE;  // 父类
    const char *name                                         OBJC2_UNAVAILABLE;  // 类名
    long version                                             OBJC2_UNAVAILABLE;  // 类的版本信息，默认为0
    long info                                                OBJC2_UNAVAILABLE;  // 类信息，供运行期使用的一些位标识
    long instance_size                                       OBJC2_UNAVAILABLE;  // 该类的实例变量大小
    struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;  // 该类的成员变量链表
    struct objc_method_list  **methodLists                   OBJC2_UNAVAILABLE;  // 方法定义的链表
    struct objc_cache *cache                                 OBJC2_UNAVAILABLE;  // 方法缓存
    struct objc_protocol_list  *protocols                    OBJC2_UNAVAILABLE;  // 协议链表
#endif
}  OBJC2_UNVAAILABLE;

在上面objc_class结构体中， ivars是objc_var_list(成员变量列表)指针，methodLists是指向objc_method_list指针的指针。在runtime中，objc_class结构体大小是固定的，类的对象所占内存是已经分配好的了，如果改变，会产生灾难性的后果，所以我们只能修改修改成员变量的值，不能添加成员变量的数量。methodLists是一个二位数组，所以可以改变这个内存区域的值。

category可以添加属性

category不能添加成员变量(instance variables), 那为什么可以添加property呢？

这个我们要从category的结构体开始分析：

typedef struct category_t  {
    const char *name;      //类名
    classref_t cls;        //类
    struct method_list_t  *instanceMethods;      //category中给类添加的实例方法列表
    struct method_list_t  *classMethods;         //category给类添加的类方法列表
    struct protocol_list_t  *protocols;          //category实现的所有协议列表
   struct property_list_t  *instanceProperties;    //category中添加的所有属性
} category_t;

从category的定义可以看出category是可以添加实例方法，类方法，甚至实现协议，添加属性。
但是为什么还有很多人说category是不能添加property呢？
实际上，category是可以使用@property，但是不会生成 _变量（带下划线的成员变量），也不会生成添加属性的getter和setter方法实现，所以，尽管添加了属性，也无法使用点语法调用getter和setter方法。（因为只是去声明，根本没有实现，这个有点类似于给protocol中添加属性）详情参考我这篇

@interface UIViewController (addition)

@property(nonatomic, strong)NSString *MHVersion;

@end

#import "ViewController.h"
#import "UIViewController+addition.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    self.MHVersion = @"1.0";
}
@end

这是一个简单的🌰，我们给UIViewController添加了一个category，然后在category里面添加了一个MHVersion的property，随后我们可以看到外面是可以通过点语法正常调用category里面的这个属性的。那我们运行一下，这时候发现程序挂掉在了这一行，控制台打印输出结果：

错误信息

看到这个错误我们就应该明白，这是到不到对应的方法。

category中同名方法的问题

在使用中我们知道，如果category中出现了同名方法，那么在运行的时候是会响应category中的这个方法，而不是类中的那个方法的。那么是不是就可以判断同名方法是被覆盖掉了呢？
这需要我们继续探索下category是如何加载的

对于oc运行时，入口方法如下（在objc_os.mm文件中）

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();
    lock_init();
    exception_init();

    // Register for unmap first, in case some +load unmaps something
     _dyld_register_func_for_remove_image(&unmap_image);
     dyld_register_image_state_change_handler(dyld_image_state_bound,
                                             1/*batch*/, &map_images);
     dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}

category被附加到类上面是在map_images的时候发生的，再具体的细节可以参考美团关于category的文章，这里就不再贴一遍了。
我们这里直接看结论：

1.category方法并没有“完全替换掉”原来类已有的方法，也就是说如果category和类都有methodA，那么category附加完成以后，类的方法列表里面会有两个methodA

category的方法会被放到新的方法列表前面，而原来的类方法被放到了新方法列表的后面，这也就是我们平常所说的category的方法会“覆盖”掉原来类名的同名方法，这是因为运行时在查找方法的时候是顺着方法列表的顺序查找的，他只要一找到对应的名字方法，就会return掉。

这里有个误区，有人会觉得我在import这个category的时候，这个category才会被加载，如果没有import，那就不会加载。比如说，我在category里面声明了一个方法，然后没有import这个category的时候，在IDE里面没法直接调用这个方法啊。但是事实上，你只需要用performSelector:@selector() withObject:这个方法就能正常的调用到category里面的方法了，原因就是上面那里，category是在class在init的时候一起被初始化了。category里面的方法也被动态的加载进去，所以不管你有没有import，都是会被加载进内存当中的。平时在使用category的时候一定要特别注意这点，比如说：不要在category里面去重写class的同名方法！

如果多个category中存在同名方法，运行时到底调用哪个方法

我们知道，在类和category中都可以有+load方法，那么有两个问题：
1)、在类的+load方法调用的时候，我们可以调用category中声明的方法么？
2)、这么些个+load方法，调用顺序是咋样的呢？
鉴于上述几节我们看的代码太多了，对于这两个问题我们先来看一点直观的：

image.png

我们的代码里有MyClass和MyClass的两个category （Category1和Category2），MyClass和两个category都添加了+load方法，并且Category1和Category2都写了MyClass的printName方法。
在Xcode中点击Edit Scheme，添加如下两个环境变量（可以在执行load方法以及加载category的时候打印log信息，更多的环境变量选项可参见objc-private.h）:

image.png

运行项目，我们会看到控制台打印很多东西出来，我们只找到我们想要的信息，顺序如下：

objc[1187]: REPLACED: -[MyClass printName] by category Category1
objc[1187]: REPLACED: -[MyClass printName] by category Category2
...
objc[1187]: LOAD: class 'MyClass' scheduled for +load
objc[1187]: LOAD: category 'MyClass(Category1)' scheduled for +load
objc[1187]: LOAD: category 'MyClass(Category2)' scheduled for +load
objc[1187]: LOAD: +[MyClass load]
...
objc[1187]: LOAD: +[MyClass(Category1) load]
...
objc[1187]: LOAD: +[MyClass(Category2) load]

所以，对于上面两个问题，答案是很明显的：
1)、可以调用，因为附加category到类的工作会先于+load方法的执行
2)、+load的执行顺序是先类，后category，而category的+load执行顺序是根据编译顺序决定的。
目前的编译顺序是这样的：

image.png

我们调整一个Category1和Category2的编译顺序，run。ok，我们可以看到控制台的输出顺序变了：

image.png

objc[1187]: REPLACED: -[MyClass printName] by category Category2
objc[1187]: REPLACED: -[MyClass printName] by category Category1
...
objc[1187]: LOAD: class 'MyClass' scheduled for +load
objc[1187]: LOAD: category 'MyClass(Category2)' scheduled for +load
objc[1187]: LOAD: category 'MyClass(Category1)' scheduled for +load
objc[1187]: LOAD: +[MyClass load]
...
objc[1187]: LOAD: +[MyClass(Category2) load]
...
objc[1187]: LOAD: +[MyClass(Category1) load]

虽然对于+load的执行顺序是这样，但是对于“覆盖”掉的方法，则会先找到最后一个编译的category里的对应方法。

我们现在知道了方法其实都不会被覆盖掉，那么我们怎么调用类中被隐藏起来的方法呢？

上面我们已经知道category其实并不是完全替换掉原来类的同名方法，只是category在方法列表的前面而已，所以我们只要顺着方法列表找到最后一个对应名字的方法，就可以调用原来类的方法：

Class currentClass = [MyClass class];
MyClass *my = [[MyClass alloc] init];

if (currentClass) {
   unsigned int methodCount;
    Method *methodList = class_copyMethodList(currentClass, &methodCount);
    IMP lastImp = NULL;
    SEL lastSel = NULL;
    for (NSInteger i = 0; i < methodCount; i++) {
        Method method = methodList[i];
        NSString *methodName = [NSString stringWithCString:sel_getName(method_getName(method)) 
                                    encoding:NSUTF8StringEncoding];
        if ([@"printName" isEqualToString:methodName]) {
            lastImp = method_getImplementation(method);
            lastSel = method_getName(method);
        }
    }
    typedef void (*fn)(id,SEL);

    if (lastImp != NULL) {
        fn f = (fn)lastImp;
       f(my,lastSel);
    }
    free(methodList);
}

更上一层-category和关联对象

我们已经知道category是无法为类添加实例变量的。但是我们很多时候需要在category中添加对象关联的值，而不仅仅是根据属性去生成getter和setter方法。
这时候我们可以利用关联对象来实现

#import "MyClass.h"

@interface MyClass (Category1)

@property(nonatomic,copy) NSString *name;

@end

#import "MyClass+Category1.h"
#import <objc/runtime.h>

@implementation MyClass (Category1)

+ (void)load  {
    NSLog(@"%@",@"load in Category1");
}

- (void)setName:(NSString *)name   {
    objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY);
}

- (NSString*)name {
    NSString *nameObject = objc_getAssociatedObject(self, _cmd);
    return nameObject;
}
@end