java对象和xml互转

灰太狼 2022-07-19 05:21 162阅读 0赞

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的相互转换，然后，在通过模块的概念阐述要点三种的场景，当然，代码不难，很简单的模拟，对于项目中的概念会比这复杂很多，也会有专门复杂这个过程的代码编写。所以，我仅仅是抛砖引玉，能够让读者尽量有这种思想，到时候写项目的时候如果有遇到此种情况，就可以很好的进行思想迁移。

pojo

package com.ming.pojo;
    
    import java.io.Serializable;
    
    import javax.xml.bind.annotation.XmlAccessType;
    import javax.xml.bind.annotation.XmlAccessorType;
    import javax.xml.bind.annotation.XmlRootElement;
    import javax.xml.bind.annotation.XmlType;
    
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlRootElement(name = "Phone")
    @XmlType(propOrder = { "userId", "phone" })
    public class Phone implements Serializable { 
        /** * */
        private static final long serialVersionUID = 1L;
        private long userId;
        private String phone;
    
        public Phone() {
        }
    
        public Phone(long userId, String phone) {
            super();
            this.userId = userId;
            this.phone = phone;
        }
    
        public long getUserId() {
            return userId;
        }
    
        public void setUserId(long userId) {
            this.userId = userId;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        @Override
        public String toString() {
            return "Phone [userId=" + userId + ", phone=" + phone + "]";
        }
    
    }

package com.ming.pojo;
    
    import java.io.Serializable;
    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;
    
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlRootElement(name = "User")
    @XmlType(propOrder = { "userId", "userName", "passWord","phones" })
    public class User implements Serializable { 
        /** * */
        private static final long serialVersionUID = 1858480386705537937L;
        private long userId;
        private String userName;
        private String passWord;
        private List<Phone> phones;
    
        public User() {
        }
    
        public User(long userId, String userName, String passWord) {
            this.userId = userId;
            this.userName = userName;
            this.passWord = passWord;
        }
    
        public long getUserId() {
            return userId;
        }
    
        public void setUserId(long 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 List<Phone> getPhones() {
            return phones;
        }
    
        public void setPhones(List<Phone> phones) {
            this.phones = phones;
        }
    
        @Override
        public String toString() {
            return "User [userId=" + userId + ", userName=" + userName + ", passWord=" + passWord + ", phones=" + phones
                    + "]";
        }
    
    }

核心

package com.ming.util;
    
    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 ming * */  
    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;  
        }  
    }

测试：

package com.ming;
    
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    import com.ming.pojo.Phone;
    import com.ming.pojo.User;
    import com.ming.util.XMLUtil;
    
    public class Test {
        public static void main(String[] args) {
            // 创建需要转换的对象
            User user = new User(1, "ming","123456");
            Phone phone=new Phone(1,"12345678910");
            Phone phone1=new Phone(1,"12345678911");
            List<Phone> phones=new ArrayList<Phone>();
            phones.add(phone);
            phones.add(phone1);
            user.setPhones(phones);
            System.out.println("---将对象转换成string类型的xml Start---");
            // 将对象转换成string类型的xml
            String str = XMLUtil.convertToXml(user);
            // 输出
            System.out.println(str);
    
            User user1=(User) XMLUtil.convertXmlStrToObject(User.class, str);
            System.out.println(user1);
    
        }
    }