玩转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

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

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

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

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，内容如下所示：

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

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内容如下：

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

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文件：

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

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