update 优化获取节点扩展属性,简化节点编码

ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/impl/FlwNodeExtServiceImpl.java

@@ -6,7 +6,6 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.dromara.common.core.domain.dto.DictTypeDTO;
 import org.dromara.common.core.service.DictService;
-import org.dromara.common.core.utils.StringUtils;
 import org.dromara.warm.flow.ui.service.NodeExtService;
 import org.dromara.warm.flow.ui.vo.NodeExt;
 import org.dromara.workflow.common.ConditionalOnEnable;
@@ -37,11 +36,6 @@ public class FlwNodeExtServiceImpl implements NodeExtService {
      */
     private static final String PERMISSION_TAB_NAME = "权限";
 
-    /**
-     * 枚举类型标识
-     */
-    private static final String ENUM_TYPE_PREFIX = "enum:";
-
     /**
      * 基础设置
      */
@@ -58,7 +52,7 @@ public class FlwNodeExtServiceImpl implements NodeExtService {
     private static final Map<String, Map<String, Object>> CHILD_NODE_MAP = new HashMap<>();
 
     static {
-        CHILD_NODE_MAP.put(ButtonPermissionEnum.class.getName(),
+        CHILD_NODE_MAP.put(ButtonPermissionEnum.class.getSimpleName(),
             Map.of("label", "权限按钮", "type", 4, "must", false, "multiple", true));
     }
 
@@ -67,33 +61,40 @@ public class FlwNodeExtServiceImpl implements NodeExtService {
     /**
      * 获取节点扩展属性
      *
-     * @return 结果
+     * @return 节点扩展属性列表
      */
     @Override
     public List<NodeExt> getNodeExt() {
         List<NodeExt> nodeExtList = new ArrayList<>();
         // 构建按钮权限页面
         nodeExtList.add(buildNodeExt(PERMISSION_TAB, PERMISSION_TAB_NAME, TYPE_NEW_TAB,
-            ENUM_TYPE_PREFIX + ButtonPermissionEnum.class.getName()));
+            List.of(ButtonPermissionEnum.class)));
         return nodeExtList;
     }
 
     /**
-     * 构建一个 NodeExt 对象
+     * 构建一个 `NodeExt` 对象
      *
-     * @param code        编码，此json中唯一
+     * @param code    唯一编码
-     * @param name        名称，如果type为新页签时，作为页签名称
+     * @param name    名称（新页签时，作为页签名称）
-     * @param type        节点类型，1：基础设置，2：新页签
+     * @param type    节点类型（1: 基础设置，2: 新页签）
-     * @param sourceTypes 字典/枚举类型来源（逗号分隔）
+     * @param sources 数据来源（枚举类或字典类型）
-     * @return 返回构建好的 NodeExt 对象
+     * @return 构建的 `NodeExt` 对象
      */
-    private NodeExt buildNodeExt(String code, String name, int type, String sourceTypes) {
+    private NodeExt buildNodeExt(String code, String name, int type, List<Object> sources) {
         NodeExt nodeExt = new NodeExt();
         nodeExt.setCode(code);
         nodeExt.setType(type);
         nodeExt.setName(name);
-        nodeExt.setChilds(StringUtils.splitList(sourceTypes)
+        nodeExt.setChilds(sources.stream()
-            .stream().map(this::buildChildNode)
+            .map(source -> {
+                if (source instanceof Class<?> clazz && NodeExtEnum.class.isAssignableFrom(clazz)) {
+                    return buildChildNode((Class<? extends Enum<?>>) clazz);
+                } else if (source instanceof String dictType) {
+                    return buildChildNode(dictType);
+                }
+                return null;
+            })
             .filter(ObjectUtil::isNotNull)
             .toList()
         );
@@ -101,52 +102,36 @@ public class FlwNodeExtServiceImpl implements NodeExtService {
     }
 
     /**
-     * 构建一个 ChildNode 对象
+     * 根据枚举类型构建一个 `ChildNode` 对象
      *
-     * @param sourceType 字典类型
+     * @param enumClass 枚举类，必须实现 `NodeExtEnum` 接口
-     * @return 返回构建好的 ChildNode 对象
+     * @return 构建的 `ChildNode` 对象
      */
-    private NodeExt.ChildNode buildChildNode(String sourceType) {
+    private NodeExt.ChildNode buildChildNode(Class<? extends Enum<?>> enumClass) {
-        return sourceType.startsWith(ENUM_TYPE_PREFIX) ?
+        if (!enumClass.isEnum()) {
-            buildChildNodeFromEnum(sourceType.substring(ENUM_TYPE_PREFIX.length())) : buildChildNodeFromDict(sourceType);
+            return null;
-    }
-
-    /**
-     * 根据枚举构建一个 ChildNode 对象
-     *
-     * @param enumClassName 枚举名称
-     * @return 返回构建好的 ChildNode 对象
-     */
-    private NodeExt.ChildNode buildChildNodeFromEnum(String enumClassName) {
-        try {
-            Class<?> enumClass = Class.forName(enumClassName);
-            if (!enumClass.isEnum()) {
-                return null;
-            }
-            NodeExt.ChildNode childNode = buildChildNodeMap(enumClassName);
-            // 编码，此json中唯
-            childNode.setCode(ENUM_TYPE_PREFIX + enumClassName);
-            // 字典，下拉框和复选框时用到
-            childNode.setDict(Arrays.stream(enumClass.getEnumConstants())
-                .filter(NodeExtEnum.class::isInstance)
-                .map(NodeExtEnum.class::cast)
-                .map(x ->
-                    new NodeExt.DictItem(x.getLabel(), x.getValue(), x.isSelected())
-                ).toList());
-            return childNode;
-        } catch (ClassNotFoundException e) {
-            log.error("Enum class not found: {}", enumClassName, e);
         }
-        return null;
+        String simpleName = enumClass.getSimpleName();
+        NodeExt.ChildNode childNode = buildChildNodeMap(simpleName);
+        // 编码，此json中唯
+        childNode.setCode(simpleName);
+        // 字典，下拉框和复选框时用到
+        childNode.setDict(Arrays.stream(enumClass.getEnumConstants())
+            .filter(NodeExtEnum.class::isInstance)
+            .map(NodeExtEnum.class::cast)
+            .map(x ->
+                new NodeExt.DictItem(x.getLabel(), x.getValue(), x.isSelected())
+            ).toList());
+        return childNode;
     }
 
     /**
-     * 根据字典构建一个 ChildNode 对象
+     * 根据字典类型构建 `ChildNode` 对象
      *
      * @param dictType 字典类型
-     * @return 返回构建好的 ChildNode 对象
+     * @return 构建的 `ChildNode` 对象
      */
-    private NodeExt.ChildNode buildChildNodeFromDict(String dictType) {
+    private NodeExt.ChildNode buildChildNode(String dictType) {
         DictTypeDTO dictTypeDTO = dictService.getDictType(dictType);
         if (ObjectUtil.isNull(dictTypeDTO)) {
             return null;