正文

简单实体类和xml文件的相互转换

author  author  2022-09-16  758

关键词：

最近写一个题目，要求将一组员工实体类转换成xml文件，或将xml文件转换成一组实体类。题目不难，但写完感觉可以利用泛型和反射将任意一个实体类和xml文件进行转换。于是今天下午立马动手

试了下，做了个简单的模型，可以将简单的实体类和xml文件进行相互转换，但对实体类的属性类型有限制，目前只支持String, Integer, Double三种类型。但是后面可以扩展。

我的大概思路是这样的，只要能拿到实体类的类型信息，我就能拿到实体类的全部字段名称和类型，拼属性的set和get方法更是简单明了，这时候只需要通过方法的反射，将xml文件的数据读取出来给这个反射即可。

反过来只要给我一个任意对象，我就能通过反射拿到该对象所有字段的值，这时候在写xml文件即可。

具体代码如下：

package com.pcq.entity;

import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

public class XMLAndEntityUtil {
    private static Document document = DocumentHelper.createDocument();
    
    /**
     * 判断是否是个xml文件,目前类里尚未使用该方法
     * @param filePath 
     * @return
     */
    @SuppressWarnings("unused")
    private static boolean isXMLFile(String filePath) {
        File file = new File(filePath);
        if(!file.exists() || filePath.indexOf(".xml") > -1) {
            return false;
        }
        return true;
    }
    
    /**
     * 将一组对象数据转换成XML文件
     * @param list
     * @param filePath 存放的文件路径
     */
    public static <T> void writeXML(List<T> list, String filePath) {
        Class<?> c = list.get(0).getClass();
        String root = c.getSimpleName().toLowerCase() + "s";
        Element rootEle = document.addElement(root);
        for(Object obj : list) {
            try {
                Element e = writeXml(rootEle, obj);
                document.setRootElement(e);
                writeXml(document, filePath);
            } catch (NoSuchMethodException | SecurityException
                    | IllegalAccessException | IllegalArgumentException
                    | InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 通过一个根节点来写对象的xml节点，这个方法不对外开放，主要给writeXML(List<T> list, String filePath)提供服务
     * @param root
     * @param object
     * @return
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    private static Element writeXml(Element root, Object object) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Class<?> c = object.getClass();
        String className = c.getSimpleName().toLowerCase();
        Element ele = root.addElement(className);
        Field[] fields = c.getDeclaredFields();
        for(Field f : fields) {
            String fieldName = f.getName();
            String param = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
            Element fieldElement = ele.addElement(fieldName);
            Method m = c.getMethod("get" + param, null);
            String s = "";
            if(m.invoke(object, null) != null) {
                s = m.invoke(object, null).toString();
            }
            fieldElement.setText(s);
        }
        return root;
    }
    
    /**
     * 默认使用utf-8
     * @param c
     * @param filePath
     * @return
     * @throws UnsupportedEncodingException
     * @throws FileNotFoundException
     */
    public static <T> List<T> getEntitys(Class<T> c, String filePath) throws UnsupportedEncodingException, FileNotFoundException {
        return getEntitys(c, filePath, "utf-8");
    }
    /**
     * 将一个xml文件转变成实体类
     * @param c
     * @param filePath
     * @return
     * @throws FileNotFoundException 
     * @throws UnsupportedEncodingException 
     */
    public static <T> List<T> getEntitys(Class<T> c, String filePath, String encoding) throws UnsupportedEncodingException, FileNotFoundException {
        File file = new File(filePath);
        String labelName = c.getSimpleName().toLowerCase();
        SAXReader reader = new SAXReader();
        List<T> list = null;
         try {
            InputStreamReader in = new InputStreamReader(new FileInputStream(file), encoding);
            Document document = reader.read(in);
            Element root = document.getRootElement();
            List elements = root.elements(labelName);
            list = new ArrayList<T>();
            for(Iterator<Emp> it = elements.iterator(); it.hasNext();) {
                 Element e = (Element)it.next();
                 T t = getEntity(c, e);
                 list.add(t);
             }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e1) {
            e1.printStackTrace();
        } catch (IllegalAccessException e1) {
            e1.printStackTrace();
        } catch (NoSuchMethodException e1) {
            e1.printStackTrace();
        } catch (SecurityException e1) {
            e1.printStackTrace();
        } catch (IllegalArgumentException e1) {
            e1.printStackTrace();
        } catch (InvocationTargetException e1) {
            e1.printStackTrace();
        }
        return list;
    }
    
    
    /**
     * 将一种类型 和对应的 xml元素节点传进来，返回该类型的对象,该方法不对外开放
     * @param c  类类型
     * @param ele 元素节点
     * @return  该类型的对象
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    @SuppressWarnings("unchecked")
    private static <T> T getEntity(Class<T> c, Element ele) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
        Field[] fields = c.getDeclaredFields();
        Object object = c.newInstance();//
        for(Field f : fields) {
            String type = f.getType().toString();//获得字段的类型
            String fieldName = f.getName();//获得字段名称
            String param = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);//把字段的第一个字母变成大写
            Element e = ele.element(fieldName);
            if(type.indexOf("Integer") > -1) {//说明该字段是Integer类型
                Integer i = null;
                if(e.getTextTrim() != null && !e.getTextTrim().equals("")) {
                    i = Integer.parseInt(e.getTextTrim());
                }
                Method m = c.getMethod("set" + param, Integer.class);
                m.invoke(object, i);//通过反射给该字段set值
            }
            if(type.indexOf("Double") > -1) { //说明该字段是Double类型
                Double d = null;
                if(e.getTextTrim() != null && !e.getTextTrim().equals("")) {
                    d = Double.parseDouble(e.getTextTrim());
                }
                Method m = c.getMethod("set" + param, Double.class);
                m.invoke(object, d);
            }
            if(type.indexOf("String") > -1) {//说明该字段是String类型
                String s = null;
                if(e.getTextTrim() != null && !e.getTextTrim().equals("")) {
                    s = e.getTextTrim();
                }
                Method m = c.getMethod("set" + param, String.class);
                m.invoke(object, s);
            }
        }
        return (T)object;
    }
    /**
     * 用来写xml文件
     * @param doc Document对象
     * @param filePath 生成的文件路径
     * @param encoding 写xml文件的编码
     */
    public static void writeXml(Document doc, String filePath, String encoding) {
        XMLWriter writer = null;
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding(encoding);// 指定XML编码        

        try {
            writer = new XMLWriter(new FileWriter(filePath), format);
            writer.write(doc);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 默认使用utf-8的格式写文件
     * @param doc
     * @param filePath
     */
    public static void writeXml(Document doc, String filePath) {
        writeXml(doc, filePath, "utf-8");
    }
}

假如有个实体类是：

package com.pcq.entity;

import java.io.Serializable;

public class Emp implements Serializable{

    private Integer id;
    private String name;
    private Integer deptNo;
    private Integer age;
    private String gender;
    private Integer bossId;
    private Double salary;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getDeptNo() {
        return deptNo;
    }
    public void setDeptNo(Integer deptNo) {
        this.deptNo = deptNo;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public Integer getBossId() {
        return bossId;
    }
    public void setBossId(Integer bossId) {
        this.bossId = bossId;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    
}

那么写出来的xml文件格式如下：

<?xml version="1.0" encoding="utf-8"?>

<emps>
  <emp>
    <id>1</id>
    <name>张三</name>
    <deptNo>50</deptNo>
    <age>25</age>
    <gender>男</gender>
    <bossId>6</bossId>
    <salary>9000.0</salary>
  </emp>
  <emp>
    <id>2</id>
    <name>李四</name>
    <deptNo>50</deptNo>
    <age>22</age>
    <gender>女</gender>
    <bossId>6</bossId>
    <salary>8000.0</salary>
  </emp>
</emps>

假如有个实体类如下：

package com.pcq.entity;

public class Student {

    private Integer id;
    private String name;
    private Integer age;
    private String gender;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    
}

那么写出来的xml文件如下

<?xml version="1.0" encoding="utf-8"?>

<students>
  <student>
    <id></id>
    <name>pcq</name>
    <age>18</age>
    <gender>男</gender>
  </student>
</students>

读取也必须读这种格式的xml文件，才能转换成实体类，要求是实体类的类类型信息（Class）必须要获得到。

另外这里的实体类的属性类型均是Integer,String,Double,可以看到工具类里只对这三种类型做了判断。而且可以预想的是，如果出现一对多的关系，即一个实体类拥有一组另一个类对象的引用，

那xml和实体类的相互转换要比上述的情况复杂的多。lz表示短时间内甚至长时间内也不一定能做的出来，欢迎同道高人指点。

springboot配置xml与实体类的相互转换

...boot会将http报文首部content-type为application/json的报文主体与实体类，map，List之间做相互转换。做以下配置，可以实现xml格式与实体类，map，list之间相互转换。配置该依赖后，@RequestBody可以将请求报文为application/xml格式的主体可以... 查看详情

实体类和json对象之间相互转化

. [代码]工具类 ?123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778packagem 查看详情

xml和实体类之间相互转换(序列化和反序列化)

我们需要在XML与实体类，DataTable，List之间进行转换，下面是XmlUtil类，该类来自网络并稍加修改。 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727 查看详情

xml和实体类之间相互转换(序列化和反序列化)

在idea中自动生成实体类和hibernate.cfg.xml文件

1　　按快捷键ctrl+shift+alt+s调出projectstructure菜单,点击项目名称,添加hibernate模块,在最右侧点击+号,添加hibernate.cfg.xml文件2　　点击DataBase中的+号,连接mysql数据库选择数据库名称, 建立连接3　　在persistence窗口中,右键,genaratepersi... 查看详情

spring简单的配置和操作(创建实体类,配置xml文件,调试)

<1>实体类 Personpackagejava_spring.modle;/***一个实体类(Person)*/publicclassPerson{privateintuserId;privateStringuserName;privateStringuserAge;publicintgetUserId(){returnuserId;}publicvoidsetUserId 查看详情

java的generator工具类，数据库生成实体类和映射文件(代码片段)

首先需要几个jar包：freemarker-2.3.23.jarlog4j-1.2.16.jarmybatis-3.2.3.jarmybatis-generator-core-1.3.2.jarmysql-connector-java-5.1.28-bin.jarojdbc14.jar这些jar包网上都有下载的地方xml配置文件：generatorConfig.xml代查看详情

java的generator工具类，数据库生成实体类和映射文件(代码片段)

xml文件与实体类的互相转换

　1.通常程序的配置信息都保存在程序或者网站的专门的配置文件中(App.config/web.config)。但是现在为了演示XML序列化和反序列化，将配置信息保存在一个XML文件(config.xml)中，通过反序列化将配置信息读取出来保存到一个单独的类(C... 查看详情

xml与数组的相互转换

1、XML转数组步骤：（1）首先使用SimpleXML将xml文件转换为对象（2）由于这个对象中既有数组，数组内又包含对象，我们使用递归将每一个对象强转成数组转换代码：<?php/***XML转换成数组*@authorwebbc*/functionxml2arr($simxml){$simxml=(array... 查看详情

xml文件和domdocumentstring字符串三种类型之间的相互转换(代码片段)

　　　　最近在工作中用到了解析XML文件，网上的教程一言难尽，分享一个我自己解析XML文件的方法，记录一下。有XML文件转成DOM，XML文件转成Sting，String转DOM等各种操作。用的包是 org.w3c.dom.Document下的/***@Authordengzp*@Date2022/3... 查看详情

springboot集成mybatis自动生成实体类和mapper文件dao层

1.创建springboot集成mybatis请见2.在resources目录下新键mybatis-generator文件夹，并在文件夹中新键mybatis-generatorConfig.xml文件和mybatis-generatorinit.properties两个文件mybatis-generatorinit.propertiesjdbc_driver=oracle.jdbc.driver. 查看详情

xml和json格式相互转换的java实现

依赖的包:json-lib-2.4-jdk15.jarezmorph-1.0.6.jarxom-1.2.1.jarcommons-lang-2.1.jarcommons-io-1.3.2.jarjaxen-1.1.jar 输入xml文件,输出JSON对象 packagecom.cash.util;importjava.io.IOException;imp 查看详情

labelimg标注的voc格式标签xml文件和yolo格式标签txt文件相互转换(代码片段)

目录1labelimg标注VOC格式和yolo格式介绍1.1voc格式1.2yolo数据格式介绍2voc格式数据和yolo格式数据相互转换2.1voc转yolo代码2.2yolo转voc格式代码 1labelimg标注VOC格式和yolo格式介绍 labelimg标注工具怎么安装和使用在我的博客中已经讲... 查看详情

用java实现xml文件转实体类

...esponse>这种xml文件对应一系列的java类，所展现的是一个实体的值，请问如何一个通用方法得到这个xml对应的值！请求相关代码！使用XStream完成java类与XML互换。下面代码实现了以下4种基本功能：1.object类型转换为xml类型，在控... 查看详情

hibernate零配置之annotation注解

...实体类集中在一起。　　以下我将使用eclipse来构建一个简单使用注解取代*.hbm.xml的查询小例子。（p.s建议不要使用Myeclipse，他很方便但是对于初学者来说没有eclipse学得牢靠）1.在数据库中构建一查看详情

通过现有实体类，如何自动生成映射文件

我现在有实体类,要生成数据库的配置文件,再通过实体类和生成的这个配置文件生成数据库.谁有这方面的经验,尽量具体点.通过反射，将实体类的private字段取出，默认的数据表字段就是该private字段，表名就是类名。当然，你可... 查看详情

nhibernate生成实体类xml映射文件

...之前使用的codeSmith安装不了，索性自己写一个。界面比较简单，如下图:第一行为Oracle数据库的连接字符串。连接成功后，填充表到第4行的下拉列表中。第二行为实体类命名空间。第三行为保存生成类、xml文件选择文件夹。1privat... 查看详情