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

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.utils.StringUtils;
import org.dom4j.*;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.*;
import java.util.*;


public class XMLParse  {

    //文件路徑
    static String path = "D:\\DevelopWorkspace\\MY\\opensource-framework\\RuoYi-Vue\\doc\\DataSourceConfig.xml";

    public static void main(String[] args) throws Exception {

        //1、讀取文件并轉(zhuǎn)換為Document文檔對象
        Document doc = new SAXReader().read(new File(path));

        //2、使用asXML()方法將DOM文檔對象轉(zhuǎn)換為字符串
        String s = doc.asXML();

        //3、調(diào)用自定義的方法轉(zhuǎn)換為JSON數(shù)據(jù)格式
        JSONObject jsonObject = startXMLToJSON(s);

        //4、輸出結(jié)果
        System.out.println(jsonObject);


    }

    /**
     * 自定義*/
    public static JSONObject startXMLToJSON(String xml){
        //1、定義JSON對象保存結(jié)果
        JSONObject result = new JSONObject();
        try {
            //2、使用DocumentHelper.parseText()轉(zhuǎn)換為DOM文檔對象
            Document document = DocumentHelper.parseText(xml);
            //3、獲取DOM文檔根節(jié)點
            Element rootElement = document.getRootElement();
            //4、調(diào)用自定義的方法轉(zhuǎn)換為JSON數(shù)據(jù)格式
            parseJson(rootElement,result);
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return result;
    }

    public static void parseJson(Element element,JSONObject result){
        //1、獲取子節(jié)點列表
        List<Element> elements = element.elements();
        //2、循環(huán)子節(jié)點列表獲取數(shù)據(jù)
        for (Element e:elements) {
            //3、有數(shù)據(jù)則獲取
            if (!e.elements().isEmpty() && !e.getText().isEmpty()){
                //4、定義另一個JSON對象保存子節(jié)點JSON數(shù)據(jù)
                JSONObject cjson = new JSONObject();
                //5、此處調(diào)用自身繼續(xù)方法繼續(xù)循環(huán)取值，知道遍歷完所有字節(jié)點數(shù)據(jù)
                parseJson(e,cjson);
                if (!cjson.isEmpty()){
                    //6、添加到JSON對象
                    result.put(e.getName(),cjson);
                }
            }else {
                if (!e.getText().isEmpty()){
                    //6、添加到JSON對象
                    result.put(e.getName(),e.getText());
                }
            }
        }
    }
 }

        //1、讀取文件并轉(zhuǎn)換為Document文檔對象
        Document doc = new SAXReader().read(new File(path));

	Reads a Document from the given File
	Params:
	file – is the File to read from.
	Returns:
	the newly created Document instance
	Throws:
	DocumentException – if an error occurs during parsing.
	public Document read(File file) throws DocumentException {
        try {
            /*
             * We cannot convert the file to an URL because if the filename
             * contains '#' characters, there will be problems with the URL in
             * the InputSource (because a URL like
             * http://myhost.com/index#anchor is treated the same as
             * http://myhost.com/index) Thanks to Christian Oetterli
             */
             //1、使用new InputSource(new FileInputStream(file))獲取文件輸入流對象source
            InputSource source = new InputSource(new FileInputStream(file));
            
            //2、校驗字符編碼，此處并沒有設(shè)置
            if (this.encoding != null) {
                source.setEncoding(this.encoding);
            }
            //3、file.getAbsolutePath()獲取文件file的絕對路徑
            String path = file.getAbsolutePath();

			//4、文件路徑path不為空則統(tǒng)一文件路徑的分隔符/
            if (path != null) {
                // Code taken from Ant FileUtils
                StringBuffer sb = new StringBuffer("file://");

                // add an extra slash for filesystems with drive-specifiers
                if (!path.startsWith(File.separator)) {
                    sb.append("/");
                }

                path = path.replace('\\', '/');
                sb.append(path);

                source.setSystemId(sb.toString());
            }
            
			//5、最后將文件輸入流對象source作為參數(shù)調(diào)用read(source)方法
            return read(source);
        } catch (FileNotFoundException e) {
            throw new DocumentException(e.getMessage(), e);
        }
    }

	public Document read(InputSource in) throws DocumentException {
        try {
            XMLReader reader = getXMLReader();

            reader = installXMLFilter(reader);

            EntityResolver thatEntityResolver = this.entityResolver;

            if (thatEntityResolver == null) {
                thatEntityResolver = createDefaultEntityResolver(in
                        .getSystemId());
                this.entityResolver = thatEntityResolver;
            }

            reader.setEntityResolver(thatEntityResolver);

            SAXContentHandler contentHandler = createContentHandler(reader);
            contentHandler.setEntityResolver(thatEntityResolver);
            contentHandler.setInputSource(in);

            boolean internal = isIncludeInternalDTDDeclarations();
            boolean external = isIncludeExternalDTDDeclarations();

            contentHandler.setIncludeInternalDTDDeclarations(internal);
            contentHandler.setIncludeExternalDTDDeclarations(external);
            contentHandler.setMergeAdjacentText(isMergeAdjacentText());
            contentHandler.setStripWhitespaceText(isStripWhitespaceText());
            contentHandler.setIgnoreComments(isIgnoreComments());
            reader.setContentHandler(contentHandler);

            configureReader(reader, contentHandler);

            reader.parse(in);

            return contentHandler.getDocument();
        } catch (Exception e) {
            if (e instanceof SAXParseException) {
                // e.printStackTrace();
                SAXParseException parseException = (SAXParseException) e;
                String systemId = parseException.getSystemId();

                if (systemId == null) {
                    systemId = "";
                }

                String message = "Error on line "
                        + parseException.getLineNumber() + " of document "
                        + systemId + " : " + parseException.getMessage();

                throw new DocumentException(message, e);
            } else {
                throw new DocumentException(e.getMessage(), e);
            }
        }
    }

/**
 * <p>
 * <code>asXML</code> returns the textual XML representation of this node.
 * </p>
 * 
 * @return the XML representation of this node
 */
String asXML();

	public String asXML() {
		//1、使用OutputFormat定義輸出XML文件流格式
        OutputFormat format = new OutputFormat();
        
        //2、定義編碼格式，建議使用UTF-8
        format.setEncoding(encoding);
        
        try {
        	//3、創(chuàng)建StringWriter作為字符串輸出緩沖區(qū)
            StringWriter out = new StringWriter();
            
            //4、創(chuàng)建XMLWriter并輸出對象
            XMLWriter writer = new XMLWriter(out, format);
            writer.write(this);
            writer.flush();
            
			//5、最后返回輸出到StringWriter的字符串
            return out.toString();
        } catch (IOException e) {
            throw new RuntimeException("IOException while generating textual "
                    + "representation: " + e.getMessage());
        }
    }

    /**
     * <p>
     * <code>parseText</code> parses the given text as an XML document and
     * returns the newly created Document.
     * </p>
     * 
     * @param text
     *            the XML text to be parsed
     * 
     * @return a newly parsed Document
     * 
     * @throws DocumentException
     *             if the document could not be parsed
     */
    public static Document parseText(String text) throws DocumentException {
        Document result = null;
		//1、創(chuàng)建SAXReader
        SAXReader reader = new SAXReader();
        
		//2、換取編碼格式
        String encoding = getEncoding(text);
        
		//3、使用輸入流讀取需要解析的字符串文本
        InputSource source = new InputSource(new StringReader(text));
        //4、設(shè)置編碼格式
        source.setEncoding(encoding);
		//使用read(InputSource in)方法讀取解析
        result = reader.read(source);

        // if the XML parser doesn't provide a way to retrieve the encoding,
        // specify it manually
        //如果XML解析器不提供檢索編碼的方法，手動指定
        if (result.getXMLEncoding() == null) {
            result.setXMLEncoding(encoding);
        }

        return result;
    }