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;
}
}

View File

@@ -0,0 +1,242 @@
package com.eip4.platform.metadata.menu;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* {@link MenuService} 单测:树构建 + 按权限剪枝逻辑(纯函数,mock JdbcTemplate 不连库)。
*
* <p>覆盖契约:
* <ol>
* <li>正常两层树构建:root → 目录 → 叶子</li>
* <li>剪枝:可见叶子集合为空 → 返回空 roots</li>
* <li>剪枝:部分叶子可见 → 只保留有可见叶子的目录和 root</li>
* <li>每层按 seq 升序排列</li>
* <li>叶子 templateId = view_templateid;目录 templateId = null</li>
* <li>用户无任何可见菜单 → 空列表(不报错)</li>
* </ol>
*/
class MenuServiceTest {
private final MenuService service = new MenuService();
// ---------------------------------------------------------------- 测试数据构建辅助
private Map<String, Object> root(String id, String name, int seq) {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", id);
m.put("name", name);
m.put("seq", seq);
return m;
}
/** 目录节点:parentid=null,挂 rootId */
private Map<String, Object> dir(String id, String name, String rootId, int seq) {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", id);
m.put("name", name);
m.put("parentid", null);
m.put("menuroot", rootId);
m.put("view_templateid", null);
m.put("typename", "folder");
m.put("seq", seq);
return m;
}
/** 叶子节点:parentid=dirId,挂 rootId,含 templateId */
private Map<String, Object> leaf(String id, String name, String dirId, String rootId,
String templateId, int seq) {
Map<String, Object> m = new LinkedHashMap<>();
m.put("id", id);
m.put("name", name);
m.put("parentid", dirId);
m.put("menuroot", rootId);
m.put("view_templateid", templateId);
m.put("typename", "menu");
m.put("seq", seq);
return m;
}
// ---------------------------------------------------------------- 测试用例
@Test
@DisplayName("1. 正常两层树:root→目录→叶子,templateId、children 结构符合契约")
void buildNormalTree() {
List<Map<String, Object>> roots = List.of(root("R1", "信息站", 1));
List<Map<String, Object>> menus = List.of(
dir("D1", "通知目录", "R1", 1),
leaf("L1", "通知列表", "D1", "R1", "tpl-001", 1),
leaf("L2", "公告列表", "D1", "R1", "tpl-002", 2));
Set<String> visible = Set.of("L1", "L2");
List<Map<String, Object>> result = service.buildTree(roots, menus, visible);
assertEquals(1, result.size());
Map<String, Object> r = result.get(0);
assertEquals("R1", r.get("id"));
assertEquals("信息站", r.get("name"));
@SuppressWarnings("unchecked")
List<Map<String, Object>> dirs = (List<Map<String, Object>>) r.get("children");
assertEquals(1, dirs.size());
Map<String, Object> d = dirs.get(0);
assertEquals("D1", d.get("id"));
assertNotNull(d.get("children")); // 目录有 children
// 目录 templateId 为 null
assertTrue(d.get("templateId") == null);
@SuppressWarnings("unchecked")
List<Map<String, Object>> leaves = (List<Map<String, Object>>) d.get("children");
assertEquals(2, leaves.size());
assertEquals("L1", leaves.get(0).get("id"));
assertEquals("tpl-001", leaves.get(0).get("templateId"));
assertEquals("L2", leaves.get(1).get("id"));
assertEquals("tpl-002", leaves.get(1).get("templateId"));
// 叶子 children 为空列表
assertEquals(List.of(), leaves.get(0).get("children"));
}
@Test
@DisplayName("2. 可见集合为空 → 返回空 roots")
void emptyVisibleReturnsEmpty() {
List<Map<String, Object>> roots = List.of(root("R1", "信息站", 1));
List<Map<String, Object>> menus = List.of(
dir("D1", "通知目录", "R1", 1),
leaf("L1", "通知列表", "D1", "R1", "tpl-001", 1));
Set<String> visible = Set.of();
List<Map<String, Object>> result = service.buildTree(roots, menus, visible);
assertTrue(result.isEmpty(), "无可见菜单时应返回空列表");
}
@Test
@DisplayName("3. 部分叶子可见 → 只保留有可见子节点的目录和 root")
void partialVisiblePruning() {
List<Map<String, Object>> roots = List.of(
root("R1", "信息站", 1),
root("R2", "我的申请", 2));
List<Map<String, Object>> menus = List.of(
dir("D1", "通知目录", "R1", 1),
leaf("L1", "通知列表", "D1", "R1", "tpl-001", 1),
leaf("L2", "公告列表", "D1", "R1", "tpl-002", 2),
dir("D2", "申请目录", "R2", 1),
leaf("L3", "发起申请", "D2", "R2", "tpl-003", 1));
// 用户只能看 L1,看不到 L2 和 L3
Set<String> visible = Set.of("L1");
List<Map<String, Object>> result = service.buildTree(roots, menus, visible);
// R2 无可见叶子 → 不下发
assertEquals(1, result.size());
assertEquals("R1", result.get(0).get("id"));
@SuppressWarnings("unchecked")
List<Map<String, Object>> dirs = (List<Map<String, Object>>) result.get(0).get("children");
assertEquals(1, dirs.size());
@SuppressWarnings("unchecked")
List<Map<String, Object>> leaves = (List<Map<String, Object>>) dirs.get(0).get("children");
// 只保留 L1
assertEquals(1, leaves.size());
assertEquals("L1", leaves.get(0).get("id"));
}
@Test
@DisplayName("4. 每层按 seq 升序排列")
void seqOrdering() {
List<Map<String, Object>> roots = List.of(
root("R2", "我的申请", 2),
root("R1", "信息站", 1));
List<Map<String, Object>> menus = List.of(
dir("D2", "目录B", "R1", 2),
dir("D1", "目录A", "R1", 1),
leaf("L2", "叶子B", "D1", "R1", "tpl-002", 2),
leaf("L1", "叶子A", "D1", "R1", "tpl-001", 1));
Set<String> visible = Set.of("L1", "L2");
// D2 没有叶子,不会出现在结果中
List<Map<String, Object>> result = service.buildTree(roots, menus, visible);
// roots 按 seq 升序
assertEquals("R1", result.get(0).get("id"));
@SuppressWarnings("unchecked")
List<Map<String, Object>> dirs = (List<Map<String, Object>>) result.get(0).get("children");
assertEquals("D1", dirs.get(0).get("id"));
@SuppressWarnings("unchecked")
List<Map<String, Object>> leaves = (List<Map<String, Object>>) dirs.get(0).get("children");
assertEquals("L1", leaves.get(0).get("id"));
assertEquals("L2", leaves.get(1).get("id"));
}
@Test
@DisplayName("5. 目录无叶子(全被剪枝)→ 目录也不下发,root 随之消失")
void dirWithNoVisibleLeavesDropped() {
List<Map<String, Object>> roots = List.of(root("R1", "信息站", 1));
List<Map<String, Object>> menus = List.of(
dir("D1", "通知目录", "R1", 1),
leaf("L1", "通知列表", "D1", "R1", "tpl-001", 1));
// 用户看不到任何叶子
Set<String> visible = Set.of("OTHER_ID");
List<Map<String, Object>> result = service.buildTree(roots, menus, visible);
assertTrue(result.isEmpty());
}
@Test
@DisplayName("6. trim 辅助方法:null/空字符串/有空格值处理正确")
void trimHelper() {
assertEquals(null, MenuService.trim(null));
assertEquals(null, MenuService.trim(" "));
assertEquals("abc", MenuService.trim(" abc "));
assertEquals("abc", MenuService.trim("abc"));
}
@Test
@DisplayName("7. compareSeq:null 排最后,数字升序,非数字字典序")
void compareSeqHelper() {
assertTrue(MenuService.compareSeq(1, 2) < 0);
assertTrue(MenuService.compareSeq(2, 1) > 0);
assertEquals(0, MenuService.compareSeq(1, 1));
assertTrue(MenuService.compareSeq(null, 1) > 0);
assertTrue(MenuService.compareSeq(1, null) < 0);
assertEquals(0, MenuService.compareSeq(null, null));
}
@Test
@DisplayName("8. 多 root 多目录:各 root 独立剪枝,互不影响")
void multiRootMultiDir() {
List<Map<String, Object>> roots = List.of(
root("R1", "信息站", 1),
root("R2", "我的申请", 2),
root("R3", "项目经理", 3));
List<Map<String, Object>> menus = new ArrayList<>();
menus.add(dir("D1", "通知", "R1", 1));
menus.add(leaf("L1", "通知列表", "D1", "R1", "tpl-1", 1));
menus.add(dir("D2", "申请", "R2", 1));
menus.add(leaf("L2", "发起申请", "D2", "R2", "tpl-2", 1));
menus.add(dir("D3", "项目", "R3", 1));
menus.add(leaf("L3", "项目列表", "D3", "R3", "tpl-3", 1));
// 用户只可见 R1 和 R3 的叶子
Set<String> visible = Set.of("L1", "L3");
List<Map<String, Object>> result = service.buildTree(roots, menus, visible);
assertEquals(2, result.size());
assertEquals("R1", result.get(0).get("id"));
assertEquals("R3", result.get(1).get("id"));
}
}