JSON — Java与JSON数据互转

转换时Bean所要求的：

• 被转换的Bean必需是public的。
• Bean被转换的属性一定要有对应的get方法，且一定要是public的。
• Bean中不能用引用自身的this的属性，否则运行时出现et.sf.json.JSONException: There is a cycle in the hierarchy!异常
• json-lib包转换时，不能以null为键名，否则运行报net.sf.json.JSONException:java.lang.NullPointerException:JSON keys must not be null nor the 'null' string.
• json-lib包转换时， 转换成XML元素key的名字要符合XML元素标签的命名规则，否则会报nu.xom.IllegalNameException: NCNames cannot start with the character 25异常

转换时问题：

• 如果某个Bean中存在存放数组的Map属性，则使用org.json包中的JSONObject直接封装时得不到正确的JSON，要用JSONArray对数组进行封装处理，否则为转换JavaScript中的空的对象{}，但能使用json-lib包很好地解决这一问题

两种包的比较：

• json-lib包比org.json要易使用些，至少没有烦人的JSONExcetipn捕获异常了。
• json-lib对Bean的支持比org.json要强，特别是对bean中内嵌属性的支持较好。

json-lib依赖包：

1. commons-beanutils-1.8.0.jar
2. commons-collections-3.2.1.jar
3. commons-lang-2.4.jar
4. commons-logging-1.1.1.jar
5. ezmorph-1.0.6.jar
6. json-lib-2.3-jdk15.jar
7. xom-1.2.2.jar

• 实例所用到的三个Bean

1. package bean;
2. /**
3. * 创建Address实体类的POJO
4. * (C) 2009-9-1, jzj
5. */
6. public class Address {
7. private String street;//街道
8. private String city;//城市
9. private int zip;//邮编
10. private String tel;//第一个电话号码
11. private String telTwo;//第二个电话号码
12. public Address() {
13. }
14. public Address(String street, String city, int zip, String tel, String telTwo) {
15. this.street = street;
16. this.city = city;
17. this.zip = zip;
18. this.tel = tel;
19. this.telTwo = telTwo;
20. }
21. //以下是get set 方法
22. ......
23. }

1. package bean;
2. import java.util.ArrayList;
3. import java.util.HashMap;
4. import java.util.HashSet;
5. import java.util.List;
6. import java.util.Map;
7. import java.util.Set;
8. /**
9. * POJO 定义各种类型的属性，便于测试
10. * (C) 2009-9-7, jzj
11. */
12. public class OtherBean {
13. /*
14. * 定义一个整数属性
15. */
16. ;
17. /*
18. * 定义一个浮点数属性
19. */
20. .1f;
21. /*
22. * 定义一个布尔型属性
23. */
24. private boolean booleanAttr = true;
25. /*
26. * 定义一个空的属性
27. */
28. private Address nullAttr = null;
29. /*
30. * 定义一个字符属性
31. */
32. private char charAttr = 'j';
33. /*
34. * 定义一个包装类整型属性
35. */
36. );
37. /*
38. * 定义一个字符属性
39. */
40. private String strAttr = "jzj";
41. /*
42. * 定义一个引用其他Bean的属性
43. */
44. , "541-322-1723",
45. "546-338-1100");
46. /*
47. * 定义一个字符数组属性
48. */
49. private String[] strArrAttr = new String[] { "str1", "str2" };
50. /*
51. * 定义一个字符数组属性
52. */
53. private char[] charArrAttr = new char[] { 'j', 's', 'o', 'n' };
54. /*
55. * 定义一个list集合属性
56. */
57. private List listAttr = new ArrayList();
58. /*
59. * 定义一个set集合属性
60. */
61. private Set hasSetAttr = new HashSet();
62. /*
63. * 定义一个hashMap为存放数组的map属性，如果用
64. * org.json包转换时则得不到正确有结果json-lib则可以
65. */
66. private Map hashMapAttr = new HashMap();
67. /**
68. * 构造器，初始化集合
69. */
70. public OtherBean() {
71. List tempList = new ArrayList();
72. tempList.add("one");
73. tempList.add("two");
74. listAttr.add("jiang");
75. listAttr.add(tempList);
76. , "561-832-3180",
77. "531-133-9098"));
78. hasSetAttr.addAll(listAttr);
79. hashMapAttr.put("first", new String[][] { { "1", "2" }, { "3" } });
80. hashMapAttr.put("second", new String[][] { { "one", "two" }, { "three" } });
81. }
82. //以下是get set方法
83. ......
84. }

1. package bean;
2. import java.util.ArrayList;
3. import java.util.Date;
4. import java.util.HashMap;
5. import java.util.HashSet;
6. import java.util.List;
7. import java.util.Map;
8. import java.util.Set;
9. import net.sf.json.JSONFunction;
10. /**
11. * POJO 定义各种类型的属性，便于测试
12. * (C) 2009-9-7, jzj
13. */
14. public class Bean {
15. //其他属性略，在OtherBean的基础上加上了otherBeanAttr属性而已
16. ......
17. /*
18. * 定义一个引用复杂实例的属性，这样可以测试属性递归情况
19. * print：以上各属性值
20. */
21. private OtherBean otherBeanAttr = new OtherBean();
22. //以下是get set 方法
23. ......
24. }

• 使用json-lib包进行转换

1. package jsonlib;
2. import java.io.BufferedOutputStream;
3. import java.io.ByteArrayOutputStream;
4. import java.io.IOException;
5. import java.util.ArrayList;
6. import java.util.Date;
7. import java.util.LinkedHashMap;
8. import java.util.List;
9. import java.util.Map;
10. import junit.framework.TestCase;
11. import net.sf.ezmorph.bean.MorphDynaBean;
12. import net.sf.json.JSONArray;
13. import net.sf.json.JSONFunction;
14. import net.sf.json.JSONObject;
15. import net.sf.json.JsonConfig;
16. import net.sf.json.xml.XMLSerializer;
17. import org.dom4j.Document;
18. import org.dom4j.DocumentException;
19. import org.dom4j.DocumentHelper;
20. import org.dom4j.io.OutputFormat;
21. import org.dom4j.io.XMLWriter;
22. import bean.Address;
23. import bean.Bean;
24. /**
25. * 使用json-lib包进行bean、json、xml的数据转换
26. * (C) 2009-9-6,jzj
27. */
28. public class JSONFormatTest extends TestCase {
29. public void testDate2Json() {
30. JSONObject jsonObj = JSONObject.fromObject(new Date());
31. // print: {"date":10,"day":4,"hours":2,"minutes":2,
32. //"month":8,"seconds":38,"time":1252519358062,"timezoneOffset":-480,"year":109}
33. System.out.println(jsonObj.toString());
34. }
35. public void testArray2Json() {
36. JSONArray jsonArr = JSONArray.fromObject(new String[][] { { "one", "two" },
37. { "three", "four" } });
38. // print: [["one","two"],["three","four"]]
39. System.out.println(jsonArr.toString());
40. //json串转JSONArray
41. JSONArray jsArr = JSONArray.fromObject(jsonArr.toString());
42. //从JSONObject读取数据
43. //print: three
44. )).get(0));
45. System.out.println("\n");
46. }
47. public void testList2Json() {
48. List list = new ArrayList();
49. ));
50. list.add(new Boolean(true));
51. list.add(new Character('j'));
52. list.add(new char[] { 'j', 's', 'o', 'n' });
53. list.add(null);
54. list.add("json");
55. list.add(new String[] { "json", "-", "lib" });
56. list.add(new JSONFunction(new String[] { "i" }, "alert(i)"));
57. , "561-832-3180",
58. "531-133-9098"));
59. //list转JSONArray
60. JSONArray jsArr = JSONArray.fromObject(list);
61. /*
62. * list转JSON串
63. * print: [1,true,"j",["j","s","o","n"],null,"json",["json","-","lib"],
64. * function(i){ alert(i) },{"city":"Seattle, WA","street":"P.O BOX 54534",
65. * "tel":"561-832-3180","telTwo":"531-133-9098","zip":42452}]
66. */
67. ));
68. //从JSON串到JSONArray
69. jsArr = JSONArray.fromObject(jsArr.toString());
70. //--从JSONArray里读取
71. //print: json
72. )).get(0));
73. //print: address.city = Seattle, WA
74. )).get("city"));
75. System.out.println("\n");
76. }
77. public void testMap2Json() throws DocumentException {
78. Map map = new LinkedHashMap();
79. ));
80. map.put("boolean", new Boolean(true));
81. map.put("char", new Character('j'));
82. map.put("charArr", new char[] { 'j', 's', 'o', 'n' });
83. //注:不能以null为键名，否则运行报net.sf.json.JSONException: java.lang.NullPointerException:
84. //JSON keys must not be null nor the 'null' string.
85. map.put("nullAttr", null);
86. map.put("str", "json");
87. map.put("strArr", new String[] { "json", "-", "lib" });
88. map.put("jsonFunction", new JSONFunction(new String[] { "i" }, "alert(i)"));
89. ,
90. "561-832-3180", "531-133-9098"));
91. //map转JSONArray
92. JSONObject jsObj = JSONObject.fromObject(map);
93. /*
94. * map转JSON串
95. *
96. * print:{"integer":1,"boolean":true,"char":"j","charArr":["j","s","o","n"],
97. * "nullAttr":null,"str":"json","strArr":["json","-","lib"],"jsonFunction":
98. * function(i){ alert(i) },"address":{"city":"Seattle, WA","street":"P.O BOX 54534",
99. * "tel":"561-832-3180","telTwo":"531-133-9098","zip":42452}}
100. */
101. ));
102. //从JSON串到JSONObject
103. jsObj = JSONObject.fromObject(jsObj.toString());
104. //--从JSONObject里读取
105. //print: json
106. System.out.println(jsObj.get("str"));
107. //print: address.city = Seattle, WA
108. System.out.println("address.city = "
109. + ((JSONObject) jsObj.get("address")).get("city"));
110. //--从动态Bean里读取数据，由于不能转换成具体的Bean，感觉没有多大用处
111. MorphDynaBean mdBean = (MorphDynaBean) JSONObject.toBean(jsObj);
112. //print: json
113. System.out.println(mdBean.get("str"));
114. //print: address.city = Seattle, WA
115. System.out.println("address.city = "
116. + ((MorphDynaBean) mdBean.get("address")).get("city"));
117. //--JSONObject转XML
118. XMLSerializer xmlSerial = new XMLSerializer();
119. xmlSerial.setRootName("root");
120. /*注：转换成XML元素key的名字要符合XML元素标签的命名规则，否则会报
121. nu.xom.IllegalNameException: NCNames cannot start with the character 25异常
122. print:
123. <?xml version="1.0" encoding="UTF-8"?>
124. <root>
125. <address class="object">
126. <city type="string">Seattle, WA</city>
127. <street type="string">P.O BOX 54534</street>
128. <tel type="string">561-832-3180</tel>
129. <telTwo type="string">531-133-9098</telTwo>
130. <zip type="number">42452</zip>
131. </address>
132. <boolean type="boolean">true</boolean>
133. <char type="string">j</char>
134. <charArr class="array">
135. <e type="string">j</e>
136. <e type="string">s</e>
137. <e type="string">o</e>
138. <e type="string">n</e>
139. </charArr>
140. <integer type="number">1</integer>
141. <jsonFunction type="function" params="i"><![CDATA[alert(i)]]></jsonFunction>
142. <nullAttr class="object" null="true"/>
143. <str type="string">json</str>
144. <strArr class="array">
145. <e type="string">json</e>
146. <e type="string">-</e>
147. <e type="string">lib</e>
148. </strArr>
149. </root>
150. */
151. System.out.println(write2XML(DocumentHelper.parseText(xmlSerial.write(jsObj))));
152. System.out.println("\n");
153. }
154. public void testBean2Json() throws DocumentException {
155. Bean bean = new Bean();
156. JSONObject jsonObj = JSONObject.fromObject(bean);
157. /*print:
158. {
159. "booleanAttr": true,
160. "charArrAttr":     [
161. "j",
162. "s",
163. "o",
164. "n"
165. ],
166. "charAttr": "j",
167. "floatAttr": 1.1,
168. "hasSetAttr":     [
169. "jiang",
170. [
171. "one",
172. "two"
173. ],
174. {
175. "city": "Seattle, WA",
176. "street": "P.O BOX 54534",
177. "tel": "561-832-3180",
178. "telTwo": "531-133-9098",
179. "zip": 42452
180. }
181. ],
182. "hashMapAttr":     {
183. "first":         [
184. [
185. "1",
186. "2"
187. ],
188. ["3"]
189. ],
190. "second":         [
191. [
192. "one",
193. "two"
194. ],
195. ["three"]
196. ]
197. },
198. "intAttr": 1,
199. "intgerAttr": 2,
200. "jsonFunctionAttr": function(name){ alert(name) },
201. "listAttr":     [
202. "jiang",
203. [
204. "one",
205. "two"
206. ],
207. {
208. "city": "Seattle, WA",
209. "street": "P.O BOX 54534",
210. "tel": "561-832-3180",
211. "telTwo": "531-133-9098",
212. "zip": 42452
213. }
214. ],
215. "nullAttr": null,
216. "otherBeanAttr":     {
217. "addrArr":         {
218. "city": "lixian",
219. "street": "changde",
220. "tel": "541-322-1723",
221. "telTwo": "546-338-1100",
222. "zip": 72452
223. },
224. "booleanAttr": true,
225. "charArrAttr":         [
226. "j",
227. "s",
228. "o",
229. "n"
230. ],
231. "charAttr": "j",
232. "floatAttr": 1.1,
233. "hasSetAttr":         [
234. {
235. "city": "Seattle, WA",
236. "street": "P.O BOX 54534",
237. "tel": "561-832-3180",
238. "telTwo": "531-133-9098",
239. "zip": 42452
240. },
241. [
242. "one",
243. "two"
244. ],
245. "jiang"
246. ],
247. "hashMapAttr":         {
248. "first":             [
249. [
250. "1",
251. "2"
252. ],
253. ["3"]
254. ],
255. "second":             [
256. [
257. "one",
258. "two"
259. ],
260. ["three"]
261. ]
262. },
263. "intAttr": 1,
264. "intgerAttr": 2,
265. "listAttr":         [
266. "jiang",
267. [
268. "one",
269. "two"
270. ],
271. {
272. "city": "Seattle, WA",
273. "street": "P.O BOX 54534",
274. "tel": "561-832-3180",
275. "telTwo": "531-133-9098",
276. "zip": 42452
277. }
278. ],
279. "nullAttr": null,
280. "strArrAttr":         [
281. "str1",
282. "str2"
283. ],
284. "strAttr": "jzj"
285. },
286. "strArrAttr":     [
287. "str1",
288. "str2"
289. ],
290. "strAttr": "jzj"
291. }
292. */
293. ));
294. //json转JSONObject
295. jsonObj = JSONObject.fromObject(jsonObj.toString());
296. //print:Seattle, WA
297. ))
298. .get("city"));
299. //--JSONObject转Bean
300. bean = (Bean) JSONObject.toBean(jsonObj, Bean.class);
301. //注:如果Bean里的某个属性存有数组，则数组转换成list存放，但如果数组为bean属性时转换后还是数组
302. //print: 1
303. ))
304. ));
305. //print: j
306. ]);
307. //--Bean转XML
308. XMLSerializer xmlSerial = new XMLSerializer();
309. //设置根节点名
310. xmlSerial.setRootName("root");
311. JsonConfig jc = new JsonConfig();
312. //排除不需要转换的属性，排除otherBeanAttr内部引用属性
313. jc.setExcludes(new String[] { "otherBeanAttr" });
314. jsonObj = JSONObject.fromObject(bean, jc);
315. /*
316. print:
317. <?xml version="1.0" encoding="UTF-8"?>
318. <root>
319. <booleanAttr type="boolean">true</booleanAttr>
320. <charArrAttr class="array">
321. <e type="string">j</e>
322. <e type="string">s</e>
323. <e type="string">o</e>
324. <e type="string">n</e>
325. </charArrAttr>
326. <charAttr type="string">j</charAttr>
327. <floatAttr type="number">1.1</floatAttr>
328. <hasSetAttr class="array">
329. <e type="string">jiang</e>
330. <e class="array">
331. <e type="string">one</e>
332. <e type="string">two</e>
333. </e>
334. <e class="object">
335. <city type="string">Seattle, WA</city>
336. <street type="string">P.O BOX 54534</street>
337. <tel type="string">561-832-3180</tel>
338. <telTwo type="string">531-133-9098</telTwo>
339. <zip type="number">42452</zip>
340. </e>
341. </hasSetAttr>
342. <hashMapAttr class="object">
343. <first class="array">
344. <e class="array">
345. <e type="string">1</e>
346. <e type="string">2</e>
347. </e>
348. <e class="array">
349. <e type="string">3</e>
350. </e>
351. </first>
352. <second class="array">
353. <e class="array">
354. <e type="string">one</e>
355. <e type="string">two</e>
356. </e>
357. <e class="array">
358. <e type="string">three</e>
359. </e>
360. </second>
361. </hashMapAttr>
362. <intAttr type="number">1</intAttr>
363. <intgerAttr type="number">2</intgerAttr>
364. <jsonFunctionAttr type="function" params="name"><![CDATA[alert(name)]]></jsonFunctionAttr>
365. <listAttr class="array">
366. <e type="string">jiang</e>
367. <e class="array">
368. <e type="string">one</e>
369. <e type="string">two</e>
370. </e>
371. <e class="object">
372. <city type="string">Seattle, WA</city>
373. <street type="string">P.O BOX 54534</street>
374. <tel type="string">561-832-3180</tel>
375. <telTwo type="string">531-133-9098</telTwo>
376. <zip type="number">42452</zip>
377. </e>
378. </listAttr>
379. <nullAttr class="object" null="true"/>
380. <strArrAttr class="array">
381. <e type="string">str1</e>
382. <e type="string">str2</e>
383. </strArrAttr>
384. <strAttr type="string">jzj</strAttr>
385. </root>
386. */
387. System.out.println(write2XML(DocumentHelper.parseText(xmlSerial.write(jsonObj))));
388. }
389. private static String write2XML(Document doc) {
390. ByteArrayOutputStream cache = null;
391. try {
392. * 512);
393. OutputFormat of = new OutputFormat();
394. of.setIndent(true);
395. of.setIndent(" ");
396. );
397. of.setNewlines(true);
398. BufferedOutputStream bos = new BufferedOutputStream(cache);
399. XMLWriter xmlWrite = new XMLWriter(bos, of);
400. xmlWrite.write(doc);
401. bos.close();
402. return cache.toString("UTF-8");
403. } catch (IOException e) {
404. }
405. return null;
406. }
407. }

• 使用org.json进行转换

1. package orgjson;
2. import java.io.BufferedOutputStream;
3. import java.io.ByteArrayOutputStream;
4. import java.io.IOException;
5. import java.util.ArrayList;
6. import java.util.Iterator;
7. import java.util.LinkedHashMap;
8. import java.util.List;
9. import java.util.Map;
10. import junit.framework.TestCase;
11. import net.sf.json.JSONFunction;
12. import org.dom4j.Document;
13. import org.dom4j.DocumentException;
14. import org.dom4j.DocumentHelper;
15. import org.dom4j.io.OutputFormat;
16. import org.dom4j.io.XMLWriter;
17. import org.json.JSONArray;
18. import org.json.JSONException;
19. import org.json.JSONObject;
20. import org.json.XML;
21. import bean.Address;
22. import bean.Bean;
23. /**
24. * 使用org.json包进行bean、json、xml的数据转换
25. * (C) 2009-9-6,jzj
26. */
27. public class JSONFormatTest extends TestCase {
28. public void testArray2Json() throws JSONException {
29. JSONArray jsonArr = new JSONArray(new String[][] { { "one", "two" },
30. { "three", "four" } });
31. // print: [["one","two"],["three","four"]]
32. System.out.println(jsonArr.toString());
33. //json串转JSONArray
34. JSONArray jsArr = new JSONArray(jsonArr.toString());
35. //从JSONObject读取数据
36. //print: three
37. )).get(0));
38. System.out.println("\n");
39. }
40. public void testList2Json() throws JSONException {
41. List list = new ArrayList();
42. ));
43. list.add(new Boolean(true));
44. list.add(new Character('j'));
45. list.add(new char[] { 'j', 's', 'o', 'n' });
46. list.add(null);
47. list.add("json");
48. list.add(new String[] { "json", "-", "lib" });
49. list.add(new JSONFunction(new String[] { "i" }, "alert(i)"));
50. , "561-832-3180",
51. "531-133-9098"));
52. //list转JSONArray
53. JSONArray jsArr = new JSONArray(list);
54. /*
55. * list转JSON串
56. * print:
57. [
58. 1,
59. true,
60. "j",
61. [
62. "j",
63. "s",
64. "o",
65. "n"
66. ],
67. null,
68. "json",
69. [
70. "json",
71. "-",
72. "lib"
73. ],
74. "function(i){ alert(i) }",
75. "bean.Address@1cf8583"
76. ]
77. * 注：org.json不支持list中非JSON对象与数组对象外的对象，会直接调用对象的toString方法
78. */
79. ));
80. //从JSON串到JSONArray
81. JSONArray jsArr1 = new JSONArray(jsArr.toString());
82. //--从JSONArray里读取
83. //print: json
84. )).get(0));
85. //不能正确读取对象的信息 print: address.city = bean.Address@1cf8583
86. ));
87. System.out.println("\n");
88. }
89. public void testMap2Json() throws JSONException, DocumentException {
90. Map map = new LinkedHashMap();
91. ));
92. map.put("boolean", new Boolean(true));
93. map.put("char", new Character('j'));
94. map.put("charArr", new char[] { 'j', 's', 'o', 'n' });
95. map.put("null", null);
96. map.put("str", "json");
97. map.put("strArr", new String[] { "json", "-", "lib" });
98. map.put("jsonFunction", new JSONFunction(new String[] { "i" }, "alert(i)"));
99. ,
100. "561-832-3180", "531-133-9098"));
101. //map转JSONArray
102. JSONObject jsObj = new JSONObject(map);
103. /*
104. * map转JSON串
105. * print:
106. {
107. "address": "bean.Address@1cf8583",
108. "boolean": true,
109. "char": "j",
110. "charArr": [
111. "j",
112. "s",
113. "o",
114. "n"
115. ],
116. "integer": 1,
117. "jsonFunction": "function(i){ alert(i) }",
118. "null": null,
119. "str": "json",
120. "strArr": [
121. "json",
122. "-",
123. "lib"
124. ]
125. }
126. */
127. ));
128. //从JSON串到JSONObject
129. jsObj = new JSONObject(jsObj.toString());
130. //--从JSONObject里读取
131. //print: json
132. System.out.println(jsObj.get("str"));
133. //print: address.city = Seattle, WA
134. System.out.println("address.city = " + jsObj.get("address"));
135. //--org.json不支持从JSONObject到Bean的转换
136. //MorphDynaBean mdBean = (MorphDynaBean) JSONObject.toBean(jsObj);
137. //--JSONObject转XML
138. //print:
139. /*
140. <root>
141. <null>null</null>
142. <char>j</char>
143. <integer>1</integer>
144. <address>bean.Address@901887</address>
145. <strArr>json</strArr>
146. <strArr>-</strArr>
147. <strArr>lib</strArr>
148. <charArr>j</charArr>
149. <charArr>s</charArr>
150. <charArr>o</charArr>
151. <charArr>n</charArr>
152. <jsonFunction>function(i){ alert(i) }</jsonFunction>
153. <str>json</str>
154. <boolean>true</boolean>
155. </root>
156. */
157. System.out.println(write2XML(DocumentHelper
158. .parseText(XML.toString(jsObj, "root"))));
159. System.out.println("\n");
160. }
161. /**
162. * 如果某个Bean里含有Map属性，且Map里存放的为数组，此时需要对Map里的数组进一步用
163. * JSONArray包装后才能输出正确结果
164. * @throws JSONException
165. */
166. public void testBeanToJsonStr() throws JSONException {
167. Bean bean = new Bean();
168. JSONObject jsonObj = new JSONObject(bean);
169. try {
170. /* 如果不用JSONArray进行包装转换，则不能得到正确结果，其关键原因是：如果Bean的某属性
171. * 所对应的属性类型为Map时，转换Map中的值所对就代码如下：
172. *  } else if (result instanceof Map) {
173. *      map.put(key, new JSONObject((Map)result, includeSuperClass));
174. * 由于上述代码数组转换成了JSONObject对象了，对应的应该JSONArray
175. */
176. ));
177. //--以下是正确作法
178. //得到Bean的Map属性值
179. Map hashMapAttr = bean.getHashMapAttr();
180. //对hashMap属性用JSONArray进行包装
181. Iterator it = hashMapAttr.entrySet().iterator();
182. //Bean中hashMap属性值转换成map2JsonObj
183. JSONObject map2JsonObj = new JSONObject();
184. while (it.hasNext()) {
185. Map.Entry entry = (Map.Entry) it.next();
186. map2JsonObj.put((String) entry.getKey(), new JSONArray(entry.getValue()));
187. }
188. //置换掉Bean中hashMap属性原有的map对象值，置换后hashMap属性的值为JSONObject对象实例，
189. //而JSONObject对象实例存储了原hashMap中所对应值的所有信息
190. jsonObj.put("hashMap", map2JsonObj);
191. ));
192. //json转JSONObject
193. jsonObj = new JSONObject(jsonObj.toString());
194. //print:Seattle, WA
195. System.out.println(((JSONObject) ((JSONArray) jsonObj.get("hasSetAttr"))
196. )).get("city"));
197. //--Bean转XML
198. //print:
199. System.out.println(XML.toString(jsonObj, "root"));
200. } catch (JSONException e) {
201. e.printStackTrace();
202. }
203. }
204. private static String write2XML(Document doc) {
205. ByteArrayOutputStream cache = null;
206. try {
207. * 512);
208. OutputFormat of = new OutputFormat();
209. of.setIndent(true);
210. of.setIndent(" ");
211. );
212. of.setNewlines(true);
213. BufferedOutputStream bos = new BufferedOutputStream(cache);
214. XMLWriter xmlWrite = new XMLWriter(bos, of);
215. xmlWrite.write(doc);
216. bos.close();
217. return cache.toString("UTF-8");
218. } catch (IOException e) {
219. }
220. return null;
221. }
222. }

源码请参考《JSON入门与实战详解 —— JavaScript、Java与JSON互转》 附件。