当前位置：首页 > 后端开发 > 正文

xml怎么增加子节点java

Java中，使用DOM解析器创建新元素并追加到父节点即可增加XML子节点

Java中操作XML文档,增加子节点是一个常见的需求，以下是详细的步骤和代码示例，帮助你理解如何在Java中实现这一功能。

使用DOM解析器

DOM（Document Object Model）是处理XML的一种方式，它将XML文档加载到内存中，形成一个树结构，你可以方便地遍历和修改这个树结构。

xml怎么增加子节点java 第1张

步骤：

  1. 导入相关库：需要导入javax.xml.parsers和org.w3c.dom包。
  2. 创建DocumentBuilderFactory和DocumentBuilder：用于解析XML文档。
  3. 解析XML文件：将XML文件解析为一个Document对象。
  4. 创建新节点：使用Document对象创建新的元素节点。
  5. 将新节点添加到父节点：找到需要添加子节点的父节点，然后将其添加到父节点中。
  6. 保存修改后的XML文档：将修改后的Document对象写回到XML文件中。

代码示例：

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.io.File;
import java.io.IOException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
public class XmlAddChildNode {
    public static void main(String[] args) {
        try {
            // 1. 创建DocumentBuilderFactory和DocumentBuilder
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            // 2. 解析XML文件
            Document document = builder.parse(new File("input.xml"));
            // 3. 获取根节点
            Element root = document.getDocumentElement();
            // 4. 创建新节点
            Element newNode = document.createElement("newChild");
            newNode.setTextContent("This is a new child node");
            // 5. 将新节点添加到父节点
            root.appendChild(newNode);
            // 6. 保存修改后的XML文档
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(document);
            StreamResult result = new StreamResult(new File("output.xml"));
            transformer.transform(source, result);
            System.out.println("New node added successfully!");
        } catch (ParserConfigurationException | IOException | TransformerException e) {
            e.printStackTrace();
        }
    }
}

使用SAX解析器

SAX（Simple API for XML）是一种事件驱动的解析方式，它逐行读取XML文档，适合处理大型XML文件，SAX不支持直接修改XML文档，因此通常与DOM结合使用。

步骤：

  1. 导入相关库：需要导入javax.xml.parsers和org.xml.sax包。
  2. 创建SAX解析器：用于逐行读取XML文档。
  3. 在遇到目标节点时，动态创建新节点并添加到文档中：由于SAX不支持直接修改文档，通常需要在内存中构建新的文档结构。
  4. 保存修改后的XML文档：将构建好的文档写回到XML文件中。

代码示例：

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import java.io.File;
import java.io.IOException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
public class XmlAddChildNodeSAX {
    public static void main(String[] args) {
        try {
            // 1. 创建SAX解析器
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();
            // 2. 创建DocumentBuilderFactory和DocumentBuilder
            DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
            // 3. 解析XML文件
            Document document = docBuilder.parse(new File("input.xml"));
            // 4. 创建SAX事件处理器
            saxParser.parse(new File("input.xml"), new DefaultHandler() {
                @Override
                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
                    if (qName.equals("parentNode")) {
                        // 5. 创建新节点
                        Element newNode = document.createElement("newChild");
                        newNode.setTextContent("This is a new child node");
                        // 6. 将新节点添加到父节点
                        document.getDocumentElement().appendChild(newNode);
                    }
                }
            });
            // 7. 保存修改后的XML文档
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(document);
            StreamResult result = new StreamResult(new File("output.xml"));
            transformer.transform(source, result);
            System.out.println("New node added successfully!");
        } catch (ParserConfigurationException | SAXException | IOException | TransformerException e) {
            e.printStackTrace();
        }
    }
}

使用StAX解析器

StAX（Streaming API for XML）是一种介于DOM和SAX之间的解析方式，它允许你以流的方式读取和写入XML文档，同时支持更细粒度的控制。

步骤：

  1. 导入相关库：需要导入javax.xml.stream包。
  2. 创建XMLEventReader和XMLEventWriter：用于读取和写入XML文档。
  3. 逐行读取XML文档：在遇到目标节点时，动态创建新节点并写入到输出流中。
  4. 保存修改后的XML文档：将构建好的文档写回到XML文件中。

代码示例：

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.events.XMLEvent;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.XMLEventFactory;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class XmlAddChildNodeStAX {
    public static void main(String[] args) {
        try {
            // 1. 创建XMLInputFactory和XMLEventReader
            XMLInputFactory inputFactory = XMLInputFactory.newInstance();
            InputStream inputStream = new FileInputStream("input.xml");
            XMLEventReader eventReader = inputFactory.createXMLEventReader(inputStream);
            // 2. 创建XMLOutputFactory和XMLEventWriter
            XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
            OutputStream outputStream = new FileOutputStream("output.xml");
            XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(outputStream);
            // 3. 创建XMLEventFactory
            XMLEventFactory eventFactory = XMLEventFactory.newInstance();
            XMLEvent newNodeStart = eventFactory.createStartElement("", "newChild", "newChild");
            XMLEvent newNodeContent = eventFactory.createCharacters("This is a new child node");
            XMLEvent newNodeEnd = eventFactory.createEndElement("", "newChild", "newChild");
            // 4. 逐行读取XML文档
            while (eventReader.hasNext()) {
                XMLEvent event = eventReader.nextEvent();
                eventWriter.add(event);
                if (event instanceof StartElement && event.asStartElement().getName().getLocalPart().equals("parentNode")) {
                    // 5. 写入新节点
                    eventWriter.add(newNodeStart);
                    eventWriter.add(newNodeContent);
                    eventWriter.add(newNodeEnd);
                }
            }
            // 6. 关闭事件读写器
            eventWriter.close();
            eventReader.close();
            inputStream.close();
            outputStream.close();
            System.out.println("New node added successfully!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用JAXB（Java Architecture for XML Binding）

JAXB是一种将Java对象与XML数据绑定的技术,适合处理复杂的XML结构，通过JAXB，你可以将XML文档映射为Java对象，然后通过操作Java对象来修改XML文档。

步骤：

  1. 定义Java类：根据XML结构定义相应的Java类，并使用JAXB注解进行标注。
  2. 创建JAXBContext和Unmarshaller：用于将XML文档转换为Java对象。
  3. 修改Java对象：在Java对象中添加新的子节点。
  4. 创建Marshaller：将修改后的Java对象写回到XML文档中。
  5. 保存修改后的XML文档：将生成的XML文档写回到文件中。

代码示例：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class XmlAddChildNodeJAXB {
    public static void main(String[] args) {
        try {
            // 1. 创建JAXBContext和Unmarshaller
            JAXBContext context = JAXBContext.newInstance(ParentNode.class);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            // 2. 将XML文档转换为Java对象
            ParentNode parentNode = (ParentNode) unmarshaller.unmarshal(new File("input.xml"));
            // 3. 修改Java对象，添加新的子节点
            ChildNode newChild = new ChildNode();
            newChild.setContent("This is a new child node");
            parentNode.getChildren().add(newChild);
            // 4. 创建Marshaller，将修改后的Java对象写回到XML文档中
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.marshal(parentNode, new File("output.xml"));
            System.out.println("New node added successfully!");
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

Java类定义：

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;
import java.util.ArrayList;
@XmlRootElement(name = "parentNode")
public class ParentNode {
    private List<ChildNode> children;
    public ParentNode() {
        children = new ArrayList<>();
    }
    @XmlElement(name = "child")
    public List<ChildNode> getChildren() {
        return children;
    }
    public void setChildren(List<ChildNode> children) {
        this.children = children;
    }
}
import javax.xml.bind.annotation.XmlValue;
public class ChildNode {
    private String content;
    @XmlValue
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

归纳与比较

  • DOM：适合处理小型XML文档，操作简单，但内存消耗较大。
  • SAX：适合处理大型XML文档，内存消耗小，但操作复杂，不支持直接修改。
  • StAX：介于DOM和SAX之间，支持流式处理，适合需要细粒度控制的场景。
Java子节点
0

相关文章