我存在，你深深的循環里--從反射看JSON死循環

 

JSON有一個非常經典的問題:JSONException: There is a cycle in the hierarchy!俗稱死循環.解決這個問題至少有三種以上的辦法,總之一句話就是過濾.今天嘗試着從

反射的角度來闡述和解決這個問題.

 

一.“反射重組（姑且這么叫吧）”

 

廢話不多說,直接上代碼.以下代碼,預設有兩個實體類,Company及Product,它們為一對多雙向關聯映射。類Product中有屬性company與之關聯類Company.現在，需要以

列表形式展示Product,后台以JSON格式傳遞數據。

class  
{
    @RequestMapping
    @ResponseBody
    public void getproduct(HttpServletRequest request,HttpServletResponse response,Product product) throws Exception{
        PageBean<Product, Product> pageBean = this.getPageBean(request);
        pageBean.setSearchCondObj(product);
        PageBean<Product, Product> bean = this.productService.getProduct(pageBean);
        Map<String, Object> map=new HashMap<String, Object>();
        JsonConfig config = new JsonConfig(); 
        
        //屏蔽掉相關聯的實體屬性，以及不需要在列表中展示的屬性
         
        config.setExcludes(new String[] {"description","companyperson","comment","productitems","companycontact"});
        // 把列表顯示需要的實體屬性傳過去
        
        config.registerJsonValueProcessor(Company.class,   //調用registerJsonValueProcessor構造方法，初始化參數
                   new ObjectJsonValueProcessor(new String[]{"name","id"},Company.class));
        
        Map<String, Object> jsonMap = new HashMap<String, Object>();
        jsonMap.put("total", bean.getSize());
        jsonMap.put("rows", bean.getSource());
        JSONObject result = JSONObject.fromObject(jsonMap, config);
        this.outPrint(response, request, result.toString());
    }
}

 

為了避免陷入"net.sf.json.JSONException: There is a cycle in the hierarchy!",以下這段代碼是核心代碼,它的核心是反射重組.代碼出處為網絡,非本人原創.

我添加了注釋,以便理解查看.

package com.project.pojo;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
 
/** 
 * 解決JSONObject.fromObject拋出"There is a cycle in the hierarchy"異常導致死循環的解決辦法 
 * 以及實體屬性無法傳遞的問題
 * 此段代碼為網絡資料，非原創
 */  
public class ObjectJsonValueProcessor implements JsonValueProcessor {
    
     /** 
     * 需要留下的字段數組 
     */  
    private String[] properties;  
      
    /** 
     * 需要做處理的復雜屬性類型 
     */  
    private Class<?> clazz;  
      
    /** 
     * 構造方法,參數必須 
     * @param properties 
     * @param clazz 
     */  
    public ObjectJsonValueProcessor(String[] properties,Class<?> clazz){  
        this.properties = properties;  
        this.clazz =clazz;  
    }  

    @Override
    public Object processArrayValue(Object value, JsonConfig arg1) {
            PropertyDescriptor pd = null;  
            Method method = null;  
            StringBuffer json = new StringBuffer("{");  
            try{  
                for(int i=0;i<properties.length;i++){  
                    pd = new PropertyDescriptor(properties[i], clazz);  
                    method = pd.getReadMethod(); 
                    String v = String.valueOf(method.invoke(value));  
                    json.append("'"+properties[i]+"':'"+v+"'");  
                    json.append(i != properties.length-1?",":"");  
                }  
                json.append("}");  
            }catch (Exception e) {  
                e.printStackTrace();  
            }  
            return JSONObject.fromObject(json.toString());  
        return null;
    }

      @Override  
        public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {  
        //key為實體關聯字段，即外鍵
            PropertyDescriptor pd = null;  
            Method method = null;  
            StringBuffer json = new StringBuffer("{");  
            try{  
                for(int i=0;i<properties.length;i++){  
                    pd = new PropertyDescriptor(properties[i], clazz);  
                    //反射：通過類PropertyDescriptor可以得到properties數組即相關聯的實體中需要傳遞的屬性，它的名稱，類型以及getter,setter方法
                    method = pd.getReadMethod(); //得到屬性的讀取方法，即getter()
                    if (value != null){
                    
                String v = String.valueOf(method.invoke(value));//執行getter(),當然也可以看出這里value
                //即是一個實體類的字節碼，在這里是Company.class,然后在組裝JSON格式的字符串
                    
                json.append("'" + properties[i] + "':'" + v + "'");
                json.append(i != properties.length - 1 ? "," : "");
                    
                } 
                } 
               
                json.append("}"); 
                System.out.println("json = "+json.toString());
            }catch (Exception e) {  
                e.printStackTrace();  
            }  
            return JSONObject.fromObject(json.toString());  
        }  
}

 

為了更好的驗證以及看清processObjectValue(),貼一段測試代碼及結果:

class  
{
    public static void main(String[] args) 
    {
        @Override  
        public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {  
            System.out.println("key :"+key);
            PropertyDescriptor pd = null;  
            Method method = null;  
            StringBuffer json = new StringBuffer("{");  
            try{  
                for(int i=0;i<properties.length;i++){  
                    pd = new PropertyDescriptor(properties[i], clazz);  
                    System.out.println("pd :"+pd);
                  
                    method = pd.getReadMethod(); 
                    
                if (value != null){
                    System.out.println("value :"+value);
                    String v = String.valueOf(method.invoke(value));
                    System.out.println("v :"+v);
                    json.append("'" + properties[i] + "':'" + v + "'");
                    json.append(i != properties.length - 1 ? "," : "");
                    } 
                
                } 
               
                json.append("}"); 
                System.out.println("json = "+json.toString());
            }catch (Exception e) {  
                e.printStackTrace();  
            }  
            return JSONObject.fromObject(json.toString());  
        }  
    }
}

 測試結果:

 

在執行

 config.registerJsonValueProcessor(Company.class,new ObjectJsonValueProcessor(new String[]{"name","id"},Company.class));

這段代碼的時候，僅僅只是對ObjectJsonValueProcessor作了初始化，真正執行類ObjectJsonValueProcessor中processObjectValue(),還是在這里：

    JSONObject result = JSONObject.fromObject(jsonMap, config);

通過觀察JSONObject源碼可以看到，在fromObject(jsonMap, config)中調用了fromDynaBean(DynaBean bean, JsonConfig jsonConfig)，從名字中可以看出，

參數為一個動態JAVABEAN，即為在processObjectValue()中，通過反射得到關聯實體的屬性，然后動態組裝。

public static JSONObject fromObject(Object object, JsonConfig jsonConfig)
  {
    if ((object == null) || (JSONUtils.isNull(object)))
      return new JSONObject(true);
    if ((object instanceof Enum))
      throw new JSONException("'object' is an Enum. Use JSONArray instead");
    if (((object instanceof Annotation)) || ((object != null) && (object.getClass().isAnnotation())))
    {
      throw new JSONException("'object' is an Annotation.");
    }if ((object instanceof JSONObject))
      return _fromJSONObject((JSONObject)object, jsonConfig);
    if ((object instanceof DynaBean))
      return _fromDynaBean((DynaBean)object, jsonConfig);//執行這里
    if ((object instanceof JSONTokener))
      return _fromJSONTokener((JSONTokener)object, jsonConfig);
    if ((object instanceof JSONString))
      return _fromJSONString((JSONString)object, jsonConfig);
    if ((object instanceof Map))
      return _fromMap((Map)object, jsonConfig);
    if ((object instanceof String))
      return _fromString((String)object, jsonConfig);
    if ((JSONUtils.isNumber(object)) || (JSONUtils.isBoolean(object)) || (JSONUtils.isString(object)))
    {
      return new JSONObject();
    }if (JSONUtils.isArray(object)) {
      throw new JSONException("'object' is an array. Use JSONArray instead");
    }
    return _fromBean(object, jsonConfig);
  }

 然后再執行processObjectValue(),得到關聯實體需要的屬性組成的JSON對象,然后再調用 setValue(jsonObject, key, value, value.getClass(), jsonConfig, bypass)

 組裝完整的JSON對象

 if (!exclusions.contains(key))
        {
          Object value = entry.getValue();
          if ((jsonPropertyFilter == null) || (!jsonPropertyFilter.apply(map, key, value)))
          {
            if (value != null) {
              JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(value.getClass(), key);

              if (jsonValueProcessor != null) {
                value = jsonValueProcessor.processObjectValue(key, value, jsonConfig);//執行processObjectValue(),得到關聯實體需要的屬性組成的JSON對象
                bypass = true;
                if (!JsonVerifier.isValidJsonValue(value)) {
                  throw new JSONException("Value is not a valid JSON value. " + value);
                }
              }
              setValue(jsonObject, key, value, value.getClass(), jsonConfig, bypass);//組裝完整的JSON對象
            }

 

二.其它方法 

通過JsonValueProcessor解決JSON死循環的問題,到此基本描述清楚了.思慮再在一,我覺得還有必要羅嗦幾句,即講一講其它三種解決JSON死循環的方法,不然怎能看出用

JsonValueProcessor解決的好處呢?

 1:過濾屏蔽,如: 

 1 JsonConfig config = new JsonConfig(); 
 2 config.setExcludes(new String[] {"company"});

 如此可以過濾掉不需要的屬性以及關聯實體屬性，這樣當然不會報錯，但是如果我需要展示"company"的屬性呢？這樣顯然無法滿足需求。

 

2：使用JSON屬性過濾器PropertyFilter()

config.setJsonPropertyFilter(new PropertyFilter() {
            
            @Override
            /**
             * argo:當前進行操作的實體,如:product
             * arg1:實體屬性
             * arg2:實體屬性的類型
             */
            public boolean apply(Object arg0, String arg1, Object arg2) {
                if(arg1.equals("company")){
                    return true;//表示過濾掉此屬性
                }
                return false;//表示正常操作
            }
        });

此方法實際上跟方法1所能達到的效果一樣，但是更為復雜。當然可以在[if(arg1.equals("company"))]這里通過反射得到setter方法，重新設置屬性值，但是反射不能改

變屬性的類型和方法參數類型，所以還是不能避免死循環。

 

3：使用JsonValueProcessor()

config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT); //首先避免掉死循環
         config.setExcludes(new String[]{"handler","hibernateLazyInitializer"});  //設置延遲加載
         config.registerJsonValueProcessor(Date.class,new JsonValueProcessor() { 
            public Object processObjectValue(String arg0, Object arg1, JsonConfig arg2) {
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date d=(Date) arg1;
                return sdf.format(d);
            } 
            public Object processArrayValue(Object arg0, JsonConfig arg1) { 
                return null;
            }
        }); 

 

這段代碼完全能夠實現既避免死循環又得到"company"的全部屬性。功能上沒有問題，但是效率上有大問題。盡管我在實體和屬性層面上都設置了延遲加載，但是product還

是通過company把所有的區域信息加載出來，所形成的JSON字符串足足有3.5MB,嚴重影響了效率。

 

三.小結

其它的方法應該還有，我甚至見過有人新建一個JAVABean或新建一個內部類，在通過循環賦值構建一個沒有關聯實體的單獨的JAVABean,來作為構建JSON對象的實體類。既

然有這么多的方法可能解決問題，就應該尋求一個高效的解決方法，我認為使用這種姑且叫做“反射重組”的方法是比較高效的，它可以代碼重用，可以有效得到需要的內容。歡

迎討論，輕拍。