本文完成于2021.1.14，首发于独立博客空间

一、概述

Json是fastjson软件包使用的入口、代码的主类，能获得一个可操作的JsonObject对象；其分别实现了JSONSteamAware接口和JSONAware接口

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图1

二、提供对外API

1.toJSONString(object)

该方法要求对象必须为泛型(Generic type)，与之相对的writeJSONString(Writer, Object, SerializerFeature[])方法，就可以使用非泛型的对象，两者的目标都是将制定对象转换为特定格式的JSON形式的字符串

其实现了13个重载方法：

  1. public static String toJSONString(Object object)
  2.  public static String toJSONString(Object object, SerializerFeature... features) 
  3.  public static String toJSONString(Object object, int defaultFeatures, SerializerFeature... features) 
  4.  public static String toJSONStringWithDateFormat(Object object, String dateFormat,SerializerFeature... features) 
  5.  public static String toJSONString(Object object, SerializeFilter filter, SerializerFeature... features)
  6.  public static String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features)
  7.   public static String toJSONString(Object object, SerializeConfig config, SerializerFeature... features)
  8.   public static String toJSONString(Object object, SerializeConfig config,SerializeFilter filter,SerializerFeature... features) 
  9.   public static String toJSONString(Object object, SerializeConfig config, SerializeFilter[] filters, SerializerFeature... features)
  10.  public static String toJSONString(Object object,SerializeConfig config,SerializeFilter[] filters, String dateFormat,int defaultFeatures, SerializerFeature... features) 
  11.   public static String toJSONStringZ(Object object, SerializeConfig mapping, SerializerFeature... features)
  12.   public static String toJSONString(Object object, boolean prettyFormat) 
  13.   public String toJSONString()

在简单使用中，我们只传入一个任意类型的对象时，代码如下：

Coder.java

  1. public class Coder {
  2.     private String name;
  3.     private int hairs;
  4.     private String health;
  5.     ....
  6.     }

测试方法

  1.     public void testToJsonStringObject(){
  2.         Coder coder = new Coder();
  3.         coder.setName("张三");
  4.         coder.setHairs(100);
  5.         coder.setHealth("快死了");
  7.         String jsonString = JSON.toJSONString(coder);
  8.         System.out.println(jsonString);
  9.     }

首先进入JSON的toJSONString(coder)方法：

  1.     public static String toJSONString(Object object) {
  2.         return toJSONString(object, emptyFilters);
  3.     }

这个返回调用toJSONString(object, emptyFilters)：

运行后发现指向

  1.     public static String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features) {
  2.         return toJSONString(object, SerializeConfig.globalInstance, filters, null, DEFAULT_GENERATE_FEATURE, features);
  3.     }

再次跟进，进入：

  1.     public static String toJSONString(Object object, // 
  2.                                       SerializeConfig config, // 
  3.                                       SerializeFilter[] filters, // 
  4.                                       String dateFormat, //
  5.                                       int defaultFeatures, // 
  6.                                       SerializerFeature... features)

此时变量情况如下：

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图2

仔细观察当前进入方法逻辑：

首先是创建了一个SerializeWriter对象

  1. SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);

SerializeWriter类的作用是对输入对象进行序列化操作，在此处是用来提前构建一个缓冲区，用于之后的解析操作。

因为在该类中有一个静态代码块，首次执行时，会设定一个缓存区域的大小

  1.     static {
  2.         try {
  3.             String prop = IOUtils.getStringProperty("fastjson.serializer_buffer_threshold");
  4.             if (prop != null && prop.length() > 0) {
  5.                 int serializer_buffer_threshold = Integer.parseInt(prop);
  6.                 if (serializer_buffer_threshold >= 64 && serializer_buffer_threshold <= 1024 * 64) {
  7.                     BUFFER_THRESHOLD = serializer_buffer_threshold * 1024;
  8.                 }
  9.             }
  10.         } catch (Throwable error) {
  11.             // skip
  12.         }
  13.     }

存储当前设定值的缓冲区域的值为BUFFER_THRESHO

此时就多了一个SeriallzeWriter类型的out对象了

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图3

再次往下运行代码，进入异常处理区域

  1.         try {
  2.             JSONSerializer serializer = new JSONSerializer(out, config);
  4.             if (dateFormat != null && dateFormat.length() != 0) {
  5.                 serializer.setDateFormat(dateFormat);
  6.                 serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
  7.             }
  9.             if (filters != null) {
  10.                 for (SerializeFilter filter : filters) {
  11.                     serializer.addFilter(filter);
  12.                 }
  13.             }
  15.             serializer.write(object);
  17.             return out.toString();
  18.         } finally {
  19.             out.close();
  20.         }

这里首先是新建了一个JSONSerializer对象，将刚才新建的SeriallzeWriter类型的out对象，以及SerializeConfig类型的config对象，作为参数传入

  1. JSONSerializer serializer = new JSONSerializer(out, config);

通过JSONSerializer类的构造方法，赋值给当前对象的指定对象中

  1.     public JSONSerializer(SerializeWriter out, SerializeConfig config){
  2.         this.out = out;
  3.         this.config = config;
  4.     }

这个类是对JSON解析的序列化，除了要根据规则

还要对时区和语言进行一个初始化设置

  1. // 时区  本质上使用的是java.util.TimeZone,TimeZone使用的也是sun.util.calendar.ZoneInfo
  2. protected TimeZone                               timeZone    = JSON.defaultTimeZone;
  4. // 语言
  5. protected Locale                                 locale      = JSON.defaultLocale;

执行完这一步，将结果返回到变量中

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图4

因为此处dataformat为空，所以直接跳过下面代码

  1.             if (dateFormat != null && dateFormat.length() != 0) {
  2.                 serializer.setDateFormat(dateFormat);
  3.                 serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
  4.             }

执行

  1.  if (filters != null) {
  2.                 for (SerializeFilter filter : filters) {
  3.                     serializer.addFilter(filter);
  4.                 }
  5.             }

所有前置准备都执行完毕后，现在将我们输入的对象写进JSONSerializer类型的变量serializer中

  1. serializer.write(object);

下面为JSONSerializer.write方法

  1.  public final void write(Object object) {
  2.         if (object == null) {
  3.             out.writeNull();
  4.             return;
  5.         }
  7.         Class<?> clazz = object.getClass();
  8.         ObjectSerializer writer = getObjectWriter(clazz);
  10.         try {
  11.             writer.write(this, object, null, null, 0);
  12.         } catch (IOException e) {
  13.             throw new JSONException(e.getMessage(), e);
  14.         }
  15.     }

此处，在对传入对象进行一个判空操作以后，使用getClass()方法获得object运行时额类

  1.  Class<?> clazz = object.getClass();

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图5

此处是利用到了Java的反射，所谓反射，可以理解为在运行Java代码时获取对象类型信息的操作，即动态获取对象运行类型信息。

然后将获取到的类型，获取到制定的序列化方法，一个ObjectSerializer类型的对象，此处为writer

  1. public ObjectSerializer getObjectWriter(Class<?> clazz) {
  2.     return config.getObjectWriter(clazz);
  3. }

然后就是写入

  1. writer.write(this, object, null, null, 0);
  2. } catch (IOException e) {
  3.     throw new JSONException(e.getMessage(), e);

还记得刚才利用SerializeWriter分配的缓存空间吗，刚才在JSONSerializer类中进行的写入操作的数据，其实都放在缓存空间中

所以，最后一步的操作就是讲缓存空间中的数据转换为字符类型，并返回

  1. return out.toString();

至此，一个对象解析为JSON格式的字符串的整个流程我们就走完了。

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图6

2.parseObject(String,Class)

变成JSON的格式的字符串还是字符串，不是一个JSON对象，所以这里我们还需要使用parseObject方法来将上面个我们得到的字符串转换为JSON对象

在测试代码中加上：

  1.         JSONObject jsonObject = JSON.parseObject(jsonString);

以下是JSON.parseObject()方法的源码

  1.     public static JSONObject parseObject(String text) {
  2.         Object obj = parse(text);
  3.         if (obj instanceof JSONObject) {
  4.             return (JSONObject) obj;
  5.         }
  7.         try {
  8.             return (JSONObject) JSON.toJSON(obj);
  9.         } catch (RuntimeException e) {
  10.             throw new JSONException("can not cast to JSONObject.", e);
  11.         }
  12.     }

在正式进行转换之前，FastJson还需要按照内置规范对字符串进行解析

  1.     public static Object parse(String text) {
  2.         return parse(text, DEFAULT_PARSER_FEATURE);
  3.     }
  1.     public static Object parse(String text, int features) {
  2.         return parse(text, ParserConfig.getGlobalInstance(), features);
  3.     }
  1.    public static Object parse(String text, ParserConfig config, int features) {
  2.         if (text == null) {
  3.             return null;
  4.         }
  6.         DefaultJSONParser parser = new DefaultJSONParser(text, config, features);
  7.         Object value = parser.parse();
  9.         parser.handleResovleTask(value);
  11.         parser.close();
  13.         return value;
  14.     }

连着进了三个方法，终于来到了正题

此时的变量如下：

[FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图7

将传入的三个值作为参数，新建一个DefaultJSONParser类型的对象，构建一个默认的 解析器

  1. DefaultJSONParser parser = new DefaultJSONParser(text, config, features);

这里主要是进行了一个字节码格式的添加，斗胆猜测是为了提高解析的速度，故先内置一些常用的数据类型

  1.       private final static Set<Class<?>> primitiveClasses   = new HashSet<Class<?>>();
  2.     static {
  3.         Class<?>[] classes = new Class[] {
  4.                 boolean.class,
  5.                 byte.class,
  6.                 short.class,
  7.                 int.class,
  8.                 long.class,
  9.                 float.class,
  10.                 double.class,
  12.                 Boolean.class,
  13.                 Byte.class,
  14.                 Short.class,
  15.                 Integer.class,
  16.                 Long.class,
  17.                 Float.class,
  18.                 Double.class,
  20.                 BigInteger.class,
  21.                 BigDecimal.class,
  22.                 String.class
  23.         };
  25.         primitiveClasses.addAll(Arrays.asList(classes));
  26.     }

于是我们就有了一个默认的解析器

[FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图8

使用其parse方法对 传入的对象进行解析

  1. Object value = parser.parse();

这个解析方法源码如下：

  1.     public Object parse(Object fieldName) {
  2.         final JSONLexer lexer = this.lexer;
  3.         switch (lexer.token()) {
  4.             case SET:
  5.                 lexer.nextToken();
  6.                 HashSet<Object> set = new HashSet<Object>();
  7.                 parseArray(set, fieldName);
  8.                 return set;
  9.             case TREE_SET:
  10.                 lexer.nextToken();
  11.                 TreeSet<Object> treeSet = new TreeSet<Object>();
  12.                 parseArray(treeSet, fieldName);
  13.                 return treeSet;
  14.             case LBRACKET:
  15.                 JSONArray array = new JSONArray();
  16.                 parseArray(array, fieldName);
  17.                 if (lexer.isEnabled(Feature.UseObjectArray)) {
  18.                     return array.toArray();
  19.                 }
  20.                 return array;
  21.             case LBRACE:
  22.                 JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
  23.                 return parseObject(object, fieldName);
  24. //            case LBRACE: {
  25. //                Map<String, Object> map = lexer.isEnabled(Feature.OrderedField)
  26. //                        ? new LinkedHashMap<String, Object>()
  27. //                        : new HashMap<String, Object>();
  28. //                Object obj = parseObject(map, fieldName);
  29. //                if (obj != map) {
  30. //                    return obj;
  31. //                }
  32. //                return new JSONObject(map);
  33. //            }
  34.             case LITERAL_INT:
  35.                 Number intValue = lexer.integerValue();
  36.                 lexer.nextToken();
  37.                 return intValue;
  38.             case LITERAL_FLOAT:
  39.                 Object value = lexer.decimalValue(lexer.isEnabled(Feature.UseBigDecimal));
  40.                 lexer.nextToken();
  41.                 return value;
  42.             case LITERAL_STRING:
  43.                 String stringLiteral = lexer.stringVal();
  44.                 lexer.nextToken(JSONToken.COMMA);
  46.                 if (lexer.isEnabled(Feature.AllowISO8601DateFormat)) {
  47.                     JSONScanner iso8601Lexer = new JSONScanner(stringLiteral);
  48.                     try {
  49.                         if (iso8601Lexer.scanISO8601DateIfMatch()) {
  50.                             return iso8601Lexer.getCalendar().getTime();
  51.                         }
  52.                     } finally {
  53.                         iso8601Lexer.close();
  54.                     }
  55.                 }
  57.                 return stringLiteral;
  58.             case NULL:
  59.                 lexer.nextToken();
  60.                 return null;
  61.             case UNDEFINED:
  62.                 lexer.nextToken();
  63.                 return null;
  64.             case TRUE:
  65.                 lexer.nextToken();
  66.                 return Boolean.TRUE;
  67.             case FALSE:
  68.                 lexer.nextToken();
  69.                 return Boolean.FALSE;
  70.             case NEW:
  71.                 lexer.nextToken(JSONToken.IDENTIFIER);
  73.                 if (lexer.token() != JSONToken.IDENTIFIER) {
  74.                     throw new JSONException("syntax error");
  75.                 }
  76.                 lexer.nextToken(JSONToken.LPAREN);
  78.                 accept(JSONToken.LPAREN);
  79.                 long time = lexer.integerValue().longValue();
  80.                 accept(JSONToken.LITERAL_INT);
  82.                 accept(JSONToken.RPAREN);
  84.                 return new Date(time);
  85.             case EOF:
  86.                 if (lexer.isBlankInput()) {
  87.                     return null;
  88.                 }
  89.                 throw new JSONException("unterminated json string, " + lexer.info());
  90.             case HEX:
  91.                 byte[] bytes = lexer.bytesValue();
  92.                 lexer.nextToken();
  93.                 return bytes;
  94.             case IDENTIFIER:
  95.                 String identifier = lexer.stringVal();
  96.                 if ("NaN".equals(identifier)) {
  97.                     lexer.nextToken();
  98.                     return null;
  99.                 }
  100.                 throw new JSONException("syntax error, " + lexer.info());
  101.             case ERROR:
  102.             default:
  103.                 throw new JSONException("syntax error, " + lexer.info());
  104.         }
  105.     }

内容过于变态，吓得我跳了出去

经过解析后的数据如下：

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图9

然后就是jsonObject格式的转换了

  1. parser.handleResovleTask(value);

底层代码依旧变态

  1.     public void handleResovleTask(Object value) {
  2.         if (resolveTaskList == null) {
  3.             return;
  4.         }
  6.         for (int i = 0, size = resolveTaskList.size(); i < size; ++i) {
  7.             ResolveTask task = resolveTaskList.get(i);
  8.             String ref = task.referenceValue;
  10.             Object object = null;
  11.             if (task.ownerContext != null) {
  12.                 object = task.ownerContext.object;
  13.             }
  15.             Object refValue;
  17.             if (ref.startsWith("$")) {
  18.                 refValue = getObject(ref);
  19.                 if (refValue == null) {
  20.                     try {
  21.                         JSONPath jsonpath = JSONPath.compile(ref);
  22.                         if (jsonpath.isRef()) {
  23.                             refValue = jsonpath.eval(value);
  24.                         }
  25.                     } catch (JSONPathException ex) {
  26.                         // skip
  27.                     }
  28.                 }
  29.             } else {
  30.                 refValue = task.context.object;
  31.             }
  33.             FieldDeserializer fieldDeser = task.fieldDeserializer;
  35.             if (fieldDeser != null) {
  36.                 if (refValue != null
  37.                         && refValue.getClass() == JSONObject.class
  38.                         && fieldDeser.fieldInfo != null
  39.                         && !Map.class.isAssignableFrom(fieldDeser.fieldInfo.fieldClass)) {
  40.                     Object root = this.contextArray[0].object;
  41.                     JSONPath jsonpath = JSONPath.compile(ref);
  42.                     if (jsonpath.isRef()) {
  43.                         refValue = jsonpath.eval(root);
  44.                     }
  45.                 }
  47.                 // workaround for bug
  48.                 if (fieldDeser.getOwnerClass() != null
  49.                         && (!fieldDeser.getOwnerClass().isInstance(object))
  50.                         && task.ownerContext.parent != null
  51.                 ) {
  52.                     for (ParseContext ctx = task.ownerContext.parent;ctx != null;ctx = ctx.parent) {
  53.                         if (fieldDeser.getOwnerClass().isInstance(ctx.object)) {
  54.                             object = ctx.object;
  55.                             break;
  56.                         }
  57.                     }
  58.                 }
  60.                 fieldDeser.setValue(object, refValue);
  61.             }
  62.         }
  63.     }

不过我们可以依稀看见是在利用数据组装JSON了（哈哈

最后，我们终于获取到了想要的JSON数据

FastJson源码阅读笔记：推开FastJson的大门-JSON.java - 图10