如何在Java中修改XML中指定name的job节点？

Got it, let's tackle this problem of modifying a specific <job> node by its <name> in your XML. Here are a few reliable Java approaches you can use, with concrete code examples to make it easy to follow:

1. 使用Java原生DOM API #

The DOM API comes built right into Java, so you don't need any external libraries. It's a bit verbose, but perfect for small to medium XML files where you don't want to add dependencies.

Here's a complete example that finds the job with name="Job2" and updates its <time> and <status> values:

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;
import java.io.StringReader;
import org.xml.sax.InputSource;

public class XmlDomModifier {
    public static void main(String[] args) {
        try {
            // 1. Parse XML (use StringReader if working with an XML string instead of file)
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            
            // Option 1: Parse from file
            // Document doc = builder.parse(new File("jobs.xml"));
            
            // Option 2: Parse from XML string
            String xmlContent = "<list> <job> <id>B001</id> <name>Job1</name> <time>7</time> <status>success</status> </job> <job> <id>B002</id> <name>Job2</name> <time>1</time> <status>success</status> </job> </list>";
            InputSource inputSource = new InputSource(new StringReader(xmlContent));
            Document doc = builder.parse(inputSource);

            // 2. Get all <job> nodes
            NodeList jobNodes = doc.getElementsByTagName("job");

            // 3. Traverse to find the target job by name
            String targetName = "Job2";
            for (int i = 0; i < jobNodes.getLength(); i++) {
                Element jobElement = (Element) jobNodes.item(i);
                Element nameElement = (Element) jobElement.getElementsByTagName("name").item(0);
                String currentName = nameElement.getTextContent();

                if (targetName.equals(currentName)) {
                    // Update <time> value
                    Element timeElement = (Element) jobElement.getElementsByTagName("time").item(0);
                    timeElement.setTextContent("5");
                    
                    // Update <status> value
                    Element statusElement = (Element) jobElement.getElementsByTagName("status").item(0);
                    statusElement.setTextContent("in_progress");
                    
                    break; // Exit loop once target is found
                }
            }

            // 4. Write modified XML back to file or string
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // Pretty print output
            
            // Option 1: Write to file
            // StreamResult result = new StreamResult(new File("updated_jobs.xml"));
            
            // Option 2: Write to string
            StreamResult result = new StreamResult(new StringWriter());
            transformer.transform(new DOMSource(doc), result);
            String updatedXml = result.getWriter().toString();
            System.out.println("Updated XML:\n" + updatedXml);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 使用JDOM2（更简洁的第三方库） #

JDOM2 simplifies XML handling with a more intuitive, less boilerplate-heavy API. You'll need to add its dependency first:

For Maven, add this to your pom.xml:

<dependency>
    <groupId>org.jdom</groupId>
    <artifactId>jdom2</artifactId>
    <version>2.0.6.1</version>
</dependency>

Here's the streamlined code example:

import org.jdom2.*;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.List;

public class JdomXmlModifier {
    public static void main(String[] args) {
        try {
            // Parse XML string
            String xmlContent = "<list> <job> <id>B001</id> <name>Job1</name> <time>7</time> <status>success</status> </job> <job> <id>B002</id> <name>Job2</name> <time>1</time> <status>success</status> </job> </list>";
            SAXBuilder saxBuilder = new SAXBuilder();
            Document doc = saxBuilder.build(new StringReader(xmlContent));
            Element root = doc.getRootElement();

            // Get all <job> elements
            List<Element> jobElements = root.getChildren("job");

            // Find and modify target job
            String targetName = "Job2";
            for (Element job : jobElements) {
                if (targetName.equals(job.getChildText("name"))) {
                    job.getChild("time").setText("5");
                    job.getChild("status").setText("in_progress");
                    break;
                }
            }

            // Output modified XML
            XMLOutputter xmlOutput = new XMLOutputter(Format.getPrettyFormat());
            StringWriter writer = new StringWriter();
            xmlOutput.output(doc, writer);
            System.out.println("Updated XML:\n" + writer.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 使用Jackson XML（对象映射方式） #

If you prefer working with Java objects instead of raw XML nodes, Jackson can serialize/deserialize XML to POJOs. This is great for complex XML structures where OOP makes the code more maintainable.

First, add the Jackson XML dependency:

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.15.2</version>
</dependency>

Create your POJO classes to map the XML structure:

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import java.util.List;

@JacksonXmlRootElement(localName = "list")
public class JobList {
    @JacksonXmlElementWrapper(useWrapping = false) // Avoid extra <jobs> wrapper node
    private List<Job> job;

    // Getters and Setters
    public List<Job> getJob() { return job; }
    public void setJob(List<Job> job) { this.job = job; }
}

class Job {
    private String id;
    private String name;
    private String time;
    private String status;

    // Getters and Setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getTime() { return time; }
    public void setTime(String time) { this.time = time; }
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
}

Now the code to modify the XML via objects:

import com.fasterxml.jackson.dataformat.xml.XmlMapper;

public class JacksonXmlModifier {
    public static void main(String[] args) {
        try {
            XmlMapper xmlMapper = new XmlMapper();
            String xmlContent = "<list> <job> <id>B001</id> <name>Job1</name> <time>7</time> <status>success</status> </job> <job> <id>B002</id> <name>Job2</name> <time>1</time> <status>success</status> </job> </list>";
            
            // Convert XML to Java object
            JobList jobList = xmlMapper.readValue(xmlContent, JobList.class);

            // Modify target job
            String targetName = "Job2";
            for (Job job : jobList.getJob()) {
                if (targetName.equals(job.getName())) {
                    job.setTime("5");
                    job.setStatus("in_progress");
                    break;
                }
            }

            // Convert modified object back to XML
            String updatedXml = xmlMapper.writerWithDefaultPrettyPrinter().writeValueAsString(jobList);
            System.out.println("Updated XML:\n" + updatedXml);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Quick Recommendation #

• DOM API: Go with this if you want no external dependencies and are dealing with small XML snippets.
• JDOM2: Best balance of simplicity and functionality for most XML modification tasks.
• Jackson XML: Ideal for complex XML structures or if you're already using Jackson for JSON processing in your project.

内容的提问来源于stack exchange，提问作者Nguyen Hoang Vu