Java 动态JTree和SwingUtilities.invokeLater（）不执行任何操作

为了创建我的动态JTree，我正在阅读关于动态JTree的教程

现在我已经实现了它，并且认识到在GUI线程中加载数据需要很长时间，而且也很难看。因此，我添加了一个线程来展开子级，然后将

TreeNode

元素添加到树中

private void getChildNodes() {
    areChildrenDefined = true;
    Thread t = new Thread(new Runnable()
    {
        @Override
        public void run() {
        System.out.println("Expand");
            final List<DECTTreeNode> listNodes = new ArrayList<DECTTreeNode>();
            if (castNode().canExpand())
            {
                for(DECTNode crt : castNode().getChildren())
                {   
                    DECTTreeNode treeNode = new DECTTreeNode(crt);
                    listNodes.add(treeNode);
                }

                try {
                    SwingUtilities.invokeAndWait(new Runnable()
                    {
                        @Override
                        public void run() {
                            System.out.println(listNodes.size());
                            for (DECTTreeNode crt : listNodes)
                            {
                                add(crt); // <==== Adds the node to the JTree
                            }
                        }

                    });
                    //}).run();
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        }

    });
    t.start();
}

private void getChildNodes（）{
areChildrenDefined=true；
线程t=新线程（新的可运行线程（）
{
@凌驾
公开募捐{
System.out.println（“扩展”）；
最终列表listNodes=new ArrayList（）；
if（castNode（）.canExpand（））
{
对于（DECTNode crt:castNode（）.getChildren（））
{   
DECTTreeNode=新DECTTreeNode（crt）；
添加（treeNode）；
}
试一试{
SwingUtilities.invokeAndWait（新的Runnable（）
{
@凌驾
公开募捐{
System.out.println（listNodes.size（））；
用于（DECTTreeNode crt:listNodes）
{
add（crt）；//尝试将
invokeAndWait
替换为
invokeLater
检查add（）方法是否触发了正确的TreeModelEvent
我在目前正在处理的项目中遇到了相同的问题

我使用
TreeWillExpandListener
来确定何时必须加载我的树
当树展开时，我捕获了节点并将其子节点加载到线程中，因为我必须从服务器输出解析节点

您面临的问题是，在加载子项之前，树会展开。因此，您必须抛出
ExpandVetoException
或类似的命令，等待子项加载。然后展开树。在这种情况下，所有内容都会正确显示

希望这能解决你的问题

Exampland->Stop expand->loadchildren->addChildren->now expand tree->查看节点

编辑：

@Override
public void loadChildren(CustomTreeNode tn) {
    ctn = tn;
    LoadChildrenWorker worker = new LoadChildrenWorker();
    worker.execute();
}


private class LoadChildrenWorker extends SwingWorker<String, Object> {

            @Override
    protected String doInBackground() throws Exception {
                    //load source here and return a string when finished.
                    //In my case its a string repesentation of a directory
    }

    @Override
    protected void done() {
            //with get(), you get the string from doBackground()
            for (String str : parseFromOutput(get())) {
                    if (str.endsWith("/")) {
                        ctn.add(new CustomTreeNode("Directory");
                    } else {
                        ctn.add(new CustomTreeNode("Leaf");
                    }
            }
            //call listeners
            ctn.fireChildrenLoaded();
    }

如果您使用swing，您最好使用SwingWorker.Works对我更有效。
要扩展Walter+1的建议，请从JButton
addButton
调用
Runnable\Thread

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;

public class DynamicTreeDemo extends JPanel implements ActionListener {

    private static final long serialVersionUID = 1L;
    private int newNodeSuffix = 1;
    private static String ADD_COMMAND = "add";
    private static String REMOVE_COMMAND = "remove";
    private static String CLEAR_COMMAND = "clear";
    private DynamicTree treePanel;

    public DynamicTreeDemo() {
        super(new BorderLayout()); // Create the components.
        treePanel = new DynamicTree();
        populateTree(treePanel);
        JButton addButton = new JButton("Add");
        addButton.setActionCommand(ADD_COMMAND);
        addButton.addActionListener(this);
        JButton removeButton = new JButton("Remove");
        removeButton.setActionCommand(REMOVE_COMMAND);
        removeButton.addActionListener(this);
        JButton clearButton = new JButton("Clear");
        clearButton.setActionCommand(CLEAR_COMMAND);
        clearButton.addActionListener(this);  // Lay everything out.
        treePanel.setPreferredSize(new Dimension(300, 150));
        add(treePanel, BorderLayout.CENTER);
        JPanel panel = new JPanel(new GridLayout(0, 3));
        panel.add(addButton);
        panel.add(removeButton);
        panel.add(clearButton);
        add(panel, BorderLayout.SOUTH);
    }

    public void populateTree(DynamicTree treePanel) {
        String p1Name = "Parent 1";
        String p2Name = "Parent 2";
        String c1Name = "Child 1";
        String c2Name = "Child 2";
        DefaultMutableTreeNode p1, p2;
        p1 = treePanel.addObject(null, p1Name);
        p2 = treePanel.addObject(null, p2Name);
        treePanel.addObject(p1, c1Name);
        treePanel.addObject(p1, c2Name);
        treePanel.addObject(p2, c1Name);
        treePanel.addObject(p2, c2Name);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();
        if (ADD_COMMAND.equals(command)) { // Add button clicked
            treePanel.addObject("New Node " + newNodeSuffix++);
        } else if (REMOVE_COMMAND.equals(command)) { // Remove button clicked
            treePanel.removeCurrentNode();
        } else if (CLEAR_COMMAND.equals(command)) { // Clear button clicked.
            treePanel.clear();
        }
    }


    private static void createAndShowGUI() { // Create and set up the window.
        JFrame frame = new JFrame("DynamicTreeDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Create and set up the content pane.
        DynamicTreeDemo newContentPane = new DynamicTreeDemo();
        newContentPane.setOpaque(true); // content panes must be opaque
        frame.setContentPane(newContentPane);  // Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                createAndShowGUI();
            }
        });
    }
}


class DynamicTree extends JPanel {
    private static final long serialVersionUID = 1L;

    private DefaultMutableTreeNode rootNode;
    private DefaultTreeModel treeModel;
    private JTree tree;
    private Toolkit toolkit = Toolkit.getDefaultToolkit();

    public DynamicTree() {
        super(new GridLayout(1, 0));
        rootNode = new DefaultMutableTreeNode("Root Node");
        treeModel = new DefaultTreeModel(rootNode);
        treeModel.addTreeModelListener(new MyTreeModelListener());
        tree = new JTree(treeModel);
        tree.setEditable(true);
        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.setShowsRootHandles(true);
        JScrollPane scrollPane = new JScrollPane(tree);
        add(scrollPane);
    }

    public void clear() {
        rootNode.removeAllChildren();
        treeModel.reload();
    }

    public void removeCurrentNode() {
        TreePath currentSelection = tree.getSelectionPath();
        if (currentSelection != null) {
            DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) (currentSelection.getLastPathComponent());
            MutableTreeNode parent = (MutableTreeNode) (currentNode.getParent());
            if (parent != null) {
                treeModel.removeNodeFromParent(currentNode);
                return;
            }
        } // Either there was no selection, or the root was selected.
        toolkit.beep();
    }


    public DefaultMutableTreeNode addObject(Object child) {
        DefaultMutableTreeNode parentNode = null;
        TreePath parentPath = tree.getSelectionPath();
        if (parentPath == null) {
            parentNode = rootNode;
        } else {
            parentNode = (DefaultMutableTreeNode) (parentPath.getLastPathComponent());
        }
        return addObject(parentNode, child, true);
    }

    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent, Object child) {
        return addObject(parent, child, false);
    }

    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent, Object child, boolean shouldBeVisible) {
        DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
        if (parent == null) {
            parent = rootNode;
        }
        // It is key to invoke this on the TreeModel, and NOT DefaultMutableTreeNode
        treeModel.insertNodeInto(childNode, parent, parent.getChildCount());
        // Make sure the user can see the lovely new node.
        if (shouldBeVisible) {
            tree.scrollPathToVisible(new TreePath(childNode.getPath()));
        }
        return childNode;
    }



    class MyTreeModelListener implements TreeModelListener {

        @Override
        public void treeNodesChanged(TreeModelEvent e) {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) (e.getTreePath().getLastPathComponent());            /*
             * If the event lists children, then the changed node is the child of the
             * node we've already gotten. Otherwise, the changed node and the
             * specified node are the same.
             */ int index = e.getChildIndices()[0];
            node = (DefaultMutableTreeNode) (node.getChildAt(index));
            System.out.println("The user has finished editing the node.");
            System.out.println("New value NodesChanged: " + node.getUserObject());
        }

        @Override
        public void treeNodesInserted(TreeModelEvent e) {
            DefaultMutableTreeNode node= (DefaultMutableTreeNode) (e.getTreePath().getLastPathComponent());            /*
             * If the event lists children, then the changed node is the child of the
             * node we've already gotten. Otherwise, the changed node and the
             * specified node are the same.
             */ int index = e.getChildIndices()[0];
            node = (DefaultMutableTreeNode) (node.getChildAt(index));
            System.out.println("New value NodesInserted : " + node.getUserObject());
        }

        @Override
        public void treeNodesRemoved(TreeModelEvent e) {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) (e.getTreePath().getLastPathComponent());            /*
             * If the event lists children, then the changed node is the child of the
             * node we've already gotten. Otherwise, the changed node and the
             * specified node are the same.
             */ int index = e.getChildIndices()[0];
            node = (DefaultMutableTreeNode) (node.getChildAt(index));
            System.out.println("New value NodesRemoved : " + node.getUserObject());
        }

        @Override
        public void treeStructureChanged(TreeModelEvent e) {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) (e.getTreePath().getLastPathComponent());            /*
             * If the event lists children, then the changed node is the child of the
             * node we've already gotten. Otherwise, the changed node and the
             * specified node are the same.
             */ int index = e.getChildIndices()[0];
            node = (DefaultMutableTreeNode) (node.getChildAt(index));
            System.out.println("New value StructureChanged : " + node.getUserObject());
        }
    }
}

是否添加我。这对我有效。CustomTreeNode是从defaultMutableTreeNode扩展而来的，并添加了一个自写ChildLoadedListener，当工厂加载子对象时会调用该Listener。isExpanded布尔值是为了避免无休止的循环。
工厂创建一个SwingWorker来加载子项并执行它。然后调用ChillLoadedListener并再次展开树

希望这将有助于或至少有助于您思考您的问题；-）

编辑：

@Override
public void loadChildren(CustomTreeNode tn) {
    ctn = tn;
    LoadChildrenWorker worker = new LoadChildrenWorker();
    worker.execute();
}


private class LoadChildrenWorker extends SwingWorker<String, Object> {

            @Override
    protected String doInBackground() throws Exception {
                    //load source here and return a string when finished.
                    //In my case its a string repesentation of a directory
    }

    @Override
    protected void done() {
            //with get(), you get the string from doBackground()
            for (String str : parseFromOutput(get())) {
                    if (str.endsWith("/")) {
                        ctn.add(new CustomTreeNode("Directory");
                    } else {
                        ctn.add(new CustomTreeNode("Leaf");
                    }
            }
            //call listeners
            ctn.fireChildrenLoaded();
    }

@覆盖
公共无效加载子项（CustomTreeNode tn）{
ctn=tn；
LoadChildrenWorker=新的LoadChildrenWorker（）；
worker.execute（）；
}
私有类LoadChildrenWorker扩展SwingWorker{
@凌驾
受保护的字符串doInBackground（）引发异常{
//在此处加载源代码，完成后返回字符串。
//在我的例子中，它是目录的字符串表示
}
@凌驾
受保护的void done（）{
//使用get（），可以从doBackground（）获取字符串
for（字符串str:parseFromOutput（get（）））{
if（str.endsWith（“/”）{
ctn.add（新的CustomTreeNode（“目录”）；
}否则{
ctn.添加（新CustomTreeNode（“Leaf”）；
}
}
//呼叫侦听器
ctn.fireChildrenLoaded（）；
}
我认为这段代码没有任何作用，如果上面提到了一些内容，请您打印出TreeModel中的节点，如果没有线程，它似乎可以工作。如果我展开它们并在同一个线程中显示所有节点，它就可以工作。即使我没有这样做，我想它也不会工作：当折叠节点时，我不会删除内容。好了因此，当再次折叠和重新展开节点时，它应该是可见的。但事实并非如此。或者这是另一个不同的问题吗？我也有同样的问题。每次树打开时，它们都会加载子项。并且每次加载子项之前，它都会打开树。
System.out.println（）
是我们的朋友；-）（正如我以前的老师常说的）无意冒犯，但尽管您的解决方案似乎对您有效，但我认为这看起来像是一个丑陋的黑客行为？嗯……正如前面提到的：我有一个标志，确保子项只展开一次。它们将保留在列表中并返回……很抱歉造成了混淆。我问题中的代码片段是扩展DefaultMutableTr的类的一部分eNode
。因此，
add（）
执行父级，
DefaultMutableTreeNode
执行的操作。这就是问题所在。调用add（）时，DefaultMutableTreeNode不会触发事件。您需要通过模型添加节点，请参阅DefaultTreeModel#insertNodeInto（或手动触发正确的事件）。谢谢你的回复。你能给我看看你的
SwingWorker
的
finished（）
方法吗？我在迭代之前注册的侦听器时不知怎么得到了一个
ConcurrentModificationException
。非常感谢