java处理json与对象的转化 递归

整个类是一个case，总结了我在使用java处理json的时候遇到的问题，还有级联关系的对象如何遍历，json和对象之间的转换！

对于对象json转换中遇到的问题我参考了一篇博客，http://blog.csdn.net/xq328220454/article/details/39256589

很有益处，我在文章的后半部分照搬了过来！

首先准备数据，准备了一堆具有主子关系的对象，包含普通属性id，父对象parent，子集合list<HeadCell>,还有关联对象message;

 @Before
     public void setUp() throws Exception {
         Message message = new Message("name", 1);
         HeadCell hc1 = new HeadCell();
         HeadCell hc2 = new HeadCell();
         HeadCell hc11 = new HeadCell();
         HeadCell hc12 = new HeadCell();
         HeadCell hc21 = new HeadCell();
         HeadCell hc111 = new HeadCell();
         HeadCell hc112 = new HeadCell();

         hc111.setId("hc111");
         hc111.setMessage(message);

         hc112.setId("hc112");
         hc112.setMessage(message);

         hc11.setId("hc11");
         hc11.setMessage(message);

         hc12.setId("hc12");
         hc12.setMessage(message);

         hc21.setId("hc21");
         hc21.setMessage(message);

         hc1.setId("hc1");
         hc1.setMessage(message);

         hc2.setId("hc2");
         hc2.setMessage(message);

         List<HeadCell> hcs11 = new ArrayList<>();
         hcs11.add(hc111);
         hcs11.add(hc112);
         hc11.setChildren(hcs11);
         hc111.setParent(hc11);
         hc112.setParent(hc11);

         List<HeadCell> hcs1 = new ArrayList<>();
         hcs1.add(hc11);
         hcs1.add(hc12);
         hc1.setChildren(hcs1);
         hc11.setParent(hc1);
         hc12.setParent(hc1);

         List<HeadCell> hcs2 = new ArrayList<>();
         hcs2.add(hc21);
         hc2.setChildren(hcs2);

         headCells.add(hc1);
         headCells.add(hc2);
     }

 public class Message {
     private String name;
     private Integer age;

     public Message() {}

     public Message(String name, Integer age) {
         this.name = name;
         this.age = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Integer getAge() {
         return age;
     }

     public void setAge(Integer age) {
         this.age = age;
     }

 }

通过递归以目录格式解析层级关系,把准备的list以树形的方式打印处理

 　　@Test
     public void chart() {
         String str = "";
         buildChart(headCells, str);
     }

     private void buildChart(List<HeadCell> headCells, String str) {
         str += "++";
         for (int i = 0; i < headCells.size(); i++) {
             HeadCell headCell = headCells.get(i);
             if (headCell.getChildren() != null && headCell.getChildren().size() > 0) {
                 System.out.println(str + headCell.getId());
                 buildChart(headCell.getChildren(), str);
             } else {
                 System.out.println(str + headCell.getId());
             }
         }
     }

打印结果为：

++hc1
++++hc11
++++++hc111
++++++hc112
++++hc12
++hc2
++++hc21

处理List<HeadCell>转化为jsonarray，当然对象是转换为jsonObject，还有一种是继承了ArrayList的对象，我有遇到过这种情况，忘了是怎么处理的了

这里转换的时候使用了config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);是因为parent自关联会无限递归下去，所以这解析出json的值

parent为空

 　　@Test
     public void proHeadCell2Json() {
         JsonConfig config = new JsonConfig();
         // config.setExcludes(new String[]{});
         config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
         try {
             String array = JSONArray.fromObject(headCells, config).toString();
             System.out.println(array);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

list对象转成json结果为

 [ {
     "children" : [ {
         "children" : [ {
             "children" : [],
             "id" : "hc111",
             "message" : {
                 "age" : 1,
                 "name" : "name"
             },
             "parent" : null
         }, {
             "children" : [],
             "id" : "hc112",
             "message" : {
                 "age" : 1,
                 "name" : "name"
             },
             "parent" : null
         } ],
         "id" : "hc11",
         "message" : {
             "age" : 1,
             "name" : "name"
         },
         "parent" : null
     }, {
         "children" : [],
         "id" : "hc12",
         "message" : {
             "age" : 1,
             "name" : "name"
         },
         "parent" : null
     } ],
     "id" : "hc1",
     "message" : {
         "age" : 1,
         "name" : "name"
     },
     "parent" : null
 }, {
     "children" : [ {
         "children" : [],
         "id" : "hc21",
         "message" : {
             "age" : 1,
             "name" : "name"
         },
         "parent" : null
     } ],
     "id" : "hc2",
     "message" : {
         "age" : 1,
         "name" : "name"
     },
     "parent" : null
 } ]

把json转为list对象，这里主要是级联列并不能转为级联关系的对象，会直接报错，所以我们需要递归json把每一级都转为一个对象，并且在转换时把children添加

为例外，这里要知道我们的parent是空的，message并不存在级联列，所以可以直接存在对象里面。那么我们需要建立他们的父关系和子关系，还是要递归处理！

 　　@Test
     public void proJson2HeadCell() {
         JSONArray array = perpareHeadCell2Json();
         List<HeadCell> headCells = new ArrayList<>();
         for (int i = 0; i < array.size(); i++) {
             JSONObject object = array.getJSONObject(i);
             headCells.add(buildTierObj(object));
         }
     }

     private HeadCell buildTierObj(JSONObject object) {
         HeadCell hc = new HeadCell();
         if (!StringUtils.equals("[]", object.getString("children"))) {
             hc = (HeadCell) JSONObject.toBean(object, HeadCell.class);
             hc.setChildren(new ArrayList<HeadCell>());
             hc.setParent(null);
             JSONArray array = object.getJSONArray("children");
             for (int i = 0; i < array.size(); i++) {
                 HeadCell subHeadCell = buildTierObj(array.getJSONObject(i));
                 subHeadCell.setParent(hc);
                 hc.getChildren().add(subHeadCell);
             }
         } else {
             hc = (HeadCell) JSONObject.toBean(object, HeadCell.class);
             hc.setParent(null);
         }
         return hc;
     }

     public JSONArray perpareHeadCell2Json() {
         JsonConfig config = new JsonConfig();
         config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
         try {
             JSONArray array = JSONArray.fromObject(headCells, config);
             return array;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

下面是json转为对象中遇到的问题的总结：

在JSON-LIB中，要转换的对象包含自身对象时，会抛出异常There is a cycle in the hierarchy，解决办法,如下，这样不会保存自关联属性

 　　JsonConfig config = new JsonConfig();
　　 config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);

自定义要被转换的字段

 　　JsonConfig config = new JsonConfig();
 2　　 config.setJsonPropertyFilter(new PropertyFilter() {
　　　　@Override
       public boolean apply(Object arg0, String arg1, Object arg2) {
       　　if (arg1.equals("id") || arg1.equals("serialNumber") || arg1.equals("productName")) {
           　　return false;
           } else {
              return true;
           }
        }
    });

解决延迟加载产生异常的问题(net.sf.json.JSONException:java.lang.reflect.InvocationTargetException)

 JsonConfig config = new JsonConfig();
 // 解决延迟加载产生异常的问题
 config.setExcludes(new String[] { "handler", "hibernateLazyInitializer" });

解决数据库查询结果中，Date转换的问题(net.sf.json.JSONException:java.lang.reflect.InvocationTargetException)

         JsonConfig config = new JsonConfig();
         config.registerJsonValueProcessor(java.util.Date.class, new JsonValueProcessor() {
             @Override
             public Object processArrayValue(Object obj, JsonConfig jsonconfig) {
                 return null;
             }

             @Override
             public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
                 if (value == null)
                     return "";
                 // 注意：在判断几个父子级类型时要先判断子类型再判断父类型
                 if (value instanceof java.sql.Date) {
                     String str = DateFormat.getDateInstance(DateFormat.DEFAULT).format(value);
                     return str;
                 } else if (value instanceof java.sql.Timestamp || value instanceof java.util.Date) {
                     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                     String str = format.format(value);
                     return str;
                 }
                 return value.toString();
             }
         });

有些字段的类型是枚举类型，可以在转换的时候将值设置为枚举类的value或者是label；

首先创建一个枚举类，这里我觉得我该写一篇关于枚举的博客，虽说不咋用。。。。。。

 public enum Gender {
         // 通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错
         // 赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
         MAN("MAN"), WOMEN("WOMEN");

         private final String value;

         // 构造器默认也只能是private, 从而保证构造函数只能在内部使用
         Gender(String value) {
             this.value = value;
         }

         public String getValue() {
             return value;
         }
     }

配置config

         JsonConfig config = new JsonConfig();
         config.registerJsonValueProcessor(Gender.class, new JsonValueProcessor() {
             @Override
             public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
                 if (value instanceof Gender) {
                     Gender tmpValue = (Gender) value;
                     return tmpValue.getValue();
                 }
                 return value.toString();
             }

             @Override
             public Object processArrayValue(Object arg0, JsonConfig arg1) {
                 // TODO Auto-generated method stub
                 return null;
             }
         });

在处理json的时候可能有提供一些封装好的API，但是掌握基础是很重要的。。。。。。。