F1-1: 按权限裁剪菜单树 GET /api/menu

- 新增 MenuService:纯函数树构建+自底向上剪枝逻辑(单测友好)
- 新增 MenuController:JdbcTemplate 直查三张表,通过 UserSession 取当前
  用户(与 PickerController 同口径,不新增模块依赖),无菜单返回空 roots
- 叶子节点 templateId = view_templateid,目录节点 templateId=null,
  每层按 seq 升序,无可见菜单的 root 不下发
- MenuServiceTest 8 个用例覆盖树构建、剪枝、排序、边界场景
- SQL 全参数化(userid = ?),不带 schema 前缀

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
2026-06-11 20:13:33 +08:00
parent d137577759
commit 1b4f393d20
3 changed files with 512 additions and 0 deletions

View File

@@ -0,0 +1,133 @@
package com.eip4.platform.metadata.menu;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
/**
* 菜单树构建与按权限剪枝的纯逻辑服务(无 Spring 依赖,便于单测)。
*
* <p>算法:
* <ol>
* <li>从数据库平铺行构建 sys_menu_root → 目录/叶子两级 Map;</li>
* <li>按用户可见叶子集合自底向上剪枝(目录层:子树内存在可见叶子才保留);</li>
* <li>没有可见菜单的 root 不下发。</li>
* </ol>
*
* <p>所有数据行由调用方({@link MenuController})以 JDBC 平铺 List 传入,本类不持有任何 bean。
*/
public class MenuService {
/**
* 构建按权限裁剪后的菜单根节点列表。
*
* @param roots sys_menu_root 全量平铺行,每行含 id / name / seq
* @param menus sys_menu isactive=1 全量平铺行,每行含 id / name / parentid / menuroot / view_templateid / typename / seq
* @param visibleMenuIds 当前用户可见的叶子菜单 id 集合(来自 view_sys_usermenuid)
* @return 裁剪后的根节点树,已按 seq 排序,没有可见子节点的根不包含在内
*/
public List<Map<String, Object>> buildTree(
List<Map<String, Object>> roots,
List<Map<String, Object>> menus,
Set<String> visibleMenuIds) {
// 按 rootId 分桶:目录节点(parentid 为空/null)和叶子节点(parentid 非空)
// 数据模型:sys_menu 两层——parentid 为空则挂 menuroot;parentid 非空则挂父目录
Map<String, List<Map<String, Object>>> dirsByRoot = new LinkedHashMap<>(); // rootId -> 目录列表
Map<String, List<Map<String, Object>>> leavesByParent = new LinkedHashMap<>(); // parentid -> 叶子列表
for (Map<String, Object> menu : menus) {
String parentId = trim(menu.get("parentid"));
String rootId = trim(menu.get("menuroot"));
if (parentId == null || parentId.isEmpty()) {
// 目录层:直接挂 root
dirsByRoot.computeIfAbsent(rootId, k -> new ArrayList<>()).add(menu);
} else {
// 叶子层:挂父目录
leavesByParent.computeIfAbsent(parentId, k -> new ArrayList<>()).add(menu);
}
}
List<Map<String, Object>> result = new ArrayList<>();
for (Map<String, Object> root : roots) {
String rootId = trim(root.get("id"));
List<Map<String, Object>> dirs = dirsByRoot.getOrDefault(rootId, List.of());
// 为每个目录节点构建叶子列表(只保留可见叶子)
List<Map<String, Object>> visibleDirs = new ArrayList<>();
for (Map<String, Object> dir : dirs) {
String dirId = trim(dir.get("id"));
List<Map<String, Object>> leaves = leavesByParent.getOrDefault(dirId, List.of());
// 按可见集合过滤叶子
List<Map<String, Object>> visibleLeaves = leaves.stream()
.filter(leaf -> visibleMenuIds.contains(trim(leaf.get("id"))))
.sorted((a, b) -> compareSeq(a.get("seq"), b.get("seq")))
.map(leaf -> buildLeafNode(leaf))
.collect(Collectors.toList());
if (!visibleLeaves.isEmpty()) {
Map<String, Object> dirNode = new LinkedHashMap<>();
dirNode.put("id", dirId);
dirNode.put("name", trim(dir.get("name")));
dirNode.put("templateId", null);
dirNode.put("typename", trim(dir.get("typename")));
dirNode.put("seq", dir.get("seq"));
dirNode.put("children", visibleLeaves);
visibleDirs.add(dirNode);
}
}
if (!visibleDirs.isEmpty()) {
visibleDirs.sort((a, b) -> compareSeq(a.get("seq"), b.get("seq")));
Map<String, Object> rootNode = new LinkedHashMap<>();
rootNode.put("id", trim(root.get("id")));
rootNode.put("name", trim(root.get("name")));
rootNode.put("seq", root.get("seq"));
rootNode.put("children", visibleDirs);
result.add(rootNode);
}
}
result.sort((a, b) -> compareSeq(a.get("seq"), b.get("seq")));
return result;
}
/** 构建叶子节点 Map(templateId = view_templateid)。 */
private Map<String, Object> buildLeafNode(Map<String, Object> leaf) {
Map<String, Object> node = new LinkedHashMap<>();
node.put("id", trim(leaf.get("id")));
node.put("name", trim(leaf.get("name")));
node.put("templateId", trim(leaf.get("view_templateid")));
node.put("children", List.of());
return node;
}
/** null 安全 trim:Object → String,null/空均返回 null。 */
static String trim(Object val) {
if (val == null) {
return null;
}
String s = val.toString().trim();
return s.isEmpty() ? null : s;
}
/** seq 升序比较(null 排最后)。 */
static int compareSeq(Object a, Object b) {
if (a == null && b == null) return 0;
if (a == null) return 1;
if (b == null) return -1;
try {
return Integer.compare(
Integer.parseInt(a.toString().trim()),
Integer.parseInt(b.toString().trim()));
} catch (NumberFormatException e) {
return a.toString().compareTo(b.toString());
}
}
}

View File

@@ -0,0 +1,137 @@
package com.eip4.platform.metadata.web;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import com.dsasp.server.common.user.service.LoggedInUser;
import com.dsasp.server.common.util.UserSession;
import com.eip4.platform.metadata.menu.MenuService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
/**
* 按权限裁剪的菜单树端点(F1-1)。
*
* <p>契约:{@code GET /api/menu}(需 JWT 认证,沿用 SecurityFilterChain 默认拦截)
* 返回 {@code { "roots": [...] }},每个 root 含两级 children(目录→叶子),
* 叶子 templateId = sys_menu.view_templateid(前端打开 /page/:templateId)。
*
* <p>裁剪语义:用户可见叶子集合来自 view_sys_usermenuid(userid=当前用户),
* 目录节点保留条件 = 子树内存在可见叶子;无可见菜单的 root 不下发。
*
* <p>当前用户取自 {@code UserSession.get()}(由 {@code JwtAuthFilter→EngineContextBinder}
* 在请求线程上绑定,key = {@code CURRENTUSER}),与 {@link PickerController} 拿用户的方式一致,
* 不依赖 platform-auth 模块。principal 为 null 或无菜单 → 返回空 roots,不报错。
*/
@Tag(name = "菜单树(按权限裁剪)", description = "F1-1 按当前用户权限裁剪的菜单树,叶子 templateId 供前端打开 /page/:templateId")
@RestController
public class MenuController {
private final JdbcTemplate jdbcTemplate;
private final MenuService menuService;
public MenuController(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
this.menuService = new MenuService();
}
/**
* 返回当前用户可见的菜单树。
*
* <p>每层按 seq 升序;叶子 templateId = view_templateid;
* 没有可见菜单的 root 不下发。
*
* @return {@code { "roots": [ { id, name, seq, children: [ { id, name, templateId, typename, seq, children: [...] } ] } ] }}
*/
@Operation(summary = "当前用户可见菜单树(按权限裁剪,两级:目录→叶子)",
description = "裁剪依据:view_sys_usermenuid(userid=当前用户);无可见菜单返回空 roots")
@GetMapping("/api/menu")
public Map<String, Object> menu() {
// 1. 获取当前用户 id(JwtAuthFilter 已在请求线程上绑定 UserSession)
String userId = currentUserId();
if (userId == null || userId.isEmpty()) {
return emptyRoots();
}
// 2. 查询 root 列表(全量 isactive=1,按 seq 排序)
List<Map<String, Object>> roots = jdbcTemplate.query(
"SELECT trim(sys_menu_root_id) AS id, trim(name) AS name, seq"
+ " FROM sys_menu_root WHERE isactive = 1 ORDER BY seq",
(rs, i) -> {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", rs.getString("id"));
m.put("name", rs.getString("name"));
m.put("seq", rs.getObject("seq"));
return m;
});
if (roots.isEmpty()) {
return emptyRoots();
}
// 3. 查询 sys_menu 全量活跃菜单(两层:目录 parentid=null + 叶子 parentid≠null)
List<Map<String, Object>> menus = jdbcTemplate.query(
"SELECT trim(sys_menu_id) AS id, trim(name) AS name,"
+ " trim(parentid) AS parentid, trim(menuroot) AS menuroot,"
+ " trim(view_templateid) AS view_templateid,"
+ " trim(typename) AS typename, seq"
+ " FROM sys_menu WHERE isactive = 1 ORDER BY seq",
(rs, i) -> {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", rs.getString("id"));
m.put("name", rs.getString("name"));
m.put("parentid", rs.getString("parentid"));
m.put("menuroot", rs.getString("menuroot"));
m.put("view_templateid", rs.getString("view_templateid"));
m.put("typename", rs.getString("typename"));
m.put("seq", rs.getObject("seq"));
return m;
});
// 4. 查询当前用户可见叶子菜单 id 集合(参数化,防注入)
List<String> visibleList = jdbcTemplate.queryForList(
"SELECT trim(menuid) FROM view_sys_usermenuid WHERE userid = ?",
String.class, userId);
Set<String> visibleMenuIds = visibleList.stream()
.filter(id -> id != null && !id.isEmpty())
.collect(Collectors.toSet());
if (visibleMenuIds.isEmpty()) {
return emptyRoots();
}
// 5. 构建裁剪后的树
List<Map<String, Object>> treeRoots = menuService.buildTree(roots, menus, visibleMenuIds);
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("roots", treeRoots);
return resp;
}
/**
* 从请求线程的引擎上下文取当前用户 id(JwtAuthFilter 在认证成功时已绑定)。
* 与 {@link PickerController#buildCtx} 同口径:读 UserSession.get() 的 CURRENTUSER。
*/
private String currentUserId() {
Properties ctx = UserSession.get();
if (ctx == null) {
return null;
}
return ctx.getProperty(LoggedInUser.CURRENTUSER);
}
private Map<String, Object> emptyRoots() {
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("roots", List.of());
return resp;
}
}