Java XML 和 JSON 处理

XML (eXtensible Markup Language) 和 JSON (JavaScript Object Notation) 是当今最流行的数据交换格式。无论是调用 Web 服务、读取配置文件还是在不同系统间传输数据，都离不开它们。本章将介绍在 Java 中处理这两种格式的常用方法。

处理 XML

XML 是一种基于标签的标记语言，结构严谨，曾广泛用于配置文件和 SOAP Web 服务。Java 提供了多种处理 XML 的 API。

JAXB (Java Architecture for XML Binding)

JAXB 是一个强大的 API，它可以将 Java 对象编组 (Marshal) 为 XML，以及将 XML 解组 (Unmarshal) 回 Java 对象，实现了对象与 XML 之间的自动映射。

要使用 JAXB，需要定义一个与 XML 结构匹配的 Java 类，并使用 JAXB 注解来标记它。

// 1. 定义一个 Java 类，使用 JAXB 注解
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlElement;

@XmlRootElement
public class Customer {
    private String name;
    private int age;

    @XmlElement
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }

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

// 2. 编组 (Java 对象 -> XML)
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import java.io.File;

public class JaxbMarshalExample {
    public static void main(String[] args) throws Exception {
        Customer customer = new Customer();
        customer.setName("John Doe");
        customer.setAge(30);

        JAXBContext context = JAXBContext.newInstance(Customer.class);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); // 格式化输出

        // 输出到控制台
        marshaller.marshal(customer, System.out);
        // 输出到文件
        marshaller.marshal(customer, new File("customer.xml"));
    }
}
// 输出的 XML:
// <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
// <customer>
//     <age>30</age>
//     <name>John Doe</name>
// </customer>

注意: 从 Java 9 开始，JAXB 不再是标准库的一部分，需要作为单独的依赖项添加到项目中。

处理 JSON

JSON 是一种轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成。它已成为 RESTful API 的事实标准。

Java 标准库没有内置的 JSON 处理 API，但有许多优秀的第三方库可供选择，其中最流行的是：

• Jackson: 功能非常强大，性能优秀，是 Spring 等许多主流框架的默认选择。
• Gson: 由 Google 开发，API 简洁易用，非常适合简单的 JSON-对象映射。

使用 Jackson

Jackson 的核心组件是 ObjectMapper，它可以轻松地在 Java 对象和 JSON 字符串之间进行转换。

// 1. 定义一个简单的 POJO (Plain Old Java Object)
public class Car {
    private String brand;
    private int doors;

    // 需要 getter 和 setter，以及一个无参构造方法
    public Car() {}
    public Car(String brand, int doors) { this.brand = brand; this.doors = doors; }

    public String getBrand() { return brand; }
    public void setBrand(String brand) { this.brand = brand; }
    public int getDoors() { return doors; }
    public void setDoors(int doors) { this.doors = doors; }
}

// 2. 序列化 (Java 对象 -> JSON) 和反序列化 (JSON -> Java 对象)
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // --- 序列化 ---
        Car car = new Car("Toyota", 4);
        String jsonString = objectMapper.writeValueAsString(car);
        System.out.println("序列化后的 JSON: " + jsonString);
        // 输出: {"brand":"Toyota","doors":4}

        // --- 反序列化 ---
        String jsonToParse = "{\"brand\":\"Ford\",\"doors\":2}";
        Car parsedCar = objectMapper.readValue(jsonToParse, Car.class);
        System.out.println("反序列化后的品牌: " + parsedCar.getBrand()); // 输出: Ford
    }
}

使用 Gson

Gson 的用法与 Jackson 类似，主要通过 Gson 类来操作。

import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {
        Gson gson = new Gson();

        // --- 序列化 ---
        Car car = new Car("Honda", 4);
        String jsonString = gson.toJson(car);
        System.out.println("序列化后的 JSON: " + jsonString);
        // 输出: {"brand":"Honda","doors":4}

        // --- 反序列化 ---
        String jsonToParse = "{\"brand\":\"BMW\",\"doors\":2}";
        Car parsedCar = gson.fromJson(jsonToParse, Car.class);
        System.out.println("反序列化后的品牌: " + parsedCar.getBrand()); // 输出: BMW
    }
}

选择哪个库通常取决于项目的需求。对于需要高度定制和最佳性能的复杂项目，Jackson 是更好的选择。对于简单的数据绑定任务，Gson 的简洁性可能更具吸引力。