最近写一个题目，要求将一组员工实体类转换成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 void writeXML(List 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 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 List getEntitys(Class c, String filePath) throws UnsupportedEncodingException, FileNotFoundException {

return getEntitys(c, filePath, "utf-8");

}

/**

* 将一个xml文件转变成实体类

* @param c

* @param filePath

* @return

* @throws FileNotFoundException

* @throws UnsupportedEncodingException

*/

public static List getEntitys(Class c, String filePath, String encoding) throws UnsupportedEncodingException, FileNotFoundException {

File file = new File(filePath);

String labelName = c.getSimpleName().toLowerCase();

SAXReader reader = new SAXReader();

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

for(Iterator 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 getEntity(Class 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文件格式如下：

1

张三

50

25

男

6

9000.0

2

李四

50

22

女

6

8000.0

假如有个实体类如下：

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文件如下

pcq

18

男

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

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

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

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