Java 使用延迟加载恢复JTree中的扩展/选择状态

我有一个应用程序，其中包含一个以DefaultTreeModel为后盾的JTree，该模型用于显示反映我服务器上文件系统部分的文件层次结构（我将此称为我的客户端应用程序）。我还有一个服务器应用程序，它提供我的客户端应用程序需要显示的数据（我将此称为我的服务器应用程序）。我使用的是“延迟加载子对象”的方法，因此，如果用户感兴趣，我只需将文件加载到我的树中。延迟加载方法：

我覆盖

treeWillExpand（treeeexpansionevent evt）

我将选择路径设置为展开节点的路径

然后我向服务器发送一条消息，询问该节点的子节点

当服务器响应时，我得到最后一个选择的路径组件

然后我对每个返回的数据文件使用

DefaultTreeModel.insertNodeInto（）

最后，我调用

DefaultTreeModel.nodeStructureChanged（）

上述工作很好，我没有任何问题懒惰加载的孩子。当新数据上传到服务器时，我的问题就出现了，我想更新树，使其不仅包含新数据，而且将扩展状态和所选节点设置为更新树之前的状态（这样用户就不会因为有新数据要查看而在树上乱动）。流程如下：

新数据将上载到服务器

服务器应用程序存档此数据，并用上载文件的信息填充数据库

服务器应用程序通知客户端应用程序已上载新数据

客户端应用程序使用

JTree.getExpandedDescendats（）保存树的扩展状态

客户端应用程序使用

JTree.getSelectionPath（）

客户端应用程序从DefaultTreeModel中删除所有节点

客户端应用从根节点开始从服务器请求数据

客户端应用程序在枚举中的每个树路径上遍历从调用

JTree.getExpandedDescendats（）

返回的树路径枚举

客户端应用程序设置选定的树路径

我的问题是，无论我尝试什么，树的GUI都不会更新以反映扩展状态。我知道我对expandPath的调用正在工作，因为每次调用expandPath时，我都可以看到客户端发送的数据请求和服务器的数据响应。我还将在另一个窗口中显示有关当前选定节点的信息，它将显示正确选定的节点。但是，遗憾的是，令我失望的是，GUI只显示根节点（已展开）及其子节点（未展开），而不是以前的展开状态

因此，我的问题是：如何恢复JTree的扩展状态，使GUI在数据模型更新前后保持不变？

以下是我尝试过的一些事情：

• 我发现了一个与我类似的设置，他的问题通过覆盖

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

}

package tree.sscce；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.SwingUtilities；
导入java.awt.BorderLayout；
导入javax.swing.JScrollPane；
导入javax.swing.JTree；
导入javax.swing.JButton；
导入java.util.Enumeration；
导入javax.swing.BoxLayout；
导入javax.swing.event.TreeExpansionEvent；
导入javax.swing.event.TreeWillExpandListener；
导入javax.swing.tree.DefaultMutableTreeNode；
导入javax.swing.tree.DefaultTreeModel；
导入javax.swing.tree.ExpandVetoException；
导入javax.swing.tree.MutableTreeNode；
导入javax.swing.tree.TreePath；
导入java.awt.event.ActionListener；
导入java.awt.event.ActionEvent；
导入javax.swing.JTextPane；
公共类TreeSCCE扩展JFrame实现TreeWireExpandListener{
私有静态最终长serialVersionUID=-1930472429779070045L；
公共静态void main（字符串[]args）
{
SwingUtilities.invokeLater（新的Runnable（）{
公开募捐{
TreeSCCE inst=新的TreeSCCE（）；
inst.setLocationRelativeTo（空）；
仪器设置可见（真）；
inst.SETDEFAULTCLOSE操作（关闭时退出）；
}           
});
}
私有DefaultMutableTreeNode根节点；
私有JTree树；
私有DefaultTreeModel树模型；
private TreePath selectionPathPriorToNewData；
私有枚举ExpandedPathSprioToNewData；
私有int-treeSize=5；
公共树cce（）{
这个.挫折（0,0,500,400）；
JPanel mainPanel=新的JPanel（）；
getContentPane（）.add（主面板，BorderLayout.CENTER）；
主面板.立根（0,0,500,400）；
mainPanel.setLayout（新的BoxLayout（mainPanel，BoxLayout.Y_轴））；
JPanel descriptionPanel=新的JPanel（）；
描述面板.立根（0,0,500,200）；
主面板。添加（描述面板）；
JTextPane textPane=新的JTextPane（）；
字符串newLine=System.getProperty（“line.separator”）；
descriptionPanel.setLayout（新的BorderLayout（0,0））；
textPane.setText（“首先展开一些节点，然后单击“添加新数据”，您将注意到树状态没有保留。”）；
descriptionPanel.add（文本窗格）；
//初始化树
tree=newjtree（）；
rootNode=新的DefaultMutableTreeNode（“根”）；
treeModel=新的DefaultTreeModel（rootNode）；
addTreeWillExpandListener（thi
//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);
}