这几天草草的浏览了一下电子版的《lua程序设计》，没有懂的地方就自动忽略了，挑拣了一些可以理解的部分一直在推进。推进至后面的时候已经浑浑噩噩的了，有种想看完这本书的强迫症的感觉。推进CAPI部分的时候发现难度一下子提升了，有种难以理解的感觉，而且这本书没有相对应的练习，只是看书没有进行相应的实践，确实难度比较大。这里先暂缓推进这本书的进程，决定拿一下小的项目来试试写lua代码的感觉，写完这个项目在回去体会lua程序设计这本书，这样可能效果会更好一些。这里我会列出项目描述，而且会记录完成这个项目的过程，当然，项目是一个非常简单，而且已经存在优秀的开源库的东西，但是这里先检查一下自己是否能够完成，完成之后可以参阅一下相关开源库的实现，对比之中应该会有所提高。
项目描述：
基于lua 5.2.3 封装实现一个可供其他lua脚本使用的功能模块，具体要求为: 1、实现一个标准的lua功能模块 2、封装json格式的数据与lua value间的互相转换功能 3、遵循json格式定义确保相同的数据源彼此转换后数据仍然一致 4、只允许使用lua内建基础库，不允许使用任何第三方开发库 5、有合理的注释和单元测试代码 6、独立完成此作业，对任何代码抄袭现象零容忍基本要求：提交lua代码文件名为json.lua，测试代码和文档（如果有）可以打一个包作为第二个附件提交json.lua中需要实现以下接口： function Marshal(json_str) return lua_val end function Unmarshal(lua_val) return "json_str" end对基本要求的说明： 1、lua版本要求5.2.3 2、lua的空table统一转化成json的空object，而不是空array 3、test case中的json_str符合ECMA-404 json格式标准 4、Unmarshal传入的lua_val如果是table的话，不会有循环嵌套 5、table如果是以array方式使用，转换如下：{[2]=1,[4]=1} == {nil,1,nil,1} <-> [null,1,null,1] 6、table中有string key时，统一处理成hash table的格式，如：{1,2;a=3} -> {"1":1,"2":2","a":3} 7、不会出现类似 {1,2;["2"]="same key 2 in json"} 造成转换有歧义的table 8、Unicode转成lua字符串时，按lua的字符串格式 \xXX\xYY... 9、能成功转换的话，只需要return单个值进阶要求：对test case的错误进行检查，返回相应错误 function Marshal(json_str) return nil, "error_type" end基本测试方法：local json = require 'json'local test_result1 = json.Marshal('{"a":1}')local test_result2 = json.Unmarshal{ b="cd" }-- validate test_result1 & test_result2
项目解决过程：
一.模块
首先这个问题是实现一个模块，在lua 5.1版开始，lua已经为模块和包定义了一系列的规则，我们需要使用table，函数，元表和环境来实现这些规则。其中lua提供了两个重要的函数实现这些规则，分别是require（使用模块函数）和module（创建模块函数）。
require可以加载模块，这里加载到的为一个table，table内容包含该模块提供的接口和成员变量；规则还定义一个规范的模块应该可以使require返回该模块的table。require使用方法为：
require "<模块名>"。其实这里require的功能感觉和dofile比较像，但是还是存在区别的，require详细的内容我目前也不是很理解，这里先略去。
完成了加载模块的解释，接下来就是自己实现模块需要遵守什么样的规则呢？模块的主要功能就是定义一个table，然后定义这个table需要导出的成员接口&成员变量，然后返回这个table即完成了这个模块的实现。module函数完成了很多简化模块编写的功能；module函数的更加详细部分以及模块编写的公共部分演化这里略去。
local modname = ...local M = {}_G[modname] = Mpackage.loaded[modname] = M setfenv(1,M) 关于子模块和包的部分这里也利用不到，所以这部分知识也略去，关于lua程序设计一书中这部分讲述也稍有复杂，其中印刷题中关于'-'和'_'区分不好，看起来比较吃力，不过关于require和module的部分讲解的非常不错。
所以这部分的代码实现如下：
module(...,package.seeall)function Marshal(json_str) print(json_str)endfunction Unmarshal(lua_content) print(lua_content)end
这里把函数的内容简化为只进行参数的输出，后面继续分析并实现函数的功能。
这部分看起来非常的容易，不过还是要明白其中的道理。
二.JSON语法简析
json的语法非常的简单，数据在 名称/值 对中，数据由逗号分隔，花括号保存对象，方括号保存数组；
json的值类型包含：数字（整数或者浮点数），字符串（双引号），逻辑值（true或者false），数组（方括号中），对象（花括号中），null
所以json语言还是比较简单的。
谈到这种解析的工作，之前接触过（浏览过）一个自己实现的HTMLParser实现，使用的方法是自动机的策略进行实现的。这种有解析思路的项目均可以利用自动机的思想来实现，自动机的课程很早之前学习的了，此时发现智商好低，学习的内容基本都已经完全还给老师了。不过针对JSON的解析可以使用自动机的思路。这里我搬运一下json官网上的自动机图解。
首先json数据是由对象 or 数组组成的基本结构;
json的对象由大括号包含的key:value组成，key:value之间由逗号隔开，其中key为string的类型，string类型具体定义下面给出。value的具体类型下面给出；
json的数组由中括号包含的value组成，value之间由逗号隔开，其中value的具体类型下面给出；
value的具体类型由string，number，object，array和一些其他json常量组成；
string是由双引号包含的一个字符串，其中包含unicode编码和一些转义字符，其中unicode字符在lua中的存储应该也是一个比较棘手的问题；
json中的转义字符也是一个很bug的问题，lua字符串中也存在转义字符。
而且lua中字符串的表示可以利用单引号，双引号和双中括号，其中单双引号的功能比较类似，存在转义符号。然而双中括号会忽略转义符号，所以这个地方编写程序的时候应该特别注意。
所以lua中定义的json字符串的转义符号要转换为lua中的转义字符串，根据上面自动机的标示有8个转义字符和一个unicode转义字符。lua的json字符串中的符号应该为"\\",\\/,\\\\,\\b,\\f,\\n,\\r,\\t,\\u...."这些了，分别应该转为lua中的"",/,\,\b,\f,\n,\r,\t"。
当然lua中内部的转义字符转换也应该逆转换过来；
所以会有两个dict进行转换； 关于unicode码的转换后面进行解释；
json_to_lua = {['\\"] = '"',['\\/'] = '/',['\\\\'] = '\\'["\\t"] = "\t",["\\f"] = "\f",["\\r"] = "\r",["\\n"] = "\n",["\\b"] = "\b"}lua_json = {['"'] = '\\"',['\\'] = '\\\\',['/'] = '\\/',['\b'] = '\\b',['\f'] = '\\f',['\n'] = '\\n',['\r'] = '\\r',['\t'] = '\\t'} 
数字的自动机转移图，其中数字包含正负类型，浮点数，整型，科学技术法，所以合法的数字类型的状态机比较复杂，但是lua中有一个可以偷懒的地方在于tonumber函数的使用，可以将string转换为number，如果转换不合法，则返回nil；
三.lua编写状态机的一些知识
由于上面已经提及了自动机来实现json的解析，然而根据lua程序设计，函数尾调用一节中得知，在lua中”尾调用“的一大应用就是编写”状态机“。
”这种程序通常一个函数就是一个状态，改变状态利用’goto‘或尾调用到另外一个特定的函数。尾调用就是一个函数的return的最后语句是另外一个函数，此时针对此函数的栈信息不进行保存，所以最后一个函数调用相当于goto语句的调用，所以如此可以进行无限的调用也不会产生栈溢出的错误。尾调用详细信息这里略去，只是简单介绍一下。
另外lua中的字符串遍历不是很方便，lua中的string是不变量，也没有提供下标访问的接口，所以只能利用string提供的sub函数去一个字符一个字符的遍历；
四.具体代码的实现
（1）json字符串的解析部分
a. Marsha1解析json字符串的接口，从第一个个字符开始遍历json字符串，position设置为1。
b. skipBlank函数跳过空格，tab，换行等空白字符；
c. 找到第一个有效字符，‘{’或者‘[’，分别继续调用decodeObject和decodeArray函数返回相应的内部lua table即可。如果不是这两个符号，则此json字符串存在格式错误。
--two interface encode json or decode jsonfunction M.Marshal(json_str) local nowTime = os.time() --json must be json array or object local position = 1 position = M.skipBlank(json_str,position) --null json string case local json_len = string.len(json_str) if position > json_len then return nil,[[null json string]] end --change to json object or json array --otherwise,invalid local c = string.sub(json_str,position,position) local res if c == [[{]] then res = M.decodeObject(json_str,position) elseif c == [[[]] then res = M.decodeArray(json_str,position) else res = nil,[[error that json no an object or array,invalid]] end M.MarshalTime = M.MarshalTime + os.time() - nowTime return resend
接下来就是decodeObject，decodeArray，decodeNumber，decodeString，decodeOther等，分别对应于json中的object，array，number，string，true，false，null等变量；和skipBlank函数同样，这些函数具有类似的输入和输出参数；
关于这些函数的输入，因为整个过程是遍历字符串，所以字符串和当前遍历的位置信息比较重要，所以这些函数的传入参数为json字符串和当前字符的位置信息；
这些函数的输出函数分别为解析到的lua内部的数据结构和下一个字符的位置信息；
（这里实现的时候同样可以把json字符串和指针的位置信息设置为两个全局变量，思路相同）
了解完这些函数的思想之后接下来就容易理解这些函数的实现代码。
跳过空白字符
其中在代码debug的时候遇到了
malformed pattern （missing ']'),error的错误，
这里因为string.find函数把第二个参数中的'['符号判断为正则表达式符号了，所以这里就产生错误，所以这里针对'['符号进行一下特殊处理；
其他方面就只检测当前字符是不是自定义的blankcharacter中的一个即可
--skip the blank character--blank character include space,\n \r \t--params--[in] json_str : json string--[in] position : current position of the string--[out] the next of end position of the blank characterfunction skipBlank(json_str,position) local blankcharacter = ' \t\r\n' local json_len = string.len(json_str) while position <= json_len do local c = string.sub(json_str,position,position) --malformed pattern (missing ']'),error if c == "[" then return position elseif string.find(blankcharacter,c) then position = position + 1 else break end end return positionend
解析json object
函数看似比较复杂，其实逻辑比较清晰；
json object开始于 '{'，结束于 '}'，由key:value对组成，由 ',' 分隔；
不断的读取key ， ':' ， value 然后填入相应的lua table，返回lua table即可；
其中利用计数的方法保证 ',' 的语法正确；
--decode from json object--begin with '{'--params--[in] json_str : json string--[in] position : current position of the string--[out] lua table , the next of end the end position of the stringfunction decodeObject(json_str,position) local lua_object = {} local key,subobject,subarray,str,number,othervalue local c = string.sub(json_str,position,position) --check case if c ~= [[{]] then base.print [[error that object not start with { ]] return nil,[[error in decodeObject begin]] end position = position + 1 position = skipBlank(json_str,position) c = string.sub(json_str,position,position) if c == [[}]] then position = position + 1 return lua_object,position end --then json array including {key:value,key:value,key:value,...} --key --> string --value including --string --number --object --array --true,false,nil ---------------------------------------------------------------- local precount = -1 local curcount = 0 local json_len = string.len(json_str) while position <= json_len do position = skipBlank(json_str,position) c = string.sub(json_str,position,position) --key:value if c == [[}]] then --object over if precount >= curcount then --,is adjace to ] base.print "error that , is adjace to }" return nil,"error that , is adjace to }" end break elseif c == [[,]] then --next key:value or over position = position + 1 precount = precount + 1 if 0 == curcount then --,is the first,error base.print [[error that , in key:value is the first]] return nil,[[error that , in key:value is the first]] end if precount >= curcount then --,is more than one base.print [[error that , in key:value is more than one]] return nil,[[error that , in key:value is more than one]] end elseif c == [["]] then --begin key:value key,position = decodeString(json_str,position) --: position = skipBlank(json_str,position) c = string.sub(json_str,position,position) if c ~= [[:]] then base.print [[error,that object not key:value format]] return nil,[[error in decodeObject,format error]] else position = position + 1 end --begin value position = skipBlank(json_str,position) c = string.sub(json_str,position,position) if c == '[' then subarray,position = decodeArray(json_str,position) lua_object[key] = subarray elseif c == '{' then subobject,position = decodeObject(json_str,position) lua_object[key] = subobject elseif c == [["]] then str,position = decodeString(json_str,position) lua_object[key] = str elseif string.find([[+-0123456789.e]],c) then number,position = decodeNumber(json_str,position) lua_object[key] = number else othervalue,position = decodeOther(json_str,position) if othervalue then lua_object[key] = othervalue end end if not lua_object[key] then base.print [[error in json object key:value --> value,can't get value]] return nil,[[error in decodeObject value]] else curcount = curcount + 1 end --end value else base.print [[error json format]] return nil,[[error json format,in decodeObject end]] end end return lua_object,position + 1end 解析json array
json array的解析开始于 '[' 符号，结束于 ']' 符号，value值之间利用 ',' 隔开；
创建一个lua table，针对value值利用 t[#t+1] = value插入新的值，新的值根据符号调用相应的decode方法即可，
其中为了确保json语法错误被检测出来，利用计数的方法保证 ',' 语法的正确；
--decode from json array--begin with '['--params--[in] json_str : json string--[in] position : current position of the string--[out] lua table , the next of end the end position of the stringfunction decodeArray(json_str,position) local lua_array = {} local c = string.sub(json_str,position,position) --check case if c ~= [[[]] then base.print [[error that array not start with [ ]] return nil,[[error in decodeArray begin]] end position = position + 1 position = skipBlank(json_str,position) c = string.sub(json_str,position,position) if c == ']' then position = position + 1 return lua_array,position end --then json array including [value,value,value...] --value including --string --number --object --array --true,false,nil ------------------------------------------------------------------------- --about [,] or ["hello",] or [,"hello"] or ["hello",,"world"] check error --using pre count & cur count to find this local precount = -1 local curcount = 0 local json_len = string.len(json_str) while position <= json_len do position = skipBlank(json_str,position) c = string.sub(json_str,position,position) if c == '[' then subarray,position = decodeArray(json_str,position) lua_array[#lua_array+1] = subarray curcount = curcount + 1 elseif c == '{' then subobject,position = decodeObject(json_str,position) lua_array[#lua_array+1] = subobject curcount = curcount + 1 elseif c == [["]] then str,position = decodeString(json_str,position) lua_array[#lua_array+1] = str curcount = curcount + 1 elseif string.find([[+-0123456789.e]],c) then number,position = decodeNumber(json_str,position) lua_array[#lua_array+1] = number curcount = curcount + 1 elseif c == ']' then --there is some bugs,which is end with , if precount >= curcount then --,is adjace to ] base.print "error that , is adjace to ]" return nil,"error that , is adjace to ]" end break elseif c == ',' then --there is some bugs,which is begin with , position = position + 1 precount = precount + 1 if 0 == curcount then --,is the first,error base.print [[error that , is the first]] return nil,[[error that , is the first]] end if precount >= curcount then --,is more than one base.print [[error that , is more than one]] return nil,[[error that , is more than one]] end else othervalue,position = decodeOther(json_str,position) lua_array[#lua_array+1] = othervalue curcount = curcount + 1 end end if position > json_len then base.print 'error that array not end with ]' return nil,[[error in decodeArray end]] end c = string.sub(json_str,position,position) if c ~= ']' then base.print 'error that array not end with ]' return nil,[[error in decodeArray end]] end position = position + 1 return lua_array,positionend 解析json string
关于unicode的部分还未实现，还不是很了解这方面的知识；
关于string的解析仅仅是从第一个双引号开始，找到最后一个双引号且不是[[\"]]，及转义的双引号，然后截取两个双引号之间的内容，得到字符串即可；
--decode json string,include json key of key/value and the string value--begin with ' " '--params--[in] json_str : json string--[in] position : current position of the string--[out] lua string , the next of end the end position of the stringfunction M.decodeString(json_str,position) nowTime = os.time() local endposition = position + 1 local json_len = string.len(json_str) while endposition <= json_len and ( [["]] ~= string.sub(json_str,endposition,endposition) or [[\]] == string.sub(json_str,endposition - 1,endposition - 1) ) do endposition = endposition + 1 end local str = string.sub(json_str,position + 1,endposition - 1) --process str str = string.gsub(str,'\\u....',function (tstr) local a = string.sub(tstr,3,6) local n = tonumber(a,16) local x if n < 0x80 then x = string.char(n % 0x80) elseif n < 0x800 then -- [110x xxxx] [10xx xxxx] x = string.char(0xC0 + (math.floor(n/64) % 0x20), 0x80 + (n % 0x40)) else -- [1110 xxxx] [10xx xxxx] [10xx xxxx] x = string.char(0xE0 + (math.floor(n/4096) % 0x10), 0x80 + (math.floor(n/64) % 0x40), 0x80 + (n % 0x40)) end return x end ) str = string.gsub(str,'\\.',escapeSequences) return str,endposition + 1end
当然这其中有些转义字符的处理，均利用string.gsub函数，针对相应字符如果table中包含，则进行替换，相关table和函数如下。
local ecapses = { ['"'] = '\\"', ['\\'] = '\\\\', ['/'] = '\\/', ['\b'] = '\\b', ['\f'] = '\\f', ['\n'] = '\\n', ['\r'] = '\\r', ['\t'] = '\\t'}function encodeString(s) return string.gsub(s,'.',function(c) return ecapses[c] end)endlocal escapeSequences = { ["\\t"] = "\t", ["\\f"] = "\f", ["\\r"] = "\r", ["\\n"] = "\n", ["\\b"] = "\b"}setmetatable(escapeSequences, {__index = function(t,k) -- skip "\" aka strip escape return string.sub(k,2)end}) 解析json number
这里实现number的解析也比较偷懒，获取到连续的比较像number的字符串，利用lua提供的tonumber函数转换为number，失败返回nil
--decode json number--the valid number of json,include float,int and so on--[in] json_str : json string--[in] position : current position of the string--[out] lua number , the next of end the end position of the stringfunction decodeNumber(json_str,position) --string to number,lua have this function - tonumber local acceptCharacter = [[+-0123456789.e]] if not string.find(acceptCharacter,string.sub(json_str,position,position)) then base.print [[error that string not start with " ]] return nil,[[error in decodeNumber begin]] end --find the endposition local endposition = position local json_len = string.len(json_str) while endposition <= json_len and string.find(acceptCharacter,string.sub(json_str,endposition,endposition)) do endposition = endposition + 1 end local number = base.tonumber(string.sub(json_str,position,endposition - 1)) if not number then base.print [[error in number format]] return nil,[[error in decodeNumber end]] end return number,endpositionend
解析json的一些常量
关于json中的常量包含true，false和null，解析得到相应的值即可；
--decode other json value--include boolean value(true,false) or null--[in] json_str : json string--[in] position : current position of the string--[out] lua boolean or nil , the next of end the end position of the stringfunction decodeOther(json_str,position) --true,false,null, --three value -- "true" --> true -- "false"--> false -- "null" --> nil OtherString = {"true","false","null"} JsonLua = { ["true"] = true,["false"] = false,["null"] = nil } for i = 1,#OtherString do local str = OtherString[i] if string.sub(json_str,position,position + string.len(str) - 1) == str then return JsonLua[str],position + string.len(str) end end base.print [[error,invalid json other,not true,false,null]] return nil,[[error in decodeOther end]]end （2）lua内部对象转换json
这部分比较简单，也存在一种可能是我考虑的比较简单，目前感觉实现还是正确的，因为我在debug上面的时候实现了一个printLua函数，打印json转换为lua table的内部结构；
打印出的结构刚好比较类似json的结构，所以后面只需要针对这个函数进行修改，输出部分改为输出至string即可
关于printLua函数：
这个函数的一个辅助函数是判断lua中的table是否为数组形式，或者是键值对的形式；
--this function check lua_table is array or is an object--compare to json--if there exists one key/value in the lua_table,it's an object,otherwise,it's an array--[in] lua_table : table type in lua--[out] boolean and maxnumber of array : true indicate that the lua table is an array,false indicate that the lua table is an key/value tablefunction LuaArray(lua_table) --if lua_table is an array,it imply that all its key's type is number --if lua_table is an key/value table,imply that there exists string type in its keys --so just check all its key type local isarray = true local maxindex = 0 for k,_ in base.pairs(lua_table) do if base.type(k) ~= [[number]] then isarray = false break elseif base.type(k) == [[number]] and (math.floor(k) ~= k or k < 1) then isarray = false break else maxindex = math.max(maxindex,k) end end return isarray,maxindexend--for test lua Table--output lua table--format output tablefunction printLuaTable(luaT,space) local ss = string.rep([[ ]],space) local isarray,alen = LuaArray(luaT) if isarray then io.write(ss .. '[\n') for i = 1,alen do io.write(ss .. [[ ]]) if base.type(luaT[i]) == "boolean" then if luaT[i] then io.write('true\n') else io.write('false\n') end elseif base.type(luaT[i]) == "number" then io.write(luaT[i] .. '\n') elseif base.type(luaT[i]) == "string" then io.write(luaT[i] .. '\n') elseif base.type(luaT[i]) == "nil" then io.write('nil\n') else printLuaTable(luaT[i],space + 4) end end io.write(ss .. ']\n') else io.write(ss .. '{\n') for k,v in base.pairs(luaT) do local str = [[ ]] .. k .. ':' io.write(ss .. str) if base.type(v) == "boolean" then if v then io.write('true\n') else io.write('false\n') end elseif base.type(v) == "number" then io.write(v .. '\n') elseif base.type(v) == "string" then io.write(v .. '\n') else printLuaTable(v,space + 4) end end end io.write(ss .. '}\n')end 针对输出进行修改如下：
--[out] json stringfunction Unmarshal(lua_content) --like output lua_content --like printLuaTable --using table concat result = {} Unmarsha1Helper(lua_content,result) return table.concat(result)end--[in] lua_content:decode json to lua table--[in] result:table that convert to json string--like printLuaTable , all the element insert into resultfunction Unmarsha1Helper(lua_content,result) if base.type(lua_content) ~= "table" then base.print [[error that lua_content is not table]] return nil,[[error in Unmarsha1Helper end]] end local isarray,arraylen = LuaArray(lua_content) if isarray and arraylen >= 1 then --array result[#result+1] = '[' for i = 1,arraylen do if base.type(lua_content[i]) == "boolean" then if lua_content[i] then result[#result+1] = [[true]] else result[#result+1] = [[false]] end elseif base.type(lua_content[i]) == "number" then result[#result+1] = '' .. lua_content[i] elseif base.type(lua_content[i]) == "string" then result[#result+1] = [["]] .. lua_content[i] .. [["]] elseif base.type(lua_content[i]) == "nil" then result[#result+1] = "null" else Unmarsha1Helper(lua_content[i],result) end result[#result+1] = ',' end if result[#result] == ',' then result[#result] = nil end result[#result+1] = ']' else --object result[#result+1] = [[{]] for k,v in base.pairs(lua_content) do result[#result+1] = '"' .. k .. '"' .. ':' if base.type(v) == "boolean" then if v then result[#result+1] = [[true]] else result[#result+1] = [[false]] end elseif base.type(v) == "number" then result[#result+1] = '' .. v elseif base.type(v) == "string" then result[#result+1] = [["]] .. v .. [["]] elseif base.type(v) == "nil" then result[#result+1] = "null" else Unmarsha1Helper(v,result) end result[#result+1] = ',' end if result[#result] == ',' then result[#result] = nil end result[#result+1] = [[}]] endend
关于lua与json的解析与反解析的基本实现就完成了，本地可以调试通过，接下来就是细致功能的完成和程序健壮性的调整了。
五.编写程序的一些心得
程序的实现过程中也利用了SciTE进行了单步的调试，因为实现完毕之后出现了很多奇怪的问题，死循环，输出不符合语气。用起来感觉SciTE的调试功能还算可以，帮助完成了本地版功能的实现；
实现的过程中同样感受到浏览了一遍lua程序设计之后能够记住的东西实在太少，基本的循环结构可能都不记得，当这个程序完成之后还是需要lua的继续学习，这样应该才算够学习了这门语言吧。
六.unicode码知识
关于unicode与utf8的关系，这篇文章讲的非常的详细：http://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html
unicode只是一个符号集合，并没有规定具体的如何存储，所以如何存储还需要具体的方案，比如utf8，utf16等等。unicode与utf8的关系如下：
Unicode符号范围 | UTF-8编码方式
(十六进制) | （二进制）--------------------+---------------------------------------------0000 0000-0000 007F | 0xxxxxxx0000 0080-0000 07FF | 110xxxxx 10xxxxxx0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx所以这里只需要把json中的\uXXXX编码转换为utf8字节码即可。