xdzbb

xdzbb

关注
发信
关注(28)粉丝(399)

在JAVA中封装JSONUtils工具类及使用

在JAVA中用json-lib-2.3-jdk15.jar包中提供了JSONObject和JSONArray基类，用于JSON的序列化和反序列化的操作。但是我们更习惯将其进一步封装，达到更好的重用。

封装后的JSON工具类JSONUtils.java代码如下：

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.List;
  6. import java.util.Map;
  7. import net.sf.json.JSONArray;
  8. import net.sf.json.JSONObject;
  9. import org.apache.commons.beanutils.BeanUtils;

  11. public class JSONUtils
  12. {
  13.     /**
  14.      *
  15.      * @author wangwei JSON工具类
  16.      * @param
  17.      *
  18.      */
  19.     
  20.     /***
  21.      * 将List对象序列化为JSON文本
  22.      */
  23.     public static <T> String toJSONString(List<T> list)
  24.     {
  25.         JSONArray jsonArray = JSONArray.fromObject(list);

  27.         return jsonArray.toString();
  28.     }
  29.     
  30.     /***
  31.      * 将对象序列化为JSON文本
  32.      * @param object
  33.      * @return
  34.      */
  35.     public static String toJSONString(Object object)
  36.     {
  37.         JSONArray jsonArray = JSONArray.fromObject(object);

  39.         return jsonArray.toString();
  40.     }

  42.     /***
  43.      * 将JSON对象数组序列化为JSON文本
  44.      * @param jsonArray
  45.      * @return
  46.      */
  47.     public static String toJSONString(JSONArray jsonArray)
  48.     {
  49.         return jsonArray.toString();
  50.     }

  52.     /***
  53.      * 将JSON对象序列化为JSON文本
  54.      * @param jsonObject
  55.      * @return
  56.      */
  57.     public static String toJSONString(JSONObject jsonObject)
  58.     {
  59.         return jsonObject.toString();
  60.     }
  61.     
  62.     /***
  63.      * 将对象转换为List对象
  64.      * @param object
  65.      * @return
  66.      */
  67.     public static List toArrayList(Object object)
  68.     {
  69.         List arrayList = new ArrayList();

  71.         JSONArray jsonArray = JSONArray.fromObject(object);

  73.         Iterator it = jsonArray.iterator();
  74.         while (it.hasNext())
  75.         {
  76.             JSONObject jsonObject = (JSONObject) it.next();

  78.             Iterator keys = jsonObject.keys();
  79.             while (keys.hasNext())
  80.             {
  81.                 Object key = keys.next();
  82.                 Object value = jsonObject.get(key);
  83.                 arrayList.add(value);
  84.             }
  85.         }

  87.         return arrayList;
  88.     }

  90.     /***
  91.      * 将对象转换为Collection对象
  92.      * @param object
  93.      * @return
  94.      */
  95.     public static Collection toCollection(Object object)
  96.     {
  97.         JSONArray jsonArray = JSONArray.fromObject(object);

  99.         return JSONArray.toCollection(jsonArray);
  100.     }

  102.     /***
  103.      * 将对象转换为JSON对象数组
  104.      * @param object
  105.      * @return
  106.      */
  107.     public static JSONArray toJSONArray(Object object)
  108.     {
  109.         return JSONArray.fromObject(object);
  110.     }

  112.     /***
  113.      * 将对象转换为JSON对象
  114.      * @param object
  115.      * @return
  116.      */
  117.     public static JSONObject toJSONObject(Object object)
  118.     {
  119.         return JSONObject.fromObject(object);
  120.     }

  122.     /***
  123.      * 将对象转换为HashMap
  124.      * @param object
  125.      * @return
  126.      */
  127.     public static HashMap toHashMap(Object object)
  128.     {
  129.         HashMap<String, Object> data = new HashMap<String, Object>();
  130.         JSONObject jsonObject = JSONUtils.toJSONObject(object);
  131.         Iterator it = jsonObject.keys();
  132.         while (it.hasNext())
  133.         {
  134.             String key = String.valueOf(it.next());
  135.             Object value = jsonObject.get(key);
  136.             data.put(key, value);
  137.         }

  139.         return data;
  140.     }

  142.     /***
  143.      * 将对象转换为List>
  144.      * @param object
  145.      * @return
  146.      */
  147.     // 返回非实体类型(Map)的List
  148.     public static List<Map<String, Object>> toList(Object object)
  149.     {
  150.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
  151.         JSONArray jsonArray = JSONArray.fromObject(object);
  152.         for (Object obj : jsonArray)
  153.         {
  154.             JSONObject jsonObject = (JSONObject) obj;
  155.             Map<String, Object> map = new HashMap<String, Object>();
  156.             Iterator it = jsonObject.keys();
  157.             while (it.hasNext())
  158.             {
  159.                 String key = (String) it.next();
  160.                 Object value = jsonObject.get(key);
  161.                 map.put((String) key, value);
  162.             }
  163.             list.add(map);
  164.         }
  165.         return list;
  166.     }

  168.     /***
  169.      * 将JSON对象数组转换为传入类型的List
  170.      * @param
  171.      * @param jsonArray
  172.      * @param objectClass
  173.      * @return
  174.      */
  175.     public static <T> List<T> toList(JSONArray jsonArray, Class<T> objectClass)
  176.     {
  177.         return JSONArray.toList(jsonArray, objectClass);
  178.     }

  180.     /***
  181.      * 将对象转换为传入类型的List
  182.      * @param
  183.      * @param jsonArray
  184.      * @param objectClass
  185.      * @return
  186.      */
  187.     public static <T> List<T> toList(Object object, Class<T> objectClass)
  188.     {
  189.         JSONArray jsonArray = JSONArray.fromObject(object);

  191.         return JSONArray.toList(jsonArray, objectClass);
  192.     }

  194.     /***
  195.      * 将JSON对象转换为传入类型的对象
  196.      * @param
  197.      * @param jsonObject
  198.      * @param beanClass
  199.      * @return
  200.      */
  201.     public static <T> T toBean(JSONObject jsonObject, Class<T> beanClass)
  202.     {
  203.         return (T) JSONObject.toBean(jsonObject, beanClass);
  204.     }

  206.     /***
  207.      * 将将对象转换为传入类型的对象
  208.      * @param
  209.      * @param object
  210.      * @param beanClass
  211.      * @return
  212.      */
  213.     public static <T> T toBean(Object object, Class<T> beanClass)
  214.     {
  215.         JSONObject jsonObject = JSONObject.fromObject(object);

  217.         return (T) JSONObject.toBean(jsonObject, beanClass);
  218.     }

  220.     /***
  221.      * 将JSON文本反序列化为主从关系的实体
  222.      * @param 泛型T 代表主实体类型
  223.      * @param 泛型D 代表从实体类型
  224.      * @param jsonString JSON文本
  225.      * @param mainClass 主实体类型
  226.      * @param detailName 从实体类在主实体类中的属性名称
  227.      * @param detailClass 从实体类型
  228.      * @return
  229.      */
  230.     public static <T, D> T toBean(String jsonString, Class<T> mainClass,
  231.             String detailName, Class<D> detailClass)
  232.     {
  233.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  234.         JSONArray jsonArray = (JSONArray) jsonObject.get(detailName);

  236.         T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
  237.         List<D> detailList = JSONUtils.toList(jsonArray, detailClass);

  239.         try
  240.         {
  241.             BeanUtils.setProperty(mainEntity, detailName, detailList);
  242.         }
  243.         catch (Exception ex)
  244.         {
  245.             throw new RuntimeException("主从关系JSON反序列化实体失败！");
  246.         }

  248.         return mainEntity;
  249.     }

  251.     /***
  252.      * 将JSON文本反序列化为主从关系的实体
  253.      * @param 泛型T 代表主实体类型
  254.      * @param 泛型D1 代表从实体类型
  255.      * @param 泛型D2 代表从实体类型
  256.      * @param jsonString JSON文本
  257.      * @param mainClass 主实体类型
  258.      * @param detailName1 从实体类在主实体类中的属性
  259.      * @param detailClass1 从实体类型
  260.      * @param detailName2 从实体类在主实体类中的属性
  261.      * @param detailClass2 从实体类型
  262.      * @return
  263.      */
  264.     public static <T, D1, D2> T toBean(String jsonString, Class<T> mainClass,
  265.             String detailName1, Class<D1> detailClass1, String detailName2,
  266.             Class<D2> detailClass2)
  267.     {
  268.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  269.         JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
  270.         JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);

  272.         T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
  273.         List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1);
  274.         List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2);

  276.         try
  277.         {
  278.             BeanUtils.setProperty(mainEntity, detailName1, detailList1);
  279.             BeanUtils.setProperty(mainEntity, detailName2, detailList2);
  280.         }
  281.         catch (Exception ex)
  282.         {
  283.             throw new RuntimeException("主从关系JSON反序列化实体失败！");
  284.         }

  286.         return mainEntity;
  287.     }
  288.     
  289.     /***
  290.      * 将JSON文本反序列化为主从关系的实体
  291.      * @param 泛型T 代表主实体类型
  292.      * @param 泛型D1 代表从实体类型
  293.      * @param 泛型D2 代表从实体类型
  294.      * @param jsonString JSON文本
  295.      * @param mainClass 主实体类型
  296.      * @param detailName1 从实体类在主实体类中的属性
  297.      * @param detailClass1 从实体类型
  298.      * @param detailName2 从实体类在主实体类中的属性
  299.      * @param detailClass2 从实体类型
  300.      * @param detailName3 从实体类在主实体类中的属性
  301.      * @param detailClass3 从实体类型
  302.      * @return
  303.      */
  304.     public static <T, D1, D2, D3> T toBean(String jsonString,
  305.             Class<T> mainClass, String detailName1, Class<D1> detailClass1,
  306.             String detailName2, Class<D2> detailClass2, String detailName3,
  307.             Class<D3> detailClass3)
  308.     {
  309.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  310.         JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
  311.         JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);
  312.         JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3);

  314.         T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
  315.         List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1);
  316.         List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2);
  317.         List<D3> detailList3 = JSONUtils.toList(jsonArray3, detailClass3);

  319.         try
  320.         {
  321.             BeanUtils.setProperty(mainEntity, detailName1, detailList1);
  322.             BeanUtils.setProperty(mainEntity, detailName2, detailList2);
  323.             BeanUtils.setProperty(mainEntity, detailName3, detailList3);
  324.         }
  325.         catch (Exception ex)
  326.         {
  327.             throw new RuntimeException("主从关系JSON反序列化实体失败！");
  328.         }

  330.         return mainEntity;
  331.     }

  333.     /***
  334.      * 将JSON文本反序列化为主从关系的实体
  335.      * @param 主实体类型
  336.      * @param jsonString JSON文本
  337.      * @param mainClass 主实体类型
  338.      * @param detailClass 存放了多个从实体在主实体中属性名称和类型
  339.      * @return
  340.      */
  341.     public static <T> T toBean(String jsonString, Class<T> mainClass,
  342.             HashMap<String, Class> detailClass)
  343.     {
  344.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  345.         T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
  346.         for (Object key : detailClass.keySet())
  347.         {
  348.             try
  349.             {
  350.                 Class value = (Class) detailClass.get(key);
  351.                 BeanUtils.setProperty(mainEntity, key.toString(), value);
  352.             }
  353.             catch (Exception ex)
  354.             {
  355.                 throw new RuntimeException("主从关系JSON反序列化实体失败！");
  356.             }
  357.         }
  358.         return mainEntity;
  359.     }
  360. }

上面代码中所需的jar包有：json-lib-2.3-jdk15.jar，commons-beanutils-1.8.0.jar

12-21 02:28
Powered by LMLPHP ©2024 xdzbb 0.078431