精华内容
下载资源
问答
  • Java对象XML相互转换

    万次阅读 多人点赞 2018-08-19 13:33:40
    最近在项目中一直出现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 绑定信息的抽象,这些操作包括:解组、编组和验证。

    展开全文
  • 与第三方接口对接,三方使用的xml数据格式,于是使用了JAXB做xmljava对象之间的转换。就是会封装好多和数据结构相同的javabean比较麻烦,但是于考虑转会成json的话嵌套的层数较多,取值容易出错,所以还是选择...

    与第三方接口对接,三方使用的xml数据格式,于是使用了JAXB做xml和java对象之间的转换。就是会封装好多和数据结构相同的javabean比较麻烦,但是于考虑到转会成json的话嵌套的层数较多,取值容易出错,所以还是选择使用了JAXB,现总结如下:

    XML数据:

    <OTA_HotelResRQ Version="2.1" PrimaryLangID="en-us" EchoToken="201403211401"
    RetransmissionIndicator="true" xmlns="http://www.opentravel.org/OTA/2003/05"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
       <HotelReservations>
       	<HotelReservation>
       		<ResGuests>
       			<ResGuest ArrivalTime="14:30">
       				<Profiles>
       					<ProfileInfo>
       						<Profile>
       							<Customer>
       								<PersonName AgeQualifyingCode="10" Gender="M" Age="30">
       									<GivenName>Clark</GivenName>
       									<MiddleName>Soe</MiddleName>
       									<Surname>Jim </Surname>
       								</PersonName>
       								<PersonName AgeQualifyingCode="8" Gender="M" Age="4">
       									<GivenName>Jerry</GivenName> 
       									<Surname>Jim </Surname>
       								</PersonName>
       								<ContactPerson ContactType="non">
       									<PersonName>
       										<GivenName>Ctrip</GivenName>
       										<Surname>International</Surname>
       									</PersonName>
       									<Telephone PhoneNumber="8602165342213"/>
       									<Email>a@b.com</Email>
       								</ContactPerson>
       							</Customer>
       						</Profile>
       					</ProfileInfo>
       				</Profiles>
       			</ResGuest>
       		</ResGuests>
       		<RatePlanDescription>
       			<Text Language="en-us" TextFormat="PlainText">Chrismas Promotion</Text>
       		</RatePlanDescription>
       	</HotelReservation>
       </HotelReservations>
    </OTA_HotelResRQ>
    

    javaBean

    应该每个节点都对应相应的名字的javaBean,这里就不一一样写出了,只列举几个有特征的bean。首先根节点OTA_HotelResRQ 对象:

    /**
     @XmlRootElement :根节点标签
    **/
    @XmlRootElement(name="OTA_HotelResRQ")
    public class OTA_HotelResRQ implements Serializable{
       
       private static final long serialVersionUID = 6594065944133388442L;
       private String EchoToken;
       private List<HotelReservation> HotelReservations;
       
       public OTA_HotelResRQ(String echoToken, List<HotelReservation> hotelReservations) {
       	super();
       	EchoToken = echoToken;
       	HotelReservations = hotelReservations;
       }
       public OTA_HotelResRQ() {
       	super();	
       }
    
       public List<HotelReservation> getHotelReservations() {
       	return HotelReservations;
       }
       /**
       @XmlElementWrapper:有list集合时使用
       @XmlElement:XML的元素标签
       **/
       @XmlElementWrapper(name="HotelReservations")
       @XmlElement(name="HotelReservation")
       public void setHotelReservations(List<HotelReservation> hotelReservations) {
       	HotelReservations = hotelReservations;
       }
    
       public String getEchoToken() {
       	return EchoToken;
       }
       /**
       	@XmlAttribute:XML的属性标签
       **
       @XmlAttribute(name="EchoToken")
       public void setEchoToken(String echoToken) {
       	EchoToken = echoToken;
       }
    }
    

    Customer标签层有多个personName节点此时需要,此时需要定义一个list集合,刚Customer对象定义如下:

    public class Customer implements Serializable{
      private static final long serialVersionUID = 7225574002375905961L;
      
      @XmlElement(name="PersonName")
      private  List<PersonName> PersonNames;
      
      private ContactPerson ContactPerson;
      
      public List<PersonName> getPersonNames() {
      	return PersonNames;
      }
      public void setPersonNames(List<PersonName> personNames) {
      	PersonNames = personNames;
      }
      public ContactPerson getContactPerson() {
      	return ContactPerson;
      }
    
      @XmlElement(name="ContactPerson")
      public void setContactPerson(ContactPerson contactPerson) {
      	ContactPerson = contactPerson;
      }
    }
    

    Text标签既有属性,又有值 ,如下定义:

    public class Text implements Serializable{
      private static final long serialVersionUID = -7475419099742497253L;
      private String Language;
      private String TextFormat;
      private String Text;
      
      public String getLanguage() {
      	return Language;
      }
      
      @XmlAttribute(name="Language")
      public void setLanguage(String language) {
      	Language = language;
      }
      public String getTextFormat() {
      	return TextFormat;
      }
      @XmlAttribute(name="TextFormat")
      public void setTextFormat(String textFormat) {
      	TextFormat = textFormat;
      }
      public String getText() {
      	return Text;
      }
      /**
    @XmlValue : 接收节点值 的标签
    **/
      @XmlValue
      public void setText(String text) {
      	Text = text;
      }
    }
    

    controller层

    @RequestMapping(value = "/createReservation", consumes = "application/xml", method = RequestMethod.POST)
      @ResponseBody
      public String createReservation(@RequestBody OTA_HotelResRQ reservationObj, HttpServletRequest request)
      		throws Exception {
    
      	HotelReservation hotelReservation = reservationObj.getHotelReservations().get(0);
      	}
    

    这样便完成了xml转换成java对象

    java对象转XML

    xml数据格式

    <OTA_HotelResRS Version="2.1" EchoToken="201403211421"
    xmlns="http://www.opentravel.org/OTA/2003/05" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    	<Errors>
    		<Error ShortText="Property 54395 is not a valid property code" Type="3" Code="400"/>
    	</Errors>
    	<HotelReservations> 
    
    		<HotelReservation ResStatus="R">
    			<ResGlobalInfo>
    				<HotelReservationIDs>
    					<HotelReservationID ResID_Value="859623" ResID_Type="501"/>
    				</HotelReservationIDs>
    			</ResGlobalInfo>
    		</HotelReservation>
    	</HotelReservations>
    </OTA_HotelResRS>
    

    javaBean

    @XmlRootElement(name="OTA_HotelResRS")
    public class OTA_HotelResRS implements Serializable {
    	
    	private static final long serialVersionUID = 8908009209610550489L;
    	private String Version;
    	private String EchoToken;
    	private String xmlns;
    	private Success Success;
    	private HotelReservations HotelReservations;
    	private Warnings Warnings;
    	@XmlAttribute(name = "Version")
    	public String getVersion() {
    		return Version;
    	}
    	public void setVersion(String version) {
    		Version = version;
    	}
    	
    	@XmlAttribute(name = "EchoToken")
    	public String getEchoToken() {
    		return EchoToken;
    	}
    	public void setEchoToken(String echoToken) {
    		EchoToken = echoToken;
    	}
    	
    	@XmlAttribute(name = "xmlns")
    	public String getXmlns() {
    		return xmlns;
    	}
    	public void setXmlns(String xmlns) {
    		this.xmlns = xmlns;
    	}
    	
    	@XmlElement(name="Success")
    	public Success getSuccess() {
    		return Success;
    	}
    	public void setSuccess(Success success) {
    		Success = success;
    	}
    	@XmlElement(name = "HotelReservations")
    	public HotelReservations getHotelReservations() {
    		return HotelReservations;
    	}
    	public void setHotelReservations(HotelReservations hotelReservations) {
    		HotelReservations = hotelReservations;
    	}
    }
    
    

    controller层

    @RequestMapping(value = "/createReservation", consumes = "application/xml", method = RequestMethod.POST)
    	@ResponseBody
    	public String createReservation(@RequestBody OTA_HotelResRQ reservationObj, HttpServletRequest request)
    			throws Exception {
    			// 获得转换的上下文对象
    			JAXBContext context = JAXBContext.newInstance(OTA_HotelResRS.class);
    			// 获得Marshaller对象
    			Marshaller marshaller = context.createMarshaller();
    			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    			// 将java对象进行转换成xml respobnse为封装好要返回的java对象
    			OTA_HotelResRS response = new OTA_HotelResRS();
    			marshaller.marshal(response, writer);
    			String XmlString = writer.toString();
    			System.out.println(XmlString);
    	return responseXml;
    }
    
    展开全文
  • XML绑定Java体系结构(JAXB)是将Java对象映射到XML以及从XML映射Java对象流行选择。它提供了易于使用编程接口,用于将Java对象读取和写入XML,反之亦然。...编组— Java对象到XML 在JAXB术语中,Java对象到.

    XML绑定的Java体系结构(JAXB)是将Java对象映射到XML以及从XML映射Java对象的流行选择。它提供了易于使用的编程接口,用于将Java对象读取和写入XML,反之亦然。

    在此快速指南中,您将学习如何将Java对象转换为XML文档。我们还将看一个将XML文档转换回Java对象的示例。

    依存关系

    Java 1.6以来,JAXBJava开发工具包(JDK)的一部分。因此,您不需要任何第三方依赖就可以在项目中使用JAXB

    编组— Java对象到XML

    JAXB术语中,Java对象到XML的转换称为封送处理。编组将Java对象转换为XML文档的过程。JAXB提供了Marshall执行此转换的类。

    创建Java

    在我们实际讨论封送处理的工作原理之前,让我们首先创建两个简单的Java类,分别称为AuthorBook。这些类为一个非常简单的场景建模,在这种场景中,我们有一本书,而每一本书恰好有一位作者。

    我们首先创建Author类以对作者进行建模:

    public class Author {
    
    	private Long id;
    	private String firstName;
    	private String lastName;
    
    	public Author() {
    	}
    
    	public Author(Long id, String firstName, String lastName) {
    		this.id = id;
    		this.firstName = firstName;
    		this.lastName = lastName;
    	}
    
    	public Long getId() {
    		return id;
    	}
    
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	public String getFirstName() {
    		return firstName;
    	}
    
    	public void setFirstName(String firstName) {
    		this.firstName = firstName;
    	}
    
    	public String getLastName() {
    		return lastName;
    	}
    
    	public void setLastName(String lastName) {
    		this.lastName = lastName;
    	}
    
    	@Override
    	public String toString() {
    		return "Author{" + "id=" + id + ", firstName='" + firstName + '\'' + ", lastName='" + lastName + '\'' + '}';
    	}
    }

    Author 是一个简单的Java类,具有ID,名字和姓氏以及它们相应的getsetter方法。

    接下来,我们将创建Book该类并使用JAXB批注注释其字段,以控制应如何将其编组为XML

    import javax.xml.bind.annotation.XmlAttribute;
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlRootElement;
    
    @XmlRootElement(name = "book")
    public class Book {
    
    	private Long id;
    	private String title;
    	private String isbn;
    	private Author author;
    
    	public Book() {
    	}
    
    	public Book(Long id, String title, String isbn, Author author) {
    		this.id = id;
    		this.title = title;
    		this.isbn = isbn;
    		this.author = author;
    	}
    
    	public Long getId() {
    		return id;
    	}
    
    	@XmlAttribute(name = "id")
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	public String getTitle() {
    		return title;
    	}
    
    	@XmlElement(name = "title")
    	public void setTitle(String title) {
    		this.title = title;
    	}
    
    	public String getIsbn() {
    		return isbn;
    	}
    
    	public void setIsbn(String isbn) {
    		this.isbn = isbn;
    	}
    
    	public Author getAuthor() {
    		return author;
    	}
    
    	@XmlElement(name = "author")
    	public void setAuthor(Author author) {
    		this.author = author;
    	}
    
    	@Override
    	public String toString() {
    		return "Book{" + "id=" + id + ", title='" + title + '\'' + ", isbn='" + isbn + '\'' + ", author=" + author
    				+ '}';
    	}
    }

     

    Book上面的类中,我们使用了几个JAXB注释:

    • @XmlRootElement—在顶级类中使用此批注指定XML文档的根元素。批注中的name属性是可选的。如果未指定,则将类名用作XML文档中根元素的名称。
    • @XmlAttribute —此注释用于指示根元素的属性。
    • @XmlElement —在将作为根元素的子元素的类的字段上使用此注释。

    而已。Book现在可以将类编组到XML文档中。让我们从一个简单的场景开始,您要将Java对象转换为XML字符串。

    Java对象转换为XML字符串

    要将Java对象转换为XML字符串,您需要首先创建的实例JAXBContext。这是JAXB API的切入点,它提供了封送,取消封送和验证XML文档的几种方法。

    接下来,Marshall从获取实例JAXBContext。之后,使用其marshal()方法将Java对象编组为XML。您可以将生成的XML写入文件,字符串,或仅在控制台上将其打印。

    这是将Book对象转换为XML字符串的示例:

    try {

        // create an instance of `JAXBContext`

        JAXBContext context = JAXBContext.newInstance(Book.class);

     

        // create an instance of `Marshaller`

        Marshaller marshaller = context.createMarshaller();

     

        // enable pretty-print XML output

        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

     

        // write XML to `StringWriter`

        StringWriter sw = new StringWriter();

     

        // create `Book` object

        Book book = new Book(17L, "Head First Java", "ISBN-45565-45",

                new Author(5L, "Bert", "Bates"));

     

        // convert book object to XML

        marshaller.marshal(book, sw);

     

        // print the XML

        System.out.println(sw.toString());

     

    } catch (JAXBException ex) {

        ex.printStackTrace();

    }

    上面的代码将在控制台上打印以下内容:

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

    <book id="17">

        <author>

            <firstName>Bert</firstName>

            <id>5</id>

            <lastName>Bates</lastName>

        </author>

        <isbn>ISBN-45565-45</isbn>

        <title>Head First Java</title>

    </book>

    Java对象转换为XML文件

    Java对象到XML文件的转换与上面的示例非常相似。您需要做的只是将StringWriter实例替换为File要存储XML的实例:

    try {

        // create an instance of `JAXBContext`

        JAXBContext context = JAXBContext.newInstance(Book.class);

     

        // create an instance of `Marshaller`

        Marshaller marshaller = context.createMarshaller();

     

        // enable pretty-print XML output

        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

     

        // create XML file

        File file = new File("book.xml");

     

        // create `Book` object

        Book book = new Book(17L, "Head First Java", "ISBN-45565-45",

                new Author(5L, "Bert", "Bates"));

     

        // convert book object to XML file

        marshaller.marshal(book, file);

     

    } catch (JAXBException ex) {

        ex.printStackTrace();

    }

    现在,如果您执行上述代码片段,您将看到一个名为XMLXML文件book.xml,其生成的XML内容与上述示例相同。

    解组— XMLJava对象

    XMLJava对象的转换或解组涉及Unmarshaller从创建一个实例JAXBContext并调用unmarshal()方法。此方法接受XML文件作为解组参数。

    以下示例显示了如何将book.xml上面刚刚创建的文件转换为的实例Book

    try {

        // create an instance of `JAXBContext`

        JAXBContext context = JAXBContext.newInstance(Book.class);

     

        // create an instance of `Unmarshaller`

        Unmarshaller unmarshaller = context.createUnmarshaller();

     

        // XML file path

        File file = new File("book.xml");

     

        // convert XML file to `Book` object

        Book book = (Book) unmarshaller.unmarshal(file);

     

        // print book object

        System.out.println(book);

     

    } catch (JAXBException ex) {

        ex.printStackTrace();

    }

    这是上面示例的输出:

    Book{id=17, title='Head First Java', isbn='ISBN-45565-45', author=Author{id=5, firstName='Bert', lastName='Bates'}}

    马歇尔Java集合到XML

    很多时候,您想将Java集合对象(例如ListMap)或SetXML文档编组,还希望将XML转换回Java集合对象。

    对于这样的情况下,我们需要创建一个名为一类特殊的Books是持有ListBook对象。看起来是这样的:

    import java.util.ArrayList;
    import java.util.List;
    
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlRootElement;
    
    @XmlRootElement(name = "books")
    public class Books {
    
    	private List<Book> books;
    
    	public List<Book> getBooks() {
    		return books;
    	}
    
    	@XmlElement(name = "book")
    	public void setBooks(List<Book> books) {
    		this.books = books;
    	}
    
    	public void add(Book book) {
    		if (this.books == null) {
    			this.books = new ArrayList<>();
    		}
    		this.books.add(book);
    	}
    }

     

    Books上面的类中,@XmlRootElement注释将XML的根元素表示为books。此类只有一个List具有gettersetter方法的字段。add()此类的方法接受一个Book对象并将其添加到列表中。

    下面的示例演示如何Java集合对象转换为XML文档

    try {

        // create an instance of `JAXBContext`

        JAXBContext context = JAXBContext.newInstance(Books.class);

     

        // create an instance of `Marshaller`

        Marshaller marshaller = context.createMarshaller();

     

        // enable pretty-print XML output

        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

     

        // create `Books` object

        Books books = new Books();

     

        // add books to list

        books.add(new Book(1L, "Head First Java", "ISBN-45565-45",

                new Author(1L, "Bert", "Bates")));

        books.add(new Book(2L, "Thinking in Java", "ISBN-95855-3",

                new Author(2L, "Bruce", "Eckel")));

     

        // convert `Books` object to XML file

        marshaller.marshal(books, new File("books.xml"));

     

        // print XML to console

        marshaller.marshal(books, System.out);

     

    } catch (JAXBException ex) {

        ex.printStackTrace();

    }

    上面的示例将以下XML输出到books.xml文件以及在控制台上:

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

    <books>

        <book id="1">

            <author>

                <firstName>Bert</firstName>

                <id>1</id>

                <lastName>Bates</lastName>

            </author>

            <isbn>ISBN-45565-45</isbn>

            <title>Head First Java</title>

        </book>

        <book id="2">

            <author>

                <firstName>Bruce</firstName>

                <id>2</id>

                <lastName>Eckel</lastName>

            </author>

            <isbn>ISBN-95855-3</isbn>

            <title>Thinking in Java</title>

        </book>

    </books>

    结论

    Java对象转换为XML文档,反之亦然。我们学习了如何将Java对象或Java集合对象编组为XML文件。同样,我们还看了一个将XML文档转换回Java对象的示例。

     

    展开全文
  • java 对象XML的转换

    2011-05-08 14:03:44
    对象到xml java.beans 类 XMLEncoder XMLEncoder e = new XMLEncoder( new BufferedOutputStream( new FileOutputStream("Test.xml"))); e.wr...
    对象到xml
    java.beans
    类 XMLEncoder

    XMLEncoder e = new XMLEncoder(
    new BufferedOutputStream(
    new FileOutputStream("Test.xml")));
    e.writeObject(new JButton("Hello, world"));
    e.close();


    从xml读取为对象。
    java.beans
    类 XMLDecoder

    XMLDecoder d = new XMLDecoder(
    new BufferedInputStream(
    new FileInputStream("Test.xml")));
    Object result = d.readObject();
    d.close();


    以上是java jdk的实现。
    初步试验了一下 ,属性如果是一个对象,就不可以深度的不序列化为xml

    还有一种就是 xStream
    xStream 可以深度的转换为xml,但是不是标准的set get属性也为转换为xml。
    XStream xStream = new XStream();
    xStream.alias("node", TreeNode.class);
    System.out.println(xStream.toXML(root));
    eclipse 内部也实现了该功能。
    展开全文
  • 使用xStream实现xml和object相互转换 官方地址:http://x-stream.github.io/index.html 1.xStream依赖 <!-- https://mvnrepository.com/artifact/com.thoughtworks.xstream/xstream --> <...
  • java对象xml文件转换

    千次阅读 2011-11-14 15:20:22
    XStream 对象相当Java对象和XML之间的转换器,转换过程是双向的。创建XSteam对象的方式很简单,只需要new XStream()即可。 Java 到xml,用toXML()方法。 Xml到Java,用fromXML()方法。 在没有任何设置默认情况
  • java 对象XML的转换

    2011-07-20 14:44:52
    //保存对象到xml文件中 File file = new File("C:\\xbliuc.xml"); FileOutputStream fos = new FileOutputStream(file); BufferedOutputStream bos = new BufferedOutputStream(fos); XMLEncoder ...
  • Jaxb2 转换XML文档——完成Java对象和XML相互转换 这次介绍Jaxb2完成xml的转换,Jaxb2使用了...下面我们就来看看Jaxb2是怎么样完成Java对象到XML之间的相互转换吧。 一、 准备工作 1、 资源准备 a) 官方文档:ht
  • 利用JAXB实现java对象xml的相互转换

    千次阅读 2014-12-30 15:28:15
    JAXB 可以实现Java对象XML的相互转换,在JAXB中,将一个Java对象转换XML的过程称之为Marshal,将XML转换Java对象的过程称之为UnMarshal。我们可以通过在 Java 类中标注注解的方式将一个Java对象绑定一段XML...
  • 玩转Java对象XML相互转换

    万次阅读 多人点赞 2013-12-13 18:39:08
    最近在项目中一直出现Java对象XML之间相互转换,一开始由于项目很庞大,我又是临时调度过去,导致在按照项目组长要求进行写代码同时,总是在这块云里雾里,最近才慢慢开始搞清楚项目中具体使用缘由。...
  • XStream对象相当Java对象和XML之间的转换器,转换过程是双向的。创建XSteam对象的方式很简单,只需要new XStream()即可。 Java到xml,用toXML()方法。 Xml到Java,用fromXML()方法。     在没有任何...
  • JAXB-java对象xml相互转换

    千次阅读 2015-09-15 10:48:02
    该过程中,JAXB也提供了将XML实例文档反向生成Java对象方法,并能将Java对象内容重新写到XML实例文档。有多种实现。   2、JAXB中有什么:包含“xjc”工具和一个“schemagen”工具。  “xjc”工
  • Java对象XML的相互转换

    千次阅读 2017-10-17 11:10:52
     可以根据XML Schema产生Java类技术.JAXB也提供了将XML实例文档反向生成Java对象方法,并能将Java对象内容重新写到XML实例文档. JAXB 2.0是JDK 1.6组成部分。JAXB 2.2.3是JDK 1.7组成部分。在实际...
  • Java对象转换XML的过程叫marshal。 XML转换到Java对象的过程叫unmarshal。 一、Java对象转化为XML package com.gstarcad.fei.xml.vo;/** * @Title: ${file_name} * @Package ${package_name} * @Description: * ...
  • jaxb是jdk自带一种实现java对象xml文件互相转化;以及生成自动生成xsd文件。 JAXB 2.0是JDK 1.6组成部分。JAXB 2.2.3是JDK 1.7组成部分,不需要引入其他jar包。 主要接口: JAXBContext类,是应用...
  • XStream对象相当Java对象和XML之间的转换器,转换过程是双向的。创建XSteam对象的方式很简单,只需要new XStream()即可。 Java到xml,用toXML()方法。 Xml到Java,用fromXML()方法。   在没有任何默认配置的...
  • 本示例程序提供从XML到java对象的转换方法,同时也提供一种从java对象到XML的转换方法
  • JAXB 实现java对象xml之间互相转换 ... JAXB(Java Architecture for XML Binding)...该过程中,JAXB也提供了将XML实例文档反向生成Java对象方法,并能将Java对象内容重新写 XML实例文档。  
  • @XmlRootElement,将Java类或枚举类型映射到XML元素。(生成xml根节点,默认是class名) 可以用name指定@XmlRootElement(name="QueryResquest") @XmlElement,将Java一个属性映射到与属性同名一个XML元素...
  • JAXB(Java Architecture for XML Binding)是J2SE和J2EE平台的一部分,让开发者能够快速完成Java类和XML的互相映射。一些具体的介绍和使用可以此细看:JAXB教程 java与xml互转工具类: import javax.xml.bind....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,012
精华内容 404
关键字:

java对象到xml的转换

java 订阅