fastjson学习及解析

fastjson 是一个性能极好的用 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。

主要特点：

快速FAST (比其它任何基于Java的解析器和生成器更快，包括jackson）

强大（支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum）

零依赖（没有依赖其它任何类库除了JDK）

一 、生成Json：
JavaBean、List<JavaBean>、List<String>、List<Map<String,Object>>

String jsonString = JSON.toJSONString(obj);

二、解析Json：
（1）JavaBean

Class class= JSON.parseObject(jsonString, Class.class);

（2）List<JavaBean>

List<Class> class=JSON.parseArray((jsonString, Class.class);

（3）List<String>

List<String> listString = JSON.parseArray(jsonString, String.class);

（4）List<Map<String,Object>>

List<Map<String, Object>> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map<String,Object>>>(){});

EXAMPLE

JavaBean

public class UserInfo {
private String name;
private int age;

public String getName() {
return name;
}

@Override
public String toString() {
return "UserInfo{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

序列化与反序列化

public final class MyTest {

public static void main(String[] args) {
//UserInfo的序列化
UserInfo info = new UserInfo("zhangsan", 24);
System.out.println(info);//此处使用的是javabean中的toString方法
String strJson = JSON.toJSONString(info);//将对象转换为JSON字符串
System.out.println("JSON=" + strJson);
//UserInfo的反序列化
UserInfo userInfo = JSON.parseObject(strJson, UserInfo.class);
System.out.println(info + "+name:" + userInfo.getName() + "+age:" + userInfo.getAge());//此处使用的是javabean中的toString方法

//List<UserInfo>序列化
List<UserInfo> userInfoList = new ArrayList<>();
UserInfo info1 = new UserInfo("lisi", 30);
userInfoList.add(info);
userInfoList.add(info1);
System.out.println(userInfoList);//此处使用的是javabean中的toString方法
String listStrJson = JSON.toJSONString(userInfoList);
System.out.println(listStrJson);
//List<UserInfo>反序列化
List<UserInfo> userInfoList1 = JSON.parseArray(listStrJson, UserInfo.class);
System.out.println(userInfoList1);//此处使用的是javabean中的toString方法

//List<Map<String, Object>>序列化
List<Map<String, Object>> list = new ArrayList<>();
Map<String,Object> map = new HashMap<String,Object>();
map.put("zhangsan", 24);
map.put("lisi", 30);
list.add(map);
System.out.println(list);
String listString=JSON.toJSONString(list);
System.out.println(listString);
//List<Map<String, Object>>反序列化
List<Map<String, Object>> list1=JSON.parseObject(listString,new TypeReference<List<Map<String,Object>>>(){});
System.out.println(list1);
}

}

输出为

UserInfo{name='zhangsan', age=24}
JSON={"age":24,"name":"zhangsan"}
UserInfo{name='zhangsan', age=24}+name:zhangsan+age:24
[UserInfo{name='zhangsan', age=24}, UserInfo{name='lisi', age=30}]
[{"age":24,"name":"zhangsan"},{"age":30,"name":"lisi"}]
[UserInfo{name='zhangsan', age=24}, UserInfo{name='lisi', age=30}]
[{lisi=30, zhangsan=24}]
[{"lisi":30,"zhangsan":24}]
[{lisi=30, zhangsan=24}]

fastjson的总体处理思想



fastjson总体处理思想.png

在这里，需要考虑的主要有两个部分，一是临时保存在序列化过程中用于储存数据的容器，二是处理对象序列化的序列化器。
在fastjson中，保存数据的容器使用了wirter，字符输出流，而且是自实现的一个字符输出流。相对原来的writer，追加了很多需要输出的信息的实现，比如输出一个字符串，输出一个字符，输出一个long类型数据等。而处理对象序列化的序列化器，而使用了责任链模式和工厂模式，将不同类型的java对象分散到不同的序列化器当中。而每个序列化器只处理与自身类型相对应的数据信息，这样就避免了在处理时，各种情况交织在一块，逻辑混乱的问题。

速度优化点：

全程使用buffer替换string字符串拼接操作，使用ThreadLocal进行回收重用

使用Integer,Long里的stringSize()计算数字类型的字符串长度

使用String,Long,Integer等的getChars()方法，直接输出数据到buf上，避免出现字符拼装

扩容一次性计算

javaBean的反序列化通过jsonSerializer缓存解析完成的method (使用多例，可以减少从map的查找过程)

identityHashMap使用

</div>