Java JPersistentTree（JTree，boundtree）将路径扩展到给定节点

我试图使用来实现商店类别上的CRUD操作。我不知道在哪里可以找到有使用这个软件包经验的人，所以我决定在这里询问

我想添加一个快速搜索选项，用户可以在其中搜索类别而无需浏览树，所选路径和节点在JTree上展开

到目前为止，我已经做了以下工作：

ArrayList<FpsInventoryCategory> path;

    // recursive method to find the path to the root of a selected node
    private void findTreePath(FpsInventoryCategory currentNode) throws StorageException{
        Object parentId = currentNode.getParentId();
        FpsInventoryCategory parentNode = (FpsInventoryCategory) store.getItem(parentId);
        if (parentNode.isRoot()){
            path.add(0, parentNode);
        } else {
            path.add(0, parentNode);
            findTreePath(parentNode);
        }

    }

ArrayList路径；
//查找选定节点根的路径的递归方法
私有void findTreePath（FpsInventoryCategory currentNode）引发StorageException{
对象parentId=currentNode.getParentId（）；
FpsInventoryCategory父节点=（FpsInventoryCategory）store.getItem（parentId）；
if（parentNode.isRoot（））{
添加路径（0，父节点）；
}否则{
添加路径（0，父节点）；
findTreePath（父节点）；
}
}

FPS InventoryCategory实现HierarchicalItem。path是InventoryCategory的数组列表。这很有效，我能够得到想要的路径

我遇到的问题是理解包，以便确定如何扩展节点和/或树路径。我最初尝试通过树路径，但后来意识到，由于JPersistentTree的整个思想是动态加载数据，因此JTree不会有超过第一行子级的数据。这是正确的假设吗

如果是这样，那么我假设我必须沿着我尝试的路径加载孩子们，如下所示：

private void viewTreeNodeAndPath(Long id2) throws StorageException {
        // TODO Auto-generated method stub
gui.getTreeInventoryCategory().getModel().getRoot();
            path = new ArrayList<FpsInventoryCategory>();
            store = gui.getStore();
            FpsInventoryCategory startNode = (FpsInventoryCategory) store.getItem(id);
            path.add(startNode);
            findTreePath(startNode);
            DynamicTreeNode currentTreeNode;
            Iterator it = path.iterator();
            int i = 0;
            FpsInventoryCategory temp;
            while(it.hasNext()){
                temp = (FpsInventoryCategory) it.next();
                System.out.println("temp cat:" + temp.getName());
                currentTreeNode = new DynamicTreeNode(store, temp);
                currentTreeNode.loadChildren();
                gui.getTreeInventoryCategory().expandRow(i);
                i++;
            }

//      selectedTreePath = new TreePath(dynamicNodePath);
//      System.out.println(selectedTreePath);
//      gui.getTreeInventoryCategory().setSelectionPath(selectedTreePath);
//      
//      gui.getTreeInventoryCategory().expandPath(selectedTreePath);

    }

private void viewTreeNodeAndPath（长id2）引发StorageException{
//TODO自动生成的方法存根
getTreeInventoryCategory（）.getModel（）.getRoot（）；
路径=新的ArrayList（）；
store=gui.getStore（）；
FpsInventoryCategory startNode=（FpsInventoryCategory）store.getItem（id）；
add（startNode）；
findTreePath（startNode）；
动态三极管；
Iterator it=path.Iterator（）；
int i=0；
库存类别温度；
while（it.hasNext（））{
temp=（FpsInventoryCategory）it.next（）；
System.out.println（“temp cat:+temp.getName（））；
currentTreeNode=新的DynamicTreeNode（存储、温度）；
currentTreeNode.loadChildren（）；
gui.getTreeInventoryCategory（）.expandRow（i）；
i++；
}
//selectedTreePath=新树路径（DynamicDepath）；
//System.out.println（selectedTreePath）；
//gui.getTreeInventoryCategory（）.setSelectionPath（selectedTreePath）；
//      
//gui.getTreeInventoryCategory（）.expandPath（selectedTreePath）；
}

^注释掉按路径选择的内容，因为它不产生结果。这同样不起作用

你知道我怎样才能让树扩大吗？或者我在哪里可以得到更多关于这件事的信息

请随时给我建议或让我知道我在哪里可以找到解决方案

---

致以最诚挚的问候。

好的。。。让它发挥作用。这是密码。在编码之间做了一些其他的事情，所以可能会遗漏一两件事

我将首先提到关键字段（全局变量），然后指出相关的方法。这是一个控制器，MVC模式

private FpsInventoryCategoryTreeAdapter store;
    ArrayList<FpsInventoryCategory> path;
    TreePath selectedTreePath;
    private Long id;

// expand path and select node in JPersistentTree of category being searched
    private void viewTreeNodeAndPath() throws StorageException {
        // TODO Auto-generated method stub
        path = new ArrayList<FpsInventoryCategory>();
        store = gui.getStore(); // get store from gui (view contains HierarchicalDataStore implementation for JPersistentTree)
        FpsInventoryCategory startNode = (FpsInventoryCategory) store.getItem(id);  // id is the selected node as per quick search
        path.add(startNode);    // add selected node to path
        // find path from root to selected node
        findTreePath(startNode);
        int pathLength = path.size(); 
        TreeModel model = gui.getTreeInventoryCategory().getModel();
        DynamicTreeNode rootNode = (DynamicTreeNode) model.getRoot();
        // traverse through JPersistentTree from root to searched node, returning path to selectedTreePath
        searchThroughTree(model, rootNode, pathLength, 1);
        // expand selectedTreePath (from root to searched node)
        gui.getTreeInventoryCategory().setSelectionPath(selectedTreePath);
        gui.getTreeInventoryCategory().scrollPathToVisible(selectedTreePath);
    }

    // recursive method to find the path to the root of a selected node
    private void findTreePath(FpsInventoryCategory currentNode) throws StorageException{
        Object parentId = currentNode.getParentId();
        FpsInventoryCategory parentNode = (FpsInventoryCategory) store.getItem(parentId);
        if (parentNode.isRoot()){
            path.add(0, parentNode);
        } else {
            path.add(0, parentNode);
            findTreePath(parentNode);
        }

    }

    // recusrive method to get TreePath of searched node
    // pathSize: number of nodes from root to searched path
    // pathPosition: index of current node in path
    private void searchThroughTree(TreeModel model, DynamicTreeNode rootNode, int pathSize, int pathPosition){
        int childCount = model.getChildCount(rootNode);
        for (int i = 0; i < childCount; i++){
            DynamicTreeNode childNode = (DynamicTreeNode) model.getChild(rootNode, i);
            if (model.isLeaf(childNode)){
                if (path.get(pathPosition).getId() == childNode.getUserObject().getId()){
                    selectedTreePath = getPath(childNode);
                    break;
                }
            } else {
                if (path.get(pathPosition).getId() == childNode.getUserObject().getId()){
                    if (pathPosition + 1 == pathSize){
                        selectedTreePath = getPath(childNode);
                        break;
                    } else {
                        pathPosition = pathPosition + 1;
                        searchThroughTree(model, childNode, pathSize, pathPosition);
                    }   
                }
            }
        }
    }

    // find path from root to node
    public TreePath getPath(DynamicTreeNode node){
        List list = new ArrayList();
        // Add all nodes to list
        while (node != null){
            list.add(node);
            node = (DynamicTreeNode) node.getParent();
        }
        Collections.reverse(list);
        // Convert array of DynamicTreeNodes to TreePath
        return new TreePath(list.toArray());
    }

私有FPS InventoryCategoryTreeAdapter存储；
阵列列表路径；
树路径选择树路径；
私人长id；
//展开路径并选择正在搜索的类别树中的节点
私有void viewTreeNodeAndPath（）引发StorageException{
//TODO自动生成的方法存根
路径=新的ArrayList（）；
store=gui.getStore（）；//从gui获取存储（视图包含JPersistentTree的HierarchycalDatastore实现）
FpsInventoryCategory startNode=（FpsInventoryCategory）store.getItem（id）；//id是根据快速搜索选择的节点
path.add（startNode）；//将所选节点添加到路径
//查找从根到选定节点的路径
findTreePath（startNode）；
int path length=path.size（）；
TreeModel model=gui.getTreeInventoryCategory（）.getModel（）；
DynamicTreeNode rootNode=（DynamicTreeNode）model.getRoot（）；
//从根遍历JPersistentTree到搜索节点，将路径返回到selectedTreePath
searchThroughTree（模型，根节点，路径长度，1）；
//展开selectedTreePath（从根节点到搜索节点）
gui.getTreeInventoryCategory（）.setSelectionPath（selectedTreePath）；
gui.getTreeInventoryCategory（）.scrollPathToVisible（selectedTreePath）；
}
//查找选定节点根的路径的递归方法
私有void findTreePath（FpsInventoryCategory currentNode）引发StorageException{
对象parentId=currentNode.getParentId（）；
FpsInventoryCategory父节点=（FpsInventoryCategory）store.getItem（parentId）；
if（parentNode.isRoot（））{
添加路径（0，父节点）；
}否则{
添加路径（0，父节点）；
findTreePath（父节点）；
}
}
//获取搜索节点树状图的递归方法
//pathSize：从根到搜索路径的节点数
//pathPosition:路径中当前节点的索引
私有void searchthThroughtree（树模型、DynamicTreeNode根节点、int路径大小、int路径位置）{
int childCount=model.getChildCount（rootNode）；
for（int i=0；i