Fastjson 1.2.83 序列化与反序列化源码机制解析

String json = JSON.toJSONString(object);

User user = JSON.parseObject(json, User.class);

com.alibaba.fastjson/
├── JSON.java                         # 核心入口类
├── JSONObject.java                   # JSON 对象结构，基于 Map
├── JSONArray.java                    # JSON 数组结构，基于 List
├── annotation/                       # 注解定义
│   ├── JSONField.java
│   └── JSONType.java
├── asm/                              # 精简 ASM 字节码工具
├── parser/                           # 反序列化模块
│   ├── DefaultJSONParser.java        # 默认 JSON 解析调度器
│   ├── JSONLexer.java                # 词法分析器接口
│   ├── JSONLexerBase.java            # 词法分析器基础实现
│   ├── JSONScanner.java              # 基于字符串的扫描器
│   └── deserializer/                 # 反序列化器
├── serializer/                       # 序列化模块
│   ├── JSONSerializer.java           # 序列化调度器
│   ├── SerializeConfig.java          # 序列化配置与缓存
│   ├── SerializeWriter.java          # 高性能 JSON 字符串写入器
│   ├── ObjectSerializer.java         # 序列化器接口
│   └── JavaBeanSerializer.java       # JavaBean 序列化器
├── spi/                              # SPI 扩展机制
├── support/                          # 框架适配支持
└── util/                             # 工具类

Person person = new Person();
person.setName("Alice");
person.setAge(18);

String json = JSON.toJSONString(person);

public static String toJSONString(Object object,
                                  SerializeConfig config,
                                  SerializeFilter[] filters,
                                  String dateFormat,
                                  int defaultFeatures,
                                  SerializerFeature... features) {
    SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);

    try {
        JSONSerializer serializer = new JSONSerializer(out, config);

        if (dateFormat != null) {
            serializer.setDateFormat(dateFormat);
        }

        if (filters != null) {
            for (SerializeFilter filter : filters) {
                serializer.addFilter(filter);
            }
        }

        serializer.write(object);
        return out.toString();
    } finally {
        out.close();
    }
}

public final void write(Object object) {
    if (object == null) {
        out.writeNull();
        return;
    }

    Class<?> clazz = object.getClass();
    ObjectSerializer writer = getObjectWriter(clazz);

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

protected void write(JSONSerializer serializer,
                     Object object,
                     Object fieldName,
                     Type fieldType,
                     int features,
                     boolean unwrapped) throws IOException {
    SerializeWriter out = serializer.out;

    if (object == null) {
        out.writeNull();
        return;
    }

    if (writeReference(serializer, object, features)) {
        return;
    }

    FieldSerializer[] fieldSerializers =
            out.sortField ? sortedGetters : getters;

    SerialContext parent = serializer.context;
    serializer.setContext(parent, object, fieldName, beanInfo.features, features);

    try {
        out.write('{');

        for (int i = 0; i < fieldSerializers.length; i++) {
            FieldSerializer fieldSerializer = fieldSerializers[i];

            Object value = fieldSerializer.getPropertyValue(object);
            Object processed = processValue(
                    serializer,
                    fieldSerializer.fieldContext,
                    object,
                    fieldSerializer.fieldInfo.name,
                    value,
                    features
            );

            fieldSerializer.writePrefix(serializer);
            fieldSerializer.writeValue(serializer, processed);
        }

        out.write('}');
    } finally {
        serializer.context = parent;
    }
}

class Node {
    public String name;
    public Node next;
}

Node a = new Node();
Node b = new Node();
a.name = "a";
b.name = "b";
a.next = b;
b.next = a;

a -> b -> a -> b -> a -> ...

protected IdentityHashMap<Object, SerialContext> references;
protected SerialContext context;

public void setContext(SerialContext parent,
                       Object object,
                       Object fieldName,
                       int features,
                       int fieldFeatures) {
    if (out.disableCircularReferenceDetect) {
        return;
    }

    this.context = new SerialContext(parent, object, fieldName, features, fieldFeatures);

    if (references == null) {
        references = new IdentityHashMap<Object, SerialContext>();
    }

    references.put(object, context);
}

public boolean writeReference(JSONSerializer serializer, Object object, int fieldFeatures) {
    SerialContext context = serializer.context;

    int mask = SerializerFeature.DisableCircularReferenceDetect.mask;

    if (context == null || (context.features & mask) != 0 || (fieldFeatures & mask) != 0) {
        return false;
    }

    if (serializer.references != null && serializer.references.containsKey(object)) {
        serializer.writeReference(object);
        return true;
    }

    return false;
}

{
  "name": "a",
  "next": {
    "name": "b",
    "next": {
      "$ref": ".."
    }
  }
}

public void writeValue(JSONSerializer serializer, Object propertyValue) throws Exception {
    Class<?> runtimeFieldClass =
            propertyValue != null ? propertyValue.getClass() : fieldInfo.fieldClass;

    ObjectSerializer fieldSerializer =
            serializer.getObjectWriter(runtimeFieldClass);

    if (format != null && !(fieldSerializer instanceof DoubleSerializer)) {
        serializer.writeWithFormat(propertyValue, format);
        return;
    }

    fieldSerializer.write(
            serializer,
            propertyValue,
            fieldInfo.name,
            fieldInfo.fieldType,
            fieldFeatures
    );
}

private Animal animal;

new Dog()

private static final ThreadLocal<char[]> bufLocal = new ThreadLocal<char[]>();
private static final ThreadLocal<byte[]> bytesBufLocal = new ThreadLocal<byte[]>();

String text = "{\"name\":\"Alice\",\"age\":18}";
Person person = JSON.parseObject(text, Person.class);

public static <T> T parseObject(String text, Class<T> clazz, int features) {
    if (text == null) {
        return null;
    }

    DefaultJSONParser parser = new DefaultJSONParser(
            text,
            ParserConfig.getGlobalInstance(),
            features
    );

    try {
        T value = parser.parseObject(clazz);
        parser.handleResovleTask(value);
        return value;
    } finally {
        parser.close();
    }
}

public ObjectDeserializer getDeserializer(Type type) {
    ObjectDeserializer deserializer = deserializers.get(type);

    if (deserializer != null) {
        return deserializer;
    }

    if (type instanceof Class<?>) {
        return getDeserializer((Class<?>) type, type);
    }

    if (type instanceof ParameterizedType) {
        Type rawType = ((ParameterizedType) type).getRawType();

        if (rawType instanceof Class<?>) {
            return getDeserializer((Class<?>) rawType, type);
        }

        return getDeserializer(rawType);
    }

    return JavaObjectDeserializer.instance;
}

List<Order> orders = JSON.parseObject(
        json,
        new TypeReference<List<Order>>() {}
);

public int scanFieldInt(char[] fieldName) {
    matchStat = UNKNOWN;

    if (!charArrayCompare(fieldName)) {
        matchStat = NOT_MATCH_NAME;
        return 0;
    }

    int offset = fieldName.length;
    char ch = charAt(bp + offset++);

    boolean negative = ch == '-';
    if (negative) {
        ch = charAt(bp + offset++);
    }

    int value = 0;

    if (ch < '0' || ch > '9') {
        matchStat = NOT_MATCH;
        return 0;
    }

    while (ch >= '0' && ch <= '9') {
        value = value * 10 + (ch - '0');
        ch = charAt(bp + offset++);
    }

    if (value < 0) {
        matchStat = NOT_MATCH;
        return 0;
    }

    if (ch == ',') {
        bp += offset;
        token = JSONToken.COMMA;
        matchStat = VALUE;
        return negative ? -value : value;
    }

    if (ch == '}') {
        // 根据后续字符设置 RBRACE、RBRACKET、EOF 等 token
        matchStat = END;
        return negative ? -value : value;
    }

    matchStat = NOT_MATCH;
    return 0;
}

for (int fieldIndex = 0, notMatchCount = 0; ; fieldIndex++) {
    FieldDeserializer fieldDeserializer = null;
    FieldInfo fieldInfo = null;

    if (fieldIndex < sortedFieldDeserializers.length && notMatchCount < 16) {
        fieldDeserializer = sortedFieldDeserializers[fieldIndex];
        fieldInfo = fieldDeserializer.fieldInfo;
    }

    boolean matchField = false;
    Object fieldValue = null;

    if (fieldDeserializer != null) {
        char[] nameChars = fieldInfo.name_chars;
        Class<?> fieldClass = fieldInfo.fieldClass;

        if (fieldClass == int.class || fieldClass == Integer.class) {
            int intValue = lexer.scanFieldInt(nameChars);

            if (lexer.matchStat > 0) {
                fieldValue = intValue;
                matchField = true;
            } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
                notMatchCount++;
                continue;
            }
        }

        // long、boolean、String 等类型也有类似快速路径
    }

    if (!matchField) {
        String key = lexer.scanSymbol(parser.symbolTable);
        // 动态字段名匹配、$ref、@type 都在这里处理
    }
}

protected Object createInstance(DefaultJSONParser parser, Type type) {
    Class<?> clazz = (Class<?>) type;

    if (clazz.isInterface()) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        JSONObject backing = new JSONObject();

        return Proxy.newProxyInstance(
                loader,
                new Class<?>[] { clazz },
                backing
        );
    }

    if (beanInfo.defaultConstructor == null && beanInfo.factoryMethod == null) {
        return null;
    }

    try {
        Constructor<?> constructor = beanInfo.defaultConstructor;

        if (constructor.getParameterCount() == 0) {
            return constructor.newInstance();
        }

        ParseContext context = parser.getContext();

        if (context == null || context.object == null) {
            throw new JSONException("can't create non-static inner class instance.");
        }

        return constructor.newInstance(context.object);
    } catch (Exception e) {
        throw new JSONException("create instance error, class " + clazz.getName(), e);
    }
}

public void setValue(Object object, Object value) {
    if (value == null && fieldInfo.fieldClass.isPrimitive()) {
        return;
    }

    if (fieldInfo.fieldClass == String.class
            && "trim".equals(fieldInfo.format)) {
        value = ((String) value).trim();
    }

    try {
        Method method = fieldInfo.method;

        if (method != null) {
            if (fieldInfo.getOnly) {
                Object current = method.invoke(object);

                if (current instanceof AtomicInteger) {
                    ((AtomicInteger) current).set(((AtomicInteger) value).get());
                } else if (current instanceof Map) {
                    ((Map) current).putAll((Map) value);
                } else if (current instanceof Collection) {
                    Collection collection = (Collection) current;
                    collection.clear();
                    collection.addAll((Collection) value);
                }
            } else {
                method.invoke(object, value);
            }
        } else if (fieldInfo.field != null) {
            fieldInfo.field.set(object, value);
        }
    } catch (Exception e) {
        throw new JSONException("set property error, " + fieldInfo.name, e);
    }
}

Object value = getterMethod.invoke(object);
field.set(object, value);

String name = object.getName();
out.writeFieldValue(',', "name", name);

interface Animal {
}

class Dog implements Animal {
    private String name;
    private double weight;

    public Dog() {
    }

    public Dog(String name, double weight) {
        this.name = name;
        this.weight = weight;
    }

    // getter / setter
}

class PetStore {
    private Animal animal;

    // getter / setter
}

Animal dog = new Dog("dodi", 12);
PetStore store = new PetStore();
store.setAnimal(dog);

String json = JSON.toJSONString(store);
System.out.println(json);

{
  "animal": {
    "name": "dodi",
    "weight": 12.0
  }
}

String json = JSON.toJSONString(
        store,
        SerializerFeature.WriteClassName
);

{
  "@type": "com.example.PetStore",
  "animal": {
    "@type": "com.example.Dog",
    "name": "dodi",
    "weight": 12.0
  }
}

ParserConfig.getGlobalInstance().addAccept("com.example.");

PetStore restored = JSON.parseObject(json, PetStore.class);
Dog parsedDog = (Dog) restored.getAnimal();

ParserConfig.getGlobalInstance().setSafeMode(true);

ParserConfig.getGlobalInstance().setAutoTypeSupport(true);

try (JSONReader reader = new JSONReader(
        new InputStreamReader(
                new FileInputStream("huge-array.json"),
                StandardCharsets.UTF_8
        ))) {

    reader.startArray();

    while (reader.hasNext()) {
        Order order = reader.readObject(Order.class);

        processOrder(order);
        orderRepository.save(order);

        // 当前 order 处理完后即可等待 GC 回收
    }

    reader.endArray();
}

[
  {"orderId": "1001", "amount": 99.5},
  {"orderId": "1002", "amount": 18.0},
  {"orderId": "1003", "amount": 42.8}
]

String json = JSON.toJSONString(
        user,
        SerializerFeature.WriteMapNullValue
);

class User {
    @JSONField(name = "user_name")
    private String userName;

    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    private Date createdAt;

    @JSONField(serialize = false)
    private String password;

    // getter / setter
}

class PetStore {
    private Animal animal;
}

class Page<T> {
    private List<T> records;
}

List<Order> orders = JSON.parseObject(
        json,
        new TypeReference<List<Order>>() {}
);

JSONObject obj = JSON.parseObject(json);
String type = obj.getString("animalType");

Animal animal;
if ("dog".equals(type)) {
    animal = obj.getObject("animal", Dog.class);
} else if ("cat".equals(type)) {
    animal = obj.getObject("animal", Cat.class);
} else {
    throw new IllegalArgumentException("unsupported animal type: " + type);
}

String json = JSON.toJSONString(
        object,
        SerializerFeature.DisableCircularReferenceDetect
);