java xml转map map转xml 带属性

参考效果:xml转json

java xml转json json转xml
http://happyqing.iteye.com/blog/2316142

 

java xml转map

Java代码   收藏代码
  1. package xml2map;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.io.StringWriter;  
  6. import java.util.ArrayList;  
  7. import java.util.HashMap;  
  8. import java.util.Iterator;  
  9. import java.util.LinkedHashMap;  
  10. import java.util.List;  
  11. import java.util.Map;  
  12.   
  13. import net.sf.json.JSON;  
  14. import net.sf.json.JSONObject;  
  15.   
  16. import org.apache.commons.io.FileUtils;  
  17. import org.dom4j.Attribute;  
  18. import org.dom4j.Document;  
  19. import org.dom4j.DocumentException;  
  20. import org.dom4j.DocumentHelper;  
  21. import org.dom4j.Element;  
  22. import org.dom4j.io.OutputFormat;  
  23. import org.dom4j.io.XMLWriter;  
  24.   
  25. /** 
  26.  * xml转map,map转xml 带属性  
  27.  * http://happyqing.iteye.com/blog/2316275  
  28.  * @author happyqing 
  29.  * @since 2016.8.8 
  30.  */  
  31. @SuppressWarnings({ "rawtypes""unchecked" })  
  32. public class XmlUtil {  
  33.     public static void main(String[] args) throws DocumentException, IOException {  
  34.         String textFromFile = FileUtils.readFileToString(new File("D:/workspace/workspace_3.7/xml2map/src/xml2json/sample.xml"),"UTF-8");  
  35.         Map<String, Object> map = xml2map(textFromFile, false);  
  36.         // long begin = System.currentTimeMillis();  
  37.         // for(int i=0; i<1000; i++){  
  38.         // map = (Map<String, Object>) xml2mapWithAttr(doc.getRootElement());  
  39.         // }  
  40.         // System.out.println("耗时:"+(System.currentTimeMillis()-begin));  
  41.         JSON json = JSONObject.fromObject(map);  
  42.         System.out.println(json.toString(1)); // 格式化输出  
  43.           
  44.         Document doc = map2xml(map, "root");  
  45.         //Document doc = map2xml(map); //map中含有根节点的键  
  46.         System.out.println(formatXml(doc));  
  47.     }  
  48.           
  49.     /** 
  50.      * xml转map 不带属性 
  51.      * @param xmlStr 
  52.      * @param needRootKey 是否需要在返回的map里加根节点键 
  53.      * @return 
  54.      * @throws DocumentException 
  55.      */  
  56.     public static Map xml2map(String xmlStr, boolean needRootKey) throws DocumentException {  
  57.         Document doc = DocumentHelper.parseText(xmlStr);  
  58.         Element root = doc.getRootElement();  
  59.         Map<String, Object> map = (Map<String, Object>) xml2map(root);  
  60.         if(root.elements().size()==0 && root.attributes().size()==0){  
  61.             return map;  
  62.         }  
  63.         if(needRootKey){  
  64.             //在返回的map里加根节点键(如果需要)  
  65.             Map<String, Object> rootMap = new HashMap<String, Object>();  
  66.             rootMap.put(root.getName(), map);  
  67.             return rootMap;  
  68.         }  
  69.         return map;  
  70.     }  
  71.   
  72.     /** 
  73.      * xml转map 带属性 
  74.      * @param xmlStr 
  75.      * @param needRootKey 是否需要在返回的map里加根节点键 
  76.      * @return 
  77.      * @throws DocumentException 
  78.      */  
  79.     public static Map xml2mapWithAttr(String xmlStr, boolean needRootKey) throws DocumentException {  
  80.         Document doc = DocumentHelper.parseText(xmlStr);  
  81.         Element root = doc.getRootElement();  
  82.         Map<String, Object> map = (Map<String, Object>) xml2mapWithAttr(root);  
  83.         if(root.elements().size()==0 && root.attributes().size()==0){  
  84.             return map; //根节点只有一个文本内容  
  85.         }  
  86.         if(needRootKey){  
  87.             //在返回的map里加根节点键(如果需要)  
  88.             Map<String, Object> rootMap = new HashMap<String, Object>();  
  89.             rootMap.put(root.getName(), map);  
  90.             return rootMap;  
  91.         }  
  92.         return map;  
  93.     }  
  94.   
  95.     /** 
  96.      * xml转map 不带属性 
  97.      * @param e 
  98.      * @return 
  99.      */  
  100.     private static Map xml2map(Element e) {  
  101.         Map map = new LinkedHashMap();  
  102.         List list = e.elements();  
  103.         if (list.size() > 0) {  
  104.             for (int i = 0; i < list.size(); i++) {  
  105.                 Element iter = (Element) list.get(i);  
  106.                 List mapList = new ArrayList();  
  107.   
  108.                 if (iter.elements().size() > 0) {  
  109.                     Map m = xml2map(iter);  
  110.                     if (map.get(iter.getName()) != null) {  
  111.                         Object obj = map.get(iter.getName());  
  112.                         if (!(obj instanceof List)) {  
  113.                             mapList = new ArrayList();  
  114.                             mapList.add(obj);  
  115.                             mapList.add(m);  
  116.                         }  
  117.                         if (obj instanceof List) {  
  118.                             mapList = (List) obj;  
  119.                             mapList.add(m);  
  120.                         }  
  121.                         map.put(iter.getName(), mapList);  
  122.                     } else  
  123.                         map.put(iter.getName(), m);  
  124.                 } else {  
  125.                     if (map.get(iter.getName()) != null) {  
  126.                         Object obj = map.get(iter.getName());  
  127.                         if (!(obj instanceof List)) {  
  128.                             mapList = new ArrayList();  
  129.                             mapList.add(obj);  
  130.                             mapList.add(iter.getText());  
  131.                         }  
  132.                         if (obj instanceof List) {  
  133.                             mapList = (List) obj;  
  134.                             mapList.add(iter.getText());  
  135.                         }  
  136.                         map.put(iter.getName(), mapList);  
  137.                     } else  
  138.                         map.put(iter.getName(), iter.getText());  
  139.                 }  
  140.             }  
  141.         } else  
  142.             map.put(e.getName(), e.getText());  
  143.         return map;  
  144.     }  
  145.   
  146.     /** 
  147.      * xml转map 带属性 
  148.      * @param e 
  149.      * @return 
  150.      */  
  151.     private static Map xml2mapWithAttr(Element element) {  
  152.         Map<String, Object> map = new LinkedHashMap<String, Object>();  
  153.   
  154.         List<Element> list = element.elements();  
  155.         List<Attribute> listAttr0 = element.attributes(); // 当前节点的所有属性的list  
  156.         for (Attribute attr : listAttr0) {  
  157.             map.put("@" + attr.getName(), attr.getValue());  
  158.         }  
  159.         if (list.size() > 0) {  
  160.   
  161.             for (int i = 0; i < list.size(); i++) {  
  162.                 Element iter = list.get(i);  
  163.                 List mapList = new ArrayList();  
  164.   
  165.                 if (iter.elements().size() > 0) {  
  166.                     Map m = xml2mapWithAttr(iter);  
  167.                     if (map.get(iter.getName()) != null) {  
  168.                         Object obj = map.get(iter.getName());  
  169.                         if (!(obj instanceof List)) {  
  170.                             mapList = new ArrayList();  
  171.                             mapList.add(obj);  
  172.                             mapList.add(m);  
  173.                         }  
  174.                         if (obj instanceof List) {  
  175.                             mapList = (List) obj;  
  176.                             mapList.add(m);  
  177.                         }  
  178.                         map.put(iter.getName(), mapList);  
  179.                     } else  
  180.                         map.put(iter.getName(), m);  
  181.                 } else {  
  182.   
  183.                     List<Attribute> listAttr = iter.attributes(); // 当前节点的所有属性的list  
  184.                     Map<String, Object> attrMap = null;  
  185.                     boolean hasAttributes = false;  
  186.                     if (listAttr.size() > 0) {  
  187.                         hasAttributes = true;  
  188.                         attrMap = new LinkedHashMap<String, Object>();  
  189.                         for (Attribute attr : listAttr) {  
  190.                             attrMap.put("@" + attr.getName(), attr.getValue());  
  191.                         }  
  192.                     }  
  193.   
  194.                     if (map.get(iter.getName()) != null) {  
  195.                         Object obj = map.get(iter.getName());  
  196.                         if (!(obj instanceof List)) {  
  197.                             mapList = new ArrayList();  
  198.                             mapList.add(obj);  
  199.                             // mapList.add(iter.getText());  
  200.                             if (hasAttributes) {  
  201.                                 attrMap.put("#text", iter.getText());  
  202.                                 mapList.add(attrMap);  
  203.                             } else {  
  204.                                 mapList.add(iter.getText());  
  205.                             }  
  206.                         }  
  207.                         if (obj instanceof List) {  
  208.                             mapList = (List) obj;  
  209.                             // mapList.add(iter.getText());  
  210.                             if (hasAttributes) {  
  211.                                 attrMap.put("#text", iter.getText());  
  212.                                 mapList.add(attrMap);  
  213.                             } else {  
  214.                                 mapList.add(iter.getText());  
  215.                             }  
  216.                         }  
  217.                         map.put(iter.getName(), mapList);  
  218.                     } else {  
  219.                         // map.put(iter.getName(), iter.getText());  
  220.                         if (hasAttributes) {  
  221.                             attrMap.put("#text", iter.getText());  
  222.                             map.put(iter.getName(), attrMap);  
  223.                         } else {  
  224.                             map.put(iter.getName(), iter.getText());  
  225.                         }  
  226.                     }  
  227.                 }  
  228.             }  
  229.         } else {  
  230.             // 根节点的  
  231.             if (listAttr0.size() > 0) {  
  232.                 map.put("#text", element.getText());  
  233.             } else {  
  234.                 map.put(element.getName(), element.getText());  
  235.             }  
  236.         }  
  237.         return map;  
  238.     }  
  239.       
  240.     /** 
  241.      * map转xml map中没有根节点的键 
  242.      * @param map 
  243.      * @param rootName 
  244.      * @throws DocumentException 
  245.      * @throws IOException 
  246.      */  
  247.     public static Document map2xml(Map<String, Object> map, String rootName) throws DocumentException, IOException  {  
  248.         Document doc = DocumentHelper.createDocument();  
  249.         Element root = DocumentHelper.createElement(rootName);  
  250.         doc.add(root);  
  251.         map2xml(map, root);  
  252.         //System.out.println(doc.asXML());  
  253.         //System.out.println(formatXml(doc));  
  254.         return doc;  
  255.     }  
  256.       
  257.     /** 
  258.      * map转xml map中含有根节点的键 
  259.      * @param map 
  260.      * @throws DocumentException 
  261.      * @throws IOException 
  262.      */  
  263.     public static Document map2xml(Map<String, Object> map) throws DocumentException, IOException  {  
  264.         Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();  
  265.         if(entries.hasNext()){ //获取第一个键创建根节点  
  266.             Map.Entry<String, Object> entry = entries.next();  
  267.             Document doc = DocumentHelper.createDocument();  
  268.             Element root = DocumentHelper.createElement(entry.getKey());  
  269.             doc.add(root);  
  270.             map2xml((Map)entry.getValue(), root);  
  271.             //System.out.println(doc.asXML());  
  272.             //System.out.println(formatXml(doc));  
  273.             return doc;  
  274.         }  
  275.         return null;  
  276.     }  
  277.       
  278.     /** 
  279.      * map转xml 
  280.      * @param map 
  281.      * @param body xml元素 
  282.      * @return 
  283.      */  
  284.     private static Element map2xml(Map<String, Object> map, Element body) {  
  285.         Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();  
  286.         while (entries.hasNext()) {  
  287.             Map.Entry<String, Object> entry = entries.next();  
  288.             String key = entry.getKey();  
  289.             Object value = entry.getValue();  
  290.             if(key.startsWith("@")){    //属性  
  291.                 body.addAttribute(key.substring(1, key.length()), value.toString());  
  292.             } else if(key.equals("#text")){ //有属性时的文本  
  293.                 body.setText(value.toString());  
  294.             } else {  
  295.                 if(value instanceof java.util.List ){  
  296.                     List list = (List)value;  
  297.                     Object obj;  
  298.                     for(int i=0; i<list.size(); i++){  
  299.                         obj = list.get(i);  
  300.                         //list里是map或String,不会存在list里直接是list的,  
  301.                         if(obj instanceof java.util.Map){  
  302.                             Element subElement = body.addElement(key);  
  303.                             map2xml((Map)list.get(i), subElement);  
  304.                         } else {  
  305.                             body.addElement(key).setText((String)list.get(i));  
  306.                         }  
  307.                     }  
  308.                 } else if(value instanceof java.util.Map ){  
  309.                     Element subElement = body.addElement(key);  
  310.                     map2xml((Map)value, subElement);  
  311.                 } else {  
  312.                     body.addElement(key).setText(value.toString());  
  313.                 }  
  314.             }  
  315.             //System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
  316.         }  
  317.         return body;  
  318.     }  
  319.       
  320.     /** 
  321.      * 格式化输出xml 
  322.      * @param xmlStr 
  323.      * @return 
  324.      * @throws DocumentException 
  325.      * @throws IOException 
  326.      */  
  327.     public static String formatXml(String xmlStr) throws DocumentException, IOException  {  
  328.         Document document = DocumentHelper.parseText(xmlStr);  
  329.         return formatXml(document);  
  330.     }  
  331.       
  332.     /** 
  333.      * 格式化输出xml 
  334.      * @param document 
  335.      * @return 
  336.      * @throws DocumentException 
  337.      * @throws IOException 
  338.      */  
  339.     public static String formatXml(Document document) throws DocumentException, IOException  {  
  340.         // 格式化输出格式  
  341.         OutputFormat format = OutputFormat.createPrettyPrint();  
  342.         //format.setEncoding("UTF-8");  
  343.         StringWriter writer = new StringWriter();  
  344.         // 格式化输出流  
  345.         XMLWriter xmlWriter = new XMLWriter(writer, format);  
  346.         // 将document写入到输出流  
  347.         xmlWriter.write(document);  
  348.         xmlWriter.close();  
  349.         return writer.toString();  
  350.     }  
  351.   
  352. }  

 

参考:

Java xml文件转换为map集合

http://my.oschina.net/u/2253208/blog/500877
java xml转map 高级版
http://xuelianbobo.iteye.com/blog/2153384

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值