基于 Fastjson 重复引用和循环引用所导致的生产问题 - 出现$ref引用，分析原因，提出解决办法（很透彻）

╰+攻爆jí腚メ 2022-11-12 09:54 310阅读 0赞

原创博文，欢迎转载，转载时请务必附上博文链接，感谢您的尊重。

# 前言 #

通过本篇，你将学习到 alibaba.fastjson【循环引用】和【重复引用】的概念，还有出现此类问题时候的【解决办法】，着急的朋友可以直接看最后的总结。

拜同事所赐，又给我搞出来个奇怪的问题，又是在大半夜，又是上线的前一刻发现的，又双叒叕......有机会一定要好好谢谢你。

![20210324104926954.jpg][]

问题的定位并不难，由于前端接收的Data中出现了**$ref**字样的数据，导致了处理和显示的时候产生错误，从后端Debug一下就会发现是Fastjson.toJSONString()出现的问题。

后来明白了，fastjson默认开启**引用检测****，**在传输的数据中出现相同的对象时，会将相同的对象写成引用的形式，$ref 就是引用的语法。

虽然在第一次看到的时候确实有点懵逼——“这TM是个啥啥个啥啥啊”，但现在想想生产的问题也没什么可炫耀的，所以我就不巴巴了，说多了显得更Low，o(╯□╰)o。

--------------------

# 正文 #

Fastjson 使用Java语言编写，是阿里巴巴开源的项目，号称最快的JSON库，作为前后端或系统间的数据传输格式再合适不过。

Fastjson 还有个特性，支持**引用检测**功能，引用分为两种——【**重复引用**】和【**循环引用**】，并且是**“缺省打开”**的。

*  重复引用：一个对象对另外一个对象多个字段重复引用，或集合字段重复引用；
 *  循环引用：对象A引用对象B，对象B引用对象A，出现你中有，我中有你现象；

当序列化后的JSON传输到浏览器或者其他语言中，如果这些Json解析器不支持循环引用，从而导致数据丢失，那我们可以关闭fastjson的循环引用支持，并且，关闭引用检测，还能够提升序列化时的性能。

## 1. 关闭方法 ##

*  全局配置关闭

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

*  非全局关闭

JSON.toJSONString(obj, SerializerFeature.DisableCircularReferenceDetect);

## 2. 语法 ##

如果关闭引用检测，使得Json解析器不支持循环引用，那么重复的对象就会以引用的方式出现，语法如下：

<table> 
 <thead> 
  <tr> 
   <th style="text-align:center;">语法</th> 
   <th style="text-align:center;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="text-align:center;">{"$ref":"$"}</td> 
   <td>引用根对象</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">{"$ref":"@"}</td> 
   <td>引用自己</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">{"$ref":".."}</td> 
   <td>引用父对象</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">{"$ref":"../.."}</td> 
   <td>引用父对象的父对象</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">{"$ref":"$.members[0].reportTo"}</td> 
   <td>基于路径的引用</td> 
  </tr> 
 </tbody> 
</table>

## 3. 场景 ##

我写了一个简单的Demo，【**重复引用**】和【**循环引用**】两种场景可以同时验证，还能学到正确的使用方法，Junit环境下可以直接复制运行。

Demo中，对象模拟类、数据表设计，打印结果模拟前端接收到的数据，try...catch...部分代码是为了证明“循环引用”场景下关闭引用监测机制的后果。

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.List;
    
    public class FastJsonTest {
    
        /** 商品信息 */
        private static class Item{
            private String itemId;      // 商品Id
            private String itemName;    // 商品名称
            private Order order;        // 关联订单
    
            public String getItemId() { return itemId; }
            public void setItemId(String itemId) { this.itemId = itemId; }
            public String getItemName() { return itemName; }
            public void setOrder( Order order) { this.order = order; }
            public Order getOrder() { return order; }
            public void setItemName(String itemName) { this.itemName = itemName; }
        }
    
        /** 订单信息 */
        private static class Order{
            private String orderId;     // 订单Id
            private String orderName;   // 订单名称
            private Item item;          // 关联商品
    
            public String getOrderId() { return orderId; }
            public void setOrderId(String orderId) { this.orderId = orderId; }
            public String getOrderName() { return orderName; }
            public void setOrderName(String orderName) { this.orderName = orderName; }
            public Item getItem() { return item; }
            public void setItem( Item item) { this.item = item; }
        }
    
        @Test
        public void test_fastjson(){
            Item item = new  Item();
            item.setItemId("13518");
            item.setItemName("IT无知君");
            Order order = new  Order();
            order.setOrderId("18712");
            order.setOrderName("天涯未远，有缘再见");
    
            // 1、验证“验证FastJson的重复引用”
            List<Item> list = new ArrayList<>();
            list.add(item);
            list.add(item);
            list.add(item);
            System.out.println("1.默认缺省打开时，list1 = " + JSON.toJSONString(list));
            System.out.println("2.关闭缺省打开时，list2 = " + JSON.toJSONString(list, SerializerFeature.DisableCircularReferenceDetect));
            System.out.println("3.再次使用缺省时，list3 = " + JSON.toJSONString(list));
    
            // 2、验证“验证FastJson的循环引用”
            item.setOrder(order);
            order.setItem(item);
            System.out.println("4.默认缺省打开时，item1 = " + JSON.toJSONString(item));
            System.out.println("5.默认缺省打开时，order1 = " + JSON.toJSONString(order));
            try {
                System.out.println("6.关闭缺省打开时，item2 = " + JSON.toJSONString(item, SerializerFeature.DisableCircularReferenceDetect));
            } catch (Exception e) {
                System.out.println("7.这行代码执行不到，因为StackOverflowError不属于Exception。");
            }
            System.out.println("8.这行代码也执行不到，因为系统已经出现了StackOverflowError（堆栈溢出错误）！");
        }
    }

**运行结果：**

1.默认缺省打开时，list1 = [{"itemId":"13518","itemName":"IT无知君"},{"$ref":"$[0]"},{"$ref":"$[0]"}]
    2.关闭缺省打开时，list2 = [{"itemId":"13518","itemName":"IT无知君"},{"itemId":"13518","itemName":"IT无知君"},{"itemId":"13518","itemName":"IT无知君"}]
    3.再次使用缺省时，list3 = [{"itemId":"13518","itemName":"IT无知君"},{"$ref":"$[0]"},{"$ref":"$[0]"}]
    4.默认缺省打开时，item1 = {"itemId":"13518","itemName":"IT无知君","order":{"item":{"$ref":".."},"orderId":"18712","orderName":"天涯未远，有缘再见"}}
    5.默认缺省打开时，order1 = {"item":{"itemId":"13518","itemName":"IT无知君","order":{"$ref":".."}},"orderId":"18712","orderName":"天涯未远，有缘再见"}
    
    java.lang.StackOverflowError
    ......

**通过Demo，我们可以学到什么？**

*  结果1显示，由于FastJson默认引用检测打开，所以在集合中重复使用同一个对象时，后出现的的对象会被引用语法替代，如：\{"$ref":"$"\}；
 *  结果2显示，关闭FastJson的引用检测，当需要JSON转换时，FastJson不会检测对象地址，全部按新对象进行序列化，所以不会出现引用语法；
 *  结果3显示，非全局关闭FastJson的引用检测只会对当前序列化生效，不是永久关闭，不会对该对象的后续序列化产生影响，该被引用还是会引用；
 *  结果4,5显示，“你中有我，我中有你”的循环引用场景下，重复出现的对象也会被引用语法替代，如：\{"$ref":".."\}；
 *  StackOverflowError显示，在循环引用场景下关闭引用检测，不管数据量多小，都会引发堆栈溢出；且该问题属于Error，不被异常捕获，直接影响业务流程，后果很严重。

## 4. 解决方法 ##

上面的Demo其实已经给出了答案，我再巴巴几句，来点干货：

**针对【重复引用】：**

*  编码时，使用新对象或者新集合赋值 ，避免同一个对象多次赋值使用（像上面Demo中那样），是同一个对象不是值相等的对象；
 *  如果使用同一个对象多次赋值，就算不会出现 Fastjson 的缺省引用问题，也可能会出现其他代码问题，这种写法本身就是【编码不规范】的；
 *  如果前端用不到这个被**$ref**的属性，可以拒绝让该属性被序列化，在它的get()方法上使用注解【@JSONField(serialize=false)】可以实现；
 *  前面的话也并非绝对，出现即合理嘛，如果遇到非这样写不可的场景，使用上面提到的2种关闭方法即可，建议“非全局关闭”。

**针对【循环引用】：**

*  首先，**类**或**数据表**设计可能有问题，应该从设计层面进行优化，从根本上避免“你中有我，我中有你”式的结构出现；
 *  其次，如果前端用不到这个被**$ref**的属性，也可以拒绝让该属性被序列化，在它的get()方法上使用注解【@JSONField(serialize=false)】可以实现；
 *  **注意，**该场景下绝对不能关闭 FastJson 的引用检测机制，否则一定会出现“StackOverflowError”异常。

--------------------

# 个人建议 #

1.  不要关闭 FastJson 的引用检测机制，尤其是在循环引用的场景下，官方的默认缺省打开是有道理的；
2.  如果为了避免在**重复引用**时显示$ref而关闭它，万一发生了**循环引用****，**会导致出现“StackOverflowError”异常，得不偿失（这句话没有写错，要好好理解）。
3.  在重复引用的场景下，如果需要关闭引用检测机制，一定要使用“非全局关闭”方法，也能最大限度避免出现“StackOverflowError”的情况；
4.  Last but not least，每一次出现重复或循环引用的场景都是有原因的，要从根本上解决，轻易不要关闭 FastJson 的引用检测机制。

--------------------

**我是**「**IT无知君**」**，您的点赞、评论和关注，是我创作的动力源泉。  
学无止境，气有浩然，让我们一起加油，天涯未远，江湖有缘再见！！**

[20210324104926954.jpg]: /images/20221022/12806bdae036421ca1d0e81c4f3ecfa9.png