cJSON序列化工具解读一（结构剖析）

cJSON序列化工具解读一（结构剖析）

cJSON简介

JSON基本信息

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。

易于人阅读和编写。

同时易于机器解析和生成。

是一种很好地数据交换语言。

官方信息解读简介

JSON构建：基于两种结构

　　“名称/值”对 的集合。

　　值得有序列表。

JSON具体结构表示

　　对象：一个”名称/值"对的集合  {名称：值，名称：值}

　　数组：值得有序集合[值，值]

　　值：str，num，true，false，null，object，array。

可嵌套

　　字符串：由双引号包围的任意数量Unicode字符的集合，反斜杠转义

　　数值：类似C,java：没有8进制和具体的编码细节

cJSON源码解读

首先给出cJSON文件中头文件函数列表

我们将根据此进行模块化解读

①结构描述

关于具体的结构图解描述，请参考官方描述

    /* cJSON Types: */

#define cJSON_False 0

#define cJSON_True 1

#define cJSON_NULL 2

#define cJSON_Number 3

#define cJSON_String 4

#define cJSON_Array 5

#define cJSON_Object 6

#define cJSON_IsReference 256

#define cJSON_StringIsConst 512

以上是具体的类型区分描述，可以改进为使用enum实现更加安全

    /* The cJSON structure: */

    typedef struct cJSON {

        struct cJSON *next, *prev;    /* 如果是同一级别类型元素，使用双项链方式实现 */

        struct cJSON *child;        /* 如果是具体结构或者数组，第一个指针指向内部链 */

        int type;                    /*根据以上定义描述所保存对象类型*/

        char *valuestring;            /* The item's string, if type==cJSON_String */

        int valueint;                /* The item's number, if type==cJSON_Number */

        double valuedouble;            /* The item's number, if type==cJSON_Number */

        char *string;                /* 对于key-value映射结构，表示其key/名称 */

    }cJSON;

②关于内存管理

    typedef struct cJSON_Hooks {

        void *(*malloc_fn)(size_t sz);

        void(*free_fn)(void *ptr);

    } cJSON_Hooks;

注：cJSON的内存管理，提供了用户自主方式的接口。

可以通过方法InitHooks来设置自己的内存管理，默认使用malloc，free

static void *(*cJSON_malloc)(size_t sz) = malloc;

static void(*cJSON_free)(void *ptr) = free;

void cJSON_InitHooks(cJSON_Hooks* hooks)

{

    if (!hooks) { /* Reset hooks */

        cJSON_malloc = malloc;

        cJSON_free = free;

        return;

    }

    cJSON_malloc = (hooks->malloc_fn) ? hooks->malloc_fn : malloc;

    cJSON_free = (hooks->free_fn) ? hooks->free_fn : free;

}

③结点创建，删除结点

/* Internal constructor. */

static cJSON *cJSON_New_Item(void)

{

    cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));

    if (node) memset(node, , sizeof(cJSON));

    return node;

}

/* Delete a cJSON structure. */

//删除节点很简单， 先删除儿子，然后清理内存即可。

//总结一下就是对于 object 和 array 需要先删除儿子，然后删除自己。

//对于 字符串， 需要先释放字符串的内存， 再释放自己这块内存。

//对于其他节点，直接释放自己这块内存。

void cJSON_Delete(cJSON *c)

{

    cJSON *next;

    while (c)

    {

        next = c->next;

        if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);　　//

        if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);

        if (!(c->type&cJSON_StringIsConst) && c->string) cJSON_free(c->string);

        cJSON_free(c);

        c = next;

    }

}

有了结点设置，那么下面就是具体类型结点的实现了：设置类型，设置具体类型的值

    /* These calls create a cJSON item of the appropriate type. */

    extern cJSON *cJSON_CreateNull(void);

    extern cJSON *cJSON_CreateTrue(void);

    extern cJSON *cJSON_CreateFalse(void);

    extern cJSON *cJSON_CreateBool(int b);

    extern cJSON *cJSON_CreateNumber(double num);

    extern cJSON *cJSON_CreateString(const char *string);

    extern cJSON *cJSON_CreateArray(void);

    extern cJSON *cJSON_CreateObject(void);

    /* These utilities create an Array of count items. */

    extern cJSON *cJSON_CreateIntArray(const int *numbers, int count);

    extern cJSON *cJSON_CreateFloatArray(const float *numbers, int count);

    extern cJSON *cJSON_CreateDoubleArray(const double *numbers, int count);

    extern cJSON *cJSON_CreateStringArray(const char **strings, int count);

/* Create basic types: */

cJSON *cJSON_CreateNull(void)

{

    cJSON *item = cJSON_New_Item();

    if (item)

        item->type = cJSON_NULL;

    return item;

}

/* Create Arrays: */

cJSON *cJSON_CreateIntArray(const int *numbers, int count)

{

    int i; cJSON *n = , *p = ,

        *a = cJSON_CreateArray();

    for (i = ; a && i < count; i++)

    {

        n = cJSON_CreateNumber(numbers[i]); //申请N个几点

        if (!i)

            a->child = n;//第一个结点链接使用child

        else

            suffix_object(p, n);//其他结点 ：连接prev next

        p = n;

    }return a;

}

④结点 *** 作

    /* Append item to the specified array/object. */

    extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);

    extern void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);

    extern void cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);    /* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object */

/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, 
but don't want to corrupt your existing cJSON. */

    extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);

    extern void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);

    /* Remove/Detatch items from Arrays/Objects. */
　　//Detatch脱离，使item从arr链中脱离，便于delete

    extern cJSON *cJSON_DetachItemFromArray(cJSON *array, int which);

    extern void   cJSON_DeleteItemFromArray(cJSON *array, int which);

    extern cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string);

    extern void   cJSON_DeleteItemFromObject(cJSON *object, const char *string);

    /* Update array items. */

    extern void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem);    /* Shifts pre-existing items to the right. */

    extern void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);

    extern void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem);

注：①

Detach 是什么东西呢？
我们把一个节点从 json 树中删除， 但是不释放内存，而是先保留这个节点的指针， 这样储存在这个节点的信息都保留了下来。

接下来我们就可以做很多事了， 合适的时候添加到其他对象中， 合适的时候释放内存。

比如上面的 delete 函数， 就需要真实的删除了， 这个时候我们删除即可。

而 detach 实现也比较简单， 只是少了一步删除 *** 作。

//将结点从结构中脱离

cJSON *cJSON_DetachItemFromArray(cJSON *array, int which)

{

    cJSON *c = array->child;

    while (c && which>)

        c = c->next, which--;

    if (!c)

        return ;

    if (c->prev)

        c->prev->next = c->next;

    if (c->next)

        c->next->prev = c->prev;

    if (c == array->child)

        array->child = c->next;

    c->prev = c->next = ;

    return c;

}

void   cJSON_DeleteItemFromArray(cJSON *array, int which)

{

    cJSON_Delete(cJSON_DetachItemFromArray(array, which));

}

　　②关于以上相关方法，简单的增加结点就是个链表 *** 作了，然后对于

cJSON_AddItemReferenceToArray这个方法说明
cJSON除了实现简单的增加结点到结构之外，还有简单考虑效率问题。


比如同时增加一个结点到两棵树中，那么如果有深浅拷贝问题时，cJSON做法是，增加一个结点为Reference类型，在另一棵树中。

这里的做法可以是引用计数，写实拷贝等
我们来看看cJSON实现吧

/* Utility for handling references. */

static cJSON *create_reference(cJSON *item)

{

    cJSON *ref = cJSON_New_Item();

    if (!ref)

        return ;

    memcpy(ref, item, sizeof(cJSON)); //浅拷贝所有值-->最终保存了结点的value部分

    ref->string = ; //k-v中的值清空，以便于重新设置

    ref->type |= cJSON_IsReference;  //结点类性是具体item类型的同时也是reference

    ref->next = ref->prev = ;  //只是当前节点的引用，去除引用的链接

    return ref;

}

void    cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)

{

    cJSON_AddItemToArray(array, create_reference(item)); //创建应用结点之后加入目的数组

}

void   cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)

{

    cJSON *c = array->child;

    while (c && which>)

        c = c->next, which--;   //找到具体位置

    if (!c)

        return;

    newitem->next = c->next;

    newitem->prev = c->prev; //连入结构中

    if (newitem->next)

        newitem->next->prev = newitem;//修改后指针

    if (c == array->child)  //如果是个孩子，

        array->child = newitem;

    else

        newitem->prev->next = newitem;  //修改后指针

    c->next = c->prev = ;//释放被代替的结点

    cJSON_Delete(c);

}

⑤查找相关

/* Get Array size/item / object item. */

int    cJSON_GetArraySize(cJSON *array)

{

    cJSON *c = array->child;

    int i = ;

    while (c)

        i++, c = c->next;

    return i;

}

cJSON *cJSON_GetArrayItem(cJSON *array, int item)

{

    cJSON *c = array->child;

    while (c && item>)

        item--, c = c->next;

    return c;

}

//结构中结点的设置，需要通过变量名来查找

cJSON *cJSON_GetObjectItem(cJSON *object, const char *string)

{

    cJSON *c = object->child;

    while (c && cJSON_strcasecmp(c->string, string))

        c = c->next;

    return c;

}

⑥总结部分：

通过以上对于cJSON结构的简单学习和剖析，我们不难联想到广义表。

其实这个结构的实现就是类似广义表实现：由child递归为广义结构

关于具体的cJSON数据解析部分，请参考博客《cJONS序列化工具解读②(数据解析)》