实用工具类，xml转map或map转xml,使用各种情况

import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

/**
 * xml转map，map转xml 带属性
 * @author QS
 * @since 2018.3.22
 */
public class MapXmlUtil {

    public static void main(String[] args) throws Exception {
        String textFromFile = FileUtils
                .readFileToString(new File("E:/sample.xml"), "UTF-8");
        Map<String, Object> map2 = xml2map(textFromFile, false);
        //JSON json = JSONObject.fromObject(map2);
        System.out.println(map2); // 格式化输出

         /*  Map<String,Object> rootMap = new HashMap<String,Object>();
            List<Object> list = new ArrayList<Object>();
            Map<String,Object> map = new HashMap<String,Object>();
            map.put("CODE","2003");
            map.put("SN", "0001");
            map.put("DATE", "yyyyMMdd");
            map.put("TIME","HHmmss");
            map.put("ID","001");
            map.put("CODE","00");
            map.put("SE","00");
            map.put("CARD","00000002");
            map.put("AREA","1");
            map.put("NOTIFICATION","201801291500001234");
            map.put("TRAN_DATE",new Date());
            Map<String,Object> map1 = new HashMap<String,Object>();
            map1.put("TRANS_CODE","2003");
            map1.put("TRANS_SN","0001");
            map1.put("DATE", "yyyyMMdd");
            map1.put("TIME","HHmmss");
            map1.put("CHANNEL_ID","001");
            map1.put("RESPONSE_CODE","00");
            map1.put("RESPONSE","00");
            map1.put("CARD_ID","00000002");
            map1.put("AREA_ID","1");
            map1.put("NOTIFICATION","201801291500001234");
            map1.put("TRAN_DATE",new Date());
            list.add(map);
            list.add(map1);
            rootMap.put("list",list);
            rootMap.put("name","123");
            rootMap.put("pass","456");
        Document doc = map2Xml(rootMap,"input","1");
        // Document doc = map2xml(map); //map中含有根节点的键
        System.out.println(formatXml(doc));*/
    }

    /**
     * xml转map 不带属性
     *
     * @param xmlStr
     * @param needRootKey
     *            是否需要在返回的map里加根节点键
     * @return
     * @throws DocumentException
     */
    public static Map xml2map(String xmlStr, boolean needRootKey) throws DocumentException {
        Document doc = DocumentHelper.parseText(xmlStr);
        Element root = doc.getRootElement();
        Map<String, Object> map = (Map<String, Object>) xml2map(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 xmlStr
     * @param needRootKey
     *            是否需要在返回的map里加根节点键
     * @return
     * @throws DocumentException
     */
    public static Map xml2mapWithAttr(String xmlStr, boolean needRootKey) throws DocumentException {
        Document doc = DocumentHelper.parseText(xmlStr);
        Element root = doc.getRootElement();
        Map<String, Object> map = (Map<String, Object>) xml2mapWithAttr(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 e
     * @return
     */
    private static Map xml2map(Element e) {
        Map map = new LinkedHashMap();
        List list = e.elements();
        if (list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                Element iter = (Element) list.get(i);
                List mapList = new ArrayList();

                if (iter.elements().size() > 0) {
                    Map m = xml2map(iter);
                    if (map.get(iter.getName()) != null) {
                        Object obj = map.get(iter.getName());
                        if (!(obj instanceof List)) {
                            mapList = new ArrayList();
                            mapList.add(obj);
                            mapList.add(m);
                        }
                        if (obj instanceof List) {
                            mapList = (List) obj;
                            mapList.add(m);
                        }
                        map.put(iter.getName(), mapList);
                    } else
                        map.put(iter.getName(), m);
                } else {
                    if (map.get(iter.getName()) != null) {
                        Object obj = map.get(iter.getName());
                        if (!(obj instanceof List)) {
                            mapList = new ArrayList();
                            mapList.add(obj);
                            mapList.add(iter.getText());
                        }
                        if (obj instanceof List) {
                            mapList = (List) obj;
                            mapList.add(iter.getText());
                        }
                        map.put(iter.getName(), mapList);
                    } else
                        map.put(iter.getName(), iter.getText());
                }
            }
        } else
            map.put(e.getName(), e.getText());
        return map;
    }

    /**
     * xml转map 带属性
     *
     * @param e
     * @return
     */
    private static Map xml2mapWithAttr(Element element) {
        Map<String, Object> map = new LinkedHashMap<String, Object>();

        List<Element> list = element.elements();
        List<Attribute> listAttr0 = element.attributes(); // 当前节点的所有属性的list
        for (Attribute attr : listAttr0) {
            map.put("@" + attr.getName(), attr.getValue());
        }
        if (list.size() > 0) {

            for (int i = 0; i < list.size(); i++) {
                Element iter = list.get(i);
                List mapList = new ArrayList();

                if (iter.elements().size() > 0) {
                    Map m = xml2mapWithAttr(iter);
                    if (map.get(iter.getName()) != null) {
                        Object obj = map.get(iter.getName());
                        if (!(obj instanceof List)) {
                            mapList = new ArrayList();
                            mapList.add(obj);
                            mapList.add(m);
                        }
                        if (obj instanceof List) {
                            mapList = (List) obj;
                            mapList.add(m);
                        }
                        map.put(iter.getName(), mapList);
                    } else
                        map.put(iter.getName(), m);
                } else {

                    List<Attribute> listAttr = iter.attributes(); // 当前节点的所有属性的list
                    Map<String, Object> attrMap = null;
                    boolean hasAttributes = false;
                    if (listAttr.size() > 0) {
                        hasAttributes = true;
                        attrMap = new LinkedHashMap<String, Object>();
                        for (Attribute attr : listAttr) {
                            attrMap.put("@" + attr.getName(), attr.getValue());
                        }
                    }

                    if (map.get(iter.getName()) != null) {
                        Object obj = map.get(iter.getName());
                        if (!(obj instanceof List)) {
                            mapList = new ArrayList();
                            mapList.add(obj);
                            // mapList.add(iter.getText());
                            if (hasAttributes) {
                                attrMap.put("#text", iter.getText());
                                mapList.add(attrMap);
                            } else {
                                mapList.add(iter.getText());
                            }
                        }
                        if (obj instanceof List) {
                            mapList = (List) obj;
                            // mapList.add(iter.getText());
                            if (hasAttributes) {
                                attrMap.put("#text", iter.getText());
                                mapList.add(attrMap);
                            } else {
                                mapList.add(iter.getText());
                            }
                        }
                        map.put(iter.getName(), mapList);
                    } else {
                        // map.put(iter.getName(), iter.getText());
                        if (hasAttributes) {
                            attrMap.put("#text", iter.getText());
                            map.put(iter.getName(), attrMap);
                        } else {
                            map.put(iter.getName(), iter.getText());
                        }
                    }
                }
            }
        } else {
            // 根节点的
            if (listAttr0.size() > 0) {
                map.put("#text", element.getText());
            } else {
                map.put(element.getName(), element.getText());
            }
        }
        return map;
    }
    /**
     * 格式化输出xml
     *
     * @param xmlStr
     * @return
     * @throws DocumentException
     * @throws IOException
     */
    public static String formatXml(String xmlStr) throws DocumentException, IOException {
        Document document = DocumentHelper.parseText(xmlStr);
        return formatXml(document);
    }
    /**
     * 格式化输出xml
     *
     * @param document
     * @return
     * @throws DocumentException
     * @throws IOException
     */
    public static String formatXml(Document document) throws DocumentException, IOException {
        // 格式化输出格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        // format.setEncoding("UTF-8");
        StringWriter writer = new StringWriter();
        // 格式化输出流
        XMLWriter xmlWriter = new XMLWriter(writer, format);
        // 将document写入到输出流
        xmlWriter.write(document);
        xmlWriter.close();
        return writer.toString();
    }
    public static Document map2Xml(Map<String, Object> map, String node, String type) throws Exception{
        Document document = DocumentHelper.createDocument();
        Element nodeElement = document.addElement(node);
        map2Xml(map, nodeElement, type);
        return document;
    }
    public static final String map2Xml_TYPE_listElementWrapper = "1";
    private static void map2Xml(Map<String, Object> map,Element nodeElement, String type) throws Exception{
        
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String key = (String)entry.getKey();
            Object value = entry.getValue();
            if((value instanceof List) && StringUtils.isBlank(type)){
                Element element = nodeElement.addElement(key);
                List<Map<String, Object>> list = (List<Map<String, Object>>)value;
                for (Map<String, Object> subMap: list) {
                    map2Xml(subMap, element, type);
                }
            } else if((value instanceof List) && StringUtils.isNotBlank(type) && type.contains(map2Xml_TYPE_listElementWrapper)) {
                List<Map<String, Object>> list = (List<Map<String, Object>>)value;
                for (Map<String, Object> subMap: list) {
                    Element element = nodeElement.addElement(key);
                    map2Xml(subMap, element, type);
                }
            } else if(value instanceof Map) {
                Element element = nodeElement.addElement(key);

                Map<String, Object> valueMap = (Map<String, Object>)value;
                map2Xml(valueMap, element, type);
            } else if(value instanceof String){
                Element keyElement = nodeElement.addElement(key);
                keyElement.setText((String)value);
            }else if(value instanceof Integer){
                Element keyElement = nodeElement.addElement(key);
                keyElement.setText(((Integer)value).toString());
            } else if(value instanceof BigDecimal){
                Element keyElement = nodeElement.addElement(key);
                keyElement.setText(((BigDecimal)value).toString());
            }else if(value instanceof Date){
                Element keyElement = nodeElement.addElement(key);
                keyElement.setText(( new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(value)).toString());
            }else {
                throw new Exception("不支持的 value 类型");
            }
        }
    }