Comment convertir des classes d'entités et des fichiers XML

Cette fois, je vais vous montrer comment convertir des classes d'entités et des fichiers XML. Quelles sont les précautions pour convertir des classes d'entités et des fichiers XML. Ce qui suit est un cas pratique, jetons un coup d'œil.

J'ai récemment écrit une question qui nécessitait de convertir un ensemble de classes d'entités d'employés en fichiers XML, ou de convertir des fichiers XML en un ensemble de classes d'entités. La question n'est pas difficile, mais après l'avoir écrite, je sens que je peux utiliser les génériques et la réflexion pour convertir n'importe quelle classe d'entité et fichier XML. J'ai donc immédiatement essayé

cet après-midi et créé un modèle simple qui peut convertir des classes d'entités simples et des fichiers XML entre eux. Cependant, il existe des restrictions sur les types d'attributs des classes d'entités. Actuellement, seule String est prise en charge. Il existe trois types : Integer et Double. Mais il pourra être élargi ultérieurement.

Mon idée générale est la suivante. Tant que je peux obtenir les informations de type de la classe d'entité, je peux obtenir tous les noms de champs et types de la classe d'entité. Les méthodes set et get des attributs sont paires. C'est plus simple et plus clair pour le moment, il vous suffit de lire les données du fichier XML et de les transmettre à cette réflexion via la méthode de réflexion.

D'un autre côté, tant que vous me donnez un objet arbitraire, je peux obtenir les valeurs de tous les champs de l'objet par réflexion. À ce stade, je peux simplement écrire le fichier XML.

Le code spécifique est le suivant :

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");
 }
}

S'il existe une classe d'entité :

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;
 }
 
}

puis écrivez-le. Le format du fichier XML est le suivant :

<?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>

S'il existe une classe d'entité comme suit :

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;
 }
 
}

Alors le fichier XML écrit est le suivant :

<?xml version="1.0" encoding="utf-8"?>
<students>
 <student>
 <id></id>
 <name>pcq</name>
 <age>18</age>
 <gender>男</gender>
 </student>
</students>

peut également être lu Le fichier XML dans ce format doit être lu pour le convertir en classe d'entité. La condition est que les informations de type de classe (Classe) de la classe d'entité soient obtenues.

De plus, les types d'attributs des classes d'entités ici sont tous Integer, String et Double. Vous pouvez voir que seuls ces trois types sont jugés dans la classe d'outils. Et on peut s'attendre à ce que s'il existe une relation un-à-plusieurs, c'est-à-dire qu'une classe d'entité a un ensemble de références à un autre objet de classe,

alors la conversion mutuelle entre XML et la classe d'entité est beaucoup plus compliqué que la situation ci-dessus. Lz a dit qu'il ne serait peut-être pas possible de le faire dans un court laps de temps, voire dans un long laps de temps. J'apprécie les conseils de mes collègues experts.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture recommandée :

Comment utiliser AJAX pour détecter si les noms d'utilisateur sont des doublons

Comment vérifier l'e-mail et le nom d'utilisateur en utilisant l'unicité d'Ajax

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!