给JSON数据字符串中的键名加上双引号

发表于2015年7月17日由xmsg

因为项目需要的HTTP协议环境下的JSON数据进行交互.并且本地开发使用C/C++.为了减少工作量自然是需要找几个开源库支持一下.HTTP协议方面CURL即可.JSON方面看起来有不少库可以选择.我找了一个jsoncpp和一个libjson库准备择优录取.

因为JSON格式数据源是JAVA输出的,JSON中的Object集合中的key没有使用双引号结果在jsoncpp和libjson下parse都不能成功.然后我让同事在boost库中有的JSON模式下测试.结果还是不支持没有使用双引号的key.
libjson期待的数据格式:{“key”:”value”},HTTP提供的数据:{key:value}

 

数据源是第三方软件支持的.没有修改的余地，没有别的办法．我只好自己写这样一个功能：实现一个函数．函数读取并解析JSON串并将所有的集合中的key都加上双引号.并且要求如下.首选函数不能JSON串中的双引号和转义字符干扰.第二.需要支持JSON中的ARRYA,Object的嵌套和混合嵌套.第三不能被空白字符和其它编码干扰.
经过分析和调试.写了一个函数.用来把一个JSON串中的key加上双引号.
此函数可以配合各种C/C++版的JSON使用用于在JSON串中添加和删除双引号.并且函数只用于无格式化的JSON数据.

 

[cpp] view plaincopy

  1. // libjsontest.cpp : 定义控制台应用程序的入口点。
  2. //
  4. #include “stdafx.h”
  6. #include “libjson/libjson.h”
  7. #include “libjson_ext.h”
  9. #pragma comment(lib,”statLibJson.lib”)
  11. char * json_getobjtype(char type)
  12. {
  13.     /*
  14.     #define JSON_NULL ‘/0’
  15. #define JSON_STRING ‘/1’
  16. #define JSON_NUMBER ‘/2’
  17. #define JSON_BOOL ‘/3’
  18. #define JSON_ARRAY ‘/4’
  19. #define JSON_NODE ‘/5’*/
  20.     switch(type)
  21.     {
  22.     case ‘/0’:
  23.         return “NULL”;
  24.     case ‘/1’:
  25.         return “STRING”;
  26.     case ‘/2’:
  27.         return “NUMBER”;
  28.     case ‘/3’:
  29.         return “BOOL”;
  30.     case ‘/4’:
  31.         return “ARRAY”;
  32.     case ‘/5’:
  33.         return “NODE”;
  34.     default:
  35.         return “UNDEFINE”;
  36.     }
  37. }
  39. //排除引号区域并搜索特殊字符.
  40. char * json_getcharaddr(char * start,char * end,char key)
  41. {
  42.     char inq=‘#’;
  43.     char * startbak=start;
  44.     while(start<end)
  45.     {
  46.         if(inq==‘#’&&(*start==‘/’‘||*start==’“‘)&&(start==startbak||*(start-1)!=’//’))
  47.         {
  48.             inq=*start;//进入引区.
  49.             start++;
  50.             continue;
  51.         }
  52.         if(inq!=‘#’&&*start==inq&&*(start-1)!=‘//’)
  53.         {
  54.             inq=‘#’;//退出引区.
  55.             start++;
  56.             continue;
  57.         }
  58.         if(inq==‘#’&&*start==key)return start;//找到了.
  59.         start++;
  60.     }
  61.     return NULL;
  62. }
  64. void * json_findnode(void * json,char * xpath)
  65. {
  66.     char * _xpath=xpath;
  67.     char * xpathend=xpath+strlen(xpath);
  68.     char value[2048];
  69.     unsigned int valueindex=0;
  70.     void * ret=json;
  71.     int ind=0;
  72.     while(_xpath<=xpathend)
  73.     {
  74.         if(*_xpath==‘/’||*_xpath==‘/0’||_xpath==xpathend)
  75.         {
  76.             if(valueindex!=0)
  77.             {
  78.                 //printf(“%s/n”,value);
  79.                 char * valueend=value+valueindex;
  80.                 char * spkey=json_getcharaddr(value,valueend,‘:’);
  81.                 char * spkeyold=value;
  82.                 if(spkey)
  83.                 {
  84.                     while(spkey)
  85.                     {
  86.                         *spkey=‘/0’;
  87.                         spkey++;
  88.                         ret=::json_get(ret,spkeyold);
  89.                         //printf(“%s/n”,spkeyold);
  90.                         if(!ret)return NULL;
  91.                         if(spkey==valueend)break;
  92.                         spkeyold=spkey;
  93.                         spkey=json_getcharaddr(spkeyold,valueend,‘:’);
  94.                     }
  95.                     //printf(“%s/n%s/n/n”,spkeyold,spkey);
  96.                     //int size=::json_size(ret);
  97.                     //if(size==0);//这里是值并非OBJ或ARR
  98.                     if(spkey==NULL)
  99.                     {
  100.                         ind=atoi(spkeyold);
  101.                         //printf(“%s/n”,spkeyold);
  102.                         ret=::json_at(ret,ind);
  103.                         if(!ret)return NULL;
  104.                     }
  105.                 }
  106.                 else
  107.                 {
  108.                     ind=atoi(value);
  109.                     int size=::json_size(ret);
  110.                     if(size==0)return NULL;//这里是值并非OBJ或ARR
  111.                     ret=::json_at(ret,ind);
  112.                     if(!ret)return NULL;
  113.                 }
  114.             }
  115.             memset(value,0,valueindex);
  116.             valueindex=0;
  117.         }
  118.         else
  119.         {
  120.             value[valueindex]=*_xpath;
  121.             valueindex++;
  122.             if(valueindex>sizeof(value))
  123.                 return NULL;
  124.         }
  125.         _xpath++;
  126.     }
  127.     return ret;
  128. }
  130. //获取第一个非空白字符.
  131. char * json_getfirstcharaddr(char * start,char * end)
  132. {
  133.     while(start<end)
  134.     {
  135.         if(!isspace(*start))return start;
  136.         start++;
  137.     }
  138.     return NULL;
  139. }
  140. //获取最后一个非空白字符.
  141. char * json_getlastcharaddr(char * start,char * end)
  142. {
  143.     end–;
  144.     while(end>=start)
  145.     {
  146.         if(!isspace(*end))return end+1;
  147.         end++;
  148.     }
  149.     return NULL;
  150. }
  152. bool json_formatjsonkey(char ** injson,char * injsonend,char ** outjson,char * outjsonmax,bool addq/*=true*/,char split/*=’#’*/)
  153. {//函数不关心值边界问题.
  154.     //界符:{[,:”‘]}
  155.     //转义:/被转意:”,’,/,/,b,f,n,r,t,u
  156.     //值中不能出现”,/
  157.     //函数在递归时确定injson肯定只包含了一个值.
  158.     char * _injson=*injson;
  159.     char * _outjson=*outjson;
  161.     char _split=‘#’;//默认界符是无界#.找到界,再退出界,然后就返回了.如果没找到界的话.看父界处理.
  162.     //找不到边界就是!按值处理.
  164.     //消除第一个有效字符前的空白字符
  165.     while(_injson<injsonend)//循环条件就是字符串没有处理完.
  166.     {
  167.         if(isspace(*_injson))//在任何情况下都不处理空白字符
  168.             _injson++;
  169.         else
  170.             break;
  171.     }
  172.     if(_injson==injsonend)return false;
  173.     //确定界符.
  174.     if(*_injson==‘[‘||*_injson==‘{‘)
  175.         _split=*_injson;
  176.     else
  177.         _split=‘!’;
  179.     while(_injson<injsonend)//循环条件就是字符串没有处理完.
  180.     {
  181.         if(_outjson>=outjsonmax)return false;
  182.         //_split只可能取值为[,{,!
  183.         switch(_split)
  184.         {
  185.         case ‘[‘:
  186.             //进数组界.
  187.             if(*_injson==‘[‘||*_injson==‘,’)
  188.             {
  189.                 *_outjson=*_injson;
  190.                 _injson++;
  191.                 _outjson++;
  192.                 if(!json_formatjsonkey(&_injson,injsonend,&_outjson,outjsonmax,addq,_split))
  193.                     return false;
  194.                 *injson=_injson;
  195.                 *outjson=_outjson;//指针因为函数的执行而向前跳越.
  196.             }
  197.             else if(*_injson==‘]’)
  198.             {
  199.                 //出界.进入父界.
  200.                 *_outjson=*_injson;
  201.                 _injson++;
  202.                 _outjson++;
  203.                 *injson=_injson;
  204.                 *outjson=_outjson;
  205.                 *_outjson=‘/0’;
  206.                 return true;//递归返回点.
  207.             }
  208.             else
  209.             {
  210.                 _injson++;
  211.             }
  212.             break;
  213.         case ‘{‘:
  214.             //进对象界.
  215.             if(*_injson==‘{‘||*_injson==‘,’)
  216.             {
  217.                 *_outjson=*_injson;
  218.                 _injson++;
  219.                 _outjson++;
  220.                 //进行KEY处理
  221.                 char *tmp=json_getcharaddr(_injson,injsonend,‘:’);
  223.                 if(tmp==NULL)return false;//没找到KEY的边界.
  224.                 char * keyfirst=json_getfirstcharaddr(_injson,tmp);
  225.                 char * keyend=json_getlastcharaddr(keyfirst,tmp);
  226.                 int tmplen=keyend-keyfirst;
  227.                 bool needq=*keyfirst!=‘”‘;
  228.                 if(addq)
  229.                 {
  230.                     if(needq)
  231.                     {
  232.                         *_outjson=‘/”‘;
  233.                         _outjson++;
  234.                     }
  235.                     memcpy(_outjson,keyfirst,tmplen);
  236.                     _outjson+=tmplen;
  237.                     _injson=tmp;
  238.                     if(needq)
  239.                     {
  240.                         *_outjson=‘/”‘;
  241.                         _outjson++;
  242.                     }
  243.                 }
  244.                 else
  245.                 {
  246.                     if(!needq)
  247.                     {
  248.                         keyfirst++;
  249.                         tmplen-=2;
  250.                     }
  251.                     memcpy(_outjson,keyfirst,tmplen);
  252.                     _outjson+=tmplen;
  253.                     _injson=tmp;
  254.                 }
  255.                 //进行值处理
  256.                 *_outjson=*_injson;
  257.                 _injson++;
  258.                 _outjson++;
  259.                 if(!json_formatjsonkey(&_injson,injsonend,&_outjson,outjsonmax,addq,_split))
  260.                     return false;
  261.                 *injson=_injson;
  262.                 *outjson=_outjson;//指针因为函数的执行而向前跳越.
  263.             }
  264.             else if(*_injson==‘}’)
  265.             {
  266.                 //出界.进入父界.
  267.                 *_outjson=*_injson;
  268.                 _injson++;
  269.                 _outjson++;
  270.                 *injson=_injson;
  271.                 *outjson=_outjson;
  272.                 *_outjson=‘/0’;
  273.                 return true;//递归返回点.
  274.             }
  275.             else
  276.             {
  277.                 _injson++;
  278.             }
  279.             break;
  280.         case ‘!’:
  281.             switch(split)
  282.             {//如果认定当前内容非ARRAY也非OBJ的话.以父内容来定界.
  283.             case ‘[‘:
  284.                 if(*_injson==‘]’||*_injson==‘,’)
  285.                 {
  286.                     //出界.进入父界.
  287.                     *_outjson=*_injson;
  288.                     *injson=_injson;
  289.                     *outjson=_outjson;
  290.                     return true;//递归返回点.
  291.                 }
  292.                 else
  293.                 {
  294.                     *_outjson=*_injson;
  295.                     _injson++;
  296.                     _outjson++;
  297.                     continue;
  298.                 }
  299.                 break;
  300.             case ‘{‘:
  301.                 if(*_injson==‘}’||*_injson==‘,’)
  302.                 {
  303.                     //出界.进入父界.
  304.                     *_outjson=*_injson;
  305.                     *injson=_injson;
  306.                     *outjson=_outjson;
  307.                     return true;//递归返回点.
  308.                 }
  309.                 else
  310.                 {
  311.                     *_outjson=*_injson;
  312.                     _injson++;
  313.                     _outjson++;
  314.                     continue;
  315.                 }
  316.                 break;
  317.             default:
  318.                 return false;
  319.             }
  320.             break;
  321.         default:
  322.             return false;
  323.         }
  324.     }
  325.     return false;
  326. }

 

版权声明：本文为博主原创文章，未经博主允许不得转载。

关于xmsg

技术面前人人平等.同时技术也不分高低贵贱.正所谓学无大小,达者为尊.
此条目发表在C/C++分类目录，贴了, 标签。将固定链接加入收藏夹。