java xml与json 相互转换

 

转自：http://blog.csdn.net/arjick/article/details/6251777

 

需要json-lib-2.1-jdk15.jar和xom-1.2.5.jar，maven pom.xml如下：

 

Xml代码  

1. <dependency>  
2.     <groupId>net.sf.json-lib</groupId>  
3.     <artifactId>json-lib</artifactId>  
4.     <version>2.1</version>  
5.     <classifier>jdk15</classifier>  
6. </dependency>  
7.   
8. <dependency>  
9.     <groupId>xom</groupId>  
10.     <artifactId>xom</artifactId>  
11.     <version>1.2.5</version>  
12.     <type>jar</type>  
13.     <scope>compile</scope>  
14. </dependency>  

 

 

Java代码  

1. <p>package com.shine.framework.core.util;</p>  
2. import java.io.ByteArrayOutputStream;  
3. import java.util.ArrayList;  
4. import java.util.HashMap;  
5. import java.util.Iterator;  
6. import java.util.List;  
7. import java.util.Map;  
8.   
9. import net.sf.json.JSON;  
10. import net.sf.json.JSONSerializer;  
11. import net.sf.json.xml.XMLSerializer;  
12.   
13. import org.dom4j.Document;  
14. import org.dom4j.DocumentHelper;  
15. import org.dom4j.Element;  
16. import org.dom4j.io.OutputFormat;  
17. import org.dom4j.io.XMLWriter;  
18.   
19. /** 
20.  * common xml conver utility 
21.  *  
22.  * @author viruscodecn@gmail.com 
23.  * @version Framework 2010.10.26 
24.  * @url http://blog.csdn.net/arjick/article/details/6251777 
25.  */  
26. public class XmlConverUtil {  
27.     /** 
28.      * map to xml xml <node><key label="key1">value1</key><key 
29.      * label="key2">value2</key>......</node> 
30.      *  
31.      * @param map 
32.      * @return 
33.      */  
34.     public static String maptoXml(Map map) {  
35.         Document document = DocumentHelper.createDocument();  
36.         Element nodeElement = document.addElement("node");  
37.         for (Object obj : map.keySet()) {  
38.             Element keyElement = nodeElement.addElement("key");  
39.             keyElement.addAttribute("label", String.valueOf(obj));  
40.             keyElement.setText(String.valueOf(map.get(obj)));  
41.         }  
42.         return doc2String(document);  
43.     }  
44.   
45.     /** 
46.      * list to xml xml <nodes><node><key label="key1">value1</key><key 
47.      * label="key2">value2</key>......</node><node><key 
48.      * label="key1">value1</key><key 
49.      * label="key2">value2</key>......</node></nodes> 
50.      *  
51.      * @param list 
52.      * @return 
53.      */  
54.     public static String listtoXml(List list) throws Exception {  
55.         Document document = DocumentHelper.createDocument();  
56.         Element nodesElement = document.addElement("nodes");  
57.         int i = 0;  
58.         for (Object o : list) {  
59.             Element nodeElement = nodesElement.addElement("node");  
60.             if (o instanceof Map) {  
61.                 for (Object obj : ((Map) o).keySet()) {  
62.                     Element keyElement = nodeElement.addElement("key");  
63.                     keyElement.addAttribute("label", String.valueOf(obj));  
64.                     keyElement.setText(String.valueOf(((Map) o).get(obj)));  
65.                 }  
66.             } else {  
67.                 Element keyElement = nodeElement.addElement("key");  
68.                 keyElement.addAttribute("label", String.valueOf(i));  
69.                 keyElement.setText(String.valueOf(o));  
70.             }  
71.             i++;  
72.         }  
73.         return doc2String(document);  
74.     }  
75.   
76.     /** 
77.      * json to xml {"node":{"key":{"@label":"key1","#text":"value1"}}} conver 
78.      * <o><node class="object"><key class="object" 
79.      * label="key1">value1</key></node></o> 
80.      *  
81.      * @param json 
82.      * @return 
83.      */  
84.     public static String jsontoXml(String json) {  
85.         try {  
86.             XMLSerializer serializer = new XMLSerializer();  
87.             JSON jsonObject = JSONSerializer.toJSON(json);  
88.             return serializer.write(jsonObject);  
89.         } catch (Exception e) {  
90.             e.printStackTrace();  
91.         }  
92.         return null;  
93.     }  
94.   
95.     /** 
96.      * xml to map xml <node><key label="key1">value1</key><key 
97.      * label="key2">value2</key>......</node> 
98.      *  
99.      * @param xml 
100.      * @return 
101.      */  
102.     public static Map xmltoMap(String xml) {  
103.         try {  
104.             Map map = new HashMap();  
105.             Document document = DocumentHelper.parseText(xml);  
106.             Element nodeElement = document.getRootElement();  
107.             List node = nodeElement.elements();  
108.             for (Iterator it = node.iterator(); it.hasNext();) {  
109.                 Element elm = (Element) it.next();  
110.                 map.put(elm.attributeValue("label"), elm.getText());  
111.                 elm = null;  
112.             }  
113.             node = null;  
114.             nodeElement = null;  
115.             document = null;  
116.             return map;  
117.         } catch (Exception e) {  
118.             e.printStackTrace();  
119.         }  
120.         return null;  
121.     }  
122.   
123.     /** 
124.      * xml to list xml <nodes><node><key label="key1">value1</key><key 
125.      * label="key2">value2</key>......</node><node><key 
126.      * label="key1">value1</key><key 
127.      * label="key2">value2</key>......</node></nodes> 
128.      *  
129.      * @param xml 
130.      * @return 
131.      */  
132.     public static List xmltoList(String xml) {  
133.         try {  
134.             List<Map> list = new ArrayList<Map>();  
135.             Document document = DocumentHelper.parseText(xml);  
136.             Element nodesElement = document.getRootElement();  
137.             List nodes = nodesElement.elements();  
138.             for (Iterator its = nodes.iterator(); its.hasNext();) {  
139.                 Element nodeElement = (Element) its.next();  
140.                 Map map = xmltoMap(nodeElement.asXML());  
141.                 list.add(map);  
142.                 map = null;  
143.             }  
144.             nodes = null;  
145.             nodesElement = null;  
146.             document = null;  
147.             return list;  
148.         } catch (Exception e) {  
149.             e.printStackTrace();  
150.         }  
151.         return null;  
152.     }  
153.   
154.     /** 
155.      * xml to json <node><key label="key1">value1</key></node> 转化为 
156.      * {"key":{"@label":"key1","#text":"value1"}} 
157.      *  
158.      * @param xml 
159.      * @return 
160.      */  
161.     public static String xmltoJson(String xml) {  
162.         XMLSerializer xmlSerializer = new XMLSerializer();  
163.         return xmlSerializer.read(xml).toString();  
164.     }  
165.   
166.     /** 
167.      *  
168.      * @param document 
169.      * @return 
170.      */  
171.     public static String doc2String(Document document) {  
172.         String s = "";  
173.         try {  
174.             // 使用输出流来进行转化  
175.             ByteArrayOutputStream out = new ByteArrayOutputStream();  
176.             // 使用UTF-8编码  
177.             OutputFormat format = new OutputFormat("   ", true, "UTF-8");  
178.             XMLWriter writer = new XMLWriter(out, format);  
179.             writer.write(document);  
180.             s = out.toString("UTF-8");  
181.         } catch (Exception ex) {  
182.             ex.printStackTrace();  
183.         }  
184.         return s;  
185.     }  
186. }