Samples DataBind FastJson循环引用问题

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的代码如下：

@RequestMapping("/testBind")  
    @ResponseBody  
    public String testBind(@RequestBody MgQueryCondition<TestBean> queryCondition){  
        System.out.println(queryCondition);  
          
        return "success";  
    }  

import java.io.Serializable;  
  
public class TestBean implements Serializable{  
    private Integer id;  
  
    public Integer getId() {  
        return id;  
    }  
  
    public void setId(Integer id) {  
        this.id = id;  
    }  
  
    @Override  
    public String toString() {  
        return "TestBean [id=" + id + "]";  
    }  
}  

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.JSONObject;  
import com.alibaba.fastjson.TypeReference;  
  
public class MgQueryCondition<T> {  
    private T model;  
  
    private Integer pageNo;  
  
    private Integer pageNum;  
  
    public T getModel() {  
        return model;  
    }  
  
    public void setModel(T model) {  
        this.model = model;  
    }  
  
    public Integer getPageNo() {  
        return pageNo;  
    }  
  
    public void setPageNo(Integer pageNo) {  
        this.pageNo = pageNo;  
    }  
  
    public Integer getPageNum() {  
        return pageNum;  
    }  
  
    public void setPageNum(Integer pageNum) {  
        this.pageNum = pageNum;  
    }  
  
    @Override  
    public String toString() {  
        return "MgQueryCondition [model=" + model + ", pageNo=" + pageNo  
                + ", pageNum=" + pageNum + "]";  
    }  
  
}  

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

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

public static void main(String[] args) {  
    MgQueryCondition<TestBean> test = new MgQueryCondition<TestBean>();  
    TestBean testBean = new TestBean();  
    testBean.setId(1);  
    test.setModel(testBean);  
    test.setPageNo(1);  
    test.setPageNum(1);  
    System.out.println(JSONObject.toJSONString(test));  
  
    String json = "{"model":{"id":1},"pageNo":1,"pageNum":1}";  
    <strong>MgQueryCondition<TestBean> clazz = JSON.parseObject(json,   
            new TypeReference<MgQueryCondition<TestBean>>(){});</strong>  
    System.out.println(clazz.getModel().getClass());  
  
}  

    这样我们就无法使用@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));

循环引用：对象的属性之间存在相互引用导致循环，会引起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));

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

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

根据fastJson的语法：

语法	描述
{“$ref”:”$”}	引用根对象
{“$ref”:”@”}	引用自己
{“$ref”:”..”}	引用父对象
{“$ref”:”../..”}	引用父对象的父对象
{“$ref”:”$.members[0].reportTo”}	基于路径的引用

可以得出，”$.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