玩转Java对象和XML相互转换

最近在项目中一直出现Java对象和XML之间的相互转换，一开始由于项目很庞大，我又是临时调度过去，导致在按照项目组长的要求进行写代码的同时，总是在这块云里雾里，最近才慢慢开始搞清楚项目中具体的使用缘由。但是项目中封装的代码总是很庞大，因为要考虑太多的东西，而对于此，我只能通过小的Demo来说明，其实在项目中用到很多插件，轻巧，灵便，封装很好使用，但这里我讲解的是JAXB（Java Architecture for XML Binding）。

JAXB（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用程序中能方便地结合XML数据和处理函数。

JDK中JAXB相关的重要Class和Interface：(来源于百度百科JAXB)

  • JAXBContext类，是应用的入口，用于管理XML/Java绑定信息。
  • Marshaller接口，将Java对象序列化为XML数据。
  • Unmarshaller接口，将XML数据反序列化为Java对象。

JDK中JAXB相关的重要Annotation：(来源于百度百科JAXB)

  • @XmlType，将Java类或枚举类型映射到XML模式类型
  • @XmlAccessorType(XmlAccessType.FIELD) ，控制字段或属性的序列化。FIELD表示JAXB将自动绑定Java类中的每个非静态的（static）、非瞬态的（由@XmlTransient标注）字段到XML。其他值还有XmlAccessType.PROPERTY和XmlAccessType.NONE。
  • @XmlAccessorOrder，控制JAXB 绑定类中属性和字段的排序。
  • @XmlJavaTypeAdapter，使用定制的适配器（即扩展抽象类XmlAdapter并覆盖marshal()和unmarshal()方法），以序列化Java类为XML。
  • @XmlElementWrapper ，对于数组或集合（即包含多个元素的成员变量），生成一个包装该数组或集合的XML元素（称为包装器）。
  • @XmlRootElement，将Java类或枚举类型映射到XML元素。
  • @XmlElement，将Java类的一个属性映射到与属性同名的一个XML元素。
  • @XmlAttribute，将Java类的一个属性映射到与属性同名的一个XML属性。

在以上的注解中，用的最多的是@XMLType，@XmlAccessorType，@XmlRootElement。

使用JAXB的缘由：

1，在项目中，有时候会有很多的XML文件，但如果可以将这些文件通过对象的方式去操作，就会减少很多操作问题，而且更加符合程序员的编码方式，

2，在项目中，有时候会遇到一个页面中存在很多的实体类中的数据，而且有时候有些数据不是必需的，就是说可以通过DTO来编写这些实体类，但有时候需要将这些DTO进行预先存储，不是存储到数据库中，这样就有两种思路，可以存储在内存中，也可以存储在硬盘上，此时就可以通过将Java对象转换成XML文件存储，或者变成String类型进行存储在内存中。

3，给出一个场景，比如说，一个页面中有很多个模块构成，但是这些模块都是属于一个整体的模块，当用户有操作其中几个模块的时候，但操作后的数据不是最终的数据，那这个时候首先要保存当前页面中的数据（Done），然后到其他页面进行其他操作后再转到这个页面，那么之前那个页面中的数据应该还会存在，用户可以方便查看。但是由于模块较多，如果之前就存到数据库中就会造成浪费，因为其不是最终的保存效果，而当用户想进行保存（Save），此时才进行将最终的数据保存到数据库中。在这个过程中就会用到大量的临时数据，而解决这个问题很好的方法就是可以用XML保存页面中当前的数据。

在本文中，首先我给出一个对象与XML的相互转换，然后，在通过模块的概念阐述要点三种的场景，当然，代码不难，很简单的模拟，对于项目中的概念会比这复杂很多，也会有专门复杂这个过程的代码编写。所以，我仅仅是抛砖引玉，能够让读者尽量有这种思想，到时候写项目的时候如果有遇到此种情况，就可以很好的进行思想迁移。

说这么多，就来看看到底如何进行Java对象和XML之间的相互转换吧。

首先看看Java项目的结构图：

图1

首先给出User.java这个类

User.java

[java] view plain copy

  1. package com.xml;
  2. import java.io.Serializable;
  3. import java.util.Date;
  4. import javax.xml.bind.annotation.XmlAccessType;
  5. import javax.xml.bind.annotation.XmlAccessorType;
  6. import javax.xml.bind.annotation.XmlRootElement;
  7. import javax.xml.bind.annotation.XmlType;
  8. /**
  9. *
  10. * @author Steven
  11. *
  12. */
  13. @XmlAccessorType(XmlAccessType.FIELD)
  14. // XML文件中的根标识
  15. @XmlRootElement(name = "User")
  16. // 控制JAXB 绑定类中属性和字段的排序
  17. @XmlType(propOrder = {
  18. "userId",
  19. "userName",
  20. "password",
  21. "birthday",
  22. "money",
  23. })
  24. public class User implements Serializable {
  25. private static final long serialVersionUID = 1L;
  26. // 用户Id
  27. private int userId;
  28. // 用户名
  29. private String userName;
  30. // 用户密码
  31. private String password;
  32. // 用户生日
  33. private Date birthday;
  34. // 用户钱包
  35. private double money;
  36. public User() {
  37. super();
  38. }
  39. public User(int userId, String userName, String password, Date birthday,
  40. double money) {
  41. super();
  42. this.userId = userId;
  43. this.userName = userName;
  44. this.password = password;
  45. this.birthday = birthday;
  46. this.money = money;
  47. }
  48. public int getUserId() {
  49. return userId;
  50. }
  51. public void setUserId(int userId) {
  52. this.userId = userId;
  53. }
  54. public String getUserName() {
  55. return userName;
  56. }
  57. public void setUserName(String userName) {
  58. this.userName = userName;
  59. }
  60. public String getPassword() {
  61. return password;
  62. }
  63. public void setPassword(String password) {
  64. this.password = password;
  65. }
  66. public Date getBirthday() {
  67. return birthday;
  68. }
  69. public void setBirthday(Date birthday) {
  70. this.birthday = birthday;
  71. }
  72. public double getMoney() {
  73. return money;
  74. }
  75. public void setMoney(double money) {
  76. this.money = money;
  77. }
  78. @Override
  79. public String toString() {
  80. return "User [birthday=" + birthday + ", money=" + money
  81. + ", password=" + password + ", userId=" + userId
  82. + ", userName=" + userName + "]";
  83. }
  84. }

此时给出最重要的进行Java对象和XML文件相互操作的核心代码XMLUtil.java，其中有着两种方式进行转换，一种是转换成对象和string类型的xml转换，一种是对象和xml文件进行转换。

XMLUtil.java

[java] view plain copy

  1. package com.xml;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileReader;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.io.StringReader;
  7. import java.io.StringWriter;
  8. import javax.xml.bind.JAXBContext;
  9. import javax.xml.bind.JAXBException;
  10. import javax.xml.bind.Marshaller;
  11. import javax.xml.bind.Unmarshaller;
  12. /**
  13. * 封装了XML转换成object，object转换成XML的代码
  14. *
  15. * @author Steven
  16. *
  17. */
  18. public class XMLUtil {
  19. /**
  20. * 将对象直接转换成String类型的 XML输出
  21. *
  22. * @param obj
  23. * @return
  24. */
  25. public static String convertToXml(Object obj) {
  26. // 创建输出流
  27. StringWriter sw = new StringWriter();
  28. try {
  29. // 利用jdk中自带的转换类实现
  30. JAXBContext context = JAXBContext.newInstance(obj.getClass());
  31. Marshaller marshaller = context.createMarshaller();
  32. // 格式化xml输出的格式
  33. marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
  34. Boolean.TRUE);
  35. // 将对象转换成输出流形式的xml
  36. marshaller.marshal(obj, sw);
  37. } catch (JAXBException e) {
  38. e.printStackTrace();
  39. }
  40. return sw.toString();
  41. }
  42. /**
  43. * 将对象根据路径转换成xml文件
  44. *
  45. * @param obj
  46. * @param path
  47. * @return
  48. */
  49. public static void convertToXml(Object obj, String path) {
  50. try {
  51. // 利用jdk中自带的转换类实现
  52. JAXBContext context = JAXBContext.newInstance(obj.getClass());
  53. Marshaller marshaller = context.createMarshaller();
  54. // 格式化xml输出的格式
  55. marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
  56. Boolean.TRUE);
  57. // 将对象转换成输出流形式的xml
  58. // 创建输出流
  59. FileWriter fw = null;
  60. try {
  61. fw = new FileWriter(path);
  62. } catch (IOException e) {
  63. e.printStackTrace();
  64. }
  65. marshaller.marshal(obj, fw);
  66. } catch (JAXBException e) {
  67. e.printStackTrace();
  68. }
  69. }
  70. @SuppressWarnings("unchecked")
  71. /**
  72. * 将String类型的xml转换成对象
  73. */
  74. public static Object convertXmlStrToObject(Class clazz, String xmlStr) {
  75. Object xmlObject = null;
  76. try {
  77. JAXBContext context = JAXBContext.newInstance(clazz);
  78. // 进行将Xml转成对象的核心接口
  79. Unmarshaller unmarshaller = context.createUnmarshaller();
  80. StringReader sr = new StringReader(xmlStr);
  81. xmlObject = unmarshaller.unmarshal(sr);
  82. } catch (JAXBException e) {
  83. e.printStackTrace();
  84. }
  85. return xmlObject;
  86. }
  87. @SuppressWarnings("unchecked")
  88. /**
  89. * 将file类型的xml转换成对象
  90. */
  91. public static Object convertXmlFileToObject(Class clazz, String xmlPath) {
  92. Object xmlObject = null;
  93. try {
  94. JAXBContext context = JAXBContext.newInstance(clazz);
  95. Unmarshaller unmarshaller = context.createUnmarshaller();
  96. FileReader fr = null;
  97. try {
  98. fr = new FileReader(xmlPath);
  99. } catch (FileNotFoundException e) {
  100. e.printStackTrace();
  101. }
  102. xmlObject = unmarshaller.unmarshal(fr);
  103. } catch (JAXBException e) {
  104. e.printStackTrace();
  105. }
  106. return xmlObject;
  107. }
  108. }

下面给出测试类Test.java

[java] view plain copy

  1. package com.xml;
  2. import java.util.Date;
  3. /**
  4. *
  5. * @author Steven
  6. *
  7. */
  8. public class Test {
  9. public static void main(String[] args) {
  10. // 创建需要转换的对象
  11. User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);
  12. System.out.println("---将对象转换成string类型的xml Start---");
  13. // 将对象转换成string类型的xml
  14. String str = XMLUtil.convertToXml(user);
  15. // 输出
  16. System.out.println(str);
  17. System.out.println("---将对象转换成string类型的xml End---");
  18. System.out.println();
  19. System.out.println("---将String类型的xml转换成对象 Start---");
  20. User userTest = (User) XMLUtil.convertXmlStrToObject(User.class, str);
  21. System.out.println(userTest);
  22. System.out.println("---将String类型的xml转换成对象 End---");
  23. }
  24. }

运行的结果如图2所示：


                         图2

第二种方式的测试类如下所示;

Test.java

[java] view plain copy

  1. package com.xml;
  2. import java.util.Date;
  3. /**
  4. *
  5. * @author Steven
  6. *
  7. */
  8. public class Test {
  9. public static void main(String[] args) {
  10. // 创建需要转换的对象
  11. User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);
  12. String path = "D:\\user.xml";
  13. System.out.println("---将对象转换成File类型的xml Start---");
  14. XMLUtil.convertToXml(user, path);
  15. System.out.println("---将对象转换成File类型的xml End---");
  16. System.out.println();
  17. System.out.println("---将File类型的xml转换成对象 Start---");
  18. User user2 = (User) XMLUtil.convertXmlFileToObject(User.class, path);
  19. System.out.println(user2);
  20. System.out.println("---将File类型的xml转换成对象 End---");
  21. }
  22. }

此时在D:\产生的文件如图3所示：

图3

控制台信息如图4所示：

图4

此时打开user.xml，内容如下所示：

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  2. <User>
  3. <userId>1</userId>
  4. <userName>Steven</userName>
  5. <password>@sun123</password>
  6. <birthday>2013-12-13T18:24:03.477+08:00</birthday>
  7. <money>1000.0</money>
  8. </User>

此时就是一个对象和XML间的相互转换过程，但是对于实际中会有很多的情况，在User中存在一个子模块Computer，这时候就需要将Computer作为User的一个属性，此时的代码如下所示：

Computer.java

[java] view plain copy

  1. package com.xml;
  2. import java.io.Serializable;
  3. import java.util.Date;
  4. import javax.xml.bind.annotation.XmlAccessType;
  5. import javax.xml.bind.annotation.XmlAccessorType;
  6. import javax.xml.bind.annotation.XmlRootElement;
  7. import javax.xml.bind.annotation.XmlType;
  8. /**
  9. * 电脑类
  10. *
  11. * @author Steven
  12. *
  13. */
  14. @XmlAccessorType(XmlAccessType.FIELD)
  15. @XmlRootElement(name = "Computer")
  16. @XmlType(propOrder = { "serialNumber", "brandName", "productDate", "price" })
  17. public class Computer implements Serializable {
  18. private static final long serialVersionUID = 1L;
  19. // 序列号
  20. private String serialNumber;
  21. // 品牌名
  22. private String brandName;
  23. // 生成日期
  24. private Date productDate;
  25. // 价格
  26. private double price;
  27. public Computer() {
  28. super();
  29. }
  30. public Computer(String serialNumber, String brandName, Date productDate,
  31. double price) {
  32. super();
  33. this.serialNumber = serialNumber;
  34. this.brandName = brandName;
  35. this.productDate = productDate;
  36. this.price = price;
  37. }
  38. public String getSerialNumber() {
  39. return serialNumber;
  40. }
  41. public void setSerialNumber(String serialNumber) {
  42. this.serialNumber = serialNumber;
  43. }
  44. public String getBrandName() {
  45. return brandName;
  46. }
  47. public void setBrandName(String brandName) {
  48. this.brandName = brandName;
  49. }
  50. public Date getProductDate() {
  51. return productDate;
  52. }
  53. public void setProductDate(Date productDate) {
  54. this.productDate = productDate;
  55. }
  56. public double getPrice() {
  57. return price;
  58. }
  59. public void setPrice(double price) {
  60. this.price = price;
  61. }
  62. }

此时的User.java内容如下：

[java] view plain copy

  1. package com.xml;
  2. import java.io.Serializable;
  3. import java.util.Date;
  4. import java.util.List;
  5. import javax.xml.bind.annotation.XmlAccessType;
  6. import javax.xml.bind.annotation.XmlAccessorType;
  7. import javax.xml.bind.annotation.XmlRootElement;
  8. import javax.xml.bind.annotation.XmlType;
  9. /**
  10. *
  11. * @author Steven
  12. *
  13. */
  14. @XmlAccessorType(XmlAccessType.FIELD)
  15. // XML文件中的根标识
  16. @XmlRootElement(name = "User")
  17. // 控制JAXB 绑定类中属性和字段的排序
  18. @XmlType(propOrder = {
  19. "userId",
  20. "userName",
  21. "password",
  22. "birthday",
  23. "money",
  24. "computers"
  25. })
  26. public class User implements Serializable {
  27. private static final long serialVersionUID = 1L;
  28. // 用户Id
  29. private int userId;
  30. // 用户名
  31. private String userName;
  32. // 用户密码
  33. private String password;
  34. // 用户生日
  35. private Date birthday;
  36. // 用户钱包
  37. private double money;
  38. // 拥有的电脑
  39. private List<Computer> computers;
  40. public User() {
  41. super();
  42. }
  43. public User(int userId, String userName, String password, Date birthday,
  44. double money) {
  45. super();
  46. this.userId = userId;
  47. this.userName = userName;
  48. this.password = password;
  49. this.birthday = birthday;
  50. this.money = money;
  51. }
  52. public int getUserId() {
  53. return userId;
  54. }
  55. public void setUserId(int userId) {
  56. this.userId = userId;
  57. }
  58. public String getUserName() {
  59. return userName;
  60. }
  61. public void setUserName(String userName) {
  62. this.userName = userName;
  63. }
  64. public String getPassword() {
  65. return password;
  66. }
  67. public void setPassword(String password) {
  68. this.password = password;
  69. }
  70. public Date getBirthday() {
  71. return birthday;
  72. }
  73. public void setBirthday(Date birthday) {
  74. this.birthday = birthday;
  75. }
  76. public double getMoney() {
  77. return money;
  78. }
  79. public void setMoney(double money) {
  80. this.money = money;
  81. }
  82. public void setComputers(List<Computer> computers) {
  83. this.computers = computers;
  84. }
  85. public List<Computer> getComputers() {
  86. return computers;
  87. }
  88. @Override
  89. public String toString() {
  90. return "User [birthday=" + birthday + ", computers=" + computers
  91. + ", money=" + money + ", password=" + password + ", userId="
  92. + userId + ", userName=" + userName + "]";
  93. }
  94. }

此时测试类为

Test.java

[java] view plain copy

  1. package com.xml;
  2. import java.util.ArrayList;
  3. import java.util.Date;
  4. import java.util.List;
  5. /**
  6. *
  7. * @author Steven
  8. *
  9. */
  10. public class Test {
  11. public static void main(String[] args) {
  12. User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);
  13. List<Computer> list = new ArrayList<Computer>();
  14. list.add(new Computer("xxxMMeedd", "asus", new Date(), 4455.5));
  15. list.add(new Computer("lenvoXx", "lenvo", new Date(), 4999));
  16. user.setComputers(list);
  17. String path = "D:\\user.xml";
  18. System.out.println("---将对象转换成File类型的xml Start---");
  19. XMLUtil.convertToXml(user, path);
  20. System.out.println("---将对象转换成File类型的xml End---");
  21. System.out.println();
  22. System.out.println("---将File类型的xml转换成对象 Start---");
  23. User user2 = (User) XMLUtil.convertXmlFileToObject(User.class, path);
  24. System.out.println(user2);
  25. System.out.println("---将File类型的xml转换成对象 End---");
  26. }
  27. }

在这里仅仅测试File类型的转换，其结果如下所示：

产生的user.xml文件：

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  2. <User>
  3. <userId>1</userId>
  4. <userName>Steven</userName>
  5. <password>@sun123</password>
  6. <birthday>2013-12-13T18:36:08.508+08:00</birthday>
  7. <money>1000.0</money>
  8. <computers>
  9. <serialNumber>xxxMMeedd</serialNumber>
  10. <brandName>asus</brandName>
  11. <productDate>2013-12-13T18:36:08.508+08:00</productDate>
  12. <price>4455.5</price>
  13. </computers>
  14. <computers>
  15. <serialNumber>lenvoXx</serialNumber>
  16. <brandName>lenvo</brandName>
  17. <productDate>2013-12-13T18:36:08.508+08:00</productDate>
  18. <price>4999.0</price>
  19. </computers>
  20. </User>

控制台输出信息如图5所示为：

图5

这里就可以看出一个模块中有着另外一个模块，在项目中可以通过此种思想不断延伸，可以进行很多数据的暂存，可以起到缓存的目的。代码写完一遍，大家应该有着自己的思路，这样的话，在项目中可以根据具体的情况具体的分析了。

时间： 2024-10-22 10:25:17

玩转Java对象和XML相互转换的相关文章

java对象与xml相互转换 ---- xstream

XStream是一个Java对象和XML相互转换的工具,很好很强大.提供了所有的基础类型.数组.集合等类型直接转换的支持. XStream中的核心类就是XStream类,一般来说,熟悉这个类基本就够用了. 由于XStream.jar依赖于xmlpull.jar 所以,需将这两个jar一同导入. 下载地址 : https://pan.baidu.com/s/1eSpZs3o#path=%252F%25E5%25B7%25A5%25E5%2585%25B7jar XStream对象相当Java对象和

java对象和xml相互转换

Castor-xml.jar包 --Castor可以完成Java和XML的相互转换: 1)利用mapping配置,编组JavaObject.解组XML 在此之前我们设置过mapping.xml.如果不设置,肯定是不能转换成我们想要的XML的.那么,mapping.xml配置文件是怎么配置Account这个对象的呢 mapping.xml配置如下 <?xml version="1.0"encoding="UTF-8"?> <!DOCTYPE mapp

使用XStream注解实现Java对象与XML互相转换的代码示例

本文记录一下使用xstream这个api的注解特性对Java对象与XML字符串相互转换的一些代码示例.    我们很多人都处理过XML文件,也有很多非常成熟的第三方开源软件.如:jdom.dom4j等.虽然他们的功能非常强大,但在使用上还是有点不那么习惯.对于格式比较固定的XML文档,它的结构没有变化或是很少变化,这时将它转换成我们熟悉的Java对象来操作的话,会使工作变得更容易一些,而xstream正好可以满足这一点.    本文所用xstream的版本为:1.4.7 <dependency>

java socket报文通信（三）java对象和xml格式文件的相互转换

前两节讲了socket服务端,客户端的建立以及报文的封装.今天就来讲一下java对象和xml格式文件的相互转换. 上一节中我们列举了一个报文格式,其实我们可以理解为其实就是一个字符串.但是我们不可能每次都去写字符串啊,这样的话肯定要疯.既然是面向对象的编程,肯定会有好的办法来解决这个问题.我们使用JAXBContext这个工具. package cn.com.egj.entity.shortcutTransfer.test; import java.io.BufferedReader; impo

JSON对象与XML相互转换工具类

依赖jar <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</

JAVA对象和XML文档、原来他们之间还有这一出

最近项目开发中遇到一个问题,访问接口不再通过url地址请求的方式,而是 通过socket发送xml格式的报文到指定服务器来进行信息的统一认证.. 因此组装xml格式的报文字符串以及解析服务器返回的xml格式的字符获得所需数据成了 解决问题的关键..在这之前,以为会有点难...做完之后,然并卵,也就那么一回事... LZ主要用的xStream类..这个类的完美地解决了XML文档和JAVA对象之间的转换.. 由于刚刚接触这个类...对于里面提供的很多功能还没细细挖掘..只是简单地实现了 我想要实现的

XML编程总结（六）——使用JAXB进行java对象和xml格式之间的相互转换

(六)使用JAXB进行java对象和xml格式之间的相互转换 JAXB能够使用Jackson对JAXB注解的支持实现(jackson-module-jaxb-annotations),既方便生成XML,也方便生成JSON,这样一来可以更好的标志可以转换为JSON对象的JAVA类. JAXB(Java Architecture for XML Binding) 是一个业界的标准,是一项可以根据XML Schema产生Java类的技术.该过程中,JAXB也提供了将XML实例文档反向生成Java对象树

通过JAXB完成Java对象与XML之间的转换

Java对象转换XML的过程叫marshal. XML转换到Java对象的过程叫unmarshal. 一.Java对象转化为XML 这里省略getter和setter方法 通过标注@XMLRootElement用于标注XML的根元素.这个类的所有属性默认映射为根元素的子元素. 运行代码后,将生成一个D:\test.xml文件,其数据为 二.XML转化为Java对象 代码运行如下 三.更为复杂的映射 将XML中数据读到ArticleData中,类中有一个List,保存每条article数据

使用JAXB实现JAVA对象和XML字符串的互相转换实例

测试类: package com.yanek.test; import java.util.ArrayList; import java.util.List; import com.yanek.test.JaxbUtil.CollectionWrapper; public class Test { /** * @param args */ public static void main(String[] args) { //创建java对象 Hotel hotel=new Hotel(); ho