美文网首页
cJSON源码分析

cJSON源码分析

作者: 书呆子的复仇 | 来源:发表于2017-01-14 12:17 被阅读4634次

    cJSON是C语言中的一个JSON编解码器,非常轻量级,C文件只有不到一千行,代码的可读性也很好,很适合作为C语言项目进行学习。项目主页:
    https://sourceforge.net/projects/cjson/

    对于json格式编码与解码,其实就是类似于一个解释器,主要原理还是运用递归。个人认为,如果能用一些支持面向对象的语言来做这个项目,代码实现起来应该会更加优雅。

    先来看一下cJSON的数据结构:

    /* The cJSON structure: */
    typedef struct cJSON {
        struct cJSON *next,*prev;   /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
        struct cJSON *child;        /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
    
        int type;                   /* The type of the item, as above. */
    
        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;               /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
    } cJSON;
    

    不管是数值类型、字符串类型或者对象类型等都使用该结构体,类型信息通过标识符 type来进行判断,cJSON总共定义了7种类型:

    /* 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
    

    另外,如果是对象或者数组,采用的是双向链表来实现,链表中的每一个节点表示数组中的一个元素或者对象中的一个字段。其中child表示头结点,next、prev分别表示下一个节点和前一个节点。valuestring、valueint、valuedouble分别表示字符串、整数、浮点数的字面量。string表示对象中某一字段的名称,比如有这样的一个json字符串:

    {'age': 20}
    

    'age'则用结构体中的string来表示。

    cJSON的api使用起来非常简单:

    char *out;cJSON *json;
        
    json=cJSON_Parse(text);
    if (!json) {
        printf("Error before: [%s]\n",cJSON_GetErrorPtr());
    } else {
        out=cJSON_Print(json);
        cJSON_Delete(json);
        printf("%s\n",out);
        free(out);
    }
    

    代码都是自解释的就不啰嗦,唯一需要注意的是使用完成后,必须释放内存,以免内存泄露。

    JSON的解析

    下面我们先来看一下json字符串的解析,json的字符串的解析主要是通过cJSON_Parse函数来完成,打开cJSON_Parse函数后,我们发现该函数使用了另外一个辅助函数:

    /* Default options for cJSON_Parse */
    cJSON *cJSON_Parse(const char *value) {
        return cJSON_ParseWithOpts(value,0,0);
    }
    

    cJSON_ParseWithOpts提供了一些额外的参数选项:

    /* Parse an object - create a new root, and populate. */
    cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated) {
        const char *end = 0;
        cJSON *c = cJSON_New_Item();
        ep = 0;
        if (!c) return 0;       /* memory fail */
    
        end = parse_value(c, skip(value));
        if (!end) {
            cJSON_Delete(c);
            return 0;
        }    /* parse failure. ep is set. */
    
        /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
        if (require_null_terminated) {
            end = skip(end);
            if (*end) {
                cJSON_Delete(c);
                ep = end;
                return 0;
            }
        }
        if (return_parse_end) *return_parse_end = end;
        return c;
    }
    

    第一步:先调用cJSON_New_Item创建一个节点,该函数实现非常简单,就是使用malloc分配一块内存,再将分配的内存使用0来进行初始化。

    /* Internal constructor. */
    static cJSON *cJSON_New_Item(void)
    {
        cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));
        if (node) memset(node,0,sizeof(cJSON));
        return node;
    }
    

    第二步:调用parse_value函数进行真正的解析,该函数是json解析的核心部分,后面我们会重点分析。而在解析前,先对json字符串调用了一次skip,其实就是将字符串前面的的一些空字符去除,代码如下:

    /* Utility to jump whitespace and cr/lf */
    static const char *skip(const char *in) {
        while (in && *in && (unsigned char) *in <= 32) in++;
        return in;
    }
    

    最后一步:函数中参数中提供了require_null_terminated是为了确保json字符串必须以'\0'字符作为结尾。若参数提供了return_parse_end,将返回json字符串解析完成后剩余的部分。

    下面来看json解析算法的核心部分:

    static const char *parse_value(cJSON *item, const char *value) {
        if (!value) return 0;    /* Fail on null. */
        //若字符串等于null,直接将type标记为cJSON_NULL
        if (!strncmp(value, "null", 4)) {
            item->type = cJSON_NULL;
            return value + 4;
        }
        //若字符串等于false,直接将type标记为cJSON_False
        if (!strncmp(value, "false", 5)) {
            item->type = cJSON_False;
            return value + 5;
        }
        //若字符串等于true,直接将type标记为cJSON_True
        if (!strncmp(value, "true", 4)) {
            item->type = cJSON_True;
            item->valueint = 1;
            return value + 4;
        }
        //若字符串以\"开头,说明是一个字符串
        if (*value == '\"') { return parse_string(item, value); }
        //若字符串以0~9或者-开头,则是一个数值
        if (*value == '-' || (*value >= '0' && *value <= '9')) { return parse_number(item, value); }
        //若字符串以[开头,则是一个数组
        if (*value == '[') { return parse_array(item, value); }
        //若字符串以{开头,则是一个对象
        if (*value == '{') { return parse_object(item, value); }
    
        ep = value;
        return 0;    /* failure. */
    }
    

    上述 代码看上去应该清晰易懂,且都已加入注释。对于json为null、true或者false的情况,直接将type置为对应的类型即可。对于其他情况,需要分别再做处理,先来看json为字符串的情况:

    static const char *parse_string(cJSON *item, const char *str) {
        const char *ptr = str + 1;
        char *ptr2;
        char *out;
        int len = 0;
        unsigned uc, uc2;
        if (*str != '\"') {
            ep = str;
            return 0;
        }    /* not a string! */
    
        /* 这一步主要是为了确定字符串的长度,以便下一步进行内存分配
         * 问题在于字符串中可能存在一定的转义字符,由于json字符串本身
         * 是一个字符串,碰到像双引号必须进行转义,另外像\t这样的转义
         * 字符,需要再次转义,用\\t来表示。而在解析的时候,我们不需要
         * 这些多余的转义字符。(说得有点绕,不知道能不能看明白)
         */
        while (*ptr != '\"' && *ptr && ++len) 
            if (*ptr++ == '\\') ptr++;   
    
        //分配内存,保存解析后的结果
        out = (char *) cJSON_malloc(len + 1);
        if (!out) return 0;
    
        ptr = str + 1; //跳过第一个\"
        ptr2 = out;
        //当遇到\"时,说明到达字符串的末尾
        while (*ptr != '\"' && *ptr) {
            //如果不是转义字符,直接原样复制
            if (*ptr != '\\') *ptr2++ = *ptr++;
            else { //碰到像\\b的再转义字符,改成\b
                ptr++;
                switch (*ptr) {
                    case 'b':
                        *ptr2++ = '\b';
                        break;
                    case 'f':
                        *ptr2++ = '\f';
                        break;
                    case 'n':
                        *ptr2++ = '\n';
                        break;
                    case 'r':
                        *ptr2++ = '\r';
                        break;
                    case 't':
                        *ptr2++ = '\t';
                        break;
                    case 'u':     /*这里将 utf16 转为 utf8,算法比较复杂,不做分析 */
                        uc = parse_hex4(ptr + 1);
                        ptr += 4;    /* get the unicode char. */
    
                        if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0) break;    /* check for invalid.  */
    
                        if (uc >= 0xD800 && uc <= 0xDBFF)    /* UTF16 surrogate pairs.  */
                        {
                            if (ptr[1] != '\\' || ptr[2] != 'u') break;    /* missing second-half of surrogate. */
                            uc2 = parse_hex4(ptr + 3);
                            ptr += 6;
                            if (uc2 < 0xDC00 || uc2 > 0xDFFF) break;    /* invalid second-half of surrogate.    */
                            uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));
                        }
    
                        len = 4;
                        if (uc < 0x80) len = 1; else if (uc < 0x800) len = 2; else if (uc < 0x10000) len = 3;
                        ptr2 += len;
    
                        switch (len) {
                            case 4:
                                *--ptr2 = ((uc | 0x80) & 0xBF);
                                uc >>= 6;
                            case 3:
                                *--ptr2 = ((uc | 0x80) & 0xBF);
                                uc >>= 6;
                            case 2:
                                *--ptr2 = ((uc | 0x80) & 0xBF);
                                uc >>= 6;
                            case 1:
                                *--ptr2 = (uc | firstByteMark[len]);
                        }
                        ptr2 += len;
                        break;
                    default:
                        *ptr2++ = *ptr;
                        break;
                }
                ptr++;
            }
        }
        *ptr2 = 0;
        if (*ptr == '\"') ptr++;
        item->valuestring = out;
        item->type = cJSON_String;
        return ptr;
    }
    

    解析字符串的困难之处在于可能会碰到转义字符,需要将类似于\\t这样的再转义字符转化为\t,对于如何将utf16转为utf8的算法比较复杂,我就不做分析了。其他情况原样复制即可。

    下面是解析数值类型的代码:

    static const char *parse_number(cJSON *item, const char *num) {
        double n = 0, sign = 1, scale = 0;
        int subscale = 0, signsubscale = 1;
    
        if (*num == '-') sign = -1, num++;    /*如果是负数,将sign置位-1 */
        if (*num == '0') num++;            /* 如果是0,直接越过 */
        if (*num >= '1' && *num <= '9') /* 碰到数字1~9,用循环计算整数部分的数值 */
            do n = (n * 10.0) + (*num++ - '0'); while (*num >= '0' && *num <= '9');    
        if (*num == '.' && num[1] >= '0' && num[1] <= '9') { /* 遇到小数点,计算小数位的数值,用scale来标记小数有多少位 */
            num++;
            do n = (n * 10.0) + (*num++ - '0'), scale--; while (*num >= '0' && *num <= '9');
        }    
        if (*num == 'e' || *num == 'E')     /* 遇到指数,计算指数位的数值 */
        {
            num++;
            if (*num == '+') num++; else if (*num == '-') signsubscale = -1, num++;       
            while (*num >= '0' && *num <= '9') subscale = (subscale * 10) + (*num++ - '0');   
        }
    
       /* 最后根据前面的得到的数值,计算最终的结果 */
        n = sign * n * pow(10.0, (scale + subscale * signsubscale));    /* number = +/- number.fraction * 10^+/- exponent */
    
        item->valuedouble = n;
        item->valueint = (int) n;
        item->type = cJSON_Number;
        return num;
    }
    

    这部分代码也不难,花点时间应该就能看懂。主要是考虑了小数和指数的情况,会带来一定的复杂性。 吐槽一下作者把if语句块中的代码都写在一行上,导致看起来很费劲。

    接下来是如何解析数组:

    static const char *parse_array(cJSON *item, const char *value) {
        cJSON *child;
        if (*value != '[') { //不是一个数组,直接返回
            ep = value;
            return 0;
        }   
    
        item->type = cJSON_Array;
        value = skip(value + 1); //跳过前面的空白字符
        if (*value == ']') return value + 1;    /* 空数组 */
    
        //创建数组的头结点,表示数组的第一个元素
        item->child = child = cJSON_New_Item();
        if (!item->child) return 0;      
        //对数组中的第一个元素递归调用parse_value 
        value = skip(parse_value(child, skip(value))); 
        if (!value) return 0;
    
        //如果数组第一个元素后面存在逗号,说明还有其他元素
        //对剩下的元素同样递归调用parse_value,并将后面的元素
        //放在child节点的尾部,形成一个链表
        while (*value == ',') {
            cJSON *new_item;
            if (!(new_item = cJSON_New_Item())) return 0;   
            //移动指针
            child->next = new_item;
            new_item->prev = child;
            child = new_item;
            
            value = skip(parse_value(child, skip(value + 1)));
            if (!value) return 0;
        }
    
        if (*value == ']') return value + 1;    /* 达到数组的尾部 */
        ep = value;
        return 0;
    }
    

    解析数组时,其基本思想是对数组中每一个元素递归调用parse_value,再将这些元素连接形成一个链表。

    如果能看懂数组的解析过程,对象的解析对你来说应该也不难,直接来看代码:

    static const char *parse_object(cJSON *item, const char *value) {
        cJSON *child;
        if (*value != '{') {
            ep = value;
            return 0;
        }    //不是一个对象,直接返回
    
        item->type = cJSON_Object;
        value = skip(value + 1);
        if (*value == '}') return value + 1;    /* 空对象 */
    
        //创建节点,用于保存对象中的第一个字段
        item->child = child = cJSON_New_Item();
        if (!item->child) return 0;
        
        //调用parse_string,解析第一个字段的名称
        value = skip(parse_string(child, skip(value)));
        if (!value) return 0;
        child->string = child->valuestring;
        child->valuestring = 0;
    
        //如果字段名称后面不是冒号,则不是一个合法的json字符串,直接返回
        if (*value != ':') {
            ep = value;
            return 0;
        }    
    
        //递归调用parse_value解析第一个字段的值
        value = skip(parse_value(child, skip(value + 1)));    
        if (!value) return 0;
    
       //若第一个字段后面存在逗号,则说明json对象存在其他的字段
       //后面的步骤基本跟解析数组时相同,也就是将各个字段放在
       //child节点后面,形成一个链表,唯一不同的是需要解析每个
       //字段的名称
        while (*value == ',') {
            cJSON *new_item;
            if (!(new_item = cJSON_New_Item())) return 0; 
            child->next = new_item;
            new_item->prev = child;
            child = new_item;
            value = skip(parse_string(child, skip(value + 1)));
            if (!value) return 0;
            child->string = child->valuestring;
            child->valuestring = 0;
            if (*value != ':') {
                ep = value;
                return 0;
            }  
            value = skip(parse_value(child, skip(value + 1)));   
            if (!value) return 0;
        }
    
        if (*value == '}') return value + 1;    /* 达到对象的末尾 */
        ep = value;
        return 0; 
    }
    

    最后,客户端代码在使用完成后,需要将分配的内存释放掉:

    void cJSON_Delete(cJSON *c) {
        cJSON *next;
        while (c) { //循环删除链表中所有节点
            next = c->next;
            if (c->child) cJSON_Delete(c->child); //存在子节点,递归删除
            if (c->valuestring) cJSON_free(c->valuestring); 
            if (c->string) cJSON_free(c->string);
            cJSON_free(c); //删除结构体本身
            c = next;
        }
    }
    

    cJSON对于json字符串的解析基本就结束了。后面还有关于一个生成好的json对象如何打印,其实就是解析的逆向过程,我就不赘述了。老实说,代码的基本原理很简单,无非就是使用递归,如果让我写个demo,花一个小时就能写出来。但是这样的代码之所以值得我去阅读,不光是对于代码的风格、设计还有可读性上。更重要的是,作者能考虑到很多我不会去考虑的东西,比如说对于字符串的解析,如果是我自己写,可能不会考虑存在转义字符或者utf16的情况。在解析数值时,也不会考虑存在指数的情况。如果给定的字符串不是一个合法的json字符串,又该去如何处理?这也是一个代码新手做出来的东西与一款成熟产品的区别所在。

    如果有时间,我想根据cJSON的思路,用java面向对象的方式来进行实现,并且在这基础上加入类型信息,而不是通过一个type标识符来判断类型。

    相关文章

      网友评论

          本文标题:cJSON源码分析

          本文链接:https://www.haomeiwen.com/subject/tbrebttx.html