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





package com.xml;

import java.io.Serializable;

import java.util.Date;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

/**

*

* @author Steven

*

*/

@XmlAccessorType(XmlAccessType.FIELD)

// XML文件中的根标识

@XmlRootElement(name = "User")

// 控制JAXB 绑定类中属性和字段的排序

@XmlType(propOrder = {

"userId",

"userName",

"password",

"birthday",

"money",

})

public class User implements Serializable {

private static final long serialVersionUID = 1L;

// 用户Id

private int userId;

// 用户名

private String userName;

// 用户密码

private String password;

// 用户生日

private Date birthday;

// 用户钱包

private double money;

public User() {

super();

}

public User(int userId, String userName, String password, Date birthday,

double money) {

super();

this.userId = userId;

this.userName = userName;

this.password = password;

this.birthday = birthday;

this.money = money;

}

public int getUserId() {

return userId;

}

public void setUserId(int userId) {

this.userId = userId;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public Date getBirthday() {

return birthday;

}

public void setBirthday(Date birthday) {

this.birthday = birthday;

}

public double getMoney() {

return money;

}

public void setMoney(double money) {

this.money = money;

}

@Override

public String toString() {

return "User [birthday=" + birthday + ", money=" + money

+ ", password=" + password + ", userId=" + userId

+ ", userName=" + userName + "]";

}

}

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

XMLUtil.java

[java] view
plaincopy





package com.xml;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Marshaller;

import javax.xml.bind.Unmarshaller;

/**

* 封装了XML转换成object，object转换成XML的代码

*

* @author Steven

*

*/

public class XMLUtil {

/**

* 将对象直接转换成String类型的 XML输出

*

* @param obj

* @return

*/

public static String convertToXml(Object obj) {

// 创建输出流

StringWriter sw = new StringWriter();

try {

// 利用jdk中自带的转换类实现

JAXBContext context = JAXBContext.newInstance(obj.getClass());

Marshaller marshaller = context.createMarshaller();

// 格式化xml输出的格式

marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,

Boolean.TRUE);

// 将对象转换成输出流形式的xml

marshaller.marshal(obj, sw);

} catch (JAXBException e) {

e.printStackTrace();

}

return sw.toString();

}

/**

* 将对象根据路径转换成xml文件

*

* @param obj

* @param path

* @return

*/

public static void convertToXml(Object obj, String path) {

try {

// 利用jdk中自带的转换类实现

JAXBContext context = JAXBContext.newInstance(obj.getClass());

Marshaller marshaller = context.createMarshaller();

// 格式化xml输出的格式

marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,

Boolean.TRUE);

// 将对象转换成输出流形式的xml

// 创建输出流

FileWriter fw = null;

try {

fw = new FileWriter(path);

} catch (IOException e) {

e.printStackTrace();

}

marshaller.marshal(obj, fw);

} catch (JAXBException e) {

e.printStackTrace();

}

}

@SuppressWarnings("unchecked")

/**

* 将String类型的xml转换成对象

*/

public static Object convertXmlStrToObject(Class clazz, String xmlStr) {

Object xmlObject = null;

try {

JAXBContext context = JAXBContext.newInstance(clazz);

// 进行将Xml转成对象的核心接口

Unmarshaller unmarshaller = context.createUnmarshaller();

StringReader sr = new StringReader(xmlStr);

xmlObject = unmarshaller.unmarshal(sr);

} catch (JAXBException e) {

e.printStackTrace();

}

return xmlObject;

}

@SuppressWarnings("unchecked")

/**

* 将file类型的xml转换成对象

*/

public static Object convertXmlFileToObject(Class clazz, String xmlPath) {

Object xmlObject = null;

try {

JAXBContext context = JAXBContext.newInstance(clazz);

Unmarshaller unmarshaller = context.createUnmarshaller();

FileReader fr = null;

try {

fr = new FileReader(xmlPath);

} catch (FileNotFoundException e) {

e.printStackTrace();

}

xmlObject = unmarshaller.unmarshal(fr);

} catch (JAXBException e) {

e.printStackTrace();

}

return xmlObject;

}

}

下面给出测试类Test.java

[java] view
plaincopy





package com.xml;

import java.util.Date;

/**

*

* @author Steven

*

*/

public class Test {

public static void main(String[] args) {

// 创建需要转换的对象

User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);

System.out.println("---将对象转换成string类型的xml Start---");

// 将对象转换成string类型的xml

String str = XMLUtil.convertToXml(user);

// 输出

System.out.println(str);

System.out.println("---将对象转换成string类型的xml End---");

System.out.println();

System.out.println("---将String类型的xml转换成对象 Start---");

User userTest = (User) XMLUtil.convertXmlStrToObject(User.class, str);

System.out.println(userTest);

System.out.println("---将String类型的xml转换成对象 End---");

}

}

运行的结果如图2所示：



图2

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

Test.java

[java] view
plaincopy





package com.xml;

import java.util.Date;

/**

*

* @author Steven

*

*/

public class Test {

public static void main(String[] args) {

// 创建需要转换的对象

User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);

String path = "D:\\user.xml";

System.out.println("---将对象转换成File类型的xml Start---");

XMLUtil.convertToXml(user, path);

System.out.println("---将对象转换成File类型的xml End---");

System.out.println();

System.out.println("---将File类型的xml转换成对象 Start---");

User user2 = (User) XMLUtil.convertXmlFileToObject(User.class, path);

System.out.println(user2);

System.out.println("---将File类型的xml转换成对象 End---");

}

}

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



图3

控制台信息如图4所示：



图4

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

[html] view
plaincopy





<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<User>

<userId>1</userId>

<userName>Steven</userName>

<password>@sun123</password>

<birthday>2013-12-13T18:24:03.477+08:00</birthday>

<money>1000.0</money>

</User>

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

Computer.java

[java] view
plaincopy





package com.xml;

import java.io.Serializable;

import java.util.Date;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

/**

* 电脑类

*

* @author Steven

*

*/

@XmlAccessorType(XmlAccessType.FIELD)

@XmlRootElement(name = "Computer")

@XmlType(propOrder = { "serialNumber", "brandName", "productDate", "price" })

public class Computer implements Serializable {

private static final long serialVersionUID = 1L;

// 序列号

private String serialNumber;

// 品牌名

private String brandName;

// 生成日期

private Date productDate;

// 价格

private double price;

public Computer() {

super();

}

public Computer(String serialNumber, String brandName, Date productDate,

double price) {

super();

this.serialNumber = serialNumber;

this.brandName = brandName;

this.productDate = productDate;

this.price = price;

}

public String getSerialNumber() {

return serialNumber;

}

public void setSerialNumber(String serialNumber) {

this.serialNumber = serialNumber;

}

public String getBrandName() {

return brandName;

}

public void setBrandName(String brandName) {

this.brandName = brandName;

}

public Date getProductDate() {

return productDate;

}

public void setProductDate(Date productDate) {

this.productDate = productDate;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

}

此时的User.java内容如下：

[java] view
plaincopy





package com.xml;

import java.io.Serializable;

import java.util.Date;

import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

/**

*

* @author Steven

*

*/

@XmlAccessorType(XmlAccessType.FIELD)

// XML文件中的根标识

@XmlRootElement(name = "User")

// 控制JAXB 绑定类中属性和字段的排序

@XmlType(propOrder = {

"userId",

"userName",

"password",

"birthday",

"money",

"computers"

})

public class User implements Serializable {

private static final long serialVersionUID = 1L;

// 用户Id

private int userId;

// 用户名

private String userName;

// 用户密码

private String password;

// 用户生日

private Date birthday;

// 用户钱包

private double money;

// 拥有的电脑

private List<Computer> computers;

public User() {

super();

}

public User(int userId, String userName, String password, Date birthday,

double money) {

super();

this.userId = userId;

this.userName = userName;

this.password = password;

this.birthday = birthday;

this.money = money;

}

public int getUserId() {

return userId;

}

public void setUserId(int userId) {

this.userId = userId;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public Date getBirthday() {

return birthday;

}

public void setBirthday(Date birthday) {

this.birthday = birthday;

}

public double getMoney() {

return money;

}

public void setMoney(double money) {

this.money = money;

}

public void setComputers(List<Computer> computers) {

this.computers = computers;

}

public List<Computer> getComputers() {

return computers;

}

@Override

public String toString() {

return "User [birthday=" + birthday + ", computers=" + computers

+ ", money=" + money + ", password=" + password + ", userId="

+ userId + ", userName=" + userName + "]";

}

}

此时测试类为

Test.java

[java] view
plaincopy





package com.xml;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

/**

*

* @author Steven

*

*/

public class Test {

public static void main(String[] args) {

User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);

List<Computer> list = new ArrayList<Computer>();

list.add(new Computer("xxxMMeedd", "asus", new Date(), 4455.5));

list.add(new Computer("lenvoXx", "lenvo", new Date(), 4999));

user.setComputers(list);

String path = "D:\\user.xml";

System.out.println("---将对象转换成File类型的xml Start---");

XMLUtil.convertToXml(user, path);

System.out.println("---将对象转换成File类型的xml End---");

System.out.println();

System.out.println("---将File类型的xml转换成对象 Start---");

User user2 = (User) XMLUtil.convertXmlFileToObject(User.class, path);

System.out.println(user2);

System.out.println("---将File类型的xml转换成对象 End---");

}

}

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

产生的user.xml文件：

[html] view
plaincopy





<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<User>

<userId>1</userId>

<userName>Steven</userName>

<password>@sun123</password>

<birthday>2013-12-13T18:36:08.508+08:00</birthday>

<money>1000.0</money>

<computers>

<serialNumber>xxxMMeedd</serialNumber>

<brandName>asus</brandName>

<productDate>2013-12-13T18:36:08.508+08:00</productDate>

<price>4455.5</price>

</computers>

<computers>

<serialNumber>lenvoXx</serialNumber>

<brandName>lenvo</brandName>

<productDate>2013-12-13T18:36:08.508+08:00</productDate>

<price>4999.0</price>

</computers>

</User>

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



图5

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