fastjson深度源码解析- 序列化(三) - 序列化字段属性键值对

转x33g5p2x  于2021-12-25 转载在 其他  
字(4.9k)|赞(0)|评价(0)|浏览(578)

SerializeWriter成员函数

序列化字段名称

  1. public void writeFieldName(String key, boolean checkSpecial) {
  2.         if (key == null) {
  3.             /** 如果字段key为null， 输出 "null:" */
  4.             write("null:");
  5.             return;
  6.         }
  8.         if (useSingleQuotes) {
  9.             if (quoteFieldNames) {
  10.                 /** 使用单引号并且在字段后面加'：'输出 标准的json key*/
  11.                 writeStringWithSingleQuote(key);
  12.                 write(':');
  13.             } else {
  14.                 /** 输出key，如果有特殊字符会自动添加单引号 */
  15.                 writeKeyWithSingleQuoteIfHasSpecial(key);
  16.             }
  17.         } else {
  18.             if (quoteFieldNames) {
  19.                 /** 使用双引号输出json key 并添加 ： */
  20.                 writeStringWithDoubleQuote(key, ':');
  21.             } else {
  22.                 boolean hashSpecial = key.length() == 0;
  23.                 for (int i = 0; i < key.length(); ++i) {
  24.                     char ch = key.charAt(i);
  25.                     boolean special = (ch < 64 && (sepcialBits & (1L << ch)) != 0) || ch == '\\';
  26.                     if (special) {
  27.                         hashSpecial = true;
  28.                         break;
  29.                     }
  30.                 }
  31.                 if (hashSpecial) {
  32.                     /** 如果包含特殊字符，会进行特殊字符转换输出，eg: 使用转换后的native编码输出 */
  33.                     writeStringWithDoubleQuote(key, ':');
  34.                 } else {
  35.                     /** 输出字段不加引号 */
  36.                     write(key);
  37.                     write(':');
  38.                 }
  39.             }
  40.         }
  41.     }

序列化字段名称方法writeFieldName主要的任务：

  1. 完成字段特殊字符的转译
  2. 添加字段的引号

处理输出key的特殊字符方法writeStringWithDoubleQuote前面已经分析过了，序列化字段名称是否需要添加引号和特殊字符处理参考writeKeyWithSingleQuoteIfHasSpecial：

  1. private void writeKeyWithSingleQuoteIfHasSpecial(String text) {
  2.         final byte[] specicalFlags_singleQuotes = IOUtils.specicalFlags_singleQuotes;
  4.         int len = text.length();
  5.         int newcount = count + len + 1;
  6.         if (newcount > buf.length) {
  7.             if (writer != null) {
  8.                 if (len == 0) {
  9.                     /** 如果字段为null， 输出空白字符('':)作为key */
  10.                     write('\'');
  11.                     write('\'');
  12.                     write(':');
  13.                     return;
  14.                 }
  16.                 boolean hasSpecial = false;
  17.                 for (int i = 0; i < len; ++i) {
  18.                     char ch = text.charAt(i);
  19.                     if (ch < specicalFlags_singleQuotes.length && specicalFlags_singleQuotes[ch] != 0) {
  20.                         hasSpecial = true;
  21.                         break;
  22.                     }
  23.                 }
  25.                 /** 如果有特殊字符，给字段key添加单引号 */
  26.                 if (hasSpecial) {
  27.                     write('\'');
  28.                 }
  29.                 for (int i = 0; i < len; ++i) {
  30.                     char ch = text.charAt(i);
  31.                     if (ch < specicalFlags_singleQuotes.length && specicalFlags_singleQuotes[ch] != 0) {
  32.                         /** 如果输出key中包含特殊字符，添加转译字符并将特殊字符替换成普通字符 */
  33.                         write('\\');
  34.                         write(replaceChars[(int) ch]);
  35.                     } else {
  36.                         write(ch);
  37.                     }
  38.                 }
  40.                 /** 如果有特殊字符，给字段key添加单引号 */
  41.                 if (hasSpecial) {
  42.                     write('\'');
  43.                 }
  44.                 write(':');
  45.                 return;
  46.             }
  47.             /** 输出器writer为null触发扩容，扩容到为原有buf容量1.5倍+1, copy原有buf的字符*/
  48.             expandCapacity(newcount);
  49.         }
  51.         if (len == 0) {
  52.             int newCount = count + 3;
  53.             if (newCount > buf.length) {
  54.                 expandCapacity(count + 3);
  55.             }
  56.             buf[count++] = '\'';
  57.             buf[count++] = '\'';
  58.             buf[count++] = ':';
  59.             return;
  60.         }
  62.         int start = count;
  63.         int end = start + len;
  65.         /** buffer能够容纳字符串，直接拷贝text到buf缓冲数组 */
  66.         text.getChars(0, len, buf, start);
  67.         count = newcount;
  69.         boolean hasSpecial = false;
  71.         for (int i = start; i < end; ++i) {
  72.             char ch = buf[i];
  73.             if (ch < specicalFlags_singleQuotes.length && specicalFlags_singleQuotes[ch] != 0) {
  74.                 if (!hasSpecial) {
  75.                     newcount += 3;
  76.                     if (newcount > buf.length) {
  77.                         expandCapacity(newcount);
  78.                     }
  79.                     count = newcount;
  81.                     /** 将字符后移两位，插入字符'\ 并替换特殊字符为普通字符 */
  82.                     System.arraycopy(buf, i + 1, buf, i + 3, end - i - 1);
  83.                     /** 将字符后移一位 */
  84.                     System.arraycopy(buf, 0, buf, 1, i);
  85.                     buf[start] = '\'';
  86.                     buf[++i] = '\\';
  87.                     buf[++i] = replaceChars[(int) ch];
  88.                     end += 2;
  89.                     buf[count - 2] = '\'';
  91.                     hasSpecial = true;
  92.                 } else {
  93.                     newcount++;
  94.                     if (newcount > buf.length) {
  95.                         expandCapacity(newcount);
  96.                     }
  97.                     count = newcount;
  99.                     /** 包含特殊字符，将字符后移一位，插入转译字符\ 并替换特殊字符为普通字符 */
  100.                     System.arraycopy(buf, i + 1, buf, i + 2, end - i);
  101.                     buf[i] = '\\';
  102.                     buf[++i] = replaceChars[(int) ch];
  103.                     end++;
  104.                 }
  105.             }
  106.         }
  108.         buf[newcount - 1] = ':';
  109.     }

序列化Boolean类型字段键值对

  1. public void writeFieldValue(char seperator, String name, boolean value) {
  2.         if (!quoteFieldNames) {
  3.             /** 如果不需要输出双引号，则一次输出字段分隔符，字段名字，字段值 */
  4.             write(seperator);
  5.             writeFieldName(name);
  6.             write(value);
  7.             return;
  8.         }
  9.         /** true 占用4位， false 占用5位 */
  10.         int intSize = value ? 4 : 5;
  12.         int nameLen = name.length();
  13.         /** 输出总长度， 中间的4 代表 key 和 value 总共占用4个引号 */
  14.         int newcount = count + nameLen + 4 + intSize;
  15.         if (newcount > buf.length) {
  16.             if (writer != null) {
  17.                 /** 依次输出字段分隔符，字段：字段值 */
  18.                 write(seperator);
  19.                 writeString(name);
  20.                 write(':');
  21.                 write(value);
  22.                 return;
  23.             }
  24.             /** 输出器writer为null触发扩容，扩容到为原有buf容量1.5倍+1, copy原有buf的字符*/
  25.             expandCapacity(newcount);
  26.         }
  28.         int start = count;
  29.         count = newcount;
  31.         /** 输出字段分隔符，一般是, */
  32.         buf[start] = seperator;
  34.         int nameEnd = start + nameLen + 1;
  36.         /** 输出字段属性分隔符，一般是单引号或双引号 */
  37.         buf[start + 1] = keySeperator;
  39.         /** 输出字段名称 */
  40.         name.getChars(0, nameLen, buf, start + 2);
  42.         /** 字段名称添加分隔符，一般是单引号或双引号 */
  43.         buf[nameEnd + 1] = keySeperator;
  45.         /** 输出boolean类型字符串值 */
  46.         if (value) {
  47.             System.arraycopy(":true".toCharArray(), 0, buf, nameEnd + 2, 5);
  48.         } else {
  49.             System.arraycopy(":false".toCharArray(), 0, buf, nameEnd + 2, 6);
  50.         }
  51.     }

序列化boolean类型的键值对属性，因为不涉及特殊字符，主要就是把原型序列化为字面量值。

序列化Int类型字段键值对

  1. public void writeFieldValue(char seperator, String name, int value) {
  2.         if (value == Integer.MIN_VALUE || !quoteFieldNames) {
  3.             /** 如果是整数最小值或不需要输出双引号，则一次输出字段分隔符，字段名字，字段值 */
  4.             write(seperator);
  5.             writeFieldName(name);
  6.             writeInt(value);
  7.             return;
  8.         }
  10.         /** 根据数字判断占用的位数，负数会多一位用于存储字符`-` */
  11.         int intSize = (value < 0) ? IOUtils.stringSize(-value) + 1 : IOUtils.stringSize(value);
  13.         int nameLen = name.length();
  14.         int newcount = count + nameLen + 4 + intSize;
  15.         if (newcount > buf.length) {
  16.             if (writer != null) {
  17.                 write(seperator);
  18.                 writeFieldName(name);
  19.                 writeInt(value);
  20.                 return;
  21.             }
  22.             /** 扩容到为原有buf容量1.5倍+1, copy原有buf的字符*/
  23.             expandCapacity(newcount);
  24.         }
  26.         int start = count;
  27.         count = newcount;
  29.         /** 输出字段分隔符，一般是, */
  30.         buf[start] = seperator;
  32.         int nameEnd = start + nameLen + 1;
  34.         /** 输出字段属性分隔符，一般是单引号或双引号 */
  35.         buf[start + 1] = keySeperator;
  37.         /** 输出字段名称 */
  38.         name.getChars(0, nameLen, buf, start + 2);
  40.         buf[nameEnd + 1] = keySeperator;
  41.         buf[nameEnd + 2] = ':';
  43.         /** 输出整数值，对整数转化成单字符 */
  44.         IOUtils.getChars(value, count, buf);
  45.     }

序列化int类型的键值对属性，因为不涉及特殊字符，主要就是把原型序列化为字面量值。截止到现在，已经把核心SerializWriter类讲完了，剩余字段键值对极其类似writeFieldValue boolean和int等，因此无需冗余分析。因为序列化真正开始之前，这个类极其基础并且非常重要，因此花的时间较多。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/shangzonghai/article/details/79253254

内容来源于网络，如有侵权，请联系作者删除！

Javafastjson源码解析

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com