Category在平時的工作中也是經常用到，是開發中不可缺少的一個利器，簡單介紹。

優點：

不需要通過增加子類而增加現有類的行為(方法),且分類中的方法與原始類方法基本沒有區別;在日常開發中通過分類可以將龐大一個類的方法按照功能模塊進行劃分,從而便于代碼的日后的維護、更新以及提高代碼的閱讀性

缺點：

1.無法向類目添加實例變量,如果需要添加實例變量,只能通過定義子類的方式。
2.類目中的方法與原始類以及父類方法相比具有更高優先級,如果覆蓋父類的方法,可能導致super消息的斷裂。因此,最好不要覆蓋原始類中的方法。

底層探索：

寫一段代碼，新建Presen類 然后為Presen增加兩個分類，分別是Presen+Text，Preson+Eat，代碼如下

Presen類 
// Presen.h
#import <Foundation/Foundation.h>
@interface Preson : NSObject
{
    int _age;
}
- (void)text;
@end

// Presen.m
#import "Preson.h"
@implementation Preson
- (void) text
{
    NSLog(@"Person - text");
}
@end

Presen擴展1
// Presen+Test.h
#import "Preson.h"
@interface Preson (Test) <NSCopying>
- (void)test;
+ (void)test2;
@end

// Presen+Test.m
#import "Preson+Test.h"
@implementation Preson (Test)
- (void)test
{
}
+ (void)test2
{
}
@end

Presen分類2
// Preson+Eat.h
#import "Preson.h"
@interface Preson (Eat)
@end

// Preson+Eat.m
#import "Preson+Eat.h"
@implementation Preson (Test2)
- (void)text
{
    NSLog(@"Person (Test2) - text");
}
@end

iOS OC對象的本質窺探講到過實例對象的isa指針指向類對象，類對象的isa指針指向元類對象，當p調用text方法時，通過實例對象的isa指針找到類對象，然后在類對象中查找對象方法，如果沒有找到，就通過類對象的superclass指針找到父類對象，接著去尋找text方法。

那么當調用分類的方法時，步驟是否和調用對象方法一樣呢？
分類中的對象方法依然是存儲在類對象中的，同本類對象方法在同一個地方，調用步驟也同調用對象方法一樣。如果是類方法的話，也同樣是存儲在元類對象中。
那么分類方法是如何存儲在類對象中的? 如果一個類含有多個分類那么存儲順序是怎么樣的呢？我們來通過源碼看一下分類的底層結構。
源碼下載地址

分類的底層結構

通過查看分類的源碼我們可以找到category_t 結構體。

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);
};

從源碼基本可以看出我們平時使用categroy的方式，對象方法，類方法，協議，和屬性都可以找到對應的存儲方式。并且我們發現分類結構體中是不存在成員變量的，因此分類中是不允許添加成員變量的。分類中添加的屬性并不會幫助我們自動生成成員變量，只會生成get set方法的聲明，需要我們自己去實現。

通過源碼我們發現，分類的方法，協議，屬性等好像確實是存放在categroy結構體里面的，那么他又是如何存儲在類對象中的呢？
我們來看一下底層的內部方法探尋其中的原理。
首先我們通過命令行將Preson+Test.m文件轉化為c++文件，查看其中的編譯過程。

Preson+Test轉化成c++文件結構體.png

往下尋找，我們可以看到_method_list_t類型的結構體，如下圖所示

對象方法列表結構體.png

接下來我們發現同樣的_method_list_t類型的類方法結構體，如下圖所示

類方法列表

Preson+Test轉化成c++文件結構體.png

企業微信截圖_80cfebb9-8d90-4f00-b818-70ccbbf534ed.png

上下兩張圖一一對應，并且我們看到定義_class_t類型的OBJC_CLASS_$_Preson結構體，最后將_OBJC_$_CATEGORY_Preson_$_Test的cls指針指向OBJC_CLASS_$_Preson結構體地址。我們這里可以看出，cls指針指向的應該是分類的主類類對象的地址。

通過以上分析我們發現。分類源碼中確實是將我們定義的對象方法，類方法，屬性等都存放在catagory_t結構體中。接下來我們在回到runtime源碼查看catagory_t存儲的方法，屬性，協議等是如何存儲在類對象中的。

首先來到runtime初始化函數

runtime初始化函數.png

Discover categories代碼.png

從上述代碼中我們可以知道這段代碼是用來查找有沒有分類的。通過_getObjc2CategoryList函數獲取到分類列表之后，進行遍歷，獲取其中的方法，協議，屬性等。可以看到最終都調用了remethodizeClass(cls);函數。我們來到remethodizeClass(cls);函數內部查看。

remethodizeClass函數內部.png

來到attachCategories函數內部。

attachCategories函數內部實現.png

下面來看一下attachLists函數內部。

attachLists函數內部.png

attachLists函數中最重要的兩個方法為memmove內存移動和memcpy內存拷貝。我們先來分別看一下這兩個函數

// memmove ：內存移動。
/*  __dst : 移動內存的目的地
*   __src : 被移動的內存首地址
*   __len : 被移動的內存長度
*   將__src的內存移動__len塊內存到__dst中
*/
void    *memmove(void *__dst, const void *__src, size_t __len);

// memcpy ：內存拷貝。
/*  __dst : 拷貝內存的拷貝目的地
*   __src : 被拷貝的內存首地址
*   __n : 被移動的內存長度
*   將__src的內存移動__n塊內存到__dst中
*/
void    *memcpy(void *__dst, const void *__src, size_t __n);

下面解釋下上面重點代碼的含義

memmove: 將array()->lists的內存 移動oldCount * sizeof(array()->lists[0]) 個內存 到 lists + addedCount。

memcpy: 將addedLists的內存 復制addedCount * sizeof(array()->lists[0]) 個內存 到 array()->lists。

下面通過圖示分析下經過memmove和memcpy方法過后的內存變化。

經過memmove和memcpy方法之前

array()->lists (原來的方法，屬性，協議列表)

array()->lists內存結構.png

addedLists (傳入的分類方法，屬性，協議列表)

addedLists內存結構.jpg

經過memmove方法之后，內存變化為

// array()->lists 原來方法、屬性、協議列表數組
// addedCount 分類數組長度
// oldCount * sizeof(array()->lists[0]) 原來數組占據的空間
memmove(array()->lists + addedCount, array()->lists, 
                  oldCount * sizeof(array()->lists[0]));

array()->lists (原來的方法，屬性，協議列表)

array()->lists 經過memmove之后.png

addedLists (傳入的分類方法，屬性，協議列表)未變化
經過memmove方法之后，我們發現，雖然本類的方法，屬性，協議列表會分別后移，但是本類的對應數組的指針依然指向原始位置。
memcpy方法之后，內存變化

// array()->lists 原來方法、屬性、協議列表數組
// addedLists 分類方法、屬性、協議列表數組
// addedCount * sizeof(array()->lists[0]) 原來數組占據的空間
memcpy(array()->lists, addedLists, 
               addedCount * sizeof(array()->lists[0]));

最終結果

最終效果圖.png

我們發現原來指針并沒有改變，至始至終指向開頭的位置。并且經過memmove和memcpy方法之后，分類的方法，屬性，協議列表被放在了類對象中原本存儲的方法，屬性，協議列表前面。

那么為什么要將分類方法的列表追加到本來的對象方法前面呢，這樣做的目的是為了保證分類方法優先調用，我們知道當分類重寫本類的方法時，會覆蓋本類的方法。
其實經過上面的分析我們知道本質上并不是覆蓋，而是優先調用。本類的方法依然在內存中的。我們可以通過打印所有類的所有方法名來查看

- (void)printMethodNamesOfClass:(Class)cls
{
    unsigned int count;
    // 獲得方法數組
    Method *methodList = class_copyMethodList(cls, &count);
    // 存儲方法名
    NSMutableString *methodNames = [NSMutableString string];
    // 遍歷所有的方法
    for (int i = 0; i < count; i++) {
        // 獲得方法
        Method method = methodList[i];
        // 獲得方法名
        NSString *methodName = NSStringFromSelector(method_getName(method));
        // 拼接方法名
        [methodNames appendString:methodName];
        [methodNames appendString:@", "];
    }
    // 釋放
    free(methodList);
    // 打印方法名
    NSLog(@"%@ - %@", cls, methodNames);
}
- (void)viewDidLoad {
    [super viewDidLoad];    
    Preson *p = [[Preson alloc] init];
    [p run];
    [self printMethodNamesOfClass:[Preson class]];
}

通過下圖中打印內容可以發現，調用的是Test2中的text方法，并且Person類中存儲著兩個text方法。

關于源碼的讀取順序

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)

總結:

1.Category的實現原理，以及Category為什么只能加方法不能加屬性?

分類的實現原理是將category中的方法，屬性，協議數據放在category_t結構體中，然后將結構體內的方法列表拷貝到類對象的方法列表中。
Category可以添加屬性，但是并不會自動生成成員變量及set/get方法。因為category_t結構體中并不存在成員變量。通過之前對對象的分析我們知道成員變量是存放在實例對象中的，并且編譯的那一刻就已經決定好了。而分類是在運行時才去加載的。那么我們就無法再程序運行時將分類的成員變量中添加到實例對象的結構體中。因此分類中不可以添加成員變量。
如果Category中的方法和類中的方法重復，將調用Category中的方法，因為在將結構體內的方法列表拷貝到類對象的方法列表中的時候放在了類數據前面。

更多iOS 開發相關知識

我的簡書主頁