Java中字符串XML转JSON且保留原数据的方案咨询

方案一：使用Jackson XML + JSON模块（Java 1.8兼容） #

Jackson的XML与JSON处理模块支持自定义类型解析规则，能强制将所有XML节点值按字符串处理，避免自动转换丢失前导零，且Java 1.8有对应兼容版本。

步骤1：添加Maven依赖 #

选用兼容Java 1.8的Jackson 2.12.x版本：

<dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-xml</artifactId>
        <version>2.12.7</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.7</version>
    </dependency>
</dependencies>

步骤2：转换代码实现 #

配置XML解析器强制以字符串读取所有节点值，再转成JSON：

import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import java.io.IOException;

public class XmlToJsonConverter {
    public static String convertXmlToJson(String xmlStr) throws Exception {
        // 配置XML解析器，禁用自动数字类型转换
        XmlMapper xmlMapper = new XmlMapper();
        xmlMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, false);
        xmlMapper.configure(DeserializationFeature.USE_LONG_FOR_INTS, false);
        
        // 自定义处理逻辑，强制所有值按字符串解析
        xmlMapper.addHandler(new DeserializationProblemHandler() {
            @Override
            public Object handleUnexpectedToken(DeserializationContext ctxt, Class<?> targetType, JsonToken t, JsonParser p, String failureMsg) throws IOException {
                if (!targetType.equals(String.class)) {
                    return p.getText();
                }
                return super.handleUnexpectedToken(ctxt, targetType, t, p, failureMsg);
            }
        });

        // XML转通用对象（所有值为字符串）
        Object xmlObj = xmlMapper.readValue(xmlStr, Object.class);
        
        // 通用对象转JSON字符串
        ObjectMapper jsonMapper = new ObjectMapper();
        jsonMapper.configure(com.fasterxml.jackson.databind.SerializationFeature.INDENT_OUTPUT, true);
        return jsonMapper.writeValueAsString(xmlObj);
    }

    public static void main(String[] args) throws Exception {
        String xml = "<root><id>00123</id><code>000ABC</code><number>00456</number></root>";
        System.out.println(convertXmlToJson(xml));
    }
}

这段代码会将所有XML节点值保留为字符串，不会自动转换为数字类型，前导零可完整保留。

方案二：DOM解析+手动构建JSON（完全自定义控制） #

如果不想引入第三方库或需要精细控制转换逻辑，可使用Java原生DOM解析XML，再手动构建JSON对象（依赖org.json库，兼容Java 1.8）。

步骤1：添加Maven依赖 #

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20230227</version>
</dependency>

步骤2：转换代码实现 #

import org.json.JSONObject;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.ByteArrayInputStream;

public class DomXmlToJson {
    public static String convert(String xmlStr) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(new ByteArrayInputStream(xmlStr.getBytes()));
        doc.getDocumentElement().normalize();

        JSONObject jsonObj = new JSONObject();
        processNode(doc.getDocumentElement(), jsonObj);

        return jsonObj.toString(4);
    }

    private static void processNode(Node node, JSONObject parentJson) {
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            String nodeName = node.getNodeName();
            NodeList childNodes = node.getChildNodes();

            // 单文本子节点直接存字符串值
            if (childNodes.getLength() == 1 && childNodes.item(0).getNodeType() == Node.TEXT_NODE) {
                parentJson.put(nodeName, childNodes.item(0).getTextContent().trim());
                return;
            }

            // 递归处理子元素节点
            JSONObject childJson = new JSONObject();
            for (int i = 0; i < childNodes.getLength(); i++) {
                Node child = childNodes.item(i);
                processNode(child, childJson);
            }
            parentJson.put(nodeName, childJson);
        }
    }

    public static void main(String[] args) throws Exception {
        String xml = "<root><id>00123</id><code>000ABC</code><number>00456</number></root>";
        System.out.println(convert(xml));
    }
}

该方法完全手动处理每个节点，所有值均以字符串形式存入JSON，确保原始文本（含前导零）完全保留，无类型转换问题。

方案对比 #

• Jackson方案：代码简洁，支持复杂XML结构（嵌套数组、属性等），适合大多数常规场景。
• DOM手动构建方案：除org.json外无额外依赖，完全可控，适合需精细处理XML节点的场景，但复杂结构需额外处理数组逻辑。

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