Java对象和XML相互转换

最近在项目中一直出现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

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

注意:

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

2、需要转换的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();  
        }  
          
    }  
}  

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

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页