Récemment, j'ai travaillé sur un cadre de plate-forme efficace. Un affichage de page d'accueil configurable, mais après avoir travaillé dur pendant deux semaines, probablement après la mise en œuvre de la fonction, j'ai réalisé que ce n'est pas ce que je veux faire. Les semaines n'ont pas été gaspillées et j'en ai beaucoup appris.
Lors de la construction d'un système, je rencontre souvent la nécessité de lire XML. Presque la même chose, j'ai trouvé que, pourquoi ne pas encapsuler toutes ces opérations dans une classe et les appeler directement en les utilisant? , avec cette mentalité, continuez à vérifier en ligne (car je pense vraiment qu'il doit y avoir quelque chose en ligne, si je le résume moi-même, ma tête obtiendra vraiment de l'eau).
Affichage du code source:
La copie de code est la suivante:
package com.gxpt.struts2;
Importer java.io.file;
import java.io.filewriter;
Importer java.util.iterator;
Importer java.util.list;
importation java.util.map;
import org.dom4j.attribute;
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;
classe publique TestAddDeleTExml {
document de document privé;
Filepath privé;
// writelog privé WriteLog;
public static void main (String [] args) lève DocumentException {
// String filepath = System.getProperty ("user.dir") + "/ xmlfiles / localServicesConfig.xml";
String filepath = "f: // java project // University Platform // Demo // gxpt // webContent // Limits // Manager.txt";
TestAdDdeleTExML Operator = new TestAdDDeleTexml (FilePath);
operator.getxmlfile ();
// map map = new HashMap ();
//map.put("id "," M1 ");
//map.put("name" ,"module1 ");
//map.put("url "," index1.jsp ");
//Operator.addchild("div "," div9 "," module "," ", map);
//Operator.updatechild("Style "," "," div "," asdfasdf ", 1);
operator.deletechildone ("style", "", "div", "div11");
//Operator.deletechild("div "," div9 "," module ");
// string str = opérator.getchild ("div", "div8", "module");
//System.out.println(str);
// élément root = document.getRootelement (); // Obtenez le nom du nœud racine
}
public testAdDdeleTExml (String filepath) {
this.Document = null;
this.filepath = filepath;
// writeLog = new WriteLog ();
}
/ **
* Créer un fichier XML
* @param rootname: nom du nœud racine
* /
public void createExmlfile (String rootName) {
if (! FileExist ()) {
this.Document = documentHelper.CreateDocument ();
this.Document.Addelement (rootName);
SAVEXMLFILE (this.Document);
}
}
/ **
* Obtenez un document XML existant
* @retour
* /
Document public getXmlfile () {
if (fileExist ()) {
SAXREDER Reader = new saxReader ();
essayer {
this.Document = reader.read (nouveau fichier (filepath));
} catch (documentException e) {
// String Loginfo = stackTraceToString.getExceptionTrace (E);
// writeLog.WriteLogtoend ("LocalServerManager", Loginfo);
} enfin{
lecteur = null;
}
} autre {
// Écriture d'un journal
// String Loginfo = "Le fichier xml n'existe pas, la lecture de l'erreur!";
// writeLog.WriteLogtoend ("LocalServerManager", Loginfo);
System.exit (0);
}
Renvoyez ce.Document;
}
/ **
* Ajouter des éléments
* @param Pathepath: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nom du nœud à ajouter
* @param childvalue: la valeur du nœud à ajouter
* /
public void addChild (String Fathernode, String pèreAttr, String ChildName, String childvalue, map mapAttr) {
Childoperator (Fathernode, FatherAttr, ChildName, ChildValue, "Add", MapAttr, 0);
}
/ **
* Modifier les éléments
* @param Pathepath: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nom du nœud à modifier
* @param childvalue: la valeur du nœud à modifier
* /
public void updateChild (String Fathernode, String pèreAttr, String ChildName, String childvalue, int updateid) {
ChildOperator (Fathernode, FatherAttr, ChildName, ChildValue, "Update", null, updatid);
}
/ **
* Supprimer les éléments
* @param Pathepath: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nom du nœud à supprimer
* /
public void Deletechild (String Fathernode, String pèreAttr, String ChildName) {
Childoperator (Fathernode, pèreattr, childname, "", "supprimer", null, 0);
}
/ **
* Supprimer les éléments
* @param Pathepath: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nom du nœud à supprimer
* /
public void Deletechildall (String Fathernode, String pèreAttr, String ChildName) {
Childoperator (Fathernode, Fatherattr, Childname, "", "Deleteall", null, 0);
}
/ **
* Supprimer un élément
* @param Pathepath: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nom du nœud à supprimer
* /
public void DeletechildOne (String Fathernode, String FatherAttr, String ChildName, String childvalue) {
Infiltoperator (Fathernode, Fatherattr, Childname, Childvalue, "DeleteOne", null, 0);
}
/ **
* Obtenez la valeur d'un élément
* @param Pathepath: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nom du nœud à supprimer
* /
public String getchild (String Fathernode, String pèreAtTr, String ChildName) {
Résultat de chaîne = "";
result = childoperator (Fathernode, pèreattr, childname, "", "get", null, 0);
Résultat de retour;
}
/ **
* Opération de nœud enfant
* @param fathernode: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nœud à modifier
* @param childvalue: valeur de nœud modifiée
* Opérateur @param: le nom de l'opération à effectuer
* /
String privé synchronisé childoperator (String Fathernode, String FatherAttr, String ChildName, String childvalue, String Operator, map MapAttr, int updateID) {
Résultat de chaîne = "";
if (this.Document == null) {
retourner "null";
}
Élément root = this.document.getrootementment (); // Obtenez le nom du nœud racine
if (! root.getName (). Equals (Fathernode)) {// s'il n'est pas ajouté sous le nœud racine
Résultat = XmleMelementOperator (Root, Fathernode, FatherAttr, ChildName, ChildValue, Operator, MapAttr);
}autre{
if (operator.equals ("add")) {
Element childElement = root.addelement (childname); // La valeur d'attribut d'élément n'existe pas dans le nœud racine
childElement.setAttributeValue ("id", childvalue);
SAVEXMLFILE (this.Document);
} else if (operator.equals ("update")) {
Liste des enfants = root.Elements (ChildName);
// pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
// élément tout le monde = (élément) childS.Next ();
// tout le monde.seTText (ChildValue);
// tout le monde.SetAttributeValue ("id", childvalue);
Élément tout le monde = (élément) childelements.get (updateID);
Everybody.SetAttributeValue ("ID", ChildValue);
//}
SAVEXMLFILE (this.Document);
} else if (operator.equals ("delete")) {
Liste des enfants = root.Elements (ChildName); // Obtenez tous les nœuds enfants sous le nœud actuel, jugez leurs valeurs et modifiez-les
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
Lister les enfants = tout le monde.Elements ("module");
for (iterator childing1 = childelements1.iterator (); childs1.hasnext ();) {
Élément tout le monde1 = (élément) childs1.next ();
tout le monde.
}
}
SAVEXMLFILE (this.Document);
} else if (operator.equals ("get")) {
Liste des enfants = root.Elements (ChildName); // Obtenez tous les nœuds enfants sous le nœud actuel, jugez leurs valeurs et modifiez-les
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
résultat = tout le monde.GetText ();
}
SAVEXMLFILE (this.Document);
} else if (operator.equals ("DeleteOne")) {
Liste des enfants = root.Elements (ChildName); // Obtenez tous les nœuds enfants sous le nœud actuel, jugez leurs valeurs et modifiez-les
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
String Diverment = Everybody.AttributeValue ("ID");
if (Divetment.equals (childvalue)) {
root.remove (tout le monde);
}
}
SAVEXMLFILE (this.Document);
} else if (operator.equals ("deleteall")) {
Liste des enfants = root.Elements (); // obtenir tous les nœuds enfants sous le nœud actuel, juger leurs valeurs et les modifier
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
List childdiv = Everybody.Elements ();
for (iterator childrendiv = childdiv.iterator (); childsdiv.hasnext ();) {
Element everyonediv = (élément) childdsdiv.next ();
tout le monde.
}
}
}
SAVEXMLFILE (this.Document);
}
Résultat de retour;
}
/ **
* Fonctionnement de l'élément récursif
* élément @param: l'élément à être récursif
* @param fathernode: nom du nœud parent
* @param pèreattr: attribut de nœud parent
* @param childname: le nœud à utiliser
* @param childvalue: valeur de nœud après opération
* Opérateur @param: le nom de l'opération à effectuer
* /
String privé synchronisé xmleMelementOperator (élément, élément, chaîne fathernode, chaîne pèreattr, chaîne childname, chaîne childvalue, opérateur de chaîne, map mapaTtr) {
Résultat de chaîne = "";
Lister les éléments = élément.Elements ();
for (iterator it = elements.iterator (); it.hasnext ();) {
Element currentElement = (élément) it.next ();
If (! CurrentElement.getName (). Equals (Fathernode)) {// Continuez à rechercher lorsque l'élément actuel n'est pas l'élément parent que nous recherchons
XmleMelementOperator (CurrentElement, Fathernode, FatherAttr, ChildName, ChildValue, Operator, Mapattr); // Appel récursif
}autre{
if (currentElement.AttributeCount ()> 0) {// Lorsque l'élément actuel a une valeur d'attribut, c'est
for (iterator list = currentElement.attrutiaTiterator (); list.hasnext ();) {// transf la valeur d'attribut
Attribut att = (attribut) list.next ();
if (att.getValue (). equals (pèreAttr)) {// déterminer l'élément parent unique en fonction de la valeur d'attribut
if (operator.equals ("add")) {// Ajouter un élément
Élément childElement = currentElement.Addelement (ChildName);
childElement.setText (childvalue);
Iterator itmapattr = mapattr.KeySet (). Iterator ();
while (itmapattr.hasnext ()) {
String key = (string) itmapattr.next ();
String Value = MapAtTr.get (KEY) .TOSTRING ();
childElement.setAttributeValue (clé, valeur);
}
// childElement.SetAttributeValue ("id", "m1");
// childElement.SetAttributeValue ("name", "module1");
// childElement.SetAttributeValue ("URL", "index1.jsp");
} else if (operator.equals ("update")) {// Modifier un élément
Liste des enfants = currentElement.Elements (ChildName); // Obtenez tous les nœuds enfants sous le nœud actuel, jugez leurs valeurs et modifiez-les
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
Tout le monde.
}
} else if (operator.equals ("delete")) {// supprimer un élément spécifié
Lister les enfants = currentElement.Elements (); // obtenir tous les nœuds enfants sous le nœud actuel, juger leurs valeurs et les modifier
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
CurrentElement.Remove (tout le monde);
}
} else if (operator.equals ("get")) {
Liste des enfants = currentElement.Elements (ChildName); // Obtenez tous les nœuds enfants sous le nœud actuel, jugez leurs valeurs et modifiez-les
pour (iterator enfants = childlements.iterator (); child.hasnext ();) {
Élément tout le monde = (élément) childS.Next ();
// result = tout le monde.getText ();
result = everybody.attributeValue ("id") + "," + result;
}
}
autre{
// Écriture d'un journal
// String Loginfo = "L'opérateur xmlfile n'existe pas!";
// writeLog.WriteLogtoend ("LocalServerManager", Loginfo);
}
}
}
}
}
}
SAVEXMLFILE (this.Document);
Résultat de retour;
}
/ **
* Enregistrer le fichier XML
* Document @param: nom de fichier XML
* /
private void savexmlfile (document de document) {
essayer {
OutputFormat Format = outputFormat.CreatePreretTyprint ();
format.SetEncoding ("UTF-8");
Xmlwriter writer = new XMLWriter (new FileWriter (nouveau fichier (filepath)), format);
écrivain.write (document);
écrivain.close ();
} catch (exception e) {
// String Loginfo = stackTraceToString.getExceptionTrace (E);
// writeLog.WriteLogtoend ("LocalServerManager", Loginfo);
}
}
/ **
* Déterminez si le fichier XML existe.
* @param nom de fichier
* @retour
* /
FileExist booléen privé () {
java.io.file objfile = new java.io.file (this.filepath);
if (objfile.exists ()) {
Retour Vrai;
} autre {
retourne false;
}
}
}
Fichier XML:
La copie de code est la suivante:
<? xml version = "1.0" Encoding = "utf-8"?>
<style>
<div id = "div8">
<module id = "m1" name = "module1" url = "index1.jsp" />
<module id = "m2" name = "module2" url = "index2.jsp" />
<module id = "m3" name = "module3" url = "index3.jsp" />
</div>
<div id = "div9">
<module id = "m9" name = "module9" url = "index3.jsp" />
<module id = "m10" name = "module10" url = "index4.jsp" />
<module id = "m11" name = "module11" url = "index5.jsp" />
</div>
</ style>
Analyse: Nous utilisons ici une méthode récursive pour déterminer si l'opération est pour le nœud ou le nœud enfant, ce qui est relativement clair. Utilisez une injection de dépendance, sauve la difficulté du jugement, mais je n'ai fait qu'une démo à ce moment-là, sans plus d'optimisations.
Résumé: Il n'est pas difficile de lire XML. Pour écrire beaucoup de répétitions, il y a un problème avec le code qui doit être modifié à plusieurs reprises, donc parfois, bien que les exigences soient importantes, comment les mettre en œuvre est tout aussi importante!