使用延遲加載恢復JTree中的擴展/選擇狀態

Question

我有一個應用程序，其中包含一個支持DefaultTreeModel的JTree，用於顯示反映我服務器上文件系統部分的文件層次結構（我將參考這作爲我的客戶端應用程序）。我還有一個服務器應用程序，它提供我的客戶端應用程序需要顯示的數據（我將其稱爲我的服務器應用程序）。我正在使用「延遲加載兒童」的方法，因此如果用戶對其感興趣，我只需將文件加載到我的樹中。延遲加載的方法：

1. 我重寫treeWillExpand(TreeExpansionEvent evt)
2. 我設置選擇的路徑是不斷擴大的節點。
3. 然後我發送一條消息給服務器，請求該節點的孩子。
4. 服務器響應時，我得到最後選擇的路徑組件。
5. 然後我使用DefaultTreeModel.insertNodeInto()爲每個返回的數據文件。
6. 最後我打電話給DefaultTreeModel.nodeStructureChanged()。

上述工作正常，我沒有任何問題，懶惰加載孩子。我的問題是當新數據上傳到服務器時，我想更新樹不僅包含新數據，而且還將擴展狀態和選定節點設置爲更新樹之前的內容（以便用戶因爲有新的數據可以查看，所以不會在樹上突然出現）。該流程如下：

1. 新的數據上傳到服務器
2. Server應用程序存檔這些數據，並使用有關上載的文件信息的數據庫。
3. 服務器應用程序通知客戶端應用程序已上傳新數據。
4. 客戶端應用程序使用保存JTree.getExpandedDescendants()
5. 客戶端應用程序中的樹的膨脹狀態保存使用JTree.getSelectionPath()
6. 客戶端應用程序中的樹的選擇路徑將刪除DefaultTreeModel的所有節點。
7. 客戶端應用程序向服務器請求從根節點開始的數據。
8. 客戶端應用程序遍歷從JTree.getExpandedDescendants()返回的樹路徑枚舉，枚舉中的每個TreePath都調用JTree.expandPath()。
9. 客戶端應用程序設置選定的樹形路徑。

我的問題是，無論我嘗試樹的GUI不更新以反映擴展狀態。我知道我對expandPath的調用正在工作，因爲我可以看到從客戶端發送的數據請求，以及對於每次調用expandPath的服務器數據的響應。我還在另一個窗口中顯示有關當前選定節點的信息，並顯示正確選擇的節點。但是，令人遺憾的是，GUI只顯示根節點（擴展），而它的子節點（未擴展）而不是以前的擴展狀態。

所以我的問題是：如何恢復我的JTree的擴展狀態，使GUI在數據模型更新之前和之後保持不變？

這是少數人的事情，我曾嘗試：

• 我發現a thread有類似的設置，以礦山和他的問題被重寫equals()和hashCode()解決，但沒有爲我工作。
• 各種方法來調用擴展，如：setExpandsSelectedPaths(true)，nodeStructureChanged()，節約擴張狀態JTree.invalidate()
• 許多不同的變化，但是，我不相信擴張狀態是不正確的，我可以看到正在傳遞正確的數據備份以及在客戶端應用程序和服務器應用程序之間。

這裏是我的SSCCE：

package tree.sscce; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.SwingUtilities; 
import java.awt.BorderLayout; 
import javax.swing.JScrollPane; 
import javax.swing.JTree; 
import javax.swing.JButton; 
import java.util.Enumeration; 
import javax.swing.BoxLayout; 
import javax.swing.event.TreeExpansionEvent; 
import javax.swing.event.TreeWillExpandListener; 
import javax.swing.tree.DefaultMutableTreeNode; 
import javax.swing.tree.DefaultTreeModel; 
import javax.swing.tree.ExpandVetoException; 
import javax.swing.tree.MutableTreeNode; 
import javax.swing.tree.TreePath; 
import java.awt.event.ActionListener; 
import java.awt.event.ActionEvent; 
import javax.swing.JTextPane; 

public class TreeSSCCE extends JFrame implements TreeWillExpandListener { 

private static final long serialVersionUID = -1930472429779070045L; 

public static void main(String[] args) 
{ 
    SwingUtilities.invokeLater(new Runnable() { 
     public void run() { 
      TreeSSCCE inst = new TreeSSCCE(); 
      inst.setLocationRelativeTo(null); 
      inst.setVisible(true); 
      inst.setDefaultCloseOperation(EXIT_ON_CLOSE); 
     }   
    }); 
} 

private DefaultMutableTreeNode rootNode; 
private JTree tree; 
private DefaultTreeModel treeModel; 
private TreePath selectionPathPriorToNewData; 
private Enumeration<TreePath> expandedPathsPriorToNewData; 
private int treeSize = 5; 

public TreeSSCCE() { 

    this.setBounds(0, 0, 500, 400); 
    JPanel mainPanel = new JPanel(); 
    getContentPane().add(mainPanel, BorderLayout.CENTER); 
    mainPanel.setBounds(0, 0, 500, 400); 
    mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS)); 

    JPanel descriptionPanel = new JPanel(); 
    descriptionPanel.setBounds(0, 0, 500, 200); 
    mainPanel.add(descriptionPanel); 

    JTextPane textPane = new JTextPane(); 
    String newLine = System.getProperty("line.separator"); 
    descriptionPanel.setLayout(new BorderLayout(0, 0)); 
    textPane.setText("Start by expanding some nodes then click 'Add New Data' and you will notice that the tree state is not retained."); 
    descriptionPanel.add(textPane); 

    // Initialize The Tree 
    tree = new JTree(); 
    rootNode = new DefaultMutableTreeNode("Root"); 
    treeModel = new DefaultTreeModel(rootNode); 
    tree.addTreeWillExpandListener(this); 
    tree.setModel(treeModel); 
    tree.setShowsRootHandles(true); 
    populateTree(false); 

    JScrollPane scrollPane = new JScrollPane(tree); 
    mainPanel.add(scrollPane); 

    JPanel buttonPanel = new JPanel(); 
    mainPanel.add(buttonPanel); 

    JButton btnAddNewData = new JButton("Add New Data"); 
    btnAddNewData.addActionListener(new ActionListener() { 
     public void actionPerformed(ActionEvent arg0) { 
      addNewDataToTree(); 
     } 
    }); 
    buttonPanel.add(btnAddNewData); 


} 

private void removeAllTreeNodes() 
{ 

    while(!treeModel.isLeaf(treeModel.getRoot())) 
    { 
     treeModel.removeNodeFromParent((MutableTreeNode)treeModel.getChild(treeModel.getRoot(),0)); 
    } 
    treeModel = null; 
    treeModel = new DefaultTreeModel(rootNode); 
    tree.setModel(treeModel); 
} 

public void restoreExpansionState(Enumeration enumeration) 
{ 
    if (enumeration != null) 
    { 
     while (enumeration.hasMoreElements()) 
     { 
      TreePath treePath = (TreePath) enumeration.nextElement(); 
      tree.expandPath(treePath); 
      tree.setSelectionPath(treePath); 
     } 
     tree.setSelectionPath(selectionPathPriorToNewData); 
    } 
} 

protected void addNewDataToTree() 
{ 
    // save the tree state 
    selectionPathPriorToNewData = tree.getSelectionPath(); 
    expandedPathsPriorToNewData = tree.getExpandedDescendants(new TreePath(tree.getModel().getRoot())); 
    removeAllTreeNodes(); 
    populateTree(true); 
    restoreExpansionState(expandedPathsPriorToNewData); 
} 

private void populateTree(boolean newData) 
{ 
    if(newData) 
     treeSize++; 
    MyParentNode[] parents = new MyParentNode[treeSize]; 
    for(int i = 0; i < treeSize; i++) 
    { 
     parents[i] = new MyParentNode("Parent [" + i + "]"); 
     treeModel.insertNodeInto(parents[i], rootNode, i); 
    } 
} 

@Override 
public void treeWillCollapse(TreeExpansionEvent evt) throws ExpandVetoException { 
    // Not used. 
} 

@Override 
public void treeWillExpand(TreeExpansionEvent evt) throws ExpandVetoException 
{ 
    System.out.println("Tree expanding: " + evt.getPath()); 
    tree.setExpandsSelectedPaths(true); 
    tree.setSelectionPath(evt.getPath()); 
    // we have already loaded the top-level items below root when we 
    // connected so lets just return... 
    if(evt.getPath().getLastPathComponent().equals(treeModel.getRoot())) 
     return; 

    // if this is not root lets figure out what we need to do. 
    DefaultMutableTreeNode expandingNode = (DefaultMutableTreeNode) evt.getPath().getLastPathComponent(); 

    // if this node already has children then we don't want to reload so lets return; 
    if(expandingNode.getChildCount() > 0) 
     return;  
    // if this node has no children then lets add some 
    MyParentNode mpn = new MyParentNode("Parent Under " + expandingNode.toString()); 
    treeModel.insertNodeInto(mpn, expandingNode, expandingNode.getChildCount()); 
    for(int i = 0; i < 3; i++) 
    { 
     treeModel.insertNodeInto(new DefaultMutableTreeNode("Node [" + i + "]"), mpn, i); 
    } 
} 

private class MyParentNode extends DefaultMutableTreeNode 
{ 
    private static final long serialVersionUID = 433317389888990065L; 
    private String name = ""; 

    public MyParentNode(String _name) 
    { 
     super(_name); 
     name = _name; 
    } 

    @Override 
    public int hashCode() { 
     final int prime = 31; 
     int result = 1; 
     result = prime * result + getOuterType().hashCode(); 
     result = prime * result + ((name == null) ? 0 : name.hashCode()); 
     return result; 
    } 

    @Override 
    public boolean equals(Object obj) { 
     if (this == obj) 
      return true; 
     if (obj == null) 
      return false; 
     if (getClass() != obj.getClass()) 
      return false; 
     MyParentNode other = (MyParentNode) obj; 
     if (!getOuterType().equals(other.getOuterType())) 
      return false; 
     if (name == null) { 
      if (other.name != null) 
       return false; 
     } else if (!name.equals(other.name)) 
      return false; 
     return true; 
    } 

    @Override 
    public boolean isLeaf() 
    { 
     return false; 
    } 

    private TreeSSCCE getOuterType() { 
     return TreeSSCCE.this; 
    }  
} 

} 

預先感謝任何幫助，您可以提供。

P.S.這是我的第一個問題，所以請讓我知道，如果我問得很對（並對我輕鬆）;）。

Answer 1

我正在使用自定義樹模型（擴展DefaultTreeModel）並在DBTreeEvent.STRUCTURE_CHANGED事件中作出反應來處理此問題。這就是我爲保護舊國家所做的。不知道它是否會幫助你..

//NOTE: node is the tree node that caused the tree event 
TreePath nodesPath = new TreePath(node.getPath()); 
TreePath currentSel = myTree.getLeadSelectionPath(); 
List<TreePath> currOpen = getCurrExpandedPaths(nodesPath); 
super.nodeStructureChanged(node); 
reExpandPaths(currOpen); 
myTree.setSelectionPath(currentSel); 

private List<TreePath> getCurrExpandedPaths(TreePath currPath) 
{ 
    List<TreePath> paths = new ArrayList<TreePath>(); 
    Enumeration<TreePath> expandEnum = myTree.getExpandedDescendants(currPath); 
    if (expandEnum == null) 
     return null; 

    while (expandEnum.hasMoreElements()) 
     paths.add(expandEnum.nextElement()); 

    return paths; 
} 

private void reExpandPaths(List<TreePath> expPaths) 
{ 
    if(expPaths == null) 
     return; 
    for(TreePath tp : expPaths) 
     myTree.expandPath(tp); 
}