Android FastJson解析流程原理与源码深度剖析

一、FastJson解析流程概述

FastJson作为高性能JSON解析库，其解析流程融合了编译原理中的词法分析、语法分析等经典技术，通过逐层处理将JSON字符串转换为Java对象。整个解析过程可分为词法分析（Lexical Analysis）、语法分析（Syntax Analysis）、**语义分析（Semantic Analysis）和对象构建（Object Construction）**四个核心阶段。每个阶段分工明确，通过数据结构与算法的协同工作，实现高效的解析能力。在Android环境下，这种解析流程的优化对于移动设备的资源利用和响应速度至关重要。

二、词法分析：JSON字符串的基础拆解

1. 词法单元定义

词法分析阶段的核心任务是将连续的JSON字符流拆解为独立的词法单元（Token）。FastJson定义了多种Token类型，如：

• T_NULL：表示null值
• T_TRUE、T_FALSE：布尔值
• T_NUMBER：数字类型
• T_STRING：字符串类型
• T_LEFT_BRACE、T_RIGHT_BRACE：对象括号
• T_LEFT_BRACKET、T_RIGHT_BRACKET：数组括号
• T_COLON：键值对分隔符
• T_COMMA：元素分隔符

这些Token构成了JSON数据的基础语义单元，后续的语法分析将基于这些单元进行结构识别。

2. 源码实现解析

FastJson通过JSONReader类实现词法分析，其核心方法scanSymbol用于扫描单个Token：

// JSONReader.java
private int scanSymbol(int c) {
    // 跳过空白字符
    while (Character.isWhitespace(c)) {
        c = next();
    }
    // 处理不同Token类型
    switch (c) {
        case '"': return scanString(c); // 扫描字符串
        case '[': return T_LEFT_BRACKET; // 左方括号
        case ']': return T_RIGHT_BRACKET; // 右方括号
        case '{': return T_LEFT_BRACE; // 左大括号
        case '}': return T_RIGHT_BRACE; // 右大括号
        case ',': return T_COMMA; // 逗号
        case ':': return T_COLON; // 冒号
        case 'n': 
            if (scanSymbol("null", 4)) { // 识别null
                return T_NULL;
            }
            break;
        case 't':
            if (scanSymbol("true", 4)) { // 识别true
                return T_TRUE;
            }
            break;
        case 'f':
            if (scanSymbol("false", 5)) { // 识别false
                return T_FALSE;
            }
            break;
        case '-': case '0': case '1': case '2': case '3':
        case '4': case '5': case '6': case '7': case '8': case '9':
            return scanNumber(c); // 扫描数字
    }
    throw new JSONException("syntax error"); // 非法字符抛出异常
}

上述代码通过字符扫描与匹配，将JSON字符串逐个解析为对应Token。例如，扫描到"时调用scanString方法处理字符串，扫描到数字字符时调用scanNumber方法解析数值。

3. 状态机优化

FastJson的词法分析采用**有限状态自动机（FSA）**思想，通过状态转移实现高效的Token识别。例如，在解析字符串时，会经历起始状态→字符读取状态→转义字符处理状态→结束状态，每个状态根据输入字符决定下一步操作，避免复杂的正则表达式匹配，提升解析性能。

三、语法分析：构建JSON数据结构

1. 上下文无关文法（CFG）定义

语法分析阶段基于JSON的上下文无关文法规则，将词法单元组合为结构化数据。JSON的核心文法规则可简化为：

JSON ::= Object | Array
Object ::= "{" [MemberList] "}"
MemberList ::= Member ("," Member)*
Member ::= String ":" Value
Array ::= "[" [ValueList] "]"
ValueList ::= Value ("," Value)*
Value ::= String | Number | Object | Array | true | false | null

FastJson通过递归下降分析法（Recursive Descent Parsing）实现上述规则，通过函数递归调用解析嵌套结构。

2. 递归下降解析实现

在JSONReader类中，parseObject和parseArray方法分别处理对象和数组解析：

// 解析JSON对象
private Object parseObject() {
    JSONObject object = new JSONObject();
    expect(T_LEFT_BRACE); // 期望左大括号
    if (more()) {
        do {
            String key = parseString(); // 解析键
            expect(T_COLON); // 期望冒号
            Object value = parseValue(); // 解析值
            object.put(key, value); // 添加键值对
        } while (more() && peek() == T_COMMA); // 处理多个键值对
    }
    expect(T_RIGHT_BRACE); // 期望右大括号
    return object;
}

// 解析JSON数组
private Object parseArray() {
    JSONArray array = new JSONArray();
    expect(T_LEFT_BRACKET); // 期望左方括号
    if (more()) {
        do {
            Object value = parseValue(); // 解析元素
            array.add(value); // 添加元素
        } while (more() && peek() == T_COMMA); // 处理多个元素
    }
    expect(T_RIGHT_BRACKET); // 期望右方括号
    return array;
}

上述代码通过递归调用parseValue方法，实现对嵌套对象和数组的解析。例如，当遇到{时调用parseObject，遇到[时调用parseArray，形成层级化解析逻辑。

3. 错误处理机制

语法分析过程中，FastJson通过expect方法验证Token类型是否符合预期：

private void expect(int token) {
    if (token != peek()) {
        throw new JSONException("syntax error, expect " + tokenStr(token) + ", actual " + tokenStr(peek()));
    }
    next(); // 消耗当前Token
}

若检测到不匹配的Token（如缺少分隔符、括号不闭合），则立即抛出JSONException，并附带详细的错误位置和类型信息。

四、语义分析：类型映射与对象构建

1. Java类型映射规则

语义分析阶段将JSON数据类型映射为Java对象类型，FastJson的映射规则如下：

JSON类型	Java类型
string	String
number	BigDecimal（默认）、int、long等
true/false	Boolean
null	null
object	自定义Java类或JSONObject
array	集合类型或JSONArray

2. 反射机制与对象实例化

FastJson通过Java反射机制构建对象实例。在反序列化自定义类时，会优先查找无参构造函数创建实例，再通过字段赋值或setter方法填充属性：

// 通过反射创建对象实例
private <T> T createJavaBean(Class<T> clazz) {
    try {
        Constructor<T> constructor = clazz.getConstructor();
        return constructor.newInstance();
    } catch (Exception e) {
        throw new JSONException("create java bean error", e);
    }
}

// 填充对象属性
private void fillBean(Object bean, JSONObject json) {
    Field[] fields = bean.getClass().getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        String fieldName = field.getName();
        if (json.containsKey(fieldName)) {
            Object value = json.get(fieldName);
            try {
                field.set(bean, value);
            } catch (IllegalAccessException e) {
                throw new JSONException("set field error", e);
            }
        }
    }
}

上述代码先创建对象实例，再遍历JSON对象的键值对，将对应属性值通过反射设置到Java对象中。

3. 泛型与多态处理

FastJson通过类型参数和TypeReference支持泛型解析。对于多态类型，可通过@JSONType注解指定具体实现类，确保反序列化时创建正确的对象实例：

// 使用TypeReference解析泛型
List<MyData> dataList = JSON.parseObject(json, new TypeReference<List<MyData>>() {});

// @JSONType注解指定多态类型
@JSONType(deserializer = MySubClassDeserializer.class)
interface MyInterface {}

五、缓存机制：提升解析性能

1. 类元数据缓存

FastJson通过JavaBeanInfo类缓存Java类的元数据信息，避免重复反射操作：

// JavaBeanInfo.java
public class JavaBeanInfo {
    private static final Map<Class<?>, JavaBeanInfo> BEAN_INFO_MAP = new ConcurrentHashMap<>();
    private Field[] fields;
    private Constructor<?> constructor;

    private JavaBeanInfo(Class<?> clazz) {
        fields = clazz.getDeclaredFields();
        try {
            constructor = clazz.getConstructor();
        } catch (Exception e) {
            // 处理构造函数获取失败
        }
    }

    public static JavaBeanInfo getBeanInfo(Class<?> clazz) {
        return BEAN_INFO_MAP.computeIfAbsent(clazz, JavaBeanInfo::new);
    }
}

在反序列化时，通过JavaBeanInfo.getBeanInfo获取类信息，直接使用缓存的字段和构造函数，减少反射开销。

2. 反序列化器缓存

FastJson维护了一个反序列化器注册表ParserConfig，根据类型缓存对应的反序列化器：

// ParserConfig.java
public class ParserConfig {
    private final Map<Type, ObjectDeserializer<?>> deserializers = new HashMap<>();

    public <T> ObjectDeserializer<T> getDeserializer(Type type) {
        return (ObjectDeserializer<T>) deserializers.get(type);
    }

    public <T> void putDeserializer(Type type, ObjectDeserializer<T> deserializer) {
        deserializers.put(type, deserializer);
    }
}

例如，解析String类型时直接使用缓存的StringDeserializer，无需每次动态查找反序列化逻辑。

3. 字符串池优化

在词法分析阶段，FastJson通过字符串池（String Pool）复用字符串对象，减少内存分配。对于重复出现的JSON键名，仅创建一次字符串实例，提升内存使用效率。

六、异常处理与容错机制

1. 异常类型体系

FastJson定义了以JSONException为基类的异常体系：

• JSONException：通用解析异常
• JSONSyntaxException：语法错误异常
• JSONIOException：输入输出异常
• JSONTypeException：类型转换异常

2. 异常抛出与捕获

在解析流程中，FastJson通过throw语句即时抛出异常。例如在词法分析发现非法字符时：

private int scanNumber(int c) {
    // 数字解析逻辑...
    if (!isNumber(c) && c != '.' && c != 'e' && c != 'E' && c != '-' && c != '+') {
        throw new JSONException("syntax error"); // 非法数字字符
    }
    // 继续解析...
}

调用方通过try-catch块捕获异常，并可根据异常类型进行针对性处理：

try {
    Object obj = JSON.parse(json);
} catch (JSONSyntaxException e) {
    // 处理语法错误
} catch (JSONTypeException e) {
    // 处理类型转换错误
}

3. 容错模式与数据恢复

FastJson支持通过配置开启容错模式（Feature.AllowUnQuotedFieldNames等），在遇到格式偏差时尝试继续解析。例如，允许未加引号的字段名，通过宽松的解析策略提升对非标准JSON的兼容性。

七、Android平台适配优化

1. 内存管理优化

• 对象复用：在Android内存受限环境下，FastJson通过对象池复用JSONReader、JSONWriter等核心对象，减少频繁创建带来的GC压力。
• 数据结构优化：JSONArray基于ArrayList实现，通过动态扩容策略避免内存浪费；JSONObject采用哈希表存储，保证属性访问效率。

2. 多线程支持

虽然FastJson的核心类（如JSON、JSONArray）并非线程安全，但通过ConcurrentHashMap等线程安全数据结构管理缓存，确保多线程环境下元数据访问的一致性。开发者在Android多线程场景下使用时，需额外注意对共享数据的同步控制。

3. 与网络框架集成

在Android网络请求场景中，FastJson常与OkHttp、Retrofit结合使用。例如，通过自定义Converter将网络响应的JSON数据直接解析为Java对象：

// Retrofit配置FastJson转换器
Retrofit retrofit = new Retrofit.Builder()
       .baseUrl("https://api.example.com")
       .addConverterFactory(FastJsonConverterFactory.create())
       .build();

八、扩展与定制机制

1. 自定义反序列化器

开发者可通过实现ObjectDeserializer接口定制反序列化逻辑：

// 自定义反序列化器
public class CustomDeserializer implements ObjectDeserializer {
    @Override
    public <T> T deserialze(JSONReader reader, Type type, Object fieldName) {
        // 自定义解析逻辑
        String json = reader.readString();
        return (T) convert(json); 
    }

    @Override
    public int getFastMatchToken() {
        return JSONToken.LITERAL_STRING; // 匹配字符串Token
    }
}

// 注册自定义反序列化器
ParserConfig.getGlobalInstance().putDeserializer(MyType.class, new CustomDeserializer());

2. 序列化特性配置

通过SerializerFeature枚举类，可调整序列化行为：

// 启用格式化输出
String json = JSON.toJSONString(data, SerializerFeature.PrettyFormat);
// 禁用循环引用检测
json = JSON.toJSONString(data, SerializerFeature.DisableCircularReferenceDetect);

3. 插件机制

FastJson支持通过ParserConfig的扩展方法注册自定义插件，实现对特殊类型或解析逻辑的支持，例如自定义日期格式解析、加密数据处理等。

九、性能优化策略

1. 字节流处理

FastJson避免频繁的字符串创建，采用SerializeWriter基于字符数组操作，通过write方法直接写入字符，减少字符串拼接开销：

// SerializeWriter.java
private char[] buffer;
private int pos;

public void write(char c) {
    if (pos >= buffer.length) {
        expandCapacity(); // 动态扩容
    }
    buffer[pos++] = c;
}

2. 避免装箱拆箱

在处理基本数据类型时，FastJson直接操作原始类型（如int、long），避免自动装箱为包装类（如Integer、Long）带来的性能损耗。

3. 预编译优化

通过JSON.DEFFAULT_DATE_FORMAT等配置项，FastJson可在初始化阶段预编译日期格式、正则表达式等资源，避免运行时重复解析。

十、安全性考量与应对

1. 反序列化漏洞原理

早期版本的FastJson存在反序列化漏洞，恶意用户可构造包含危险类（如java.lang.Runtime）的JSON数据，利用自动类型识别执行任意代码。漏洞根源在于未对反序列化的类进行严格限制。

2. 安全修复方案

• 黑名单机制：通过ParserConfig.getGlobalInstance().setAutoTypeSupport(false)禁用自动类型识别，仅允许白名单内的类被反序列化。
• 升级版本：使用修复漏洞的高版本FastJson（如1.2.68+），新版本增加了更严格的类型校验和安全策略。

3. 安全实践建议

在Android应用中使用FastJson时，需遵循以下原则：

• 仅反序列化可信来源的JSON数据
• 禁止在生产环境启用自动类型识别
• 定期更新FastJson至安全版本
• 结合其他安全措施（如数据签名验证）