XML wird aufgrund seiner guten Struktur häufig bei der Definition von Dokumentformaten verwendet. Wir wissen, dass Anwendungssoftware im Allgemeinen eine Konfigurationsdatei verwenden muss, um einige Parameter während der Laufzeit zu bestimmen. Die Konfigurationsdatei früherer Anwendungen war im Allgemeinen eine .ini-Datei. Obwohl INI-Dateien heute noch verwendet werden, verwenden aufgrund des Aufkommens von XML immer mehr kommerzielle Software XML als Konfigurationsdateiformat, wie z. B. Weblogic von BEA und Websphere von IBM. Wenn wir eine Softwarekonfigurationsdatei entwerfen, werden wir daher zunehmend die Verwendung von XML als Format der Konfigurationsdatei in Betracht ziehen.
Da Konfigurationsdateien manchmal von Benutzern geändert werden müssen, spiegelt die Bereitstellung eines visuellen Formats zum Bearbeiten von Konfigurationsdateien die gute Benutzerinteraktivität der Software wider. Wir müssen eine visuelle Methode für XML-Dokumente finden. Der JTree in der Swing-Komponente in der Java-Sprache eignet sich sehr gut für die Visualisierung von XML-Dokumenten. Es gibt eine sehr praktische Konvertierungsmethode zwischen den beiden. Dies bedeutet, dass wir die Vorgänge des Benutzers am JTree nach dem Speichern problemlos als Änderungen in der XML-Datei anzeigen können und dem Benutzer auch bequem die XML-Datei als JTree anzeigen können.
Ein XML-Dokument ist eigentlich eine Baumstruktur. Zum Beispiel das folgende XML-Dokument:
<?xml version=“1.0”encoding=“GB2312”?>
<skin>
<skin1>
<name>古典</name>
<dir>d:\software\App\skin</dir>
<head>head1.bmp</head>
<center>center1.bmp</center>
<foot>foot1.bmp</foot>
</skin1>
<skin2>
<name>现代</name>
<dir>d:\software\App\skin</dir>
<head>head2.bmp</head>
<center>center2.bmp</center>
<foot>foot2.bmp</foot>
</skin2>
</skin>Es ist ersichtlich, dass das XML-Dokument die Schnittstelle eines Multi-Interface-Programms Bild Konfigurationsprogramm ist, wenn das XML-Dokument visualisiert wird , dann verwenden Sie JTree. Wenn ja, sollten Sie das in der folgenden Abbildung gezeigte Ergebnis erhalten.
Ergebnisse der Abbildungsvisualisierung
Alle XML-Dokumente können einen solchen Jtree generieren. Mithilfe des XML-Parsers und der JTree-Klasse in Java kann ein allgemeines visuelles XML-Dokument erstellt werden, um einen JTree zu bilden. Das Ergebnis der XML-Dokumentenanalyse durch den XML-Parser ist die Generierung eines DOM-Baums (Dokument Objekt Modell). die Struktur des JTree, was die Zusammenarbeit zwischen JTree und XML-Parser sehr natürlich macht. Hier erfahren Sie, wie es geht.
Zuerst müssen Sie das XML-Parser-Paket erhalten, das unter der folgenden Adresse erhältlich ist: http://xml.apache.org/xerces2- j/index.html.
Dann entwerfen Sie eine XMLTree-Klasse, erben von der Definition und den Mitgliedern der JTree-Klasse Variablen und Funktionen werden wie folgt definiert:
public class XMLTree extends JTree{
private DefaultMutableTreeNode treeNode; //JTree的根节点
private DocumentBuilderFactory dbf;
// 这三个成员变量是xml parser需要的
private DocumentBuilder db;
private Document doc;
XMLTree(String fileName);
//构造函数，做初始化工作
public DefaultMutableTreeNode LoadFile(Node root);
//从某个XML文件生成该树
public void SaveToFile(DefaultMutableTreeNode root,FileWriter fw);
//将该树存盘成XML文件
private Node parseXml( String text )
}Die vom Konstruktor durchgeführte Initialisierungsarbeit ist wie folgt:
XMLTree(String fileName){
dbf = DocumentBuilderFactory.newInstance();
//生成dbf的实例
db = dbf.newDocumentBuilder();
//生成db的实例
treeNode = LoadFile( getXMLRoot( text ) );
//解析该xml文件，返回JTree的根节点
setModel( new DefaultTreeModel( treeNode ) );
//根据该根节点生成JTree
}Unter anderem ist parseXml ein Programm, das das Stammelement der XML-Datei wie folgt zurückgibt:
private Node getXMLRoot( String text ){
ByteArrayInputStream byteStream;
byteStream = new ByteArrayInputStream( text.getBytes() );
//将XML文件读到Stream里去
try{
doc = db.parse( byteStream );
//解析该xml文件。
} catch ( Exception e )
{ e.printStackTrace();}
return ( Node )doc.getDocumentElement();
//返回该XML文件的DOM树的根元素
}Der Kernteil von LoadFile ist ein Der rekursive Prozess ist wie folgt:
private DefaultMutableTreeNode createTreeNode( Node root ){
DefaultMutableTreeNode treeNode = null;
//定义要返回的根节点
String name = root.getNodeName();
//获得该节点的NodeName
String value = root.getNodeValue();
//获得该节点的NodeValue
treeNode = new DefaultMutableTreeNode( root.
getNodeType() == Node.TEXT_NODE ? value : name );
//如果为值节点，那么取得该节点的值，否则取得该节点的Tag的名字
if ( root.hasChildNodes() )
//如果该节点有孩子节点，那么递归处理该节点的孩子节点
{ NodeList children = root.getChildNodes();
//取得该节点的子节点列表
if( children != null ){
//判断子节点是否为空
int numChildren = children.getLength();
//取得字节数目
for (int i=0; i < numChildren; i++){
Node node = children.item(i);
//循环处理每个子节点
if( node != null )
{ if( node.getNodeType() == Node.ELEMENT_NODE )
{ treeNode.add( createTreeNode(node) );
//如果该子节点还有孩子节点使用递归的方法处理该子节点
} else {
String data = node.getNodeValue();
if( data != null )
{
data = data.trim();
if ( !data.equals(“\n”) && !data.equals(“\r\n”) &&
data.length() > 0 )
{ treeNode.add(new
DefaultMutableTreeNode(node.getNodeValue()));
//如果该节点没有孩子节点，那么直接加到节点下
}
}
}
}
}
}
}
return treeNode; //返回节点 }Mit den Methoden im Swing-Paket von Java können Sie problemlos Änderungen am JTree vornehmen. Sie können die Popup-Dialogfeldmethode verwenden oder Änderungen direkt in JTree vornehmen. Kurz gesagt, nachdem der JTree geändert wurde, muss er in die Datei zurückgeschrieben werden. Das Schreiben eines JTree in eine XML-Datei ist ein rekursiver Prozess:
public void SaveToFile(DefaultMutableTreeNode, FileWriter fw)
{try {
if (root.isLeaf()) fw.write(root.toString()+“\r\n”);
//如果是叶子节点则直接将该节点输出到文件中
else { //不是叶子节点的话递归输出该节点
fw.write(“<”+root.toString()+“>\r\n”);
for (int i=0; i < root.getChildCount(); i++)
{ DefaultMutableTreeNode childNode =(DefaultMutableTreeNode)
root.getChildAt(i);
saveFile(childNode, fw);
//递归输出该节点的所有子节点 }
fw.write(“</”+root.toString()+“>\r\n”);
}
} catch (Exception e)
{ e.printStackTrace();
} }Es muss beachtet werden Wenn die XML-Datei Chinesisch enthält, müssen Sie die Codierungsmethode der XML-Datei in die Datei eingeben, bevor Sie die obige Funktion aufrufen. Die Methode lautet wie folgt:
fw.write(“<?xml version=“1.0” encoding=“GB2312”?>\r\n”);
Nachdem Sie die Funktion aufgerufen haben sollte die Datei auch wie folgt schließen:
fw.close()
XML-Dateien werden häufig in Konfigurationsdateien und der Informationsübertragung verwendet. Es gibt viele Visualisierungsmethoden. In diesem Artikel wird eine der Implementierungsmethoden durch die Kombination der JTree-Klasse von Java vorgestellt. Die gute Kombination von Java-Sprache und XML macht es flexibel und bequem, Java zum Kompilieren von XML-Programmen zu verwenden.
Das obige ist der detaillierte Inhalt vonSo konvertieren Sie zwischen XML-Dokumenten und JTree. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
PR-Tastenkombination
Der Unterschied zwischen Python-Kursen und C+-Kursen
Gängige Methoden zur Erkennung von Website-Schwachstellen
Was sind die GSM-Verschlüsselungsalgorithmen?
Was tun, wenn Ihre IP-Adresse angegriffen wird?
Der Unterschied zwischen insertbefore und before
Welche Protokolle umfasst das SSL-Protokoll?
So öffnen Sie eine XML-Datei
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
