Méthode de conversion entre classes d'entités simples et fichiers XML-js tutoriel-php.cn

Maintenant, je vais vous proposer un article sur la façon de convertir des classes d'entités simples et des fichiers XML entre eux. Permettez-moi de le partager avec vous maintenant et de le donner comme référence pour tout le monde.

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. Entier, Double trois types. 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");
 }
}

Copier après la connexion

Si il y a une entité La classe est :

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

Copier après la connexion

Ensuite le format du fichier xml écrit 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>

Copier après la connexion

Supposons qu'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;
 }
 
}

Copier après la connexion

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>

Copier après la connexion

La lecture doit également lire le fichier XML dans ce format avant qu'il puisse être converti en classe d'entité. L'exigence est que les informations de type de classe (. Classe) de la classe d'entité doit être obtenue.

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 il est prévisible que s'il existe une relation un-à-plusieurs, c'est-à-dire qu'une classe d'entité a un ensemble de références à des objets d'une autre classe,

Ce qui précède est ce que j'ai compilé pour tout le monde, et J'espère que cela sera utile à tout le monde à l'avenir.

Articles associés :

Utilisation d'Ajax pour mettre à jour partiellement les pages Razor (tutoriel graphique)

AjaxFileUpload+Struts2 pour implémenter plusieurs Fonction de téléchargement de fichiers

Implémentation d'ajax pour envoyer des requêtes asynchrones (tutoriel graphique)

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!