How to convert between XML documents and JTree

XMLBecause of its good structure, it is widely used in the definition of document formats. We know that application software generally needs to use configuration file to determine some parameters during runtime. The configuration file of previous applications was generally an .ini file. Although ini files are still in use today, due to the emergence of XML, more and more commercial software is using XML as the configuration file format, such as BEA's Weblogic and IBM's Websphere. Therefore, when we design a software configuration file, we will increasingly consider using XML as the format of the configuration file.

Because configuration files sometimes must be modified by users, providing a visual format for editing configuration files is a reflection of the software's good user interactivity. We must find a visual method for XML documents. The JTree in the Swing component in the Java language is very suitable for the visualization of XML documents. There is a very convenient conversion method between the two. This means that we can easily display the user's operations on the JTree as modifications in the XML file after saving, and we can also conveniently display the XML file as a JTree to the user.

Visualization of XML documents

An XML document is actually a tree structure. For example, the following XML document:

  
    古典
    d:\software\App\skin
    head1.bmp

    center1.bmp
    foot1.bmp
  

    现代
    d:\software\App\skin
    head2.bmp

    center2.bmp
    foot2.bmp
  

It can be seen that the XML document is the interface of a multi-interface program PictureConfiguration program. If the XML document is visualized, then JTree should be used What is obtained is the result shown in the figure below.

Figure Visualization results

All XML documents can generate such a Jtree. Using XML's Parser and the JTree class in Java, a general visual XML document can be constructed to form a JTree. The result of the XML document parsing by XML Parser is to generate a DOM (Document Object Model) tree. The structure of the DOM tree is actually the same as the structure of the JTree. , which makes the cooperation between JTree and XML Parser very natural. Here’s how to do it.

A class that reads and writes XML files

First you must obtain the XML Parser package, which can be obtained from the following address: http://xml.apache.org/xerces2-j/index. html.
Then design an XMLTree class, inherit from the definition and members of the JTree class variables , functions are defined as follows:

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 )
}

where The initialization work done by the constructor is as follows:

XMLTree(String fileName){
      dbf = DocumentBuilderFactory.newInstance(); 
      //生成dbf的实例
      db = dbf.newDocumentBuilder();  
      //生成db的实例
      treeNode = LoadFile( getXMLRoot( text ) );  
      //解析该xml文件，返回JTree的根节点
      setModel( new DefaultTreeModel( treeNode ) );  
      //根据该根节点生成JTree
}

Among them, parseXml is a program that returns the root element of the XML file, as follows:

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树的根元素
}

The core part of LoadFile is a recursionThe process is as follows:

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;  //返回节点 }

You can easily make changes on the JTree using the methods in Java's Swing package. You can use the pop-up dialog box method, or you can make changes directly on the JTree. In short, after the JTree is changed, it needs to be written back to the file. Writing a JTree into an XML file is a recursive process. The method is as follows:

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(“\r\n”);
    }
      } catch (Exception e)
      {  e.printStackTrace();
      } }

It must be noted that if the XML file contains Chinese, then it needs to Before calling the above function, enter the encoding method of the XML file in the file as follows:

fw.write(“\r\n”);

After calling the function, you should also close the file as follows:

fw.close()

Conclusion

XML files are widely used in configuration files and information transmission. There are many visualization methods. This article introduces one of the implementation methods by combining Java's JTree class. The good combination of Java language and XML makes it flexible and convenient to use Java to compile XML programs.

The above is the detailed content of How to convert between XML documents and JTree. For more information, please follow other related articles on the PHP Chinese website!