如何使用Java的JAXB实现XML和Java对象互相转换？

畫卷琴夢

发布时间：2025-08-01 08:30:02

630人浏览过

来源于php中文网

原创

使用jaxb实现xml与java对象互转的核心步骤是：定义带注解的java类，创建jaxbcontext，利用marshaller和unmarshaller进行序列化与反序列化；2. 常用jaxb注解包括@xmlrootelement定义根元素，@xmlelement映射子元素，@xmlattribute映射属性，@xmltransient忽略字段，@xmltype控制元素顺序，@xmlaccessortype设置访问类型，@xmlelementwrapper用于集合包装；3. 处理复杂对象时，jaxb支持嵌套对象自动序列化、集合类型的扁平化输出或通过@xmlelementwrapper包裹，以及通过@xmljavatypeadapter实现自定义类型转换；4. 常见问题及解决方案：命名空间问题通过@xmlelement的namespace属性或package-info.java中@xmlschema定义，日期格式问题使用@xmljavatypeadapter自定义适配器，null值处理通过@xmlelement(nillable=true)生成xsi:nil元素，集合直接序列化需创建带@xmlrootelement的包装类。以上步骤和注解组合使用可完整实现jaxb在java与xml间的数据绑定，满足实际开发中的多样化需求。

如何使用Java的JAXB实现XML和Java对象互相转换？

JAXB（Java Architecture for XML Binding）提供了一套优雅的机制，让我们能够非常方便地在Java对象和XML文档之间进行转换。它通过注解来定义Java类与XML结构之间的映射关系，然后利用其API实现序列化（Java对象到XML）和反序列化（XML到Java对象）。这大大简化了处理XML的繁琐工作，让开发者可以更专注于业务逻辑。

解决方案

要使用JAXB实现XML和Java对象之间的互相转换，核心步骤涉及定义可绑定的Java类、创建JAXB上下文以及使用Marshaller和Unmarshaller。

1. 定义可绑定的Java类

立即学习“Java免费学习笔记（深入）”；

首先，你需要创建一个普通的Java类，并使用JAXB提供的注解来标记其与XML元素和属性的对应关系。

import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlType;
import java.util.Date;

@XmlRootElement(name = "book") // 定义XML根元素名称
@XmlType(propOrder = {"id", "title", "author", "publicationDate"}) // 控制XML元素顺序
public class Book {
    private Long id;
    private String title;
    private String author;
    private Date publicationDate; // 假设需要处理日期

    public Book() {
    }

    public Book(Long id, String title, String author, Date publicationDate) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.publicationDate = publicationDate;
    }

    @XmlAttribute // 标记为XML属性
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @XmlElement(name = "bookTitle") // 标记为XML元素，并指定名称
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @XmlElement // 标记为XML元素，默认使用字段名
    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    // JAXB默认对Date类型有处理，但通常需要自定义格式
    @XmlElement(name = "pubDate")
    public Date getPublicationDate() {
        return publicationDate;
    }

    public void setPublicationDate(Date publicationDate) {
        this.publicationDate = publicationDate;
    }

    @Override
    public String toString() {
        return "Book{" +
               "id=" + id +
               ", title='" + title + '\'' +
               ", author='" + author + '\'' +
               ", publicationDate=" + publicationDate +
               '}';
    }
}

2. 实现Java对象到XML的转换（Marshalling）

这部分是将Java对象序列化成XML文档。

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import java.io.StringWriter;
import java.util.Date;

public class JAXBMarshallerExample {
    public static void main(String[] args) {
        try {
            Book book = new Book(101L, "JAXB实战指南", "张三", new Date());

            // 1. 创建JAXBContext实例，指定要绑定的类
            JAXBContext context = JAXBContext.newInstance(Book.class);

            // 2. 创建Marshaller实例
            Marshaller marshaller = context.createMarshaller();

            // 3. 配置Marshaller的属性
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); // 格式化输出，方便阅读
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8"); // 设置编码

            // 4. 执行转换，将Java对象写入到输出流（例如：控制台、文件、字符串）
            StringWriter writer = new StringWriter();
            marshaller.marshal(book, writer); // 将book对象转换为XML并写入writer

            System.out.println("Java对象转换为XML:\n" + writer.toString());

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

输出示例：



    JAXB实战指南
    张三
    2023-10-27T10:00:00.000+08:00

3. 实现XML到Java对象的转换（Unmarshalling）

这部分是将XML文档反序列化成Java对象。

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;

public class JAXBUnmarshallerExample {
    public static void main(String[] args) {
        String xmlString = "\n" +
                           "\n" +
                           "    XML解析技巧\n" +
                           "    李四\n" +
                           "    2022-05-15T14:30:00.000+08:00\n" +
                           "";

        try {
            // 1. 创建JAXBContext实例，指定要绑定的类
            JAXBContext context = JAXBContext.newInstance(Book.class);

            // 2. 创建Unmarshaller实例
            Unmarshaller unmarshaller = context.createUnmarshaller();

            // 3. 执行转换，从输入流（例如：字符串、文件）读取XML并转换为Java对象
            StringReader reader = new StringReader(xmlString);
            Book book = (Book) unmarshaller.unmarshal(reader);

            System.out.println("\nXML转换为Java对象:\n" + book.toString());

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

输出示例：

XML转换为Java对象:
Book{id=102, title='XML解析技巧', author='李四', publicationDate=Sun May 15 14:30:00 CST 2022}

JAXB注解有哪些常用类型及其作用？

JAXB的强大之处在于它提供了一系列注解，让我们可以非常精细地控制Java对象和XML结构之间的映射关系。理解这些注解是高效使用JAXB的关键。

@XmlRootElement: 这个注解通常用在类的层面，它定义了该Java类在被序列化成XML时，对应的XML根元素的名称。比如，@XmlRootElement(name = "product") 会让 Product 类的实例序列化后以作为根标签。如果省略 name 属性，默认会使用类名的小写形式。它是进行XML绑定的起点，通常一个需要独立序列化的对象都需要这个注解。
@XmlElement: 用于字段或getter方法上，将Java对象的某个属性映射为XML的一个子元素。你可以通过 name 属性指定XML元素的名称（例如：@XmlElement(name = "itemName")），否则默认使用Java属性名。nillable = true 可以让属性为 null 时生成一个带有 xsi:nil="true" 的空元素，而不是直接忽略该元素。required = true 则表示该元素在XML中必须存在。
@XmlAttribute: 和 @XmlElement 类似，但它将Java对象的属性映射为XML元素的属性。例如，@XmlAttribute(name = "id") 会将Java对象的 id 属性映射为XML标签上的 id 属性，如。它通常用于标识符或一些元数据。
@XmlTransient: 如果你某个Java属性不希望被JAXB序列化到XML中，或者在反序列化时忽略XML中的某个元素，就可以用 @XmlTransient 标记该字段或其getter方法。这在处理一些内部状态或不需要暴露给外部XML的数据时非常有用。
@XmlType: 这个注解同样作用于类上，它允许你更细粒度地控制XML元素的顺序（通过 propOrder 属性，指定属性在XML中出现的顺序，例如：@XmlType(propOrder = {"name", "description", "price"})），以及定义XML命名空间等。propOrder 对于保持XML结构的一致性和可读性非常有帮助。
@XmlAccessorType: 默认情况下，JAXB会根据Java类的public getter/setter方法或public字段来推断映射关系。@XmlAccessorType 注解可以改变这种默认行为。它有几个枚举值：
- XmlAccessType.PUBLIC_MEMBER (默认): 映射所有public字段和public getter/setter方法。
- XmlAccessType.FIELD: 映射所有非静态、非瞬态的字段，无论其可见性如何。
- XmlAccessType.PROPERTY: 映射所有public getter/setter方法。
- XmlAccessType.NONE: 不映射任何字段或方法，除非它们被特定的JAXB注解明确标记。这个注解通常用于类级别，影响该类中所有成员的默认映射行为。
@XmlElementWrapper: 当你有一个集合（例如 List）需要被一个父元素包裹时，这个注解就派上用场了。例如，List 默认可能生成多个标签，如果你想让它们都在一个标签内，就可以在 List 字段上使用 @XmlElementWrapper(name = "items")。

这些注解构成了JAXB映射的基础，通过它们的组合使用，几乎可以满足所有复杂的XML结构与Java对象之间的映射需求。实际操作中，可能还需要结合 package-info.java 文件来定义全局的命名空间或者其他包级别的JAXB配置。

处理复杂对象或集合类型时JAXB如何应对？

JAXB在处理复杂对象和集合类型时表现得相当灵活和直观，这得益于其对对象图的遍历能力和一系列专门的注解。

1. 嵌套对象（复杂对象）

当一个Java对象包含另一个自定义Java对象的引用时，JAXB能够自然地处理这种嵌套关系。只要被引用的内部对象类也遵循JAXB的绑定规则（例如，它的字段也使用 @XmlElement 或 @XmlAttribute 标记），JAXB就会自动递归地将它们序列化为XML的嵌套元素。

例如，如果我们有一个 Order 类，其中包含一个 Customer 类的实例：

@XmlRootElement
public class Order {
    private Long orderId;
    private Customer customer; // 嵌套对象

    // ... getters and setters
}

@XmlType // 或者 @XmlRootElement 如果它可能单独作为根元素
public class Customer {
    private String name;
    private String address;

    // ... getters and setters
}

序列化 Order 对象时，JAXB会自动生成类似这样的XML：

2. 集合类型（List, Set等）

Lobe

微软旗下的一个训练器学习模型的平台

下载

JAXB处理集合类型主要有两种方式，取决于你希望XML如何表示这些集合：

默认行为（扁平化）: 如果你直接在一个 List 或 Set 类型的字段上使用 @XmlElement，JAXB会为集合中的每个元素生成一个重复的XML元素。

@XmlRootElement
public class ShoppingCart {
    private List items; // 假设是字符串列表

    @XmlElement(name = "item")
    public List getItems() {
        return items;
    }
    public void setItems(List items) {
        this.items = items;
    }
}

这将生成：


    Apple
    Banana
    Orange

如果 items 是 List 这样的自定义对象列表，每个 Product 对象也会被序列化为标签下的嵌套结构。

使用 @XmlElementWrapper 包裹: 当你希望集合中的所有元素都包含在一个父元素下时，@XmlElementWrapper 就非常有用。它作用于集合字段或其getter方法上。

@XmlRootElement
public class OrderDetails {
    private List products;

    @XmlElementWrapper(name = "productsList") // 集合的父元素
    @XmlElement(name = "productItem") // 集合中每个元素的名称
    public List getProducts() {
        return products;
    }
    public void setProducts(List products) {
        this.products = products;
    }
}

@XmlType // 产品类
public class Product {
    private String name;
    private double price;
    // ... getters and setters
}

这将生成：

@XmlElementWrapper 提供了更好的结构化和可读性，尤其是在处理大型集合时。

3. 自定义类型适配器 (@XmlJavaTypeAdapter)

对于一些JAXB无法直接处理的类型（比如特定的日期格式、自定义的复杂数据结构，或者需要对数据进行特殊转换的情况），可以使用 @XmlJavaTypeAdapter。你需要实现 XmlAdapter 接口，定义如何将Java类型转换为JAXB可识别的类型，以及如何反向转换。

例如，处理特定日期格式：

import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateAdapter extends XmlAdapter {
    private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public String marshal(Date date) throws Exception {
        return dateFormat.format(date);
    }

    @Override
    public Date unmarshal(String dateString) throws Exception {
        return dateFormat.parse(dateString);
    }
}

然后在Java对象中使用：

import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

public class Event {
    private String name;
    private Date eventTime;

    @XmlJavaTypeAdapter(DateAdapter.class)
    public Date getEventTime() {
        return eventTime;
    }
    public void setEventTime(Date eventTime) {
        this.eventTime = eventTime;
    }
    // ...
}

这样，eventTime 字段在XML中就会以 "yyyy-MM-dd HH:mm:ss" 的格式表示。

JAXB通过这些机制，使得在Java应用中处理各种复杂度的XML结构变得相对简单和直观。关键在于正确地选择和组合使用这些注解，以匹配预期的XML结构。

JAXB在实际开发中可能遇到哪些常见问题和解决方案？

在实际使用JAXB进行XML和Java对象转换时，开发者确实会遇到一些常见的问题。理解这些问题及其解决方案，能帮助我们更顺畅地使用JAXB。

1. 命名空间 (Namespace) 问题

问题: XML通常会使用命名空间来避免元素名冲突。JAXB默认不会为生成的XML添加命名空间，或者在反序列化时对命名空间敏感。如果你的XML源文件带有命名空间，而Java对象没有正确配置，反序列化可能会失败，或者序列化出的XML不符合预期。
解决方案:
- 在 @XmlRootElement 或 @XmlElement 上指定 namespace 属性: 例如 @XmlRootElement(namespace = "http://www.example.com/ns/book")。
- 在 package-info.java 中定义包级别的命名空间: 在你的Java包下创建一个 package-info.java 文件，并使用 @XmlSchema 注解来定义默认命名空间和前缀。
```
@XmlSchema(
    namespace = "http://www.example.com/ns/book",
    elementFormDefault = XmlNsForm.QUALIFIED,
    xmlns = {
        @XmlNs(prefix = "bk", namespaceURI = "http://www.example.com/ns/book")
    }
)
package com.example.model;

import javax.xml.bind.annotation.XmlNs;
import javax.xml.bind.annotation.XmlSchema;
import javax.xml.bind.annotation.XmlNsForm;
```
  这种方式更推荐，因为它能统一管理一个包下所有JAXB类的命名空间。

2. 日期/时间格式化问题

问题: JAXB默认对 java.util.Date 或 java.time 包下的日期时间类型有自己的处理方式，通常是ISO 8601格式。但实际业务中，XML可能使用各种自定义的日期格式。
解决方案:
- 使用 @XmlJavaTypeAdapter: 这是最灵活和推荐的方式。自定义一个继承自 XmlAdapter 的类，实现 marshal 和 unmarshal 方法来处理日期字符串和 Date 对象之间的转换，然后用 @XmlJavaTypeAdapter(YourDateAdapter.class) 标注日期字段。
- 针对 java.time (Java 8+): 如果使用 java.time 包的类型（如 LocalDate, LocalDateTime），JAXB默认不支持。你需要引入 jaxb-extra-annotations 或 jaxb-adapters-java8 这样的库，或者同样通过 XmlJavaTypeAdapter 来进行转换。

3. 空元素 (Empty Elements) 与 Null 值处理

问题: 当Java对象的某个属性为 null 时，JAXB默认会忽略该元素，不将其序列化到XML中。但有时业务要求即使值为 null，也需要生成一个空元素或者带有 xsi:nil="true" 的元素。
解决方案:
- 生成空元素: 在 @XmlElement 注解中设置 nillable = true。这样当属性为 null 时，JAXB会生成一个类似的元素。
- 强制生成空标签: 如果需要生成这种形式的空标签而不是 xsi:nil，JAXB本身没有直接的注解。这通常需要通过自定义 Marshaller.Listener 或 XmlAdapter 来拦截 null 值并手动输出空标签，或者在业务逻辑层确保不传入 null 值而是空字符串或其他默认值。

4. 集合类型序列化为根元素 (Root Element for Collections)

问题: 如果你有一个 List，并尝试直接将其作为 JAXBContext 的根类型进行序列化，JAXB通常会报错，因为它需要一个带有 @XmlRootElement 的具体类作为根。
解决方案:
- 创建包装类: 最常见的做法是创建一个包装类来包含这个集合。例如，创建一个 Books 类，其中包含 List 字段，并在 Books 类上使用 @XmlRootElement。
```
@XmlRootElement(name = "books")
public class Books {
    private List bookList;

    @XmlElement(name = "book")
    public List
```