JSON工具學習記錄–FastJSON迴圈引用問題

標籤（空格分隔）： fastjson

最近基於他人專案做二次開發,遇到了迴圈引用的問題,簡單來說A引用了B,B引用了C,C引用了A,那麼轉換json就會無休止的轉換下去.
更復雜的情況,A中引用了B,B中引用了一個A的集合,比如廣告引用了廣告型別,廣告型別裡面又有該型別下的所屬廣告.

1.構造情景

這種又叫做雙向引用,個人感覺這種設計本身就不是很合理,當然還要看具體使用場景了.

廣告類:

/**
 * @author Niu Li
 * @date 2016/8/12
 */
public class ADEntity {
    private
 
 int id;
    private String name;
    //引用了一個廣告實體類
    private ADTypeEntity adTypeEntity;

    public ADEntity(int id, String name, ADTypeEntity adTypeEntity) {
        this.id = id;
        this.name = name;
        this.adTypeEntity = adTypeEntity;
    }
//省略get和set
}

廣告實體類:

import java.util.List;

/**
 * @author
 
 Niu Li
 * @date 2016/8/12
 */
public class ADTypeEntity {
    private int id;
    private String name;
    //引用了其廣告集合
    private List<ADEntity> lists;
    //省略get和set
}

測試程式碼:

public class TestApp {
    public static void main(String[] args) {
        //構造廣告型別
        ADTypeEntity adTypeEntity = new
 
 ADTypeEntity();
        adTypeEntity.setId(1);
        adTypeEntity.setName("輪播圖");
        //構造廣告
        ADEntity entity1 = new ADEntity(1,"圖1",adTypeEntity);
        ADEntity entity2 = new ADEntity(2,"圖2",adTypeEntity);
        ADEntity entity3 = new ADEntity(3,"圖3",adTypeEntity);

        List<ADEntity> lists = new ArrayList<ADEntity>();
        lists.add(entity1);
        lists.add(entity2);
        lists.add(entity3);
        //雙向引用
        adTypeEntity.setLists(lists);

        String result = JSON.toJSONString(entity1);
        System.out.println(result);
    }
}

結果可以看到雙向引用被替換成$ref了:

{
  "adTypeEntity": {
    "id": 1,
    "lists": [
      {
        "$ref": "$"
      },
      {
        "adTypeEntity": {
          "$ref": "$.adTypeEntity"
        },
        "id": 2,
        "name": "圖2"
      },
      {
        "adTypeEntity": {
          "$ref": "$.adTypeEntity"
        },
        "id": 3,
        "name": "圖3"
      }
    ],
    "name": "輪播圖"
  },
  "id": 1,
  "name": "圖1"
}

2.解決辦法

兩種解決辦法就是哪裡有迴圈引用,就過濾掉該欄位.

1.過濾的方式可以使用JSONField註解宣告該欄位不被轉換為json

    @JSONField(serialize = false)
    private List<ADEntity> lists;

得到結果

{
  "adTypeEntity": {
    "id": 1,
    "name": "輪播圖"
  },
  "id": 1,
  "name": "圖1"
}

2.自定義轉換欄位

 SimplePropertyPreFilter filter = new SimplePropertyPreFilter(ADTypeEntity.class,"id","name");
        String result = JSON.toJSONString(entity1,filter);

這表明對於ADTypeEntity類只序列化id和name欄位,這樣的話就排除掉list集合引用了,得到的結果和上面一樣.

3.置頂轉換規則多級過濾

fastjson可以實現一些介面指定過濾屬性.過濾本質是fastjson每一次要序列化欄位的時候都會經過Apply方法進行判斷,只有Apply返回true的時候才會序列化,因此就可以根據屬性名來進行自由過濾.

以下實現PropertyPreFilter介面,根據name值來進行排除判定.

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.PropertyPreFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;

import java.util.HashMap;
import java.util.Map;

/**
 * @date 2016/8/17
 */
public class ComplexPropertyPreFilter implements PropertyPreFilter {
    private Map<Class<?>, String[]> includes = new HashMap<>();
    private Map<Class<?>, String[]> excludes = new HashMap<>();

    static {
        //全域性配置關閉迴圈引用檢測
        JSON.DEFAULT_GENERATE_FEATURE |= SerializerFeature.DisableCircularReferenceDetect.getMask();
    }

    public ComplexPropertyPreFilter() {

    }

    public ComplexPropertyPreFilter(Map<Class<?>, String[]> includes) {
        super();
        this.includes = includes;
    }

    public boolean apply(JSONSerializer serializer, Object source, String name) {

        //物件為空。直接放行
        if (source == null) {
            return true;
        }

        // 獲取當前需要序列化的物件的類物件
        Class<?> clazz = source.getClass();

        // 無需序列的物件、尋找需要過濾的物件，可以提高查詢層級
        // 找到不需要的序列化的型別
        for (Map.Entry<Class<?>, String[]> item : this.excludes.entrySet()) {
            // isAssignableFrom()，用來判斷型別間是否有繼承關係
            if (item.getKey().isAssignableFrom(clazz)) {
                String[] strs = item.getValue();

                // 該型別下 此 name 值無需序列化
                if (isHave(strs, name)) {
                    return false;
                }
            }
        }

        // 需要序列的物件集合為空 表示 全部需要序列化
        if (this.includes.isEmpty()) {
            return true;
        }

        // 需要序列的物件
        // 找到不需要的序列化的型別
        for (Map.Entry<Class<?>, String[]> item : this.includes.entrySet()) {
            // isAssignableFrom()，用來判斷型別間是否有繼承關係
            if (item.getKey().isAssignableFrom(clazz)) {
                String[] strs = item.getValue();
                // 該型別下 此 name 值無需序列化
                if (isHave(strs, name)) {
                    return true;
                }
            }
        }

        return false;
    }

    /*
     * 此方法有兩個引數，第一個是要查詢的字串陣列，第二個是要查詢的字元或字串
     */
    public static boolean isHave(String[] strs, String s) {

        for (int i = 0; i < strs.length; i++) {
            // 迴圈查詢字串陣列中的每個字串中是否包含所有查詢的內容
            if (strs[i].equals(s)) {
                // 查詢到了就返回真，不在繼續查詢
                return true;
            }
        }

        // 沒找到返回false
        return false;
    }

    public Map<Class<?>, String[]> getIncludes() {
        return includes;
    }

    public void setIncludes(Map<Class<?>, String[]> includes) {
        this.includes = includes;
    }

    public Map<Class<?>, String[]> getExcludes() {
        return excludes;
    }

    public void setExcludes(Map<Class<?>, String[]> excludes) {
        this.excludes = excludes;
    }
}

自己程式碼中用到的過濾

 Pageable pageable = new Pageable(page,rows);
        Page<Promotion> promotionPages = promotionService.findPage(pageable);

        String[] promotionFilters = {"id", "name","title","image","endDate","priceExpression","memberRanks"};
        String[] memberFilter = {"id","name"};
        String[] pageFilter = {"pageNumber","pageSize","content","total","totalPages"};
        Map<Class<?>,String[]> mapFilter = new HashMap<>();
        mapFilter.put(Promotion.class,promotionFilters);
        mapFilter.put(MemberRank.class,memberFilter);
        mapFilter.put(Page.class,pageFilter);

        ResultData result = new ResultData.Builder(ResultVo.OK)
                .setData(APPJsonUtil.toJsonObject(mapFilter,null,promotionPages))
                .builder();

json工具

 /**
     * 按照指定序列轉換為jsonObject,多級過濾
     * @param object
     * @return
     */
    public static JSONObject toJsonObject(Map<Class<?>, String[]> includes,Map<Class<?>, String[]> excludes, Object object){
        ComplexPropertyPreFilter filter = new ComplexPropertyPreFilter();
        if (excludes != null) {
            filter.setExcludes(excludes);
        }
        if (includes != null) {
            filter.setIncludes(includes);
        }
        String result = JSON.toJSONString(object, filter);
        return JSON.parseObject(result);
    }