Java对象和XML相互转换

2019/08/27 17:41
阅读数 64

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 绑定信息的抽象,这些操作包括:解组、编组和验证。

展开阅读全文
加载中
点击引领话题📣 发布并加入讨论🔥
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部