源码介绍
Fastjson 是阿里巴巴开源的一个 Java 工具库，它常常被用来完成 Java 的对象与 JSON 格式的字符串的相互转化。
此文读的源码是撰写此文时 Fastjson 的最新的发布版本，即 1.2.83
下载源码
请前去 github 找到 release 最新版下载后解压，地址为：https://github.com/alibaba/fastjson/releases/tag/1.2.83
项目结构
使用 IDEA 打开 fastjson-1.2.83 文件夹，下载相关依赖后，我们再开始阅读源码，接下来我们分别对 JSON 、JSONArray 与 JSONObject。
JSON 实现两个接口
JSON 类是实现两个接口 JSONStreamAware 、JSONAware 的抽象类，即
public abstract class JSON implements JSONStreamAware, JSONAware
我们先介绍这两个接口：
JSONStreamAware
方法 writeJSONString 中的参数 Appendable 也是一个接口，也就是可以附加字符序列和值的对象，这个接口的作用是提供一个输出JSON字符串的方法，以便于其他的方法调用。
接着我们在 JSON 抽象类中寻找用到这个方法的地方，这里主要截图其中两个具体的实现方法，另外还有几个重载方法是通过调用这两个方法的方法，这里不再列举。
JSONAware
这个接口更加简单了，实现该接口的类即需要实现 toJSONString 的方法即可。
在JSON抽象类中，具体实现为：
这里调用的是 JSONSerializer 类的对象方法，这里我们在后面介绍这个类的时候进一步介绍。
这个相对于 writeJSONString 更加实用。比如重写 toString 方法。
JSON 类的静态方法
我们常常用到这些方法，并且我们在使用 JSONObject 类方法的时候也经常用得到（JSONObject是JSON类的子类）。这里我们介绍我们最最最常用的，并且在 JSONObject 中不再介绍。
JSON.toString / JSON.toJSONString
这个方法前面关于 JSONAware 接口的实现的时候有提到过，这里就不做介绍了。
这里我们看一下 toJSONString 方法的实现原理。源码比较简单，这里就不逐行介绍了。
方法参数介绍
- object: Object 待转换的 Java 对象；
- defaultFeatures: int 后面参数 SerializerFeature 的长度，因为后面是
SerializerFeature...类型的，所以调用时需要指定它的长度； - features: SerializerFeature… 这个地方是指多个 SerializerFeature 类型的对象，调用时可以
toJSONString(obj, 1, feature0)也可以toJSONString(obj, 2, feature0, feature1)，也可以toJSONString(obj, 3, feature0, feature1, feature2)等等。
/**
* @since 1.2.11
*/
public static String toJSONString(Object object, int defaultFeatures, SerializerFeature... features) {
SerializeWriter out = new SerializeWriter((Writer) null, defaultFeatures, features);
try {
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(object);
String outString = out.toString();
int len = outString.length();
if (len > 0
&& outString.charAt(len -1) == '.'
&& object instanceof Number
&& !out.isEnabled(SerializerFeature.WriteClassName)) {
return outString.substring(0, len - 1);
}
return outString;
} finally {
out.close();
}
}
源码中用到了 SerializeWriter 对象以及它的方法，这里我们理一下它的作用与用法。
SerializeWriter 构造函数为
public SerializeWriter(Writer writer, int defaultFeatures, SerializerFeature... features){
this.writer = writer;
buf = bufLocal.get();
if (buf != null) {
bufLocal.set(null);
} else {
buf = new char[2048];
}
int featuresValue = defaultFeatures;
for (SerializerFeature feature : features) {
featuresValue |= feature.getMask();
}
this.features = featuresValue;
computeFeatures();
}
在前面初始化JSONSerializer的时候调用SerializeWriter对象，即 JSONSerializer serializer = new JSONSerializer(out); 这个时候的使用方法是：
这里查看 JSONSerializer 对象的构造函数：
public JSONSerializer(SerializeWriter out){
this(out, SerializeConfig.getGlobalInstance());
}
public JSONSerializer(SerializeWriter out, SerializeConfig config){
this.out = out;
this.config = config;
}
其 write 方法源码为：
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);
}
}
JSONObject
相对而言 JSONObject 用得更多，这里需要介绍的也更多。
无参构造函数
其中 DEFAULT_INITIAL_CAPACITY 默认等于 16，也就是创建 HashMap 或者 LinkedHashMap 对象的时候默认的 initialCapacity 的值，而 order 参数将会指定创建的 map 对象的类型。
public JSONObject(){
this(DEFAULT_INITIAL_CAPACITY, false);
}
public JSONObject(int initialCapacity, boolean ordered){
if (ordered) {
map = new LinkedHashMap<String, Object>(initialCapacity);
} else {
map = new HashMap<String, Object>(initialCapacity);
}
}
public JSONObject(boolean ordered){
this(DEFAULT_INITIAL_CAPACITY, ordered);
}
public JSONObject(int initialCapacity){
this(initialCapacity, false);
}
有参构函数
public JSONObject(Map<String, Object> map){
if (map == null) {
throw new IllegalArgumentException("map is null.");
}
this.map = map;
}
这里相对于前面的无参构造函数而言，map 对象在外界创建与初始化，直接传入 JSONObject 中，作为构造函数。这样做使得我们在反序列化、序列化的方法更加灵活，这里我们在后面介绍。
containsKey / containsValue / get / isEmpty / size 方法
这几个方法都是直接调用 成员变量 map 得以实现的，具体实现代码如下：
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean containsKey(Object key) {
boolean result = map.containsKey(key);
if (!result) {
if (key instanceof Number
|| key instanceof Character
|| key instanceof Boolean
|| key instanceof UUID
) {
result = map.containsKey(key.toString());
}
}
return result;
}
public boolean containsValue(Object value) {
return map.containsValue(value);
}
public Object get(Object key) {
Object val = map.get(key);
if (val == null) {
if (key instanceof Number
|| key instanceof Character
|| key instanceof Boolean
|| key instanceof UUID
) {
val = map.get(key.toString());
}
}
return val;
}
public Object getOrDefault(Object key, Object defaultValue) {
Object v;
return ((v = get(key)) != null) ? v : defaultValue;
}
反序列化方法
首先出场的是最简单的，将 map 中的某个 key 进行反序列化，一般情况下我们会在 这个 key 对应的是 Object 的时候使用它。比如原始的map 是 {"age": 3, "item" : {"color": "black", "length" : 2}} ，我们在反序列化 item 的时候需要调用这个方法，即 getJSONObject("item") 。
public JSONObject getJSONObject(String key) {
Object value = map.get(key);
if (value instanceof JSONObject) {
return (JSONObject) value;
}
if (value instanceof Map) {
return new JSONObject((Map) value);
}
if (value instanceof String) {
return JSON.parseObject((String) value);
}
return (JSONObject) toJSON(value);
}
类似地如果是 JSON 数组的化，调用 getJSONArray 方法，这里举一个例子为 map 为 {"age": 3, items:[{"color": "red"}, {"color": "black"}]}，我们在反序列 items 的时候会调用这个方法。
public JSONArray getJSONArray(String key) {
Object value = map.get(key);
if (value instanceof JSONArray) {
return (JSONArray) value;
}
if (value instanceof List) {
return new JSONArray((List) value);
}
if (value instanceof String) {
return (JSONArray) JSON.parse((String) value);
}
return (JSONArray) toJSON(value);
}
如果不是前面两种，我们需要获取的只是简单的 item 对象，比如 age = 3，那么就调用 getObject 方法即可，注意这里有几个重载方法。
public <T> T getObject(String key, Class<T> clazz) {
Object obj = map.get(key);
return TypeUtils.castToJavaBean(obj, clazz);
}
public <T> T getObject(String key, Type type) {
Object obj = map.get(key);
return TypeUtils.cast(obj, type, ParserConfig.getGlobalInstance());
}
public <T> T getObject(String key, TypeReference typeReference) {
Object obj = map.get(key);
if (typeReference == null) {
return (T) obj;
}
return TypeUtils.cast(obj, typeReference.getType(), ParserConfig.getGlobalInstance());
}
这个时候我们不得不介绍一下 TypeUtils 类了，毕竟出场率这么高，这里只介绍 cast 与 castToJavaBean 两个静态方法。
private static BiFunction<Object, Class, Object> castFunction = new BiFunction<Object, Class, Object>() {
public Object apply(Object obj, Class clazz) {
if (clazz == java.sql.Date.class) {
return castToSqlDate(obj);
}
if (clazz == java.sql.Time.class) {
return castToSqlTime(obj);
}
if (clazz == java.sql.Timestamp.class) {
return castToTimestamp(obj);
}
return null;
}
};
这里实现了接口 BiFunction 的 apply 方法，实现方法也非常简单粗暴，三个 if 对应三个方法 castToSql / castToSqlTime / castToTimestamp 。
这个时候可能大家会疑惑，这个跟 sql 有什么关系？其实确实没什么关系，但是毕竟 java 提供的现有的可用方法，不用白不用，这里也给大家做个广告，这里面的 java.sql.Timestamp 与 java.sql.Time 以及 java.sql.Date 确实很好用，这里以 java.sql.Timestamp 为例，它提供13位时间戳的构造方法 public Timestamp(long time) 以及常用的 compareTo 、before 、after 方法，需要的小伙伴可以自取使用。
而 cast 方法 居然都有 @SuppressWarnings("unchecked") 标注，着实让人多少有点不放心，难道一定要去使用 Fastjson2 ？
这里我们查看其中一个方法的实现，看完了你大概就会产生一种 “就这？我上我也行” 的感觉：
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj, Type type, ParserConfig mapping) {
if (obj == null) {
return null;
}
if (type instanceof Class) {
return cast(obj, (Class<T>) type, mapping);
}
if (type instanceof ParameterizedType) {
return (T) cast(obj, (ParameterizedType) type, mapping);
}
if (obj instanceof String) {
String strVal = (String) obj;
if (strVal.length() == 0 //
|| "null".equals(strVal) //
|| "NULL".equals(strVal)) {
return null;
}
}
if (type instanceof TypeVariable) {
return (T) obj;
}
throw new JSONException("can not cast to : " + type);
}
事实也确实如此，充其量就是用了点反射技术，首先判断数据类型属于哪个小可爱的子类，然后再使用放射和传过来的 clazz 创建对象，而建立其中的映射关系的，就是其中的 mapping 参数对象，仅此而已。
JSON 与 JSONObject 的区别与联系
能够用 JSON 的地方，基本上都能用 JSONObject，不同之处在于一般直接 JSON 的静态方法，因为它是抽象类，不能直接 new 出对象的。而 JSONObject 名字中就强调了 Object 的概念，所以一般直接就用它的对象的方法。
灵活使用 JSONObject
总体来说最经常用到的就是 toString 与 toJSONObject 以及 JSONObject 对象的 getInteger / getLong / getJSONObject 等等方法，这些方法都应该基于 map 联想记忆，都是比较容易理解的。
总结
Fastjson 中存在很多地方都属于让人看了就 “恍然大悟” 之处，也推荐大家去阅读，同时不得不说，阿里巴巴能够有支团队开发并不断完善Fastjson，也是挺值得前去 github 点颗星星。
最后吐槽一下 Fastjson 的实现部分有明显的 “不遵守 《JAVA 规范手册》” 的，请以后的开发人员注意多多参考 Java开发手册（嵩山版） ，多写一些些注释，成为一本与 手册 配套的代码示例，也是非常不错的 ~ 此致，敬上 ~