递归、嵌套for循环、map集合方式实现树形结构菜单列表查询

有时候， 我们需要用到菜单列表，但是怎么样去实现一个菜单列表的编写呢，这是一重要的问题。

比如我们需要编写一个树形结构的菜单，那么我们可以使用JQuery的zTree插件：http://www.treejs.cn/v3/main.php#_zTreeInfo

例如现在需要编写一个这样的菜单列表。那么就可以使用JQuery的zTree插件。

先看一下数据库表结构。

CREATE TABLE `permission` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `pid` int(11) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

1、前端页面。

                <div class="panel-body">

                    <ul id="permissionTree" class="ztree"></ul>

                </div>

<script>
   $(function () {

       var setting = {
           async: {
               enable: true,
               url:"${APP_PATH}/permission/loadData",
               autoParam:["id", "name=n", "level=lv"],
               otherParam:{"otherParam":"zTreeAsyncTest"},
           }

       };

        //树形结构
       $.fn.zTree.init($("#permissionTree"), setting);
    });
</script>

2、在这里呢，我使用的是ssm框架。所以就提交到controller层来进行操作。

Permission类的代码

 import java.util.ArrayList;
 import java.util.List;

 public class Permission {

     private Integer id;
     private String name;
     private String url;
     private Integer pid;
     private boolean open = true;
     private boolean checked = false;
     private String icon;
     private List<Permission> children = new ArrayList<Permission>();

     public boolean isChecked() {
         return checked;
     }
     public void setChecked(boolean checked) {
         this.checked = checked;
     }
     public String getIcon() {
         return icon;
     }
     public void setIcon(String icon) {
         this.icon = icon;
     }
     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getUrl() {
         return url;
     }
     public void setUrl(String url) {
         this.url = url;
     }
     public Integer getPid() {
         return pid;
     }
     public void setPid(Integer pid) {
         this.pid = pid;
     }
     public boolean isOpen() {
         return open;
     }
     public void setOpen(boolean open) {
         this.open = open;
     }
     public List<Permission> getChildren() {
         return children;
     }
     public void setChildren(List<Permission> children) {
         this.children = children;
     }

 }

使用controller这里我使用三种方式来进行查找 。

　　（1）递归方式读取各节点

controller层

    /**
     * 异步加载树结点
     * @return
     */
    @RequestMapping("/loadData")
    @ResponseBody
    public List<Permission> loadData(){
        // 递归查询数据
    Permission parent = new Permission();
    parent.setId(0);
    queryChildPermissions(parent);
    return parent.getChildren();
    }
    /**
     * 递归查询许可信息
     * 1） 方法自己调用自己
     * 2）方法一定要存在跳出逻辑
     * 3）方法调用时，参数之间应该有规律
     * 4） 递归算法，效率比较低
     * @param parent
     */
    private  void queryChildPermissions(Permission parent){
        List<Permission> childPermissions = permissionService.queryChildPermissions(parent.getId());
        for (Permission permission :childPermissions) {
            queryChildPermissions(permission);
        }
        parent.setChildren(childPermissions);
    }

　service层

    public Permission queryRootPermission() {
        return permissionMapper.queryRootPermission();
    }

mappern层

    @Select("select * from permission where pid is null")
    Permission queryRootPermission();

　　（2）嵌套for循环方式读取各节点

controller层

     /**
      * 异步加载树结点
      * @return
      */
     @RequestMapping("/loadData")
     @ResponseBody
     public List<Permission> loadData(){
         List<Permission> permissions=new ArrayList<Permission>();
         // 查询所有的许可数据
         List<Permission> ps = permissionService.queryAll();
         for ( Permission p : ps ) {
             // 子节点
             Permission child = p;
             if ( p.getPid() == 0 ) {
                 permissions.add(p);
             } else {
                 for ( Permission innerPermission : ps ) {
                     if ( child.getPid().equals(innerPermission.getId()) ) {
                         // 父节点
                         Permission parent = innerPermission;
                         // 组合父子节点的关系
                         parent.getChildren().add(child);
                         break;
                     }
                 }
             }
         }

        return permissions;
     }

service层

    public List<Permission> queryAll() {
        return permissionMapper.queryAll();
    }

mapper层

    @Select("select * from permission")
    List<Permission> queryAll();

　　（3）map集合方式读取各节点

controller层

    /**
     * 异步加载树结点
     * @return
     */
    @RequestMapping("/loadData")
    @ResponseBody
    public List<Permission> loadData(){
        List<Permission> permissions=new ArrayList<Permission>();

        // 查询所有的许可数据
        List<Permission> ps = permissionService.queryAll();

        Map<Integer, Permission> permissionMap = new HashMap<Integer, Permission>();
        for (Permission p : ps) {
            permissionMap.put(p.getId(), p);
        }
        for ( Permission p : ps ) {
            Permission child = p;
            if ( child.getPid() == 0 ) {
                permissions.add(p);
            } else {
                Permission parent = permissionMap.get(child.getPid());
                parent.getChildren().add(child);
            }
        }
       return permissions;
    }

service层

    public List<Permission> queryAll() {
        return permissionMapper.queryAll();
    }

mapper层

    @Select("select * from permission")
    List<Permission> queryAll();

三种方法的总结 ：

使用递归会使数据库查询非常频繁，不能进行性能优化

使用嵌套for循环没有使用索引，不够快速

使用map集合就使用了索引，加快查询速度。