使用XMLInputFactory 逐行读取xml文件里面的json ，不下载xml文件到整个文件里面

要高效读取大型 XML 文件（尤其是内含 JSON 数据的节点）并避免内存溢出，使用 XMLInputFactory 和 XMLStreamReader 是典型方案。以下是完整实现步骤和代码示例，结合关键优化点：

📌 核心步骤与代码实现

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamConstants;
import java.io.InputStream;

public class LargeXmlJsonReader {
    public static void main(String[] args) throws Exception {
        // 1️⃣ 创建流式解析器工厂（线程安全）
        XMLInputFactory factory = XMLInputFactory.newInstance();
        // 2️⃣ 通过输入流初始化读取器（避免一次性加载文件）
        try (InputStream is = /* 文件或网络输入流 */;
             XMLStreamReader reader = factory.createXMLStreamReader(is)) {
            
            StringBuilder jsonContent = null; // 用于缓存JSON文本
            boolean inTargetElement = false;  // 标记是否进入目标节点

            // 3️⃣ 事件循环：逐步解析XML
            while (reader.hasNext()) {
                int eventType = reader.next(); // 移动到下一个事件
                switch (eventType) {
                    case XMLStreamConstants.START_ELEMENT:
                        // 目标节点检测（假设目标元素名为 <jsonData>）
                        if ("jsonData".equals(reader.getLocalName())) {
                            inTargetElement = true;
                        }
                        break;
                    case XMLStreamConstants.CHARACTERS:
                        // ✅ 仅当在目标节点内才收集文本内容
                        if (inTargetElement && !reader.isWhiteSpace()) {
                            if (jsonContent == null) {
                                jsonContent = new StringBuilder();
                            }
                            jsonContent.append(reader.getText());
                        }
                        break;
                    case XMLStreamConstants.END_ELEMENT:
                        if (inTargetElement && "jsonData".equals(reader.getLocalName())) {
                            // 4️⃣ 提取完整JSON并处理
                            String jsonData = jsonContent.toString();
                            // 🚀 将jsonData传递给接口或其他处理器（此处仅示例）
                            System.out.println("Extracted JSON: " + jsonData);
                            
                            // 重置状态供下一个节点使用
                            jsonContent = null;
                            inTargetElement = false;
                        }
                        break;
                }
            }
        } // 自动关闭资源
    }
}

xml文件格式

<?xml version="1.0" encoding="UTF-8"?>
<response>
    <status>success</status>
    <message>数据返回成功</message>
    <fileName>data.json</fileName>
    <jsonData><![CDATA[
{
  "id": "12345",
  "name": "张三",
  "age": 30,
  "isActive": true,
  "tags": ["user", "premium"],
  "profile": {
    "email": "zhangsan@example.com",
    "phone": "+86-138-0000-1234"
  }
}
]]></jsonData>
</response>

🔍 核心注意事项

1. 内存优化原理
   StAX 是事件驱动流式解析器（搜索来源 ），逐事件（节点开始、结束、文本）读取文件，内存消耗仅取决于正在处理的节点大小而非整个文件，尤其适合大文件。

2. 精准定位目标数据

• 通过 START_ELEMENT 事件检测目标节点（如 ），标记 inTargetElement = true。
• 在 CHARACTERS 事件中，需跳过空白文本（reader.isWhiteSpace()），避免无效数据。

3. JSON 内容拼接

• 一个节点的文本可能被分割多次输出（如长文本或特殊编码），需用 StringBuilder 聚合。
• 在 END_ELEMENT 事件中确认节点结束，确保JSON完整性再处理。

4. 资源与异常管理

• 使用 try-with-resources 确保 XMLStreamReader 和 InputStream 自动关闭（代码第5行）。
• 避免中途退出时资源泄露。

🚨 常见问题处理

• XML 与 JSON 格式冲突
  若 JSON 含 XML 特殊字符（如 <, >），需确保 XML 文件中已转义（如 < → <）。否则解析器可能误判为 XML 标签导致报错。

• ✅ 检查源文件：使用 CDATA 区段包裹 JSON（如 <![CDATA[{...}]]>），可避免转义问题（解析时读取文本即可，StAX会自动处理）。

• 大文本分块读取
  若单个节点的 JSON 文本超大（如百MB级），可用 reader.getTextCharacters() 直接操作字符数组避免频繁创建字符串对象：
  java char[] buffer = new char; int len = reader.getTextCharacters(0, buffer, 0, buffer.length); jsonContent.append(buffer, 0, len);

⚡️ 性能对比（StAX vs DOM）

数据来源：DOM 需全文件加载（[来源9]），StAX 适用于大文件流式处理（[来源6][来源7]）。

通过以上方案，可安全处理任意大 XML 文件中的 JSON 数据，无需担心内存溢出。实际应用中，还可结合异步处理机制（如 Reactive Streams）进一步提升吞吐量。

返回json文件

                // 使用 StAX 流式解析 XML，防止大文件 OOM
                XMLInputFactory factory = XMLInputFactory.newInstance();
                try (InputStream is = response.getEntity().getContent()) {
                    XMLStreamReader reader = factory.createXMLStreamReader(is);
                    StringBuilder jsonContent = null;
                    boolean inJsonData = false;

                    try {
                        while (reader.hasNext()) {
                            int event = reader.next();

                            switch (event) {
                                case XMLStreamConstants.START_ELEMENT:
                                    if ("jsonData".equals(reader.getLocalName())) {
                                        inJsonData = true;
                                        jsonContent = new StringBuilder();
                                    }
                                    break;

                                case XMLStreamConstants.CHARACTERS:
                                    if (inJsonData && !reader.isWhiteSpace()) {
                                        jsonContent.append(reader.getText().trim());
                                    }
                                    break;

                                case XMLStreamConstants.END_ELEMENT:
                                    if (inJsonData && "jsonData".equals(reader.getLocalName())) {
                                        return jsonContent.toString(); // ✅ 成功提取并立即返回
                                    }
                                    break;
                            }
                        }
                    } finally {
                        try {
                            reader.close();
                        } catch (Exception e) {
                            logger.warn("关闭 XMLStreamReader 时发生异常", e);
                        }
                    }
                }