【加强版】SAX解析XML返回对应格式的Map对象（解决元素递归嵌套）-Toy模板网

这篇具有很好参考价值的文章主要介绍了【加强版】SAX解析XML返回对应格式的Map对象（解决元素递归嵌套）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

SAX解析XML返回对应格式的Map对象_辛丑年正月十五的博客-CSDN博客

前言

上篇文章实现了xml元素节点的解析并返回了对应格式的Map对象，但是遗留了一个问题，就是当xml中的元素存在递归嵌套时就解析不了，因为qname属性会重复，导致后一个元素会覆盖前一个元素。

问题明了了，解决问题的思路也就浮出水面了，要解决这种存在递归嵌套元素的xml只需找到该元素中的唯一属性值即可

简介

本文依旧使用了上一篇文章的思路和代码，只是在上一篇文章的基础上增加了一个存储元素唯一标记的Map对象，该Map对象的作用就是用以区分，待解析XML递归嵌套元素的不同之处的。缺点就是，如果你待解析的xml中没有这种唯一属性的标记，那么你则需要赋予唯一属性值，并且替换使用的"KeyId"属性后（详见#图1.0）才能有效解析

# 图1.0

阅读必读

比较难理解的是xml节点复杂关系的呈现，设计思路是定义四个Map对象和一个int类型的下标值（详见图#1.1）四个Map对象的作用分别是

1、resultMap 存储结果集。

2、indexKeyId 存储元素的唯一标识，用于区分嵌套元素中元素之间的不同之处。

3、indexKeyMap 存储通过下标位置记录元素节点名称。

4、indexKeyMapObj 该对象以元素节点名称存储了元素对象本身。

5、index 元素的下标，每开始解析一个元素+1，每解析结束一个元素-1。

描述：当startElement开始读取节点元素时，通过下标记录元素的唯一标识和名称，并通过名称记录元素对象本身，每次开始解析一个元素时index下标进行累加，执行解析结束(endElement)时-1，解析思路是通过元素节点名称+唯一标识找到目标节点。组装格式也是通过index下标来找对应关系的，下面是代码呈现

# 图1.1

【加强版】SAX解析XML返回对应格式的Map对象（解决元素递归嵌套）

代码呈现

package com.syasuo.xml;

import com.alibaba.fastjson.JSON;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.*;

/**
 * @author SYASUO
 * @date 2023/6/19 13:46
 */
@Slf4j
public class MyDefaultHandler extends DefaultHandler {

    //存储结果集
    private Map<String,Object> resultMap = new HashMap<>();

    //存储xml元素唯一的标识，主要用于区分元素节点的嵌套
    private Map<Integer,String> indexKeyId = new HashMap<>();
    
    //用下标标记key
    private Map<Integer,String> indexKeyMap = new HashMap<>();

    //下标标记的所属key的对象
    private Map<String,Map<String,Object>> indexKeyMapObj = new HashMap<>();

    //记录元素节点对应的下标，初始给0
    private int index = 0;

    @Override
    public void startDocument() throws SAXException {
        log.info("------------------------------XML读取开始------------------------------");
    }

    /**
     * 开始读取XML元素，每次记录下标对应的key和该key对应的对象
     */
    @SneakyThrows
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        Map<String,Object> node = new HashMap<>();
        String keyId = null;
        for (int i = 0; i < attributes.getLength(); i++) {
            String eleName = attributes.getQName(i);
            if(null != eleName && eleName.equals("KeyId")){
                keyId = attributes.getValue(i);
            }
            node.put(attributes.getQName(i),attributes.getValue(i));
        }
        indexKeyId.put(index,keyId);
        indexKeyMap.put(index,qName);
        indexKeyMapObj.put(qName+keyId,node);
        index++;

    }

    /**
     * 元素节点读取结束时，由于index在startElement中执行了+1操作，
     * 因此获取对应节点的父级节点时需要先执行index-1操作得到当前节点下标，在当前节点下标位再次执行-1操作得到父级节点
     * 取到父级节点时需要判断父级包不包含该节点，如果包含就说明该节点是一个List集合，否则就作为一个单独的对象放入父级对象中
     * 最后给resultMap结果集对象赋值即可
     */
    @SneakyThrows
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        //找当前节点
        int j = --index;
        String keyId = indexKeyId.get(j);
        //通过组合key找到当前元素对象
        String curKey = qName+keyId;
        Map<String,Object> curObj = indexKeyMapObj.get(curKey);
        if(j > 0){
            //找父节点
            j--;
            String parentQName = indexKeyMap.get(j);
            String parentKeyId = indexKeyId.get(j);
            //通过组合key找当前元素对象的父对象
            String parentKey = parentQName + parentKeyId;
            Map<String,Object> parent = indexKeyMapObj.get(parentKey);
            if(parent.containsKey(qName)){
                List<Map<String,Object>> list = new ArrayList<>();
                //System.out.println(parent.get(qName).getClass().getTypeName());
                if(parent.get(qName).getClass().getSimpleName().equals("HashMap")){
                    list.add((Map<String, Object>) parent.get(qName));
                }else{
                    list.addAll((Collection<? extends Map<String, Object>>) parent.get(qName));
                }
                //将当前节点对象加入当前对象集合
                list.add(curObj);
                parent.put(qName,list);
            }else{
                parent.put(qName,curObj);
            }
            resultMap = parent;
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
      /*
        String element = new String(ch,start,length);
        log.info("该方法只有在【<ele>标签值</ele>】这种类型的标签下才能有效获取");
        */
    }

    @SneakyThrows
    @Override
    public void endDocument() throws SAXException {
        log.info("------------------------------XML读取结束------------------------------");
    }

    public Map<String,Object> getResultMap(){
        return resultMap;
    }
}

测试运行

注意：CprjInfoDTO是xml对应格式的JavaBean，需要替换成自己的。

XML如何转JavaBean,可以看我这一篇

使用XJC将XML转换成JavaBean遇到的坑_辛丑年正月十五的博客-CSDN博客

package com.syasuo.xml;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.syasuo.dto.CprjInfoDTO;
import com.syasuo.entity.CprjInfo;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.*;
import java.util.Map;

/**
 * @author SYASUO
 * @date 2023/6/19 13:41
 */
public class Test {

    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        Long startTime = System.currentTimeMillis();
        SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
        MyDefaultHandler myDefaultHandler = new MyDefaultHandler();
        parser.parse(new File("D://root.xml"), myDefaultHandler);
        Map<String,Object> resultMap =  myDefaultHandler.getResultMap();
        OutputStream outputStream = new BufferedOutputStream(new FileOutputStream("D://OutMap.json"));
        //System.out.println(JSON.toJSONString(resultMap));
        outputStream.write(JSON.toJSONString(resultMap,true).getBytes());
        outputStream.close();
        CprjInfoDTO cprjInfo = JSONObject.parseObject(JSON.toJSONString(resultMap),CprjInfoDTO.class);
        OutputStream os = new BufferedOutputStream(new FileOutputStream("D://DefaultHandler.json"));
        os.write(JSON.toJSONString(cprjInfo,true).getBytes());
        os.close();
        //System.out.println(JSON.toJSONString(cprjInfo));
        System.out.println(System.currentTimeMillis()-startTime);
    }
}

由于输出太大了，控制台打印不全也不容易看，所以输出了两个文件（详见#图1.2），分别是

1、OutMap.json 存储解析的原生Map对象

2、DefaultHandler.json 存储转换后的java对象

# 图1.2

【加强版】SAX解析XML返回对应格式的Map对象（解决元素递归嵌套）