Maison > Article > développement back-end > Comment convertir entre des documents XML et JTree
Comment convertir entre des documents XML et JTree
- 黄舟original
- 2017-05-07 14:08:542138parcourir
Le
XML est largement utilisé dans la définition des formats de documents en raison de sa bonne structure. Nous savons que les logiciels d'application doivent généralement utiliser un fichier de configuration pour déterminer certains paramètres lors de l'exécution. Le fichier de configuration des applications précédentes était généralement un fichier .ini. Bien que les fichiers ini soient encore utilisés aujourd'hui, en raison de l'émergence de XML, de plus en plus de logiciels commerciaux utilisent XML comme format de fichier de configuration, tels que Weblogic de BEA et Websphere d'IBM. Par conséquent, lorsque nous concevrons un fichier de configuration logicielle, nous envisagerons de plus en plus d’utiliser XML comme format de fichier de configuration.
Parce que les fichiers de configuration doivent parfois être modifiés par les utilisateurs, fournir un format visuel pour l'édition des fichiers de configuration est le reflet de la bonne interactivité utilisateur du logiciel. Il faut trouver une méthode visuelle pour les documents XML. Le JTree du composant Swing du langage Java est très adapté à la visualisation de documents XML. Il existe une méthode de conversion très pratique entre les deux. Cela signifie que nous pouvons facilement afficher les opérations de l'utilisateur sur le JTree sous forme de modifications dans le fichier XML après l'enregistrement, et nous pouvons également afficher facilement le fichier XML en tant que JTree pour l'utilisateur.
Visualisation de documents XML
Un document XML est en fait une arborescence. Par exemple, le document XML suivant :
<?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>On voit que le document XML est l'interface d'un programme multi-interface image programme de configuration si le document XML est visualisé. , puis utilisez JTree. Si tel est le cas, vous devriez obtenir le résultat comme indiqué dans la figure ci-dessous.
Résultats de la visualisation des figures
Tous les documents XML peuvent générer un tel Jtree. En utilisant l'analyseur XML et la classe JTree en Java, un document XML visuel général peut être construit pour former un JTree. Le résultat de l'analyse des documents XML par XML Parser est de générer une arborescence DOM (Document Object Model). La structure de l'arborescence DOM est en fait la même que celle. la structure du JTree , ce qui rend la coopération entre JTree et XML Parser très naturelle. Voici comment procéder.
Une classe qui lit et écrit des fichiers XML
Vous devez d'abord vous procurer le package XML Parser, qui peut être obtenu à l'adresse suivante : http://xml.apache.org/xerces2- j/index.html.
Concevez ensuite une classe XMLTree, hérite de la définition et les membres de la classe JTree variables , et fonctions sont définies comme suit :
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 )
}Le travail d'initialisation effectué par le constructeur est le suivant :
XMLTree(String fileName){
dbf = DocumentBuilderFactory.newInstance();
//生成dbf的实例
db = dbf.newDocumentBuilder();
//生成db的实例
treeNode = LoadFile( getXMLRoot( text ) );
//解析该xml文件，返回JTree的根节点
setModel( new DefaultTreeModel( treeNode ) );
//根据该根节点生成JTree
}Parmi eux, parseXml est un programme qui renvoie l'élément racine du fichier XML, comme suit :
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树的根元素
}La partie centrale de LoadFile est un Le processus récursif est le suivant :
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; //返回节点 }En utilisant les méthodes du package Swing de Java, vous pouvez facilement apporter des modifications au JTree. Vous pouvez utiliser la méthode de la boîte de dialogue contextuelle ou directement les modifications sur JTree. En bref, une fois le JTree modifié, il doit être réécrit dans le fichier. L'écriture d'un JTree dans un fichier XML est un processus récursif :
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();
} }Il faut le noter. que si le fichier XML contient du chinois, vous devez alors saisir la méthode d'encodage du fichier XML dans le fichier avant d'appeler la fonction ci-dessus. La méthode est la suivante :
fw.write(“<?xml version=“1.0” encoding=“GB2312”?>\r\n”);
Après avoir appelé la fonction, vous. doit également fermer le fichier comme suit :
fw.close()
Conclusion
Les fichiers XML sont largement utilisés dans les fichiers de configuration et la transmission d'informations. Il existe de nombreuses méthodes de visualisation. Cet article présente l'une des méthodes d'implémentation en combinant la classe JTree de Java. La bonne combinaison du langage Java et de XML rend l'utilisation de Java flexible et pratique pour compiler des programmes XML.
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!