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

在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;
   
10. 
    
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);
    
26. 
    
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);
    
38. 
    
39.         return jsonArray.toString();
    
40.     }
    
41. 
    
42.     /***
    
43.      * 将JSON对象数组序列化为JSON文本
    
44.      * @param jsonArray
    
45.      * @return
    
46.      */
    
47.     public static String toJSONString(JSONArray jsonArray)
    
48.     {
    
49.         return jsonArray.toString();
    
50.     }
    
51. 
    
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();
    
70. 
    
71.         JSONArray jsonArray = JSONArray.fromObject(object);
    
72. 
    
73.         Iterator it = jsonArray.iterator();
    
74.         while (it.hasNext())
    
75.         {
    
76.             JSONObject jsonObject = (JSONObject) it.next();
    
77. 
    
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.         }
    
86. 
    
87.         return arrayList;
    
88.     }
    
89. 
    
90.     /***
    
91.      * 将对象转换为Collection对象
    
92.      * @param object
    
93.      * @return
    
94.      */
    
95.     public static Collection toCollection(Object object)
    
96.     {
    
97.         JSONArray jsonArray = JSONArray.fromObject(object);
    
98. 
    
99.         return JSONArray.toCollection(jsonArray);
    
100.     }
     
101. 
     
102.     /***
     
103.      * 将对象转换为JSON对象数组
     
104.      * @param object
     
105.      * @return
     
106.      */
     
107.     public static JSONArray toJSONArray(Object object)
     
108.     {
     
109.         return JSONArray.fromObject(object);
     
110.     }
     
111. 
     
112.     /***
     
113.      * 将对象转换为JSON对象
     
114.      * @param object
     
115.      * @return
     
116.      */
     
117.     public static JSONObject toJSONObject(Object object)
     
118.     {
     
119.         return JSONObject.fromObject(object);
     
120.     }
     
121. 
     
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.         }
     
138. 
     
139.         return data;
     
140.     }
     
141. 
     
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.     }
     
167. 
     
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.     }
     
179. 
     
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);
     
190. 
     
191.         return JSONArray.toList(jsonArray, objectClass);
     
192.     }
     
193. 
     
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.     }
     
205. 
     
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);
     
216. 
     
217.         return (T) JSONObject.toBean(jsonObject, beanClass);
     
218.     }
     
219. 
     
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);
     
235. 
     
236.         T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
     
237.         List<D> detailList = JSONUtils.toList(jsonArray, detailClass);
     
238. 
     
239.         try
     
240.         {
     
241.             BeanUtils.setProperty(mainEntity, detailName, detailList);
     
242.         }
     
243.         catch (Exception ex)
     
244.         {
     
245.             throw new RuntimeException("主从关系JSON反序列化实体失败！");
     
246.         }
     
247. 
     
248.         return mainEntity;
     
249.     }
     
250. 
     
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);
     
271. 
     
272.         T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
     
273.         List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1);
     
274.         List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2);
     
275. 
     
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.         }
     
285. 
     
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);
     
313. 
     
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);
     
318. 
     
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.         }
     
329. 
     
330.         return mainEntity;
     
331.     }
     
332. 
     
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. }