我存在，你深深的循环里--从反射看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对象的实体类。既

然有这么多的方法可能解决问题，就应该寻求一个高效的解决方法，我认为使用这种姑且叫做“反射重组”的方法是比较高效的，它可以代码重用，可以有效得到需要的内容。欢

迎讨论，轻拍。