update 优化 翻译模块 增加逻辑注释和相关警告日志

This reverts commit bcc11dcc12.

.claude/agents/backend-crud.md

@@ -0,0 +1,56 @@
+---
+name: backend-crud
+description: 标准后端 CRUD 专家。用于当前项目中的新增单表 CRUD、补 entity/bo/vo/mapper/service/controller、分页查询、导出、删除前校验等任务。
+---
+
+你负责当前项目中的标准后端 CRUD 实现。
+
+## 核心原则
+
+1. 先参考 `ruoyi-modules/ruoyi-gen/src/main/resources/vm/` 下的模板。
+2. 再参考当前模块内最近似的标准管理模块。
+3. 分层保持稳定：
+   `domain`、`domain.bo`、`domain.vo`、`mapper`、`service`、`service.impl`、`controller`
+
+## 结构约定
+
+- entity 默认继承 `BaseEntity`
+- mapper 默认继承 `BaseMapperPlus<Entity, Vo>`
+- BO 使用 `@AutoMapper(target = Entity.class, reverseConvertGenerate = false)`
+- VO 使用 `@AutoMapper(target = Entity.class)`
+- service 使用 `baseMapper`
+
+## 默认方法集合
+
+- `queryById`
+- `queryPageList`
+- `queryList`
+- `insertByBo`
+- `updateByBo`
+- `deleteWithValidByIds`
+
+## 查询规则
+
+- 单表查询优先用 `LambdaQueryWrapper`
+- 日期范围默认从 `bo.getParams()` 中读取 begin/end
+- 分页优先返回 `PageResult<Vo>`
+
+## 接口规则
+
+- controller 继承 `BaseController`
+- 返回值使用 `R<T>` 或 `R<Void>`
+- 标准 CRUD 路由通常是：
+  `GET /list`
+  `POST /export`
+  `GET /{id}`
+  `POST`
+  `PUT`
+  `DELETE /{ids}`
+- 默认检查是否需要 `@SaCheckPermission`、`@Log`、`@RepeatSubmit`
+
+## 自检
+
+- CRUD 链路是否完整
+- BO / VO / Entity 是否职责分离
+- 导出、分页、删除前校验是否齐全
+- 是否只是 generator 裸产物，如果是要继续补齐项目约定

.claude/agents/backend-engineering.md

@@ -0,0 +1,19 @@
+---
+name: backend-engineering
+description: 后端工程总入口。用于在当前项目中识别任务属于标准 CRUD、复杂模块增强、联表与数据权限、或前后端联动，并选择合适的后端子 agent。
+---
+
+你是当前后端工程的总入口 agent。
+
+先判断任务类型，再按下面规则处理：
+
+1. 如果是新增标准单表 CRUD、从表结构补 entity/bo/vo/mapper/service/controller，优先使用 `backend-crud.md` 的规则。
+2. 如果是修改 `system`、`workflow` 等已经很复杂的模块，优先使用 `backend-module-enhancement.md` 的规则。
+3. 如果重点在 MPJ 联表、`@DataPermission`、复杂查询、数据范围控制，优先使用 `backend-query-permission.md` 的规则。
+4. 如果同时要求同步前端接口或前端页面骨架，保持后端路由与 generator 风格稳定，便于前端 agent 对接。
+
+通用要求：
+
+- 先读同模块最近似实现，再动代码。
+- 发生冲突时优先相信当前模块真实代码，其次是公共基础设施，再其次才是 generator 模板。
+- 默认直接产出可落地代码，而不是只给抽象建议。

.claude/agents/backend-module-enhancement.md

@@ -0,0 +1,33 @@
+---
+name: backend-module-enhancement
+description: 复杂后端模块增强专家。用于修改当前项目中已经存在较重业务逻辑的模块，例如 system、workflow 等，强调增量修改、保留现有权限、事务、缓存、导入导出和业务校验。
+---
+
+你负责复杂后端模块的增量增强，不是从零生成裸 CRUD。
+
+## 核心原则
+
+1. 优先阅读当前模块最近似实现。
+2. 增量修改，不重写整块 service/controller。
+3. 保留已有的数据权限、事务、缓存、导入导出、唯一性校验、删除前校验。
+4. 不能为了“简洁”把复杂模块退化成模板式单表 CRUD。
+
+## 常见任务
+
+- 修改 `system`、`workflow` 模块的查询与导出逻辑
+- 新增或调整写入前校验
+- 维护角色、岗位、用户等关联数据
+- 增加复杂页面所需的特殊接口
+
+## 约束
+
+- controller 不堆重业务逻辑
+- service 里的旧逻辑要先理解再改
+- 如果附近已有 `ServiceException`、缓存注解、事务注解、数据权限判断，新增逻辑默认保持一致
+- 如果存在联动前端页面，接口路径与返回结构尽量稳定
+
+## 自检
+
+- 是否破坏了原模块的权限边界
+- 是否误删了旧逻辑中的事务或校验
+- 是否错误简化了复杂关系维护

.claude/agents/backend-query-permission.md

@@ -0,0 +1,28 @@
+---
+name: backend-query-permission
+description: 后端查询、联表与数据权限专家。用于当前项目中的 MPJ 联表、DataPermission、复杂分页查询、范围控制和查询增强任务。
+---
+
+你负责当前项目中的复杂查询和数据权限类任务。
+
+## 核心原则
+
+1. 优先看当前模块已有的 mapper 查询实现。
+2. 涉及数据权限时优先复用 `@DataPermission` 与已有字段映射方式。
+3. 复杂联表优先参考 MPJ 风格，不轻易改回手写零散 SQL。
+4. 如果 `BaseMapperPlus + wrapper` 足够，不要额外补 XML。
+
+## 重点关注
+
+- `BaseMapperPlus`
+- `@DataPermission`
+- `DataColumn`
+- `MPJBaseMapper`
+- `JoinWrappers.lambda(...)`
+- 复杂分页与列表查询
+
+## 输出要求
+
+- 明确说明查询是单表、联表还是带权限控制
+- 保持与当前模块 mapper 风格一致
+- 不要让查询参数风格和前端现有调用脱节

.codex/skills/ruoyi-plus-ai-coding/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: ruoyi-plus-ai-coding
+description: 在仓库内按代码生成器模板和项目既有约定生成或修改代码。用于新增 CRUD 模块、补全 controller/service/mapper/BO/VO/entity、编写 MyBatis-Plus 查询，以及新增与后端接口配套的 Vue 3 + TypeScript 页面、types 和 api 文件。
+---
+
+# RuoYi Plus AI 编码规范
+
+先对齐代码生成器产物，再叠加仓库里真实业务代码已经形成的更强约定。
+
+## 适用场景
+
+在下面这些任务里优先使用此 skill：
+
+- 新增标准 CRUD 模块。
+- 根据新表结构补齐 entity、bo、vo、mapper、service、controller。
+- 修改已有模块的查询、校验、导入导出、数据权限、事务逻辑。
+- 在系统、监控、工作流、demo 等模块内按现有约定扩展业务代码。
+- 为后端新增接口同步补前端 `api/types/index.vue` 骨架。
+
+## 不适用场景
+
+下面这些任务不要机械套用本 skill 的 CRUD 规则：
+
+- 基础框架升级、Spring Boot 主版本迁移。
+- 与当前分层明显不同的实验性模块。
+- 第三方中间件深度接入、基础设施改造。
+- 完全脱离 generator 体系的独立子系统。
+
+## 执行流程
+
+1. 先确认目标模块，优先复用同模块中最近似功能的写法。
+2. 新增标准 CRUD 代码前，先读取 `ruoyi-modules/ruoyi-gen/src/main/resources/vm/` 下的模板。
+3. 命名和分层保持与仓库一致：
+   `domain` entity、`domain.bo`、`domain.vo`、`mapper`、`service`、`service.impl`、`controller`。
+4. 优先在生成器结构上扩展，不要自行发明新的分层。
+5. 修改 `ruoyi-system` 这类复杂模块前，先阅读同类现有实现，因为这些模块通常比生成器默认产物多出数据权限、联表、缓存、安全校验等逻辑。
+
+## 优先级规则
+
+发生冲突时按下面顺序决策：
+
+1. 当前模块内最近似业务代码。
+2. 当前仓库公共基础模块约定，例如 `common-mybatis`、`common-core`、`common-web`。
+3. 代码生成器模板。
+4. 通用 Spring Boot / MyBatis-Plus 习惯。
+
+也就是说：
+
+- 同模块已有成熟实现时，优先复用该实现。
+- 同模块没有现成代码时，再参考 generator 模板。
+- 不要因为“更通用”就覆盖掉项目已形成的强约定。
+
+## 后端规则
+
+Java、MyBatis-Plus、BO/VO/entity、controller、mapper、service 的具体规则见 [references/backend.md](references/backend.md)。
+
+## 前端规则
+
+Vue 3、TypeScript API 文件、生成式列表页、表单状态、字典和日期范围约定见 [references/frontend.md](references/frontend.md)。
+
+## 使用案例
+
+具体调用方式见 [references/examples.md](references/examples.md)。
+
+## 仓库通用规则
+
+- 遵循 [`.editorconfig`](../../../.editorconfig)：UTF-8、LF，默认 4 空格，JSON/YAML 为 2 空格。
+- 不要把 `BaseMapperPlus`、`PageQuery`、`PageResult`、`R`、`MapstructUtils` 或项目工具类替换成临时自造方案。
+- 仓库已使用 `List.of(...)` 的地方，数组转列表优先继续沿用。
+- import、注解顺序、文件结构以附近代码为准，不要顺手重排整个文件。
+- 只有在业务逻辑不直观时才加简短注释。
+
+## 决策规则
+
+- 如果任务是围绕单表的标准 CRUD，尽量贴近生成器默认产物。
+- 如果目标模块已经存在自定义校验、数据权限、事务、缓存、Excel 导入导出、联表查询等逻辑，应在此基础上扩展，不要为了“简洁”把它们削平。
+- 如果附近 controller 接口已经带有权限、日志、防重、加密、分组校验等注解，新接口默认同步保持一致，除非有明确理由不这样做。
+- 如果 BO 或 VO 需要字段校验、翻译、Excel 注解，应优先参考同模块同用途对象，不要机械套通用注解。
+
+## 目录映射规则
+
+标准后端模块通常按下面结构组织：
+
+- `src/main/java/.../domain/Entity.java`
+- `src/main/java/.../domain/bo/EntityBo.java`
+- `src/main/java/.../domain/vo/EntityVo.java`
+- `src/main/java/.../mapper/EntityMapper.java`
+- `src/main/java/.../service/IEntityService.java`
+- `src/main/java/.../service/impl/EntityServiceImpl.java`
+- `src/main/java/.../controller/EntityController.java`
+
+标准生成器模板通常对应：
+
+- `vm/java/domain.java.vm` -> entity
+- `vm/java/bo.java.vm` -> bo
+- `vm/java/vo.java.vm` -> vo
+- `vm/java/mapper.java.vm` -> mapper
+- `vm/java/service.java.vm` -> service interface
+- `vm/java/serviceImpl.java.vm` -> service impl
+- `vm/java/controller.java.vm` -> controller
+- `vm/xml/mapper.xml.vm` -> 自定义 XML mapper 起点
+
+## 任务分型
+
+### 1. 标准单表 CRUD
+
+优先按 generator 模板落骨架，再补校验、权限、导出、翻译等项目约定。
+
+### 2. 强业务模块扩展
+
+如果目标模块像 `system`、`workflow` 一样已经有复杂逻辑，优先增量修改，不要回退成模板式简化代码。
+
+### 3. 基础能力复用
+
+如果涉及数据权限、缓存、事务、导入导出、字典、翻译、加密、分组校验，优先查项目已有做法并复用公共能力。
+
+## 输出要求
+
+使用本 skill 时，默认期望产出应满足：
+
+- 后端分层完整，不直接在 controller 里堆业务逻辑。
+- `BO/VO/Entity` 职责分明。
+- 查询、分页、删除校验、写入校验逻辑闭环完整。
+- 权限、日志、防重、事务、数据权限尽量贴近同模块现有实现。
+- 如果同步改前端，前端 API 路径和后端接口保持一致。
+
+## 快速检查清单
+
+- 包路径和 `@RequestMapping` 与模块保持一致。
+- 权限标识遵循 `${module}:${business}:${action}`。
+- Mapper 继承 `BaseMapperPlus<Entity, Vo>`。
+- Service 使用 `baseMapper`，并按场景返回 `PageResult` 或 `List<Vo>`。
+- 查询代码优先使用 `LambdaQueryWrapper`，复杂模块沿用既有 MPJ 联表风格。
+- BO 使用 `@AutoMapper(target = Entity.class, reverseConvertGenerate = false)`。
+- VO 使用 `@AutoMapper(target = Entity.class)`。
+- 前端 API 路径与后端路由完全对应。
+- 前端列表页继续使用仓库里的 `proxy?.addDateRange`、`proxy?.$modal`、`proxy?.download`、`useDict`、`pagination` 等工具。
+
+## 推荐提问方式
+
+推荐把任务描述到下面这个粒度：
+
+- 目标模块和业务名
+- 是新建模块还是修改已有模块
+- 表名或接口前缀
+- 是否需要分页、导出、导入、数据权限、字典、翻译、联表
+- 希望参考哪个现有模块
+
+例如：
+
+- 使用 `$ruoyi-plus-ai-coding` 在 `system` 模块新增一个标准单表 CRUD，参考 `SysConfig` 与 generator 模板。
+- 使用 `$ruoyi-plus-ai-coding` 修改 `workflow/category` 的查询和导出逻辑，保持现有模块风格。

.codex/skills/ruoyi-plus-ai-coding/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "RuoYi Plus 编码"
+  short_description: "按生成器与仓库约定编写代码"
+  default_prompt: "使用 $ruoyi-plus-ai-coding 在这个仓库里按现有约定实现代码修改。"
+
+policy:
+  allow_implicit_invocation: true

.codex/skills/ruoyi-plus-ai-coding/references/backend.md

@@ -0,0 +1,221 @@
+# 后端约定
+
+## 优先参考的代码来源
+
+- `ruoyi-modules/ruoyi-gen/src/main/resources/vm/java/*.vm`
+- `ruoyi-modules/ruoyi-demo/...`
+- `ruoyi-modules/ruoyi-system/...`
+- `ruoyi-common/ruoyi-common-mybatis/...`
+
+## 决策顺序
+
+写代码时按下面顺序取样：
+
+1. 当前业务模块下最近似实现。
+2. 当前仓库公共能力模块中的统一约定。
+3. generator 模板。
+4. 通用 Spring / MyBatis-Plus 默认习惯。
+
+如果规则冲突，优先相信当前仓库真实代码。
+
+## 分层结构
+
+标准 CRUD 代码应优先遵循下面这套结构：
+
+- `domain/Entity.java`
+- `domain/bo/EntityBo.java`
+- `domain/vo/EntityVo.java`
+- `mapper/EntityMapper.java`
+- `service/IEntityService.java`
+- `service/impl/EntityServiceImpl.java`
+- `controller/EntityController.java`
+
+## Entity 规则
+
+- 除非所在模块明显另有约定，否则实体类继承 `org.dromara.common.mybatis.core.domain.BaseEntity`。
+- 使用 Lombok `@Data` 和 `@EqualsAndHashCode(callSuper = true)`。
+- 使用 `@TableName("table_name")`。
+- 主键使用 `@TableId`。
+- 存在 `delFlag` 时保留 `@TableLogic`，存在乐观锁字段时保留 `@Version`。
+- 如果附近实体已经使用 `@OrderBy` 等额外注解，应继续保持。
+
+## BO 规则
+
+- 实现 `Serializable`。
+- 添加 `@AutoMapper(target = Entity.class, reverseConvertGenerate = false)`。
+- 请求专用字段、查询专用字段放在 BO 中，包括 `params`。
+- 在生成器或附近代码已有分组校验时，继续使用：`AddGroup`、`EditGroup`、`QueryGroup`。
+- `@Xss`、`@Email`、`@Size`、`@NotBlank`、`@NotNull` 要按真实业务语义添加，不要一股脑全套上。
+- 查询存在日期范围或扩展条件时，保留 `params = new HashMap<>()`。
+
+## VO 规则
+
+- 实现 `Serializable`。
+- 添加 `@AutoMapper(target = Entity.class)`。
+- 生成器风格的导出对象通常带 `@ExcelIgnoreUnannotated`。
+- `@ExcelProperty`、`@ExcelDictFormat`、`ExcelDictConvert`、`@ExcelRequired`、`@ExcelNotation`、`@DateTimeFormat` 只在导入导出场景下使用。
+- 如果附近代码会把 ID 翻译成展示字段，沿用 `@Translation(type = TransConstant.USER_ID_TO_NAME, mapper = "createBy")` 这类写法。
+- 展示型派生字段放在 VO，不放在 Entity。
+
+## Mapper 规则
+
+- 默认形式是 `interface XxxMapper extends BaseMapperPlus<Xxx, XxxVo>`。
+- 不要为简单的 entity 转 vo 手写重复代码，优先依赖 `BaseMapperPlus`。
+- 模块已经使用 `@DataPermission` 时，在重写方法和自定义查询上继续保留。
+- 复杂模块里 mapper 可能同时继承 `MPJBaseMapper<Entity>` 并使用 `JoinWrappers.lambda(...)`，遇到这种风格要延续，不要换一种写法。
+- 只有在 `selectVoList/selectVoPage` 不够用时，才补 XML 或自定义 mapper 方法。
+
+### Mapper 建议结构
+
+标准 mapper 一般按这个顺序组织：
+
+1. 接口声明
+2. 默认查询方法
+3. 自定义分页或列表方法
+4. 特殊数据权限重写
+5. 辅助构造方法
+
+### 什么时候需要 XML
+
+- 复杂联表 SQL 无法仅靠 wrapper 清晰表达时。
+- 需要手写查询列和结果映射时。
+- 项目当前模块已经大量使用 XML 时。
+
+如果 `BaseMapperPlus + wrapper` 已足够，优先不要补 XML。
+
+## Service 规则
+
+- 类声明通常是 `@RequiredArgsConstructor`、`@Service`，按需补 `@Slf4j`。
+- mapper 注入字段命名为 `private final XxxMapper baseMapper;`。
+- 读操作通常返回 `Vo`、`List<Vo>` 或 `PageResult<Vo>`。
+- BO 转实体用 `MapstructUtils.convert(bo, Entity.class)`。
+- 查询条件优先用 `LambdaQueryWrapper` 和 `Wrappers.lambdaQuery()`。
+- 在 wrapper 条件里直接写 `StringUtils.isNotBlank(...)` 和 null 判断。
+- 分页查询优先采用：
+  `Page<Vo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);`
+  `return PageResult.build(result.getRecords(), result.getTotal());`
+- 生成器风格模块保留 `validEntityBeforeSave(...)` 这种扩展点。
+- 多表写操作使用 `@Transactional(rollbackFor = Exception.class)`。
+- 明确的业务失败，尤其是权限、数据完整性、删除校验，使用 `ServiceException`。
+- 不要绕过模块现有的数据权限、角色校验、删除前校验。
+
+### Service 建议结构
+
+标准 service impl 一般按下面顺序组织：
+
+1. 查询单条
+2. 分页查询
+3. 列表查询
+4. 构建查询条件
+5. 新增
+6. 修改
+7. 保存前校验
+8. 删除前校验与删除
+9. 其他扩展业务方法
+
+### 查询逻辑建议
+
+- 单表查询优先使用 `LambdaQueryWrapper`。
+- 条件判断直接放在 wrapper 上，不要额外写大量 if 套壳。
+- 日期范围统一从 `bo.getParams()` 取 begin/end。
+- 复杂联表查询优先查同模块是否已有 MPJ 风格可复用。
+
+### 写入逻辑建议
+
+- BO 转实体统一走 `MapstructUtils.convert`。
+- 批量关系维护时优先拆成私有方法，例如角色、岗位、用户关联。
+- 修改前优先保留已有防误删、防越权、防并发覆盖逻辑。
+
+## Controller 规则
+
+- 继承 `BaseController`。
+- 类上通常带 `@Validated`、`@RestController`、`@RequiredArgsConstructor`、`@RequestMapping`。
+- 返回值使用 `R<T>` 或 `R<Void>`。
+- 标准 CRUD 接口通常是：`GET /list`、`POST /export`、`GET /{id}`、`POST`、`PUT`、`DELETE /{ids}`。
+- `@SaCheckPermission` 权限格式遵循 `${module}:${business}:${action}`。
+- 写操作、导入导出接口通常加 `@Log(title = "...", businessType = BusinessType.X)`。
+- 附近接口已有防重时，写接口继续使用 `@RepeatSubmit`。
+- 适合分组校验时，使用 `@Validated(AddGroup.class)` 和 `@Validated(EditGroup.class)`。
+- 特殊接口直接复用模块内现成做法，例如导入导出、`@ApiEncrypt`、multipart 上传、数据权限检查、写入前唯一性校验。
+
+### Controller 建议结构
+
+标准 controller 一般按下面顺序组织：
+
+1. 列表
+2. 导出
+3. 详情
+4. 新增
+5. 修改
+6. 删除
+7. 特殊接口
+
+### Controller 边界
+
+- controller 负责接参、校验、权限、日志、返回值转换。
+- 重业务逻辑尽量放 service，不要在 controller 里堆长逻辑。
+- 但前置权限检查、唯一性提示、显式业务失败提示可以留在 controller，前提是同模块已有这种习惯。
+
+## 查询与工具规则
+
+- 分页统一使用 `PageQuery` 和 `PageResult`，不要无故引入新的分页 DTO。
+- 优先使用项目工具类：`MapstructUtils`、`StringUtils`、`StreamUtils`、`ValidatorUtils`、`SpringUtils`、`RedisUtils`。
+- 数组转列表按附近代码习惯使用 `List.of(ids)` 或 `Arrays.asList(ids)`。
+- 日期范围查询通常从 `bo.getParams()` 中读取 `beginTime`、`endTime` 或 `beginFieldName`、`endFieldName`。
+
+## 前后端联动规则
+
+- 新增后端接口时，路径和权限前缀尽量保持 generator 约定，方便前端目录和 API 命名同步。
+- 新增日期范围查询时，记得保留 `bo.params` 结构，避免前端 `addDateRange` 无法对接。
+- 导出接口通常保持 `POST /export` 风格，便于前端直接复用现有下载逻辑。
+- 批量删除接口通常使用 `DELETE /{ids}`，便于前端直接传数组或逗号串。
+
+## 生成器优先模式
+
+从零新增 CRUD 时，优先对齐生成器默认方法集合：
+
+- `queryById`
+- `queryPageList`
+- `queryList`
+- `insertByBo`
+- `updateByBo`
+- `deleteWithValidByIds`
+
+然后再叠加模块内已有增强，例如：
+
+- 唯一性校验
+- 数据权限注解
+- MPJ 联表查询
+- 缓存注解
+- Excel 导入导出监听器
+- 关联表维护逻辑
+
+## 什么时候优先看 generator
+
+- 新增一个标准单表 CRUD 时。
+- 只有表结构和基本接口需求，没有现成业务模块可参考时。
+- 需要快速补齐整套骨架代码时。
+
+## 什么时候优先看现有模块
+
+- 目标模块已经有类似业务。
+- 涉及数据权限、联表、缓存、角色岗位关系、导入导出、工作流扩展时。
+- 任务是“修改已有模块”而不是“新建模块”时。
+
+## 避免事项
+
+- 不要在 controller 里直接暴露 entity 代替 BO/VO。
+- 不要给新的管理接口漏掉权限注解。
+- 没有明确必要时，不要从 `BaseMapperPlus` 风格退回手工映射。
+- 前端查询页用了日期范围时，不要删掉后端 `params` 相关处理。
+- 不要把 `ruoyi-system` 这类复杂逻辑强行简化成生成器式单表 CRUD。
+
+## 交付前自检
+
+交付前至少检查这些点：
+
+- CRUD 主链路是否完整。
+- BO / VO / Entity 职责是否清晰。
+- 分页、查询、删除校验是否与前端对得上。
+- 权限、日志、防重、事务是否遗漏。
+- 是否只是 generator 裸产物，如果是，需要继续补齐同模块已有增强。

.codex/skills/ruoyi-plus-ai-coding/references/examples.md

@@ -0,0 +1,101 @@
+# 使用案例
+
+## 案例 1：新增标准单表 CRUD
+
+### 用户提问示例
+
+```text
+使用 $ruoyi-plus-ai-coding 在 system 模块新增一个 client 管理的标准 CRUD。
+请参考 generator 模板和现有 system 模块写法，补齐 entity、bo、vo、mapper、service、controller。
+```
+
+### 期望执行方式
+
+- 先读 generator 的 `domain/bo/vo/service/serviceImpl/controller` 模板。
+- 再读 `system` 模块里最接近的现有管理模块。
+- 先生成骨架，再补权限、日志、校验、导出等细节。
+
+## 案例 2：修改已有复杂模块
+
+### 用户提问示例
+
+```text
+使用 $ruoyi-plus-ai-coding 修改 workflow/category 的查询和导出逻辑，保持现有模块风格，不要简化成模板式单表 CRUD。
+```
+
+### 期望执行方式
+
+- 先读当前 workflow 模块同类代码。
+- 判断这是“复杂模块增强”，不是“从零生成”。
+- 增量修改原逻辑，不要重写整个 service/controller。
+
+## 案例 3：补唯一性校验与删除前校验
+
+### 用户提问示例
+
+```text
+使用 $ruoyi-plus-ai-coding 为 demo/demo 模块补充新增和修改时的唯一性校验，并补充删除前校验。
+```
+
+### 期望执行方式
+
+- 优先修改 `validEntityBeforeSave(...)`。
+- 根据模块现有风格补 `ServiceException` 或显式失败返回。
+- 删除逻辑只补必要校验，不重构整套 CRUD。
+
+## 案例 4：补数据权限与联表查询
+
+### 用户提问示例
+
+```text
+使用 $ruoyi-plus-ai-coding 为 system 模块某个列表查询增加部门数据权限和联表字段返回，参考现有 user mapper 的 MPJ 与 DataPermission 写法。
+```
+
+### 期望执行方式
+
+- 先看 `SysUserMapper` 和相关 service。
+- 判断需要 `BaseMapperPlus` 重写还是 MPJ 联表。
+- 保持权限注解和联表风格一致。
+
+## 案例 5：新增后端接口并同步前端骨架
+
+### 用户提问示例
+
+```text
+使用 $ruoyi-plus-ai-coding 为 monitor/cache 新增一个导出接口，并同步补齐前端 api/types 调用骨架。
+```
+
+### 期望执行方式
+
+- 先补后端 `controller/service`。
+- 再根据后端路由补前端 `src/api` 或 generator 风格的前端骨架。
+- 保证导出接口路径和前端下载调用一致。
+
+## 案例 6：推荐的高质量任务描述
+
+下面这种描述最容易得到稳定结果：
+
+```text
+使用 $ruoyi-plus-ai-coding 在 workflow 模块新增一个标准列表管理功能：
+1. 需要分页、导出、详情、增删改
+2. 查询包含状态和创建时间范围
+3. 保持现有 workflow 模块风格
+4. 参考 generator 模板生成基础骨架
+5. 删除前需要做业务校验
+```
+
+## 不推荐的任务描述
+
+下面这种描述太模糊，容易导致产物偏离项目：
+
+```text
+帮我加个后端接口
+```
+
+更好的写法至少要补充：
+
+- 模块名
+- 表或业务名
+- 是新增还是修改
+- 是否需要分页、导出、权限、数据范围、联表
+- 想参考哪个现有模块

.codex/skills/ruoyi-plus-ai-coding/references/frontend.md

@@ -0,0 +1,71 @@
+# 前端约定
+
+## 优先参考的代码来源
+
+- `ruoyi-modules/ruoyi-gen/src/main/resources/vm/ts/*.vm`
+- `ruoyi-modules/ruoyi-gen/src/main/resources/vm/vue/*.vm`
+- 前端工程中与目标模块最接近的现有页面
+
+如果任务涉及前端，先看仓库里实际使用的前端目录和同类页面，不要直接套通用 Vue 习惯。
+
+## API 文件规则
+
+- 从 `@/utils/request` 引入 `request`。
+- 从 `axios` 引入 `AxiosPromise`。
+- 从 `@/api/<module>/<business>/types` 引入本模块类型。
+- 列表接口通常返回 `AxiosPromise<PageResult<Vo>>`。
+- 常规接口命名和路由保持：
+  `listXxx` -> `GET /<module>/<business>/list`
+  `getXxx` -> `GET /<module>/<business>/{id}`
+  `addXxx` -> `POST /<module>/<business>`
+  `updateXxx` -> `PUT /<module>/<business>`
+  `delXxx` -> `DELETE /<module>/<business>/{id or ids}`
+
+## 类型文件规则
+
+- 定义 `VO`、`Form`、`Query`。
+- `Form` 通常继承 `BaseEntity`。
+- 非树表页面的 `Query` 通常继承 `PageQuery`。
+- 各类 ID 字段通常用 `string | number`。
+- Java 数值类型通常映射为 `number`。
+- Boolean 映射为 `boolean`。
+- 其他生成字段默认多为 `string`。
+- 存在日期范围查询时保留 `params?: any`。
+
+## Vue 页面规则
+
+- 使用 `<script setup lang="ts">`。
+- 常见 import 来自本模块 API 和本地 `types`。
+- 通过 `getCurrentInstance()` 取 `proxy`，使用项目注入的公共工具。
+- 字典通常通过 `proxy?.useDict(...)` 获取，再用 `toRefs` 解构。
+- 常见状态包括：列表数组、`loading`、`buttonLoading`、`showSearch`、`ids`、`single`、`multiple`、`total`。
+- 查询和表单状态通常放在 `reactive<PageData<Form, Query>>({...})` 中。
+- 弹窗状态通常使用 `dialog.visible` 和 `dialog.title`。
+- 表单引用通常命名为 `queryFormRef` 和 `<business>FormRef`。
+
+## 页面行为规则
+
+- `getList` 负责设置 loading、处理日期范围参数、调用列表接口、回填 `rows` 和 `total`。
+- `handleQuery` 通常先把 `pageNum` 重置为 `1`，再重新查询。
+- `resetQuery` 负责清空日期范围和查询表单，然后重新加载。
+- `handleSelectionChange` 更新 `ids`、`single`、`multiple`。
+- `handleAdd` 先重置表单，再打开弹窗。
+- `handleUpdate` 先查详情，再把数据赋值到表单。
+- `submitForm` 校验表单、切换 `buttonLoading`、根据主键判断调用新增还是更新、提示成功并刷新列表。
+- `handleDelete` 使用 `proxy?.$modal.confirm(...)` 确认，再调用删除接口并刷新。
+- `handleExport` 使用 `proxy?.download(...)`。
+
+## 模板结构规则
+
+- 优先保持生成器的页面布局结构：搜索区卡片、表格区卡片、工具栏、分页、弹窗表单。
+- 保留 `v-hasPermi="['module:business:add']"` 这类权限指令。
+- 继续使用仓库已有组件：`right-toolbar`、`pagination`、`dict-tag`、`image-preview`、`image-upload`、`file-upload`、`editor`。
+- 已有页面对时间列使用 `parseTime` 时，新页面保持一致。
+- BETWEEN 日期查询继续使用 `el-date-picker` 加 `proxy?.addDateRange(...)`。
+
+## 避免事项
+
+- 生成器风格页面不要突然换成完全不同的状态管理方式，除非该前端目录本身已经这么做。
+- 模块已使用字典时，不要把选项文案硬编码到页面里。
+- 不要让 API 函数名和路由段偏离后端约定。
+- 后端 BO/service 依赖 begin/end 参数时，不要从查询对象里删掉 `params` 和日期范围处理。

.gitattributes

@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf

.gitignore

@@ -25,6 +25,9 @@ target/
 *.iml
 *.ipr
 
+### VS CODE ###
+.vscode
+
 ### JRebel ###
 rebel.xml
 
@@ -38,6 +41,7 @@ nbdist/
 ######################################################################
 # Others
 *.log
+*.log.gz
 *.xml.versionsBackup
 *.swp
 

.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,8 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+# Maven 3.9.X
+distributionUrl=https://mirrors.huaweicloud.com/apache/maven/maven-3/3.9.12/binaries/apache-maven-3.9.12-bin.zip
+# Maven 4.0
+#distributionUrl=https://mirrors.huaweicloud.com/apache/maven/maven-4/4.0.0-rc-5/binaries/apache-maven-4.0.0-rc-5-bin.zip
+# 分发类型为 only-script 或 bin 可以不需要该项（因为用不到），具体参考：https://maven.apache.org/tools/wrapper/maven-wrapper-distribution/index.html
+#wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.4/maven-wrapper-3.3.4.jar

.run/ruoyi-monitor-admin.run.xml

@@ -2,7 +2,7 @@
   <configuration default="false" name="ruoyi-monitor-admin" type="docker-deploy" factoryName="dockerfile" server-name="Docker">
     <deployment type="dockerfile">
       <settings>
-        <option name="imageTag" value="ruoyi/ruoyi-monitor-admin:5.4.1" />
+        <option name="imageTag" value="ruoyi/ruoyi-monitor-admin:5.5.3" />
         <option name="buildOnly" value="true" />
         <option name="sourceFilePath" value="ruoyi-extend/ruoyi-monitor-admin/Dockerfile" />
       </settings>

.run/ruoyi-server.run.xml

@@ -2,7 +2,7 @@
   <configuration default="false" name="ruoyi-server" type="docker-deploy" factoryName="dockerfile" server-name="Docker">
     <deployment type="dockerfile">
       <settings>
-        <option name="imageTag" value="ruoyi/ruoyi-server:5.4.1" />
+        <option name="imageTag" value="ruoyi/ruoyi-server:5.5.3" />
         <option name="buildOnly" value="true" />
         <option name="sourceFilePath" value="ruoyi-admin/Dockerfile" />
       </settings>

.run/ruoyi-snailjob-server.run.xml

@@ -2,7 +2,7 @@
   <configuration default="false" name="ruoyi-snailjob-server" type="docker-deploy" factoryName="dockerfile" server-name="Docker">
     <deployment type="dockerfile">
       <settings>
-        <option name="imageTag" value="ruoyi/ruoyi-snailjob-server:5.4.1" />
+        <option name="imageTag" value="ruoyi/ruoyi-snailjob-server:5.5.3" />
         <option name="buildOnly" value="true" />
         <option name="sourceFilePath" value="ruoyi-extend/ruoyi-snailjob-server/Dockerfile" />
       </settings>

README.md

@@ -5,13 +5,12 @@
 ## 平台简介
 
 [![码云Gitee](https://gitee.com/dromara/RuoYi-Vue-Plus/badge/star.svg?theme=blue)](https://gitee.com/dromara/RuoYi-Vue-Plus)
-[![GitHub](https://img.shields.io/github/stars/dromara/RuoYi-Vue-Plus.svg?style=social&label=Stars)](https://github.com/dromara/RuoYi-Vue-Plus)
+[![GitHub](https://img.shields.io/github/stars/dromara/RuoYi-Vue-Plus.svg?label=Github%20Stars)](https://github.com/dromara/RuoYi-Vue-Plus)
 [![Star](https://gitcode.com/dromara/RuoYi-Vue-Plus/star/badge.svg)](https://gitcode.com/dromara/RuoYi-Vue-Plus)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://gitee.com/dromara/RuoYi-Vue-Plus/blob/5.X/LICENSE)
-[![使用IntelliJ IDEA开发维护](https://img.shields.io/badge/IntelliJ%20IDEA-提供支持-blue.svg)](https://www.jetbrains.com/?from=RuoYi-Vue-Plus)
 <br>
-[![RuoYi-Vue-Plus](https://img.shields.io/badge/RuoYi_Vue_Plus-5.4.1-success.svg)](https://gitee.com/dromara/RuoYi-Vue-Plus)
-[![Spring Boot](https://img.shields.io/badge/Spring%20Boot-3.4-blue.svg)]()
+[![RuoYi-Vue-Plus](https://img.shields.io/badge/RuoYi_Vue_Plus-5.5.3-success.svg)](https://gitee.com/dromara/RuoYi-Vue-Plus)
+[![Spring Boot](https://img.shields.io/badge/Spring%20Boot-3.5-blue.svg)]()
 [![JDK-17](https://img.shields.io/badge/JDK-17-green.svg)]()
 [![JDK-21](https://img.shields.io/badge/JDK-21-green.svg)]()
 
@@ -23,21 +22,24 @@
 > 系统演示: [传送门](https://plus-doc.dromara.org/#/common/demo_system)
 
 > 官方前端项目地址: [gitee](https://gitee.com/JavaLionLi/plus-ui) - [github](https://github.com/JavaLionLi/plus-ui) - [gitcode](https://gitcode.com/dromara/plus-ui)<br>
-> 成员前端项目地址: 基于vben5 [ruoyi-plus-vben5](https://gitee.com/dapppp/ruoyi-plus-vben5)<br>
+> 成员前端项目地址: 基于vben5 [ruoyi-plus-vben5](https://github.com/imdap/ruoyi-plus-vben5)<br>
 > 成员前端项目地址: 基于soybean [ruoyi-plus-soybean](https://gitee.com/xlsea/ruoyi-plus-soybean)<br>
 > 成员项目地址: 删除多租户与工作流 [RuoYi-Vue-Plus-Single](https://gitee.com/ColorDreams/RuoYi-Vue-Plus-Single)<br>
 
-> 文档地址: [plus-doc](https://plus-doc.dromara.org) 文档在华为云上如果打不开大概率是DNS问题 可以尝试切换网络等方式(或者科学上网)
+> 文档地址: [plus-doc](https://plus-doc.dromara.org) 国内加速: [plus-doc.top](https://plus-doc.top)
 
 ## 赞助商
 
 MaxKey 业界领先单点登录产品 - https://gitee.com/dromara/MaxKey <br>
 CCFlow 驰聘低代码-流程-表单 - https://gitee.com/opencc/RuoYi-JFlow <br>
-数舵科技 软件定制开发APP小程序等 - http://www.shuduokeji.com/ <br>
+数舵科技 软件定制开发APP小程序等 - https://www.shuduokeji.com/ <br>
 引迈信息 软件开发平台 - https://www.jnpfsoft.com/index.html?from=plus-doc <br>
-<font color="red">**启山商城系统 多租户商城源码可免费商用可二次开发 - https://www.73app.cn/** </font><br>
 Mall4J 高质量Java商城系统 - https://www.mall4j.com/cn/?statId=11 <br>
-[如何成为赞助商 加群联系作者详谈](https://plus-doc.dromara.org/#/common/add_group)
+aizuda flowlong 工作流 - https://gitee.com/aizuda/flowlong <br>
+Ruoyi-Plus-Uniapp - https://ruoyi.plus <br>
+Topiam IAM/IDaaS身份管理平台 - https://www.topiam.cn/ <br>
+
+[如何成为赞助商 加群联系作者详谈 每日PV2500-3000 IP1700-2500](https://plus-doc.dromara.org/#/common/add_group)
 
 # 本框架与RuoYi的功能差异
 
@@ -45,13 +47,13 @@ Mall4J 高质量Java商城系统 - https://www.mall4j.com/cn/?statId=11 <br>
 |-------------|-------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------|
 | 前端项目        | 采用 Vue3 + TS + ElementPlus 重写                                                                                     | 基于Vue2/Vue3 + JS                                                                   | 
 | 后端项目结构      | 采用插件化 + 扩展包形式 结构解耦 易于扩展                                                                                           | 模块相互注入耦合严重难以扩展                                                                     | 
-| 后端代码风格      | 严格遵守Alibaba规范与项目统一配置的代码格式化                                                                                        | 代码书写与常规结构不同阅读障碍大                                                                   |
-| Web容器       | 采用 Undertow 基于 XNIO 的高性能容器                                                                                        | 采用 Tomcat                                                                          |
+| 后端代码风格      | 参考 Alibaba 规范与项目统一配置的代码格式化                                                                                        | 代码书写与常规结构不同阅读障碍大                                                                   |
+| Web容器       | 采用 Jetty 基于 Netty 的高性能容器                                                                                          | 采用 Tomcat                                                                          |
 | 权限认证        | 采用 Sa-Token、Jwt 静态使用功能齐全 低耦合 高扩展                                                                                  | Spring Security 配置繁琐扩展性极差                                                          |
 | 权限注解        | 采用 Sa-Token 支持注解 登录校验、角色校验、权限校验、二级认证校验、HttpBasic校验、忽略校验<br/>角色与权限校验支持多种条件 如 `AND` `OR` 或 `权限 OR 角色` 等复杂表达式        | 只支持是否存在匹配                                                                          |
 | 三方鉴权        | 采用 JustAuth 第三方登录组件 支持微信、钉钉等数十种三方认证                                                                               | 无                                                                                  |
 | 关系数据库支持     | 原生支持 MySQL、Oracle、PostgreSQL、SQLServer<br/>可同时使用异构切换(支持其他 mybatis-plus 支持的所有数据库 只需要增加jdbc依赖即可使用 达梦金仓等均有成功案例)      | 支持 Mysql、Oracle 不支持同时使用、不支持异构切换                                                    |
-| 缓存数据库       | 支持 Redis 5-7 支持大部分新功能特性 如 分布式限流、分布式队列                                                                             | Redis 简单 get set 支持                                                                |
+| 缓存数据库       | 支持 Redis >= 6 支持大部分新功能特性 如 分布式限流、分布式队列                                                                            | Redis 简单 get set 支持                                                                |
 | Redis客户端    | 采用 Redisson Redis官方推荐 基于Netty的客户端工具<br/>支持Redis 90%以上的命令 底层优化规避很多不正确的用法 例如: keys被转换为scan<br/>支持单机、哨兵、单主集群、多主集群等模式 | Lettuce + RedisTemplate 支持模式少 工具使用繁琐<br/>连接池采用 common-pool Bug多经常性出问题              |
 | 缓存注解        | 采用 Spring-Cache 注解 对其扩展了实现支持了更多功能<br/>例如 过期时间 最大空闲时间 组最大长度等 只需一个注解即可完成数据自动缓存                                      | 需手动编写Redis代码逻辑                                                                     |
 | ORM框架       | 采用 Mybatis-Plus 基于对象几乎不用写SQL全java操作 功能强大插件众多<br/>例如多租户插件 分页插件 乐观锁插件等等                                             | 采用 Mybatis 基于XML需要手写SQL                                                            |
@@ -72,14 +74,14 @@ Mall4J 高质量Java商城系统 - https://www.mall4j.com/cn/?statId=11 <br>
 | 分布式幂等       | 参考美团GTIS防重系统简化实现(细节可看文档)                                                                                          | 手动编写注解基于aop实现                                                                      |
 | 分布式锁        | 采用 Lock4j 底层基于 Redisson                                                                                           | 无                                                                                  |
 | 分布式任务调度     | 采用 SnailJob 天生支持分布式 统一的管理中心 支持多种数据库 支持分片重试DAG任务流等                                                                 | 采用 Quartz 基于数据库锁性能差 集群需要做很多配置与改造                                                   | 
-| 文件存储        | 采用 Minio 分布式文件存储 天生支持多机、多硬盘、多分片、多副本存储<br/>支持权限管理 安全可靠 文件可加密存储                                                     | 采用 本机文件存储 文件裸漏 易丢失泄漏 不支持集群有单点效应                                                    |
+| 文件存储        | 采用 Minio、RustFS 分布式文件存储 天生支持多机、多硬盘、多分片、多副本存储<br/>支持权限管理 安全可靠 文件可加密存储                                              | 采用 本机文件存储 文件裸漏 易丢失泄漏 不支持集群有单点效应                                                    |
 | 云存储         | 采用 AWS S3 协议客户端 支持 七牛、阿里、腾讯 等一切支持S3协议的厂家                                                                          | 不支持                                                                                |
 | 短信          | 采用 sms4j 短信融合包 支持数十种短信厂家 只需在yml配置好厂家密钥即可使用 可多厂家共用                                                                 | 不支持                                                                                |
 | 邮件          | 采用 mail-api 通用协议支持大部分邮件厂商                                                                                         | 不支持                                                                                |
 | 接口文档        | 采用 SpringDoc、javadoc 无注解零入侵基于java注释<br/>只需把注释写好 无需再写一大堆的文档注解了                                                     | 采用 Springfox 已停止维护 需要编写大量的注解来支持文档生成                                                | 
 | 校验框架        | 采用 Validation 支持注解与工具类校验 注解支持国际化                                                                                  | 仅支持注解 且注解不支持国际化                                                                    |
-| Excel框架     | 采用 FastExcel(原Alibaba EasyExcel) 基于插件化<br/>框架对其增加了很多功能 例如 自动合并相同内容 自动排列布局 字典翻译等                                   | 基于 POI 手写实现 功能有限 复杂 扩展性差                                                           |
-| 工作流支持       | 支持各种复杂审批 转办 委派 加减签 会签 或签 票签 等功能                                                                                   | 无                                                                                  |
+| Excel框架     | 采用 Apache Fesod(原Alibaba EasyExcel) 基于插件化<br/>框架对其增加了很多功能 例如 自动合并相同内容 自动排列布局 字典翻译等                                | 基于 POI 手写实现 功能有限 复杂 扩展性差                                                           |
+| 工作流支持       | 采用 WarmFlow 支持各种复杂审批 转办 委派 加减签 会签 或签 票签 等功能                                                                       | 无                                                                                  |
 | 工具类框架       | 采用 Hutool、Lombok 上百种工具覆盖90%的使用需求 基于注解自动生成 get set 等简化框架大量代码                                                       | 手写工具稳定性差易出问题 工具数量有限 代码臃肿需自己手写 get set 等                                            | 
 | 监控框架        | 采用 SpringBoot-Admin 基于SpringBoot官方 actuator 探针机制<br/>实时监控服务状态 框架还为其扩展了在线日志查看监控                                    | 无                                                                                  | 
 | 链路追踪        | 采用 Apache SkyWalking 还在为请求不知道去哪了 到哪出了问题而烦恼吗<br/>用了它即可实时查看请求经过的每一处每一个节点                                            | 无                                                                                  |
@@ -95,8 +97,6 @@ Mall4J 高质量Java商城系统 - https://www.mall4j.com/cn/?statId=11 <br>
 
 | 业务     | 功能说明                                                                 | 本框架 | RuoYi            |
 |--------|----------------------------------------------------------------------|-----|------------------|
-| 租户管理   | 系统内租户的管理 如:租户套餐、过期时间、用户数量、企业信息等                                      | 支持  | 无                |
-| 租户套餐管理 | 系统内租户所能使用的套餐管理 如:套餐内所包含的菜单等                                          | 支持  | 无                |
 | 客户端管理  | 系统内对接的所有客户端管理 如: pc端、小程序端等<br>支持动态授权登录方式 如: 短信登录、密码登录等 支持动态控制token时效 | 支持  | 无                |
 | 用户管理   | 用户的管理配置 如:新增用户、分配用户所属部门、角色、岗位等                                       | 支持  | 支持               |
 | 部门管理   | 配置系统组织机构（公司、部门、小组） 树结构展现支持数据权限                                       | 支持  | 支持               |

mvnw

@@ -0,0 +1,295 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.4
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+scriptDir="$(dirname "$0")"
+scriptName="$(basename "$0")"
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+actualDistributionDir=""
+
+# First try the expected directory name (for regular distributions)
+if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then
+  if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then
+    actualDistributionDir="$distributionUrlNameMain"
+  fi
+fi
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if [ -z "$actualDistributionDir" ]; then
+  # enable globbing to iterate over items
+  set +f
+  for dir in "$TMP_DOWNLOAD_DIR"/*; do
+    if [ -d "$dir" ]; then
+      if [ -f "$dir/bin/$MVN_CMD" ]; then
+        actualDistributionDir="$(basename "$dir")"
+        break
+      fi
+    fi
+  done
+  set -f
+fi
+
+if [ -z "$actualDistributionDir" ]; then
+  verbose "Contents of $TMP_DOWNLOAD_DIR:"
+  verbose "$(ls -la "$TMP_DOWNLOAD_DIR")"
+  die "Could not find Maven distribution directory in extracted archive"
+fi
+
+verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"

mvnw.cmd

@@ -0,0 +1,191 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.4
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+$mavenM2Item = Get-Item $MAVEN_M2_PATH
+$mavenM2Target = @($mavenM2Item.Target)
+if ($mavenM2Target.Count -gt 0 -and $null -ne $mavenM2Target[0]) {
+  $MAVEN_WRAPPER_DISTS = $mavenM2Target[0] + "/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"

pom.xml

@@ -13,49 +13,53 @@
     <description>Dromara RuoYi-Vue-Plus多租户管理系统</description>
 
     <properties>
-        <revision>5.4.1</revision>
-        <spring-boot.version>3.4.7</spring-boot.version>
+        <revision>5.5.3</revision>
+        <spring-boot.version>4.0.3</spring-boot.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <java.version>17</java.version>
-        <mybatis.version>3.5.16</mybatis.version>
-        <springdoc.version>2.8.8</springdoc.version>
+        <java.version>21</java.version>
+        <mybatis.version>3.5.19</mybatis.version>
+        <springdoc.version>3.0.2</springdoc.version>
         <therapi-javadoc.version>0.15.0</therapi-javadoc.version>
-        <fastexcel.version>1.2.0</fastexcel.version>
-        <velocity.version>2.3</velocity.version>
-        <satoken.version>1.44.0</satoken.version>
-        <mybatis-plus.version>3.5.12</mybatis-plus.version>
+        <fesod.version>2.0.1-incubating</fesod.version>
+        <velocity.version>2.4.1</velocity.version>
+        <satoken.version>1.45.0</satoken.version>
+        <mybatis-plus.version>3.5.16</mybatis-plus.version>
+        <mybatis-plus-join.version>1.5.6</mybatis-plus-join.version>
         <p6spy.version>3.9.1</p6spy.version>
-        <hutool.version>5.8.38</hutool.version>
-        <spring-boot-admin.version>3.4.7</spring-boot-admin.version>
-        <redisson.version>3.50.0</redisson.version>
+        <hutool.version>5.8.43</hutool.version>
+        <spring-boot-admin.version>4.0.2</spring-boot-admin.version>
+        <redisson.version>4.3.0</redisson.version>
         <lock4j.version>2.2.7</lock4j.version>
-        <dynamic-ds.version>4.3.1</dynamic-ds.version>
-        <snailjob.version>1.5.0</snailjob.version>
-        <mapstruct-plus.version>1.4.8</mapstruct-plus.version>
+        <dynamic-ds.version>4.5.0</dynamic-ds.version>
+        <snailjob.version>1.9.0</snailjob.version>
+        <mapstruct-plus.version>1.5.0</mapstruct-plus.version>
         <mapstruct-plus.lombok.version>0.2.0</mapstruct-plus.lombok.version>
-        <lombok.version>1.18.36</lombok.version>
-        <bouncycastle.version>1.80</bouncycastle.version>
+        <lombok.version>1.18.42</lombok.version>
+        <bouncycastle.version>1.83</bouncycastle.version>
         <justauth.version>1.16.7</justauth.version>
         <!-- 离线IP地址定位库 -->
-        <ip2region.version>2.7.0</ip2region.version>
+        <ip2region.version>3.3.6</ip2region.version>
         <!-- OSS 配置 -->
-        <aws.sdk.version>2.28.22</aws.sdk.version>
+        <aws.sdk.version>2.42.9</aws.sdk.version>
         <!-- SMS 配置 -->
-        <sms4j.version>3.3.4</sms4j.version>
+        <sms4j.version>3.3.5</sms4j.version>
         <!-- 限制框架中的fastjson版本 -->
         <fastjson.version>1.2.83</fastjson.version>
         <!-- 面向运行时的D-ORM依赖 -->
-        <anyline.version>8.7.2-20250603</anyline.version>
+        <anyline.version>8.7.3-20260306</anyline.version>
         <!-- 工作流配置 -->
-        <warm-flow.version>1.7.4</warm-flow.version>
+        <warm-flow.version>1.8.4</warm-flow.version>
+        <!-- mqtt客户端 -->
+        <mica-mqtt.version>2.5.12</mica-mqtt.version>
 
         <!-- 插件版本 -->
-        <maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
-        <maven-war-plugin.version>3.4.0</maven-war-plugin.version>
-        <maven-compiler-plugin.version>3.14.0</maven-compiler-plugin.version>
-        <maven-surefire-plugin.version>3.5.3</maven-surefire-plugin.version>
-        <flatten-maven-plugin.version>1.3.0</flatten-maven-plugin.version>
+        <maven-jar-plugin.version>3.5.0</maven-jar-plugin.version>
+        <maven-war-plugin.version>3.5.1</maven-war-plugin.version>
+        <maven-compiler-plugin.version>3.15.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>3.5.5</maven-surefire-plugin.version>
+        <!-- 统一版本号管理：Maven3.X需要，Maven4.0之后已原生支持 -->
+        <flatten-maven-plugin.version>1.7.3</flatten-maven-plugin.version>
         <!-- 打包默认跳过测试 -->
         <skipTests>true</skipTests>
     </properties>
@@ -118,23 +122,14 @@
                 <scope>import</scope>
             </dependency>
 
-            <!-- Warm-Flow国产工作流引擎, 在线文档：http://warm-flow.cn/ -->
+            <!-- sa-token-bom 依赖 -->
+            <!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
             <dependency>
-                <groupId>org.dromara.warm</groupId>
-                <artifactId>warm-flow-mybatis-plus-sb3-starter</artifactId>
-                <version>${warm-flow.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>org.dromara.warm</groupId>
-                <artifactId>warm-flow-plugin-ui-sb-web</artifactId>
-                <version>${warm-flow.version}</version>
-            </dependency>
-
-            <!-- JustAuth 的依赖配置-->
-            <dependency>
-                <groupId>me.zhyd.oauth</groupId>
-                <artifactId>JustAuth</artifactId>
-                <version>${justauth.version}</version>
+                <groupId>cn.dev33</groupId>
+                <artifactId>sa-token-bom</artifactId>
+                <version>${satoken.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
             </dependency>
 
             <!-- common 的依赖配置-->
@@ -164,10 +159,11 @@
                 <version>${lombok.version}</version>
             </dependency>
 
+            <!-- fesod (EasyExcel/FastExcel的前身) 的依赖 -->
             <dependency>
-                <groupId>cn.idev.excel</groupId>
-                <artifactId>fastexcel</artifactId>
-                <version>${fastexcel.version}</version>
+                <groupId>org.apache.fesod</groupId>
+                <artifactId>fesod-sheet</artifactId>
+                <version>${fesod.version}</version>
             </dependency>
 
             <!-- velocity代码生成使用模板 -->
@@ -177,34 +173,10 @@
                 <version>${velocity.version}</version>
             </dependency>
 
-            <!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
-            <dependency>
-                <groupId>cn.dev33</groupId>
-                <artifactId>sa-token-spring-boot3-starter</artifactId>
-                <version>${satoken.version}</version>
-            </dependency>
-            <!-- Sa-Token 整合 jwt -->
-            <dependency>
-                <groupId>cn.dev33</groupId>
-                <artifactId>sa-token-jwt</artifactId>
-                <version>${satoken.version}</version>
-                <exclusions>
-                    <exclusion>
-                        <groupId>cn.hutool</groupId>
-                        <artifactId>hutool-all</artifactId>
-                    </exclusion>
-                </exclusions>
-            </dependency>
-            <dependency>
-                <groupId>cn.dev33</groupId>
-                <artifactId>sa-token-core</artifactId>
-                <version>${satoken.version}</version>
-            </dependency>
-
             <!-- dynamic-datasource 多数据源-->
             <dependency>
                 <groupId>com.baomidou</groupId>
-                <artifactId>dynamic-datasource-spring-boot3-starter</artifactId>
+                <artifactId>dynamic-datasource-spring-boot4-starter</artifactId>
                 <version>${dynamic-ds.version}</version>
             </dependency>
 
@@ -216,7 +188,7 @@
 
             <dependency>
                 <groupId>com.baomidou</groupId>
-                <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
+                <artifactId>mybatis-plus-spring-boot4-starter</artifactId>
                 <version>${mybatis-plus.version}</version>
             </dependency>
 
@@ -232,6 +204,12 @@
                 <version>${mybatis-plus.version}</version>
             </dependency>
 
+            <dependency>
+                <groupId>com.github.yulichang</groupId>
+                <artifactId>mybatis-plus-join-boot-starter</artifactId>
+                <version>${mybatis-plus-join.version}</version>
+            </dependency>
+
             <!-- sql性能分析插件 -->
             <dependency>
                 <groupId>p6spy</groupId>
@@ -245,13 +223,13 @@
                 <artifactId>s3</artifactId>
                 <version>${aws.sdk.version}</version>
             </dependency>
-            <!-- 基于 AWS CRT 的 S3 客户端的性能增强的 S3 传输管理器 -->
+            <!-- 客户端的性能增强传输管理器 -->
             <dependency>
                 <groupId>software.amazon.awssdk</groupId>
                 <artifactId>s3-transfer-manager</artifactId>
                 <version>${aws.sdk.version}</version>
             </dependency>
-            <!-- 将基于 Netty 的 HTTP 客户端从类路径中移除 -->
+            <!-- 适用于 Netty 的客户端 -->
             <dependency>
                 <groupId>software.amazon.awssdk</groupId>
                 <artifactId>netty-nio-client</artifactId>
@@ -303,7 +281,7 @@
             <!-- 加密包引入 -->
             <dependency>
                 <groupId>org.bouncycastle</groupId>
-                <artifactId>bcprov-jdk15to18</artifactId>
+                <artifactId>bcpkix-jdk18on</artifactId>
                 <version>${bouncycastle.version}</version>
             </dependency>
 
@@ -313,6 +291,31 @@
                 <version>${mapstruct-plus.version}</version>
             </dependency>
 
+            <!-- Warm-Flow国产工作流引擎, 在线文档：http://warm-flow.cn/ -->
+            <dependency>
+                <groupId>org.dromara.warm</groupId>
+                <artifactId>warm-flow-mybatis-plus-sb3-starter</artifactId>
+                <version>${warm-flow.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.dromara.warm</groupId>
+                <artifactId>warm-flow-plugin-ui-sb-web</artifactId>
+                <version>${warm-flow.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.dromara.mica-mqtt</groupId>
+                <artifactId>mica-mqtt-client-spring-boot-starter</artifactId>
+                <version>${mica-mqtt.version}</version>
+            </dependency>
+
+            <!-- JustAuth 的依赖配置-->
+            <dependency>
+                <groupId>me.zhyd.oauth</groupId>
+                <artifactId>JustAuth</artifactId>
+                <version>${justauth.version}</version>
+            </dependency>
+
             <!-- 离线IP地址定位库 ip2region -->
             <dependency>
                 <groupId>org.lionsoul</groupId>
@@ -340,7 +343,7 @@
 
             <dependency>
                 <groupId>org.dromara</groupId>
-                <artifactId>ruoyi-generator</artifactId>
+                <artifactId>ruoyi-gen</artifactId>
                 <version>${revision}</version>
             </dependency>
 
@@ -375,8 +378,7 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven-compiler-plugin.version}</version>
                 <configuration>
-                    <source>${java.version}</source>
-                    <target>${java.version}</target>
+                    <release>${java.version}</release>
                     <encoding>${project.build.sourceEncoding}</encoding>
                     <annotationProcessorPaths>
                         <path>

ruoyi-admin/Dockerfile

@@ -1,6 +1,6 @@
 # 贝尔实验室 Spring 官方推荐镜像 JDK下载地址 https://bell-sw.com/pages/downloads/
-FROM bellsoft/liberica-openjdk-rocky:17.0.15-cds
-#FROM bellsoft/liberica-openjdk-rocky:21.0.7-cds
+FROM bellsoft/liberica-openjdk-rocky:17.0.16-cds
+#FROM bellsoft/liberica-openjdk-rocky:21.0.8-cds
 #FROM findepi/graalvm:java17-native
 
 LABEL maintainer="Lion Li"

ruoyi-admin/pom.xml

@@ -55,11 +55,6 @@
             <artifactId>ruoyi-common-social</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>org.dromara</groupId>
-            <artifactId>ruoyi-common-ratelimiter</artifactId>
-        </dependency>
-
         <dependency>
             <groupId>org.dromara</groupId>
             <artifactId>ruoyi-common-mail</artifactId>
@@ -78,7 +73,7 @@
         <!-- 代码生成-->
         <dependency>
             <groupId>org.dromara</groupId>
-            <artifactId>ruoyi-generator</artifactId>
+            <artifactId>ruoyi-gen</artifactId>
         </dependency>
 
         <!--  demo模块  -->

ruoyi-admin/src/main/java/org/dromara/web/controller/AuthController.java

@@ -1,10 +1,7 @@
 package org.dromara.web.controller;
 
 import cn.dev33.satoken.annotation.SaIgnore;
-import cn.dev33.satoken.exception.NotLoginException;
 import cn.dev33.satoken.stp.StpUtil;
-import cn.hutool.core.codec.Base64;
-import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import jakarta.servlet.http.HttpServletRequest;
 import lombok.RequiredArgsConstructor;
@@ -15,45 +12,43 @@ import me.zhyd.oauth.request.AuthRequest;
 import me.zhyd.oauth.utils.AuthStateUtils;
 import org.dromara.common.core.constant.SystemConstants;
 import org.dromara.common.core.domain.R;
+import org.dromara.common.core.domain.dto.PushPayloadDTO;
 import org.dromara.common.core.domain.model.LoginBody;
 import org.dromara.common.core.domain.model.RegisterBody;
 import org.dromara.common.core.domain.model.SocialLoginBody;
-import org.dromara.common.core.utils.*;
+import org.dromara.common.core.enums.PushSourceEnum;
+import org.dromara.common.core.enums.PushTypeEnum;
+import org.dromara.common.core.service.MessageService;
+import org.dromara.common.core.utils.DateUtils;
+import org.dromara.common.core.utils.MessageUtils;
+import org.dromara.common.core.utils.StringUtils;
+import org.dromara.common.core.utils.ValidatorUtils;
 import org.dromara.common.encrypt.annotation.ApiEncrypt;
 import org.dromara.common.json.utils.JsonUtils;
+import org.dromara.common.redis.annotation.RateLimiter;
+import org.dromara.common.redis.enums.LimitType;
 import org.dromara.common.satoken.utils.LoginHelper;
 import org.dromara.common.social.config.properties.SocialLoginConfigProperties;
 import org.dromara.common.social.config.properties.SocialProperties;
 import org.dromara.common.social.utils.SocialUtils;
-import org.dromara.common.sse.dto.SseMessageDto;
-import org.dromara.common.sse.utils.SseMessageUtils;
-import org.dromara.common.tenant.helper.TenantHelper;
-import org.dromara.system.domain.bo.SysTenantBo;
 import org.dromara.system.domain.vo.SysClientVo;
-import org.dromara.system.domain.vo.SysTenantVo;
 import org.dromara.system.service.ISysClientService;
 import org.dromara.system.service.ISysConfigService;
 import org.dromara.system.service.ISysSocialService;
-import org.dromara.system.service.ISysTenantService;
-import org.dromara.web.domain.vo.LoginTenantVo;
 import org.dromara.web.domain.vo.LoginVo;
-import org.dromara.web.domain.vo.TenantListVo;
 import org.dromara.web.service.IAuthStrategy;
 import org.dromara.web.service.SysLoginService;
 import org.dromara.web.service.SysRegisterService;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
-import java.net.URL;
-import java.nio.charset.StandardCharsets;
-import java.util.HashMap;
+import java.util.Date;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
 /**
- * 认证
+ * 认证控制器，提供登录、注册、社交绑定和退出能力。
  *
  * @author Lion Li
  */
@@ -68,10 +63,10 @@ public class AuthController {
     private final SysLoginService loginService;
     private final SysRegisterService registerService;
     private final ISysConfigService configService;
-    private final ISysTenantService tenantService;
     private final ISysSocialService socialUserService;
     private final ISysClientService clientService;
     private final ScheduledExecutorService scheduledExecutorService;
+    private final MessageService messageService;
 
 
     /**
@@ -96,48 +91,46 @@ public class AuthController {
         } else if (!SystemConstants.NORMAL.equals(client.getStatus())) {
             return R.fail(MessageUtils.message("auth.grant.type.blocked"));
         }
-        // 校验租户
-        loginService.checkTenant(loginBody.getTenantId());
         // 登录
         LoginVo loginVo = IAuthStrategy.login(body, client, grantType);
 
         Long userId = LoginHelper.getUserId();
         scheduledExecutorService.schedule(() -> {
-            SseMessageDto dto = new SseMessageDto();
-            dto.setMessage("欢迎登录RuoYi-Vue-Plus后台管理系统");
-            dto.setUserIds(List.of(userId));
-            SseMessageUtils.publishMessage(dto);
+            messageService.publishMessage(
+                List.of(userId),
+                PushPayloadDTO.of(
+                    PushTypeEnum.MESSAGE,
+                    PushSourceEnum.BACKEND,
+                    DateUtils.getTodayHour(new Date()) + "好，欢迎登录 RuoYi-Vue-Plus 后台管理系统",
+                    null
+                )
+            );
         }, 5, TimeUnit.SECONDS);
         return R.ok(loginVo);
     }
 
     /**
-     * 获取跳转URL
+     * 获取第三方绑定跳转地址。
      *
      * @param source 登录来源
-     * @return 结果
+     * @return 跳转地址
      */
     @GetMapping("/binding/{source}")
-    public R<String> authBinding(@PathVariable("source") String source,
-                                 @RequestParam String tenantId, @RequestParam String domain) {
+    public R<String> authBinding(@PathVariable("source") String source) {
         SocialLoginConfigProperties obj = socialProperties.getType().get(source);
         if (ObjectUtil.isNull(obj)) {
             return R.fail(source + "平台账号暂不支持");
         }
         AuthRequest authRequest = SocialUtils.getAuthRequest(source, socialProperties);
-        Map<String, String> map = new HashMap<>();
-        map.put("tenantId", tenantId);
-        map.put("domain", domain);
-        map.put("state", AuthStateUtils.createState());
-        String authorizeUrl = authRequest.authorize(Base64.encode(JsonUtils.toJsonString(map), StandardCharsets.UTF_8));
+        String authorizeUrl = authRequest.authorize(AuthStateUtils.createState());
         return R.ok("操作成功", authorizeUrl);
     }
 
     /**
-     * 前端回调绑定授权(需要token)
+     * 处理前端回调后的社交账号绑定。
      *
      * @param loginBody 请求体
-     * @return 结果
+     * @return 操作结果
      */
     @PostMapping("/social/callback")
     public R<Void> socialCallback(@RequestBody SocialLoginBody loginBody) {
@@ -145,8 +138,8 @@ public class AuthController {
         StpUtil.checkLogin();
         // 获取第三方登录信息
         AuthResponse<AuthUser> response = SocialUtils.loginAuth(
-                loginBody.getSource(), loginBody.getSocialCode(),
-                loginBody.getSocialState(), socialProperties);
+            loginBody.getSource(), loginBody.getSocialCode(),
+            loginBody.getSocialState(), socialProperties);
         AuthUser authUserData = response.getData();
         // 判断授权响应是否成功
         if (!response.ok()) {
@@ -158,9 +151,10 @@ public class AuthController {
 
 
     /**
-     * 取消授权(需要token)
+     * 取消当前用户的社交账号授权。
      *
      * @param socialId socialId
+     * @return 操作结果
      */
     @DeleteMapping(value = "/unlock/{socialId}")
     public R<Void> unlockSocial(@PathVariable Long socialId) {
@@ -181,12 +175,15 @@ public class AuthController {
     }
 
     /**
-     * 用户注册
+     * 用户注册。
+     *
+     * @param user 注册信息
+     * @return 操作结果
      */
     @ApiEncrypt
     @PostMapping("/register")
     public R<Void> register(@Validated @RequestBody RegisterBody user) {
-        if (!configService.selectRegisterEnabled(user.getTenantId())) {
+        if (!configService.selectRegisterEnabled()) {
             return R.fail("当前系统没有开启注册功能！");
         }
         registerService.register(user);
@@ -194,46 +191,24 @@ public class AuthController {
     }
 
     /**
-     * 登录页面租户下拉框
+     * 获取登录页租户下拉框数据，当前仅预留返回结构。
      *
+     * @param request 当前请求
      * @return 租户列表
+     * @throws Exception 异常
      */
+    @RateLimiter(time = 60, count = 20, limitType = LimitType.IP)
     @GetMapping("/tenant/list")
     public R<LoginTenantVo> tenantList(HttpServletRequest request) throws Exception {
-        // 返回对象
-        LoginTenantVo result = new LoginTenantVo();
-        boolean enable = TenantHelper.isEnable();
-        result.setTenantEnabled(enable);
-        // 如果未开启租户这直接返回
-        if (!enable) {
-            return R.ok(result);
-        }
-
-        List<SysTenantVo> tenantList = tenantService.queryList(new SysTenantBo());
-        List<TenantListVo> voList = MapstructUtils.convert(tenantList, TenantListVo.class);
-        try {
-            // 如果只超管返回所有租户
-            if (LoginHelper.isSuperAdmin()) {
-                result.setVoList(voList);
-                return R.ok(result);
-            }
-        } catch (NotLoginException ignored) {
-        }
-
-        // 获取域名
-        String host;
-        String referer = request.getHeader("referer");
-        if (StringUtils.isNotBlank(referer)) {
-            // 这里从referer中取值是为了本地使用hosts添加虚拟域名，方便本地环境调试
-            host = referer.split("//")[1].split("/")[0];
-        } else {
-            host = new URL(request.getRequestURL().toString()).getHost();
-        }
-        // 根据域名进行筛选
-        List<TenantListVo> list = StreamUtils.filter(voList, vo ->
-            StringUtils.equalsIgnoreCase(vo.getDomain(), host));
-        result.setVoList(CollUtil.isNotEmpty(list) ? list : voList);
-        return R.ok(result);
+        // 暂时预留给前端使用 后续删除
+        return R.ok(new LoginTenantVo(false));
     }
 
+    /**
+     * 登录租户列表响应对象。
+     *
+     * @param tenantEnabled 是否启用租户
+     */
+    public record LoginTenantVo(Boolean tenantEnabled) {
+    }
 }

ruoyi-admin/src/main/java/org/dromara/web/controller/CaptchaController.java

@@ -1,8 +1,9 @@
 package org.dromara.web.controller;
 
 import cn.dev33.satoken.annotation.SaIgnore;
-import cn.hutool.captcha.AbstractCaptcha;
 import cn.hutool.captcha.generator.CodeGenerator;
+import cn.hutool.captcha.generator.MathGenerator;
+import cn.hutool.captcha.generator.RandomGenerator;
 import cn.hutool.core.util.IdUtil;
 import cn.hutool.core.util.RandomUtil;
 import jakarta.validation.constraints.NotBlank;
@@ -14,18 +15,17 @@ import org.dromara.common.core.domain.R;
 import org.dromara.common.core.exception.ServiceException;
 import org.dromara.common.core.utils.SpringUtils;
 import org.dromara.common.core.utils.StringUtils;
-import org.dromara.common.core.utils.reflect.ReflectUtils;
+import org.dromara.common.core.utils.regex.RegexValidator;
 import org.dromara.common.mail.config.properties.MailProperties;
 import org.dromara.common.mail.utils.MailUtils;
-import org.dromara.common.ratelimiter.annotation.RateLimiter;
-import org.dromara.common.ratelimiter.enums.LimitType;
+import org.dromara.common.redis.annotation.RateLimiter;
+import org.dromara.common.redis.enums.LimitType;
 import org.dromara.common.redis.utils.RedisUtils;
 import org.dromara.common.web.config.properties.CaptchaProperties;
-import org.dromara.common.web.enums.CaptchaType;
+import org.dromara.common.web.core.WaveAndCircleCaptcha;
 import org.dromara.sms4j.api.SmsBlend;
 import org.dromara.sms4j.api.entity.SmsResponse;
 import org.dromara.sms4j.core.factory.SmsFactory;
-import org.dromara.web.domain.vo.CaptchaVo;
 import org.springframework.expression.Expression;
 import org.springframework.expression.ExpressionParser;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
@@ -33,6 +33,7 @@ import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.awt.*;
 import java.time.Duration;
 import java.util.LinkedHashMap;
 
@@ -52,14 +53,18 @@ public class CaptchaController {
     private final MailProperties mailProperties;
 
     /**
-     * 短信验证码
+     * 发送短信验证码。
      *
-     * @param phonenumber 用户手机号
+     * @param phoneNumber 用户手机号
+     * @return 操作结果
      */
     @RateLimiter(key = "#phonenumber", time = 60, count = 1)
     @GetMapping("/resource/sms/code")
-    public R<Void> smsCode(@NotBlank(message = "{user.phonenumber.not.blank}") String phonenumber) {
-        String key = GlobalConstants.CAPTCHA_CODE_KEY + phonenumber;
+    public R<Void> smsCode(@NotBlank(message = "{user.phonenumber.not.blank}") String phoneNumber) {
+        if (!RegexValidator.isMobile(phoneNumber)) {
+            return R.fail("请输入正确的手机号！");
+        }
+        String key = GlobalConstants.CAPTCHA_CODE_KEY + phoneNumber;
         String code = RandomUtil.randomNumbers(4);
         RedisUtils.setCacheObject(key, code, Duration.ofMinutes(Constants.CAPTCHA_EXPIRATION));
         // 验证码模板id 自行处理 (查数据库或写死均可)
@@ -67,7 +72,7 @@ public class CaptchaController {
         LinkedHashMap<String, String> map = new LinkedHashMap<>(1);
         map.put("code", code);
         SmsBlend smsBlend = SmsFactory.getSmsBlend("config1");
-        SmsResponse smsResponse = smsBlend.sendMessage(phonenumber, templateId, map);
+        SmsResponse smsResponse = smsBlend.sendMessage(phoneNumber, templateId, map);
         if (!smsResponse.isSuccess()) {
             log.error("验证码短信发送异常 => {}", smsResponse);
             return R.fail(smsResponse.getData().toString());
@@ -76,22 +81,27 @@ public class CaptchaController {
     }
 
     /**
-     * 邮箱验证码
+     * 发送邮箱验证码
      *
      * @param email 邮箱
+     * @return 操作结果
      */
     @GetMapping("/resource/email/code")
     public R<Void> emailCode(@NotBlank(message = "{user.email.not.blank}") String email) {
         if (!mailProperties.getEnabled()) {
             return R.fail("当前系统没有开启邮箱功能！");
         }
+        if (!RegexValidator.isEmail(email)) {
+            return R.fail("请输入正确的邮箱地址！");
+        }
         SpringUtils.getAopProxy(this).emailCodeImpl(email);
         return R.ok();
     }
 
     /**
-     * 邮箱验证码
-     * 独立方法避免验证码关闭之后仍然走限流
+     * 发送邮箱验证码的实际执行方法，拆分出来避免开关关闭时仍触发限流。
+     *
+     * @param email 邮箱
      */
     @RateLimiter(key = "#email", time = 60, count = 1)
     public void emailCodeImpl(String email) {
@@ -107,22 +117,23 @@ public class CaptchaController {
     }
 
     /**
-     * 生成验证码
+     * 获取图片验证码。
+     *
+     * @return 验证码信息
      */
     @GetMapping("/auth/code")
     public R<CaptchaVo> getCode() {
         boolean captchaEnabled = captchaProperties.getEnable();
         if (!captchaEnabled) {
-            CaptchaVo captchaVo = new CaptchaVo();
-            captchaVo.setCaptchaEnabled(false);
-            return R.ok(captchaVo);
+            return R.ok(new CaptchaVo(false, null, null));
         }
         return R.ok(SpringUtils.getAopProxy(this).getCodeImpl());
     }
 
     /**
-     * 生成验证码
-     * 独立方法避免验证码关闭之后仍然走限流
+     * 实际生成图片验证码并缓存结果。
+     *
+     * @return 验证码信息
      */
     @RateLimiter(time = 60, count = 10, limitType = LimitType.IP)
     public CaptchaVo getCodeImpl() {
@@ -130,25 +141,37 @@ public class CaptchaController {
         String uuid = IdUtil.simpleUUID();
         String verifyKey = GlobalConstants.CAPTCHA_CODE_KEY + uuid;
         // 生成验证码
-        CaptchaType captchaType = captchaProperties.getType();
-        boolean isMath = CaptchaType.MATH == captchaType;
-        Integer length = isMath ? captchaProperties.getNumberLength() : captchaProperties.getCharLength();
-        CodeGenerator codeGenerator = ReflectUtils.newInstance(captchaType.getClazz(), length);
-        AbstractCaptcha captcha = SpringUtils.getBean(captchaProperties.getCategory().getClazz());
+        String captchaType = captchaProperties.getType();
+        CodeGenerator codeGenerator;
+        if ("math".equals(captchaType)) {
+            codeGenerator = new MathGenerator(captchaProperties.getNumberLength(), false);
+        } else {
+            codeGenerator = new RandomGenerator(captchaProperties.getCharLength());
+        }
+        WaveAndCircleCaptcha captcha = new WaveAndCircleCaptcha(160, 60);
+        // captcha.setBackground(Color.WHITE); // 不设置就是透明底
+        captcha.setFont(new Font("Arial", Font.BOLD, 45));
         captcha.setGenerator(codeGenerator);
         captcha.createCode();
         // 如果是数学验证码，使用SpEL表达式处理验证码结果
         String code = captcha.getCode();
-        if (isMath) {
+        if ("math".equals(captchaType)) {
             ExpressionParser parser = new SpelExpressionParser();
             Expression exp = parser.parseExpression(StringUtils.remove(code, "="));
             code = exp.getValue(String.class);
         }
         RedisUtils.setCacheObject(verifyKey, code, Duration.ofMinutes(Constants.CAPTCHA_EXPIRATION));
-        CaptchaVo captchaVo = new CaptchaVo();
-        captchaVo.setUuid(uuid);
-        captchaVo.setImg(captcha.getImageBase64());
-        return captchaVo;
+        return new CaptchaVo(true, uuid, captcha.getImageBase64());
+    }
+
+    /**
+     * 图片验证码响应对象。
+     *
+     * @param captchaEnabled 是否启用验证码
+     * @param uuid           验证码标识
+     * @param img            Base64 图片数据
+     */
+    public record CaptchaVo(Boolean captchaEnabled, String uuid, String img) {
     }
 
 }

ruoyi-admin/src/main/java/org/dromara/web/controller/IndexController.java

@@ -18,7 +18,9 @@ import org.springframework.web.bind.annotation.RestController;
 public class IndexController {
 
     /**
-     * 访问首页，提示语
+     * 访问首页时返回引导提示。
+     *
+     * @return 首页提示语
      */
     @GetMapping("/")
     public String index() {

ruoyi-admin/src/main/java/org/dromara/web/domain/vo/CaptchaVo.java

@@ -1,25 +0,0 @@
-package org.dromara.web.domain.vo;
-
-import lombok.Data;
-
-/**
- * 验证码信息
- *
- * @author Michelle.Chung
- */
-@Data
-public class CaptchaVo {
-
-    /**
-     * 是否开启验证码
-     */
-    private Boolean captchaEnabled = true;
-
-    private String uuid;
-
-    /**
-     * 验证码图片
-     */
-    private String img;
-
-}

ruoyi-admin/src/main/java/org/dromara/web/domain/vo/LoginTenantVo.java

@@ -1,25 +0,0 @@
-package org.dromara.web.domain.vo;
-
-import lombok.Data;
-
-import java.util.List;
-
-/**
- * 登录租户对象
- *
- * @author Michelle.Chung
- */
-@Data
-public class LoginTenantVo {
-
-    /**
-     * 租户开关
-     */
-    private Boolean tenantEnabled;
-
-    /**
-     * 租户对象列表
-     */
-    private List<TenantListVo> voList;
-
-}

ruoyi-admin/src/main/java/org/dromara/web/domain/vo/LoginVo.java

@@ -4,7 +4,7 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 
 /**
- * 登录验证信息
+ * 登录成功后的令牌信息返回对象。
  *
  * @author Michelle.Chung
  */

ruoyi-admin/src/main/java/org/dromara/web/domain/vo/TenantListVo.java

@@ -1,31 +0,0 @@
-package org.dromara.web.domain.vo;
-
-import org.dromara.system.domain.vo.SysTenantVo;
-import io.github.linpeilie.annotations.AutoMapper;
-import lombok.Data;
-
-/**
- * 租户列表
- *
- * @author Lion Li
- */
-@Data
-@AutoMapper(target = SysTenantVo.class)
-public class TenantListVo {
-
-    /**
-     * 租户编号
-     */
-    private String tenantId;
-
-    /**
-     * 企业名称
-     */
-    private String companyName;
-
-    /**
-     * 域名
-     */
-    private String domain;
-
-}

ruoyi-admin/src/main/java/org/dromara/web/listener/UserActionListener.java

@@ -1,31 +1,28 @@
 package org.dromara.web.listener;
 
 import cn.dev33.satoken.listener.SaTokenListener;
-import cn.dev33.satoken.stp.StpUtil;
 import cn.dev33.satoken.stp.parameter.SaLoginParameter;
-import cn.hutool.core.convert.Convert;
 import cn.hutool.http.useragent.UserAgent;
 import cn.hutool.http.useragent.UserAgentUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.common.core.constant.CacheConstants;
+import org.dromara.common.core.constant.CacheNames;
 import org.dromara.common.core.constant.Constants;
 import org.dromara.common.core.domain.dto.UserOnlineDTO;
 import org.dromara.common.core.utils.MessageUtils;
 import org.dromara.common.core.utils.ServletUtils;
 import org.dromara.common.core.utils.SpringUtils;
 import org.dromara.common.core.utils.ip.AddressUtils;
-import org.dromara.common.log.event.LogininforEvent;
+import org.dromara.common.log.event.LoginInfoEvent;
 import org.dromara.common.redis.utils.RedisUtils;
 import org.dromara.common.satoken.utils.LoginHelper;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.web.service.SysLoginService;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
 
 /**
- * 用户行为 侦听器的实现
+ * 用户行为监听器，用于同步在线状态和登录日志。
  *
  * @author Lion Li
  */
@@ -37,7 +34,7 @@ public class UserActionListener implements SaTokenListener {
     private final SysLoginService loginService;
 
     /**
-     * 每次登录时触发
+     * 登录成功后记录在线信息并写入登录日志。
      */
     @Override
     public void doLogin(String loginType, Object loginId, String tokenValue, SaLoginParameter loginParameter) {
@@ -51,64 +48,52 @@ public class UserActionListener implements SaTokenListener {
         dto.setLoginTime(System.currentTimeMillis());
         dto.setTokenId(tokenValue);
         String username = (String) loginParameter.getExtra(LoginHelper.USER_NAME_KEY);
-        String tenantId = (String) loginParameter.getExtra(LoginHelper.TENANT_KEY);
         dto.setUserName(username);
         dto.setClientKey((String) loginParameter.getExtra(LoginHelper.CLIENT_KEY));
         dto.setDeviceType(loginParameter.getDeviceType());
         dto.setDeptName((String) loginParameter.getExtra(LoginHelper.DEPT_NAME_KEY));
-        TenantHelper.dynamic(tenantId, () -> {
-            if(loginParameter.getTimeout() == -1) {
-                RedisUtils.setCacheObject(CacheConstants.ONLINE_TOKEN_KEY + tokenValue, dto);
-            } else {
-                RedisUtils.setCacheObject(CacheConstants.ONLINE_TOKEN_KEY + tokenValue, dto, Duration.ofSeconds(loginParameter.getTimeout()));
-            }
-        });
+        if (loginParameter.getTimeout() == -1) {
+            RedisUtils.setCacheObject(CacheNames.ONLINE_TOKEN_KEY + tokenValue, dto);
+        } else {
+            RedisUtils.setCacheObject(CacheNames.ONLINE_TOKEN_KEY + tokenValue, dto, Duration.ofSeconds(loginParameter.getTimeout()));
+        }
+
         // 记录登录日志
-        LogininforEvent logininforEvent = new LogininforEvent();
-        logininforEvent.setTenantId(tenantId);
-        logininforEvent.setUsername(username);
-        logininforEvent.setStatus(Constants.LOGIN_SUCCESS);
-        logininforEvent.setMessage(MessageUtils.message("user.login.success"));
-        logininforEvent.setRequest(ServletUtils.getRequest());
-        SpringUtils.context().publishEvent(logininforEvent);
+        LoginInfoEvent loginInfoEvent = new LoginInfoEvent();
+        loginInfoEvent.setUsername(username);
+        loginInfoEvent.setStatus(Constants.LOGIN_SUCCESS);
+        loginInfoEvent.setMessage(MessageUtils.message("user.login.success"));
+        loginInfoEvent.setRequest(ServletUtils.getRequest());
+        SpringUtils.context().publishEvent(loginInfoEvent);
         // 更新登录信息
         loginService.recordLoginInfo((Long) loginParameter.getExtra(LoginHelper.USER_KEY), ip);
         log.info("user doLogin, userId:{}, token:{}", loginId, tokenValue);
     }
 
     /**
-     * 每次注销时触发
+     * 注销时清理在线缓存。
      */
     @Override
     public void doLogout(String loginType, Object loginId, String tokenValue) {
-        String tenantId = Convert.toStr(StpUtil.getExtra(tokenValue, LoginHelper.TENANT_KEY));
-        TenantHelper.dynamic(tenantId, () -> {
-            RedisUtils.deleteObject(CacheConstants.ONLINE_TOKEN_KEY + tokenValue);
-        });
+        RedisUtils.deleteObject(CacheNames.ONLINE_TOKEN_KEY + tokenValue);
         log.info("user doLogout, userId:{}, token:{}", loginId, tokenValue);
     }
 
     /**
-     * 每次被踢下线时触发
+     * 被踢下线时清理在线缓存。
      */
     @Override
     public void doKickout(String loginType, Object loginId, String tokenValue) {
-        String tenantId = Convert.toStr(StpUtil.getExtra(tokenValue, LoginHelper.TENANT_KEY));
-        TenantHelper.dynamic(tenantId, () -> {
-            RedisUtils.deleteObject(CacheConstants.ONLINE_TOKEN_KEY + tokenValue);
-        });
+        RedisUtils.deleteObject(CacheNames.ONLINE_TOKEN_KEY + tokenValue);
         log.info("user doKickout, userId:{}, token:{}", loginId, tokenValue);
     }
 
     /**
-     * 每次被顶下线时触发
+     * 被顶下线时清理在线缓存。
      */
     @Override
     public void doReplaced(String loginType, Object loginId, String tokenValue) {
-        String tenantId = Convert.toStr(StpUtil.getExtra(tokenValue, LoginHelper.TENANT_KEY));
-        TenantHelper.dynamic(tenantId, () -> {
-            RedisUtils.deleteObject(CacheConstants.ONLINE_TOKEN_KEY + tokenValue);
-        });
+        RedisUtils.deleteObject(CacheNames.ONLINE_TOKEN_KEY + tokenValue);
         log.info("user doReplaced, userId:{}, token:{}", loginId, tokenValue);
     }
 

ruoyi-admin/src/main/java/org/dromara/web/service/IAuthStrategy.java

@@ -39,7 +39,7 @@ public interface IAuthStrategy {
      *
      * @param body   登录对象
      * @param client 授权管理视图对象
-     * @return 登录验证信息
+     * @return 当前策略完成认证后的登录结果
      */
     LoginVo login(String body, SysClientVo client);
 

ruoyi-admin/src/main/java/org/dromara/web/service/SysLoginService.java

@@ -10,10 +10,8 @@ import com.baomidou.lock.annotation.Lock4j;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import me.zhyd.oauth.model.AuthUser;
-import org.dromara.common.core.constant.CacheConstants;
+import org.dromara.common.core.constant.CacheNames;
 import org.dromara.common.core.constant.Constants;
-import org.dromara.common.core.constant.SystemConstants;
-import org.dromara.common.core.constant.TenantConstants;
 import org.dromara.common.core.domain.dto.PostDTO;
 import org.dromara.common.core.domain.dto.RoleDTO;
 import org.dromara.common.core.domain.model.LoginUser;
@@ -21,12 +19,10 @@ import org.dromara.common.core.enums.LoginType;
 import org.dromara.common.core.exception.ServiceException;
 import org.dromara.common.core.exception.user.UserException;
 import org.dromara.common.core.utils.*;
-import org.dromara.common.log.event.LogininforEvent;
+import org.dromara.common.log.event.LoginInfoEvent;
 import org.dromara.common.mybatis.helper.DataPermissionHelper;
 import org.dromara.common.redis.utils.RedisUtils;
 import org.dromara.common.satoken.utils.LoginHelper;
-import org.dromara.common.tenant.exception.TenantException;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.system.domain.SysUser;
 import org.dromara.system.domain.bo.SysSocialBo;
 import org.dromara.system.domain.vo.*;
@@ -36,7 +32,7 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 import java.time.Duration;
-import java.util.Date;
+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.function.Supplier;
 
@@ -56,7 +52,6 @@ public class SysLoginService {
     @Value("${user.password.lockTime}")
     private Integer lockTime;
 
-    private final ISysTenantService tenantService;
     private final ISysPermissionService permissionService;
     private final ISysSocialService sysSocialService;
     private final ISysRoleService roleService;
@@ -113,11 +108,7 @@ public class SysLoginService {
             if (ObjectUtil.isNull(loginUser)) {
                 return;
             }
-            if (TenantHelper.isEnable() && LoginHelper.isSuperAdmin()) {
-                // 超级管理员 登出清除动态租户
-                TenantHelper.clearDynamic();
-            }
-            recordLogininfor(loginUser.getTenantId(), loginUser.getUsername(), Constants.LOGOUT, MessageUtils.message("user.logout.success"));
+            recordLoginInfo(loginUser.getUsername(), Constants.LOGOUT, MessageUtils.message("user.logout.success"));
         } catch (NotLoginException ignored) {
         } finally {
             try {
@@ -130,73 +121,85 @@ public class SysLoginService {
     /**
      * 记录登录信息
      *
-     * @param tenantId 租户ID
      * @param username 用户名
      * @param status   状态
      * @param message  消息内容
      */
-    public void recordLogininfor(String tenantId, String username, String status, String message) {
-        LogininforEvent logininforEvent = new LogininforEvent();
-        logininforEvent.setTenantId(tenantId);
-        logininforEvent.setUsername(username);
-        logininforEvent.setStatus(status);
-        logininforEvent.setMessage(message);
-        logininforEvent.setRequest(ServletUtils.getRequest());
-        SpringUtils.context().publishEvent(logininforEvent);
+    public void recordLoginInfo(String username, String status, String message) {
+        LoginInfoEvent loginInfoEvent = new LoginInfoEvent();
+        loginInfoEvent.setUsername(username);
+        loginInfoEvent.setStatus(status);
+        loginInfoEvent.setMessage(message);
+        loginInfoEvent.setRequest(ServletUtils.getRequest());
+        SpringUtils.context().publishEvent(loginInfoEvent);
     }
 
     /**
-     * 构建登录用户
+     * 根据用户视图对象组装登录态上下文。
+     *
+     * @param user 用户基础信息
+     * @return 包含部门、角色、岗位与权限数据的登录用户
      */
     public LoginUser buildLoginUser(SysUserVo user) {
         LoginUser loginUser = new LoginUser();
         Long userId = user.getUserId();
-        loginUser.setTenantId(user.getTenantId());
         loginUser.setUserId(userId);
         loginUser.setDeptId(user.getDeptId());
         loginUser.setUsername(user.getUserName());
         loginUser.setNickname(user.getNickName());
         loginUser.setUserType(user.getUserType());
-        loginUser.setMenuPermission(permissionService.getMenuPermission(userId));
-        loginUser.setRolePermission(permissionService.getRolePermission(userId));
         if (ObjectUtil.isNotNull(user.getDeptId())) {
             Opt<SysDeptVo> deptOpt = Opt.of(user.getDeptId()).map(deptService::selectDeptById);
             loginUser.setDeptName(deptOpt.map(SysDeptVo::getDeptName).orElse(StringUtils.EMPTY));
             loginUser.setDeptCategory(deptOpt.map(SysDeptVo::getDeptCategory).orElse(StringUtils.EMPTY));
         }
-        List<SysRoleVo> roles = roleService.selectRolesByUserId(userId);
-        List<SysPostVo> posts = postService.selectPostsByUserId(userId);
-        loginUser.setRoles(BeanUtil.copyToList(roles, RoleDTO.class));
-        loginUser.setPosts(BeanUtil.copyToList(posts, PostDTO.class));
+        ThreadUtils.virtualSubmit(() -> {
+            loginUser.setMenuPermission(permissionService.getMenuPermission(userId));
+        }, () -> {
+            loginUser.setRolePermission(permissionService.getRolePermission(userId));
+        }, () -> {
+            List<SysRoleVo> roles = roleService.selectRolesByUserId(userId);
+            List<RoleDTO> roleDtos = BeanUtil.copyToList(roles, RoleDTO.class);
+            loginUser.setRoles(roleDtos);
+            loginUser.setDataScopeRoleMap(permissionService.getDataScopeRoleMap(roleDtos));
+        }, () -> {
+            List<SysPostVo> posts = postService.selectPostsByUserId(userId);
+            loginUser.setPosts(BeanUtil.copyToList(posts, PostDTO.class));
+        });
         return loginUser;
     }
 
     /**
-     * 记录登录信息
+     * 更新用户最近一次登录IP与登录时间。
      *
      * @param userId 用户ID
+     * @param ip     登录IP
      */
     public void recordLoginInfo(Long userId, String ip) {
         SysUser sysUser = new SysUser();
         sysUser.setUserId(userId);
         sysUser.setLoginIp(ip);
-        sysUser.setLoginDate(DateUtils.getNowDate());
+        sysUser.setLoginDate(LocalDateTime.now());
         sysUser.setUpdateBy(userId);
         DataPermissionHelper.ignore(() -> userMapper.updateById(sysUser));
     }
 
     /**
-     * 登录校验
+     * 执行登录失败次数校验，并在成功后清空失败计数。
+     *
+     * @param loginType 登录类型
+     * @param username  登录标识
+     * @param supplier  返回 {@code true} 表示本次认证失败
      */
-    public void checkLogin(LoginType loginType, String tenantId, String username, Supplier<Boolean> supplier) {
-        String errorKey = CacheConstants.PWD_ERR_CNT_KEY + username;
+    public void checkLogin(LoginType loginType, String username, Supplier<Boolean> supplier) {
+        String errorKey = CacheNames.PWD_ERR_CNT_KEY + username;
         String loginFail = Constants.LOGIN_FAIL;
 
         // 获取用户登录错误次数，默认为0 (可自定义限制策略 例如: key + username + ip)
         int errorNumber = ObjectUtil.defaultIfNull(RedisUtils.getCacheObject(errorKey), 0);
         // 锁定时间内登录 则踢出
         if (errorNumber >= maxRetryCount) {
-            recordLogininfor(tenantId, username, loginFail, MessageUtils.message(loginType.getRetryLimitExceed(), maxRetryCount, lockTime));
+            recordLoginInfo(username, loginFail, MessageUtils.message(loginType.getRetryLimitExceed(), maxRetryCount, lockTime));
             throw new UserException(loginType.getRetryLimitExceed(), maxRetryCount, lockTime);
         }
 
@@ -206,11 +209,11 @@ public class SysLoginService {
             RedisUtils.setCacheObject(errorKey, errorNumber, Duration.ofMinutes(lockTime));
             // 达到规定错误次数 则锁定登录
             if (errorNumber >= maxRetryCount) {
-                recordLogininfor(tenantId, username, loginFail, MessageUtils.message(loginType.getRetryLimitExceed(), maxRetryCount, lockTime));
+                recordLoginInfo(username, loginFail, MessageUtils.message(loginType.getRetryLimitExceed(), maxRetryCount, lockTime));
                 throw new UserException(loginType.getRetryLimitExceed(), maxRetryCount, lockTime);
             } else {
                 // 未达到规定错误次数
-                recordLogininfor(tenantId, username, loginFail, MessageUtils.message(loginType.getRetryLimitCount(), errorNumber));
+                recordLoginInfo(username, loginFail, MessageUtils.message(loginType.getRetryLimitCount(), errorNumber));
                 throw new UserException(loginType.getRetryLimitCount(), errorNumber);
             }
         }
@@ -219,33 +222,4 @@ public class SysLoginService {
         RedisUtils.deleteObject(errorKey);
     }
 
-    /**
-     * 校验租户
-     *
-     * @param tenantId 租户ID
-     */
-    public void checkTenant(String tenantId) {
-        if (!TenantHelper.isEnable()) {
-            return;
-        }
-        if (StringUtils.isBlank(tenantId)) {
-            throw new TenantException("tenant.number.not.blank");
-        }
-        if (TenantConstants.DEFAULT_TENANT_ID.equals(tenantId)) {
-            return;
-        }
-        SysTenantVo tenant = tenantService.queryByTenantId(tenantId);
-        if (ObjectUtil.isNull(tenant)) {
-            log.info("登录租户：{} 不存在.", tenantId);
-            throw new TenantException("tenant.not.exists");
-        } else if (SystemConstants.DISABLE.equals(tenant.getStatus())) {
-            log.info("登录租户：{} 已被停用.", tenantId);
-            throw new TenantException("tenant.blocked");
-        } else if (ObjectUtil.isNotNull(tenant.getExpireTime())
-            && new Date().after(tenant.getExpireTime())) {
-            log.info("登录租户：{} 已超过有效期.", tenantId);
-            throw new TenantException("tenant.expired");
-        }
-    }
-
 }

ruoyi-admin/src/main/java/org/dromara/web/service/SysRegisterService.java

@@ -14,9 +14,8 @@ import org.dromara.common.core.utils.MessageUtils;
 import org.dromara.common.core.utils.ServletUtils;
 import org.dromara.common.core.utils.SpringUtils;
 import org.dromara.common.core.utils.StringUtils;
-import org.dromara.common.log.event.LogininforEvent;
+import org.dromara.common.log.event.LoginInfoEvent;
 import org.dromara.common.redis.utils.RedisUtils;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.common.web.config.properties.CaptchaProperties;
 import org.dromara.system.domain.SysUser;
 import org.dromara.system.domain.bo.SysUserBo;
@@ -39,9 +38,10 @@ public class SysRegisterService {
 
     /**
      * 注册
+     *
+     * @param registerBody 注册请求参数
      */
     public void register(RegisterBody registerBody) {
-        String tenantId = registerBody.getTenantId();
         String username = registerBody.getUsername();
         String password = registerBody.getPassword();
         // 校验用户类型是否存在
@@ -50,7 +50,7 @@ public class SysRegisterService {
         boolean captchaEnabled = captchaProperties.getEnable();
         // 验证码开关
         if (captchaEnabled) {
-            validateCaptcha(tenantId, username, registerBody.getCode(), registerBody.getUuid());
+            validateCaptcha(username, registerBody.getCode(), registerBody.getUuid());
         }
         SysUserBo sysUser = new SysUserBo();
         sysUser.setUserName(username);
@@ -58,18 +58,16 @@ public class SysRegisterService {
         sysUser.setPassword(BCrypt.hashpw(password));
         sysUser.setUserType(userType);
 
-        boolean exist = TenantHelper.dynamic(tenantId, () -> {
-            return userMapper.exists(new LambdaQueryWrapper<SysUser>()
-                .eq(SysUser::getUserName, sysUser.getUserName()));
-        });
+        boolean exist = userMapper.exists(new LambdaQueryWrapper<SysUser>()
+            .eq(SysUser::getUserName, sysUser.getUserName()));
         if (exist) {
             throw new UserException("user.register.save.error", username);
         }
-        boolean regFlag = userService.registerUser(sysUser, tenantId);
+        boolean regFlag = userService.registerUser(sysUser);
         if (!regFlag) {
             throw new UserException("user.register.error");
         }
-        recordLogininfor(tenantId, username, Constants.REGISTER, MessageUtils.message("user.register.success"));
+        recordLoginInfo(username, Constants.REGISTER, MessageUtils.message("user.register.success"));
     }
 
     /**
@@ -79,16 +77,16 @@ public class SysRegisterService {
      * @param code     验证码
      * @param uuid     唯一标识
      */
-    public void validateCaptcha(String tenantId, String username, String code, String uuid) {
+    public void validateCaptcha(String username, String code, String uuid) {
         String verifyKey = GlobalConstants.CAPTCHA_CODE_KEY + StringUtils.blankToDefault(uuid, "");
         String captcha = RedisUtils.getCacheObject(verifyKey);
         RedisUtils.deleteObject(verifyKey);
         if (captcha == null) {
-            recordLogininfor(tenantId, username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
+            recordLoginInfo(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
             throw new CaptchaExpireException();
         }
-        if (!code.equalsIgnoreCase(captcha)) {
-            recordLogininfor(tenantId, username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error"));
+        if (!StringUtils.equalsIgnoreCase(code, captcha)) {
+            recordLoginInfo(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error"));
             throw new CaptchaException();
         }
     }
@@ -96,20 +94,17 @@ public class SysRegisterService {
     /**
      * 记录登录信息
      *
-     * @param tenantId 租户ID
      * @param username 用户名
      * @param status   状态
      * @param message  消息内容
-     * @return
      */
-    private void recordLogininfor(String tenantId, String username, String status, String message) {
-        LogininforEvent logininforEvent = new LogininforEvent();
-        logininforEvent.setTenantId(tenantId);
-        logininforEvent.setUsername(username);
-        logininforEvent.setStatus(status);
-        logininforEvent.setMessage(message);
-        logininforEvent.setRequest(ServletUtils.getRequest());
-        SpringUtils.context().publishEvent(logininforEvent);
+    private void recordLoginInfo(String username, String status, String message) {
+        LoginInfoEvent loginInfoEvent = new LoginInfoEvent();
+        loginInfoEvent.setUsername(username);
+        loginInfoEvent.setStatus(status);
+        loginInfoEvent.setMessage(message);
+        loginInfoEvent.setRequest(ServletUtils.getRequest());
+        SpringUtils.context().publishEvent(loginInfoEvent);
     }
 
 }

ruoyi-admin/src/main/java/org/dromara/web/service/impl/EmailAuthStrategy.java

@@ -20,7 +20,6 @@ import org.dromara.common.core.utils.ValidatorUtils;
 import org.dromara.common.json.utils.JsonUtils;
 import org.dromara.common.redis.utils.RedisUtils;
 import org.dromara.common.satoken.utils.LoginHelper;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.system.domain.SysUser;
 import org.dromara.system.domain.vo.SysClientVo;
 import org.dromara.system.domain.vo.SysUserVo;
@@ -43,19 +42,23 @@ public class EmailAuthStrategy implements IAuthStrategy {
     private final SysLoginService loginService;
     private final SysUserMapper userMapper;
 
+    /**
+     * 执行邮箱验证码登录，并按客户端配置生成访问令牌。
+     *
+     * @param body   登录请求体
+     * @param client 当前客户端配置
+     * @return 登录结果
+     */
     @Override
     public LoginVo login(String body, SysClientVo client) {
         EmailLoginBody loginBody = JsonUtils.parseObject(body, EmailLoginBody.class);
         ValidatorUtils.validate(loginBody);
-        String tenantId = loginBody.getTenantId();
         String email = loginBody.getEmail();
         String emailCode = loginBody.getEmailCode();
-        LoginUser loginUser = TenantHelper.dynamic(tenantId, () -> {
-            SysUserVo user = loadUserByEmail(email);
-            loginService.checkLogin(LoginType.EMAIL, tenantId, user.getUserName(), () -> !validateEmailCode(tenantId, email, emailCode));
-            // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
-            return loginService.buildLoginUser(user);
-        });
+        SysUserVo user = loadUserByEmail(email);
+        loginService.checkLogin(LoginType.EMAIL, user.getUserName(), () -> !validateEmailCode(email, emailCode));
+        // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
+        LoginUser loginUser = loginService.buildLoginUser(user);
         loginUser.setClientKey(client.getClientKey());
         loginUser.setDeviceType(client.getDeviceType());
         SaLoginParameter model = new SaLoginParameter();
@@ -76,17 +79,27 @@ public class EmailAuthStrategy implements IAuthStrategy {
     }
 
     /**
-     * 校验邮箱验证码
+     * 校验邮箱验证码是否存在且匹配。
+     *
+     * @param email     邮箱地址
+     * @param emailCode 用户输入的邮箱验证码
+     * @return 是否校验通过
      */
-    private boolean validateEmailCode(String tenantId, String email, String emailCode) {
+    private boolean validateEmailCode(String email, String emailCode) {
         String code = RedisUtils.getCacheObject(GlobalConstants.CAPTCHA_CODE_KEY + email);
         if (StringUtils.isBlank(code)) {
-            loginService.recordLogininfor(tenantId, email, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
+            loginService.recordLoginInfo(email, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
             throw new CaptchaExpireException();
         }
         return code.equals(emailCode);
     }
 
+    /**
+     * 按邮箱加载可登录用户，并校验是否存在或被停用。
+     *
+     * @param email 邮箱地址
+     * @return 用户信息
+     */
     private SysUserVo loadUserByEmail(String email) {
         SysUserVo user = userMapper.selectVoOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getEmail, email));
         if (ObjectUtil.isNull(user)) {

ruoyi-admin/src/main/java/org/dromara/web/service/impl/PasswordAuthStrategy.java

@@ -22,7 +22,6 @@ import org.dromara.common.core.utils.ValidatorUtils;
 import org.dromara.common.json.utils.JsonUtils;
 import org.dromara.common.redis.utils.RedisUtils;
 import org.dromara.common.satoken.utils.LoginHelper;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.common.web.config.properties.CaptchaProperties;
 import org.dromara.system.domain.SysUser;
 import org.dromara.system.domain.vo.SysClientVo;
@@ -47,11 +46,17 @@ public class PasswordAuthStrategy implements IAuthStrategy {
     private final SysLoginService loginService;
     private final SysUserMapper userMapper;
 
+    /**
+     * 执行账号密码登录，并按客户端配置生成访问令牌。
+     *
+     * @param body   登录请求体
+     * @param client 当前客户端配置
+     * @return 登录结果
+     */
     @Override
     public LoginVo login(String body, SysClientVo client) {
         PasswordLoginBody loginBody = JsonUtils.parseObject(body, PasswordLoginBody.class);
         ValidatorUtils.validate(loginBody);
-        String tenantId = loginBody.getTenantId();
         String username = loginBody.getUsername();
         String password = loginBody.getPassword();
         String code = loginBody.getCode();
@@ -60,14 +65,12 @@ public class PasswordAuthStrategy implements IAuthStrategy {
         boolean captchaEnabled = captchaProperties.getEnable();
         // 验证码开关
         if (captchaEnabled) {
-            validateCaptcha(tenantId, username, code, uuid);
+            validateCaptcha(username, code, uuid);
         }
-        LoginUser loginUser = TenantHelper.dynamic(tenantId, () -> {
-            SysUserVo user = loadUserByUsername(username);
-            loginService.checkLogin(LoginType.PASSWORD, tenantId, username, () -> !BCrypt.checkpw(password, user.getPassword()));
-            // 此处可根据登录用户的数据不同 自行创建 loginUser
-            return loginService.buildLoginUser(user);
-        });
+        SysUserVo user = loadUserByUsername(username);
+        loginService.checkLogin(LoginType.PASSWORD, username, () -> !BCrypt.checkpw(password, user.getPassword()));
+        // 此处可根据登录用户的数据不同 自行创建 loginUser
+        LoginUser loginUser = loginService.buildLoginUser(user);
         loginUser.setClientKey(client.getClientKey());
         loginUser.setDeviceType(client.getDeviceType());
         SaLoginParameter model = new SaLoginParameter();
@@ -88,26 +91,32 @@ public class PasswordAuthStrategy implements IAuthStrategy {
     }
 
     /**
-     * 校验验证码
+     * 校验图形验证码是否有效且匹配。
      *
      * @param username 用户名
-     * @param code     验证码
-     * @param uuid     唯一标识
+     * @param code     用户输入的验证码
+     * @param uuid     验证码缓存标识
      */
-    private void validateCaptcha(String tenantId, String username, String code, String uuid) {
+    private void validateCaptcha(String username, String code, String uuid) {
         String verifyKey = GlobalConstants.CAPTCHA_CODE_KEY + StringUtils.blankToDefault(uuid, "");
         String captcha = RedisUtils.getCacheObject(verifyKey);
         RedisUtils.deleteObject(verifyKey);
         if (captcha == null) {
-            loginService.recordLogininfor(tenantId, username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
+            loginService.recordLoginInfo(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
             throw new CaptchaExpireException();
         }
-        if (!code.equalsIgnoreCase(captcha)) {
-            loginService.recordLogininfor(tenantId, username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error"));
+        if (!StringUtils.equalsIgnoreCase(code, captcha)) {
+            loginService.recordLoginInfo(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error"));
             throw new CaptchaException();
         }
     }
 
+    /**
+     * 按用户名加载可登录用户，并校验是否存在或被停用。
+     *
+     * @param username 用户名
+     * @return 用户信息
+     */
     private SysUserVo loadUserByUsername(String username) {
         SysUserVo user = userMapper.selectVoOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserName, username));
         if (ObjectUtil.isNull(user)) {

ruoyi-admin/src/main/java/org/dromara/web/service/impl/SmsAuthStrategy.java

@@ -20,7 +20,6 @@ import org.dromara.common.core.utils.ValidatorUtils;
 import org.dromara.common.json.utils.JsonUtils;
 import org.dromara.common.redis.utils.RedisUtils;
 import org.dromara.common.satoken.utils.LoginHelper;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.system.domain.SysUser;
 import org.dromara.system.domain.vo.SysClientVo;
 import org.dromara.system.domain.vo.SysUserVo;
@@ -43,19 +42,23 @@ public class SmsAuthStrategy implements IAuthStrategy {
     private final SysLoginService loginService;
     private final SysUserMapper userMapper;
 
+    /**
+     * 执行短信验证码登录，并按客户端配置生成访问令牌。
+     *
+     * @param body   登录请求体
+     * @param client 当前客户端配置
+     * @return 登录结果
+     */
     @Override
     public LoginVo login(String body, SysClientVo client) {
         SmsLoginBody loginBody = JsonUtils.parseObject(body, SmsLoginBody.class);
         ValidatorUtils.validate(loginBody);
-        String tenantId = loginBody.getTenantId();
-        String phonenumber = loginBody.getPhonenumber();
+        String phoneNumber = loginBody.getPhoneNumber();
         String smsCode = loginBody.getSmsCode();
-        LoginUser loginUser = TenantHelper.dynamic(tenantId, () -> {
-            SysUserVo user = loadUserByPhonenumber(phonenumber);
-            loginService.checkLogin(LoginType.SMS, tenantId, user.getUserName(), () -> !validateSmsCode(tenantId, phonenumber, smsCode));
-            // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
-            return loginService.buildLoginUser(user);
-        });
+        SysUserVo user = loadUserByPhoneNumber(phoneNumber);
+        loginService.checkLogin(LoginType.SMS, user.getUserName(), () -> !validateSmsCode(phoneNumber, smsCode));
+        // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
+        LoginUser loginUser = loginService.buildLoginUser(user);
         loginUser.setClientKey(client.getClientKey());
         loginUser.setDeviceType(client.getDeviceType());
         SaLoginParameter model = new SaLoginParameter();
@@ -76,25 +79,35 @@ public class SmsAuthStrategy implements IAuthStrategy {
     }
 
     /**
-     * 校验短信验证码
+     * 校验短信验证码是否存在且匹配。
+     *
+     * @param phoneNumber 手机号
+     * @param smsCode     用户输入的短信验证码
+     * @return 是否校验通过
      */
-    private boolean validateSmsCode(String tenantId, String phonenumber, String smsCode) {
-        String code = RedisUtils.getCacheObject(GlobalConstants.CAPTCHA_CODE_KEY + phonenumber);
+    private boolean validateSmsCode(String phoneNumber, String smsCode) {
+        String code = RedisUtils.getCacheObject(GlobalConstants.CAPTCHA_CODE_KEY + phoneNumber);
         if (StringUtils.isBlank(code)) {
-            loginService.recordLogininfor(tenantId, phonenumber, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
+            loginService.recordLoginInfo(phoneNumber, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire"));
             throw new CaptchaExpireException();
         }
         return code.equals(smsCode);
     }
 
-    private SysUserVo loadUserByPhonenumber(String phonenumber) {
-        SysUserVo user = userMapper.selectVoOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getPhonenumber, phonenumber));
+    /**
+     * 按手机号加载可登录用户，并校验是否存在或被停用。
+     *
+     * @param phoneNumber 手机号
+     * @return 用户信息
+     */
+    private SysUserVo loadUserByPhoneNumber(String phoneNumber) {
+        SysUserVo user = userMapper.selectVoOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getPhoneNumber, phoneNumber));
         if (ObjectUtil.isNull(user)) {
-            log.info("登录用户：{} 不存在.", phonenumber);
-            throw new UserException("user.not.exists", phonenumber);
+            log.info("登录用户：{} 不存在.", phoneNumber);
+            throw new UserException("user.not.exists", phoneNumber);
         } else if (SystemConstants.DISABLE.equals(user.getStatus())) {
-            log.info("登录用户：{} 已被停用.", phonenumber);
-            throw new UserException("user.blocked", phonenumber);
+            log.info("登录用户：{} 已被停用.", phoneNumber);
+            throw new UserException("user.blocked", phoneNumber);
         }
         return user;
     }

ruoyi-admin/src/main/java/org/dromara/web/service/impl/SocialAuthStrategy.java

@@ -13,13 +13,11 @@ import org.dromara.common.core.domain.model.LoginUser;
 import org.dromara.common.core.domain.model.SocialLoginBody;
 import org.dromara.common.core.exception.ServiceException;
 import org.dromara.common.core.exception.user.UserException;
-import org.dromara.common.core.utils.StreamUtils;
 import org.dromara.common.core.utils.ValidatorUtils;
 import org.dromara.common.json.utils.JsonUtils;
 import org.dromara.common.satoken.utils.LoginHelper;
 import org.dromara.common.social.config.properties.SocialProperties;
 import org.dromara.common.social.utils.SocialUtils;
-import org.dromara.common.tenant.helper.TenantHelper;
 import org.dromara.system.domain.vo.SysClientVo;
 import org.dromara.system.domain.vo.SysSocialVo;
 import org.dromara.system.domain.vo.SysUserVo;
@@ -31,7 +29,6 @@ import org.dromara.web.service.SysLoginService;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
-import java.util.Optional;
 
 /**
  * 第三方授权策略
@@ -49,10 +46,11 @@ public class SocialAuthStrategy implements IAuthStrategy {
     private final SysLoginService loginService;
 
     /**
-     * 登录-第三方授权登录
+     * 执行第三方授权登录，并校验授权账号与系统账号的绑定关系。
      *
      * @param body     登录信息
      * @param client   客户端信息
+     * @return 登录结果
      */
     @Override
     public LoginVo login(String body, SysClientVo client) {
@@ -70,21 +68,9 @@ public class SocialAuthStrategy implements IAuthStrategy {
         if (CollUtil.isEmpty(list)) {
             throw new ServiceException("你还没有绑定第三方账号，绑定后才可以登录！");
         }
-        SysSocialVo social;
-        if (TenantHelper.isEnable()) {
-            Optional<SysSocialVo> opt = StreamUtils.findAny(list, x -> x.getTenantId().equals(loginBody.getTenantId()));
-            if (opt.isEmpty()) {
-                throw new ServiceException("对不起，你没有权限登录当前租户！");
-            }
-            social = opt.get();
-        } else {
-            social = list.get(0);
-        }
-        LoginUser loginUser = TenantHelper.dynamic(social.getTenantId(), () -> {
-            SysUserVo user = loadUser(social.getUserId());
-            // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
-            return loginService.buildLoginUser(user);
-        });
+        SysUserVo user = loadUser(list.get(0).getUserId());
+        // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
+        LoginUser loginUser = loginService.buildLoginUser(user);
         loginUser.setClientKey(client.getClientKey());
         loginUser.setDeviceType(client.getDeviceType());
         SaLoginParameter model = new SaLoginParameter();
@@ -104,6 +90,12 @@ public class SocialAuthStrategy implements IAuthStrategy {
         return loginVo;
     }
 
+    /**
+     * 根据用户ID加载用户，并校验账号状态是否允许登录。
+     *
+     * @param userId 用户ID
+     * @return 用户信息
+     */
     private SysUserVo loadUser(Long userId) {
         SysUserVo user = userMapper.selectVoById(userId);
         if (ObjectUtil.isNull(user)) {

ruoyi-admin/src/main/java/org/dromara/web/service/impl/XcxAuthStrategy.java

@@ -38,6 +38,13 @@ public class XcxAuthStrategy implements IAuthStrategy {
 
     private final SysLoginService loginService;
 
+    /**
+     * 执行微信小程序登录，并根据 openid 构建小程序用户登录态。
+     *
+     * @param body   登录请求体
+     * @param client 当前客户端配置
+     * @return 登录结果
+     */
     @Override
     public LoginVo login(String body, SysClientVo client) {
         XcxLoginBody loginBody = JsonUtils.parseObject(body, XcxLoginBody.class);
@@ -67,7 +74,6 @@ public class XcxAuthStrategy implements IAuthStrategy {
         SysUserVo user = loadUserByOpenid(openid);
         // 此处可根据登录用户的数据不同 自行创建 loginUser 属性不够用继承扩展就行了
         XcxLoginUser loginUser = new XcxLoginUser();
-        loginUser.setTenantId(user.getTenantId());
         loginUser.setUserId(user.getUserId());
         loginUser.setUsername(user.getUserName());
         loginUser.setNickname(user.getNickName());
@@ -94,6 +100,12 @@ public class XcxAuthStrategy implements IAuthStrategy {
         return loginVo;
     }
 
+    /**
+     * 按 openid 查询小程序绑定用户。
+     *
+     * @param openid 小程序用户唯一标识
+     * @return 绑定的系统用户信息
+     */
     private SysUserVo loadUserByOpenid(String openid) {
         // 使用 openid 查询绑定用户 如未绑定用户 则根据业务自行处理 例如 创建默认用户
         // todo 自行实现 userService.selectUserByOpenid(openid);

ruoyi-admin/src/main/resources/application-dev.yml

@@ -27,8 +27,6 @@ snail-job:
   port: 2${server.port}
   # 客户端ip指定
   host:
-  # RPC类型: netty, grpc
-  rpc-type: grpc
 
 --- # 数据源配置
 spring:

ruoyi-admin/src/main/resources/application-prod.yml

@@ -30,8 +30,6 @@ snail-job:
   port: 2${server.port}
   # 客户端ip指定
   host:
-  # RPC类型: netty, grpc
-  rpc-type: grpc
 
 --- # 数据源配置
 spring:

ruoyi-admin/src/main/resources/application.yml

@@ -5,28 +5,21 @@ server:
   servlet:
     # 应用的访问路径
     context-path: /
-  # undertow 配置
-  undertow:
+  # jetty 配置
+  jetty:
     # HTTP post内容的最大大小。当值为-1时，默认值为大小是无限的
-    max-http-post-size: -1
-    # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
-    # 每块buffer的空间大小,越小的空间被利用越充分
-    buffer-size: 512
-    # 是否分配的直接内存
-    direct-buffers: true
+    max-http-form-post-size: -1
     threads:
-      # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
-      io: 8
-      # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
-      worker: 256
+      # 最小线程数
+      min: 8
+      # 最大线程数
+      max: 256
 
 captcha:
   # 是否启用验证码校验
   enable: true
   # 验证码类型 math 数组计算 char 字符验证
-  type: MATH
-  # line 线段干扰 circle 圆圈干扰 shear 扭曲干扰
-  category: CIRCLE
+  type: math
   # 数字验证码位数
   numberLength: 1
   # 字符验证码长度
@@ -57,6 +50,13 @@ spring:
     # 开启虚拟线程 仅jdk21可用
     virtual:
       enabled: false
+  task:
+    execution:
+      # 从 springboot 3.5 开始 spring自带线程池
+      # 不再需要 AsyncConfig与ThreadPoolConfig 可直接注入线程池使用
+      thread-name-prefix: async-
+      # 由spring自己初始化线程池
+      mode: force
   # 资源信息
   messages:
     # 国际化资源文件路径
@@ -76,8 +76,6 @@ spring:
     format:
       date-time: yyyy-MM-dd HH:mm:ss
   jackson:
-    # 日期格式化
-    date-format: yyyy-MM-dd HH:mm:ss
     serialization:
       # 格式化输出
       indent_output: false
@@ -112,22 +110,6 @@ security:
     - /*/api-docs/**
     - /warm-flow-ui/config
 
-# 多租户配置
-tenant:
-  # 是否开启
-  enable: true
-  # 排除表
-  excludes:
-    - sys_menu
-    - sys_tenant
-    - sys_tenant_package
-    - sys_role_dept
-    - sys_role_menu
-    - sys_user_post
-    - sys_user_role
-    - sys_client
-    - sys_oss_config
-
 # MyBatisPlus配置
 # https://baomidou.com/config/
 mybatis-plus:
@@ -189,13 +171,6 @@ springdoc:
       name: Lion Li
       email: crazylionli@163.com
       url: https://gitee.com/dromara/RuoYi-Vue-Plus
-  components:
-    # 鉴权方式配置
-    security-schemes:
-      apiKey:
-        type: APIKEY
-        in: HEADER
-        name: ${sa-token.token-name}
   #这里定义了两个分组，可定义多个，也可以不定义
   group-configs:
     - group: 1.演示模块
@@ -213,20 +188,10 @@ springdoc:
 xss:
   # 过滤开关
   enabled: true
-  # 排除链接（多个用逗号分隔）
+  # 排除链接
   excludeUrls:
     - /system/notice
 
-# 全局线程池相关配置
-# 如使用JDK21请直接使用虚拟线程 不要开启此配置
-thread-pool:
-  # 是否开启线程池
-  enabled: false
-  # 队列最大长度
-  queueCapacity: 128
-  # 线程池维护线程所允许的空闲时间
-  keepAliveSeconds: 300
-
 --- # 分布式锁 lock4j 全局配置
 lock4j:
   # 获取分布式锁超时时间，默认为 3000 毫秒
@@ -246,18 +211,14 @@ management:
     logfile:
       external-file: ./logs/sys-console.log
 
---- # 默认/推荐使用sse推送
-sse:
+--- # 统一消息推送配置
+message:
   enabled: true
-  path: /resource/sse
-
---- # websocket
-websocket:
-  # 如果关闭 需要和前端开关一起关闭
-  enabled: false
-  # 路径
-  path: /resource/websocket
-  # 设置访问源地址
+  # sse / websocket
+  transport: sse
+  # 统一访问路径
+  path: /resource/message
+  # websocket 允许的跨域来源
   allowedOrigins: '*'
 
 --- # warm-flow工作流配置
@@ -266,13 +227,49 @@ warm-flow:
   enabled: true
   # 是否开启设计器ui
   ui: true
+  # 是否显示流程图顶部文字
+  top-text-show: true
+  # 是否渲染节点悬浮提示，默认true
+  node-tooltip: true
   # 默认Authorization，如果有多个token，用逗号分隔
   token-name: ${sa-token.token-name},clientid
-  # 流程状态对应的三元色
-  chart-status-color:
-    ## 未办理
-    - 62,62,62
-    ## 待办理
-    - 255,205,23
-    ## 已办理
-    - 157,255,0
+
+--- # mqtt 配置
+# 具体配置还需查看文档
+# https://mica-mqtt.dreamlu.net/guide/spring/client.html
+mqtt.client:
+  # 是否开启客户端，默认：true
+  enabled: false
+  # 连接的服务端 ip ，默认：127.0.0.1
+  ip: 127.0.0.1
+  # 端口：默认：1883
+  port: 1883
+  # 客户端名称
+  name: Mqtt-Client
+  # 客户端Id（非常重要，一般为设备 sn，不可重复）
+  client-id: 000001
+  username: ruoyi
+  password: 123456
+  # 超时时间，单位：秒，默认：5秒
+  timeout: 5
+  # 重连时间，默认 5000 毫秒
+  re-interval: 5000
+  # mqtt 协议版本，可选 MQTT_3_1、mqtt_3_1_1、mqtt_5，默认：mqtt_3_1_1
+  version: mqtt_3_1_1
+  # 接收数据的 buffer size，默认：8k
+  read-buffer-size: 8KB
+  # 消息解析最大 bytes 长度，默认：10M
+  max-bytes-in-message: 10MB
+  # keep-alive 时间，单位：秒
+  keep-alive-secs: 60
+  # 开启保留 session 时，session 的有效期
+  session-expiry-interval-secs: 0
+  # 工作线程数，如果消息量比较大，例如做 emqx 的转发消息处理，可以调大此参数
+  mqtt-executor-size: 2
+  # 是否开启 ssl
+  ssl:
+    enabled: false
+    keystore-path:
+    keystore-pass:
+    truststore-path:
+    truststore-pass:

ruoyi-admin/src/main/resources/i18n/messages.properties

@@ -5,7 +5,7 @@ user.jcaptcha.expire=验证码已失效
 user.not.exists=对不起, 您的账号：{0} 不存在.
 user.password.not.match=用户不存在/密码错误
 user.password.retry.limit.count=密码输入错误{0}次
-user.password.retry.limit.exceed=密码输入错误{0}次，帐户锁定{1}分钟
+user.password.retry.limit.exceed=密码输入错误{0}次，账户锁定{1}分钟
 user.password.delete=对不起，您的账号：{0} 已被删除
 user.blocked=对不起，您的账号：{0} 已禁用，请联系管理员
 role.blocked=角色已封禁，请联系管理员
@@ -17,6 +17,7 @@ user.username.length.valid=账户长度必须在{min}到{max}个字符之间
 user.password.not.blank=用户密码不能为空
 user.password.length.valid=用户密码长度必须在{min}到{max}个字符之间
 user.password.not.valid=* 5-50个字符
+user.password.format.valid=密码必须包含大写字母、小写字母、数字和特殊字符
 user.email.not.valid=邮箱格式错误
 user.email.not.blank=邮箱不能为空
 user.phonenumber.not.blank=用户手机号不能为空
@@ -46,16 +47,12 @@ repeat.submit.message=不允许重复提交，请稍候再试
 rate.limiter.message=访问过于频繁，请稍候再试
 sms.code.not.blank=短信验证码不能为空
 sms.code.retry.limit.count=短信验证码输入错误{0}次
-sms.code.retry.limit.exceed=短信验证码输入错误{0}次，帐户锁定{1}分钟
+sms.code.retry.limit.exceed=短信验证码输入错误{0}次，账户锁定{1}分钟
 email.code.not.blank=邮箱验证码不能为空
 email.code.retry.limit.count=邮箱验证码输入错误{0}次
-email.code.retry.limit.exceed=邮箱验证码输入错误{0}次，帐户锁定{1}分钟
+email.code.retry.limit.exceed=邮箱验证码输入错误{0}次，账户锁定{1}分钟
 xcx.code.not.blank=小程序[code]不能为空
 social.source.not.blank=第三方登录平台[source]不能为空
 social.code.not.blank=第三方登录平台[code]不能为空
 social.state.not.blank=第三方登录平台[state]不能为空
-##租户
-tenant.number.not.blank=租户编号不能为空
-tenant.not.exists=对不起, 您的租户不存在，请联系管理员
-tenant.blocked=对不起，您的租户已禁用，请联系管理员
-tenant.expired=对不起，您的租户已过期，请联系管理员
+

ruoyi-admin/src/main/resources/i18n/messages_en_US.properties

@@ -17,6 +17,7 @@ user.username.length.valid=Account length must be between {min} and {max} charac
 user.password.not.blank=Password cannot be empty
 user.password.length.valid=Password length must be between {min} and {max} characters
 user.password.not.valid=* 5-50 characters
+user.password.format.valid=Password must contain uppercase, lowercase, digit, and special character
 user.email.not.valid=Mailbox format error
 user.email.not.blank=Mailbox cannot be blank
 user.phonenumber.not.blank=Phone number cannot be blank
@@ -54,8 +55,4 @@ xcx.code.not.blank=Mini program [code] cannot be blank
 social.source.not.blank=Social login platform [source] cannot be blank
 social.code.not.blank=Social login platform [code] cannot be blank
 social.state.not.blank=Social login platform [state] cannot be blank
-##租户
-tenant.number.not.blank=Tenant number cannot be blank
-tenant.not.exists=Sorry, your tenant does not exist. Please contact the administrator
-tenant.blocked=Sorry, your tenant is disabled. Please contact the administrator
-tenant.expired=Sorry, your tenant has expired. Please contact the administrator.
+

ruoyi-admin/src/main/resources/i18n/messages_zh_CN.properties

@@ -5,7 +5,7 @@ user.jcaptcha.expire=验证码已失效
 user.not.exists=对不起, 您的账号：{0} 不存在.
 user.password.not.match=用户不存在/密码错误
 user.password.retry.limit.count=密码输入错误{0}次
-user.password.retry.limit.exceed=密码输入错误{0}次，帐户锁定{1}分钟
+user.password.retry.limit.exceed=密码输入错误{0}次，账户锁定{1}分钟
 user.password.delete=对不起，您的账号：{0} 已被删除
 user.blocked=对不起，您的账号：{0} 已禁用，请联系管理员
 role.blocked=角色已封禁，请联系管理员
@@ -17,6 +17,7 @@ user.username.length.valid=账户长度必须在{min}到{max}个字符之间
 user.password.not.blank=用户密码不能为空
 user.password.length.valid=用户密码长度必须在{min}到{max}个字符之间
 user.password.not.valid=* 5-50个字符
+user.password.format.valid=密码必须包含大写字母、小写字母、数字和特殊字符
 user.email.not.valid=邮箱格式错误
 user.email.not.blank=邮箱不能为空
 user.phonenumber.not.blank=用户手机号不能为空
@@ -46,16 +47,12 @@ repeat.submit.message=不允许重复提交，请稍候再试
 rate.limiter.message=访问过于频繁，请稍候再试
 sms.code.not.blank=短信验证码不能为空
 sms.code.retry.limit.count=短信验证码输入错误{0}次
-sms.code.retry.limit.exceed=短信验证码输入错误{0}次，帐户锁定{1}分钟
+sms.code.retry.limit.exceed=短信验证码输入错误{0}次，账户锁定{1}分钟
 email.code.not.blank=邮箱验证码不能为空
 email.code.retry.limit.count=邮箱验证码输入错误{0}次
-email.code.retry.limit.exceed=邮箱验证码输入错误{0}次，帐户锁定{1}分钟
+email.code.retry.limit.exceed=邮箱验证码输入错误{0}次，账户锁定{1}分钟
 xcx.code.not.blank=小程序[code]不能为空
 social.source.not.blank=第三方登录平台[source]不能为空
 social.code.not.blank=第三方登录平台[code]不能为空
 social.state.not.blank=第三方登录平台[state]不能为空
-##租户
-tenant.number.not.blank=租户编号不能为空
-tenant.not.exists=对不起, 您的租户不存在，请联系管理员
-tenant.blocked=对不起，您的租户已禁用，请联系管理员
-tenant.expired=对不起，您的租户已过期，请联系管理员
+

ruoyi-admin/src/main/resources/logback-plus.xml

@@ -38,7 +38,7 @@
         <!-- 循环政策：基于时间创建日志文件 -->
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
             <!-- 日志文件名格式 -->
-            <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>
+            <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log.gz</fileNamePattern>
             <!-- 日志最大的历史 60天 -->
             <maxHistory>60</maxHistory>
         </rollingPolicy>
@@ -60,7 +60,7 @@
         <!-- 循环政策：基于时间创建日志文件 -->
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
             <!-- 日志文件名格式 -->
-            <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log</fileNamePattern>
+            <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log.gz</fileNamePattern>
             <!-- 日志最大的历史 60天 -->
             <maxHistory>60</maxHistory>
         </rollingPolicy>

ruoyi-common/pom.xml

@@ -8,6 +8,12 @@
         <version>${revision}</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
+    <artifactId>ruoyi-common</artifactId>
+    <packaging>pom</packaging>
+
+    <description>
+        common 通用模块
+    </description>
 
     <modules>
         <module>ruoyi-common-bom</module>
@@ -15,13 +21,11 @@
         <module>ruoyi-common-core</module>
         <module>ruoyi-common-doc</module>
         <module>ruoyi-common-excel</module>
-        <module>ruoyi-common-idempotent</module>
         <module>ruoyi-common-job</module>
         <module>ruoyi-common-log</module>
         <module>ruoyi-common-mail</module>
         <module>ruoyi-common-mybatis</module>
         <module>ruoyi-common-oss</module>
-        <module>ruoyi-common-ratelimiter</module>
         <module>ruoyi-common-redis</module>
         <module>ruoyi-common-satoken</module>
         <module>ruoyi-common-security</module>
@@ -31,16 +35,8 @@
         <module>ruoyi-common-sensitive</module>
         <module>ruoyi-common-json</module>
         <module>ruoyi-common-encrypt</module>
-        <module>ruoyi-common-tenant</module>
-        <module>ruoyi-common-websocket</module>
-        <module>ruoyi-common-sse</module>
+        <module>ruoyi-common-push</module>
+        <module>ruoyi-common-mqtt</module>
     </modules>
 
-    <artifactId>ruoyi-common</artifactId>
-    <packaging>pom</packaging>
-
-    <description>
-        common 通用模块
-    </description>
-
 </project>

ruoyi-common/ruoyi-common-bom/pom.xml

@@ -14,7 +14,7 @@
     </description>
 
     <properties>
-        <revision>5.4.1</revision>
+        <revision>5.5.3</revision>
     </properties>
 
     <dependencyManagement>
@@ -40,13 +40,6 @@
                 <version>${revision}</version>
             </dependency>
 
-            <!-- 幂等 -->
-            <dependency>
-                <groupId>org.dromara</groupId>
-                <artifactId>ruoyi-common-idempotent</artifactId>
-                <version>${revision}</version>
-            </dependency>
-
             <!-- 调度模块 -->
             <dependency>
                 <groupId>org.dromara</groupId>
@@ -82,13 +75,6 @@
                 <version>${revision}</version>
             </dependency>
 
-            <!-- 限流 -->
-            <dependency>
-                <groupId>org.dromara</groupId>
-                <artifactId>ruoyi-common-ratelimiter</artifactId>
-                <version>${revision}</version>
-            </dependency>
-
             <!-- 缓存服务 -->
             <dependency>
                 <groupId>org.dromara</groupId>
@@ -117,6 +103,7 @@
                 <version>${revision}</version>
             </dependency>
 
+            <!-- 授权认证 -->
             <dependency>
                 <groupId>org.dromara</groupId>
                 <artifactId>ruoyi-common-social</artifactId>
@@ -158,24 +145,17 @@
                 <version>${revision}</version>
             </dependency>
 
-            <!-- 租户模块 -->
+            <!-- 消息推送模块 -->
             <dependency>
                 <groupId>org.dromara</groupId>
-                <artifactId>ruoyi-common-tenant</artifactId>
+                <artifactId>ruoyi-common-push</artifactId>
                 <version>${revision}</version>
             </dependency>
 
-            <!-- WebSocket模块 -->
+            <!-- mqtt模块 -->
             <dependency>
                 <groupId>org.dromara</groupId>
-                <artifactId>ruoyi-common-websocket</artifactId>
-                <version>${revision}</version>
-            </dependency>
-
-            <!-- SSE模块 -->
-            <dependency>
-                <groupId>org.dromara</groupId>
-                <artifactId>ruoyi-common-sse</artifactId>
+                <artifactId>ruoyi-common-mqtt</artifactId>
                 <version>${revision}</version>
             </dependency>
 

ruoyi-common/ruoyi-common-core/pom.xml

@@ -36,7 +36,7 @@
 
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-aop</artifactId>
+            <artifactId>spring-boot-starter-aspectj</artifactId>
         </dependency>
 
         <!--常用工具类 -->

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/config/AsyncConfig.java

@@ -1,52 +0,0 @@
-package org.dromara.common.core.config;
-
-import cn.hutool.core.util.ArrayUtil;
-import org.dromara.common.core.exception.ServiceException;
-import org.dromara.common.core.utils.SpringUtils;
-import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
-import org.springframework.boot.autoconfigure.AutoConfiguration;
-import org.springframework.core.task.VirtualThreadTaskExecutor;
-import org.springframework.scheduling.annotation.AsyncConfigurer;
-
-import java.util.Arrays;
-import java.util.concurrent.Executor;
-
-/**
- * 异步配置
- * <p>
- * 如果未使用虚拟线程则生效
- *
- * @author Lion Li
- */
-@AutoConfiguration
-public class AsyncConfig implements AsyncConfigurer {
-
-    /**
-     * 自定义 @Async 注解使用系统线程池
-     */
-    @Override
-    public Executor getAsyncExecutor() {
-        if(SpringUtils.isVirtual()) {
-            return new VirtualThreadTaskExecutor("async-");
-        }
-        return SpringUtils.getBean("scheduledExecutorService");
-    }
-
-    /**
-     * 异步执行异常处理
-     */
-    @Override
-    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
-        return (throwable, method, objects) -> {
-            throwable.printStackTrace();
-            StringBuilder sb = new StringBuilder();
-            sb.append("Exception message - ").append(throwable.getMessage())
-                .append(", Method name - ").append(method.getName());
-            if (ArrayUtil.isNotEmpty(objects)) {
-                sb.append(", Parameter value - ").append(Arrays.toString(objects));
-            }
-            throw new ServiceException(sb.toString());
-        };
-    }
-
-}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/config/ThreadPoolConfig.java

@@ -3,19 +3,12 @@ package org.dromara.common.core.config;
 import jakarta.annotation.PreDestroy;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.concurrent.BasicThreadFactory;
-import org.dromara.common.core.config.properties.ThreadPoolProperties;
 import org.dromara.common.core.utils.SpringUtils;
-import org.dromara.common.core.utils.Threads;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.core.task.VirtualThreadTaskExecutor;
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.*;
 
 /**
  * 线程池配置
@@ -24,7 +17,6 @@ import java.util.concurrent.ThreadPoolExecutor;
  **/
 @Slf4j
 @AutoConfiguration
-@EnableConfigurationProperties(ThreadPoolProperties.class)
 public class ThreadPoolConfig {
 
     /**
@@ -34,20 +26,10 @@ public class ThreadPoolConfig {
 
     private ScheduledExecutorService scheduledExecutorService;
 
-    @Bean(name = "threadPoolTaskExecutor")
-    @ConditionalOnProperty(prefix = "thread-pool", name = "enabled", havingValue = "true")
-    public ThreadPoolTaskExecutor threadPoolTaskExecutor(ThreadPoolProperties threadPoolProperties) {
-        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
-        executor.setCorePoolSize(core);
-        executor.setMaxPoolSize(core * 2);
-        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
-        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
-        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
-        return executor;
-    }
-
     /**
      * 执行周期性或定时任务
+     *
+     * @return 全局定时任务线程池
      */
     @Bean(name = "scheduledExecutorService")
     protected ScheduledExecutorService scheduledExecutorService() {
@@ -64,7 +46,7 @@ public class ThreadPoolConfig {
             @Override
             protected void afterExecute(Runnable r, Throwable t) {
                 super.afterExecute(r, t);
-                Threads.printException(r, t);
+                printException(r, t);
             }
         };
         this.scheduledExecutorService = scheduledThreadPoolExecutor;
@@ -73,15 +55,60 @@ public class ThreadPoolConfig {
 
     /**
      * 销毁事件
+     * 停止线程池
+     * 先使用shutdown, 停止接收新任务并尝试完成所有已存在任务.
+     * 如果超时, 则调用shutdownNow, 取消在workQueue中Pending的任务,并中断所有阻塞函数.
+     * 如果仍然超時，則強制退出.
+     * 另对在shutdown时线程本身被调用中断做了处理.
      */
     @PreDestroy
     public void destroy() {
         try {
             log.info("====关闭后台任务任务线程池====");
-            Threads.shutdownAndAwaitTermination(scheduledExecutorService);
+            ScheduledExecutorService pool = scheduledExecutorService;
+            if (pool != null && !pool.isShutdown()) {
+                pool.shutdown();
+                try {
+                    if (!pool.awaitTermination(120, TimeUnit.SECONDS)) {
+                        pool.shutdownNow();
+                        if (!pool.awaitTermination(120, TimeUnit.SECONDS)) {
+                            log.info("Pool did not terminate");
+                        }
+                    }
+                } catch (InterruptedException ie) {
+                    pool.shutdownNow();
+                    Thread.currentThread().interrupt();
+                }
+            }
         } catch (Exception e) {
             log.error(e.getMessage(), e);
         }
     }
 
+    /**
+     * 打印线程异常信息
+     *
+     * @param r 已执行的任务
+     * @param t 任务执行过程中抛出的异常
+     */
+    public static void printException(Runnable r, Throwable t) {
+        if (t == null && r instanceof Future<?>) {
+            try {
+                Future<?> future = (Future<?>) r;
+                if (future.isDone()) {
+                    future.get();
+                }
+            } catch (CancellationException ce) {
+                t = ce;
+            } catch (ExecutionException ee) {
+                t = ee.getCause();
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        if (t != null) {
+            log.error(t.getMessage(), t);
+        }
+    }
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/config/ValidatorConfig.java

@@ -3,7 +3,7 @@ package org.dromara.common.core.config;
 import jakarta.validation.Validator;
 import org.hibernate.validator.HibernateValidator;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
-import org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration;
+import org.springframework.boot.validation.autoconfigure.ValidationAutoConfiguration;
 import org.springframework.context.MessageSource;
 import org.springframework.context.annotation.Bean;
 import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
@@ -20,6 +20,9 @@ public class ValidatorConfig {
 
     /**
      * 配置校验框架 快速失败模式
+     *
+     * @param messageSource 国际化消息源
+     * @return 启用快速失败模式的校验器
      */
     @Bean
     public Validator validator(MessageSource messageSource) {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/config/properties/ThreadPoolProperties.java

@@ -1,30 +0,0 @@
-package org.dromara.common.core.config.properties;
-
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-
-/**
- * 线程池 配置属性
- *
- * @author Lion Li
- */
-@Data
-@ConfigurationProperties(prefix = "thread-pool")
-public class ThreadPoolProperties {
-
-    /**
-     * 是否开启线程池
-     */
-    private boolean enabled;
-
-    /**
-     * 队列最大长度
-     */
-    private int queueCapacity;
-
-    /**
-     * 线程池维护线程所允许的空闲时间
-     */
-    private int keepAliveSeconds;
-
-}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/CacheConstants.java

@@ -1,30 +0,0 @@
-package org.dromara.common.core.constant;
-
-/**
- * 缓存的key 常量
- *
- * @author Lion Li
- */
-public interface CacheConstants {
-
-    /**
-     * 在线用户 redis key
-     */
-    String ONLINE_TOKEN_KEY = "online_tokens:";
-
-    /**
-     * 参数管理 cache key
-     */
-    String SYS_CONFIG_KEY = "sys_config:";
-
-    /**
-     * 字典管理 cache key
-     */
-    String SYS_DICT_KEY = "sys_dict:";
-
-    /**
-     * 登录账户密码错误次数 redis key
-     */
-    String PWD_ERR_CNT_KEY = "pwd_err_cnt:";
-
-}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/CacheNames.java

@@ -1,7 +1,7 @@
 package org.dromara.common.core.constant;
 
 /**
- * 缓存组名称常量
+ * 缓存组名称常量，统一约定缓存名和缓存策略配置格式。
  * <p>
  * key 格式为 cacheNames#ttl#maxIdleTime#maxSize#local
  * <p>
@@ -36,15 +36,10 @@ public interface CacheNames {
      */
     String SYS_DICT_TYPE = "sys_dict_type";
 
-    /**
-     * 租户
-     */
-    String SYS_TENANT = GlobalConstants.GLOBAL_REDIS_KEY + "sys_tenant#30d";
-
     /**
      * 客户端
      */
-    String SYS_CLIENT = GlobalConstants.GLOBAL_REDIS_KEY + "sys_client#30d";
+    String SYS_CLIENT = "sys_client#30d";
 
     /**
      * 用户账户
@@ -52,7 +47,7 @@ public interface CacheNames {
     String SYS_USER_NAME = "sys_user_name#30d";
 
     /**
-     * 用户名称
+     * 用户昵称
      */
     String SYS_NICKNAME = "sys_nickname#30d";
 
@@ -79,11 +74,16 @@ public interface CacheNames {
     /**
      * OSS配置
      */
-    String SYS_OSS_CONFIG = GlobalConstants.GLOBAL_REDIS_KEY + "sys_oss_config";
+    String SYS_OSS_CONFIG = "sys_oss_config";
 
     /**
      * 在线用户
      */
-    String ONLINE_TOKEN = "online_tokens";
+    String ONLINE_TOKEN_KEY = "online_tokens:";
+
+    /**
+     * 登录账户密码错误次数 redis key
+     */
+    String PWD_ERR_CNT_KEY = "pwd_err_cnt:";
 
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/Constants.java

@@ -1,7 +1,7 @@
 package org.dromara.common.core.constant;
 
 /**
- * 通用常量信息
+ * 通用基础常量定义。
  *
  * @author ruoyi
  */
@@ -72,5 +72,10 @@ public interface Constants {
      */
     Long TOP_PARENT_ID = 0L;
 
+    /**
+     * 加密头
+     */
+    String ENCRYPT_HEADER = "ENC_";
+
 }
 

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/GlobalConstants.java

@@ -1,7 +1,7 @@
 package org.dromara.common.core.constant;
 
 /**
- * 全局的key常量 (业务无关的key)
+ * 全局通用键常量，主要用于业务无关的 Redis Key 前缀定义。
  *
  * @author Lion Li
  */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/RegexConstants.java

@@ -7,7 +7,7 @@ import cn.hutool.core.lang.RegexPool;
  * <p>
  * 常用正则表达式集合，更多正则见: https://any86.github.io/any-rule/
  *
- * @author Feng
+ * @author AprilWind
  */
 public interface RegexConstants extends RegexPool {
 

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/SystemConstants.java

@@ -18,25 +18,15 @@ public interface SystemConstants {
     String DISABLE = "1";
 
     /**
-     * 是否为系统默认（是）
+     * 是
      */
     String YES = "Y";
 
     /**
-     * 是否为系统默认（否）
+     * 否
      */
     String NO = "N";
 
-    /**
-     * 是否菜单外链（是）
-     */
-    String YES_FRAME = "0";
-
-    /**
-     * 是否菜单外链（否）
-     */
-    String NO_FRAME = "1";
-
     /**
      * 菜单类型（目录）
      */
@@ -72,6 +62,11 @@ public interface SystemConstants {
      */
     Long SUPER_ADMIN_ID = 1L;
 
+    /**
+     * 超级管理员角色 roleKey
+     */
+    String SUPER_ADMIN_ROLE_KEY = "superadmin";
+
     /**
      * 根部门祖级列表
      */
@@ -82,4 +77,10 @@ public interface SystemConstants {
      */
     Long DEFAULT_DEPT_ID = 100L;
 
+    /**
+     * 排除敏感属性字段
+     */
+    String[] EXCLUDE_PROPERTIES = { "password", "oldPassword", "newPassword", "confirmPassword" };
+
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/TenantConstants.java

@@ -1,35 +0,0 @@
-package org.dromara.common.core.constant;
-
-/**
- * 租户常量信息
- *
- * @author Lion Li
- */
-public interface TenantConstants {
-
-    /**
-     * 超级管理员ID
-     */
-    Long SUPER_ADMIN_ID = 1L;
-
-    /**
-     * 超级管理员角色 roleKey
-     */
-    String SUPER_ADMIN_ROLE_KEY = "superadmin";
-
-    /**
-     * 租户管理员角色 roleKey
-     */
-    String TENANT_ADMIN_ROLE_KEY = "admin";
-
-    /**
-     * 租户管理员角色名称
-     */
-    String TENANT_ADMIN_ROLE_NAME = "管理员";
-
-    /**
-     * 默认租户ID
-     */
-    String DEFAULT_TENANT_ID = "000000";
-
-}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/PageResult.java

@@ -0,0 +1,70 @@
+package org.dromara.common.core.domain;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.Collection;
+
+/**
+ * 表格分页数据对象
+ *
+ * @author Lion Li
+ */
+@Data
+@NoArgsConstructor
+public class PageResult<T> implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 总记录数
+     */
+    private long total;
+
+    /**
+     * 列表数据
+     */
+    private Collection<T> rows;
+
+    /**
+     * 分页
+     *
+     * @param list  列表数据
+     * @param total 总记录数
+     */
+    public PageResult(Collection<T> list, long total) {
+        this.rows = list;
+        this.total = total;
+    }
+
+    /**
+     * 根据分页对象构建表格分页数据对象
+     */
+    public static <T> PageResult<T> build(Collection<T> list, long total) {
+        PageResult<T> rspData = new PageResult<>();
+        rspData.setRows(list);
+        rspData.setTotal(total);
+        return rspData;
+    }
+
+    /**
+     * 根据数据列表构建表格分页数据对象
+     */
+    public static <T> PageResult<T> build(Collection<T> list) {
+        PageResult<T> rspData = new PageResult<>();
+        rspData.setRows(list);
+        rspData.setTotal(list.size());
+        return rspData;
+    }
+
+    /**
+     * 构建表格分页数据对象
+     */
+    public static <T> PageResult<T> build() {
+        return new PageResult<>();
+    }
+
+}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/R.java

@@ -1,15 +1,19 @@
 package org.dromara.common.core.domain;
 
-import org.dromara.common.core.constant.HttpStatus;
 import lombok.Data;
 import lombok.NoArgsConstructor;
+import org.dromara.common.core.constant.HttpStatus;
 
 import java.io.Serial;
 import java.io.Serializable;
 
+import static org.dromara.common.core.constant.HttpStatus.ERROR;
+import static org.dromara.common.core.constant.HttpStatus.SUCCESS;
+
 /**
  * 响应信息主体
  *
+ * @param <T> 响应数据的泛型类型
  * @author Lion Li
  */
 @Data
@@ -20,78 +24,152 @@ public class R<T> implements Serializable {
     private static final long serialVersionUID = 1L;
 
     /**
-     * 成功
+     * 响应状态码
      */
-    public static final int SUCCESS = 200;
-
-    /**
-     * 失败
-     */
-    public static final int FAIL = 500;
-
     private int code;
 
+    /**
+     * 响应提示信息
+     */
     private String msg;
 
+    /**
+     * 响应业务数据
+     */
     private T data;
 
+    /**
+     * 构建成功响应结果
+     *
+     * @param <T> 响应数据的泛型类型
+     * @return 成功响应结果对象
+     */
     public static <T> R<T> ok() {
         return restResult(null, SUCCESS, "操作成功");
     }
 
+    /**
+     * 构建成功响应结果（带业务数据）
+     *
+     * @param data 业务数据
+     * @param <T>  响应数据的泛型类型
+     * @return 成功响应结果对象
+     */
     public static <T> R<T> ok(T data) {
         return restResult(data, SUCCESS, "操作成功");
     }
 
+    /**
+     * 构建成功响应结果（自定义提示信息）
+     *
+     * @param msg 自定义提示信息
+     * @param <T> 响应数据的泛型类型
+     * @return 成功响应结果对象
+     */
     public static <T> R<T> ok(String msg) {
         return restResult(null, SUCCESS, msg);
     }
 
+    /**
+     * 构建成功响应结果（自定义提示信息+业务数据）
+     *
+     * @param msg  自定义提示信息
+     * @param data 业务数据
+     * @param <T>  响应数据的泛型类型
+     * @return 成功响应结果对象
+     */
     public static <T> R<T> ok(String msg, T data) {
         return restResult(data, SUCCESS, msg);
     }
 
+    /**
+     * 构建失败响应结果
+     *
+     * @param <T> 响应数据的泛型类型
+     * @return 失败响应结果对象
+     */
     public static <T> R<T> fail() {
-        return restResult(null, FAIL, "操作失败");
+        return restResult(null, ERROR, "操作失败");
     }
 
+    /**
+     * 构建失败响应结果（自定义提示信息）
+     *
+     * @param msg 自定义提示信息
+     * @param <T> 响应数据的泛型类型
+     * @return 失败响应结果对象
+     */
     public static <T> R<T> fail(String msg) {
-        return restResult(null, FAIL, msg);
+        return restResult(null, ERROR, msg);
     }
 
+    /**
+     * 构建失败响应结果（带业务数据）
+     *
+     * @param data 业务数据
+     * @param <T>  响应数据的泛型类型
+     * @return 失败响应结果对象
+     */
     public static <T> R<T> fail(T data) {
-        return restResult(data, FAIL, "操作失败");
+        return restResult(data, ERROR, "操作失败");
     }
 
+    /**
+     * 构建失败响应结果（自定义提示信息+业务数据）
+     *
+     * @param msg  自定义提示信息
+     * @param data 业务数据
+     * @param <T>  响应数据的泛型类型
+     * @return 失败响应结果对象
+     */
     public static <T> R<T> fail(String msg, T data) {
-        return restResult(data, FAIL, msg);
+        return restResult(data, ERROR, msg);
     }
 
+    /**
+     * 构建失败响应结果（自定义状态码+提示信息）
+     *
+     * @param code 自定义状态码
+     * @param msg  自定义提示信息
+     * @param <T>  响应数据的泛型类型
+     * @return 失败响应结果对象
+     */
     public static <T> R<T> fail(int code, String msg) {
         return restResult(null, code, msg);
     }
 
     /**
-     * 返回警告消息
+     * 构建警告响应结果
      *
-     * @param msg 返回内容
-     * @return 警告消息
+     * @param msg 自定义提示信息
+     * @param <T> 响应数据的泛型类型
+     * @return 警告响应结果对象
      */
     public static <T> R<T> warn(String msg) {
         return restResult(null, HttpStatus.WARN, msg);
     }
 
     /**
-     * 返回警告消息
+     * 构建警告响应结果（自定义提示信息+业务数据）
      *
-     * @param msg 返回内容
-     * @param data 数据对象
-     * @return 警告消息
+     * @param msg  自定义提示信息
+     * @param data 业务数据
+     * @param <T>  响应数据的泛型类型
+     * @return 警告响应结果对象
      */
     public static <T> R<T> warn(String msg, T data) {
         return restResult(data, HttpStatus.WARN, msg);
     }
 
+    /**
+     * 核心构建方法
+     *
+     * @param data 业务数据
+     * @param code 响应状态码
+     * @param msg  提示信息
+     * @param <T>  响应数据的泛型类型
+     * @return 响应结果对象
+     */
     private static <T> R<T> restResult(T data, int code, String msg) {
         R<T> r = new R<>();
         r.setCode(code);
@@ -100,11 +178,26 @@ public class R<T> implements Serializable {
         return r;
     }
 
+    /**
+     * 判断响应结果是否为失败
+     *
+     * @param ret 响应结果对象
+     * @param <T> 响应数据的泛型类型
+     * @return true=失败，false=成功
+     */
     public static <T> Boolean isError(R<T> ret) {
         return !isSuccess(ret);
     }
 
+    /**
+     * 判断响应结果是否为成功
+     *
+     * @param ret 响应结果对象
+     * @param <T> 响应数据的泛型类型
+     * @return true=成功，false=失败
+     */
     public static <T> Boolean isSuccess(R<T> ret) {
-        return R.SUCCESS == ret.getCode();
+        return SUCCESS == ret.getCode();
     }
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/CompleteTaskDTO.java

@@ -50,6 +50,11 @@ public class CompleteTaskDTO implements Serializable {
      */
     private String notice;
 
+    /**
+     * 办理人(可不填 用于覆盖当前节点办理人)
+     */
+    private String handler;
+
     /**
      * 流程变量
      */
@@ -60,9 +65,15 @@ public class CompleteTaskDTO implements Serializable {
      */
     private String ext;
 
+    /**
+     * 获取流程变量并自动剔除空值。
+     *
+     * @return 流程变量
+     */
     public Map<String, Object> getVariables() {
         if (variables == null) {
-            return new HashMap<>(16);
+            variables = new HashMap<>(16);
+            return variables;
         }
         variables.entrySet().removeIf(entry -> Objects.isNull(entry.getValue()));
         return variables;

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/FlowCopyDTO.java

@@ -1,30 +1,14 @@
 package org.dromara.common.core.domain.dto;
 
-import lombok.Data;
-
-import java.io.Serial;
-import java.io.Serializable;
-
-
 /**
  * 抄送
  *
+ * @param userId   抄送用户 ID
+ * @param nickName 抄送用户昵称
  * @author may
  */
-@Data
-public class FlowCopyDTO implements Serializable {
-
-    @Serial
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * 用户id
-     */
-    private Long userId;
-
-    /**
-     * 用户名称
-     */
-    private String userName;
-
+public record FlowCopyDTO(
+    Long userId,
+    String nickName
+) {
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/FlowInstanceBizExtDTO.java

@@ -0,0 +1,45 @@
+package org.dromara.common.core.domain.dto;
+
+import lombok.Data;
+
+import java.io.Serial;
+import java.io.Serializable;
+
+/**
+ * 流程实例业务扩展对象
+ *
+ * @author may
+ * @date 2025-08-05
+ */
+@Data
+public class FlowInstanceBizExtDTO implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    private Long id;
+
+    /**
+     * 流程实例ID
+     */
+    private Long instanceId;
+
+    /**
+     * 业务ID
+     */
+    private String businessId;
+
+    /**
+     * 业务编码
+     */
+    private String businessCode;
+
+    /**
+     * 业务标题
+     */
+    private String businessTitle;
+
+}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/OssDTO.java

@@ -7,7 +7,7 @@ import java.io.Serial;
 import java.io.Serializable;
 
 /**
- * OSS对象
+ * OSS 文件简要信息对象。
  *
  * @author Lion Li
  */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/PostDTO.java

@@ -7,7 +7,7 @@ import java.io.Serial;
 import java.io.Serializable;
 
 /**
- * 岗位
+ * 岗位简要信息对象。
  *
  * @author AprilWind
  */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/PushPayloadDTO.java

@@ -0,0 +1,81 @@
+package org.dromara.common.core.domain.dto;
+
+import lombok.Data;
+import org.dromara.common.core.enums.PushSourceEnum;
+import org.dromara.common.core.enums.PushTypeEnum;
+import org.dromara.common.core.utils.StringUtils;
+
+import java.io.Serial;
+import java.io.Serializable;
+
+/**
+ * 推送给前端的统一消息体
+ *
+ * @author Lion Li
+ */
+@Data
+public class PushPayloadDTO implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 消息记录ID
+     */
+    private Long messageId;
+
+    /**
+     * 消息类型
+     */
+    private String type;
+
+    /**
+     * 消息来源
+     */
+    private String source;
+
+    /**
+     * 文本消息
+     */
+    private String message;
+
+    /**
+     * 扩展数据
+     */
+    private Object data;
+
+    /**
+     * 前端跳转路径
+     */
+    private String path;
+
+    /**
+     * 时间戳
+     */
+    private Long timestamp;
+
+    public static PushPayloadDTO of(String type, String source, String message, Object data) {
+        PushPayloadDTO payload = new PushPayloadDTO();
+        payload.setType(StringUtils.defaultIfBlank(type, PushTypeEnum.MESSAGE.getType()));
+        payload.setSource(StringUtils.defaultIfBlank(source, PushSourceEnum.BACKEND.getSource()));
+        payload.setMessage(message);
+        payload.setData(data);
+        payload.setTimestamp(System.currentTimeMillis());
+        return payload;
+    }
+
+    public static PushPayloadDTO of(PushTypeEnum type, PushSourceEnum source, String message, Object data) {
+        return of(
+            type == null ? null : type.getType(),
+            source == null ? null : source.getSource(),
+            message,
+            data
+        );
+    }
+
+    public static PushPayloadDTO of(PushTypeEnum type, PushSourceEnum source, String message, Object data, String path) {
+        PushPayloadDTO payload = of(type, source, message, data);
+        payload.setPath(path);
+        return payload;
+    }
+}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/RoleDTO.java

@@ -7,11 +7,10 @@ import java.io.Serial;
 import java.io.Serializable;
 
 /**
- * 角色
+ * 角色简要信息对象。
  *
  * @author Lion Li
  */
-
 @Data
 @NoArgsConstructor
 public class RoleDTO implements Serializable {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/StartProcessDTO.java

@@ -1,6 +1,7 @@
 package org.dromara.common.core.domain.dto;
 
 
+import cn.hutool.core.util.ObjectUtil;
 import lombok.Data;
 
 import java.io.Serial;
@@ -10,7 +11,7 @@ import java.util.Map;
 import java.util.Objects;
 
 /**
- * 启动流程对象
+ * 启动流程请求对象。
  *
  * @author may
  */
@@ -30,16 +31,44 @@ public class StartProcessDTO implements Serializable {
      */
     private String flowCode;
 
+    /**
+     * 办理人(可不填 用于覆盖当前节点办理人)
+     */
+    private String handler;
+
     /**
      * 流程变量，前端会提交一个元素{'entity': {业务详情数据对象}}
      */
     private Map<String, Object> variables;
 
+    /**
+     * 流程业务扩展信息
+     */
+    private FlowInstanceBizExtDTO bizExt;
+
+    /**
+     * 获取流程变量并自动剔除空值。
+     *
+     * @return 流程变量
+     */
     public Map<String, Object> getVariables() {
         if (variables == null) {
-            return new HashMap<>(16);
+            variables = new HashMap<>(16);
+            return variables;
         }
         variables.entrySet().removeIf(entry -> Objects.isNull(entry.getValue()));
         return variables;
     }
+
+    /**
+     * 获取流程业务扩展信息，为空时返回默认对象。
+     *
+     * @return 业务扩展信息
+     */
+    public FlowInstanceBizExtDTO getBizExt() {
+        if (ObjectUtil.isNull(bizExt)) {
+            bizExt = new FlowInstanceBizExtDTO();
+        }
+        return bizExt;
+    }
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/StartProcessReturnDTO.java

@@ -1,30 +1,14 @@
 package org.dromara.common.core.domain.dto;
 
-
-import lombok.Data;
-
-import java.io.Serial;
-import java.io.Serializable;
-
 /**
- * 启动流程返回对象
+ * 启动流程后的返回结果对象。
  *
+ * @param processInstanceId 流程实例 ID
+ * @param taskId            首个任务 ID
  * @author Lion Li
  */
-@Data
-public class StartProcessReturnDTO implements Serializable {
-
-    @Serial
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * 流程实例id
-     */
-    private Long processInstanceId;
-
-    /**
-     * 任务id
-     */
-    private Long taskId;
-
+public record StartProcessReturnDTO(
+    Long processInstanceId,
+    Long taskId
+) {
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/TaskAssigneeDTO.java

@@ -6,7 +6,8 @@ import lombok.NoArgsConstructor;
 
 import java.io.Serial;
 import java.io.Serializable;
-import java.util.Date;
+import java.util.Collection;
+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -29,7 +30,7 @@ public class TaskAssigneeDTO implements Serializable {
     private Long total = 0L;
 
     /**
-     *
+     * 受让人列表。
      */
     private List<TaskHandler> list;
 
@@ -42,7 +43,7 @@ public class TaskAssigneeDTO implements Serializable {
      * 将源列表转换为 TaskHandler 列表
      *
      * @param <T>              通用类型
-     * @param sourceList       待转换的源列表
+     * @param sourceCollection 待转换的源列表
      * @param storageId        提取 storageId 的函数
      * @param handlerCode      提取 handlerCode 的函数
      * @param handlerName      提取 handlerName 的函数
@@ -51,22 +52,25 @@ public class TaskAssigneeDTO implements Serializable {
      * @return 转换后的 TaskHandler 列表
      */
     public static <T> List<TaskHandler> convertToHandlerList(
-        List<T> sourceList,
-        Function<T, Long> storageId,
+        Collection<T> sourceCollection,
+        Function<T, String> storageId,
         Function<T, String> handlerCode,
         Function<T, String> handlerName,
-        Function<T, Long> groupName,
-        Function<T, Date> createTimeMapper) {
-        return sourceList.stream()
+        Function<T, String> groupName,
+        Function<T, LocalDateTime> createTimeMapper) {
+        return sourceCollection.stream()
             .map(item -> new TaskHandler(
-                String.valueOf(storageId.apply(item)),
+                storageId.apply(item),
                 handlerCode.apply(item),
                 handlerName.apply(item),
-                groupName != null ? String.valueOf(groupName.apply(item)) : null,
+                groupName.apply(item),
                 createTimeMapper.apply(item)
             )).collect(Collectors.toList());
     }
 
+    /**
+     * 任务受让人明细对象。
+     */
     @Data
     @NoArgsConstructor
     @AllArgsConstructor
@@ -95,7 +99,7 @@ public class TaskAssigneeDTO implements Serializable {
         /**
          * 创建时间
          */
-        private Date createTime;
+        private LocalDateTime createTime;
     }
 
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/UserDTO.java

@@ -5,7 +5,7 @@ import lombok.NoArgsConstructor;
 
 import java.io.Serial;
 import java.io.Serializable;
-import java.util.Date;
+import java.time.LocalDateTime;
 
 
 /**
@@ -53,7 +53,7 @@ public class UserDTO implements Serializable {
     /**
      * 手机号码
      */
-    private String phonenumber;
+    private String phoneNumber;
 
     /**
      * 用户性别（0男 1女 2未知）
@@ -61,13 +61,13 @@ public class UserDTO implements Serializable {
     private String sex;
 
     /**
-     * 帐号状态（0正常 1停用）
+     * 账号状态（0正常 1停用）
      */
     private String status;
 
     /**
      * 创建时间
      */
-    private Date createTime;
+    private LocalDateTime createTime;
 
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/dto/UserOnlineDTO.java

@@ -7,11 +7,10 @@ import java.io.Serial;
 import java.io.Serializable;
 
 /**
- * 当前在线会话
+ * 当前在线会话信息对象。
  *
  * @author ruoyi
  */
-
 @Data
 @NoArgsConstructor
 public class UserOnlineDTO implements Serializable {
@@ -30,7 +29,7 @@ public class UserOnlineDTO implements Serializable {
     private String deptName;
 
     /**
-     * 用户名称
+     * 用户账号
      */
     private String userName;
 

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/event/ProcessDeleteEvent.java

@@ -16,11 +16,6 @@ public class ProcessDeleteEvent implements Serializable {
     @Serial
     private static final long serialVersionUID = 1L;
 
-    /**
-     * 租户ID
-     */
-    private String tenantId;
-
     /**
      * 流程定义编码
      */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/event/ProcessEvent.java

@@ -17,16 +17,16 @@ public class ProcessEvent implements Serializable {
     @Serial
     private static final long serialVersionUID = 1L;
 
-    /**
-     * 租户ID
-     */
-    private String tenantId;
-
     /**
      * 流程定义编码
      */
     private String flowCode;
 
+    /**
+     * 实例id
+     */
+    private Long instanceId;
+
     /**
      * 业务id
      */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/event/ProcessTaskEvent.java

@@ -4,6 +4,7 @@ import lombok.Data;
 
 import java.io.Serial;
 import java.io.Serializable;
+import java.util.Map;
 
 /**
  * 流程任务监听
@@ -16,11 +17,6 @@ public class ProcessTaskEvent implements Serializable {
     @Serial
     private static final long serialVersionUID = 1L;
 
-    /**
-     * 租户ID
-     */
-    private String tenantId;
-
     /**
      * 流程定义编码
      */
@@ -46,6 +42,11 @@ public class ProcessTaskEvent implements Serializable {
      */
     private Long taskId;
 
+    /**
+     * 实例id
+     */
+    private Long instanceId;
+
     /**
      * 业务id
      */
@@ -56,4 +57,9 @@ public class ProcessTaskEvent implements Serializable {
      */
     private String status;
 
+    /**
+     * 办理参数
+     */
+    private Map<String, Object> params;
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/EmailLoginBody.java

@@ -6,11 +6,10 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 /**
- * 邮件登录对象
+ * 邮箱验证码登录请求对象。
  *
  * @author Lion Li
  */
-
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class EmailLoginBody extends LoginBody {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/LoginBody.java

@@ -7,11 +7,10 @@ import java.io.Serial;
 import java.io.Serializable;
 
 /**
- * 用户登录对象
+ * 通用登录请求对象，封装客户端、授权类型和验证码信息。
  *
  * @author Lion Li
  */
-
 @Data
 public class LoginBody implements Serializable {
 
@@ -30,18 +29,13 @@ public class LoginBody implements Serializable {
     @NotBlank(message = "{auth.grant.type.not.blank}")
     private String grantType;
 
-    /**
-     * 租户ID
-     */
-    private String tenantId;
-
     /**
      * 验证码
      */
     private String code;
 
     /**
-     * 唯一标识
+     * 验证码唯一标识。
      */
     private String uuid;
 

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/LoginUser.java

@@ -8,10 +8,11 @@ import org.dromara.common.core.domain.dto.RoleDTO;
 import java.io.Serial;
 import java.io.Serializable;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
- * 登录用户身份权限
+ * 登录用户上下文对象，保存当前会话的身份、权限和终端信息。
  *
  * @author Lion Li
  */
@@ -22,11 +23,6 @@ public class LoginUser implements Serializable {
     @Serial
     private static final long serialVersionUID = 1L;
 
-    /**
-     * 租户ID
-     */
-    private String tenantId;
-
     /**
      * 用户ID
      */
@@ -112,6 +108,11 @@ public class LoginUser implements Serializable {
      */
     private List<RoleDTO> roles;
 
+    /**
+     * 数据权限角色映射 key 为权限码 value 为可参与数据权限计算的角色ID列表
+     */
+    private Map<String, List<Long>> dataScopeRoleMap;
+
     /**
      * 岗位对象
      */
@@ -133,7 +134,9 @@ public class LoginUser implements Serializable {
     private String deviceType;
 
     /**
-     * 获取登录id
+     * 获取 Sa-Token 使用的登录标识。
+     *
+     * @return 登录标识
      */
     public String getLoginId() {
         if (userType == null) {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/PasswordLoginBody.java

@@ -26,6 +26,7 @@ public class PasswordLoginBody extends LoginBody {
      */
     @NotBlank(message = "{user.password.not.blank}")
     @Length(min = 5, max = 30, message = "{user.password.length.valid}")
+//    @Pattern(regexp = RegexConstants.PASSWORD, message = "{user.password.format.valid}")
     private String password;
 
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/RegisterBody.java

@@ -26,8 +26,12 @@ public class RegisterBody extends LoginBody {
      */
     @NotBlank(message = "{user.password.not.blank}")
     @Length(min = 5, max = 30, message = "{user.password.length.valid}")
+//    @Pattern(regexp = RegexConstants.PASSWORD, message = "{user.password.format.valid}")
     private String password;
 
+    /**
+     * 用户类型
+     */
     private String userType;
 
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/SmsLoginBody.java

@@ -5,11 +5,10 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 /**
- * 短信登录对象
+ * 短信验证码登录请求对象。
  *
  * @author Lion Li
  */
-
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class SmsLoginBody extends LoginBody {
@@ -18,7 +17,7 @@ public class SmsLoginBody extends LoginBody {
      * 手机号
      */
     @NotBlank(message = "{user.phonenumber.not.blank}")
-    private String phonenumber;
+    private String phoneNumber;
 
     /**
      * 短信code

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/SocialLoginBody.java

@@ -5,11 +5,10 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 /**
- * 三方登录对象
+ * 第三方平台登录绑定请求对象。
  *
  * @author Lion Li
  */
-
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class SocialLoginBody extends LoginBody {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/XcxLoginBody.java

@@ -5,11 +5,10 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 /**
- * 三方登录对象
+ * 小程序登录请求对象。
  *
  * @author Lion Li
  */
-
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class XcxLoginBody extends LoginBody {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/domain/model/XcxLoginUser.java

@@ -7,7 +7,7 @@ import lombok.NoArgsConstructor;
 import java.io.Serial;
 
 /**
- * 小程序登录用户身份权限
+ * 小程序登录用户上下文对象。
  *
  * @author Lion Li
  */
@@ -20,7 +20,7 @@ public class XcxLoginUser extends LoginUser {
     private static final long serialVersionUID = 1L;
 
     /**
-     * openid
+     * 小程序 openid。
      */
     private String openid;
 

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/BusinessStatusEnum.java

@@ -13,7 +13,7 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
- * 业务状态枚举
+ * 流程业务状态枚举，统一定义单据在审批流转中的状态。
  *
  * @author may
  */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/DeviceType.java

@@ -4,7 +4,7 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 /**
- * 设备类型
+ * 登录设备类型枚举。
  *
  * @author Lion Li
  */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/LoginType.java

@@ -4,7 +4,7 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 /**
- * 登录类型
+ * 登录类型枚举，同时维护不同登录方式对应的重试提示配置。
  *
  * @author Lion Li
  */

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/PushSourceEnum.java

@@ -0,0 +1,41 @@
+package org.dromara.common.core.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 推送消息来源枚举
+ *
+ * @author Lion Li
+ */
+@Getter
+@AllArgsConstructor
+public enum PushSourceEnum {
+
+    /**
+     * 后端系统消息
+     */
+    BACKEND("backend"),
+
+    /**
+     * 通知公告
+     */
+    NOTICE("notice"),
+
+    /**
+     * 工作流
+     */
+    WORKFLOW("workflow"),
+
+    /**
+     * 大模型
+     */
+    LLM("llm"),
+
+    /**
+     * 客户端消息
+     */
+    CLIENT("client");
+
+    private final String source;
+}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/PushTypeEnum.java

@@ -0,0 +1,36 @@
+package org.dromara.common.core.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 推送消息类型枚举
+ *
+ * @author Lion Li
+ */
+@Getter
+@AllArgsConstructor
+public enum PushTypeEnum {
+
+    /**
+     * 通用消息
+     */
+    MESSAGE("message"),
+
+    /**
+     * 通知公告
+     */
+    NOTICE("notice"),
+
+    /**
+     * 大模型消息
+     */
+    LLM("llm"),
+
+    /**
+     * 自定义消息
+     */
+    CUSTOM("custom");
+
+    private final String type;
+}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/UserStatus.java

@@ -24,7 +24,14 @@ public enum UserStatus {
      */
     DELETED("2", "删除");
 
+    /**
+     * 状态编码。
+     */
     private final String code;
+
+    /**
+     * 状态说明。
+     */
     private final String info;
 
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/UserType.java

@@ -28,6 +28,12 @@ public enum UserType {
      */
     private final String userType;
 
+    /**
+     * 根据字符串内容匹配用户类型。
+     *
+     * @param str 待匹配字符串
+     * @return 用户类型
+     */
     public static UserType getUserType(String str) {
         for (UserType value : values()) {
             if (StringUtils.contains(str, value.getUserType())) {

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/exception/ServiceException.java

@@ -1,11 +1,15 @@
 package org.dromara.common.core.exception;
 
-import lombok.*;
+import cn.hutool.core.text.StrFormatter;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
 
 import java.io.Serial;
 
 /**
- * 业务异常
+ * 通用业务异常，支持使用占位符拼接错误信息。
  *
  * @author ruoyi
  */
@@ -33,25 +37,58 @@ public final class ServiceException extends RuntimeException {
      */
     private String detailMessage;
 
+    /**
+     * 使用错误消息构造业务异常。
+     *
+     * @param message 错误消息
+     */
     public ServiceException(String message) {
         this.message = message;
     }
 
+    /**
+     * 使用错误消息和错误码构造业务异常。
+     *
+     * @param message 错误消息
+     * @param code 错误码
+     */
     public ServiceException(String message, Integer code) {
         this.message = message;
         this.code = code;
     }
 
+    /**
+     * 使用占位符参数格式化错误消息。
+     *
+     * @param message 模板消息
+     * @param args 参数
+     */
+    public ServiceException(String message, Object... args) {
+        this.message = StrFormatter.format(message, args);
+    }
+
     @Override
     public String getMessage() {
         return message;
     }
 
+    /**
+     * 设置错误消息并返回当前异常对象。
+     *
+     * @param message 错误消息
+     * @return 当前异常对象
+     */
     public ServiceException setMessage(String message) {
         this.message = message;
         return this;
     }
 
+    /**
+     * 设置错误明细并返回当前异常对象。
+     *
+     * @param detailMessage 错误明细
+     * @return 当前异常对象
+     */
     public ServiceException setDetailMessage(String detailMessage) {
         this.detailMessage = detailMessage;
         return this;

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/exception/SseException.java

@@ -8,7 +8,7 @@ import lombok.NoArgsConstructor;
 import java.io.Serial;
 
 /**
- * sse 特制异常
+ * SSE 场景专用异常。
  *
  * @author LionLi
  */
@@ -36,10 +36,21 @@ public final class SseException extends RuntimeException {
      */
     private String detailMessage;
 
+    /**
+     * 使用错误消息构造 SSE 异常。
+     *
+     * @param message 错误消息
+     */
     public SseException(String message) {
         this.message = message;
     }
 
+    /**
+     * 使用错误消息和错误码构造 SSE 异常。
+     *
+     * @param message 错误消息
+     * @param code 错误码
+     */
     public SseException(String message, Integer code) {
         this.message = message;
         this.code = code;
@@ -50,11 +61,23 @@ public final class SseException extends RuntimeException {
         return message;
     }
 
+    /**
+     * 设置错误消息并返回当前异常对象。
+     *
+     * @param message 错误消息
+     * @return 当前异常对象
+     */
     public SseException setMessage(String message) {
         this.message = message;
         return this;
     }
 
+    /**
+     * 设置错误明细并返回当前异常对象。
+     *
+     * @param detailMessage 错误明细
+     * @return 当前异常对象
+     */
     public SseException setDetailMessage(String detailMessage) {
         this.detailMessage = detailMessage;
         return this;

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/exception/base/BaseException.java

@@ -10,7 +10,7 @@ import lombok.NoArgsConstructor;
 import java.io.Serial;
 
 /**
- * 基础异常
+ * 基础国际化异常，支持按错误码解析最终提示信息。
  *
  * @author ruoyi
  */
@@ -43,18 +43,42 @@ public class BaseException extends RuntimeException {
      */
     private String defaultMessage;
 
+    /**
+     * 使用模块、错误码和参数构造异常。
+     *
+     * @param module 所属模块
+     * @param code 错误码
+     * @param args 参数
+     */
     public BaseException(String module, String code, Object[] args) {
         this(module, code, args, null);
     }
 
+    /**
+     * 使用模块和默认消息构造异常。
+     *
+     * @param module 所属模块
+     * @param defaultMessage 默认消息
+     */
     public BaseException(String module, String defaultMessage) {
         this(module, null, null, defaultMessage);
     }
 
+    /**
+     * 使用错误码和参数构造异常。
+     *
+     * @param code 错误码
+     * @param args 参数
+     */
     public BaseException(String code, Object[] args) {
         this(null, code, args, null);
     }
 
+    /**
+     * 使用默认消息构造异常。
+     *
+     * @param defaultMessage 默认消息
+     */
     public BaseException(String defaultMessage) {
         this(null, null, null, defaultMessage);
     }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/service/ConfigService.java

@@ -1,5 +1,11 @@
 package org.dromara.common.core.service;
 
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.lang.Dict;
+
+import java.math.BigDecimal;
+import java.util.List;
+
 /**
  * 通用 参数配置服务
  *
@@ -15,4 +21,80 @@ public interface ConfigService {
      */
     String getConfigValue(String configKey);
 
+    /**
+     * 根据参数 key 获取布尔值
+     *
+     * @param configKey 参数 key
+     * @return Boolean 值
+     */
+    default Boolean getConfigBool(String configKey) {
+        return Convert.toBool(getConfigValue(configKey));
+    }
+
+    /**
+     * 根据参数 key 获取整数值
+     *
+     * @param configKey 参数 key
+     * @return Integer 值
+     */
+    default Integer getConfigInt(String configKey) {
+        return Convert.toInt(getConfigValue(configKey));
+    }
+
+    /**
+     * 根据参数 key 获取长整型值
+     *
+     * @param configKey 参数 key
+     * @return Long 值
+     */
+    default Long getConfigLong(String configKey) {
+        return Convert.toLong(getConfigValue(configKey));
+    }
+
+    /**
+     * 根据参数 key 获取 BigDecimal 值
+     *
+     * @param configKey 参数 key
+     * @return BigDecimal 值
+     */
+    default BigDecimal getConfigDecimal(String configKey) {
+        return Convert.toBigDecimal(getConfigValue(configKey));
+    }
+
+    /**
+     * 根据参数 key 获取 Map 类型的配置
+     *
+     * @param configKey 参数 key
+     * @return Dict 对象，如果配置为空或无法解析，返回空 Dict
+     */
+    Dict getConfigMap(String configKey);
+
+    /**
+     * 根据参数 key 获取 Map 类型的配置列表
+     *
+     * @param configKey 参数 key
+     * @return Dict 列表，如果配置为空或无法解析，返回空列表
+     */
+    List<Dict> getConfigArrayMap(String configKey);
+
+    /**
+     * 根据参数 key 获取指定类型的配置对象
+     *
+     * @param configKey 参数 key
+     * @param clazz     目标对象类型
+     * @param <T>       目标对象泛型
+     * @return 对象实例，如果配置为空或无法解析，返回 null
+     */
+    <T> T getConfigObject(String configKey, Class<T> clazz);
+
+    /**
+     * 根据参数 key 获取指定类型的配置列表
+     *
+     * @param configKey 参数 key
+     * @param clazz     目标元素类型
+     * @param <T>       元素类型泛型
+     * @return 指定类型列表，如果配置为空或无法解析，返回空列表
+     */
+    <T> List<T> getConfigArray(String configKey, Class<T> clazz);
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/service/DeptService.java

@@ -2,7 +2,9 @@ package org.dromara.common.core.service;
 
 import org.dromara.common.core.domain.dto.DeptDTO;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 通用 部门服务
@@ -34,4 +36,12 @@ public interface DeptService {
      */
     List<DeptDTO> selectDeptsByList();
 
+    /**
+     * 根据部门 ID 列表查询部门名称映射关系
+     *
+     * @param deptIds 部门 ID 列表
+     * @return Map，其中 key 为部门 ID，value 为对应的部门名称
+     */
+    Map<Long, String> selectDeptNamesByIds(Collection<Long> deptIds);
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/service/MessageService.java

@@ -0,0 +1,66 @@
+package org.dromara.common.core.service;
+
+import org.dromara.common.core.domain.dto.PushPayloadDTO;
+
+import java.util.List;
+
+/**
+ * 通用 消息服务
+ *
+ * @author Lion Li
+ */
+public interface MessageService {
+
+    /**
+     * 发送指定用户文本消息
+     *
+     * @param userId  目标用户ID
+     * @param message 文本消息内容
+     */
+    void sendMessage(Long userId, String message);
+
+    /**
+     * 全局广播文本消息
+     *
+     * @param message 文本消息内容
+     */
+    void sendMessage(String message);
+
+    /**
+     * 发送指定用户自定义消息体
+     *
+     * @param userId  目标用户ID
+     * @param payload 消息推送体
+     */
+    void sendMessage(Long userId, PushPayloadDTO payload);
+
+    /**
+     * 全局广播自定义消息体
+     *
+     * @param payload 消息推送体
+     */
+    void sendMessage(PushPayloadDTO payload);
+
+    /**
+     * 批量发布消息给指定用户列表
+     *
+     * @param userIds 用户ID集合
+     * @param payload 消息推送体
+     */
+    void publishMessage(List<Long> userIds, PushPayloadDTO payload);
+
+    /**
+     * 发布全局广播文本消息
+     *
+     * @param message 文本消息内容
+     */
+    void publishAll(String message);
+
+    /**
+     * 发布全局广播自定义消息体
+     *
+     * @param payload 消息推送体
+     */
+    void publishAll(PushPayloadDTO payload);
+
+}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/service/PermissionService.java

@@ -1,5 +1,9 @@
 package org.dromara.common.core.service;
 
+import org.dromara.common.core.domain.dto.RoleDTO;
+
+import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -25,4 +29,12 @@ public interface PermissionService {
      */
     Set<String> getMenuPermission(Long userId);
 
+    /**
+     * 根据角色列表构建数据权限角色映射
+     *
+     * @param roles 角色列表
+     * @return key 为权限码 value 为命中的角色ID列表
+     */
+    Map<String, List<Long>> getDataScopeRoleMap(List<RoleDTO> roles);
+
 }

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/service/PostService.java

@@ -1,5 +1,8 @@
 package org.dromara.common.core.service;
 
+import java.util.Collection;
+import java.util.Map;
+
 /**
  * 通用 岗位服务
  *
@@ -7,4 +10,12 @@ package org.dromara.common.core.service;
  */
 public interface PostService {
 
+    /**
+     * 根据岗位 ID 列表查询岗位名称映射关系
+     *
+     * @param postIds 岗位 ID 列表
+     * @return Map，其中 key 为岗位 ID，value 为对应的岗位名称
+     */
+    Map<Long, String> selectPostNamesByIds(Collection<Long> postIds);
+
 }