如何正确创建自定义XML元素？Java天气应用XML追加记录问题

Hey there! Let's work through your two XML-related issues with your weather app—appending search records and handling special characters in your XML elements. I've got you covered with practical solutions and explanations.

1. Fixing the "Can't Append New Search Records" Issue #

The most common reason you're overwriting instead of appending is that you're probably writing the entire XML file from scratch each time, rather than updating the existing one. Here are two reliable approaches to fix this:

Option 1: Use DOM Parser (Great for Small to Medium Files) #

DOM loads the entire XML into memory, making it easy to modify and append nodes. It's straightforward for apps with a manageable number of search records.

Add this method to your WeatherParser.java:

import org.w3c.dom.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;

public void appendSearchRecord(String searchTerm, String temperature) {
    DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
    Document weatherDoc;
    File xmlFile = new File("weatherSearches.xml");

    try {
        if (xmlFile.exists()) {
            // Load existing XML file
            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
            weatherDoc = docBuilder.parse(xmlFile);
            weatherDoc.getDocumentElement().normalize(); // Clean up DOM structure
        } else {
            // Create new document and root node if file doesn't exist
            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
            weatherDoc = docBuilder.newDocument();
            Element rootElement = weatherDoc.createElement("weathersearches");
            weatherDoc.appendChild(rootElement);
        }

        // Build the new <search> node
        Element searchNode = weatherDoc.createElement("search");
        
        // Add <term> element
        Element termElement = weatherDoc.createElement("term");
        termElement.setTextContent(searchTerm);
        searchNode.appendChild(termElement);
        
        // Add <temperature> element
        Element tempElement = weatherDoc.createElement("temperature");
        tempElement.setTextContent(temperature);
        searchNode.appendChild(tempElement);
        
        // Append new node to root
        weatherDoc.getDocumentElement().appendChild(searchNode);

        // Write updated DOM back to file (with pretty formatting)
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        DOMSource source = new DOMSource(weatherDoc);
        StreamResult result = new StreamResult(xmlFile);
        transformer.transform(source, result);

    } catch (Exception e) {
        e.printStackTrace(); // Replace with proper error handling for your app
    }
}

Key Notes:

• normalize() ensures the DOM tree is structured correctly (no extra whitespace nodes).
• Handles both first-time file creation and subsequent appends.
• setTextContent() automatically escapes special characters (like &, <, >) so you don't have to do it manually.

Option 2: Use StAX Parser (Best for Large Files) #

If you expect tons of search records, DOM might use too much memory. StAX uses a stream-based approach, which is more memory-efficient. The catch is you need to manually find the end of the root element to append new nodes:

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

public void appendSearchRecordStAX(String searchTerm, String temperature) throws XMLStreamException, IOException {
    File xmlFile = new File("weatherSearches.xml");
    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();

    if (!xmlFile.exists()) {
        // First run: create full XML structure
        XMLStreamWriter writer = outputFactory.createXMLStreamWriter(new FileOutputStream(xmlFile), "UTF-8");
        writer.writeStartDocument("UTF-8", "1.0");
        writer.writeStartElement("weathersearches");
        writeSearchNode(writer, searchTerm, temperature);
        writer.writeEndElement();
        writer.writeEndDocument();
        writer.close();
    } else {
        // Append mode: insert new node before </weathersearches>
        RandomAccessFile raf = new RandomAccessFile(xmlFile, "rw");
        long fileEndPos = raf.length() - "</weathersearches>".length();
        
        // Create temp file to build updated content
        File tempFile = File.createTempFile("weather_temp", ".xml");
        FileWriter tempWriter = new FileWriter(tempFile);

        // Copy existing content up to the root closing tag
        raf.seek(0);
        byte[] buffer = new byte[1024];
        int bytesRead;
        while (raf.getFilePointer() < fileEndPos) {
            bytesRead = raf.read(buffer);
            tempWriter.write(new String(buffer, 0, bytesRead));
        }

        // Write new <search> node
        XMLStreamWriter writer = outputFactory.createXMLStreamWriter(tempWriter);
        writeSearchNode(writer, searchTerm, temperature);
        writer.flush();
        writer.close();

        // Add back the root closing tag
        tempWriter.write("</weathersearches>");
        tempWriter.close();

        // Replace original file with temp file
        raf.close();
        if (!xmlFile.delete() || !tempFile.renameTo(xmlFile)) {
            throw new IOException("Failed to update search records file");
        }
    }
}

private void writeSearchNode(XMLStreamWriter writer, String term, String temp) throws XMLStreamException {
    writer.writeStartElement("search");
    writer.writeStartElement("term");
    writer.writeCharacters(term);
    writer.writeEndElement();
    writer.writeStartElement("temperature");
    writer.writeCharacters(temp);
    writer.writeEndElement();
    writer.writeEndElement();
}

Key Notes:

• Avoids loading the entire XML into memory, perfect for large datasets.
• Uses a temp file to safely modify the content without corrupting the original file.

2. Will "Unknown Symbols" in XML Elements Cause Problems? #

Short answer: It depends on the symbols. XML has strict rules about allowed characters, so invalid characters will break your XML file (making it unparseable).

What's Allowed? #

XML permits these characters in element text content:

• Tab (\t), newline (\n), carriage return (\r)
• Printable characters from U+0020 (space) to U+D7FF, U+E000 to U+FFFD, and U+10000 to U+10FFFF

What's Not Allowed? #

• Control characters like U+0000 to U+0008, U+000B, U+000C, U+000E to U+001F
• Unescaped special characters: &, <, >, ", ' (these need to be converted to &, <, >, ", ' respectively)

How to Fix It? #

If you use the DOM or StAX methods above, the setTextContent() (DOM) and writeCharacters() (StAX) methods automatically escape the special allowed characters (like &). For invalid control characters, you'll need to filter them out before writing to XML.

Add this helper method to clean up user input:

private String sanitizeXmlText(String input) {
    if (input == null) return "";
    StringBuilder cleanText = new StringBuilder();
    for (char c : input.toCharArray()) {
        // Check if character is allowed in XML
        if ((c == 0x9) || (c == 0xA) || (c == 0xD) ||
            ((c >= 0x20) && (c <= 0xD7FF)) ||
            ((c >= 0xE000) && (c <= 0xFFFD)) ||
            ((c >= 0x10000) && (c <= 0x10FFFF))) {
            cleanText.append(c);
        }
    }
    return cleanText.toString();
}

Call this before passing searchTerm or temperature to your append methods:

String cleanTerm = sanitizeXmlText(userSearchTerm);
String cleanTemp = sanitizeXmlText(weatherTemperature);
appendSearchRecord(cleanTerm, cleanTemp);

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