使用JAXB实现Xml与Java对象转换（XML）

JAXB（Java Architecture for XML Binding）是 Java 平台上用于将 XML 数据和 Java 对象之间进行双向映射（绑定）的技术和规范。JAXB 允许开发人员在 Java 对象和 XML 数据之间进行无缝转换，使得在处理 XML 数据时变得更加方便和容易。以下是关于 JAXB 的一些重要信息：

  1. XML 到 Java 的反序列化：JAXB 允许将 XML 数据反序列化为 Java 对象。通过提供 XML 数据和 Java 类型之间的映射，JAXB 可以自动将 XML 数据解析并转换为相应的 Java 对象。

  2. Java 到 XML 的序列化：JAXB 还允许将 Java 对象序列化为 XML 数据。开发人员可以使用 Java 注解来指定如何将 Java 对象转换为 XML 数据。

  3. 自动生成 Java 类：JAXB 提供了工具，可以根据 XML Schema（XSD）文件自动生成 Java 类，这些类与 XML 数据的结构相匹配。这使得创建与 XML 数据兼容的 Java 类变得更加容易。

  4. JAXB 注解：JAXB 使用注解来配置映射关系。一些常见的 JAXB 注解包括 @XmlRootElement、@XmlElement、@XmlAttribute 等，它们用于定义 XML 元素和属性与 Java 类型的关联。

    1. @XmlRootElement：指定类是 XML 文档的根元素。通常用于标识整个 XML 文档的顶级元素。
    2. @XmlElement：指定字段或方法应该映射到 XML 元素。可以用于自定义元素的名称、命名空间等属性。
    3. @XmlType：用于指定类的类型信息，包括名称、命名空间、属性顺序等。
    4. @XmlAccessorType：控制字段的访问方式，可选的访问方式包括字段（Field）、属性（Property）、公共字段（PublicField）、公共属性（PublicProperty）等。
    5. @XmlEnumValue：用于在枚举类型中自定义枚举常量的值。

    6. @XmlAttribute：将字段映射为 XML 属性，而不是元素。

    7. @XmlAnyElement：用于处理未知元素。通常与 List 或 Object 类型的字段一起使用，用于接收 XML 中未被明确定义的元素。

  5. 运行时库：JAXB 的运行时库提供了处理 XML 数据的类和方法。这些类包括 Unmarshaller（用于反序列化）和 Marshaller（用于序列化）等。

  6. JAXB 上下文：JAXB 使用 JAXB 上下文来管理映射关系和配置。JAXB 上下文允许您控制如何将 XML 数据映射到 Java 对象以及如何将 Java 对象序列化为 XML 数据。

  7. 标准化：JAXB 是 Java 平台的一部分，由 Java 标准化组织（JCP）制定和维护。它是 Java SE 的一部分，因此无需额外的库或依赖项。

         8. 适用场景：JAXB 在处理与 XML 数据交互的场景中非常有用，例如 Web 服务、SOAP、RESTful 服务、配置文件解析和数据持久化等。

示例如下：

1、不需要引入依赖，直接使用

2、创建实体类

 1 @Data
 2 @XmlAccessorType(XmlAccessType.FIELD)
 3 @XmlRootElement(name = "Department")
 4 @XmlType(propOrder = {
 5         "name",
 6         "phone",
 7         "users"
 8 })
 9 public class Department {
10 
11     private String name;
12 
13     private String  phone;
14 
15     private List<User> users;
16 }
 1 @Data
 2 @XmlAccessorType(XmlAccessType.FIELD)
 3 @XmlRootElement(name = "User")
 4 @XmlType(propOrder = {
 5         "name",
 6         "age",
 7         "sex"
 8 })
 9 public class User {
10 
11     private String name;
12 
13     private Integer age;
14 
15     private String sex;
16 }

3、创建XmlUtils工具类，里面包含了四个方法

 1 public class XmlUtils {
 2     /**
 3      * 将Java对象转换成Xml字符串
 4      */
 5     public static String objToXmlStr(Object obj) {
 6         // 创建输出流  
 7         StringWriter sw = new StringWriter();
 8         try {
 9             // 利用jdk中自带的转换类实现  
10             JAXBContext context = JAXBContext.newInstance(obj.getClass());
11 
12             Marshaller marshaller = context.createMarshaller();
13             // 格式化xml输出的格式  
14             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
15             // 将对象转换成输出流形式的xml  
16             marshaller.marshal(obj, sw);
17         } catch (JAXBException e) {
18             e.printStackTrace();
19         }
20         return sw.toString();
21     }
22 
23     /**
24      * 将Java对象根据路径转换成xml文件
25      */
26     public static void objToXmlFile(Object obj, String path) {
27         try {
28             // 利用jdk中自带的转换类实现  
29             JAXBContext context = JAXBContext.newInstance(obj.getClass());
30 
31             Marshaller marshaller = context.createMarshaller();
32             // 格式化xml输出的格式  
33             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
34             // 将对象转换成输出流形式的xml  
36             FileWriter fw = null;
37             try {
38                 fw = new FileWriter(path);
39             } catch (IOException e) {
40                 e.printStackTrace();
41             }
42             marshaller.marshal(obj, fw);
43         } catch (JAXBException e) {
44             e.printStackTrace();
45         }
46     }
47 
48     /**
49      * 将Xml字符串转换成Java对象
50      */
51     public static Object xmlStrToObj(Class clazz, String xmlStr) {
52         Object xmlObject = null;
53         try {
54             JAXBContext context = JAXBContext.newInstance(clazz);
55             // 进行将Xml转成对象的核心接口  
56             Unmarshaller unmarshaller = context.createUnmarshaller();
57             StringReader sr = new StringReader(xmlStr);
58             xmlObject = unmarshaller.unmarshal(sr);
59         } catch (JAXBException e) {
60             e.printStackTrace();
61         }
62         return xmlObject;
63     }
64 
65     /**
66      * 将Xml文件转换成Java对象
67      */
68     public static Object xmlFileToObject(Class clazz, String path) {
69         Object xmlObject = null;
70         try {
71             JAXBContext context = JAXBContext.newInstance(clazz);
72             Unmarshaller unmarshaller = context.createUnmarshaller();
73             FileReader fr = null;
74             try {
75                 fr = new FileReader(path);
76             } catch (FileNotFoundException e) {
77                 e.printStackTrace();
78             }
79             xmlObject = unmarshaller.unmarshal(fr);
80         } catch (JAXBException e) {
81             e.printStackTrace();
82         }
83         return xmlObject;
84     }
85 }

 这里详解方法中使用到的类：JAXBContext 、Unmarshaller 、Marshaller 

3.1、JAXBContext 

JAXBContext 是 Java API for XML Binding (JAXB) 的一部分，用于将 Java 对象和 XML 数据进行相互转换。它允许将 Java 对象转换为 XML 格式（marshal），以及将 XML 数据转换回 Java 对象（unmarshal）。JAXB 是 Java 中处理 XML 数据的一种强大方式，特别适用于处理 XML 数据和 Java 对象之间的映射关系。

常用的方法：

3.1.1、newInstance(Class... classesToBeBound) 

静态工厂方法，用于创建 JAXBContext 的实例。参数 classesToBeBound 是要绑定的 Java 类的类对象数组。

JAXBContext context = JAXBContext.newInstance(Person.class);

3.1.2 createMarshaller()

创建一个 Marshaller 对象，用于将 Java 对象转换为 XML 数据。

Marshaller marshaller = context.createMarshaller();

3.1.3 createUnmarshaller()

创建一个 Unmarshaller 对象，用于将 XML 数据转换为 Java 对象。

Unmarshaller unmarshaller = context.createUnmarshaller();

3.1.4 generateSchema(SchemaOutputResolver outputResolver)

生成 XML Schema 定义（XSD）文件。SchemaOutputResolver 是一个回调接口，用于指定生成的 XSD 文件的输出位置。

context.generateSchema(new MySchemaOutputResolver());

3.1.5 newInstance(String contextPath)

根据指定的上下文路径创建 JAXBContext 的实例。上下文路径通常是一组 Java 包的名称，用逗号分隔。

JAXBContext context = JAXBContext.newInstance("com.example");

3.1.6 newInstance(String contextPath, ClassLoader classLoader)

类似于上述方法，但可以指定类加载器来加载上下文中的类。

JAXBContext context = JAXBContext.newInstance("com.example", MyClassLoader.class);

 

3.2、Marshaller 

Marshaller 是 Java API for XML Binding (JAXB) 中的一个接口，它用于将 Java 对象转换为 XML 数据。Marshaller 提供了一组方法，允许指定如何将 Java 对象映射到 XML 数据以及生成的 XML 数据的格式。

常用的方法：

3.2.1  marshal(Object obj, Writer writer)

将给定的 Java 对象转换为 XML 数据，并将结果写入 Writer 对象中。

marshaller.marshal(person, writer);

3.2.2 marshal(Object obj, OutputStream os)

将给定的 Java 对象转换为 XML 数据，并将结果写入 OutputStream 对象中。

marshaller.marshal(person, outputStream);

3.2.3 marshal(Object obj, Result result)

将给定的 Java 对象转换为 XML 数据，并将结果存储在 Result 对象中。Result 可以是 DOMResult、StreamResult 等。

DOMResult domResult = new DOMResult();
marshaller.marshal(person, domResult);

3.2.4 setProperty(String name, Object value)

设置属性以控制 Marshaller 的行为。例如设置缩进、格式化输出等。

marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

3.2.5 setListener(Marshaller.Listener listener)

设置 Marshaller 的监听器，以便在生成 XML 数据时执行自定义操作。

marshaller.setListener(new MyMarshallerListener());

3.2.6 setEventHandler(ValidationEventHandler handler)

设置事件处理程序，用于处理转换期间的验证事件。

marshaller.setEventHandler(new MyValidationEventHandler());

3.2.7 setAdapter(XmlAdapter<BoundType, ValueType> adapter)

设置适配器，用于自定义字段或属性的转换。

marshaller.setAdapter(new MyXmlAdapter());

 

3.3、Unmarshaller 

Unmarshaller 是 Java API for XML Binding (JAXB) 中的一个接口，它用于将 XML 数据解析为 Java 对象。Unmarshaller 提供了一组方法，允许从 XML 数据中提取信息并将其转换为 Java 对象。

3.3.1 unmarshal(Source source)

将给定的 Source 对象中的 XML 数据解析为 Java 对象。Source 可以是 StreamSource、DOMSource 等。

Person person = (Person) unmarshaller.unmarshal(new StreamSource(xmlInputStream));

3.3.2 unmarshal(InputStream is)

将给定的 InputStream 中的 XML 数据解析为 Java 对象。

Person person = (Person) unmarshaller.unmarshal(xmlInputStream);

3.3.3 unmarshal(Reader reader)

将给定的 Reader 中的 XML 数据解析为 Java 对象。

Person person = (Person) unmarshaller.unmarshal(new StringReader(xmlData));

3.3.4 unmarshal(Node node)

将给定的 DOM 节点解析为 Java 对象。

Node xmlNode = ...; // 获取一个 DOM 节点
Person person = (Person) unmarshaller.unmarshal(xmlNode);

3.3.5 setAdapter(XmlAdapter<BoundType, ValueType> adapter)

设置适配器，用于自定义字段或属性的转换。

unmarshaller.setAdapter(new MyXmlAdapter());

3.3.6 setEventHandler(ValidationEventHandler handler)

设置事件处理程序，用于处理解析期间的验证事件。

unmarshaller.setEventHandler(new MyValidationEventHandler());

3.3.7 setProperty(String name, Object value)

设置属性以控制 Unmarshaller 的行为。例如，您可以设置验证模式、解析器属性等。

unmarshaller.setProperty(Unmarshaller.JAXB_FORMATTED_OUTPUT, true);

 

4、在测试类中进行测试

这里只进行Xml文件与Java对象的相互转换。

4.1 将Java对象转换为Xml文件

 1  @Test
 2  void ToXml()  {
 3 
 4             User user = new User();
 5             user.setName("Tom");
 6             user.setAge(22);
 7             user.setSex("男");
 8 
 9             List<User> users = new ArrayList<>();
10             users.add(user);
11 
12             Department department = new Department();
13             department.setName("人事部");
14             department.setPhone("13111111111");
15             department.setUsers(users);
16 
17             XmlUtils.objToXmlFile(department, PATH);
18  }

测试结果：

 4.2、将Xml文件转换为Java对象

1 @Test
2 void toObject()  {
3 
4      Department department = (Department) XmlUtils.xmlFileToObject(Department.class, PATH);
5      System.out.println(department);
6 }

测试结果：

 

posted @ 2023-09-15 14:50  xiaogh  阅读(3529)  评论(0)    收藏  举报