Recientemente, he estado trabajando en un marco de plataforma eficiente. Una pantalla de página de inicio configurable, pero después de trabajar duro durante dos semanas, probablemente después de que se implementó la función, me di cuenta de que esto no es lo que quiero hacer. No se han desperdiciado semanas, y he aprendido mucho de eso.
Al construir un sistema, a menudo encuentro la necesidad de leer XML. Casi lo mismo, descubrí que, ¿por qué no encapsulé todas estas operaciones en una clase y las llamo directamente al usarlas? , con esta mentalidad, continúa verificando en línea (porque realmente siento que debe haber algo en línea, si lo encapsula yo mismo, mi cabeza realmente obtendrá agua).
Pantalla del código fuente:
La copia del código es la siguiente:
paquete com.gxpt.struts2;
import java.io.file;
import java.io.filewriter;
import java.util.iterator;
import java.util.list;
import java.util.map;
importar org.dom4j.attribute;
importar org.dom4j.document;
importar org.dom4j.documentException;
importar org.dom4j.documentHelper;
importar org.dom4j.Element;
importar org.dom4j.io.outputformat;
importar org.dom4j.io.saxreader;
importar org.dom4j.io.xmlwriter;
clase pública testAdDdeletExml {
documento de documento privado;
cadena privada Filepath;
// WriteLog Writelog privado;
public static void main (string [] args) lanza DocumentException {
// String filepath = system.getProperty ("user.dir")+"/xmlfiles/localServicesconfig.xml";
String filepath = "f: // Java Project // Plataforma universitaria // demostración // gxpt // webcontent // limits // ganager.txt";
testAdDDeletExml Operator = new testAdDdeletExml (FilePath);
operador.getxmlFile ();
// map map = new Hashmap ();
//map.put("id "," m1 ");
//map.put("name","module1 ");
//map.put("url "," index1.jsp ");
//operator.addchild("div "," div9 "," módulo "," ", mapa);
//operator.updateChild("Style "," "," div "," asdfasdf ", 1);
operador.deletechildone ("estilo", "", "div", "div11");
//operator.deletechild("div "," div9 "," módulo ");
// string str = operator.getChild ("div", "div8", "módulo");
//System.out.println(str);
// elemento root = document.getRoOtElement (); // Obtener el nombre del nodo raíz
}
public testAdDDeletExml (String filepath) {
this.document = null;
this.filepath = filepath;
// writeLog = new WriteLog ();
}
/**
* Crear archivo XML
* @param rootname: nombre del nodo raíz
*/
public void createExmlFile (String rootName) {
if (! fileExist ()) {
this.document = documentHelper.CreateDocument ();
this.document.addelement (rootname);
saveXmlFile (this.document);
}
}
/**
* Obtener un documento XML existente
* @devolver
*/
Documento público getxmlFile () {
if (fileExist ()) {
Saxreader lector = new saxreader ();
intentar {
this.document = Reader.read (nuevo archivo (FilePath));
} catch (DocumentException e) {
// string loginfo = stackTraceToString.getExceptionTrace (e);
// writeLog.WriteLogToend ("LocalServerManager", Loginfo);
} finalmente{
lector = nulo;
}
} demás {
// Escribir un registro
// string loginfo = "El archivo xml no existe, lea el error!";
// writeLog.WriteLogToend ("LocalServerManager", Loginfo);
System.exit (0);
}
devolver esto.document;
}
/**
* Agregar elementos
* @param PatherPath: Nombre del nodo para padres
* @param Padreattr: atributo de nodo parent
* @param childName: el nombre del nodo que se agregará
* @param ChildValue: el valor del nodo a agregar
*/
public void addChild (String Fathernode, String FatherAttr, String ChildName, String ChildValue, Map Mapattr) {
Infancia (Fathernode, Fatherattr, Nombre de infancia, Valor infantil, "Agregar", Mapattr, 0);
}
/**
* Modificar elementos
* @param PatherPath: Nombre del nodo para padres
* @param Padreattr: atributo de nodo parent
* @param childName: el nombre del nodo a modificar
* @param ChildValue: el valor del nodo a ser modificado
*/
public void UpdateChild (String Fathernode, String FatherAttr, String ChildName, String ChildValue, int UpdateID) {
ChildOperator (Fathernode, FatherAttr, ChildName, ChildValue, "Actualización", NULL, Updatid);
}
/**
* Eliminar elementos
* @param PatherPath: Nombre del nodo para padres
* @param Padreattr: atributo de nodo parent
* @param childName: el nombre del nodo a eliminar
*/
public void DeleteChild (String Fathernode, String FatherAttr, String ChildName) {
Infancia (Fathernode, Padreattr, Nombre de infancia ",", "Delete", Null, 0);
}
/**
* Eliminar elementos
* @param PatherPath: Nombre del nodo para padres
* @param Padreattr: atributo de nodo parent
* @param childName: el nombre del nodo a eliminar
*/
public void DeleteChildall (String Fathernode, String FatherAttr, String ChildName) {
Infancia (Fathernode, Fatherattr, Nombre de infancia ",", "DeleteAll", Null, 0);
}
/**
* Eliminar un elemento
* @param PatherPath: Nombre del nodo para padres
* @param Padreattr: atributo de nodo parent
* @param childName: el nombre del nodo a eliminar
*/
public void DeleteChildone (String Fathernode, String FatherAttr, String ChildName, String ChildValue) {
Infancia (Fathernode, Padreattr, Nombre de infancia, Valor infantil, "Deleteone", Null, 0);
}
/**
* Obtener el valor de un elemento
* @param PatherPath: Nombre del nodo para padres
* @param Padreattr: atributo de nodo parent
* @param childName: el nombre del nodo a eliminar
*/
Public String getChild (String Fathernode, String FatherAttr, String ChildName) {
Resultado de cadena = "";
resultado = infancia (fathernode, pheetattr, infancia, "", "Get", null, 0);
resultado de retorno;
}
/**
* Operación de nodo infantil
* @param fathernode: nombre del nodo principal
* @param Padreattr: atributo de nodo parent
* @param childName: el nodo a modificar
* @param ChildValue: valor de nodo modificado
* @Param Operator: el nombre de la operación a realizar
*/
Cadena privada sincronizada Childoperator (String Fathernode, String FatherAttr, String ChildName, String ChildValue, String Operator, Map Mapattr, int UpdateID) {
Resultado de cadena = "";
if (this.document == null) {
regresar "nulo";
}
Elemento root = this.document.getrooTelement (); // Obtener el nombre del nodo raíz
if (?
resultado = xmlelementoperator (root, fathernode, fatherattr, nombre de niño, valor infantil, operador, mapattr);
}demás{
if (operator.equals ("add")) {
Elemento infantilement = root.addelement (childName); // El valor del atributo del elemento no existe en el nodo raíz
ChildElement.SetAttributeValue ("ID", Valor infantil);
saveXmlFile (this.document);
} else if (operator.equals ("actualización")) {
List Children = root.elements (childName);
// para (iterator children = childlements.iterator (); childs.hasnext ();) {
// Elemento de todos = (elemento) childs.next ();
// todos.settext (Valor infantil);
// todos.SetAttributeValue ("ID", Valor infantil);
Elemento todos = (elemento) ChildElements.get (updateID);
todos.setTributeValue ("ID", Valor infantil);
//}
saveXmlFile (this.document);
} else if (operator.equals ("eliminar")) {
List Children = root.elements (childName); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
Lista de childrenes1 = todos.elements ("módulo");
para (iterator children1 = ChildElements1.iterator (); childs1.hasnext ();) {
Elemento tuyo1 = (elemento) childs1.next ();
todos. Remove (todos1);
}
}
saveXmlFile (this.document);
} else if (operator.equals ("get")) {
List Children = root.elements (childName); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
resultado = todos.gettext ();
}
saveXmlFile (this.document);
} else if (operator.equals ("deleteone")) {
List Children = root.elements (childName); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
String divelement = everything.attributeValue ("id");
if (divelement.equals (valor infantil)) {
root.remove (todos);
}
}
saveXmlFile (this.document);
} else if (operator.equals ("deleteall")) {
List Children = root.elements (); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
List ChildDiv = Everything.elements ();
para (iterator childrendiv = childDiv.iterator (); childsdiv.hasnext ();) {
Elemento EveryonEdiv = (Element) ChildSdiv.Next ();
Todos. Remove (Everyonediv);
}
}
}
saveXmlFile (this.document);
}
resultado de retorno;
}
/**
* Operación de elementos recursivos
* @param elemento: el elemento a ser recursivo
* @param fathernode: nombre del nodo principal
* @param Padreattr: atributo de nodo parent
* @param ChildName: el nodo que se operará en
* @param ChildValue: valor de nodo después de la operación
* @Param Operator: el nombre de la operación a realizar
*/
cadena privada sincronizada xmlelementaperator (elemento elemento, cadena fathernode, string pheetattr, string childName, string childValue, string operator, map mapattr) {
Resultado de cadena = "";
Elementos de lista = elemento.elements ();
para (iterator it = elements.iterator (); it.hasnext ();) {
Elemento CurrentElement = (elemento) it.next ();
If (?
XMLelementOperator (CurrentElement, Fathernode, FatherAttr, Nombre de niño, Valor infantil, Operador, Mapattr); // Llamada recursiva
}demás{
if (currentElement.AtTributeCount ()> 0) {// Cuando el elemento actual tiene un valor de atributo, es
para (iterator list = currentElement.AttributeIterator (); list.hasnext ();) {// Transfiar el valor de atributo
Atributo attr = (atributo) list.next ();
if (attr.getValue (). Equals (Padreattr)) {// Determinar el elemento principal único basado en el valor de atributo
if (operator.equals ("add")) {// Agregar elemento
Elemento infantilement = currentElement.addelement (nombre de niño);
ChildElement.setText (Valor infantil);
Iterator itmapattr = mapattr.keySet (). Iterator ();
while (itmapattr.hasnext ()) {
String key = (string) itmapattr.next ();
Valor de cadena = mapattr.get (key) .ToString ();
ChildElement.SetAttributeValue (clave, valor);
}
// ChildElement.SetAttributeValue ("id", "m1");
// ChildElement.SetAttributeValue ("Nombre", "Module1");
// ChildElement.SetAttributeValue ("url", "index1.jsp");
} else if (operator.equals ("actualización")) {// modificar un elemento
List Children = CurrentElement.Elements (ChildName); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
Todos.settext (Valor infantil);
}
} else if (operator.equals ("eliminar")) {// eliminar un elemento especificado
Lista de niños = CurrentElement.Elements (); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
CurrentElement.remove (todos);
}
} else if (operator.equals ("get")) {
List Children = CurrentElement.Elements (ChildName); // Obtenga todos los nodos infantiles bajo el nodo actual, juzga sus valores y modifíquelos
para (iterator children = childlements.iterator (); childs.hasnext ();) {
Elemento todos = (elemento) childs.next ();
// resultado = todos.gettext ();
resultado = todos.AttributeValue ("id")+","+resultado;
}
}
demás{
// Escribir un registro
// String loginfo = "El operador XMLFile no existe!";
// writeLog.WriteLogToend ("LocalServerManager", Loginfo);
}
}
}
}
}
}
saveXmlFile (this.document);
resultado de retorno;
}
/**
* Guardar archivo XML
* @Param Documento: nombre de archivo XML
*/
Private void savexmlFile (documento de documento) {
intentar {
OutputFormat format = outputFormat.CreatePrettyPrint ();
format.setEncoding ("UTF-8");
XMLWriter Writer = new XMLWriter (nuevo FileWriter (nuevo archivo (FilePath)), formato);
escritor.write (documento);
escritor.close ();
} Catch (Exception e) {
// string loginfo = stackTraceToString.getExceptionTrace (e);
// writeLog.WriteLogToend ("LocalServerManager", Loginfo);
}
}
/**
* Determine si existe el archivo XML.
* @param nombre de archivo
* @devolver
*/
FileExist privado booleano () {
java.io.file objfile = new java.io.file (this.filepath);
if (objfile.exists ()) {
devolver verdadero;
} demás {
devolver falso;
}
}
}
Archivo XML:
La copia del código es la siguiente:
<? xml versión = "1.0" encoding = "utf-8"?>
<estilo>
<div id = "div8">
<módulo id = "m1" name = "módulo1" url = "index1.jsp"/>
<módulo id = "m2" name = "módulo2" url = "index2.jsp"/>
<módulo id = "m3" name = "módulo3" url = "index3.jsp"/>
</div>
<div id = "div9">
<módulo id = "m9" name = "módulo9" url = "index3.jsp"/>
<módulo id = "m10" name = "módulo10" url = "index44.jsp"/>
<módulo id = "m11" name = "módulo11" url = "index5.jsp"/>
</div>
</style>
Análisis: Aquí utilizamos el método recursivo para determinar si la operación es para el nodo o el nodo infantil, que es relativamente claro. Use la inyección de dependencia, ahorra el problema del juicio IF, pero solo hice una demostración en ese momento, sin más optimizaciones.
Resumen: en realidad no es difícil leer XML. Para escribir muchas repeticiones, hay un problema con el código que debe modificarse repetidamente, por lo que a veces, aunque los requisitos son importantes, ¡cómo implementarlos es igualmente importante!