springboot构造树形结构数据并查询的方法

更新时间：2021年11月01日 12:01:25 作者：qzxl

本文主要介绍了springboot怎样构造树形结构数据并查询，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

因为项目需要，页面上需要树形结构的数据进行展示（类似下图这样），因此需要后端返回相应格式的数据。

在这里插入图片描述

不说废话，直接开干！！！

我这里用的是springboot+mybatis-plus+mysql，示例的接口是查询一级权限以及二级权限、三级权限整个权限树…

下面是导入的maven依赖

 		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--数据库连接-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>
 
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis增强工具-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
  		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.0.6</version>
        </dependency>

下面是实体类Permission

@Data
public class Permission implements Serializable {
    @TableId
    private String permissionId;
    @NotNull(message = "权限名称不能为空")
    private String permissionName;
    /**
     * 权限标识
     */
    @NotNull(message = "权限标识不能为空")
    private String permissionCode;
    /**
     * 父菜单ID，如果是-1就表示是一级权限菜单。
     */
    @NotBlank(message = "父菜单ID不能为空")
    private String parentId;

    /**
     * 前端URL访问接口路径
     */
    private String path;

    /**
     * 排序值
     */
    private Integer sort;
    /**
     * 创建时间
     */

    private LocalDateTime createTime;

    /**
     * 更新时间
     */

    private LocalDateTime updateTime;

    /**
     * 0--正常 1--删除
     */
    private String delFlag;

    public Permission() {
        this.permissionId = IdUtil.simpleUUID();
    }

树形结点类

@Data
public class TreeNode {
    protected String id;
    protected String parentId;
    protected List<TreeNode> children = new ArrayList<TreeNode>();
    protected boolean hasChildren;

   public void addTreeNode(TreeNode node){
       children.add(node);
   }
}

树形结点详细信息类

@Data
@EqualsAndHashCode(callSuper = true)
public class PermissionTree extends TreeNode implements Serializable {
    private String permissionName;
    private String permissionCode;
    private String path;
    private Integer sort;
    private String label;
    private boolean hasChildren;
    public PermissionTree() {
    }
}

构建树形结点工具类（关键），在这里我用@UtilityClass注解就表示这个类中的方法都是静态方法：

@UtilityClass
public class TreeUtil {


    public <T extends TreeNode> List<T> build(List<T> treeNodes, String root) {
        List<T> trees = new ArrayList<>();
        for (T treeNode : treeNodes) {

            if (root.equals(treeNode.getParentId())) {
                trees.add(treeNode);
            }

            for (T node : treeNodes) {
                if (node.getParentId().equals(treeNode.getId())) {
                    treeNode.addTreeNode(node);
                    treeNode.setHasChildren(true);

                }
            }
        }
        return trees;
    }


    /**
     * 通过permission创建树形节点
     *
     * @param permissionList
     * @param root
     * @return
     */
    public List<PermissionTree> buildTree(List<Permission> permissionList, String root) {
        System.out.println(Arrays.toString(permissionList.toArray()));
        List<PermissionTree> treeNodeList = new ArrayList<>();
        PermissionTree treeNode = null;
        for (Permission permission : permissionList) {
            treeNode = new PermissionTree();
            treeNode.setId(permission.getPermissionId());
            treeNode.setPermissionName(permission.getPermissionName());
            treeNode.setPath(permission.getPath());
            treeNode.setSort(permission.getSort());
            treeNode.setParentId(permission.getParentId());
            treeNode.setLabel(permission.getPermissionName());
            treeNode.setHasChildren(false);
            treeNodeList.add(treeNode);
        }
        return TreeUtil.build(treeNodeList, root);
    }
  }

响应消息主体类

/**
 * 响应信息主体
 *
 * @param <T>
 */
@ToString
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class R<T> implements Serializable {

	private static final long serialVersionUID = 1L;

	private int code;

	private String msg;

	private T data;

	public int getCode() {
		return code;
	}

	public void setCode(int code) {
		this.code = code;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}

	public static <T> R<T> ok() {
		return restResult(null, CommonConstants.SUCCESS, CommonConstants.MSG_SUCCESS);
	}

	public static <T> R<T> ok(T data) {
		return restResult(data, CommonConstants.SUCCESS, CommonConstants.MSG_SUCCESS);
	}

	public static <T> R<T> ok(T data, String msg) {
		return restResult(data, CommonConstants.SUCCESS, msg);
	}

	public static <T> R<T> failed() {
		return restResult(null, CommonConstants.FAIL, null);
	}

	public static <T> R<T> failed(String msg) {
		return restResult(null, CommonConstants.FAIL, msg);
	}

	public static <T> R<T> failed(T data) {
		return restResult(data, CommonConstants.FAIL, null);
	}

	public static <T> R<T> failed(T data, String msg) {
		return restResult(data, CommonConstants.FAIL, msg);
	}

	private static <T> R<T> restResult(T data, int code, String msg) {
		R<T> apiResult = new R<>();
		apiResult.setCode(code);
		apiResult.setData(data);
		apiResult.setMsg(msg);
		return apiResult;
	}
}

数据查询接口mapper类

@Mapper
public interface PermissionMapper extends BaseMapper<Permission>{
    
}

数据逻辑处理业务接口

public interface PermissionService extends IService<Permission> {
  

    /**
     * 构建权限树
     *
     * @param lazy
     * @param parentId
     * @return
     */
    List<PermissionTree> treePermission(boolean lazy, String parentId);
}

数据逻辑处理业务接口实现类

@Service
public class PermissionServiceImpl extends ServiceImpl<PermissionMapper, Permission> implements PermissionService {
/**
     * 构建权限树：1、不是懒加载情况，查询全部
     * 2、是懒加载，根据parentId查询
     *
     * @param lazy
     * @param parentId
     * @return
     */

    @Override
    public List<PermissionTree> treePermission(boolean lazy, String parentId) {

        if (!lazy) {
            return TreeUtil.buildTree(
                    baseMapper.selectList(Wrappers.<Permission>lambdaQuery().orderByAsc(Permission::getSort)),
                    CommonConstants.PERMISSION_ROOT_ID);
        }
        String parent = parentId == null ? CommonConstants.PERMISSION_ROOT_ID : parentId;
        return TreeUtil.buildTree(
                baseMapper.selectList(Wrappers.<Permission>lambdaQuery().eq(Permission::getParentId, parent).orderByAsc(Permission::getSort)), parent
        );
    }
}

查询权限树请求接口类

@RestController
@RequestMapping("/permission")
public class PermissionController {
    @Autowire
    private PermissionService permissionService;

    /**
     * 查询权限列表，并以树状结构显示
     *
     * @param lazy 懒加载: false时, parentId这个参数失效, 加载所有的权限; true时, 根据parentId加载
     * @param parentId
     * @return
     */
    @RequestMapping(value = "/getTree", method = RequestMethod.GET)
    public R getTree(boolean lazy, String parentId) {
        return R.ok(permissionService.treePermission(lazy, parentId));
    }
 }

表中测试数据如下（注意它的parent_id）

在这里插入图片描述

测试一：不是懒加载，查询整个权限树。 结果如下。

在这里插入图片描述

{
    "code": 0,
    "msg": "SUCCESS",
    "data": [
        {
            "id": "1",
            "parentId": "-1",
            "children": [
                {
                    "id": "2",
                    "parentId": "1",
                    "children": [
                        {
                            "id": "3",
                            "parentId": "2",
                            "children": [],
                            "hasChildren": false,
                            "permissionName": "update",
                            "permissionCode": null,
                            "path": null,
                            "sort": 3,
                            "label": "update",
                            "owned": false
                        },
                        {
                            "id": "4",
                            "parentId": "2",
                            "children": [],
                            "hasChildren": false,
                            "permissionName": "insert_role",
                            "permissionCode": null,
                            "path": null,
                            "sort": 4,
                            "label": "insert_role",
                            "owned": false
                        }
                    ],
                    "hasChildren": true,
                    "permissionName": "delete",
                    "permissionCode": null,
                    "path": null,
                    "sort": 2,
                    "label": "delete",
                    "owned": false
                }
            ],
            "hasChildren": true,
            "permissionName": "add",
            "permissionCode": null,
            "path": null,
            "sort": 1,
            "label": "add",
            "owned": false
        },
        {
            "id": "5",
            "parentId": "-1",
            "children": [],
            "hasChildren": false,
            "permissionName": "role:saveRole",
            "permissionCode": null,
            "path": "/role/saveRole",
            "sort": 5,
            "label": "role:saveRole",
            "owned": false
        }
    ]
}

测试二：是懒加载，根据parent_id查询当前分支。 结果如下。

在这里插入图片描述

{
    "code": 0,
    "msg": "SUCCESS",
    "data": [
        {
            "id": "3",
            "parentId": "2",
            "children": [],
            "hasChildren": false,
            "permissionName": "update",
            "permissionCode": null,
            "path": null,
            "sort": 3,
            "label": "update",
            "owned": false
        },
        {
            "id": "4",
            "parentId": "2",
            "children": [],
            "hasChildren": false,
            "permissionName": "insert_role",
            "permissionCode": null,
            "path": null,
            "sort": 4,
            "label": "insert_role",
            "owned": false
        }
    ]
}

到此这篇关于springboot构造树形结构数据并查询的方法的文章就介绍到这了,更多相关springboot 树形结构并查询内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java静态方法不具有多态性详解
下面小编就为大家带来一篇Java静态方法不具有多态性详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2016-06-06
python 与HFSS联合仿真的教程讲解
这篇文章主要介绍了python 与HFSS联合仿真的教程讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-03-03
MyBatis-Plus实现条件查询的三种格式例举详解
本文主要介绍了MyBatis-Plus三中条件查询格式的示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-08-08
解决SpringBoot内嵌Tomcat并发容量的问题
这篇文章主要介绍了解决SpringBoot内嵌Tomcat并发容量的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-06-06
SpringBoot获取客户端的IP地址的实现示例
在Web应用程序中,获取客户端的IP地址是一项非常常见的需求,本文主要介绍了SpringBoot获取客户端的IP地址的实现示例,具有一定的参考价值,感兴趣的可以了解一下
2023-09-09
学习java多线程
本文运用了大量的代码讲解了java多线程，它可以提高程序并行执行的速度，更快的响应程序。感兴趣的小伙伴一起来看看吧
2021-08-08
Springboot swagger配置过程详解(idea社区版2023.1.4+apache-maven-3
这篇文章主要介绍了Springboot-swagger配置(idea社区版2023.1.4+apache-maven-3.9.3-bin),本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2023-07-07
JVM Metaspace内存溢出问题解决方案
这篇文章主要介绍了JVM Metaspace内存溢出排查总结过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-11-11
Java中SpringBoot的TCC事务详解
这篇文章主要介绍了Java中SpringBoot的TCC事务详解,近年来，随着微服务架构的普及，TCC 事务成为了一种非常流行的分布式事务解决方案,在 Spring Boot 中，我们可以很容易地使用 TCC 事务来管理分布式事务,需要的朋友可以参考下
2023-07-07
Lombok的详细使用及优缺点总结
最近在学Mybatis，接触到了Lombok的使用，所以写一篇文章记录一下，包括lombok的安装及使用优缺点，感兴趣的朋友跟随小编一起看看吧
2021-07-07

springboot构造树形结构数据并查询的方法

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具