使用XMLStreamReader解析XML，移除含scoped-proxy的bean标签并写入新文件

刚接触XML解析不用慌，StAX（也就是你提到的XMLStreamReader相关API）是Java自带的轻量级XML处理工具，很适合做这种过滤修改的工作。下面是完整的示例代码，我会加详细注释，帮你理解每一步：

示例代码 #

这个代码不需要额外引入依赖，Java SE本身就包含javax.xml.stream相关类。

import javax.xml.stream.*;
import java.io.*;

public class XmlBeanFilter {
    public static void main(String[] args) {
        // 输入和输出文件路径，你可以改成自己的路径
        String inputXmlPath = "input.xml";
        String outputXmlPath = "output.xml";

        try (
            // 创建XML读取器
            XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(
                new FileInputStream(inputXmlPath)
            );
            // 创建XML写入器，设置UTF-8编码，可选格式化输出让内容更美观
            FileOutputStream fos = new FileOutputStream(outputXmlPath);
            XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
            XMLStreamWriter writer = outputFactory.createXMLStreamWriter(fos, "UTF-8")
        ) {
            // 保留原XML的声明信息
            writer.writeStartDocument("UTF-8", "1.0");

            boolean insideBean = false;
            boolean beanHasScopedProxy = false;
            int beanDepth = 0;

            while (reader.hasNext()) {
                int eventType = reader.next();

                switch (eventType) {
                    case XMLStreamConstants.START_ELEMENT:
                        String localName = reader.getLocalName();
                        // 遇到bean标签，标记进入bean范围
                        if ("bean".equals(localName)) {
                            insideBean = true;
                            beanDepth = 1;
                            beanHasScopedProxy = false;
                        } else if (insideBean) {
                            beanDepth++;
                            // 检查当前子元素是否是scoped-proxy
                            if ("scoped-proxy".equals(localName)) {
                                beanHasScopedProxy = true;
                            }
                        }

                        // 只有不在bean里，或在bean里但该bean不含scoped-proxy时，才写入开始标签
                        if (!insideBean || !beanHasScopedProxy) {
                            writer.writeStartElement(reader.getPrefix(), localName, reader.getNamespaceURI());
                            // 写入当前元素的所有属性
                            for (int i = 0; i < reader.getAttributeCount(); i++) {
                                writer.writeAttribute(
                                    reader.getAttributePrefix(i),
                                    reader.getAttributeNamespace(i),
                                    reader.getAttributeLocalName(i),
                                    reader.getAttributeValue(i)
                                );
                            }
                        }
                        break;

                    case XMLStreamConstants.END_ELEMENT:
                        localName = reader.getLocalName();
                        // 处理bean的结束标签
                        if ("bean".equals(localName)) {
                            insideBean = false;
                            // 只有该bean不需要移除时，才写入结束标签
                            if (!beanHasScopedProxy) {
                                writer.writeEndElement();
                            }
                        } else {
                            if (insideBean) {
                                beanDepth--;
                            }
                            // 非bean的结束标签，或在可保留的bean里，就写入结束标签
                            if (!insideBean || !beanHasScopedProxy) {
                                writer.writeEndElement();
                            }
                        }
                        break;

                    case XMLStreamConstants.CHARACTERS:
                        // 写入文本内容，可选过滤空白（如果想完全保留原格式，可以去掉!reader.isWhiteSpace()判断）
                        if (!reader.isWhiteSpace() || !insideBean || !beanHasScopedProxy) {
                            writer.writeCharacters(reader.getText());
                        }
                        break;

                    case XMLStreamConstants.COMMENT:
                        // 保留原XML的注释
                        if (!insideBean || !beanHasScopedProxy) {
                            writer.writeComment(reader.getText());
                        }
                        break;

                    case XMLStreamConstants.DTD:
                        // 保留DOCTYPE声明
                        writer.writeDTD(reader.getText());
                        break;
                }
            }

            writer.writeEndDocument();
            System.out.println("处理完成！已生成新XML文件：" + outputXmlPath);

        } catch (XMLStreamException | IOException e) {
            e.printStackTrace();
        }
    }
}

代码说明 #

1. 核心逻辑：

   • 遍历XML的每个事件（开始标签、结束标签、文本等）
   • 遇到bean标签时标记进入bean范围，开始检查是否存在scoped-proxy子元素
   • 若发现scoped-proxy，则标记该bean需要移除，后续不写入该bean的任何内容
   • 不需要移除的内容（其他标签、文本、注释等）原样写入新XML

2. 适配细节：

   • 支持带命名空间的XML（比如Spring配置文件的命名空间前缀），通过getLocalName()判断元素名，避免前缀干扰
   • 保留了原XML的注释、DOCTYPE声明和XML声明，保证输出XML的完整性
   • 可根据需求调整空白文本的处理逻辑，保留原格式或精简空格

3. 使用方法：

   • 修改inputXmlPath为你的原始XML文件路径
   • 运行代码后，outputXmlPath就是处理完成的新XML文件

内容的提问来源于stack exchange，提问作者Gautham