Alibaba 的fastjson源码详解

一、概述
Fastjson 是阿里巴巴开源的一个 Java 工具库，它常常被用来完成 Java 的对象与 JSON 格式的字符串的相互转化。
Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。

二、源码分析
1.首先以fastjson-1.2.70为例，用IDEA打开看下项目结构，如下：

2.涉及Java 的对象与 JSON 格式的字符串的相互转化，首先的分析JSON这个抽象类。
（1）这个类有很多的方法，如下图：

上述只是部分方法。

JSON类实现了2个接口，JSONStreamAware 、JSONAware。

JSONStreamAware ：
其中writeJSONString方法 中的参数 Appendable 也是一个接口，也就是可以附加字符序列和值的对象，这个接口的作用是提供一个输出JSON字符串的方法，以便于其他的方法调用。

public interface JSONStreamAware {
    void writeJSONString(Appendable var1) throws IOException;
}

1
2
3
4

实现类：

   public void writeJSONString(Appendable appendable) {
        SerializeWriter out = new SerializeWriter();

        try {
            (new JSONSerializer(out)).write(this);
            appendable.append(out.toString());
        } catch (IOException var7) {
            throw new JSONException(var7.getMessage(), var7);
        } finally {
            out.close();
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13

JSONAware：
这个接口只需要实现该接口的类实现toJSONString 的方法。

package com.alibaba.fastjson;

public interface JSONAware {
    String toJSONString();
}

1
2
3
4
5
6

具体实现：

    public String toJSONString() {
        SerializeWriter out = new SerializeWriter();

        String var2;
        try {
            (new JSONSerializer(out)).write(this);
            var2 = out.toString();
        } finally {
            out.close();
        }

        return var2;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

（2）JSON类中的方法。
JSON类重载大概有四类方法，分别为：

• parse方法、parseObject方法、parseArray方法；返回结果分别为Object、JSONObject、JSONArray。
• toJSONString方法，返回JSON字符串；toJSONBytes方法，返回byte数组
• writeJSONString方法，将JSON写进write流
• toJavaObject方法，将JSON对象转为java实体对象。

这个类中的四类方法是调用各个包中的方法。

这里主要说明我们经常使用的转换，parseObject 和 toJSONString，分别为转换为对象和JSON字符串。

第一个方法toJSONString，这个将java对象转换为JSON字符串：

String jsonStr = JSON.toJSONString(obj);

1
2

第一个方法parseObject ，这个将JSON字符串转换为java对象：

MyObject vo = JSON.parseObject(jsonStr, MyObject.class);

1
2

如果是返回对象是泛型，则可以这样转化。

import com.alibaba.fastjson.TypeReference;
List<MyObject> list = JSON.parseObject(jsonStr, new TypeReference<List<MyObject>>() {});

1
2
3

通过源码可以知道，JSONObject和JSONArray继承JSON。
JSONObject：

public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
    private static final long serialVersionUID = 1L;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    private final Map<String, Object> map;

    public JSONObject() {
        this(16, false);
    }

    public JSONObject(Map<String, Object> map) {
        if (map == null) {
            throw new IllegalArgumentException("map is null.");
        } else {
            this.map = map;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

通过该类的继承与实现关系，可以发现，JSONObject实现了Map接口，而json对象中的数据都是以"键值对"形式出现，可以猜想， JSONObject底层操作是由Map实现的。

JSONArray：

public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {
    private static final long serialVersionUID = 1L;
    private final List<Object> list;
    protected transient Object relatedArray;
    protected transient Type componentType;

    public JSONArray() {
        this.list = new ArrayList();
    }

    public JSONArray(List<Object> list) {
        if (list == null) {
            throw new IllegalArgumentException("list is null.");
        } else {
            this.list = list;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

根据JSONArray的继承与实现，并结合上面对JSONObject的分析，可以发现，其内部是由List接口中的方法来完成操作的。

接着来看下JSON中的toJSONString()方法，它实现json对象转化为json字符串和java对象转化为json 字符串。

public static String toJSONString(Object object) {
        return toJSONString(object, emptyFilters);
    }

    public static String toJSONString(Object object, SerializerFeature... features) {
        return toJSONString(object, DEFAULT_GENERATE_FEATURE, features);
    }

    public static String toJSONString(Object object, int defaultFeatures, SerializerFeature... features) {
        SerializeWriter out = new SerializeWriter((Writer)null, defaultFeatures, features);

        String var5;
        try {
            JSONSerializer serializer = new JSONSerializer(out);
            serializer.write(object);
            var5 = out.toString();
        } finally {
            out.close();
        }

        return var5;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

该方法经过多次重载，但最终都是实现json对象转化为json字符串和java对象转化为json 字符串。

再来看下JSON类中的parseObject()方法，实现json字符串转换为json对象或javabean对象。

 public static JSONObject parseObject(String text, Feature... features) {
        return (JSONObject)parse(text, features);
    }

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

该方法返回JSONObject对象，用于实现json字符串向json对象的转化，其内部调用了parse()方法，调用底层的DefaultJSONParser解析类进行转化，在转化失败时，抛出异常。

最后就是JSON类中的JSONArray()方法，实现json字符串转化为json对象数组或List。

 public static JSONArray parseArray(String text) {
        if (text == null) {
            return null;
        } else {
            DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance());
            JSONLexer lexer = parser.lexer;
            JSONArray array;
            if (lexer.token() == 8) {
                lexer.nextToken();
                array = null;
            } else if (lexer.token() == 20) {
                array = null;
            } else {
                array = new JSONArray();
                parser.parseArray(array);
                parser.handleResovleTask(array);
            }

            parser.close();
            return array;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这个与parseObject()方法类似。

（3）我们可以通过main方法测试下：

public static void main(String[] args) {
        Map<String,Object> map = new HashMap<>();
        map.put("name","张三");
        map.put("age",20);

        System.out.println("----javaBean  to jsonString-------");
        String str1= JSON.toJSONString(map);
        System.out.println("str1:"+str1);

        System.out.println("-----jsonString to javaBean------");
        //Map map1=JSON.parseObject(str1,new TypeReference<Map>(){});
        Map map1=JSON.parseObject(str1,Map.class);
        System.out.println(map1);
        System.out.println("map1:"+map1);

        List<Map<String,Object>> list = new ArrayList<>();
        list.add(map);
        System.out.println("-----jsonString to jsonArray-----");
        List<Map> list1=JSON.parseArray(JSON.toJSONString(list),Map.class);

        System.out.println("list1:"+list1);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

打印结果如下：