Dieses Mal zeige ich Ihnen, wie Sie Entitätsklassen und XML-Dateien konvertieren. Was sind die Vorsichtsmaßnahmen für die Konvertierung von Entitätsklassen und XML-Dateien?
Ich habe kürzlich eine Frage geschrieben, bei der es darum ging, eine Reihe von Mitarbeiter-Entitätsklassen in XML-Dateien oder XML-Dateien in eine Reihe von Entitätsklassen zu konvertieren. Die Frage ist nicht schwierig, aber nachdem ich sie geschrieben habe, habe ich das Gefühl, dass ich Generics und Reflection verwenden kann, um jede Entitätsklasse und jede XML-Datei zu konvertieren. Also habe ich heute Nachmittag sofort versucht
und ein einfaches Modell erstellt, das einfache Entitätsklassen und XML-Dateien ineinander konvertieren kann. Allerdings gibt es Einschränkungen für die Attributtypen von Entitätsklassen Unterstützt werden drei Typen: Integer und Double. Es kann aber später erweitert werden.
Meine allgemeine Idee ist Folgendes: Solange ich die Typinformationen der Entitätsklasse erhalten kann, kann ich alle Feldnamen und Typen der Entitätsklasse abrufen. Die Set- und Get-Methoden der Attribute sind einfach und klar. Zu diesem Zeitpunkt müssen Sie nur die Daten der XML-Datei lesen und sie über die Methodenreflexion an diese Reflexion übergeben.
Andererseits kann ich, solange Sie mir ein beliebiges Objekt geben, die Werte aller Felder des Objekts durch Reflektion erhalten. Zu diesem Zeitpunkt kann ich einfach die XML-Datei schreiben.
Der spezifische Code lautet wie folgt:
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");
}
}Nach dem Login kopieren
Wenn eine Entitätsklasse vorhanden ist:
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;
}
}Nach dem Login kopieren
Schreiben Sie es dann aus. Das XML-Dateiformat lautet wie folgt:
<?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>
Nach dem Login kopieren
Wenn es eine Entitätsklasse wie folgt gibt:
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;
}
}Nach dem Login kopieren
, lautet die geschriebene XML-Datei wie folgt:
<?xml version="1.0" encoding="utf-8"?>
<students>
<student>
<id></id>
<name>pcq</name>
<age>18</age>
<gender>男</gender>
</student>
</students>
Nach dem Login kopieren
kann auch gelesen werden Die XML-Datei in diesem Format muss gelesen werden, um sie in eine Entitätsklasse umzuwandeln. Voraussetzung ist, dass die Klassentypinformationen (Klasse) der Entitätsklasse abgerufen werden.
Außerdem sind die Attributtypen der Entitätsklassen hier alle Integer, String und Double. Sie können sehen, dass nur diese drei Typen in der Tool-Klasse beurteilt werden. Und es kann erwartet werden, dass, wenn eine Eins-zu-viele-Beziehung besteht, das heißt, eine Entitätsklasse eine Reihe von Verweisen auf ein anderes Klassenobjekt hat,
dann die gegenseitige Konvertierung zwischen XML und Entitätsklasse viel ist komplizierter als die obige Situation. lz sagte, dass es möglicherweise nicht möglich sei, dies in kurzer oder sogar langer Zeit zu tun. Ich begrüße den Rat meiner Expertenkollegen.
Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!
Empfohlene Lektüre:
So verwenden Sie AJAX, um zu erkennen, ob Benutzernamen doppelt vorhanden sind
So überprüfen Sie E-Mail-Adresse und Benutzernamen unter Verwendung von Ajax Uniqueness
Das obige ist der detaillierte Inhalt vonSo konvertieren Sie Entitätsklassen und XML-Dateien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
