Xml转Map工具类

方式一：

package com.sitech.common.utils.xmlSort;

import org.dom4j.*;

import java.util.*;

/**
 * xml字符串转map
 * Created by shihh on 2018/04/16.
 */
public class Xml2MapUtils {
    /**
     * xml转map
     * @param xmlStr
     * @param needRootKey 是否需要在返回的map里加根节点键
     * @return
     * @throws DocumentException
     */
    public static Map xmlToMapWithAttr(String xmlStr, boolean needRootKey) throws DocumentException {
        Document doc = DocumentHelper.parseText(xmlStr);
        Element root = doc.getRootElement();
        Map<String, Object> map = (Map<String, Object>) xmlToMap(root);
        if(root.elements().size()==0 && root.attributes().size()==0){
            return map; //根节点只有一个文本内容
        }
        if(needRootKey){
            //在返回的map里加根节点键（如果需要）
            Map<String, Object> rootMap = new HashMap<String, Object>();
            rootMap.put(root.getName(), map);
            return rootMap;
        }
        return map;
    }


    /**
     * xml转map
     * @param element
     * @return
     */
    private static Object xmlToMap(Element element) {
        // System.out.println(element.getName());
        Map<String, Object> map = new LinkedHashMap<String, Object>();
        List<Element> elements = element.elements();
        if (elements.size() == 0) {
            map.put(element.getName(), element.getText());
            if (!element.isRootElement()) {
                return element.getText();
            }
        } else if (elements.size() == 1) {
            map.put(elements.get(0).getName(), xmlToMap(elements.get(0)));
        } else if (elements.size() > 1) {
            // 多个子节点的话就得考虑list的情况了，比如多个子节点有节点名称相同的
            // 构造一个map用来去重
            Map<String, Element> tempMap = new LinkedHashMap<String, Element>();
            for (Element ele : elements) {
                tempMap.put(ele.getName(), ele);
            }
            Set<String> keySet = tempMap.keySet();
            for (String string : keySet) {
                Namespace namespace = tempMap.get(string).getNamespace();
                List<Element> elements2 = element.elements(new QName(string,
                        namespace));
                // 如果同名的数目大于1则表示要构建list
                if (elements2.size() > 1) {
                    List<Object> list = new ArrayList<Object>();
                    for (Element ele : elements2) {
                        list.add(xmlToMap(ele));
                    }
                    map.put(string, list);
                } else {
                    // 同名的数量不大于1则直接递归去
                    map.put(string, xmlToMap(elements2.get(0)));
                }
            }
        }

        return map;
    }
}

方式二：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
     
public class Xml2MapUtils
{ 
        /**
         * xml字符串转map
         * @param xml
         * @return
         */
        public static Map<String, Object> xml2map(String xml) throws DocumentException
        {
            Document doc = null;
            //将xml字符串转为document对象
            doc = DocumentHelper.parseText(xml);
            Map<String, Object> map = new HashMap<>();
            if (doc == null)
            {
                return map;
            }
            else
            {
                //获取根节点
                Element rootElement = doc.getRootElement();
                element2map(rootElement, map);
            }
            return map;
        }

        @SuppressWarnings("unchecked")
        private static void element2map(Element elmt, Map<String, Object> map)
        {
            if (null == elmt)
            {
                return;
            }
            String name = elmt.getName();
            
            //判断当前节点的内容是否为文本（最里面一层节点）
            if (elmt.isTextOnly())
            {
                map.put(name, elmt.getText());
            }
            else
            {
                Map<String, Object> mapSub = new HashMap<>();
                
                //获取当前节点的所有子节点
                List<Element> elements = (List<Element>)elmt.elements();
                
                //利用递归获取节点值
                for (Element elmtSub : elements)
                {
                    element2map(elmtSub, mapSub);
                }
                Object first = map.get(name);
                
                //判断
                if (null == first)
                {
                    map.put(name, mapSub);
                }
                else
                {
                    if (first instanceof List<?>)
                    {
                        ((List<Map<String, Object>>)first).add(mapSub);
                    }
                    else
                    {
                        List<Object> listSub = new ArrayList<Object>();
                        listSub.add(first);
                        listSub.add(mapSub);
                        map.put(name, listSub);
                    }
                }
            }
        }   
}