xml json 转换 java-杰瑞科技汇

核心思路

转换的核心思路通常分为两种：

（图片来源网络，侵删）

通过中间对象（最常用）：
- XML → Java 对象 → JSON：使用 XML 解析库（如 JAXB, Jackson XML）将 XML 字符串或文件反序列化为一个 Java 对象（POJO），然后使用 JSON 库（如 Jackson, Gson）将这个 Java 对象序列化为 JSON 字符串。
- JSON → Java 对象 → XML：过程相反。
直接转换（较少用）：

使用一些专门的库，可以直接在 XML 和 JSON 格式之间进行转换，而无需显式创建中间的 Java 对象，这种方法在某些场景下很方便,但灵活性较差。

使用 Jackson (推荐)

Jackson 是一个功能强大、性能极高的 Java 库，它不仅能处理 JSON，还能通过 jackson-dataformat-xml 模块来处理 XML，这是目前最流行和推荐的方式，因为它可以让你用一套 API 处理两种格式。

（图片来源网络，侵删）

添加 Maven 依赖

在你的 pom.xml 文件中添加 Jackson 的核心依赖和 XML 模块依赖。

<dependencies>
    <!-- Jackson Core -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.15.2</version> <!-- 使用最新版本 -->
    </dependency>
    <!-- Jackson Databind (包含核心和 databind) -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>
    <!-- Jackson XML module -->
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-xml</artifactId>
        <version>2.15.2</version>
    </dependency>
</dependencies>

创建 Java POJO (Plain Old Java Object)

你需要一个与 XML/JSON 结构对应的 Java 类。

// User.java
import com.fasterxml.jackson.annotation.JsonProperty;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "user") // 用于 JAXB 和 Jackson XML 映射根标签
public class User {
    private String name;
    private int age;
    private String email;
    // 无参构造函数是必须的
    public User() {
    }
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    // Getter 和 Setter
    @JsonProperty("name") // 用于 JSON 映射，也可以不写，Jackson 会根据字段名推断
    @XmlElement(name = "name") // 用于 XML 映射
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @JsonProperty("age")
    @XmlElement(name = "age")
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @JsonProperty("email")
    @XmlElement(name = "email")
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

实现转换代码

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
public class JacksonConverter {
    public static void main(String[] args) throws Exception {
        // --- 准备数据 ---
        User user = new User("张三", 30, "zhangsan@example.com");
        // --- 1. Java 对象 -> JSON ---
        System.out.println("--- Java Object to JSON ---");
        ObjectMapper jsonMapper = new ObjectMapper();
        String jsonString = jsonMapper.writeValueAsString(user);
        System.out.println(jsonString);
        // 输出: {"name":"张三","age":30,"email":"zhangsan@example.com"}
        // --- 2. Java 对象 -> XML ---
        System.out.println("\n--- Java Object to XML ---");
        XmlMapper xmlMapper = new XmlMapper();
        String xmlString = xmlMapper.writeValueAsString(user);
        System.out.println(xmlString);
        // 输出:
        // <user>
        //   <name>张三</name>
        //   <age>30</age>
        //   <email>zhangsan@example.com</email>
        // </user>
        // --- 3. JSON -> Java 对象 ---
        System.out.println("\n--- JSON to Java Object ---");
        User fromJson = jsonMapper.readValue(jsonString, User.class);
        System.out.println(fromJson);
        // 输出: User{name='张三', age=30, email='zhangsan@example.com'}
        // --- 4. XML -> Java 对象 ---
        System.out.println("\n--- XML to Java Object ---");
        User fromXml = xmlMapper.readValue(xmlString, User.class);
        System.out.println(fromXml);
        // 输出: User{name='张三', age=30, email='zhangsan@example.com'}
    }
}

使用 Gson + JAXB

这种方法是两个库的组合使用,也比较常见。

Gson: Google 的 JSON 处理库,非常简洁易用。
JAXB (Java Architecture for XML Binding): Java 标准库，用于在 Java 对象和 XML 之间绑定，从 Java 6 开始就内置了。

添加 Maven 依赖

只需要 Gson，因为 JAXB 是 Java 标准库。

（图片来源网络，侵删）

<dependencies>
    <!-- Google Gson -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version> <!-- 使用最新版本 -->
    </dependency>
</dependencies>

创建 Java POJO

POJO 的定义和上面 Jackson 的例子几乎一样，只需要 JAXB 的注解即可。

// User.java
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "user")
public class User {
    private String name;
    private int age;
    private String email;
    public User() {}
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    @XmlElement
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    @XmlElement
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    @XmlElement
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

实现转换代码

import com.google.gson.Gson;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
import java.io.StringWriter;
public class GsonJAXBConverter {
    public static void main(String[] args) throws Exception {
        // --- 准备数据 ---
        User user = new User("李四", 25, "lisi@example.com");
        // --- 1. Java 对象 -> XML (使用 JAXB) ---
        System.out.println("--- Java Object to XML (JAXB) ---");
        JAXBContext jaxbContext = JAXBContext.newInstance(User.class);
        Marshaller marshaller = jaxbContext.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); // 美化输出
        StringWriter writer = new StringWriter();
        marshaller.marshal(user, writer);
        String xmlString = writer.toString();
        System.out.println(xmlString);
        // --- 2. XML -> Java 对象 (使用 JAXB) ---
        System.out.println("\n--- XML to Java Object (JAXB) ---");
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        StringReader reader = new StringReader(xmlString);
        User fromXml = (User) unmarshaller.unmarshal(reader);
        System.out.println(fromXml);
        // --- 3. Java 对象 -> JSON (使用 Gson) ---
        System.out.println("\n--- Java Object to JSON (Gson) ---");
        Gson gson = new Gson();
        String jsonString = gson.toJson(user);
        System.out.println(jsonString);
        // --- 4. JSON -> Java 对象 (使用 Gson) ---
        System.out.println("\n--- JSON to Java Object (Gson) ---");
        User fromJson = gson.fromJson(jsonString, User.class);
        System.out.println(fromJson);
    }
}

直接转换 (使用 Simple)

如果你只是想快速地在字符串层面转换，而不关心中间的 Java 对象，可以使用 org.json 库,它提供了直接转换的方法。

添加 Maven 依赖

<dependencies>
    <!-- org.json -->
    <dependency>
        <groupId>org.json</groupId>
        <artifactId>json</artifactId>
        <version>20251013</version> <!-- 使用最新版本 -->
    </dependency>
</dependencies>

实现转换代码

这种方法不依赖于 POJO,直接操作字符串。

import org.json.JSONObject;
import org.json.XML;
public class DirectConverter {
    public static void main(String[] args) {
        // --- 1. XML -> JSON ---
        String xmlString = "<user><name>王五</name><age>40</age><email>wangwu@example.com</email></user>";
        // org.json 提供了直接的转换方法
        JSONObject jsonObject = XML.toJSONObject(xmlString);
        String jsonString = jsonObject.toString(2); // 参数 2 表示缩进2个空格，美化输出
        System.out.println("--- XML to JSON ---");
        System.out.println(jsonString);
        /*
        输出:
        {
          "user": {
            "name": "王五",
            "age": 40,
            "email": "wangwu@example.com"
          }
        }
        */
        // --- 2. JSON -> XML ---
        String newXmlString = XML.toString(jsonObject);
        System.out.println("\n--- JSON to XML ---");
        System.out.println(newXmlString);
        // 输出: <user><name>王五</name><age>40</age><email>wangwu@example.com</email></user>
    }
}

注意: 这种方法的缺点是灵活性差，XML 中的属性（<user id="123">）在转换到 JSON 时可能会变成 {"user": {"@id": "123", ...}},处理起来比较麻烦。

总结与对比

特性	Jackson	Gson + JAXB	org.json (直接转换)
易用性	高，一套API，配置简单	中等，需要了解两个库	极高，方法直接
灵活性	极高，注解丰富，可定制性强	高，JAXB注解强大	低，直接操作字符串，难以处理复杂结构
性能	非常高	高	一般
依赖	需要添加 `jackson-dataformat-xml`	只需添加 `gson`	只需添加 `org.json`
适用场景	强烈推荐，适用于绝大多数项目，尤其是需要处理复杂数据结构、高性能要求的场景。	适合已经在使用Gson或JAXB的老项目。	适合简单的、快速的、非结构化的数据转换，或作为原型验证。

最终建议：

新项目：请毫不犹豫地选择 Jackson，它是目前 Java 生态中最成熟、功能最全、性能最好的选择。
现有项目：如果你的项目已经在广泛使用 Gson 或 JAXB，继续使用它们组合是合理的，无需为了转换而引入新的 Jackson 依赖。
快速原型/简单脚本：如果只是临时写个脚本转换一下简单的数据，org.json 的直接转换方式最快最方便。

xml json 转换 java

核心思路

使用 Jackson (推荐)

添加 Maven 依赖

创建 Java POJO (Plain Old Java Object)

实现转换代码

使用 Gson + JAXB

添加 Maven 依赖

创建 Java POJO

实现转换代码

直接转换 (使用 Simple)

添加 Maven 依赖

实现转换代码

总结与对比

99ANYc3cd6

Access教程百度云哪里找？

Eclipse如何创建Java项目？

Java JSON如何转换成XML？

Python locmemcache是什么？如何高效使用？

Java如何发送HTTP POST请求？

python phantomjs配置

如何用Python操作MySQL？pymsq怎么用？

java string 转 byte

Java如何判断Socket是否已连接？

U盘Win7原版系统安装教程如何操作？

SketchUp 8视频教程，从零开始学吗？

Python staticmethod 与普通方法有何区别？

Linux OpenCV Python如何高效配置与使用？

Java list contains如何高效判断元素存在？

Java和JavaScript，仅一字之差，区别究竟在哪？

Ubuntu下Python如何安装使用libsvm？

xml json 转换 java

核心思路

使用 Jackson (推荐)

添加 Maven 依赖

创建 Java POJO (Plain Old Java Object)

实现转换代码

使用 Gson + JAXB

添加 Maven 依赖

创建 Java POJO

实现转换代码

直接转换 (使用 Simple)

添加 Maven 依赖

实现转换代码

总结与对比

相关推荐

python phantomjs配置