Java對象和XML相互轉換

時間 2019-11-09

標籤 java 對象 xml 相互轉換欄目 Java 简体版

原文原文鏈接

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

最近在項目中一直出現Java對象和XML之間的相互轉換，一開始因爲項目很龐大，我又是臨時調度過去，致使在按照項目組長的要求進行寫代碼的同時，老是在這塊雲裏霧裏，最近才慢慢開始搞清楚項目中具體的使用原因。可是項目中封裝的代碼老是很龐大，由於要考慮太多的東西，而對於此，我只能經過小的Demo來講明，其實在項目中用到不少插件，輕巧，靈便，封裝很好使用，但這裏我講解的是JAXB（JavaArchitecture for XML Binding）。java

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的原因：app

1，在項目中，有時候會有不少的XML文件，但若是能夠將這些文件經過對象的方式去操做，就會減小不少操做問題，並且更加符合程序員的編碼方式，框架

2，在項目中，有時候會遇到一個頁面中存在不少的實體類中的數據，並且有時候有些數據不是必需的，就是說能夠經過DTO來編寫這些實體類，但有時候須要將這些DTO進行預先存儲，不是存儲到數據庫中，這樣就有兩種思路，能夠存儲在內存中，也能夠存儲在硬盤上，此時就能夠經過將Java對象轉換成XML文件存儲，或者變成String類型進行存儲在內存中。ide

3，給出一個場景，好比說，一個頁面中有不少個模塊構成，可是這些模塊都是屬於一個總體的模塊，當用戶有操做其中幾個模塊的時候，但操做後的數據不是最終的數據，那這個時候首先要保存當前頁面中的數據（Done），而後到其餘頁面進行其餘操做後再轉到這個頁面，那麼以前那個頁面中的數據應該還會存在，用戶能夠方便查看。可是因爲模塊較多，若是以前就存到數據庫中就會形成浪費，由於其不是最終的保存效果，而當用戶想進行保存（Save），此時才進行將最終的數據保存到數據庫中。在這個過程當中就會用到大量的臨時數據，而解決這個問題很好的方法就是能夠用XML保存頁面中當前的數據。函數

在本文中，首先我給出一個對象與XML的相互轉換，而後，在經過模塊的概念闡述要點三種的場景，固然，代碼不難，很簡單的模擬，對於項目中的概念會比這複雜不少，也會有專門複雜這個過程的代碼編寫。因此，我僅僅是拋磚引玉，可以讓讀者儘可能有這種思想，到時候寫項目的時候若是有遇到此種狀況，就能夠很好的進行思想遷移。

說這麼多，就來看看到底如何進行Java對象和XML之間的相互轉換吧。

首先看看Java項目的結構圖：

首先給出User.java這個類

User.java

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

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

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---");
}
}

第二種方式的測試類以下所示;

Test.java

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

此時打開user.xml，內容以下所示：

<?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

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內容以下：

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

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

<?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>

這裏就能夠看出一個模塊中有着另一個模塊，在項目中能夠經過此種思想不斷延伸，能夠進行不少數據的暫存，能夠起到緩存的目的。代碼寫完一遍，你們應該有着本身的思路，這樣的話，在項目中能夠根據具體的狀況具體的分析了。

Unmarshaller 類使客戶端應用程序可以將 XML 數據轉換爲 Java 內容對象樹。

備註：marshal(序列化、排列、整理)

Marshaller 類使客戶端應用程序可以將 Java 內容樹轉換回 XML 數據。

package hb.jaxb;
public class Classroom {
private int id;
private String name;
private int grade;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public Classroom(int id, String name, int grade) {
super();
this.id = id;
this.name = name;
this.grade = grade;
}
public Classroom() {
super();
}
}

package hb.jaxb;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class Student {
private int id;
private String name;
private int age;
private Classroom classroom;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Classroom getClassroom() {
return classroom;
}
public void setClassroom(Classroom classroom) {
this.classroom = classroom;
}
public Student(int id, String name, int age, Classroom classroom) {
super();
this.id = id;
this.name = name;
this.age = age;
this.classroom = classroom;
}
//無參夠着函數必定須要，不然JXBContext沒法正常解析。
public Student() {
super();
}
}

注意：

一、須要轉換的model對象必定要添加@XmlRootElement註解，其裏面的其餘對象則不須要

二、須要轉換的model對象必定要有不帶參數的構造方法，包括該對象裏面引用的對象。

package hb.jaxb;
import java.io.StringReader;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import org.junit.Test;
public class TestJaxb {
@Test
public void beanToXML() {
Classroom classroom = new Classroom(1, "軟件工程", 4);
Student student = new Student(101, "張三", 22, classroom);
try {
JAXBContext context = JAXBContext.newInstance(Student.class);
Marshaller marshaller = context.createMarshaller();
marshaller.marshal(student, System.out);
} catch (JAXBException e) {
e.printStackTrace();
}
}
@Test
public void XMLStringToBean(){
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>";
try {
JAXBContext context = JAXBContext.newInstance(Student.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
Student student = (Student)unmarshaller.unmarshal( new StringReader(xmlStr));
System.out.println(student.getAge());
System.out.println(student.getClassroom().getName());
} catch (JAXBException e) {
e.printStackTrace();
}
}
}