Fastjson full support databind, it‘s simple to use.

Encode

import com.alibaba.fastjson.JSON;

Group group = new Group();
group.setId(0L);
group.setName("admin");

User guestUser = new User();
guestUser.setId(2L);
guestUser.setName("guest");

User rootUser = new User();
rootUser.setId(3L);
rootUser.setName("root");

group.addUser(guestUser);
group.addUser(rootUser);

String jsonString = JSON.toJSONString(group);

System.out.println(jsonString);

Output

{"id":0,"name":"admin","users":[{"id":2,"name":"guest"},{"id":3,"name":"root"}]}

Decode

String jsonString = ...;
Group group = JSON.parseObject(jsonString, Group.class);

Group.java

public class Group {

    private Long       id;
    private String     name;
    private List<User> users = new ArrayList<User>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

        public void addUser(User user) {
            users.add(user);
        }
}

User.java

public class User {

    private Long   id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

https://github.com/alibaba/fastjson/wiki/Samples-DataBind

       上周帮同事看一个问题，是想构造一个万能的query对象，这个对象里面包含一个泛型的对象，在spring mvc的controller层想通过RequestBody直接进行转换，spring mvc的代码如下：

Java代码  

1. @RequestMapping("/testBind")  
2.     @ResponseBody  
3.     public String testBind(@RequestBody MgQueryCondition<TestBean> queryCondition){  
4.         System.out.println(queryCondition);  
5.           
6.         return "success";  
7.     }  

Java代码  

1. import java.io.Serializable;  
2.   
3. public class TestBean implements Serializable{  
4.     private Integer id;  
5.   
6.     public Integer getId() {  
7.         return id;  
8.     }  
9.   
10.     public void setId(Integer id) {  
11.         this.id = id;  
12.     }  
13.   
14.     @Override  
15.     public String toString() {  
16.         return "TestBean [id=" + id + "]";  
17.     }  
18. }  

Java代码  

1. import com.alibaba.fastjson.JSON;  
2. import com.alibaba.fastjson.JSONObject;  
3. import com.alibaba.fastjson.TypeReference;  
4.   
5. public class MgQueryCondition<T> {  
6.     private T model;  
7.   
8.     private Integer pageNo;  
9.   
10.     private Integer pageNum;  
11.   
12.     public T getModel() {  
13.         return model;  
14.     }  
15.   
16.     public void setModel(T model) {  
17.         this.model = model;  
18.     }  
19.   
20.     public Integer getPageNo() {  
21.         return pageNo;  
22.     }  
23.   
24.     public void setPageNo(Integer pageNo) {  
25.         this.pageNo = pageNo;  
26.     }  
27.   
28.     public Integer getPageNum() {  
29.         return pageNum;  
30.     }  
31.   
32.     public void setPageNum(Integer pageNum) {  
33.         this.pageNum = pageNum;  
34.     }  
35.   
36.     @Override  
37.     public String toString() {  
38.         return "MgQueryCondition [model=" + model + ", pageNo=" + pageNo  
39.                 + ", pageNum=" + pageNum + "]";  
40.     }  
41.   
42. }  

    假设我们去调试的话，发现MgQueryCondition里面的数据类型是JSONObject,如果如果在调用getModel的时候就会发生类型转换问题，后来我看了下fastjson的文档。

    针对泛型类型，使用TypeReference进行解析，代码如下：

Java代码  

1. public static void main(String[] args) {  
2.     MgQueryCondition<TestBean> test = new MgQueryCondition<TestBean>();  
3.     TestBean testBean = new TestBean();  
4.     testBean.setId(1);  
5.     test.setModel(testBean);  
6.     test.setPageNo(1);  
7.     test.setPageNum(1);  
8.     System.out.println(JSONObject.toJSONString(test));  
9.   
10.     String json = "{\"model\":{\"id\":1},\"pageNo\":1,\"pageNum\":1}";  
11.     <strong>MgQueryCondition<TestBean> clazz = JSON.parseObject(json,   
12.             new TypeReference<MgQueryCondition<TestBean>>(){});</strong>  
13.     System.out.println(clazz.getModel().getClass());  
14.   
15. }  

    这样我们就无法使用@RequestBody了，所以应该使用最基本的kv结构的进行传参。

FastJson循环引用问题

什么是循环引用和重复引用

重复引用：一个对象中的多个属性同时引用同一个对象 
例如：

        Object obj=new Object();
        Map<String,Object> map=new HashMap<>();
        map.put("1", obj);
        map.put("2", obj);//引用了同一个对象
        System.out.println(JSON.toJSONString(map));

• 1
• 2
• 3
• 4
• 5

循环引用：对象的属性之间存在相互引用导致循环，会引起StackOverFlow异常 
例如：

        Map<String,Object> map1=new HashMap<>();
        Map<String,Object> map2=new HashMap<>();
        map1.put("1",map2);//map1引用了map2
        map2.put("1",map1);//map2又引用了map1,导致循环引用
        System.out.println(JSON.toJSONString(map1));

• 1
• 2
• 3
• 4
• 5

FastJson如何解决循环引用/重复引用

fastjson支持循环引用/重复引用，并且是缺省打开的。 
* 第一个例子序列化后输出结果为：{"1":{},"2":{"$ref":"$.1"}} 
第一个对象正常序列化，第二个对象则用引用表示 
* 第二个列子序列化后输出结果为：{"1":{"1":{"$ref":".."}}}

根据fastJson的语法：

可以得出，”$.1”表示引用根对象(map)的第一个元素(obj)，”..”表示引用父对象(map1).

关闭循环引用/重复引用

fastjson默认对json序列化的时候进行循环引用的检测，从而避免了出现StackOverFlow异常。当序列化后的JSON传输到浏览器或者其他语言中，这些json解析器不支持循环引用，从而导致数据丢失。你可以关闭fastjson的循环引用检测。 
全局配置关闭

  JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.DisableCircularReferenceDetect.getMask();

非全局关闭

  JSON.toJSONString(obj, SerializerFeature.DisableCircularReferenceDetect);

处理StackOverFlowException

关闭循环引用检测功能后，在序列化的时候会出现StackOverFlow异常，这时需要用户处理好属性之间是否有循环引用的情况出现： 
可以在字段或者getter方法上使用@JSONField(serialize=false)注解来设置某些域不进行序列化，从而避免循环引用的情况发生。

http://blog.csdn.net/helloxiaoyueyue/article/details/51173168

Samples DataBind FastJson循环引用问题

原文：http://www.cnblogs.com/softidea/p/5873277.html