实体跟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

[html]  view plain  copy

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

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

XMLUtil.java

[html]  view plain  copy

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

下面给出测试类Test.java

[html]  view plain  copy

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

运行的结果如图2所示：

                         图2

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

Test.java

[html]  view plain  copy

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

此时在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

[html]  view plain  copy

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

  此时的User.java内容如下：

[html]  view plain  copy

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

此时测试类为

Test.java

[html]  view plain  copy

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

在这里仅仅测试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

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