使用Dom4j解析多层级XML为Map对象

引入dom4j的maven依赖包

<dependency>
	<groupId>org.dom4j</groupId>
	<artifactId>dom4j</artifactId>
	<version>2.1.4</version>
</dependency>

自定义Xml工具类解析

import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import io.micrometer.core.instrument.util.StringUtils;
import org.dom4j.*;
import java.util.*;


@Slf4j
public class XmlUtil {

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

    /**
     * 将xml格式响应报文解析为Map格式(并去掉List列表中的第一个空节点，防止转换成javabean时报错)
     *
     * @param xml xml原始报文
     * @return Map<String, Object> 解析结果
     */
    public static Map<String, Object> xmlToMap(String xml) {
        log.info("开始执行xmlToMap方法，解析Xml为map");
        try {
            Document doc = DocumentHelper.parseText(xml);
            Element rootElement = doc.getRootElement();
            Map<String, Object> resultMap = new HashMap<>();
            parseElementToMap(resultMap, rootElement);
            log.info("执行xmlToMap方法,解析Xml为map完成,解析结果为:resultMap = [{}]", resultMap);
            return resultMap;
        } catch (DocumentException e) {
            log.error("开始执行xmlToMap方法，解析Xml为map异常", e);
        }
        return null;
    }

    /**
     * 使用递归调用将多层级xml转为map,（xml中不能存在空节点）
     *
     * @param map         响应结果集
     * @param rootElement 节点元素
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static void parseElementToMap(Map<String, Object> map, Element rootElement) {
        //获得当前节点的子节点
        List<Element> elements = rootElement.elements();
        int elementsSize = elements.size();
        if (elementsSize == 0) {
            //没有子节点说明当前节点是叶子节点，直接取值
            String name = rootElement.getName();
            String value = rootElement.getText();
            map.put(name, value);
        } else if (elementsSize == 1) {
            String elementName = rootElement.getName();
            String textTrim = rootElement.getTextTrim();
            String parentName = rootElement.getParent().getName();
            if (parentName.endsWith("List") && StringUtils.isBlank(textTrim)) {
                if (!elementName.endsWith("List") && StringUtils.isNotBlank(elementName) && StringUtils.isBlank(textTrim)) {
                    NODE_NAME_MAP.put(parentName, elementName);
                }
            }
            //只有一个子节点说明不用考虑list的情况，继续递归
            Map<String, Object> tempMap = new HashMap<>();
            parseElementToMap(tempMap, elements.get(0));
            map.put(elementName, tempMap);
        } else {
            //多个子节点的话就要考虑list的情况了，特别是当多个子节点有名称相同的字段时
            Map<String, Object> tempMap = new HashMap<>();
            for (Element element : elements) {
                String elementName = element.getName();
                String textTrim = element.getTextTrim();
                String parentName = element.getParent().getName();
                if (parentName.endsWith("List") && StringUtils.isBlank(textTrim)) {
                    if (!elementName.endsWith("List") && StringUtils.isNotBlank(elementName) && StringUtils.isBlank(textTrim)) {
                        String name = element.getName();
                        NODE_NAME_MAP.put(parentName, name);
                    }
                }
                tempMap.put(element.getName(), null);
            }
            Set<String> keySet = tempMap.keySet();
            for (String nodeName : keySet) {
                Namespace namespace = elements.get(0).getNamespace();
                List<Element> sameElements = rootElement.elements(new QName(nodeName, namespace));
                // 如果同名的数目大于1则表示要构建list
                int sameElementSize = sameElements.size();
                if (sameElementSize > 1) {
                    List<Map> list = new ArrayList<Map>();
                    for (Element element : sameElements) {
                        Map<String, Object> sameTempMap = new HashMap<>();
                        parseElementToMap(sameTempMap, element);
                        list.add(sameTempMap);
                    }
                    map.put(nodeName, list);
                } else {
                    // 同名的数量不大于1直接递归
                    Map<String, Object> sameTempMap = new HashMap<>();
                    parseElementToMap(sameTempMap, sameElements.get(0));
                    if (NODE_NAME_MAP.containsKey(nodeName)) {
                        String childName = NODE_NAME_MAP.get(nodeName);
                        Object object = sameTempMap.get(childName);
                        if (object == null) {
                            Object childObj = sameTempMap.get(nodeName);
                            Map<String, Object> childMap = null;
                            if (childObj instanceof Map) {
                                childMap = (Map<String, Object>) childObj;
                            }
                            map.put(nodeName, childMap.get(childName));
                        } else {
                            map.put(nodeName, sameTempMap.get(childName));
                        }
                    } else if (sameTempMap.containsKey(nodeName)) {
                        map.put(nodeName, sameTempMap.get(nodeName));
                    } else {
                        map.put(nodeName, sameTempMap);
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        String xmlStr = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n" +
                "<root>\n" +
                "\t<brandName>品牌</brandName>\n" +
                "\t<type>私人</type>\n" +
                "\t<productList>\n" +
                "\t\t<itemCode>20111</itemCode>\n" +
                "\t\t<itemName>电池</itemName>\n" +
                "\t\t<quantity>2</quantity>\n" +
                "\t</productList>\n" +
                "\t<productList>\n" +
                "\t\t<itemCode>20222</itemCode>\n" +
                "\t\t<itemName>冰箱</itemName>\n" +
                "\t\t<quantity>1</quantity>\n" +
                "\t</productList>\n" +
                "</root>";
        Map<String, Object> map = xmlToMap(xmlStr);
        System.out.println(JSONUtil.toJsonPrettyStr(map));
    }
}