• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    简单实体类和xml文件的相互转换方法

    最近写一个题目,要求将一组员工实体类转换成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(ListT> 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(ListT> 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> ListT> getEntitys(ClassT> 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> ListT> getEntitys(ClassT> c, String filePath, String encoding) throws UnsupportedEncodingException, FileNotFoundException {
      File file = new File(filePath);
      String labelName = c.getSimpleName().toLowerCase();
      SAXReader reader = new SAXReader();
      ListT> 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 ArrayListT>();
       for(IteratorEmp> 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(ClassT> 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表示短时间内甚至长时间内也不一定能做的出来,欢迎同道高人指点。

    以上这篇简单实体类和xml文件的相互转换方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    您可能感兴趣的文章:
    • C#实现实体类和XML相互转换
    • C#对象与XMl文件之间的相互转换
    上一篇:表单上传功能实现 ajax文件异步上传
    下一篇:Ajax上传图片及上传前先预览功能实例代码
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

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