Content Table
2016-10-16

Fastjson 简单使用

Fastjson API 入口类是 com.alibaba.fastjson.JSON，常用的序列化操作都可以在 JSON 类上的静态方法直接完成。

Gradle 依赖

1
compile 'com.alibaba:fastjson:1.2.41'

主要 API

把对象转换为 JSON 字符串

1
2
public static String toJSONString(Object object) // 转为压缩格式的，去掉多余的空格，占用空间少
public static String toJSONString(Object object, boolean prettyFormat) // prettyFormat 为 true 转为格式化后的，可读性好

把 JSON 字符串转换为对象

1
2
public static <T> T parseObject(String text, Class<T> clazz);
public static <T> T parseObject(String text, TypeReference<T> type, Feature... features);

转为字符串时忽略某一个属性，使用 ignores

1
2
3
4
5
6
7
@JSONType(ignores = {"children"})
public static class Node {
    Long id;
    Long parentId;

    List<Node> children = new LinkedList<>();
}

前端 JS 不支持 Long，可以把 Long 转换为 String 后返回给前端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1. 在后台将这个Long类型的字段转换成String类型的，风险比较大
2. 使用 Fastjson 的提供的注解: 
   @JSONField(serializeUsing = ToStringSerializer.class)
   private Long id
3. 使用浏览器兼容模式，全局配置 BrowserCompatible 的 serializerFeatures，例如 SpringMVC 里
   <property name="fastJsonConfig">
       <bean class="com.alibaba.fastjson.support.config.FastJsonConfig">
           <property name="serializerFeatures">
               <list>
                   <value>BrowserCompatible</value> <!-- 解决 JS 不支持 Long 类型: Long 输出为字符串 -->
               </list>
           </property>
       </bean>
   </property>
   注意: 这种方式中文会转为 UTF-8 的编码，如 {"id":2,"info":"\u6D77\u9F99"}，不过浏览器里能自动识别
4. 自定义 FastJsonConfig，只把 Long 转为字符串，中文进行 UTF-8 编码，比方法 3 好一些，请参考 http://sparkgis.com/java/2018/02/springmvc使用fastjson并解决长数值精度丢失问题-原-springmvc使用fastjson并/

TypeReference

什么时候用 TypeReference 呢？使用 parseObject() 转换的结果使用范型时。

public class TypeReference extends Object

Represents a generic type T. Java doesn’t yet provide a way to represent generic types(例如 List<String>.class 是不存在的), so this class does. Forces clients to create a subclass of this class which enables retrieval the type information even at runtime.
For example, to create a type literal for List<String>, you can create an empty anonymous inner class:

    TypeReference<List<String>> list = new TypeReference<List<String>>() {};

This syntax cannot be used to create type literals that have wildcard parameters, such as Class<?> or List<? extends CharSequence>.

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

import java.util.LinkedList;
import java.util.List;

public class TestFastJson {
    public static void main(String[] args) {
        Box box = new Box("Foo");

        String json = JSON.toJSONString(box);
        System.out.println(json); // {"data":"Foo"}

        box = JSON.parseObject(json, Box.class);
        System.out.println(box); // Box{data=Foo}

        List<Box> list = new LinkedList<>();
        list.add(new Box("Alice"));
        list.add(new Box("John"));
        json = JSON.toJSONString(list);
        System.out.println(json); // [{"data":"Alice"},{"data":"John"}]

        list = JSON.parseObject(json, List.class);
        System.out.println(list); // [{"data":"Alice"}, {"data":"John"}]，可以看到，输出的不是 Box.toString() 输出的内容，说明 list 中存储的不是 Box
        // System.out.println(list.get(0).getClass()); // Error: ClassCastException: com.alibaba.fastjson.JSONObject cannot be cast to Box

        list = JSON.parseObject(json, new TypeReference<List<Box>>() {}); // 使用 parseObject() 转换的结果使用范型时使用 TypeReference
        System.out.println(list.get(0).getClass()); // class Box
        System.out.println(list); // [Box{data=Alice}, Box{data=John}]
    }
}

class Box {
    private String data;

    public Box() {

    }

    public Box(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return String.format("Box{data=%s}", data);
    }
}

常用 API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 把 JSON 文本 parse 为 JSONObject 或者 JSONArray 
public static final Object parse(String text); 

// 把 JSON 文本 parse 成 JSONObject  
public static final JSONObject parseObject(String text)；   

// 把 JSON 文本 parse 为 JavaBean
public static final <T> T parseObject(String text, Class<T> clazz); 

// 把 JSON 文本 parse 成 JSONArray 
public static final JSONArray parseArray(String text);  

// 把 JSON 文本 parse 成 JavaBean 集合 
public static final <T> List<T> parseArray(String text, Class<T> clazz); 

// 将 JavaBean 序列化为 JSON 文本 
public static final String toJSONString(Object object); 

// 将 JavaBean 序列化为带格式的 JSON 文本 
public static final String toJSONString(Object object, boolean prettyFormat);

// 将 JavaBean 转换为 JSONObject 或者 JSONArray
public static final Object toJSON(Object javaObject);

SerializeWriter: 相当于 StringBuffer
JSONArray: 相当于 List<Object>
JSONObject: 相当于 Map<String, Object>

参考资料