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

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

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

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

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

下面是导入的maven依赖

org.springframework.boot

spring-boot-starter-web

com.alibaba

druid-spring-boot-starter

1.1.21

mysql

mysql-connector-java

com.baomidou

mybatis-plus-boot-starter

3.4.0

org.projectlombok

lombok

true

cn.hutool

hutool-all

5.0.6

下面是实体类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 children = new ArrayList();

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 VExKXlrYList build(List treeNodes, String root) {

List 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 buildTree(List permissionList, String root) {

System.out.println(Arrays.toString(permissionList.toArray()));

List 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

*/

@ToString

@NoArgsConstructor

@AllArgsConstructor

@Accessors(chain = true)

public class R 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 R ok() {

return restResult(null, CommonConstants.SUCCESS, CommonConstants.MSG_SUCCESS);

}

public static R ok(T data) {

return restResult(data, CommonConstants.SUCCESS, CommonConstants.MSG_SUCCESS);

}

public static R ok(T data, String msg) {

return restResult(data, CommonConstants.SUCCESS, msg);

}

public static R failed() {

return restResult(null, CommonConstants.FAIL, null);

}

public static R failed(String msg) {

return restResult(null, CommonConstants.FAIL, msg);

}

public static R failed(T data) {

return restResult(data, CommonConstants.FAIL, null);

}

public static R failed(T data, String msg) {

return restResult(data, CommonConstants.FAIL, msg);

}

private static R restResult(T data, int code, String msg) {

R apiResult = new R<>();

apiResult.setCode(code);

apiResult.setData(data);

apiResult.setMsg(msg);

return apiResult;

}

}

数据查询接口mapper类

@Mapper

public interface PermissionMapper extends BaseMapper{

}

数据逻辑处理业务接口

public interface PermissionService extends IService {

/**

* 构建权限树

*

* @param lazy

* @param parentId

* @return

*/

List treePermission(boolean lazy, String parentId);

}

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

@Service

public class PermissionServiceImpl extends ServiceImpl implements PermissionService {

/**

* 构建权限树：1、不是懒加载情况，查询全部

* 2、是懒加载，根据parentIdVExKXlrY查询

*

* @param lazy

* @param parentId

* @return

*/

@Override

public List treePermission(boolean lazy, String parentId) {

if (!lazy) {

return TreeUtil.buildTree(

baseMapper.selectList(Wrappers.lambdaQuery().orderByAsc(Permission::getSort)),

CommonConstants.PERMISSION_ROOT_ID);

}

String parent = parentId == null ? CommonConstants.PERMISSION_ROOT_ID : parentId;

return TreeUtil.buildTree(

baseMapper.selectList(Wrappers.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

}

]

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。