參考效果：xml轉json

java xml轉map

1. package xml2map;  
2. import java.io.File;  
3. import java.io.IOException;  
4. import java.io.StringWriter;  
5. import java.util.ArrayList;  
6. import java.util.HashMap;  
7. import java.util.Iterator;  
8. import java.util.LinkedHashMap;  
9. import java.util.List;  
10. import
     java.util.Map;  
11. import net.sf.json.JSON;  
12. import net.sf.json.JSONObject;  
13. import org.apache.commons.io.FileUtils;  
14. import org.dom4j.Attribute;  
15. import org.dom4j.Document;  
16. import org.dom4j.DocumentException;  
17. import org.dom4j.DocumentHelper;  
18. import org.dom4j.Element;  
19. import org.dom4j.io.OutputFormat;  
20. import org.dom4j.io.XMLWriter;  
21. /** 
22.  * xml轉map，map轉xml 帶屬性  
23.  * http://happyqing.iteye.com/blog/2316275  
24.  * @author happyqing 
25.  * @since 2016.8.8 
26.  */  
27. @SuppressWarnings({ "rawtypes", "unchecked" })  
28. public class XmlUtil {  
29.     public static void main(String[] args) throws DocumentException, IOException {  
30.         String textFromFile = FileUtils.readFileToString(new File("D:/workspace/workspace_3.7/xml2map/src/xml2json/sample.xml"),"UTF-8");  
31.         Map<String, Object> map = xml2map(textFromFile, false);  
32.         // long begin = System.currentTimeMillis();  
33.         // for(int i=0; i<1000; i++){  
34.         // map = (Map<String, Object>) xml2mapWithAttr(doc.getRootElement());  
35.         // }  
36.         // System.out.println("耗時:"+(System.currentTimeMillis()-begin));  
37.         JSON json = JSONObject.fromObject(map);  
38.         System.out.println(json.toString(1)); // 格式化輸出  
39.         Document doc = map2xml(map, "root");  
40.         //Document doc = map2xml(map); //map中含有根節點的鍵  
41.         System.out.println(formatXml(doc));  
42.     }  
43.     /** 
44.      * xml轉map 不帶屬性 
45.      * @param xmlStr 
46.      * @param needRootKey 是否需要在返回的map里加根節點鍵 
47.      * @return 
48.      * @throws DocumentException 
49.      */  
50.     public static Map xml2map(String xmlStr, boolean needRootKey) throws DocumentException {  
51.         Document doc = DocumentHelper.parseText(xmlStr);  
52.         Element root = doc.getRootElement();  
53.         Map<String, Object> map = (Map<String, Object>) xml2map(root);  
54.         if(root.elements().size()==0 && root.attributes().size()==0){  
55.             return map;  
56.         }  
57.         if(needRootKey){  
58.             //在返回的map里加根節點鍵（如果需要）  
59.             Map<String, Object> rootMap = new HashMap<String, Object>();  
60.             rootMap.put(root.getName(), map);  
61.             return rootMap;  
62.         }  
63.         return map;  
64.     }  
65.     /** 
66.      * xml轉map 帶屬性 
67.      * @param xmlStr 
68.      * @param needRootKey 是否需要在返回的map里加根節點鍵 
69.      * @return 
70.      * @throws DocumentException 
71.      */  
72.     public static Map xml2mapWithAttr(String xmlStr, boolean needRootKey) throws DocumentException {  
73.         Document doc = DocumentHelper.parseText(xmlStr);  
74.         Element root = doc.getRootElement();  
75.         Map<String, Object> map = (Map<String, Object>) xml2mapWithAttr(root);  
76.         if(root.elements().size()==0 && root.attributes().size()==0){  
77.             return map; //根節點只有一個文字內容  
78.         }  
79.         if(needRootKey){  
80.             //在返回的map里加根節點鍵（如果需要）  
81.             Map<String, Object> rootMap = new HashMap<String, Object>();  
82.             rootMap.put(root.getName(), map);  
83.             return rootMap;  
84.         }  
85.         return map;  
86.     }  
87.     /** 
88.      * xml轉map 不帶屬性 
89.      * @param e 
90.      * @return 
91.      */  
92.     private static Map xml2map(Element e) {  
93.         Map map = new LinkedHashMap();  
94.         List list = e.elements();  
95.         if (list.size() > 0) {  
96.             for (int i = 0; i < list.size(); i++) {  
97.                 Element iter = (Element) list.get(i);  
98.                 List mapList = new ArrayList();  
99.                 if (iter.elements().size() > 0) {  
100.                     Map m = xml2map(iter);  
101.                     if (map.get(iter.getName()) != null) {  
102.                         Object obj = map.get(iter.getName());  
103.                         if (!(obj instanceof List)) {  
104.                             mapList = new ArrayList();  
105.                             mapList.add(obj);  
106.                             mapList.add(m);  
107.                         }  
108.                         if (obj instanceof List) {  
109.                             mapList = (List) obj;  
110.                             mapList.add(m);  
111.                         }  
112.                         map.put(iter.getName(), mapList);  
113.                     } else  
114.                         map.put(iter.getName(), m);  
115.                 } else {  
116.                     if (map.get(iter.getName()) != null) {  
117.                         Object obj = map.get(iter.getName());  
118.                         if (!(obj instanceof List)) {  
119.                             mapList = new ArrayList();  
120.                             mapList.add(obj);  
121.                             mapList.add(iter.getText());  
122.                         }  
123.                         if (obj instanceof List) {  
124.                             mapList = (List) obj;  
125.                             mapList.add(iter.getText());  
126.                         }  
127.                         map.put(iter.getName(), mapList);  
128.                     } else  
129.                         map.put(iter.getName(), iter.getText());  
130.                 }  
131.             }  
132.         } else  
133.             map.put(e.getName(), e.getText());  
134.         return map;  
135.     }  
136.     /** 
137.      * xml轉map 帶屬性 
138.      * @param e 
139.      * @return 
140.      */  
141.     private static Map xml2mapWithAttr(Element element) {  
142.         Map<String, Object> map = new LinkedHashMap<String, Object>();  
143.         List<Element> list = element.elements();  
144.         List<Attribute> listAttr0 = element.attributes(); // 當前節點的所有屬性的list  
145.         for (Attribute attr : listAttr0) {  
146.             map.put("@" + attr.getName(), attr.getValue());  
147.         }  
148.         if (list.size() > 0) {  
149.             for (int i = 0; i < list.size(); i++) {  
150.                 Element iter = list.get(i);  
151.                 List mapList = new ArrayList();  
152.                 if (iter.elements().size() > 0) {  
153.                     Map m = xml2mapWithAttr(iter);  
154.                     if (map.get(iter.getName()) != null) {  
155.                         Object obj = map.get(iter.getName());  
156.                         if (!(obj instanceof List)) {  
157.                             mapList = new ArrayList();  
158.                             mapList.add(obj);  
159.                             mapList.add(m);  
160.                         }  
161.                         if (obj instanceof List) {  
162.                             mapList = (List) obj;  
163.                             mapList.add(m);  
164.                         }  
165.                         map.put(iter.getName(), mapList);  
166.                     } else  
167.                         map.put(iter.getName(), m);  
168.                 } else {  
169.                     List<Attribute> listAttr = iter.attributes(); // 當前節點的所有屬性的list  
170.                     Map<String, Object> attrMap = null;  
171.                     boolean hasAttributes = false;  
172.                     if (listAttr.size() > 0) {  
173.                         hasAttributes = true;  
174.                         attrMap = new LinkedHashMap<String, Object>();  
175.                         for (Attribute attr : listAttr) {  
176.                             attrMap.put("@" + attr.getName(), attr.getValue());  
177.                         }  
178.                     }  
179.                     if (map.get(iter.getName()) != null) {  
180.                         Object obj = map.get(iter.getName());  
181.                         if (!(obj instanceof List)) {  
182.                             mapList = new ArrayList();  
183.                             mapList.add(obj);  
184.                             // mapList.add(iter.getText());  
185.                             if (hasAttributes) {  
186.                                 attrMap.put("#text", iter.getText());  
187.                                 mapList.add(attrMap);  
188.                             } else {  
189.                                 mapList.add(iter.getText());  
190.                             }  
191.                         }  
192.                         if (obj instanceof List) {  
193.                             mapList = (List) obj;  
194.                             // mapList.add(iter.getText());  
195.                             if (hasAttributes) {  
196.                                 attrMap.put("#text", iter.getText());  
197.                                 mapList.add(attrMap);  
198.                             } else {  
199.                                 mapList.add(iter.getText());  
200.                             }  
201.                         }  
202.                         map.put(iter.getName(), mapList);  
203.                     } else {  
204.                         // map.put(iter.getName(), iter.getText());  
205.                         if (hasAttributes) {  
206.                             attrMap.put("#text", iter.getText());  
207.                             map.put(iter.getName(), attrMap);  
208.                         } else {  
209.                             map.put(iter.getName(), iter.getText());  
210.                         }  
211.                     }  
212.                 }  
213.             }  
214.         } else {  
215.             // 根節點的  
216.             if (listAttr0.size() > 0) {  
217.                 map.put("#text", element.getText());  
218.             } else {  
219.                 map.put(element.getName(), element.getText());  
220.             }  
221.         }  
222.         return map;  
223.     }  
224.     /** 
225.      * map轉xml map中沒有根節點的鍵 
226.      * @param map 
227.      * @param rootName 
228.      * @throws DocumentException 
229.      * @throws IOException 
230.      */  
231.     public static Document map2xml(Map<String, Object> map, String rootName) throws DocumentException, IOException