Recentemente, tenho trabalhado em uma estrutura de plataforma eficiente. Uma exibição de página inicial configurável, mas depois de trabalhar duro por duas semanas, provavelmente depois que a função foi implementada, percebi que não é isso que eu quero fazer. As semanas não foram desperdiçadas e eu aprendi muito com isso.
Ao criar um sistema, muitas vezes encontro a necessidade de ler o XML. Quase o mesmo, descobri que, por que não encapsulou todas essas operações em uma aula e as chama diretamente ao usá -las? , com essa mentalidade continua a verificar on -line (porque realmente sinto que deve haver algo online, se eu a encapsular, minha cabeça realmente receberá água).
Exibição do código -fonte:
A cópia do código é a seguinte:
pacote com.gxpt.struts2;
importar java.io.file;
importar java.io.filewriter;
importar java.util.iterator;
importar java.util.list;
importar 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;
classe pública TestAddDeletexml {
documento privado documento;
Private String filepath;
// Private WriteLog WriteLog;
public static void main (string [] args) lança DocumentException {
// string filepath = System.getProperty ("user.dir")+"/xmlfiles/LocalServicesConfig.xml";
String filepath = "f: // java Project // University Platform // Demo // GXPT // WebContent // Limits // Manager.txt";
testaddddeletexml operador = new testaddDeletexml (filepath);
operator.getxmlfile ();
// mapa mapa = 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);
operator.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 (); // Obtenha o nome do nó raiz
}
public TestAddDeletexml (String filepath) {
this.document = null;
this.FilePath = filepath;
// writeLog = new writeLog ();
}
/**
* Crie arquivo XML
* @param rootname: nome do nó raiz
*/
public void createxmlfile (string rootname) {
if (! fileExist ()) {
this.document = documentHelper.createCumocument ();
this.document.addElement (rootname);
savexmlfile (this.document);
}
}
/**
* Obtenha um documento XML existente
* @retornar
*/
Public Document Getxmlfile () {
if (fileExist ()) {
SAXReader Reader = new SaxReader ();
tentar {
this.document = leitor.read (novo arquivo (filepath));
} catch (documentException e) {
// String Loginfo = Stacktracetostring.GetexceptionTrace (e);
// writeLog.writeLogToEnd ("LocalsServerManager", Loginfo);
} finalmente{
leitor = nulo;
}
} outro {
// escrevendo um log
// string loginfo = "O arquivo xml não existe, leia o erro!";
// writeLog.writeLogToEnd ("LocalsServerManager", Loginfo);
System.Exit (0);
}
retornar this.Document;
}
/**
* Adicione elementos
* @param paterpath: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nome do nó a ser adicionado
* @param ChildValue: o valor do nó a ser adicionado
*/
public void addChild (string fathernode, string padattr, string childname, string childvalue, map mapattr) {
Childperator (Fathernode, Padreattr, ChildName, ChildValue, "Add", Mapattr, 0);
}
/**
* Modificar elementos
* @param paterpath: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nome do nó a ser modificado
* @param ChildValue: o valor do nó a ser modificado
*/
public void updateChild (string fathernode, string padattr, string childname, string childvalue, int updateId) {
Childperator (Fathernode, Padreattr, ChildName, ChildValue, "Atualizar", Null, Updatid);
}
/**
* Excluir elementos
* @param paterpath: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nome do nó a ser excluído
*/
public void DeLeteChild (String Fathernode, String padattr, String ChildName) {
Childperator (Fathernode, Padreattr, Childname, "", "Delete", Null, 0);
}
/**
* Excluir elementos
* @param paterpath: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nome do nó a ser excluído
*/
public void DeLeTechildall (String Fathernode, String PaderAttr, String ChildName) {
Childperator (Fathernode, Padreattr, Childname, "", "Deleteall", NULL, 0);
}
/**
* Exclua um elemento
* @param paterpath: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nome do nó a ser excluído
*/
public void DeleteChildone (String Fathernode, String PaderAttr, String ChildName, String ChildValue) {
Childperator (Fathernode, Padreattr, ChildName, ChildValue, "DeleteOne", NULL, 0);
}
/**
* Obtenha o valor de um elemento
* @param paterpath: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nome do nó a ser excluído
*/
public String getChild (string fathernode, string faderattr, string ChildName) {
String result = "";
Result = ChildOperator (Fathernode, Padreattr, ChildName, "", "Get", NULL, 0);
resultado de retorno;
}
/**
* Operação do nó infantil
* @param fathernode: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nó a ser modificado
* @param ChildValue: Valor do nó modificado
* Operador @param: o nome da operação a ser executado
*/
String de String privada String ChildOperator (String Fathernode, String PADEATTR, String ChildName, String ChildValue, String Operator, Map MapAtTr, Int UpdateId) {
String result = "";
if (this.document == null) {
retornar "nulo";
}
Elemento root = this.document.getrootelement (); // Obtenha o nome do nó raiz
if (! root.getName (). Equals (fathernode)) {// se não for adicionado no nó raiz
resultado = xmlelementOperator (raiz, fathernode, padreattr, nome da criança, Criança, operador, mapattr);
}outro{
if (operator.equals ("add")) {
Elemento childElement = root.addElement (nome da criança); // o valor do atributo do elemento não existe no nó raiz
ChildElement.SetAttributeValue ("ID", ChildValue);
savexmlfile (this.document);
} else if (operator.equals ("update")) {
Listar crianças = root.elements (nome da criança);
// para (crianças iterador = infantil.iterator (); Childs.hasnext ();) {
// elemento todo mundo = (elemento) childs.next ();
// todos.settext (ChildValue);
// todos.setAttributeValue ("ID", ChildValue);
Elemento todo mundo = (elemento) childElements.get (updateId);
todos.setAtattributeValue ("ID", ChildValue);
//}
savexmlfile (this.document);
} else if (operator.equals ("delete")) {
Listar crianças = root.elements (nome da criança); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
Listar filhos1 = todos.Elementos ("Módulo");
para (Iterator Children1 = ChildElements1.iterator (); Childs1.hasnext ();) {
Elemento todo mundo1 = (elemento) childs1.next ();
todo mundo (todos 1);
}
}
savexmlfile (this.document);
} else if (operator.equals ("get")) {
Listar crianças = root.elements (nome da criança); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
resultado = todos.getText ();
}
savexmlfile (this.document);
} else if (operator.equals ("DeleteOne")) {
Listar crianças = root.elements (nome da criança); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
String dividelement = todos.attributeValue ("id");
if (divisElement.equals (ChildValue)) {
root.remove (todos);
}
}
savexmlfile (this.document);
} else if (operator.equals ("DeLeTeall")) {
Listar crianças = root.elements (); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
Listar ChildDiv = todos.Elements ();
for (iterator Childrendiv = ChildDiv.iterator (); Childsdiv.hasnext ();) {
Elemento EveryOneDiv = (elemento) Childsdiv.Next ();
todo mundo.
}
}
}
savexmlfile (this.document);
}
resultado de retorno;
}
/**
* Operação de elemento recursivo
* elemento @param: o elemento a ser recursivo
* @param fathernode: nome do nó pai
* @param padattr: atributo do nó pai
* @param ChildName: o nó a ser operado
* @param ChildValue: Nó Valor após operação
* Operador @param: o nome da operação a ser executado
*/
String sincronizada privada XMLELEMENTOPERATOR (elemento elemento, String Fathernode, String PADEATTR, String ChildName, String ChildValue, Operador de String, Map Mapattr) {
String result = "";
List elements = element.Elements ();
for (iterator it = elements.iterator (); it.hasnext ();) {
Elemento currentElement = (elemento) it.next ();
If (! CurrentElement.getName (). Equals (fathernode)) {// continuar pesquisando quando o elemento atual não for o elemento pai que estamos procurando
XMLELEMENTOPERADOR (CurrentElement, Fathernode, Padreattr, ChildName, ChildValue, Operador, Mapattr); // Call Recursive
}outro{
if (currentElement.attributecount ()> 0) {// Quando o elemento atual tem um valor de atributo, é
for (iterator list = CurrentElement.attributeIterator (); list.hasnext ();) {// transf o valor do atributo
Atributo att = (atributo) list.next ();
if (att.getValue (). Iguals (fadattr)) {// determinar o elemento pai único com base no valor do atributo
if (operator.equals ("add")) {// add element
Element ChildElement = CurrentElement.AddElement (nome da criança);
ChildElement.Settext (ChildValue);
Iterator itmapattr = mapattr.keyset (). Iterator ();
while (itmapattr.hasnext ()) {
String key = (string) itmapattr.Next ();
String value = mapattr.get (key) .toString ();
childElement.setAttributeValue (chave, valor);
}
// ChildElement.SetAttributeValue ("ID", "M1");
// ChildElement.SetAttributeValue ("Nome", "Module1");
// childElement.setAttributeValue ("url", "index1.jsp");
} else if (operator.equals ("update")) {// modifique um elemento
Liste crianças = currentElement.Elements (nome da criança); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
Todos.settext (ChildValue);
}
} else if (operator.equals ("delete")) {// exclua um elemento especificado
Liste crianças = currentElement.Elements (); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
currentElement.remove (todos);
}
} else if (operator.equals ("get")) {
Liste crianças = currentElement.Elements (nome da criança); // Obtenha todos os nós filhos no nó atual, julgue seus valores e modifique -os
for (crianças iterador = infantil.iterator (); childs.hasnext ();) {
Elemento todo mundo = (elemento) childs.next ();
// resultado = todos.getText ();
resultado = todos.attributeValue ("id")+","+resultado;
}
}
outro{
// escrevendo um log
// String Loginfo = "O operador XMLFile não existe!";
// writeLog.writeLogToEnd ("LocalsServerManager", Loginfo);
}
}
}
}
}
}
savexmlfile (this.document);
resultado de retorno;
}
/**
* Salvar o arquivo XML
* Documento @param: Nome do arquivo xml
*/
private void savexmlfile (documento documento) {
tentar {
OutputFormat format = outputFormat.createprettyprint ();
format.setEncoding ("UTF-8");
Xmlwriter writer = new XMLWriter (new FileWriter (novo arquivo (filepath)), formato);
writer.write (documento);
writer.close ();
} catch (Exceção e) {
// String Loginfo = Stacktracetostring.GetexceptionTrace (e);
// writeLog.writeLogToEnd ("LocalsServerManager", Loginfo);
}
}
/**
* Determine se o arquivo XML existe.
* @param filename
* @retornar
*/
private boolean fileExist () {
java.io.file objfile = new java.io.file (this.FilePath);
if (objfile.exists ()) {
retornar true;
} outro {
retornar falso;
}
}
}
Arquivo XML:
A cópia do código é a seguinte:
<? xml versão = "1.0" coding = "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 = "module9" url = "index3.jsp"/>
<módulo id = "m10" name = "módulo10" url = "index4.jsp"/>
<módulo id = "m11" name = "módulo11" url = "index5.jsp"/>
</div>
</style>
Análise: aqui usamos o método recursivo para determinar se a operação é para o nó ou nó filho, o que é relativamente claro. Use injeção de dependência, economiza o problema de se o julgamento, mas eu só fiz uma demonstração naquele momento, sem mais otimizações.
Resumo: Na verdade, não é difícil ler XML. Para escrever muitas repetições, há um problema com o código que precisa ser modificado repetidamente; portanto, às vezes, embora os requisitos sejam importantes, como implementá -los é igualmente importante!