Fatal编程技术网
  • java/
  • 如何在java中从数据库中获取所有子类别

如何在java中从数据库中获取所有子类别

java mysql database jdbc

如何在java中从数据库中获取所有子类别,java,mysql,database,jdbc,relational-database,Java,Mysql,Database,Jdbc,Relational Database,我的数据库中有一个树状结构，如下所示 mysql> select * from categories; +----+---------------+-----------+ | id | category_name | parent_id | +----+---------------+-----------+ | 1 | footwear | -1 | | 2 | kids footwear | 1 | | 3 | for girls

我的数据库中有一个树状结构，如下所示

mysql> select * from categories;
+----+---------------+-----------+
| id | category_name | parent_id |
+----+---------------+-----------+
|  1 | footwear      |        -1 |
|  2 | kids footwear |         1 |
|  3 | for girls     |         2 |
|  4 | sandals       |         3 |
|  5 | electronics   |        -1 |
|  6 | kids          |        -1 |
+----+---------------+-----------+
6 rows in set (0.00 sec)
我想读取父类别的所有子类别，表中的-1将该类别显示为父类别或最上面的类别。树中可能有任何级别

一旦用户单击父类别（-1），我就需要显示它的所有子类别。我不想每次单击都再次访问数据库（&i）。 我有一些类似的想法，可以通过将表条目转换成树来实现&而不是遍历树，但是从表本身检索是一项困难的任务，这变得太复杂了

我从这个链接中得到了一些想法，可以用另一种方法（第二种方法） 但是在这个方法中，如果我想插入一个新的子类别，那么我必须修改整个表

还有其他建议吗？

好的，只有几种可行的方法：

  • 以广度优先的方式检索级别，例如通过多次执行查询。此查询可能一次检索多个级别。这就是我们为浅树所做的
  • 使用链接的实体化路径/嵌套集路径
  • 读取所有行并在代码中构建树，这可能是最简单的方法，对于小树仍然是可行的。对于大树，您可能会考虑一些缓存机制。
另一种方法可能是使用不同的数据库；）

您必须使用递归函数来处理此类问题

    public String findcategoryList() {
    List<Category> results = dao.findAllCategory();
    LinkedHashMap<String, List<String>> map = new LinkedHashMap();
    LinkedHashMap<Integer, List<Integer>> mapKey = new LinkedHashMap();
    for (Object object : results) {
        Category ee = (Category) object;
        Set<Category> stsd = ee.getSubCategories();

        if (stsd != null && stsd.size() > 0 && ee.getCategory() == null) {
            dispaly(stsd, ee, map, mapKey);
        } else if (ee.getCategory() == null) {
            List<String> list = new ArrayList<String>();
            List<Integer> listKey = new ArrayList<Integer>();
            map.put(ee.getCategoryname(), list);
            mapKey.put(ee.getCategoryId(), listKey);
            System.out.println(ee.getCategoryname() + "---- No Child");
            System.out.println(ee.getCategoryId() + "---- No Child");
        }
    }

    StringBuilder menu = new StringBuilder();
    System.out.println("------------------Menu Start----------------");
    Set<String> keys = new TreeSet<String>(map.keySet());
    menu.append("<ul class='drop'>");

    Set<String> sets = new HashSet<String>();
    if(map.size() == mapKey.size()){
        Iterator<Entry<String, List<String>>> iter1 = map.entrySet().iterator();
        Iterator<Entry<Integer, List<Integer>>> iter2 = mapKey.entrySet().iterator();
        while(iter1.hasNext() || iter2.hasNext()) {
              Entry<String, List<String>> e1 = iter1.next();
              Entry<Integer, List<Integer>> e2 = iter2.next();
              String key = e1.getKey();
              List<String> child = map.get(key);
              Integer keyId = e2.getKey();
              List<Integer> childKey = mapKey.get(keyId);

        if (!sets.contains(key)) {
            System.out.println("key : "+key);
            if (child != null && child.size() > 0) {
                menu.append("<li><a href='#'>").append(key).append("<i class='fa fa-caret-down'></i></a>");
                menu.append("\n");
                menu.append("<ul class='sub_menu submenu'>");
                menu.append("\n");
            }else{
                menu.append("<li><a href='./viewVideos-"+keyId+"'>").append(key).append("<i class='fa fa-caret-down'></i></a>");
                menu.append("\n");
            }
            sets.add(key);
            menuCreate(menu, child, childKey, map, mapKey, sets);
            if (child != null && child.size() > 0) {
                menu.append("</ul>");
                menu.append("\n");
            }
             menu.append("</li>");
        }
    }
        }
    menu.append("</ul>");
    //System.out.println(menu.toString());
    return menu.toString();
}

    public static void menuCreate(StringBuilder menu, List<String> child, List<Integer> childKey, Map<String, List<String>> map,
        Map<Integer, List<Integer>> mapKey,
        Set<String> sets) {
    if (child != null && child.size() > 0) {
        // Collections.sort(child, ComparatorUtils.NATURAL_COMPARATOR);
        for (int i=0;i<child.size();i++) {
            List<String> subChild = map.get(child.get(i));
            List<Integer> subChildKey = mapKey.get(childKey.get(i));
            System.out.println("subChild : "+subChild+ " child : " + child + " Value : " + child.get(i));
            menu.append("<li>");
            boolean flag = false;
            if (subChild == null || (child != null && child.size() <= 0)) {
                menu.append("<a href='./viewVideos-"+childKey.get(i)+"'>");
                flag = true;
            }
            if(flag){
                menu.append(child.get(i)).append("<i class='fa fa-caret-right'></i>");
                menu.append("</a>");
            }else{
                menu.append("<a href='#'>").append(child.get(i)).append("<i class='fa fa-caret-right'></i></a>");
            }
            menu.append("\n");
            if (subChild != null && subChild.size() > 0) {
                if (!sets.contains(child.get(i))) {
                    sets.add(child.get(i));
                    menu.append("<ul class='sub_menu submenu'>");
                    menu.append("\n");
                    menuCreate(menu, subChild, subChildKey, map, mapKey, sets);
                    menu.append("</ul>");
                    menu.append("\n");
                }
            }
            menu.append("</li>");
        }
    }
}

    public void dispaly(Set<Category> msp, Category ee, Map<String, List<String>> map, Map<Integer, List<Integer>> mapKey) {
    for (Category category : msp) {
        Set<Category> stsd = category.getSubCategories();
        if (category.getCategory() != null) {
            if (map.get(category.getCategory().getCategoryname()) == null) {
                List<String> list = new ArrayList<String>();
                List<Integer> listKey = new ArrayList<Integer>();
                list.add(category.getCategoryname());
                listKey.add(category.getCategoryId());
                map.put(category.getCategory().getCategoryname(), list);
                mapKey.put(category.getCategory().getCategoryId(), listKey);
            } else {
                List<String> list = map.get(category.getCategory().getCategoryname());
                List<Integer> listKey = mapKey.get(category.getCategory().getCategoryId());
                list.add(category.getCategoryname());
                listKey.add(category.getCategoryId());
                map.put(category.getCategory().getCategoryname(), list);
                mapKey.put(category.getCategory().getCategoryId(), listKey);
            }

            System.out.println(category.getCategory().getCategoryname() + "----" + category.getCategoryname());
            System.out.println(category.getCategory().getCategoryId() + "----" + category.getCategoryId());
        }
        if (stsd != null && stsd.size() > 0) {
            dispaly(stsd, category, map, mapKey);
        }
    }

公共字符串findcategoryList（）{
List results=dao.findAllCategory（）；
LinkedHashMap=新建LinkedHashMap（）；
LinkedHashMap mapKey=新建LinkedHashMap（）；
用于（对象：结果）{
类别ee=（类别）对象；
设置stsd=ee.getSubCategories（）；
if（stsd！=null&&stsd.size（）>0&&ee.getCategory（）==null）{
显示（STD、ee、map、mapKey）；
}else if（ee.getCategory（）==null）{
列表=新的ArrayList（）；
List listKey=new ArrayList（）；
put（ee.getCategoryname（），list）；
put（ee.getCategoryId（），listKey）；
System.out.println（ee.getCategoryname（）+“----无子项”）；
System.out.println（ee.getCategoryId（）+“----无子项”）；
}
}
StringBuilder菜单=新建StringBuilder（）；
System.out.println（“--------------菜单开始--------------------”；
Set keys=new TreeSet（map.keySet（））；
菜单.追加（“
    ”）；
Set Set=新的HashSet（）；
if（map.size（）==mapKey.size（））{
迭代器iter1=map.entrySet（）.Iterator（）；
迭代器iter2=mapKey.entrySet（）.Iterator（）；
while（iter1.hasNext（）| | iter2.hasNext（））{
条目e1=iter1.next（）；
条目e2=iter2.next（）；
字符串key=e1.getKey（）；
List child=map.get（key）；
整数keyId=e2.getKey（）；
List childKey=mapKey.get（keyId）；
如果（！set.contains（键））{
System.out.println（“key:+key”）；
if（child！=null&&child.size（）>0）{
菜单。追加（“
  • ”）；
菜单。追加（“\n”）；
菜单。追加（“
      ”）；
菜单。追加（“\n”）；
}否则{
菜单。追加（“
    • ”）；
菜单。追加（“\n”）；
}
集合。添加（键）；
菜单创建（菜单、子项、子项、映射、映射键、集合）；
if（child！=null&&child.size（）>0）{
菜单。追加（“
    ”）；
菜单。追加（“\n”）；
}
菜单。追加（“
    • ”）；
}
}
}
菜单。追加（“
”）；
//System.out.println（menu.toString（））；
return menu.toString（）；
}
公共静态void菜单创建（StringBuilder菜单、列表子项、列表子项键、映射、，
mapKey，
（套）{
if（child！=null&&child.size（）>0）{
//Collections.sort（child、ComparatorUtils.NATURAL\u COMPARATOR）；
对于（int i=0；i 0）{
显示（标准差分、类别、地图、地图键）；
}
}
menu.toString（）将为您提供html格式的树栏。

@Neel？？English please…：）使用嵌套集方法确实可以在单个查询中完成此操作。如果父/子级别的数量非常有限，则可以为每个级别执行联接，因此仅使用单个查询。否则，您将不得不读取所有记录并执行一些com操作请注意，按照惯例，我们对邻接列表中的孤立项使用NULL。