xml与map的相互转换

简单结构的xml转换

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayInputStream;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class XmlUtil {

    /**
     * xml转换为map(只适用简单的xml(没有嵌套结构))
     *
     * @param xml     xml的字符串
     * @param charset 编码类型
     * @return
     * @throws UnsupportedEncodingException
     * @throws DocumentException
     */
    public static Map<String, String> xmlToMap(String xml, String charset) throws UnsupportedEncodingException, DocumentException, DocumentException {
        Map<String, String> respMap = new HashMap();
        SAXReader reader = new SAXReader();
        Document doc = reader.read(new ByteArrayInputStream(xml.getBytes(charset)));
        Element root = doc.getRootElement();
        xmlToMap(root, respMap);
        return respMap;
    }

    private static Map<String, String> xmlToMap(Element tmpElement, Map<String, String> respMap) {

        if (tmpElement.isTextOnly()) {
            respMap.put(tmpElement.getName(), tmpElement.getText());
            return respMap;
        }

        @SuppressWarnings("unchecked")
        Iterator<Element> eItor = tmpElement.elementIterator();
        while (eItor.hasNext()) {
            Element element = eItor.next();
            xmlToMap(element, respMap);
        }
        return respMap;
    }

    /**
     * map转换为xml
     *
     * @param data(只适用简单的map(没有嵌套结构))
     * @return
     * @throws Exception
     */
    public static String mapToXml(Map<String, String> data) throws Exception {
        org.w3c.dom.Document document = newDocumentBuilder().newDocument();
        org.w3c.dom.Element root = document.createElement("xml");
        document.appendChild(root);
        Iterator var3 = data.keySet().iterator();

        while (var3.hasNext()) {
            String key = (String) var3.next();
            String value = data.get(key);
            if (value == null) {
                value = "";
            }

            value = value.trim();
            org.w3c.dom.Element filed = document.createElement(key);
            filed.appendChild(document.createTextNode(value));
            root.appendChild(filed);
        }

        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        DOMSource source = new DOMSource(document);
        transformer.setOutputProperty("encoding", "UTF-8");
        transformer.setOutputProperty("indent", "yes");
        StringWriter writer = new StringWriter();
        StreamResult result = new StreamResult(writer);
        transformer.transform(source, result);
        String output = writer.getBuffer().toString();

        try {
            writer.close();
        } catch (Exception var10) {

        }
        return output;
    }

    private static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        documentBuilderFactory.setFeature("http://javax.xml.XMLConstants/feature/secure-processing", true);
        documentBuilderFactory.setXIncludeAware(false);
        documentBuilderFactory.setExpandEntityReferences(false);
        return documentBuilderFactory.newDocumentBuilder();
    }

    public static void main(String[] args) throws Exception {
        String s = "<xml>\n" +
                "<auth>\n" +
                "<randomStr>suiji</randomStr>\n" +
                "<token>3ed6b709d31e87af73216149dc510c6fc94975af</token>\n" +
                "</auth>\n" +
                "</xml>";
        System.out.println("------------xmlToMap---------------");
        Map<String, String> xmlToMap = xmlToMap(s, "UTF-8");
        for (Map.Entry<String, String> entry : xmlToMap.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("key = " + key + ",value = " + value);
        }
        System.out.println("------------mapToXml---------------");
        String mapToXml = mapToXml(xmlToMap);
        System.out.println(mapToXml);
    }
}

复杂结构的xml转换为map

public class XmlUtil {

    //根节点
    private static String rootName = "xml";
    //节点没有值的情况下默认值
    private static String defaultNullValue = "";

    private static Map<String, AtomicInteger> map = new HashMap();

    /**
     * xml 转换为 map
     *
     * @param xml
     * @return
     */
    public static Map<String, Object> parse(String xml) {
        Map<String, Object> map = new HashMap();
        StringReader stringReader = null;
        try {
            stringReader = new StringReader(xml);
            XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(stringReader);
            map = doParse(reader);
        } catch (Throwable t) {
            throw new RuntimeException(t);
        } finally {
            if (null != stringReader) {
                try {
                    stringReader.close();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return map;
    }

    /**
     * 真正开始解析转换
     * @param reader
     * @return
     * @throws Throwable
     */
    private static Map<String, Object> doParse(XMLStreamReader reader) throws Throwable {
        Map<String, Object> map = new HashMap<String, Object>();
        Map<String, Object> currentMap = map;
        int event = reader.getEventType();
        List<String> names = new ArrayList<String>();
        int taglength = 0;
        String tagName = null;
        String tagValue = defaultNullValue;
        while (true) {
            switch (event) {
                case XMLStreamConstants.START_DOCUMENT:
                    break;
                case XMLStreamConstants.START_ELEMENT:
                    tagValue = defaultNullValue;
                    tagName = reader.getLocalName();
                    if (rootName.equals(tagName)) {
                        break;
                    }
                    names.add(tagName);
                    taglength++;

                    currentMap = map;
                    if (taglength > 1) {
                        for (int i = 0; i < taglength - 1; i++) {
                            Object object = currentMap.get(names.get(i));
                            if (null == object) {
                                object = new HashMap<String, Object>();
                                currentMap.put(names.get(i), object);
                                currentMap = (Map<String, Object>) object;
                            } else {
                                int currentTagNameSize = getSize(i + 1 + "" + names.get(i));
                                if (currentTagNameSize > 1) {
                                    if (object instanceof Map) {
                                        List parentList = new ArrayList();
                                        parentList.add(object);
                                        Map tempMap = new HashMap();
                                        parentList.add(tempMap);
                                        currentMap.put(names.get(i), parentList);
                                        currentMap = tempMap;
                                    } else if (object instanceof List) {
                                        List parentList = (List) object;
                                        int parentListSize = parentList.size();
                                        if (parentListSize != currentTagNameSize) {
                                            Map tempMap = new HashMap();
                                            parentList.add(tempMap);
                                            currentMap = tempMap;
                                        } else {
                                            Map tempMap = (Map) parentList.get(parentList.size() - 1);
                                            currentMap = tempMap;
                                        }
                                    }
                                } else {
                                    currentMap = (Map<String, Object>) object;
                                }
                            }
                        }
                    }
                    add(names.size() + tagName);
                    break;
                case XMLStreamConstants.CHARACTERS:
                    tagValue = reader.getText();
                    break;
                case XMLStreamConstants.END_ELEMENT:
                    tagName = reader.getLocalName();
                    if (rootName.equals(tagName)) {
                        break;
                    }

                    currentMap = map;
                    if (taglength > 1) {
                        for (int i = 0; i < taglength - 1; i++) {
                            Object object = currentMap.get(names.get(i));
                            if (null == object) {
                                //nothing to do
                            } else {
                                if (object instanceof List) {
                                    List list = (List) object;
                                    currentMap = (Map) list.get(list.size() - 1);
                                } else if (object instanceof Map) {
                                    currentMap = (Map) object;
                                }
                            }
                        }
                    }

                    Object oldValue = currentMap.get(tagName);
                    if (!currentMap.containsKey(tagName)) {
                        currentMap.put(tagName, tagValue);
                        remove(names.size() + tagName);
                    } else {
                        if (oldValue instanceof List) {
                            List list = (List) oldValue;
                            if (list.size() > 0) {
                                Object obj = list.get(0);
                                if (obj instanceof String) {
                                    ((List) oldValue).add(tagValue);
                                    remove(names.size() + tagName);
                                }
                            }
                        } else if (oldValue instanceof Map) {

                        } else {
                            List tmpList = new ArrayList();
                            currentMap.put(tagName, tmpList);
                            tmpList.add(oldValue);
                            tmpList.add(tagValue);
                            remove(names.size() + tagName);
                        }
                    }

                    tagValue = defaultNullValue;
                    names.remove(names.size() - 1);
                    taglength--;
                    break;
                case XMLStreamConstants.END_DOCUMENT:
                    break;
            }

            if (!reader.hasNext()) {
                break;
            }
            event = reader.next();
        }
        return map;
    }

    private static void add(String nodeName) {
        AtomicInteger integer = map.get(nodeName);
        if (null == integer) {
            integer = new AtomicInteger(0);
            map.put(nodeName, integer);
        }
        integer.incrementAndGet();
    }

    private static void remove(String nodeName) {
        AtomicInteger integer = map.get(nodeName);
        if (null != integer) {
            integer.decrementAndGet();
        }
    }

    private static int getSize(String nodeName) {
        AtomicInteger integer = map.get(nodeName);
        if (null == integer) {
            integer = new AtomicInteger(0);
            map.put(nodeName, integer);
        }
        return integer.intValue();
    }

    public static void main(String[] args) {
        String str = "<xml>\n" +
                "<auth>\n" +
                "<randomStr>suiji</randomStr>\n" +
                "<token>3ed6b709d31e87af73216149dc510c6fc94975af</token>\n" +
                "</auth>\n" +
                "<datas>\n" +
                "<dataStatus>\n" +
                "<errorCode>0</errorCode>\n" +
                "<errormsg>发送成功</errormsg>\n" +
                "<seqId>1</seqId>\n" +
                "<lastModifyTime>2018-07-26 11:01:38</lastModifyTime>\n" +
                "</dataStatus>\n" +
                "<dataStatus>\n" +
                "<errorCode>1</errorCode>\n" +
                "<errormsg>发送失败，手机号为空</errormsg>\n" +
                "<seqId>2</seqId>\n" +
                "<lastModifyTime>2018-07-26 11:02:38</lastModifyTime>\n" +
                "</dataStatus>\n" +
                "</datas>\n" +
                "</xml>";
        Map<String, Object> parse = XMLParserStaxUtil.parse(str);
        System.out.println(parse);
    }
}

Spring中设置返回 xml格式

@RequestMapping(value = "/updateSmsStatus", produces = {"application/xml;charset=UTF-8"})
public SmsInfoVo getSMSInfo(String xmlParam) throws Exception {

//或者

@RequestMapping(value = "/updateSmsStatus", produces = MediaType.APPLICATION_XML_VALUE)
public SmsInfoVo getSMSInfo(String xmlParam) throws Exception {

//可配合使用该@XmlRootElement(name = "xml")，设置根节点名称，字节点无法使用
//这里是使用对象的属性名和xml的节点名称对象，比如 SmsVo result 对应  <result></result>

//第一层
@XmlRootElement(name = "xml")
public class SmsInfoVo {
    private SmsVo result;
}
//第二层
public class SmsVo {
    private Integer errorCode;
    private String errorMsg;
    private String constantIdent;
    private SmsDataVos datalist;
}
//第三层
public class SmsDataVos {
    private List<SmsDataVo> smsDatas;
}
//第四层
public class SmsDataVo {
    private String seqId;
    private String phoneNum;
    private String msg;
}
//最终的结果为：
<xml>
    <result>
        <constantIdent>CLS01001</constantIdent>
        <datalist>
            <smsDatas>
                <msg>3</msg>
                <phoneNum>3</phoneNum>
                <seqId>3</seqId>
            </smsDatas>
            <smsDatas>
                <msg>4</msg>
                <phoneNum>4</phoneNum>
                <seqId>4</seqId>
            </smsDatas>
        </datalist>
        <errorCode>0</errorCode>
        <errorMsg>认证成功</errorMsg>
    </result>
</xml>