JsonUtil工具类

1. package comm;
2. import java.text.SimpleDateFormat;
3. import java.util.ArrayList;
4. import java.util.Collection;
5. import java.util.Date;
6. import java.util.HashMap;
7. import java.util.Iterator;
8. import java.util.List;
9. import java.util.Map;
10. import net.sf.ezmorph.MorpherRegistry;
11. import net.sf.ezmorph.object.DateMorpher;
12. import net.sf.json.JSONArray;
13. import net.sf.json.JSONObject;
14. import net.sf.json.JsonConfig;
15. import net.sf.json.processors.JsonValueProcessor;
16. import net.sf.json.util.JSONUtils;
17. import net.sf.json.xml.XMLSerializer;
18. public class JsonUtil {
19. /**
20. * 设置日期转换格式
21. */
22. static {
23. //注册器
24. MorpherRegistry mr = JSONUtils.getMorpherRegistry();
25. //可转换的日期格式，即Json串中可以出现以下格式的日期与时间
26. DateMorpher dm = new DateMorpher(new String[] { Util.YYYY_MM_DD,
27. Util.YYYY_MM_DD_HH_MM_ss, Util.HH_MM_ss, Util.YYYYMMDD,
28. Util.YYYYMMDDHHMMSS, Util.HHMMss });
29. mr.registerMorpher(dm);
30. }
31. /**
32. * 从json串转换成实体对象
33. * @param jsonObjStr e.g. {'name':'get','dateAttr':'2009-11-12'}
34. * @param clazz Person.class
35. * @return
36. */
37. public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz) {
38. return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz);
39. }
40. /**
41. * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean
42. * @param jsonObjStr e.g. {'data':[{'name':'get'},{'name':'set'}]}
43. * @param clazz e.g. MyBean.class
44. * @param classMap e.g. classMap.put("data", Person.class)
45. * @return Object
46. */
47. public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
48. return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz, classMap);
49. }
50. /**
51. * 把一个json数组串转换成普通数组
52. * @param jsonArrStr  e.g. ['get',1,true,null]
53. * @return Object[]
54. */
55. public static Object[] getArrFromJsonArrStr(String jsonArrStr) {
56. return JSONArray.fromObject(jsonArrStr).toArray();
57. }
58. /**
59. * 把一个json数组串转换成实体数组
60. * @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
61. * @param clazz e.g. Person.class
62. * @return Object[]
63. */
64. public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz) {
65. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
66. Object[] objArr = new Object[jsonArr.size()];
67. for (int i = 0; i < jsonArr.size(); i++) {
68. objArr[i] = JSONObject.toBean(jsonArr.getJSONObject(i), clazz);
69. }
70. return objArr;
71. }
72. /**
73. * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean
74. * @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
75. * @param clazz e.g. MyBean.class
76. * @param classMap e.g. classMap.put("data", Person.class)
77. * @return Object[]
78. */
79. public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz,
80. Map classMap) {
81. JSONArray array = JSONArray.fromObject(jsonArrStr);
82. Object[] obj = new Object[array.size()];
83. for (int i = 0; i < array.size(); i++) {
84. JSONObject jsonObject = array.getJSONObject(i);
85. obj[i] = JSONObject.toBean(jsonObject, clazz, classMap);
86. }
87. return obj;
88. }
89. /**
90. * 把一个json数组串转换成存放普通类型元素的集合
91. * @param jsonArrStr  e.g. ['get',1,true,null]
92. * @return List
93. */
94. public static List getListFromJsonArrStr(String jsonArrStr) {
95. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
96. List list = new ArrayList();
97. for (int i = 0; i < jsonArr.size(); i++) {
98. list.add(jsonArr.get(i));
99. }
100. return list;
101. }
102. /**
103. * 把一个json数组串转换成集合，且集合里存放的为实例Bean
104. * @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
105. * @param clazz
106. * @return List
107. */
108. public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {
109. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
110. List list = new ArrayList();
111. for (int i = 0; i < jsonArr.size(); i++) {
112. list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));
113. }
114. return list;
115. }
116. /**
117. * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean
118. * @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
119. * @param clazz e.g. MyBean.class
120. * @param classMap e.g. classMap.put("data", Person.class)
121. * @return List
122. */
123. public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap) {
124. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
125. List list = new ArrayList();
126. for (int i = 0; i < jsonArr.size(); i++) {
127. list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));
128. }
129. return list;
130. }
131. /**
132. * 把json对象串转换成map对象
133. * @param jsonObjStr e.g. {'name':'get','int':1,'double',1.1,'null':null}
134. * @return Map
135. */
136. public static Map getMapFromJsonObjStr(String jsonObjStr) {
137. JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);
138. Map map = new HashMap();
139. for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
140. String key = (String) iter.next();
141. map.put(key, jsonObject.get(key));
142. }
143. return map;
144. }
145. /**
146. * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean
147. * @param jsonObjStr e.g. {'data1':{'name':'get'},'data2':{'name':'set'}}
148. * @param clazz e.g. Person.class
149. * @return Map
150. */
151. public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz) {
152. JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);
153. Map map = new HashMap();
154. for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
155. String key = (String) iter.next();
156. map.put(key, JSONObject.toBean(jsonObject.getJSONObject(key), clazz));
157. }
158. return map;
159. }
160. /**
161. * 把json对象串转换成map对象，且map对象里存放的其他实体Bean还含有另外实体Bean
162. * @param jsonObjStr e.g. {'mybean':{'data':[{'name':'get'}]}}
163. * @param clazz e.g. MyBean.class
164. * @param classMap  e.g. classMap.put("data", Person.class)
165. * @return Map
166. */
167. public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
168. JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);
169. Map map = new HashMap();
170. for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
171. String key = (String) iter.next();
172. map.put(key, JSONObject
173. .toBean(jsonObject.getJSONObject(key), clazz, classMap));
174. }
175. return map;
176. }
177. /**
178. * 把实体Bean、Map对象、数组、列表集合转换成Json串
179. * @param obj
180. * @return
181. * @throws Exception String
182. */
183. public static String getJsonStr(Object obj) {
184. String jsonStr = null;
185. //Json配置
186. JsonConfig jsonCfg = new JsonConfig();
187. //注册日期处理器
188. jsonCfg.registerJsonValueProcessor(java.util.Date.class,
189. new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));
190. if (obj == null) {
191. return "{}";
192. }
193. if (obj instanceof Collection || obj instanceof Object[]) {
194. jsonStr = JSONArray.fromObject(obj, jsonCfg).toString();
195. } else {
196. jsonStr = JSONObject.fromObject(obj, jsonCfg).toString();
197. }
198. return jsonStr;
199. }
200. /**
201. * 把json串、数组、集合(collection map)、实体Bean转换成XML
202. * XMLSerializer API：
203. * http://json-lib.sourceforge.net/apidocs/net/sf/json/xml/XMLSerializer.html
204. * 具体实例请参考：
205. * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
206. * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
207. * @param obj
208. * @return
209. * @throws Exception String
210. */
211. public static String getXMLFromObj(Object obj) {
212. XMLSerializer xmlSerial = new XMLSerializer();
213. //Json配置
214. JsonConfig jsonCfg = new JsonConfig();
215. //注册日期处理器
216. jsonCfg.registerJsonValueProcessor(java.util.Date.class,
217. new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));
218. if ((String.class.isInstance(obj) && String.valueOf(obj).startsWith("["))
219. || obj.getClass().isArray() || Collection.class.isInstance(obj)) {
220. JSONArray jsonArr = JSONArray.fromObject(obj, jsonCfg);
221. return xmlSerial.write(jsonArr);
222. } else {
223. JSONObject jsonObj = JSONObject.fromObject(obj, jsonCfg);
224. return xmlSerial.write(jsonObj);
225. }
226. }
227. /**
228. * 从XML转json串
229. * @param xml
230. * @return String
231. */
232. public static String getJsonStrFromXML(String xml) {
233. XMLSerializer xmlSerial = new XMLSerializer();
234. return String.valueOf(xmlSerial.read(xml));
235. }
236. }
237. /**
238. * json日期值处理器实现
239. * (C) 2009-9-11, jzj
240. */
241. class JsonDateValueProcessor implements JsonValueProcessor {
242. private String format = Util.YYYY_MM_DD_HH_MM_ss;
243. public JsonDateValueProcessor() {
244. }
245. public JsonDateValueProcessor(String format) {
246. this.format = format;
247. }
248. public Object processArrayValue(Object value, JsonConfig jsonConfig) {
249. return process(value, jsonConfig);
250. }
251. public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
252. return process(value, jsonConfig);
253. }
254. private Object process(Object value, JsonConfig jsonConfig) {
255. if (value instanceof Date) {
256. String str = new SimpleDateFormat(format).format((Date) value);
257. return str;
258. }
259. return value == null ? null : value.toString();
260. }
261. public String getFormat() {
262. return format;
263. }
264. public void setFormat(String format) {
265. this.format = format;
266. }
267. }

JsonUtilTest

1. package comm.test;
2. import java.text.SimpleDateFormat;
3. import java.util.ArrayList;
4. import java.util.Date;
5. import java.util.HashMap;
6. import java.util.Iterator;
7. import java.util.LinkedHashMap;
8. import java.util.LinkedHashSet;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.Set;
12. import junit.framework.TestCase;
13. import comm.JsonUtil;
14. /**
15. * JsonUtil测试类
16. * (C) 2009-9-11, jzj
17. */
18. public class JsonUtilTest extends TestCase {
19. /**
20. * 从json串转换成实体对象，且实体中Date属性能正确转换
21. *  void
22. */
23. public void testGetDtoFromJsonObjStr1() {
24. String json = "{'name':'get','dateAttr':'2009-11-12'}";
25. Person ps = (Person) JsonUtil.getDtoFromJsonObjStr(json, Person.class);
26. //print: get
27. System.out.println(ps.getName());
28. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
29. //print: 2009-11-12
30. System.out.println(sdf.format(ps.getDateAttr()));
31. }
32. /**
33. * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean
34. *  void
35. */
36. public void testGetDtoFromJsonObjStr3() {
37. String json = "{'data':[{'name':'get'},{'name':'set'}]}";
38. Map classMap = new HashMap();
39. classMap.put("data", Person.class);
40. MyBean myBean = (MyBean) JsonUtil.getDtoFromJsonObjStr(json, MyBean.class,
41. classMap);
42. //print: class comm.test.Person name =get
43. System.out.println(myBean.getData().get(0).getClass() + " name ="
44. + ((Person) myBean.getData().get(0)).getName());
45. //print: class comm.test.Person name =set
46. System.out.println(myBean.getData().get(1).getClass() + " name ="
47. + ((Person) myBean.getData().get(1)).getName());
48. }
49. /**
50. * 把一个json数组串转换成普通数组
51. *  void
52. */
53. public void testGetArrFromJsonArrStr() {
54. String json = "['get',1,true,null]";
55. Object[] objArr = JsonUtil.getArrFromJsonArrStr(json);
56. for (int i = 0; i < objArr.length; i++) {
57. System.out.println(objArr[i].getClass() + " " + objArr[i]);
58. }
59. /*  print:
60. class java.lang.String get
61. class java.lang.Integer 1
62. class java.lang.Boolean true
63. class net.sf.json.JSONNull null
64. */
65. }
66. /**
67. * 把一个json数组串转换成实体数组
68. *  void
69. */
70. public void testGetDtoArrFromJsonArrStr1() {
71. String json = "[{'name':'get'},{'name':'set'}]";
72. Object[] objArr = JsonUtil.getDtoArrFromJsonArrStr(json, Person.class);
73. for (int i = 0; i < objArr.length; i++) {
74. System.out.println(objArr[i].getClass() + " name = "
75. + ((Person) objArr[i]).getName());
76. }
77. /*  print:
78. class comm.test.Person name = get
79. class comm.test.Person name = set
80. */
81. }
82. /**
83. * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean
84. *  void
85. */
86. public void testGetDtoArrFromJsonArrStr2() {
87. String json = "[{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]";
88. Map classMap = new HashMap();
89. classMap.put("data", Person.class);
90. Object[] objArr = JsonUtil.getDtoArrFromJsonArrStr(json, MyBean.class, classMap);
91. for (int i = 0; i < objArr.length; i++) {
92. System.out.println(((MyBean) objArr[i]).getData().get(0).getClass()
93. + " name = "
94. + ((Person) ((MyBean) objArr[i]).getData().get(0)).getName());
95. }
96. /*  print:
97. class comm.test.Person name = get
98. class comm.test.Person name = set
99. */
100. }
101. /**
102. * 把一个json数组串转换成存放普通类型元素的集合
103. *  void
104. */
105. public void testGetListFromJsonArrStr1() {
106. String json = "['get',1,true,null]";
107. List list = JsonUtil.getListFromJsonArrStr(json);
108. for (int i = 0; i < list.size(); i++) {
109. System.out.println(list.get(i).getClass() + " " + list.get(i));
110. }
111. /*  print:
112. class java.lang.String get
113. class java.lang.Integer 1
114. class java.lang.Boolean true
115. class net.sf.json.JSONNull null
116. */
117. }
118. /**
119. * 把一个json数组串转换成集合，且集合里存放的为实例Bean
120. *  void
121. */
122. public void testGetListFromJsonArrStr2() {
123. String json = "[{'name':'get'},{'name':'set'}]";
124. List list = JsonUtil.getListFromJsonArrStr(json, Person.class);
125. for (int i = 0; i < list.size(); i++) {
126. System.out.println(list.get(i).getClass() + " name = "
127. + ((Person) list.get(i)).getName());
128. }
129. /*  print:
130. class comm.test.Person name = get
131. class comm.test.Person name = set
132. */
133. }
134. /**
135. * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean
136. *  void
137. */
138. public void testGetListFromJsonArrStr3() {
139. String json = "[{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]";
140. Map classMap = new HashMap();
141. classMap.put("data", Person.class);
142. List list = JsonUtil.getListFromJsonArrStr(json, MyBean.class, classMap);
143. for (int i = 0; i < list.size(); i++) {
144. System.out.println(((MyBean) list.get(i)).getData().get(0).getClass()
145. + " name = "
146. + ((Person) ((MyBean) list.get(i)).getData().get(0)).getName());
147. }
148. /*  print:
149. class comm.test.Person name = get
150. class comm.test.Person name = set
151. */
152. }
153. /**
154. * 把json对象串转换成map对象
155. *  void
156. */
157. public void testGetMapFromJsonObjStr() {
158. String json = "{'name':'get','int':1,'double':1.1,'null':null}";
159. Map map = JsonUtil.getMapFromJsonObjStr(json);
160. for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {
161. System.out.println(map.get(iter.next()).getClass());
162. }
163. /*  print:
164. class java.lang.Double
165. class net.sf.json.JSONNull
166. class java.lang.Integer
167. class java.lang.String
168. */
169. }
170. /**
171. * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean
172. *  void
173. */
174. public void testGetMapFromJsonObjStr2() {
175. String json = "{'data1':{'name':'get'},'data2':{'name':'set'}}";
176. Map map = JsonUtil.getMapFromJsonObjStr(json, Person.class);
177. for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {
178. String key = (String) iter.next();
179. System.out.println(map.get(key).getClass() + " name="
180. + ((Person) map.get(key)).getName());
181. }
182. /*  print:
183. class comm.test.Person name=set
184. class comm.test.Person name=get
185. */
186. }
187. /**
188. * 把json对象串转换成map对象，且map对象里
189. * 存放的其他实体Bean还含有另外实体Bean
190. *  void
191. */
192. public void testGetMapFromJsonObjStr3() {
193. String json = "{'mybean':{'data':[{'name':'get'}]}}";
194. Map classMap = new HashMap();
195. classMap.put("data", Person.class);
196. Map map = JsonUtil.getMapFromJsonObjStr(json, MyBean.class, classMap);
197. for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {
198. String key = (String) iter.next();
199. Object o = ((MyBean) map.get(key)).getData().get(0);
200. System.out.println(o.getClass() + " name=" + ((Person) o).getName());
201. }
202. /*  print:
203. class comm.test.Person name=get
204. */
205. }
206. /**
207. * 实体Bean转json串
208. *  void
209. */
210. public void testgetJsonStr1() {
211. Person ps = new Person();
212. ps.setDateAttr(new Date());
213. ps.setName("get");
214. MyBean myBean = new MyBean();
215. List list = new ArrayList();
216. list.add(ps);
217. myBean.setData(list);
218. //print: {"data":[{"dateAttr":"2009-09-12 07:24:54","name":"get"}]}
219. System.out.println(JsonUtil.getJsonStr(myBean));
220. }
221. /**
222. * map转json串
223. *  void
224. */
225. public void testgetJsonStr2() {
226. Person ps = new Person();
227. ps.setDateAttr(new Date());
228. ps.setName("get");
229. Map map = new LinkedHashMap();
230. map.put("person1", ps);
231. //print: {"person1":{"dateAttr":"2009-09-12 07:24:27","name":"get"}}
232. System.out.println(JsonUtil.getJsonStr(map));
233. }
234. /**
235. * 数组转json串
236. *  void
237. */
238. public void testgetJsonStr3() {
239. Person ps = new Person();
240. ps.setDateAttr(new Date());
241. ps.setName("get");
242. Person[] personArr = new Person[1];
243. personArr[0] = ps;
244. //print: [{"dateAttr":"2009-09-12 07:23:54","name":"get"}]
245. System.out.println(JsonUtil.getJsonStr(personArr));
246. }
247. /**
248. * list转json串
249. *  void
250. */
251. public void testgetJsonStr4() {
252. Person ps = new Person();
253. ps.setDateAttr(new Date());
254. ps.setName("get");
255. List list = new ArrayList();
256. list.add(ps);
257. //print: [{"dateAttr":"2009-09-12 07:22:49","name":"get"}]
258. System.out.println(JsonUtil.getJsonStr(list));
259. }
260. /**
261. * set转json串
262. *  void
263. */
264. public void testgetJsonStr5() {
265. Person ps = new Person();
266. ps.setDateAttr(new Date());
267. ps.setName("get");
268. Set set = new LinkedHashSet();
269. set.add(ps);
270. //print: [{"dateAttr":"2009-09-12 07:22:16","name":"get"}]
271. System.out.println(JsonUtil.getJsonStr(set));
272. }
273. /**
274. * json对象串转XML
275. *  void
276. */
277. public void testGetXMLFromObj1() {
278. System.out.println(JsonUtil
279. .getXMLFromObj("{/"name/":/"json/",/"bool/":true,/"int/":1}"));
280. /*  print:
281. <?xml version="1.0" encoding="UTF-8"?>
282. <o>
283. <bool type="boolean">true</bool>
284. <int type="number">1</int>
285. <name type="string">json</name>
286. </o>
287. */
288. }
289. /**
290. * json数组串转XML
291. *  void
292. */
293. public void testGetXMLFromObj2() {
294. System.out.println(JsonUtil.getXMLFromObj("[1,2,3]"));
295. /*  print:
296. <?xml version="1.0" encoding="UTF-8"?>
297. <a>
298. <e type="number">1</e>
299. <e type="number">2</e>
300. <e type="number">3</e>
301. </a>
302. */
303. }
304. /**
305. * java数组转XML
306. *  void
307. */
308. public void testGetXMLFromObj3() {
309. Person ps = new Person();
310. ps.setDateAttr(new Date());
311. ps.setName("get");
312. Person[] personArr = new Person[2];
313. personArr[0] = ps;
314. System.out.println(JsonUtil.getXMLFromObj(personArr));
315. /*  print:
316. <?xml version="1.0" encoding="UTF-8"?>
317. <a>
318. <e class="object">
319. <dateAttr type="string">2009-09-12 06:58:55</dateAttr>
320. <name type="string">get</name>
321. </e>
322. </a>
323. */
324. }
325. /**
326. * list转XML
327. *  void
328. */
329. public void testGetXMLFromObj4() {
330. Person ps = new Person();
331. ps.setDateAttr(new Date());
332. ps.setName("get");
333. List list = new ArrayList();
334. list.add(ps);
335. System.out.println(JsonUtil.getXMLFromObj(list));
336. /*  print:
337. <?xml version="1.0" encoding="UTF-8"?>
338. <a>
339. <e class="object">
340. <dateAttr type="string">2009-09-12 07:02:31</dateAttr>
341. <name type="string">get</name>
342. </e>
343. </a>
344. */
345. }
346. /**
347. * set转XML
348. * void
349. */
350. public void testGetXMLFromObj5() {
351. Person ps = new Person();
352. ps.setDateAttr(new Date());
353. ps.setName("get");
354. Set set = new LinkedHashSet();
355. set.add(ps);
356. System.out.println(JsonUtil.getXMLFromObj(set));
357. /*  print:
358. <?xml version="1.0" encoding="UTF-8"?>
359. <a>
360. <e class="object">
361. <dateAttr type="string">2009-09-12 07:04:38</dateAttr>
362. <name type="string">get</name>
363. </e>
364. </a>
365. */
366. }
367. /**
368. * map转XML
369. *  void
370. */
371. public void testGetXMLFromObj6() {
372. Person ps = new Person();
373. ps.setDateAttr(new Date());
374. ps.setName("get");
375. Map map = new HashMap();
376. map.put("person1", ps);
377. System.out.println(JsonUtil.getXMLFromObj(map));
378. /*  print:
379. <?xml version="1.0" encoding="UTF-8"?>
380. <o>
381. <person1 class="object">
382. <dateAttr type="string">2009-09-12 07:08:35</dateAttr>
383. <name type="string">get</name>
384. </person1>
385. </o>
386. */
387. }
388. /**
389. * 实体Bean转XML
390. *  void
391. */
392. public void testGetXMLFromObj7() {
393. Person ps = new Person();
394. ps.setDateAttr(new Date());
395. ps.setName("get");
396. System.out.println(JsonUtil.getXMLFromObj(ps));
397. /*  print:
398. <?xml version="1.0" encoding="UTF-8"?>
399. <o>
400. <dateAttr type="string">2009-09-12 07:13:02</dateAttr>
401. <name type="string">get</name>
402. </o>
403. */
404. }
405. /**
406. * 从XML对象串转json串
407. *  void
408. */
409. public void testGetJsonStrFromXML1() {
410. String xml = "<o><dateAttr type='string'>2009-09-12 07:13:02</dateAttr>"
411. + "<name type='string'>get</name></o>";
412. //print: {"dateAttr":"2009-09-12 07:13:02","name":"get"}
413. System.out.println(JsonUtil.getJsonStrFromXML(xml));
414. }
415. /**
416. * 从XML数组串转json串
417. *  void
418. */
419. public void testGetJsonStrFromXML2() {
420. String xml = "<a class='array'><e class='object'><dateAttr type='string'>2009-09-12 07:04:38</dateAttr>"
421. + "<name type='string'>get</name></e></a>";
422. //print: [{"dateAttr":"2009-09-12 07:04:38","name":"get"}]
423. System.out.println(JsonUtil.getJsonStrFromXML(xml));
424. }
425. }