How to parse and generate XML documents using XML parsing library in Java?

How to use the XML parsing library in Java to parse and generate XML documents?

XML (Extensible Markup Language) is a markup language used to store and transmit structured data. In Java development, we often encounter the need to parse and generate XML documents. Java provides many XML parsing libraries, such as DOM, SAX and JDOM, etc. These libraries can help us process XML documents easily.

This article will introduce how to use the XML parsing library in Java to parse and generate XML documents, and provide corresponding code examples.

1. Parsing XML documents

1. DOM parsing

DOM (Document Object Model) parsing is a parsing method based on a tree structure. The entire XML document is loaded into memory to form a tree structure, and the XML content is read and modified by operating the nodes of the tree.

The following is a code example that uses DOM to parse an XML document:

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

public class DOMParser {
    public static void main(String[] args) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("example.xml");
        
            NodeList nodeList = document.getElementsByTagName("student");
            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    Element element = (Element) node;
                    String id = element.getAttribute("id");
                    String name = element.getElementsByTagName("name").item(0).getTextContent();
                    String age = element.getElementsByTagName("age").item(0).getTextContent();
                    System.out.println("Student ID: " + id);
                    System.out.println("Name: " + name);
                    System.out.println("Age: " + age);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. SAX parsing

SAX (Simple API for XML) parsing is a method based on An event-driven parsing method that sequentially traverses the XML document, reads the start and end events of the nodes, and handles these events through callback functions.

The following is a code example of using SAX to parse an XML document:

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;

public class SAXParserExample {
    public static void main(String[] args) {
        try {
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser parser = factory.newSAXParser();
            
            DefaultHandler handler = new DefaultHandler() {
                boolean bName = false;
                boolean bAge = false;
                
                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
                    if (qName.equalsIgnoreCase("name")) {
                        bName = true;
                    }
                    
                    if (qName.equalsIgnoreCase("age")) {
                        bAge = true;
                    }
                }
                
                public void characters(char[] ch, int start, int length) throws SAXException {
                    if (bName) {
                        System.out.println("Name: " + new String(ch, start, length));
                        bName = false;
                    }
                    
                    if (bAge) {
                        System.out.println("Age: " + new String(ch, start, length));
                        bAge = false;
                    }
                }
            };
            
            parser.parse("example.xml", handler);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. Generate XML document

1. Use DOM to generate XML document

The following is a code example of using DOM to generate an XML document:

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class DOMGenerator {
    public static void main(String[] args) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.newDocument();
            
            Element root = document.createElement("students");
            document.appendChild(root);
            
            Element student = document.createElement("student");
            root.appendChild(student);
            
            Element name = document.createElement("name");
            name.appendChild(document.createTextNode("John"));
            student.appendChild(name);
            
            Element age = document.createElement("age");
            age.appendChild(document.createTextNode("20"));
            student.appendChild(age);
            
            // ... 追加更多的节点和数据
            
            // 保存为XML文件
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(document);
            StreamResult result = new StreamResult(new File("example.xml"));
            transformer.transform(source, result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. Using JDOM to generate an XML document

The following is a code example of using JDOM to generate an XML document:

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;

public class JDOMGenerator {
    public static void main(String[] args) {
        try {
            Element root = new Element("students");
            Document document = new Document(root);
            
            Element student = new Element("student");
            root.addContent(student);
            
            Element name = new Element("name");
            name.setText("John");
            student.addContent(name);
            
            Element age = new Element("age");
            age.setText("20");
            student.addContent(age);
            
            // ... 添加更多节点和数据
            
            // 输出为XML字符串
            XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
            String xmlString = outputter.outputString(document);
            System.out.println(xmlString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

The above is a simple example of using the XML parsing library in Java to parse and generate XML documents. In actual development, we can choose suitable parsing libraries and methods to process XML documents according to specific needs in order to operate and manage data more efficiently.

The above is the detailed content of How to parse and generate XML documents using XML parsing library in Java?. For more information, please follow other related articles on the PHP Chinese website!