添加jackson-dataformat-xml及相關(guān)依賴；2. 使用XmlMapper將XML解析為JsonNode；3. 使用ObjectMapper將JsonNode序列化為JSON字符串；4. 可選地通過配置或手動處理去除根元素包裝。該方法利用Jackson庫高效實現(xiàn)XML到JSON的轉(zhuǎn)換，支持動態(tài)結(jié)構(gòu)且集成簡便，最終輸出格式化的JSON結(jié)果。

Converting XML to JSON in Java can be efficiently handled using the Jackson library , which supports both XML and JSON processing through its modules. While Jackson is best known for JSON handling ( jackson-databind ), you can extend it to read XML by using the Jackson XML module ( jackson-dataformat-xml ). Here's how you can convert XML to JSON step by step.

? Add Required Dependencies

First, make sure you have the necessary Maven dependencies in your pom.xml :

 <dependencies>
    <!-- Jackson Databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.3</version>
    </dependency>

    <!-- Jackson XML Module -->
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-xml</artifactId>
        <version>2.15.3</version>
    </dependency>

    <!-- Needed for XML processing (uses Woodstox) -->
    <dependency>
        <groupId>com.fasterxml.jackson.module</groupId>
        <artifactId>jackson-module-jaxb-annotations</artifactId>
        <version>2.15.3</version>
    </dependency>
</dependencies>

? Jackson uses StAX under the hood for XML parsing. Woodstox is a high-performance StAX implementation — you can include it optionally:

 <dependency>
    <groupId>com.fasterxml.woodstox</groupId>
    <artifactId>woodstox-core</artifactId>
    <version>6.5.1</version>
</dependency>

? Step-by-Step: Convert XML to JSON

Here's a complete example that reads an XML string, parses it into a Java object using Jackson XML, then serializes it to JSON.

1. Create a Simple POJO (if structure is known)

Suppose you have this XML:

 <person>
    <name>John Doe</name>
    <age>30</age>
    <city>New York</city>
</person>

Create a matching class:

 import com.fasterxml.jackson.annotation.JsonProperty;

public class Person {
    @JsonProperty("name")
    private String name;

    @JsonProperty("age")
    private int age;

    @JsonProperty("city")
    private String city;

    // Getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
}

2. Convert XML to JSON Using Jackson

 import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

public class XmlToJsonConverter {

    public static void main(String[] args) {
        String xml = "<person><name>John Doe</name><age>30</age><city>New York</city></person>";

        try {
            // Step 1: Parse XML into a JsonNode (generic representation)
            XmlMapper xmlMapper = new XmlMapper();
            JsonNode node = xmlMapper.readTree(xml.getBytes());

            // Step 2: Convert JsonNode to JSON string
            ObjectMapper jsonMapper = new ObjectMapper();
            String json = jsonMapper.writerWithDefaultPrettyPrinter().writeValueAsString(node);

            System.out.println(json);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

? Output (JSON):

 {
  "person" : {
    "name" : "John Doe",
    "age" : 30,
    "city" : "New York"
  }
}

? Note: The root element becomes a field in JSON. If you want to remove the wrapper ( "person" ), keep reading.

?? Optional: Remove Root Wrapper

By default, XmlMapper wraps content under the root tag. To eliminate that layer:

 xmlMapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);

But this requires @JsonRootName on your POJO:

 @JsonRootName("person")
public class Person { ... }

Alternatively, work with JsonNode and extract the first child manually:

 JsonNode personNode = node.get("person");
String json = jsonMapper.writeValueAsString(personNode);

? Advantages of This Approach

• No need to define POJOs if using JsonNode (great for dynamic or unknown XML).
• Leverages Jackson's robust parsing and formatting.
• Clean, readable code with minimal dependencies.

?? Limitations & Notes

• XML attributes are prefixed with @ in JSON (eg, {"@id": "123"} ).
• Repeated elements become JSON arrays automatically.
• Mixed content (text elements) may not serialize cleanly.
• Processing instructions and namespaces are usually ignored unless explicitly handled.

? Summary

To convert XML to JSON in Java using Jackson:

1. Add jackson-dataformat-xml and related dependencies.
2. Use XmlMapper to read XML into a JsonNode .
3. Use ObjectMapper to write that JsonNode as formatted JSON.
4. Optionally clean up structure (remove root, handle arrays, etc.).

This method is simple, efficient, and integrates well with existing Jackson-based applications.

Basically just two mappers — one to read XML, one to write JSON — and you're done.

以上是如何使用Jackson將XML轉(zhuǎn)換為Java的JSON的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！