原文：http://zetcode.com/java/jaxb/

Java JAXB 教程显示了如何使用 JAXB 库来处理 XML。 这些示例将 Java 对象写入 XML 文件，并将 XML 数据读取到 Java 对象。

JAXB

用于 XML 绑定的 Java 架构（JAXB）是允许 Java 开发者将 Java 类映射到 XML 表示形式的软件框架。 JAXB 支持将 Java 对象编组为 XML，然后将 XML 解组为 Java 对象。

在 Java 9 中，JAXB 已移至单独的模块java.xml中。 在 Java 9 和 Java 10 中，我们需要使用--add-modules=java.xml.bind选项。 在 Java 11 中，JAXB 已从 JDK 中删除，我们需要通过 Maven 或 Gradle 将其作为单独的库添加到项目中。

在我们的示例中，我们使用 JDK 11 和 Maven 创建我们的应用。

JAXB 定义

编组是将 Java 对象转换为 XML 文档的过程。 解组是将 XML 文档读入 Java 对象的过程。 JAXBContext类提供客户端到 JAXB API 的入口点。 它提供用于编组，解组和验证的 API。

JAXB POM 设置

以下 POM 文件包含必需的 JAXB JAR。

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  5.          http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6.     <modelVersion>4.0.0</modelVersion>
  8.     <groupId>JavaWriteXmlJaxbEx</groupId>
  9.     <artifactId>JavaWriteXmlJaxbEx</artifactId>
  10.     <version>1.0-SNAPSHOT</version>
  12.     <properties>
  13.         <maven.compiler.source>11</maven.compiler.source>
  14.         <maven.compiler.target>11</maven.compiler.target>
  15.     </properties>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>javax.xml.bind</groupId>
  20.             <artifactId>jaxb-api</artifactId>
  21.             <version>2.2.11</version>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>com.sun.xml.bind</groupId>
  25.             <artifactId>jaxb-core</artifactId>
  26.             <version>2.2.11</version>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>com.sun.xml.bind</groupId>
  30.             <artifactId>jaxb-impl</artifactId>
  31.             <version>2.2.11</version>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>javax.activation</groupId>
  35.             <artifactId>activation</artifactId>
  36.             <version>1.1.1</version>
  37.         </dependency>
  39.     </dependencies>
  41.     <build>
  42.         <plugins>
  43.             <plugin>
  44.                 <artifactId>maven-assembly-plugin</artifactId>
  45.                 <executions>
  46.                     <execution>
  47.                         <phase>package</phase>
  48.                         <goals>
  49.                             <goal>single</goal>
  50.                         </goals>
  51.                     </execution>
  52.                 </executions>
  53.                 <configuration>
  54.                     <descriptorRefs>
  55.                         <descriptorRef>jar-with-dependencies</descriptorRef>
  56.                     </descriptorRefs>
  58.                     <archive>
  59.                         <manifest>
  60.                             <mainClass>com.zetcode.JavaWriteXmlJaxbEx</mainClass>
  61.                         </manifest>
  62.                     </archive>
  63.                 </configuration>
  64.             </plugin>
  65.         </plugins>
  66.     </build>
  68. </project>

除了包括 JAXB 依赖项，我们还使用maven-assembly-plugin将所有依赖项打包到一个 JAR 中。

JAXB 编写 XML 示例

在第一个示例中，我们将 Java 对象写入 XML 文件。

Book.java

  1. package com.zetcode;
  3. import javax.xml.bind.annotation.XmlElement;
  4. import javax.xml.bind.annotation.XmlRootElement;
  5. import javax.xml.bind.annotation.XmlType;
  7. @XmlRootElement(name = "book")
  9. // Defining order
  10. @XmlType(propOrder = { "author", "name", "publisher", "isbn" })
  11. public class Book {
  13.     private String name;
  14.     private String author;
  15.     private String publisher;
  16.     private String isbn;
  18.     // Changing to title
  19.     @XmlElement(name = "title")
  20.     public String getName() {
  21.         return name;
  22.     }
  24.     public void setName(String name) {
  25.         this.name = name;
  26.     }
  28.     public String getAuthor() {
  29.         return author;
  30.     }
  32.     public void setAuthor(String author) {
  33.         this.author = author;
  34.     }
  36.     public String getPublisher() {
  37.         return publisher;
  38.     }
  40.     public void setPublisher(String publisher) {
  41.         this.publisher = publisher;
  42.     }
  44.     public String getIsbn() {
  45.         return isbn;
  46.     }
  48.     public void setIsbn(String isbn) {
  49.         this.isbn = isbn;
  50.     }
  52.     @Override
  53.     public String toString() {
  54.         final StringBuilder sb = new StringBuilder("Book{");
  55.         sb.append("name='").append(name).append('\'');
  56.         sb.append(", author='").append(author).append('\'');
  57.         sb.append(", publisher='").append(publisher).append('\'');
  58.         sb.append(", isbn='").append(isbn).append('\'');
  59.         sb.append('}');
  60.         return sb.toString();
  61.     }
  62. }

这是Book bean。 该 bean 将被转换为特定的 XML 标签。

  1. @XmlRootElement(name = "book")

使用@XmlRootElement注解，我们定义 XML 标签名称。

  1. @XmlType(propOrder = { "author", "name", "publisher", "isbn" })

通过@XmlType的propOrder属性，我们定义了子元素的顺序。

  1. @XmlElement(name = "title")
  2. public String getName() {
  3.     return name;
  4. }

我们可以将默认元素名称更改为title。

BookStore.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import javax.xml.bind.annotation.XmlElement;
  5. import javax.xml.bind.annotation.XmlElementWrapper;
  6. import javax.xml.bind.annotation.XmlRootElement;
  8. //This statement means that class "Bookstore.java" is the root-element of our example
  9. @XmlRootElement(namespace = "com.zetcode")
  10. public class BookStore {
  12.     // XmLElementWrapper generates a wrapper element around XML representation
  13.     @XmlElementWrapper(name = "bookList")
  14.     // XmlElement sets the name of the entities
  15.     @XmlElement(name = "book")
  16.     private ArrayList<Book> bookList;
  17.     private String name;
  18.     private String location;
  20.     public void setBookList(ArrayList<Book> bookList) {
  21.         this.bookList = bookList;
  22.     }
  24.     public ArrayList<Book> getBooksList() {
  25.         return bookList;
  26.     }
  28.     public String getName() {
  29.         return name;
  30.     }
  32.     public void setName(String name) {
  33.         this.name = name;
  34.     }
  36.     public String getLocation() {
  37.         return location;
  38.     }
  40.     public void setLocation(String location) {
  41.         this.location = location;
  42.     }
  43. }

BookStore是一个类，其中包含一个列表，我们在其中放置书本对象。

  1. @XmlRootElement(namespace = "com.zetcode")
  2. public class BookStore {

我们用@XmlRootElement注解定义根元素。

  1. // XmLElementWrapper generates a wrapper element around XML representation
  2. @XmlElementWrapper(name = "bookList")
  3. // XmlElement sets the name of the entities
  4. @XmlElement(name = "book")
  5. private ArrayList<Book> bookList;

@XmlElementWrapper注解在book元素周围定义了包装元素。 @XmlElement注解定义包装器内的 XML 元素的名称。

JavaWriteXmlJaxbEx.java

  1. package com.zetcode;
  3. import javax.xml.bind.JAXBContext;
  4. import javax.xml.bind.JAXBException;
  5. import javax.xml.bind.Marshaller;
  6. import java.io.File;
  7. import java.util.ArrayList;
  9. public class JavaWriteXmlJaxbEx {
  11.     private static final String BOOKSTORE_XML = "src/main/resources/bookstore.xml";
  13.     public static void main(String[] args) throws JAXBException {
  15.         var bookList = new ArrayList<Book>();
  17.         // create books
  18.         var book1 = new Book();
  19.         book1.setIsbn("978-0060554736");
  20.         book1.setName("The Game");
  21.         book1.setAuthor("Neil Strauss");
  22.         book1.setPublisher("Harpercollins");
  23.         bookList.add(book1);
  25.         var book2 = new Book();
  26.         book2.setIsbn("978-3832180577");
  27.         book2.setName("Feuchtgebiete");
  28.         book2.setAuthor("Charlotte Roche");
  29.         book2.setPublisher("Dumont Buchverlag");
  30.         bookList.add(book2);
  32.         // create bookstore, assign books
  33.         var bookstore = new BookStore();
  34.         bookstore.setName("Fraport Bookstore");
  35.         bookstore.setLocation("Livres belles");
  36.         bookstore.setBookList(bookList);
  38.         // create JAXB context and instantiate marshaller
  39.         var context = JAXBContext.newInstance(BookStore.class);
  40.         var m = context.createMarshaller();
  41.         m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  43.         // Write to System.out
  44.         m.marshal(bookstore, System.out);
  46.         // Write to File
  47.         m.marshal(bookstore, new File(BOOKSTORE_XML));
  48.     }
  49. }

在示例中，我们创建书对象，将它们添加到书店，然后将书店转换为 XML 文件。

  1. // create books
  2. var book1 = new Book();
  3. book1.setIsbn("978-0060554736");
  4. book1.setName("The Game");
  5. book1.setAuthor("Neil Strauss");
  6. book1.setPublisher("Harpercollins");
  7. bookList.add(book1);
  9. var book2 = new Book();
  10. book2.setIsbn("978-3832180577");
  11. book2.setName("Feuchtgebiete");
  12. book2.setAuthor("Charlotte Roche");
  13. book2.setPublisher("Dumont Buchverlag");
  14. bookList.add(book2);

我们创建两个书本对象。

  1. // create bookstore, assign books
  2. var bookstore = new BookStore();
  3. bookstore.setName("Fraport Bookstore");
  4. bookstore.setLocation("Livres belles");
  5. bookstore.setBookList(bookList);

创建了一个书店并将书籍放入其中。

  1. // create JAXB context and instantiate marshaller
  2. var context = JAXBContext.newInstance(BookStore.class);

我们创建一个新的JAXBContext。 我们传递新上下文对象必须识别的类的列表。 （在我们的例子中，这是一类。）

  1. var m = context.createMarshaller();
  2. m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

从上下文中，我们得到了createMarshaller()的编组器。 我们设置一个属性以获取格式化输出。

  1. // Write to System.out
  2. m.marshal(bookstore, System.out);
  4. // Write to File
  5. m.marshal(bookstore, new File(BOOKSTORE_XML));

我们将数据写入系统输出和文件中。

JAXB 读取 XML 示例

在第二个示例中，我们将编组的数据读回到 Java 对象中。

JavaReadXmlJaxbEx.java

  1. package com.zetcode;
  3. import javax.xml.bind.JAXBContext;
  4. import javax.xml.bind.JAXBException;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.InputStreamReader;
  8. import java.nio.charset.StandardCharsets;
  10. public class JavaReadXmlJaxbEx {
  12.     private static final String BOOKSTORE_XML = "src/main/resources/bookstore.xml";
  14.     public static void main(String[] args) throws JAXBException, 
  15.             FileNotFoundException {
  17.         // create JAXB context and unmarshaller
  18.         var context = JAXBContext.newInstance(BookStore.class);
  19.         var um = context.createUnmarshaller();
  21.         var bookstore = (BookStore) um.unmarshal(new InputStreamReader(
  22.                 new FileInputStream(BOOKSTORE_XML), StandardCharsets.UTF_8));
  23.         var bookList = bookstore.getBooksList();
  25.         bookList.forEach((book) -> {
  26.             System.out.println(book);
  27.         });
  28.     }
  29. }

该示例从bookstore.xml文档中读取书籍。

  1. // create JAXB context and unmarshaller
  2. var context = JAXBContext.newInstance(BookStore.class);
  3. var um = context.createUnmarshaller();

我们创建一个 JAXB 上下文并获得一个新的解组器。

  1. var bookstore = (BookStore) um.unmarshal(new InputStreamReader(
  2.         new FileInputStream(BOOKSTORE_XML), StandardCharsets.UTF_8));

使用unmarshal()，我们从 XML 文档中读取数据。

  1. var bookList = bookstore.getBooksList();
  3. bookList.forEach((book) -> {
  4.     System.out.println(book);
  5. });

我们获得书籍列表并对其进行遍历。

  1. Book{name='The Game', author='Neil Strauss', publisher='Harpercollins', isbn='978-0060554736'}
  2. Book{name='Feuchtgebiete', author='Charlotte Roche', publisher='Dumont Buchverlag', isbn='978-3832180577'}

这是输出。

在本教程中，我们已经使用 Java JAXB 库读写 XML 文件。 您可能也对相关教程感兴趣： Java DOM 教程， Java SAX 教程， Java JSON 处理教程和 Java 教程 。