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对象分散到不同的序列化器当中。而每个序列化器只处理与自身类型相对应的数据信息，这样就避免了在处理时，各种情况交织在一块，逻辑混乱的问题。

速度优化点：

1. 全程使用buffer替换string字符串拼接操作，使用ThreadLocal进行回收重用
2. 使用Integer,Long里的stringSize()计算数字类型的字符串长度
3. 使用String,Long,Integer等的getChars()方法，直接输出数据到buf上，避免出现字符拼装
4. 扩容一次性计算
5. javaBean的反序列化通过jsonSerializer缓存解析完成的method (使用多例，可以减少从map的查找过程)
6. identityHashMap使用