Java对象和XML相互转换

https://blog.csdn.net/liliang_11676/article/details/81837215

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

首先给出User.java这个类

User.java

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

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

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.  
    }

 

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

Test.java

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所示：

此时打开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.  
    
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内容如下：

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

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

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>

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

 

Unmarshaller 类使客户端应用程序能够将 XML 数据转换为 Java 内容对象树。

备注：marshal(序列化、排列、整理)

Marshaller 类使客户端应用程序能够将 Java 内容树转换回 XML 数据。

1.  
   package hb.jaxb;
2.  
    
3.  
   public class Classroom {
4.  
   private int id;
5.  
   private String name;
6.  
   private int grade;
7.  
    
8.  
   public int getId() {
9.  
   return id;
10.  
    }
11.  
     
12.  
    public void setId(int id) {
13.  
    this.id = id;
14.  
    }
15.  
     
16.  
    public String getName() {
17.  
    return name;
18.  
    }
19.  
     
20.  
    public void setName(String name) {
21.  
    this.name = name;
22.  
    }
23.  
     
24.  
    public int getGrade() {
25.  
    return grade;
26.  
    }
27.  
     
28.  
    public void setGrade(int grade) {
29.  
    this.grade = grade;
30.  
    }
31.  
     
32.  
    public Classroom(int id, String name, int grade) {
33.  
    super();
34.  
    this.id = id;
35.  
    this.name = name;
36.  
    this.grade = grade;
37.  
    }
38.  
     
39.  
    public Classroom() {
40.  
    super();
41.  
    }
42.  
     
43.  
    }

1.  
   package hb.jaxb;
2.  
    
3.  
   import javax.xml.bind.annotation.XmlRootElement;
4.  
    
5.  
   @XmlRootElement
6.  
   public class Student {
7.  
   private int id;
8.  
   private String name;
9.  
   private int age;
10.  
    private Classroom classroom;
11.  
     
12.  
    public int getId() {
13.  
    return id;
14.  
    }
15.  
     
16.  
    public void setId(int id) {
17.  
    this.id = id;
18.  
    }
19.  
     
20.  
    public String getName() {
21.  
    return name;
22.  
    }
23.  
     
24.  
    public void setName(String name) {
25.  
    this.name = name;
26.  
    }
27.  
     
28.  
    public int getAge() {
29.  
    return age;
30.  
    }
31.  
     
32.  
    public void setAge(int age) {
33.  
    this.age = age;
34.  
    }
35.  
     
36.  
    public Classroom getClassroom() {
37.  
    return classroom;
38.  
    }
39.  
     
40.  
    public void setClassroom(Classroom classroom) {
41.  
    this.classroom = classroom;
42.  
    }
43.  
     
44.  
    public Student(int id, String name, int age, Classroom classroom) {
45.  
    super();
46.  
    this.id = id;
47.  
    this.name = name;
48.  
    this.age = age;
49.  
    this.classroom = classroom;
50.  
    }
51.  
     
52.  
    //无参够着函数一定需要，否则JXBContext无法正常解析。
53.  
    public Student() {
54.  
    super();
55.  
    }
56.  
    }

注意：

1、需要转换的model对象一定要添加@XmlRootElement注解，其里面的其他对象则不需要

2、需要转换的model对象一定要有不带参数的构造方法，包括该对象里面引用的对象。

1.  
   package hb.jaxb;
2.  
    
3.  
   import java.io.StringReader;
4.  
    
5.  
   import javax.xml.bind.JAXBContext;
6.  
   import javax.xml.bind.JAXBException;
7.  
   import javax.xml.bind.Marshaller;
8.  
   import javax.xml.bind.Unmarshaller;
9.  
   import org.junit.Test;
10.  
     
11.  
    public class TestJaxb {
12.  
     
13.  
    @Test
14.  
    public void beanToXML() {
15.  
    Classroom classroom = new Classroom(1, "软件工程", 4);
16.  
    Student student = new Student(101, "张三", 22, classroom);
17.  
     
18.  
    try {
19.  
    JAXBContext context = JAXBContext.newInstance(Student.class);
20.  
    Marshaller marshaller = context.createMarshaller();
21.  
    marshaller.marshal(student, System.out);
22.  
    } catch (JAXBException e) {
23.  
    e.printStackTrace();
24.  
    }
25.  
     
26.  
    }
27.  
     
28.  
    @Test
29.  
    public void XMLStringToBean(){
30.  
    String xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><student><age>22</age><classroom><grade>4</grade><id>1</id><name>软件工程</name></classroom><id>101</id><name>张三</name></student>";
31.  
    try {
32.  
    JAXBContext context = JAXBContext.newInstance(Student.class);
33.  
    Unmarshaller unmarshaller = context.createUnmarshaller();
34.  
    Student student = (Student)unmarshaller.unmarshal(new StringReader(xmlStr));
35.  
    System.out.println(student.getAge());
36.  
    System.out.println(student.getClassroom().getName());
37.  
    } catch (JAXBException e) {
38.  
    e.printStackTrace();
39.  
    }
40.  
     
41.  
    }
42.  
    }

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

 

    JAXBContext 类提供到 JAXB API 的客户端入口点。它提供了管理实现 JAXB 绑定框架操作所需的 XML/Java 绑定信息的抽象，这些操作包括：解组、编组和验证。