合并升级3.9.0

2025-12-30 09:22:26 +00:00 · 2025-12-09 11:45:38 +08:00
parent 3599120c94 26087172df
commit cac4121209
740 changed files with 33732 additions and 181938 deletions
--- a/README-AI.md
+++ b/README-AI.md
@@ -3,9 +3,6 @@ AIGC应用平台介绍

 一个全栈式 AI 开发平台，旨在帮助开发者快速构建和部署个性化的 AI 应用。

-> JDK说明：AI流程编排引擎暂时不支持jdk21，所以目前只能使用jdk8或者jdk17启动项目。
-
-
 JeecgBoot平台的AIGC功能模块，是一套类似`Dify`的`AIGC应用开发平台`+`知识库问答`，是一款基于LLM大语言模型AI应用平台和 RAG 的知识库问答系统。
 其直观的界面结合了 AI 流程编排、RAG 管道、知识库管理、模型管理、对接向量库、实时运行可观察等，让您可以快速从原型到生产，拥有AI服务能力。

--- a/README-EN.md
+++ b/README-EN.md
@@ -7,12 +7,12 @@
 JEECG BOOT AI Low Code Platform
 ===============

-Current version: 3.8.3 (Release date: 2025-10-09)
+Current version: 3.9.0 (Release date: 2025-12-01)


 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/zhangdaiscott/jeecg-boot/blob/master/LICENSE)
 [![](https://img.shields.io/badge/Author-guojusoft-orange.svg)](http://www.jeecg.com)
-[![](https://img.shields.io/badge/version-3.8.2-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/version-3.9.0-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
 [![GitHub stars](https://img.shields.io/github/stars/zhangdaiscott/jeecg-boot.svg?style=social&label=Stars)](https://github.com/zhangdaiscott/jeecg-boot)
 [![GitHub forks](https://img.shields.io/github/forks/zhangdaiscott/jeecg-boot.svg?style=social&label=Fork)](https://github.com/zhangdaiscott/jeecg-boot)

--- a/README-Enterprise.md
+++ b/README-Enterprise.md
@@ -1,124 +0,0 @@
-
-JeecgBoot低代码平台(商业版介绍)
-===============
-
-
-
-项目介绍
-----------------------------------
-
-<h3 align="center">企业级AI低代码平台</h3>
-
-
-JeecgBoot是一款集成AI应用的，基于BPM流程的低代码平台，旨在帮助企业快速实现低代码开发和构建个性化AI应用！前后端分离架构Ant Design&Vue3，SpringBoot，SpringCloud Alibaba，Mybatis-plus，Shiro。强大的代码生成器让前后端代码一键生成，无需写任何代码！ 引领AI低代码开发模式: AI生成->OnlineCoding-> 代码生成-> 手工MERGE， 帮助Java项目解决80%的重复工作，让开发更多关注业务，提高效率、节省成本，同时又不失灵活性！低代码能力：Online表单、表单设计、流程设计、Online报表、大屏/仪表盘设计、报表设计; AI应用平台功能：AI知识库问答、AI模型管理、AI流程编排、AI聊天等，支持含ChatGPT、DeepSeek、Ollama等多种AI大模型
-
-JeecgBoot 提供了一系列 `低代码能力`，实现`真正的零代码`在线开发：Online表单开发、Online报表、复杂报表设计、打印设计、在线图表设计、仪表盘设计、大屏设计、移动图表能力、表单设计器、在线设计流程、流程自动化配置、插件能力（可插拔）
-
-`AI赋能低代码:` 目前提供了AI应用、AI模型管理、AI流程编排、AI对话助手，AI建表、AI写文章、AI知识库问答、AI字段建议等功能;支持各种AI大模型ChatGPT、DeepSeek、Ollama、智普、千问等.
-
-`JEECG宗旨是:` 简单功能由OnlineCoding配置实现，做到`零代码开发`；复杂功能由代码生成器生成进行手工Merge 实现`低代码开发`，既保证了`智能`又兼顾`灵活`；实现了低代码开发的同时又支持灵活编码，解决了当前低代码产品普遍不灵活的弊端！
-
-`JEECG业务流程:` 采用工作流来实现、扩展出任务接口，供开发编写业务逻辑，表单提供多种解决方案： 表单设计器、online配置表单、编码表单。同时实现了流程与表单的分离设计（松耦合）、并支持任务节点灵活配置，既保证了公司流程的保密性，又减少了开发人员的工作量。
-
-
-
-#### JeecgBoot商业版与同类产品区别
-----------------------------------
-
- 灵活性：jeecgboot基于开源技术栈，设计初考虑到可插拔性和集成灵活性，确保平台的智能性与灵活性，避免因平台过于庞大而导致的扩展困难。
- 流程管理：支持一个表单挂接多个流程，同时一个流程可以连接多个表单，增强了流程的灵活性和复杂性管理。
- 符合中国国情的流程：针对中国市场的特定需求，jeecgboot能够实现各种符合中国国情的业务流程。
- 强大的表单设计器：jeecgboot的表单设计器与敲敲云共享，具备高质量和智能化的特点，能够满足零代码应用的需求，业内同类产品中不多见。
- 报表功能：自主研发的报表工具，拥有独立知识产权，功能上比业内老牌产品如帆软更智能，操作简便。
- BI产品整合：提供大屏、仪表盘、门户等功能，完美解决这些需求，并支持移动面板的设计与渲染。
- 自主研发的模块：jeecgboot的所有模块均为自主研发，具有独立的知识产权。
- 颗粒度和功能细致：在功能细致度和颗粒度上，jeecgboot远超同类产品，尤其在零代码能力方面表现突出。
- 零代码应用管理：最新版支持与敲敲云的零代码应用管理能力的集成，使得jeecgboot既具备低代码，又具备零代码的应用能力，业内独一无二。
- 强大的代码生成器：作为开源代码生成器的先锋，jeecgboot在代码生成的智能化和在线低代码与代码生成的结合方面，优势明显。
- 精细化权限管理：提供行级和列级的数据权限控制，满足企业在ERP和OA领域对权限管理的严格需求。
- 多平台支持的APP：目前采用uniapp3实现，支持小程序、H5、App及鸿蒙、鸿蒙Next、Electron桌面应用等多种终端。
-
-> 综上所述，jeecgboot不仅在功能上具备丰富性和灵活性，还在技术架构、权限管理和用户体验等方面展现出明显的优势，是一个综合性能强大的低代码平台。
-
-
-
-商业版演示
-----------------------------------
-
-JeecgBoot vs 敲敲云
-> - JeecgBoot是低代码产品拥有系列低代码能力，比如流程设计、表单设计、大屏设计，代码生成器，适合半开发模式（开发+低代码结合），也可以集成零代码应用管理模块.
-> - 敲敲云是零代码产品，完全不写代码，通过配置搭建业务系统，其在jeecgboot基础上研发而成，删除了online、代码生成、OA等需要编码功能，只保留应用管理功能和聊天、日程、文件三个OA组件.
-
-
- JeecgBoot低代码：  https://boot3.jeecg.com
- 敲敲云零代码：https://app.qiaoqiaoyun.com
- APP演示(多端): http://jeecg.com/appIndex
-
-
-### 流程视频介绍
-
-[![](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/flow_video.png)](https://www.bilibili.com/video/BV1Nk4y1o7Qc)
-
-
-
-### 商业版功能简述
-
-> 详细的功能介绍，[请联系官方](https://jeecg.com/vip)
-
-```
-│─更多商业功能
-│  ├─流程设计器
-│  ├─简流设计器(类钉钉版)
-│  ├─门户设计（NEW）
-│  ├─表单设计器
-│  ├─大屏设计器
-│  └─我的任务
-│  └─历史流程
-│  └─历史流程
-│  └─流程实例管理
-│  └─流程监听管理
-│  └─流程表达式
-│  └─我发起的流程
-│  └─我的抄送
-│  └─流程委派、抄送、跳转
-│  └─OA办公组件
-│  └─零代码应用管理（无需编码，在线搭建应用系统）
-│  ├─积木报表企业版（含jimureport、jimubi）
-│  ├─AI流程设计器源码
-│  ├─Online全模块功能和源码
-│  ├─AI写文章（CMS）
-│  ├─AI表单字段建议（表单设计器）
-│  ├─OA办公协同组件
-│  ├─在线聊天功能
-│  ├─设计表单移动适配
-│  ├─设计表单支持外部填报
-│  ├─设计表单AI字段建议
-│  ├─设计表单视图功能(支持多种类型含日历、表格、看板、甘特图)
-│  └─。。。
-   
-```
-
-
-
-
-##### 流程设计
-![](https://oscimg.oschina.net/oscnet/up-981ce174e4fbb48c8a2ce4ccfd7372e2994.png)
-
-![](https://oscimg.oschina.net/oscnet/up-1dc0d052149ec675f3e4fad632b82b48add.png)
-
-![](https://oscimg.oschina.net/oscnet/up-de31bc2f9d9b8332c554b0954cc73d79593.png)
-
-![输入图片说明](https://static.oschina.net/uploads/img/201907/05165142_yyQ7.png "在这里输入图片标题")
-
-![输入图片说明](https://static.oschina.net/uploads/img/201904/14160917_9Ftz.png "在这里输入图片标题")
-
-![输入图片说明](https://static.oschina.net/uploads/img/201904/14160633_u59G.png "在这里输入图片标题")
-
-
-
-##### 表单设计器
-![](https://oscimg.oschina.net/oscnet/up-5f8cb657615714b02190b355e59f60c5937.png)
-
-![](https://oscimg.oschina.net/oscnet/up-d9659b2f324e33218476ec98c9b400e6508.png)
-
-![](https://oscimg.oschina.net/oscnet/up-4868615395272d3206dbb960ade02dbc291.png)
--- a/README.md
+++ b/README.md
@@ -2,13 +2,13 @@
 JeecgBoot AI低代码平台
 ===============

-当前最新版本： 3.8.3（发布日期：2025-10-09） 
+当前最新版本： 3.9.0（发布日期：2025-12-01） 


 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/jeecgboot/JeecgBoot/blob/master/LICENSE)
 [![](https://img.shields.io/badge/Author-北京国炬软件-orange.svg)](https://jeecg.com)
 [![](https://img.shields.io/badge/blog-技术博客-orange.svg)](https://jeecg.blog.csdn.net)
-[![](https://img.shields.io/badge/version-3.8.3-brightgreen.svg)](https://github.com/jeecgboot/JeecgBoot)
+[![](https://img.shields.io/badge/version-3.9.0-brightgreen.svg)](https://github.com/jeecgboot/JeecgBoot)
 [![GitHub stars](https://img.shields.io/github/stars/zhangdaiscott/jeecg-boot.svg?style=social&label=Stars)](https://github.com/jeecgboot/JeecgBoot)
 [![GitHub forks](https://img.shields.io/github/forks/zhangdaiscott/jeecg-boot.svg?style=social&label=Fork)](https://github.com/jeecgboot/JeecgBoot)

@@ -19,14 +19,17 @@ JeecgBoot AI低代码平台

 <h3 align="center">企业级AI低代码平台</h3>

-JeecgBoot 是一款基于BPM流程和代码生成的AI低代码平台，助力企业快速实现低代码开发和构建AI应用。
+JeecgBoot 是一款融合代码生成与AI应用的低代码开发平台，助力企业快速实现低代码开发和构建AI应用。平台支持MCP和插件扩展，提供聊天式业务操作(如“一句话创建用户”)，大幅提升开发效率与用户便捷性。
+
 采用前后端分离架构（Ant Design&Vue3，SpringBoot3，SpringCloud Alibaba，Mybatis-plus），强大代码生成器实现前后端一键生成，无需手写代码。 
 平台引领AI低代码开发模式：AI生成→在线编码→代码生成→手工合并，解决Java项目80%重复工作，提升效率，节省成本，兼顾灵活性。 
 具备强大且颗粒化的权限控制，支持按钮权限和数据权限设置，满足大型业务系统需求。功能涵盖在线表单、表单设计、流程设计、门户设计、报表与大屏设计、OA办公、AI应用、AI知识库、大模型管理、AI流程编排、AI聊天，支持ChatGPT、DeepSeek、Ollama等多种AI大模型。

-`AI赋能报表:` 积木报表是一款自主研发的强大开源企业级Web报表与大屏工具。它通过零编码的拖拽式操作，赋能用户如同搭积木般轻松构建各类复杂报表和数据大屏，全面满足企业数据可视化与分析需求，助力企业级数据产品的高效打造与应用。
+`傻瓜式报表:` JimuReport是一款自主研发的强大开源企业级Web报表工具。它通过零编码的拖拽式操作，赋能用户如同搭积木般轻松构建各类复杂报表，全面满足企业数据可视化与分析需求，助力企业级数据产品的高效打造与应用。

-`AI赋能低代码:` 提供完善成熟的AI应用平台，涵盖AI应用管理、AI模型管理、智能对话助手、知识库问答、流程编排与设计器、AI建表等多项功能。平台兼容多种主流大模型，包括ChatGPT、DeepSeek、Ollama、智普、千问等，助力企业高效构建智能化应用，推动低代码开发与AI深度融合。
+`傻瓜式大屏:` JimuBI一款自主研发的强大的大屏和仪表盘设计工具。专注数字孪生与数据可视化，支持交互式大屏、仪表盘、门户和移动端，实现“一次开发，多端适配”。 大屏设计类Word风格，支持多屏切换，自由拖拽，轻松打造炫酷动态界面。
+
+`成熟AI应用功能:` 提供一套完善AI应用平台: 涵盖AI应用管理、AI模型管理、智能对话助手、知识库问答、流程编排与设计器、AI建表、MCP插件配置等功能。平台兼容主流大模型，包括ChatGPT、DeepSeek、Ollama、智普、千问等，助力企业高效构建智能化应用，推动低代码开发与AI深度融合。

 `JEECG宗旨是:` JEECG旨在通过OnlineCoding平台实现简单功能的零代码快速搭建，同时针对复杂功能采用代码生成器生成代码并手工合并，打造智能且灵活的低代码开发模式，有效解决了当前低代码产品普遍缺乏灵活性的问题，提升开发效率的同时兼顾系统的扩展性和定制化能力。

@@ -50,15 +53,16 @@ JeecgBoot低代码平台兼容所有J2EE项目开发，支持信创国产化，
 版本说明
 -----------------------------------

-|下载 | SpringBoot3.5 + Shiro  |SpringBoot3.5+ SpringAuthorizationServer | SpringBoot3.5 + Sa-Token | SpringBoot2.7(JDK17/JDK8) |
-|------|----------------|----------------------------|-------------------|--------------------------------------------|
-| Github |  [`springboot3`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3) | [`springboot3_sas`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3_sas) 分支  |  [`springboot3-satoken`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3-satoken) 分支|[`master`](https://github.com/jeecgboot/JeecgBoot) 分支|
-| Gitee |  [`springboot3`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3/)      | [`springboot3_sas`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3_sas) 分支|  [`springboot3-satoken`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3-satoken) 分支|[`master`](https://gitee.com/jeecg/JeecgBoot)     分支 |
+|下载 | SpringBoot3.5 + Shiro                                   |SpringBoot3.5+ SpringAuthorizationServer | SpringBoot3.5 + Sa-Token | SpringBoot2.7(JDK17/JDK8) |
+|------|---------------------------------------------------------|----------------------------|-------------------|--------------------------------------------|
+| Github | [`main`](https://github.com/jeecgboot/JeecgBoot)        | [`springboot3_sas`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3_sas) 分支  |  [`springboot3-satoken`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3-satoken) 分支|[`springboot2`](https://github.com/jeecgboot/JeecgBoot/tree/springboot2) 分支|
+| Gitee | [`main`](https://github.com/jeecgboot/JeecgBoot) | [`springboot3_sas`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3_sas) 分支|  [`springboot3-satoken`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3-satoken) 分支|[`springboot2`](https://github.com/jeecgboot/JeecgBoot/tree/springboot2)     分支 |


- `jeecg-boot` 是后端JAVA源码项目Springboot3+SpringCloudAlibaba（支持单体和微服务切换）.
+- `jeecg-boot` 是后端JAVA源码项目Springboot3+Shiro+Mybatis+SpringCloudAlibaba（支持单体和微服务切换）.
 - `jeecgboot-vue3` 是前端VUE3源码项目（vue3+vite6+ts最新技术栈）.
 - `JeecgUniapp`  是[配套APP框架](https://github.com/jeecgboot/JeecgUniapp) 适配多个终端，支持APP、小程序、H5、鸿蒙、鸿蒙Next.
+- `jeecg-boot-starter`  是[jeecg-boot对应的底层封装starter](https://github.com/jeecgboot/jeecg-boot-starter) ：微服务启动、xxljob、分布式锁starter、rabbitmq、分布式事务、分库分表shardingsphere等.
 - 参考 [文档](https://help.jeecg.com/ui/2dev/mini) 可以删除不需要的demo，制作一个精简版本


@@ -228,20 +232,6 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类



-
-
-开源版与企业版区别?
-----------------------------------
-
- - JeecgBoot开源版采用 [Apache-2.0 license](LICENSE) 协议附加补充条款：允许商用使用，不会造成侵权行为，允许基于本平台软件开展业务系统开发（但在任何情况下，您不得使用本软件开发可能被认为与本软件竞争的软件).
- - 商业版与开源版主要区别在于商业版提供了技术支持 和 更多的企业级功能(例如：Online图表、流程监控、流程设计、流程审批、表单设计器、表单视图、积木报表企业版、OA办公、商业APP、零代码应用、Online模块源码等功能). [更多商业功能介绍，点击查看](README-Enterprise.md)
- - JeecgBoot未来发展方向是：零代码平台的建设，也就是团队的另外一款产品 [敲敲云零代码](https://www.qiaoqiaoyun.com) ，无需编码即可通过拖拽快速搭建企业级应用，与JeecgBoot低代码平台形成互补，满足从简单业务到复杂系统的全场景开发需求，目前已经开源，[欢迎下载](https://qiaoqiaoyun.com/downloadCode)
-
-
-
-
-
-
 ### Jeecg Boot 产品功能蓝图
 ![功能蓝图](https://jeecgos.oss-cn-beijing.aliyuncs.com/upload/test/Jeecg-Boot-lantu202005_1590912449914.jpg "在这里输入图片标题")

--- a/jeecg-boot/README.md
+++ b/jeecg-boot/README.md
@@ -2,12 +2,12 @@
 JeecgBoot 低代码开发平台
 ===============

-当前最新版本： 3.8.3（发布日期：2025-10-09） 
+当前最新版本： 3.9.0（发布日期：2025-12-01） 


 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/zhangdaiscott/jeecg-boot/blob/master/LICENSE)
 [![](https://img.shields.io/badge/Author-北京国炬软件-orange.svg)](http://jeecg.com/aboutusIndex)
-[![](https://img.shields.io/badge/version-3.8.3-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/version-3.9.0-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
 [![GitHub stars](https://img.shields.io/github/stars/zhangdaiscott/jeecg-boot.svg?style=social&label=Stars)](https://github.com/zhangdaiscott/jeecg-boot)
 [![GitHub forks](https://img.shields.io/github/forks/zhangdaiscott/jeecg-boot.svg?style=social&label=Fork)](https://github.com/zhangdaiscott/jeecg-boot)

--- a/jeecg-boot/db/jeecgboot-mysql-5.7.sql
+++ b/jeecg-boot/db/jeecgboot-mysql-5.7.sql
--- a/jeecg-boot/db/其他数据库脚本/jeecgboot-oracle11g.dmp
+++ b/jeecg-boot/db/其他数据库脚本/jeecgboot-oracle11g.dmp
--- a/jeecg-boot/db/其他数据库脚本/jeecgboot-oracle11g.sql
+++ b/jeecg-boot/db/其他数据库脚本/jeecgboot-oracle11g.sql
--- a/jeecg-boot/db/其他数据库脚本/jeecgboot-postgresql17.sql
+++ b/jeecg-boot/db/其他数据库脚本/jeecgboot-postgresql17.sql
--- a/jeecg-boot/db/其他数据库脚本/jeecgboot-sqlserver2017.sql
+++ b/jeecg-boot/db/其他数据库脚本/jeecgboot-sqlserver2017.sql
--- a/jeecg-boot/docker-compose.yml
+++ b/jeecg-boot/docker-compose.yml
@@ -63,6 +63,7 @@ services:
    build:
      context: ./jeecg-module-system/jeecg-system-start
    restart: on-failure
+    mac_address: 02:42:ac:11:00:02
    depends_on:
      - jeecg-boot-mysql
      - jeecg-boot-redis
--- a/jeecg-boot/jeecg-boot-base-core/pom.xml
+++ b/jeecg-boot/jeecg-boot-base-core/pom.xml
@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.jeecgframework.boot3</groupId>
 		<artifactId>jeecg-boot-parent</artifactId>
-		<version>3.8.3</version>
+		<version>3.9.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jeecg-boot-base-core</artifactId>
@@ -44,6 +44,12 @@
 		<dependency>
 			<groupId>org.jeecgframework.boot3</groupId>
 			<artifactId>jeecg-boot-common</artifactId>
+			<exclusions>
+				<exclusion>
+					<groupId>commons-logging</groupId>
+					<artifactId>commons-logging</artifactId>
+				</exclusion>
+			</exclusions>
 		</dependency>
 		<!--集成springmvc框架并实现自动配置 -->
 		<dependency>
@@ -173,7 +179,6 @@
 			<artifactId>DmDialect-for-hibernate5.0</artifactId>
 			<version>${dm8.version}</version>
 		</dependency>
-
 		<!-- Quartz定时任务 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
@@ -198,14 +203,7 @@
 			<artifactId>sa-token-jwt</artifactId>
 			<version>${sa-token.version}</version>
 		</dependency>
-
-
-		<!--	<dependency>
-			<groupId>com.github.xiaoymin</groupId>
-			<artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
-			<version>${knife4j-spring-boot-starter.version}</version>
-		</dependency>-->
-		<!-- knife4j 升级springboot3.4.5报错 -->
+        
 		<dependency>
 			<groupId>com.github.xiaoymin</groupId>
 			<artifactId>knife4j-openapi3-ui</artifactId>
@@ -237,8 +235,8 @@

 		<!-- AutoPoi Excel工具类-->
 		<dependency>
-			<groupId>org.jeecgframework.boot3</groupId>
-			<artifactId>autopoi-web</artifactId>
+			<groupId>org.jeecgframework</groupId>
+			<artifactId>autopoi-spring-boot-3-starter</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>xerces</groupId>
@@ -256,6 +254,14 @@
 					<artifactId>checker-qual</artifactId>
 					<groupId>org.checkerframework</groupId>
 				</exclusion>
+				<exclusion>
+					<groupId>com.google.errorprone</groupId>
+					<artifactId>error_prone_annotations</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.apache.commons</groupId>
+					<artifactId>commons-compress</artifactId>
+				</exclusion>
 			</exclusions>
 		</dependency>

@@ -313,5 +319,21 @@
 			<groupId>org.jeecgframework.boot3</groupId>
 			<artifactId>jeecg-boot-starter-chatgpt</artifactId>
 		</dependency>
+        <!-- 腾讯云 -->
+        <dependency>
+            <groupId>com.tencentcloudapi</groupId>
+            <artifactId>tencentcloud-sdk-java-sms</artifactId>
+            <version>${tencentcloud-sdk-java-sms.version}</version>
+			<exclusions>
+				<exclusion>
+					<groupId>javax.xml.bind</groupId>
+					<artifactId>jaxb-api</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>com.squareup.okio</groupId>
+					<artifactId>okio</artifactId>
+				</exclusion>
+			</exclusions>
+        </dependency>
 	</dependencies>
 </project>
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/CommonAPI.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/CommonAPI.java
@@ -132,7 +132,6 @@ public interface CommonAPI {
     */
    Map<String, List<DictModel>> translateManyDict(String dictCodes, String keys);

-    //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
    /**
     * 15 字典表的 翻译，可批量
     * @param table
@@ -143,7 +142,6 @@ public interface CommonAPI {
     * @return
     */
    List<DictModel> translateDictFromTableByKeys(String table, String text, String code, String keys, String dataSource);
-    //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------

    /**
     * 16 运行AIRag流程
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/ApprovalCommentDTO.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/ApprovalCommentDTO.java
@@ -0,0 +1,48 @@
+package org.jeecg.common.api.dto;
+
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * 流程审批意见DTO
+ * @author scott
+ * @date 2025-01-29
+ */
+@Data
+public class ApprovalCommentDTO implements Serializable {
+    
+    private static final long serialVersionUID = 1L;
+    
+    /**
+     * 任务ID
+     */
+    private String taskId;
+    
+    /**
+     * 任务名称
+     */
+    private String taskName;
+    
+    /**
+     * 审批人ID
+     */
+    private String approverId;
+    
+    /**
+     * 审批人姓名
+     */
+    private String approverName;
+    
+    /**
+     * 审批意见
+     */
+    private String approvalComment;
+    
+    /**
+     * 审批时间
+     */
+    private Date approvalTime;
+}
+
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/OnlineAuthDTO.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/OnlineAuthDTO.java
@@ -30,12 +30,10 @@ public class OnlineAuthDTO implements Serializable {
     */
    private String onlineFormUrl;

-    //update-begin---author:chenrui ---date:20240123  for：[QQYUN-7992]【online】工单申请下的online表单，未配置online表单开发菜单，操作报错无权限------------
    /**
     * online工单的地址
     */
    private String onlineWorkOrderUrl;
-    //update-end---author:chenrui ---date:20240123  for：[QQYUN-7992]【online】工单申请下的online表单，未配置online表单开发菜单，操作报错无权限------------

    public OnlineAuthDTO(){

--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/PushMessageDTO.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/PushMessageDTO.java
@@ -0,0 +1,55 @@
+package org.jeecg.common.api.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 移动端消息推送
+ * @author liusq
+ * @date 2025/11/12 14:11
+ */
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class PushMessageDTO implements Serializable {
+
+
+    private static final long serialVersionUID = 7431775881170684867L;
+
+    /**
+     * 消息标题
+     */
+    private String title;
+
+    /**
+     * 消息内容
+     */
+    private String content;
+
+    /**
+     * 推送形式：all：全推送 single：单用户推送
+     */
+    private String pushType;
+
+    /**
+     * 用户名usernameList
+     */
+    List<String> usernames;
+
+    /**
+     * 用户名idList
+     */
+    List<String> userIds;
+
+    /**
+     * 消息附加参数
+     */
+    Map<String,Object> payload;
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/AutoLogAspect.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/AutoLogAspect.java
@@ -121,9 +121,8 @@ public class AutoLogAspect {
        if (operateType > 0) {
            return operateType;
        }
-        //update-begin---author:wangshuai ---date:20220331  for：阿里云代码扫描规范(不允许任何魔法值出现在代码中)------------
+        // 代码逻辑说明: 阿里云代码扫描规范(不允许任何魔法值出现在代码中)------------
        return OperateTypeEnum.getTypeByMethodName(methodName);
-        //update-end---author:wangshuai ---date:20220331  for：阿里云代码扫描规范(不允许任何魔法值出现在代码中)------------
    }

    /**
@@ -143,14 +142,15 @@ public class AutoLogAspect {
            //  https://my.oschina.net/mengzhang6/blog/2395893
            Object[] arguments  = new Object[paramsArray.length];
            for (int i = 0; i < paramsArray.length; i++) {
-                if (paramsArray[i] instanceof BindingResult || paramsArray[i] instanceof ServletRequest || paramsArray[i] instanceof ServletResponse || paramsArray[i] instanceof MultipartFile) {
+                if (paramsArray[i] instanceof BindingResult || paramsArray[i] instanceof ServletRequest || paramsArray[i] instanceof ServletResponse || paramsArray[i] instanceof MultipartFile || paramsArray[i] instanceof MultipartFile[]) {
                    //ServletRequest不能序列化，从入参里排除，否则报异常：java.lang.IllegalStateException: It is illegal to call this method if the current request is not in asynchronous mode (i.e. isAsyncStarted() returns false)
                    //ServletResponse不能序列化 从入参里排除，否则报异常：java.lang.IllegalStateException: getOutputStream() has already been called for this response
+                    //MultipartFile和MultipartFile[]不能序列化，从入参里排除
                    continue;
                }
                arguments[i] = paramsArray[i];
            }
-            //update-begin-author:taoyan date:20200724 for:日志数据太长的直接过滤掉
+            // 代码逻辑说明: 日志数据太长的直接过滤掉
            PropertyFilter profilter = new PropertyFilter() {
                @Override
                public boolean apply(Object o, String name, Object value) {
@@ -165,14 +165,13 @@ public class AutoLogAspect {
                }
            };
            params = JSONObject.toJSONString(arguments, profilter);
-            //update-end-author:taoyan date:20200724 for:日志数据太长的直接过滤掉
        } else {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            // 请求的方法参数值
            Object[] args = joinPoint.getArgs();
            // 请求的方法参数名称
-            StandardReflectionParameterNameDiscoverer u=new StandardReflectionParameterNameDiscoverer();
+            StandardReflectionParameterNameDiscoverer u= new StandardReflectionParameterNameDiscoverer();
            String[] paramNames = u.getParameterNames(method);
            if (args != null && paramNames != null) {
                for (int i = 0; i < args.length; i++) {
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/DictAspect.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/DictAspect.java
@@ -105,29 +105,24 @@ public class DictAspect {
                Map<String, List<String>> dataListMap = new HashMap<>(5);
                //取出结果集
                List<Object> records=((IPage) ((Result) result).getResult()).getRecords();
-                //update-begin--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
+                // 代码逻辑说明: 【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
                Boolean hasDict= checkHasDict(records);
                if(!hasDict){
                    return result;
                }

                log.debug(" __ 进入字典翻译切面 DictAspect —— " );
-                //update-end--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
                for (Object record : records) {
                    String json="{}";
                    try {
-                        //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
                        //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                         json = objectMapper.writeValueAsString(record);
-                        //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
                    } catch (JsonProcessingException e) {
                        log.error("json解析失败"+e.getMessage(),e);
                    }
-                    //update-begin--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
+                    // 代码逻辑说明: 【issues/3303】restcontroller返回json数据后key顺序错乱 -----
                    JSONObject item = JSONObject.parseObject(json, Feature.OrderedField);
-                    //update-end--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----

-                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                    //for (Field field : record.getClass().getDeclaredFields()) {
                    // 遍历所有字段，把字典Code取出来，放到 map 里
                    for (Field field : oConvertUtils.getAllFields(record)) {
@@ -135,7 +130,6 @@ public class DictAspect {
                        if (oConvertUtils.isEmpty(value)) {
                            continue;
                        }
-                    //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                        if (field.getAnnotation(Dict.class) != null) {
                            if (!dictFieldList.contains(field)) {
                                dictFieldList.add(field);
@@ -143,26 +137,22 @@ public class DictAspect {
                            String code = field.getAnnotation(Dict.class).dicCode();
                            String text = field.getAnnotation(Dict.class).dicText();
                            String table = field.getAnnotation(Dict.class).dictTable();
-                            //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
+                            // 代码逻辑说明: [issues/#5643]解决分布式下表字典跨库无法查询问题------------
                            String dataSource = field.getAnnotation(Dict.class).ds();
-                            //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                            List<String> dataList;
                            String dictCode = code;
                            if (!StringUtils.isEmpty(table)) {
-                                //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
+                                // 代码逻辑说明: [issues/#5643]解决分布式下表字典跨库无法查询问题------------
                                dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
-                                //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                            }
                            dataList = dataListMap.computeIfAbsent(dictCode, k -> new ArrayList<>());
                            this.listAddAllDeduplicate(dataList, Arrays.asList(value.split(",")));
                        }
                        //date类型默认转换string格式化日期
-                        //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
                        //if (JAVA_UTIL_DATE.equals(field.getType().getName())&&field.getAnnotation(JsonFormat.class)==null&&item.get(field.getName())!=null){
                            //SimpleDateFormat aDate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            // item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
                        //}
-                        //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
                    }
                    items.add(item);
                }
@@ -176,15 +166,12 @@ public class DictAspect {
                        String code = field.getAnnotation(Dict.class).dicCode();
                        String text = field.getAnnotation(Dict.class).dicText();
                        String table = field.getAnnotation(Dict.class).dictTable();
-                        //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                        // 自定义的字典表数据源
                        String dataSource = field.getAnnotation(Dict.class).ds();
-                        //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                        String fieldDictCode = code;
                        if (!StringUtils.isEmpty(table)) {
-                            //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
+                            // 代码逻辑说明: [issues/#5643]解决分布式下表字典跨库无法查询问题------------
                            fieldDictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
-                            //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                        }

                        String value = record.getString(field.getName());
@@ -286,25 +273,20 @@ public class DictAspect {
                String[] arr = dictCode.split(",");
                String table = arr[0], text = arr[1], code = arr[2];
                String values = String.join(",", needTranslDataTable);
-                //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                // 自定义的数据源
                String dataSource = null;
                if (arr.length > 3) {
                    dataSource = arr[3];
                }
-                //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                log.debug("translateDictFromTableByKeys.dictCode:" + dictCode);
                log.debug("translateDictFromTableByKeys.values:" + values);
-                //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                
-                //update-begin---author:wangshuai---date:2024-01-09---for:微服务下为空报错没有参数需要传递空字符串---
+                // 代码逻辑说明: 微服务下为空报错没有参数需要传递空字符串---
                if(null == dataSource){
                    dataSource = "";
                }
-                //update-end---author:wangshuai---date:2024-01-09---for:微服务下为空报错没有参数需要传递空字符串---
                
                List<DictModel> texts = commonApi.translateDictFromTableByKeys(table, text, code, values, dataSource);
-                //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
                log.debug("translateDictFromTableByKeys.result:" + texts);
                List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
                list.addAll(texts);
@@ -313,10 +295,8 @@ public class DictAspect {
                for (DictModel dict : texts) {
                    String redisKey = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, dict.getValue());
                    try {
-                        // update-begin-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
                        // 保留5分钟
                        redisTemplate.opsForValue().set(redisKey, dict.getText(), 300, TimeUnit.SECONDS);
-                        // update-end-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
                    } catch (Exception e) {
                        log.warn(e.getMessage(), e);
                    }
@@ -400,7 +380,7 @@ public class DictAspect {
            if (k.trim().length() == 0) {
                continue; //跳过循环
            }
-            //update-begin--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
+            // 代码逻辑说明: !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
            if (!StringUtils.isEmpty(table)){
                log.debug("--DictAspect------dicTable="+ table+" ,dicText= "+text+" ,dicCode="+code);
                String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s,%s,%s]",table,text,code,k.trim());
@@ -425,7 +405,6 @@ public class DictAspect {
                    tmpValue = commonApi.translateDict(code, k.trim());
                }
            }
-            //update-end--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----

            if (tmpValue != null) {
                if (!"".equals(textValue.toString())) {
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/PermissionDataAspect.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/PermissionDataAspect.java
@@ -57,7 +57,6 @@ public class PermissionDataAspect {
        String requestMethod = request.getMethod();
        String requestPath = request.getRequestURI().substring(request.getContextPath().length());
        requestPath = filterUrl(requestPath);
-        //update-begin-author:taoyan date:20211027 for:JTC-132【online报表权限】online报表带参数的菜单配置数据权限无效
        //先判断是否online报表请求
        if(requestPath.indexOf(UrlMatchEnum.CGREPORT_DATA.getMatchUrl())>=0 || requestPath.indexOf(UrlMatchEnum.CGREPORT_ONLY_DATA.getMatchUrl())>=0){
            // 获取地址栏参数
@@ -66,7 +65,6 @@ public class PermissionDataAspect {
                requestPath+="?"+urlParamString;
            }
        }
-        //update-end-author:taoyan date:20211027 for:JTC-132【online报表权限】online报表带参数的菜单配置数据权限无效
        log.debug("拦截请求 >> {} ; 请求类型 >> {} . ", requestPath, requestMethod);
        String username = JwtUtil.getUserNameByToken(request);
        //查询数据权限信息
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/annotation/Dict.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/annotation/Dict.java
@@ -41,7 +41,6 @@ public @interface Dict {
    String dictTable() default "";


-    //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
    /**
     * 方法描述: 数据字典表所在数据源名称
     * 作    者： chenrui
@@ -50,5 +49,4 @@ public @interface Dict {
     * @return 返回类型： String
     */
    String ds() default "";
-    //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
 }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java
@@ -301,6 +301,10 @@ public interface CommonConstant {
     */
    String SYS_ROLE_ADMIN = "admin";

+    /**
+     * 考勤补卡业务状态 （0：处理中）
+     */
+    String SIGN_PATCH_BIZ_STATUS_0 = "0";
    /**
     * 考勤补卡业务状态 （1：同意  2：不同意）
     */
@@ -584,7 +588,6 @@ public interface CommonConstant {
    String ORDER_TYPE_DESC = "DESC";


-   //update-begin---author:scott ---date:2023-09-10  for：积木报表常量----
   /**
    * 报表允许设计开发的角色
    */
@@ -599,9 +602,7 @@ public interface CommonConstant {
    * 数据隔离模式： 按照租户隔离
    */
   public static final String SAAS_MODE_TENANT = "tenant";
-   //update-end---author:scott ---date::2023-09-10  for：积木报表常量----
 
-   //update-begin---author:wangshuai---date:2024-04-07---for:修改手机号常量---
   /**
    * 修改手机号短信验证码redis-key的前缀
    */
@@ -626,7 +627,6 @@ public interface CommonConstant {
    * 修改手机号
    */
   String UPDATE_PHONE = "updatePhone";
-   //update-end---author:wangshuai---date:2024-04-07---for:修改手机号常量---
    
   /**
    * 修改手机号验证码请求次数超出
@@ -702,4 +702,28 @@ public interface CommonConstant {
     * 部门名称redisKey(全路径)
     */
    String DEPART_NAME_REDIS_KEY_PRE = "sys:cache:departPathName:";
+
+    /**
+     * 默认用户排序值
+     */
+    Integer DEFAULT_USER_SORT = 1000;
+
+    /**
+     * 发送短信方式：腾讯
+     */
+    String SMS_SEND_TYPE_TENCENT = "tencent";
+
+    /**
+     * 发送短信方式：阿里云
+     */
+    String SMS_SEND_TYPE_ALI_YUN = "aliyun";
+
+    /**============================== 【是否允许同一账号多地同时登录】登录客户端类型常量 ==============================*/
+    /** 客户端类型：PC端 */
+    String CLIENT_TYPE_PC = "PC";
+    /** 客户端类型：APP端 */
+    String CLIENT_TYPE_APP = "APP";
+    /** 客户端类型：手机号登录 */
+    String CLIENT_TYPE_PHONE = "PHONE";
+    /**============================== 【是否允许同一账号多地同时登录】登录客户端类型常量 ==============================*/
 }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/ProvinceCityArea.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/ProvinceCityArea.java
@@ -39,20 +39,18 @@ public class ProvinceCityArea {
            this.initAreaList();
            if(areaList!=null && areaList.size()>0){
                for(int i=areaList.size()-1;i>=0;i--){
-                    //update-begin-author:taoyan date:2022-5-24 for:VUEN-1088 online 导入 省市区导入后 导入数据错乱 北京市/市辖区/西城区-->山西省/晋城市/城区
+                    // 代码逻辑说明: VUEN-1088 online 导入 省市区导入后 导入数据错乱 北京市/市辖区/西城区-->山西省/晋城市/城区
                    String areaText = areaList.get(i).getText();
                    String cityText = areaList.get(i).getAheadText();
                    if(text.indexOf(areaText)>=0 && (cityText!=null && text.indexOf(cityText)>=0)){
                        return areaList.get(i).getId();
                    }
-                    //update-end-author:taoyan date:2022-5-24 for:VUEN-1088 online 导入 省市区导入后 导入数据错乱 北京市/市辖区/西城区-->山西省/晋城市/城区
                }
            }
        }
        return null;
    }

-    // update-begin-author:sunjianlei date:20220121 for:【JTC-704】数据导入错误 省市区组件，文件中为北京市，导入后，导为了山西省
    /**
     * 获取省市区code，精准匹配
     * @param texts 文本数组，省，市，区
@@ -117,7 +115,6 @@ public class ProvinceCityArea {
        }
        return null;
    }
-    // update-end-author:sunjianlei date:20220121 for:【JTC-704】数据导入错误 省市区组件，文件中为北京市，导入后，导为了山西省

    public void getAreaByCode(String code,List<String> ls){
        for(Area area: areaList){
@@ -154,9 +151,8 @@ public class ProvinceCityArea {
                            for(String areaKey:areaJson.keySet()){
                                //System.out.println("········"+areaKey);
                                Area area = new Area(areaKey,areaJson.getString(areaKey),cityKey);
-                                //update-begin-author:taoyan date:2022-5-24 for:VUEN-1088 online 导入 省市区导入后 导入数据错乱 北京市/市辖区/西城区-->山西省/晋城市/城区
+                                // 代码逻辑说明: VUEN-1088 online 导入 省市区导入后 导入数据错乱 北京市/市辖区/西城区-->山西省/晋城市/城区
                                area.setAheadText(cityJson.getString(cityKey));
-                                //update-end-author:taoyan date:2022-5-24 for:VUEN-1088 online 导入 省市区导入后 导入数据错乱 北京市/市辖区/西城区-->山西省/晋城市/城区
                                this.areaList.add(area);
                            }
                        }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/NoticeTypeEnum.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/NoticeTypeEnum.java
@@ -23,7 +23,11 @@ public enum NoticeTypeEnum {
    /**
     * 督办
     */
-    NOTICE_TYPE_SUPERVISE("督办管理", "supe");
+    NOTICE_TYPE_SUPERVISE("督办管理", "supe"),
+    /**
+     * 考勤
+     */
+    NOTICE_TYPE_ATTENDANCE("考勤消息", "attendance");

    /**
     * 文件类型名称
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/UniPushTypeEnum.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/UniPushTypeEnum.java
@@ -0,0 +1,82 @@
+package org.jeecg.common.constant.enums;
+
+import org.jeecg.common.util.oConvertUtils;
+
+/**
+ * UniPush 消息推送枚举
+ * @author: jeecg-boot
+ */
+public enum UniPushTypeEnum {
+    /**
+     * 聊天
+     */
+    CHAT("chat", "聊天消息", "收到%s发来的聊天消息"),
+    /**
+     * 流程跳转到我的任务
+     */
+    BPM("bpm_task", "待办任务", "收到%s待办任务"),
+
+    /**
+     * 流程抄送任务
+     */
+    BPM_VIEW("bpm_cc", "知会任务", "收到%s知会任务"),
+    /**
+     * 系统消息
+     */
+    SYS_MSG("system", "系统消息", "收到一条系统通告");
+
+    /**
+     * 业务类型(chat:聊天 bpm_task:流程 bpm_cc:流程抄送)
+     */
+    private String type;
+    /**
+     * 消息标题
+     */
+    private String title;
+    /**
+     * 消息内容
+     */
+    private String content;
+
+    UniPushTypeEnum(String type, String title, String content) {
+        this.type = type;
+        this.title = title;
+        this.content = content;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getTitle() {
+        return title ;
+    }
+
+    public void setTitle(String openType) {
+        this.title = openType;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public static UniPushTypeEnum getByType(String type) {
+        if (oConvertUtils.isEmpty(type)) {
+            return null;
+        }
+        for (UniPushTypeEnum val : values()) {
+            if (val.getType().equals(type)) {
+                return val;
+            }
+        }
+        return null;
+    }
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/desensitization/aspect/SensitiveDataAspect.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/desensitization/aspect/SensitiveDataAspect.java
@@ -73,7 +73,7 @@ public class SensitiveDataAspect {
            SensitiveInfoUtil.handleNestedObject(result, entity, isEncode);
        }
        long endTime=System.currentTimeMillis();
-        log.info((isEncode ? "加密操作，" : "解密操作，") + "Aspect程序耗时：" + (endTime - startTime) + "ms");
+        log.debug((isEncode ? "加密操作，" : "解密操作，") + "Aspect程序耗时：" + (endTime - startTime) + "ms");

        return result;
    }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/es/JeecgElasticsearchTemplate.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/es/JeecgElasticsearchTemplate.java
@@ -387,7 +387,7 @@ public class JeecgElasticsearchTemplate {
            data.remove("id");
            bodySb.append(data.toJSONString()).append("\n");
        }
-        System.out.println("+-+-+-: bodySb.toString(): " + bodySb.toString());
+        //System.out.println("+-+-+-: bodySb.toString(): " + bodySb.toString());
        HttpHeaders headers = RestUtil.getHeaderApplicationJson();
        RestUtil.request(url, HttpMethod.PUT, headers, null, bodySb, JSONObject.class);
        return true;
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/exception/JeecgBootExceptionHandler.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/exception/JeecgBootExceptionHandler.java
@@ -144,13 +144,12 @@ public class JeecgBootExceptionHandler {
 	@ExceptionHandler(Exception.class)
 	public Result<?> handleException(Exception e){
 		log.error(e.getMessage(), e);
-		//update-begin---author:zyf ---date:20220411  for：处理Sentinel限流自定义异常
+		// 代码逻辑说明: 处理Sentinel限流自定义异常
 		Throwable throwable = e.getCause();
 		SentinelErrorInfoEnum errorInfoEnum = SentinelErrorInfoEnum.getErrorByException(throwable);
 		if (ObjectUtil.isNotEmpty(errorInfoEnum)) {
 			return Result.error(errorInfoEnum.getError());
 		}
-		//update-end---author:zyf ---date:20220411  for：处理Sentinel限流自定义异常
 		addSysLog(e);
 		return Result.error("操作失败，"+e.getMessage());
 	}
@@ -247,7 +246,6 @@ public class JeecgBootExceptionHandler {
 		return Result.error("校验失败，存在SQL注入风险！" + msg);
 	}

-	//update-begin---author:chenrui ---date:20240423  for：[QQYUN-8732]把错误的日志都抓取了 方便后续处理，单独弄个日志类型------------
 	/**
 	 * 添加异常新系统日志
 	 * @param e 异常
@@ -266,7 +264,6 @@ public class JeecgBootExceptionHandler {
        } catch (NullPointerException | BeansException ignored) {
        }
        if (null != request) {
-			//update-begin---author:chenrui ---date:20250408  for：[QQYUN-11716]上传大图片失败没有精确提示------------
 			//请求的参数
 			if (!isTooBigException(e)) {
 				// 文件上传过大异常时不能获取参数,否则会报错
@@ -275,7 +272,6 @@ public class JeecgBootExceptionHandler {
 					log.setMethod(oConvertUtils.mapToString(request.getParameterMap()));
 				}
 			}
-			//update-end---author:chenrui ---date:20250408  for：[QQYUN-11716]上传大图片失败没有精确提示------------
            // 请求地址
            log.setRequestUrl(request.getRequestURI());
            //设置IP地址
@@ -299,7 +295,6 @@ public class JeecgBootExceptionHandler {

        baseCommonService.addLog(log);
    }
-	//update-end---author:chenrui ---date:20240423  for：[QQYUN-8732]把错误的日志都抓取了 方便后续处理，单独弄个日志类型------------

 	/**
 	 * 是否文件过大异常
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/base/controller/JeecgController.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/base/controller/JeecgController.java
@@ -68,12 +68,16 @@ public class JeecgController<T, S extends IService<T>> {
        //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.FILE_NAME, title);
        mv.addObject(NormalExcelConstants.CLASS, clazz);
-        //update-begin--Author:liusq  Date:20210126 for：图片导出报错，ImageBasePath未设置--------------------
-        ExportParams exportParams=new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title);
+        // 代码逻辑说明: 【QQYUN-13930】统一改成导出xlsx格式---
+        ExportParams exportParams=new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title, ExcelType.XSSF);
        exportParams.setImageBasePath(jeecgBaseConfig.getPath().getUpload());
-        //update-end--Author:liusq  Date:20210126 for：图片导出报错，ImageBasePath未设置----------------------
        mv.addObject(NormalExcelConstants.PARAMS,exportParams);
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
+        // 代码逻辑说明: 【issues/9052】BasicTable列表页导出excel可以指定列---
+        String exportFields = request.getParameter(NormalExcelConstants.EXPORT_FIELDS);
+        if(oConvertUtils.isNotEmpty(exportFields)){
+            mv.addObject(NormalExcelConstants.EXPORT_FIELDS, exportFields);
+        }
        return mv;
    }
    /**
@@ -94,14 +98,12 @@ public class JeecgController<T, S extends IService<T>> {
        // Step.2 计算分页sheet数据
        double total = service.count();
        int count = (int)Math.ceil(total/pageNum);
-        //update-begin-author:liusq---date:20220629--for: 多sheet导出根据选择导出写法调整 ---
        // Step.3  过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            queryWrapper.in("id",selectionList);
        }
-        //update-end-author:liusq---date:20220629--for: 多sheet导出根据选择导出写法调整 ---
        // Step.4 多sheet处理
        List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
        for (int i = 1; i <=count ; i++) {
@@ -220,16 +222,15 @@ public class JeecgController<T, S extends IService<T>> {
            params.setNeedSave(true);
            try {
                List<T> list = ExcelImportUtil.importExcel(file.getInputStream(), clazz, params);
-                //update-begin-author:taoyan date:20190528 for:批量插入数据
+                // 代码逻辑说明: 批量插入数据
                long start = System.currentTimeMillis();
                service.saveBatch(list);
                //400条 saveBatch消耗时间1592毫秒  循环插入消耗时间1947毫秒
                //1200条  saveBatch消耗时间3687毫秒 循环插入消耗时间5212毫秒
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
-                //update-end-author:taoyan date:20190528 for:批量插入数据
                return Result.ok("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
-                //update-begin-author:taoyan date:20211124 for: 导入数据重复增加提示
+                // 代码逻辑说明: 导入数据重复增加提示
                String msg = e.getMessage();
                log.error(msg, e);
                if(msg!=null && msg.indexOf("Duplicate entry")>=0){
@@ -237,7 +238,6 @@ public class JeecgController<T, S extends IService<T>> {
                }else{
                    return Result.error("文件导入失败:" + e.getMessage());
                }
-                //update-end-author:taoyan date:20211124 for: 导入数据重复增加提示
            } finally {
                try {
                    file.getInputStream().close();
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/base/entity/JeecgEntity.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/base/entity/JeecgEntity.java
@@ -13,7 +13,6 @@ import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
-import io.swagger.v3.oas.annotations.media.Schema;

 /**
 * @Description: Entity基类
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/query/QueryGenerator.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/query/QueryGenerator.java
@@ -97,7 +97,6 @@ public class QueryGenerator {
 		return queryWrapper;
 	}
 	
-	//update-begin---author:chenrui ---date:20240527  for：[TV360X-378]增加自定义字段查询规则功能------------
 	/**
 	 * 获取查询条件构造器QueryWrapper实例 通用查询条件已被封装完成
 	 * @param searchObj 查询实体
@@ -112,7 +111,6 @@ public class QueryGenerator {
 		log.debug("---查询条件构造器初始化完成,耗时:"+(System.currentTimeMillis()-start)+"毫秒----");
 		return queryWrapper;
 	}
-	//update-end---author:chenrui ---date:20240527  for：[TV360X-378]增加自定义字段查询规则功能------------

 	/**
 	 * 组装Mybatis Plus 查询条件
@@ -142,7 +140,6 @@ public class QueryGenerator {
 		}
 		
 		String name, type, column;
-		// update-begin--Author:taoyan  Date:20200923 for：issues/1671 如果字段加注解了@TableField(exist = false),不走DB查询-------
 		//定义实体字段和数据库字段名称的映射 高级查询中 只能获取实体字段 如果设置TableField注解 那么查询条件会出问题
 		Map<String,String> fieldColumnMap = new HashMap<>(5);
 		for (int i = 0; i < origDescriptors.length; i++) {
@@ -188,7 +185,7 @@ public class QueryGenerator {
 						queryWrapper.and(j -> j.like(field,vals[0]));
 					}
 				}else {
-					//update-begin---author:chenrui ---date:20240527  for：[TV360X-378]增加自定义字段查询规则功能------------
+					// 代码逻辑说明: [TV360X-378]增加自定义字段查询规则功能------------
 					QueryRuleEnum rule;
 					if(null != customRuleMap && customRuleMap.containsKey(name)) {
 						// 有自定义规则,使用自定义规则.
@@ -197,7 +194,6 @@ public class QueryGenerator {
 						//根据参数值带什么关键字符串判断走什么类型的查询
 						 rule = convert2Rule(value);
 					}
-					//update-end---author:chenrui ---date:20240527  for：[TV360X-378]增加自定义字段查询规则功能------------
 					value = replaceValue(rule,value);
 					// add -begin 添加判断为字符串时设为全模糊查询
 					//if( (rule==null || QueryRuleEnum.EQ.equals(rule)) && "class java.lang.String".equals(type)) {
@@ -217,7 +213,6 @@ public class QueryGenerator {
 				
 		//高级查询
 		doSuperQuery(queryWrapper, parameterMap, fieldColumnMap);
-		// update-end--Author:taoyan  Date:20200923 for：issues/1671 如果字段加注解了@TableField(exist = false),不走DB查询-------
 		
 	}

@@ -260,16 +255,16 @@ public class QueryGenerator {
 		}
 		
 		if(oConvertUtils.isNotEmpty(column)){
-			log.info("单字段排序规则>> column:" + column + ",排序方式:" + order);
+			log.debug("单字段排序规则>> column:" + column + ",排序方式:" + order);
 		}

 		// 1. 列表多字段排序优先
 		if(parameterMap!=null&& parameterMap.containsKey("sortInfoString")) {
 			// 多字段排序
 			String sortInfoString = parameterMap.get("sortInfoString")[0];
-			log.info("多字段排序规则>> sortInfoString:" + sortInfoString);
+			log.debug("多字段排序规则>> sortInfoString:" + sortInfoString);
 			List<OrderItem> orderItemList = SqlConcatUtil.getQueryConditionOrders(column, order, sortInfoString);
-			log.info(orderItemList.toString());
+			log.debug(orderItemList.toString());
 			if (orderItemList != null && !orderItemList.isEmpty()) {
 				for (OrderItem item : orderItemList) {
 					// 一、获取排序数据库字段
@@ -321,13 +316,11 @@ public class QueryGenerator {
 			return;
 		}
 		
-		//update-begin-author:scott date:2022-11-07 for:避免用户自定义表无默认字段{创建时间}，导致排序报错
 		//TODO 避免用户自定义表无默认字段创建时间，导致排序报错
 		if(DataBaseConstant.CREATE_TIME.equals(column) && !fieldColumnMap.containsKey(DataBaseConstant.CREATE_TIME)){
 			column = "id";
 			log.warn("检测到实体里没有字段createTime，改成采用ID排序！");
 		}
-		//update-end-author:scott date:2022-11-07 for:避免用户自定义表无默认字段{创建时间}，导致排序报错
 		
 		if (oConvertUtils.isNotEmpty(column) && oConvertUtils.isNotEmpty(order)) {
 			//字典字段，去掉字典翻译文本后缀
@@ -335,15 +328,12 @@ public class QueryGenerator {
 				column = column.substring(0, column.lastIndexOf(CommonConstant.DICT_TEXT_SUFFIX));
 			}

-			//update-begin-author:taoyan date:2022-5-16 for: issues/3676 获取系统用户列表时，使用SQL注入生效
 			//判断column是不是当前实体的
 			log.debug("当前字段有："+ allFields);
 			if (!allColumnExist(column, allFields)) {
 				throw new JeecgBootException("请注意，将要排序的列字段不存在：" + column);
 			}
-			//update-end-author:taoyan date:2022-5-16 for: issues/3676 获取系统用户列表时，使用SQL注入生效

-			//update-begin-author:scott date:2022-10-10 for:【jeecg-boot/issues/I5FJU6】doMultiFieldsOrder() 多字段排序方法存在问题
 			//多字段排序方法没有读取 MybatisPlus 注解 @TableField 里 value 的值
 			if (column.contains(",")) {
 				List<String> columnList = Arrays.asList(column.split(","));
@@ -354,12 +344,10 @@ public class QueryGenerator {
 			}else{
 				column = fieldColumnMap.get(column);
 			}
-			//update-end-author:scott date:2022-10-10 for:【jeecg-boot/issues/I5FJU6】doMultiFieldsOrder() 多字段排序方法存在问题

 			//SQL注入check
 			SqlInjectionUtil.filterContentMulti(column);

-			//update-begin--Author:scott  Date:20210531 for：36 多条件排序无效问题修正-------
 			// 排序规则修改
 			// 将现有排序 _ 前端传递排序条件{....,column: 'column1,column2',order: 'desc'} 翻译成sql "column1,column2 desc"
 			// 修改为 _ 前端传递排序条件{....,column: 'column1,column2',order: 'desc'} 翻译成sql "column1 desc,column2 desc"
@@ -368,11 +356,9 @@ public class QueryGenerator {
 			} else {
 				queryWrapper.orderByDesc(SqlInjectionUtil.getSqlInjectSortFields(column.split(",")));
 			}
-			//update-end--Author:scott  Date:20210531 for：36 多条件排序无效问题修正-------
 		}
 	}

-	//update-begin-author:taoyan date:2022-5-23 for: issues/3676 获取系统用户列表时，使用SQL注入生效
 	/**
 	 * 多字段排序 判断所传字段是否存在
 	 * @return
@@ -392,7 +378,6 @@ public class QueryGenerator {
 		}
 		return exist;
 	}
-	//update-end-author:taoyan date:2022-5-23 for: issues/3676 获取系统用户列表时，使用SQL注入生效
 	
 	/**
 	 * 高级查询
@@ -405,14 +390,14 @@ public class QueryGenerator {
 			String superQueryParams = parameterMap.get(SUPER_QUERY_PARAMS)[0];
 			String superQueryMatchType = parameterMap.get(SUPER_QUERY_MATCH_TYPE) != null ? parameterMap.get(SUPER_QUERY_MATCH_TYPE)[0] : MatchTypeEnum.AND.getValue();
            MatchTypeEnum matchType = MatchTypeEnum.getByValue(superQueryMatchType);
-            // update-begin--Author:sunjianlei  Date:20200325 for：高级查询的条件要用括号括起来，防止和用户的其他条件冲突 -------
+            // 代码逻辑说明: 高级查询的条件要用括号括起来，防止和用户的其他条件冲突 -------
            try {
                superQueryParams = URLDecoder.decode(superQueryParams, "UTF-8");
                List<QueryCondition> conditions = JSON.parseArray(superQueryParams, QueryCondition.class);
                if (conditions == null || conditions.size() == 0) {
                    return;
                }
-				// update-begin-author:sunjianlei date:20220119 for: 【JTC-573】 过滤空条件查询，防止 sql 拼接多余的 and
+				// 代码逻辑说明: 【JTC-573】 过滤空条件查询，防止 sql 拼接多余的 and
 				List<QueryCondition> filterConditions = conditions.stream().filter(
 						rule -> (oConvertUtils.isNotEmpty(rule.getField())
 													&& oConvertUtils.isNotEmpty(rule.getRule())
@@ -423,7 +408,6 @@ public class QueryGenerator {
 				if (filterConditions.size() == 0) {
 					return;
 				}
-				// update-end-author:sunjianlei date:20220119 for: 【JTC-573】 过滤空条件查询，防止 sql 拼接多余的 and
                log.debug("---高级查询参数-->" + filterConditions);

                queryWrapper.and(andWrapper -> {
@@ -438,14 +422,14 @@ public class QueryGenerator {

                            log.debug("SuperQuery ==> " + rule.toString());

-                            //update-begin-author:taoyan date:20201228 for: 【高级查询】 oracle 日期等于查询报错
+                            // 代码逻辑说明: 【高级查询】 oracle 日期等于查询报错
 							Object queryValue = rule.getVal();
                            if("date".equals(rule.getType())){
 								queryValue = DateUtils.str2Date(rule.getVal(),DateUtils.date_sdf.get());
 							}else if("datetime".equals(rule.getType())){
 								queryValue = DateUtils.str2Date(rule.getVal(), DateUtils.datetimeFormat.get());
 							}
-							// update-begin--author:sunjianlei date:20210702 for：【/issues/I3VR8E】高级查询没有类型转换，查询参数都是字符串类型 ----
+							// 代码逻辑说明: 【/issues/I3VR8E】高级查询没有类型转换，查询参数都是字符串类型 ----
 							String dbType = rule.getDbType();
 							if (oConvertUtils.isNotEmpty(dbType)) {
 								try {
@@ -478,9 +462,8 @@ public class QueryGenerator {
 									log.error("高级查询值转换失败：", e);
 								}
 							}
-							// update-begin--author:sunjianlei date:20210702 for：【/issues/I3VR8E】高级查询没有类型转换，查询参数都是字符串类型 ----
+							// 代码逻辑说明: 【/issues/I3VR8E】高级查询没有类型转换，查询参数都是字符串类型 ----
                            addEasyQuery(andWrapper, fieldColumnMap.get(rule.getField()), QueryRuleEnum.getByValue(rule.getRule()), queryValue);
-							//update-end-author:taoyan date:20201228 for: 【高级查询】 oracle 日期等于查询报错

                            // 如果拼接方式是OR，就拼接OR
                            if (MatchTypeEnum.OR == matchType && i < (filterConditions.size() - 1)) {
@@ -496,7 +479,6 @@ public class QueryGenerator {
                log.error("--高级查询拼接失败：" + e.getMessage());
                e.printStackTrace();
            }
-            // update-end--Author:sunjianlei  Date:20200325 for：高级查询的条件要用括号括起来，防止和用户的其他条件冲突 -------
 		}
 		//log.info(" superQuery getCustomSqlSegment: "+ queryWrapper.getCustomSqlSegment());
 	}
@@ -508,7 +490,7 @@ public class QueryGenerator {
 	 */
 	public static QueryRuleEnum convert2Rule(Object value) {
 		// 避免空数据
-		// update-begin-author:taoyan date:20210629 for: 查询条件输入空格导致return null后续判断导致抛出null异常
+		// 代码逻辑说明: 查询条件输入空格导致return null后续判断导致抛出null异常
 		if (value == null) {
 			return QueryRuleEnum.EQ;
 		}
@@ -516,10 +498,8 @@ public class QueryGenerator {
 		if (val.length() == 0) {
 			return QueryRuleEnum.EQ;
 		}
-		// update-end-author:taoyan date:20210629 for: 查询条件输入空格导致return null后续判断导致抛出null异常
 		QueryRuleEnum rule =null;

-		//update-begin--Author:scott  Date:20190724 for：initQueryWrapper组装sql查询条件错误 #284-------------------
 		//TODO 此处规则，只适用于 le lt ge gt
 		// step 2 .>= =<
        int length2 = 2;
@@ -535,14 +515,12 @@ public class QueryGenerator {
 				rule = QueryRuleEnum.getByValue(val.substring(0, 1));
 			}
 		}
-		//update-end--Author:scott  Date:20190724 for：initQueryWrapper组装sql查询条件错误 #284---------------------

 		// step 3 like
-		//update-begin-author:taoyan for: /issues/3382 默认带*就走模糊，但是如果只有一个*，那么走等于查询
+		// 代码逻辑说明: /issues/3382 默认带*就走模糊，但是如果只有一个*，那么走等于查询
 		if(rule == null && val.equals(STAR)){
 			rule = QueryRuleEnum.EQ;
 		}
-		//update-end-author:taoyan for: /issues/3382  默认带*就走模糊，但是如果只有一个*，那么走等于查询
 		if (rule == null && val.contains(STAR)) {
 			if (val.startsWith(STAR) && val.endsWith(STAR)) {
 				rule = QueryRuleEnum.LIKE;
@@ -567,12 +545,10 @@ public class QueryGenerator {
 			rule = QueryRuleEnum.EQ_WITH_ADD;
 		}

-		//update-begin--Author:taoyan  Date:20201229 for：initQueryWrapper组装sql查询条件错误 #284---------------------
 		//特殊处理：Oracle的表达式to_date('xxx','yyyy-MM-dd')含有逗号，会被识别为in查询，转为等于查询
 		if(rule == QueryRuleEnum.IN && val.indexOf(YYYY_MM_DD)>=0 && val.indexOf(TO_DATE)>=0){
 			rule = QueryRuleEnum.EQ;
 		}
-		//update-end--Author:taoyan  Date:20201229 for：initQueryWrapper组装sql查询条件错误 #284---------------------

 		return rule != null ? rule : QueryRuleEnum.EQ;
 	}
@@ -592,11 +568,10 @@ public class QueryGenerator {
 			return value;
 		}
 		String val = (value + "").toString().trim();
-		//update-begin-author:taoyan date:20220302 for: 查询条件的值为等号（=）bug #3443
+		// 代码逻辑说明: 查询条件的值为等号（=）bug #3443
 		if(QueryRuleEnum.EQ.getValue().equals(val)){
 			return val;
 		}
-		//update-end-author:taoyan date:20220302 for: 查询条件的值为等号（=）bug #3443
 		if (rule == QueryRuleEnum.LIKE) {
 			value = val.substring(1, val.length() - 1);
 			//mysql 模糊查询之特殊字符下划线 （_、\）
@@ -614,21 +589,19 @@ public class QueryGenerator {
 		} else if (rule == QueryRuleEnum.EQ_WITH_ADD) {
 			value = val.replaceAll("\\+\\+", COMMA);
 		}else {
-			//update-begin--Author:scott  Date:20190724 for：initQueryWrapper组装sql查询条件错误 #284-------------------
+			// 代码逻辑说明: initQueryWrapper组装sql查询条件错误 #284-------------------
 			if(val.startsWith(rule.getValue())){
 				//TODO 此处逻辑应该注释掉-> 如果查询内容中带有查询匹配规则符号，就会被截取的（比如：>=您好）
 				value = val.replaceFirst(rule.getValue(),"");
 			}else if(val.startsWith(rule.getCondition()+QUERY_SEPARATE_KEYWORD)){
 				value = val.replaceFirst(rule.getCondition()+QUERY_SEPARATE_KEYWORD,"").trim();
 			}
-			//update-end--Author:scott  Date:20190724 for：initQueryWrapper组装sql查询条件错误 #284-------------------
 		}
 		return value;
 	}
 	
 	private static void addQueryByRule(QueryWrapper<?> queryWrapper,String name,String type,String value,QueryRuleEnum rule) throws ParseException {
 		if(oConvertUtils.isNotEmpty(value)) {
-			//update-begin--Author:sunjianlei  Date:20220104 for：【JTC-409】修复逗号分割情况下没有转换类型，导致类型严格的数据库查询报错 -------------------
 			// 针对数字类型字段，多值查询
 			if(value.contains(COMMA)){
 				Object[] temp = Arrays.stream(value.split(COMMA)).map(v -> {
@@ -644,7 +617,6 @@ public class QueryGenerator {
 			}
 			Object temp = QueryGenerator.parseByType(value, type, rule);
 			addEasyQuery(queryWrapper, name, rule, temp);
-			//update-end--Author:sunjianlei  Date:20220104 for：【JTC-409】修复逗号分割情况下没有转换类型，导致类型严格的数据库查询报错 -------------------
 		}
 	}

@@ -759,13 +731,12 @@ public class QueryGenerator {
 			}else if(value instanceof String[]) {
 				queryWrapper.in(name, (Object[]) value);
 			}
-			//update-begin-author:taoyan date:20200909 for:【bug】in 类型多值查询 不适配postgresql #1671
+			// 代码逻辑说明: 【bug】in 类型多值查询 不适配postgresql #1671
 			else if(value.getClass().isArray()) {
 				queryWrapper.in(name, (Object[])value);
 			}else {
 				queryWrapper.in(name, value);
 			}
-			//update-end-author:taoyan date:20200909 for:【bug】in 类型多值查询 不适配postgresql #1671
 			break;
 		case LIKE:
 			queryWrapper.like(name, value);
@@ -782,7 +753,7 @@ public class QueryGenerator {
 		case NOT_RIGHT_LIKE:
 			queryWrapper.notLikeRight(name, value);
 			break;
-		//update-begin---author:chenrui ---date:20240527  for：[TV360X-378]下拉多框根据条件查询不出来:增加自定义字段查询规则功能------------
+		// 代码逻辑说明: [TV360X-378]下拉多框根据条件查询不出来:增加自定义字段查询规则功能------------
 		case LIKE_WITH_OR:
 			final String nameFinal = name;
 			Object[] vals;
@@ -791,7 +762,7 @@ public class QueryGenerator {
 			} else if (value instanceof String[]) {
 				vals = (Object[]) value;
 			}
-			//update-begin-author:taoyan date:20200909 for:【bug】in 类型多值查询 不适配postgresql #1671
+			// 代码逻辑说明: 【bug】in 类型多值查询 不适配postgresql #1671
 			else if (value.getClass().isArray()) {
 				vals = (Object[]) value;
 			} else {
@@ -806,7 +777,6 @@ public class QueryGenerator {
 				}
 			});
 			break;
-		//update-end---author:chenrui ---date:20240527  for：[TV360X-378]下拉多框根据条件查询不出来:增加自定义字段查询规则功能------------
 		default:
 			log.info("--查询规则未匹配到---");
 			break;
@@ -820,10 +790,8 @@ public class QueryGenerator {
 	private static boolean judgedIsUselessField(String name) {
 		return "class".equals(name) || "ids".equals(name)
 				|| "page".equals(name) || "rows".equals(name)
-//// update-begin--author:sunjianlei date:20240808 for：【TV360X-2009】取消过滤 sort、order 字段，防止前端排序报错 ------
 //// https://github.com/jeecgboot/JeecgBoot/issues/6937
 //				|| "sort".equals(name) || "order".equals(name)
-//// update-end----author:sunjianlei date:20240808 for：【TV360X-2009】取消过滤 sort、order 字段，防止前端排序报错 ------
 				;
 	}

@@ -836,13 +804,12 @@ public class QueryGenerator {
 	public static Map<String, SysPermissionDataRuleModel> getRuleMap() {
 		Map<String, SysPermissionDataRuleModel> ruleMap = new HashMap<>(5);
 		List<SysPermissionDataRuleModel> list = null;
-		//update-begin-author:taoyan date:2023-6-1 for:QQYUN-5441 【简流】获取多个用户/部门/角色 设置部门查询 报错
+		// 代码逻辑说明: QQYUN-5441 【简流】获取多个用户/部门/角色 设置部门查询 报错
 		try {
 			list = JeecgDataAutorUtils.loadDataSearchConditon();
 		}catch (Exception e){
 			log.error("根据request对象获取权限数据失败，可能是定时任务中执行的。", e);
 		}
-		//update-end-author:taoyan date:2023-6-1 for:QQYUN-5441 【简流】获取多个用户/部门/角色 设置部门查询 报错
 		if(list != null&&list.size()>0){
 			if(list.get(0)==null){
 				return ruleMap;
@@ -879,9 +846,8 @@ public class QueryGenerator {
 					addEasyQuery(queryWrapper, name, rule, DateUtils.str2Date(dateStr,DateUtils.datetimeFormat.get()));
 				}
 			}else {
-				//update-begin---author:chenrui ---date:20241125  for：[issues/7481]多租户模式下 数据权限使用变量：#{tenant_id} 报错------------
+				// 代码逻辑说明: [issues/7481]多租户模式下 数据权限使用变量：#{tenant_id} 报错------------
 				addEasyQuery(queryWrapper, name, rule, NumberUtils.parseNumber(converRuleValue(dataRule.getRuleValue()), propertyType));
-				//update-end---author:chenrui ---date:20241125  for：[issues/7481]多租户模式下 数据权限使用变量：#{tenant_id} 报错------------
 			}
 		}
 	}
@@ -935,9 +901,8 @@ public class QueryGenerator {
 			return null;
 		}
 		Set<String> varParams = new HashSet<String>();
-		//update-begin---author:chenrui ---date:20250108  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
+		// 代码逻辑说明: [QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 		String regex = "#\\{\\[*\\w+]*}";
-		//update-end---author:chenrui ---date:20250108  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 		
 		Pattern p = Pattern.compile(regex);
 		Matcher m = p.matcher(sql);
@@ -993,9 +958,8 @@ public class QueryGenerator {
 				Class propType = origDescriptors[i].getPropertyType();
 				boolean isString = propType.equals(String.class);
 				Object value;
-				//update-begin---author:chenrui ---date:20240527  for：[TV360X-539]数据权限，配置日期等于条件时后端报转换错误------------
+				// 代码逻辑说明: [TV360X-539]数据权限，配置日期等于条件时后端报转换错误------------
 				if(isString || Date.class.equals(propType)) {
-				//update-end---author:chenrui ---date:20240527  for：[TV360X-539]数据权限，配置日期等于条件时后端报转换错误------------
 					value = converRuleValue(dataRule.getRuleValue());
 				}else {
 					value = NumberUtils.parseNumber(dataRule.getRuleValue(),propType);
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/ResourceUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/ResourceUtil.java
@@ -67,13 +67,13 @@ public class ResourceUtil {
            synchronized (ResourceUtil.class) {
                if (!initialized) {
                    long startTime = System.currentTimeMillis();
-                    log.info("【枚举字典加载】开始初始化枚举字典数据...");
+                    log.debug("【枚举字典加载】开始初始化枚举字典数据...");

                    initEnumDictData();
                    initialized = true;

                    long endTime = System.currentTimeMillis();
-                    log.info("【枚举字典加载】枚举字典数据初始化完成，共加载 {} 个字典，总耗时: {}ms", enumDictData.size(), endTime - startTime);
+                    log.debug("【枚举字典加载】枚举字典数据初始化完成，共加载 {} 个字典，总耗时: {}ms", enumDictData.size(), endTime - startTime);
                }
            }
        }
@@ -103,7 +103,7 @@ public class ResourceUtil {
        }

        long scanEndTime = System.currentTimeMillis();
-        log.info("【枚举字典加载】文件扫描完成，总共找到 {} 个枚举类文件，扫描耗时: {}ms", allResources.size(), scanEndTime - scanStartTime);
+        log.debug("【枚举字典加载】文件扫描完成，总共找到 {} 个枚举类文件，扫描耗时: {}ms", allResources.size(), scanEndTime - scanStartTime);

        MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(resourcePatternResolver);

@@ -126,7 +126,7 @@ public class ResourceUtil {
        }

        long processEndTime = System.currentTimeMillis();
-        log.info("【枚举字典加载】处理完成，实际处理 {} 个带注解的枚举类，处理耗时: {}ms", processedCount, processEndTime - processStartTime);
+        log.debug("【枚举字典加载】处理完成，实际处理 {} 个带注解的枚举类，处理耗时: {}ms", processedCount, processEndTime - processStartTime);
    }

    /**
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/SqlConcatUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/SqlConcatUtil.java
@@ -150,7 +150,7 @@ public class SqlConcatUtil {
    }

    private static String getInConditionValue(Object value,boolean isString) {
-        //update-begin-author:taoyan date:20210628 for: 查询条件如果输入,导致sql报错
+        // 代码逻辑说明: 查询条件如果输入,导致sql报错
        String[] temp = value.toString().split(",");
        if(temp.length==0){
            return "('')";
@@ -168,7 +168,6 @@ public class SqlConcatUtil {
        }else {
            return "("+value.toString()+")";
        }
-        //update-end-author:taoyan date:20210628 for: 查询条件如果输入,导致sql报错
    }

    /**
@@ -215,7 +214,6 @@ public class SqlConcatUtil {
                }
            }else {

-                //update-begin-author:taoyan date:2022-6-30 for: issues/3810 数据权限规则问题
                // 走到这里说明 value不带有任何模糊查询的标识(*或者%)
                if (ruleEnum == QueryRuleEnum.LEFT_LIKE) {
                    if (DataBaseConstant.DB_TYPE_SQLSERVER.equals(getDbType())) {
@@ -236,7 +234,6 @@ public class SqlConcatUtil {
                        return "'%" + str + "%'";
                    }
                }
-                //update-end-author:taoyan date:2022-6-30 for: issues/3810 数据权限规则问题

            }
        }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/DySmsHelper.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/DySmsHelper.java
@@ -10,7 +10,9 @@ import com.aliyuncs.exceptions.ClientException;
 import com.aliyuncs.profile.DefaultProfile;
 import com.aliyuncs.profile.IClientProfile;
 import org.apache.commons.lang3.StringUtils;
+import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.enums.DySmsEnum;
+import org.jeecg.config.JeecgBaseConfig;
 import org.jeecg.config.JeecgSmsTemplateConfig;
 import org.jeecg.config.StaticConfig;
 import org.slf4j.Logger;
@@ -61,17 +63,21 @@ public class DySmsHelper {
    
    
    public static boolean sendSms(String phone, JSONObject templateParamJson, DySmsEnum dySmsEnum) throws ClientException {
-    	//可自助调整超时时间
+        JeecgBaseConfig config = SpringContextUtils.getBean(JeecgBaseConfig.class);
+        String smsSendType = config.getSmsSendType();
+        if(oConvertUtils.isNotEmpty(smsSendType) && CommonConstant.SMS_SEND_TYPE_TENCENT.equals(smsSendType)){
+            return TencentSms.sendTencentSms(phone, templateParamJson, config.getTencent(), dySmsEnum);
+        }
+        //可自助调整超时时间
        System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
        System.setProperty("sun.net.client.defaultReadTimeout", "10000");

-        //update-begin-author：taoyan date:20200811 for:配置类数据获取
+        // 代码逻辑说明: 配置类数据获取
        StaticConfig staticConfig = SpringContextUtils.getBean(StaticConfig.class);
        //logger.info("阿里大鱼短信秘钥 accessKeyId：" + staticConfig.getAccessKeyId());
        //logger.info("阿里大鱼短信秘钥 accessKeySecret："+ staticConfig.getAccessKeySecret());
        setAccessKeyId(staticConfig.getAccessKeyId());
        setAccessKeySecret(staticConfig.getAccessKeySecret());
-        //update-end-author：taoyan date:20200811 for:配置类数据获取
        
        //初始化acsClient,暂不支持region化
        IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
@@ -81,7 +87,7 @@ public class DySmsHelper {
        //验证json参数
        validateParam(templateParamJson,dySmsEnum);

-        //update-begin---author:wangshuai---date:2024-11-05---for:【QQYUN-9422】短信模板管理，阿里云---
+        // 代码逻辑说明: 【QQYUN-9422】短信模板管理，阿里云---
        String templateCode = dySmsEnum.getTemplateCode();
        JeecgSmsTemplateConfig baseConfig = SpringContextUtils.getBean(JeecgSmsTemplateConfig.class);
        if(baseConfig != null && CollectionUtil.isNotEmpty(baseConfig.getTemplateCode())){
@@ -97,7 +103,6 @@ public class DySmsHelper {
            logger.info("yml中读取签名名称{}",baseConfig.getSignature());
            signName = baseConfig.getSignature();
        }
-        //update-end---author:wangshuai---date:2024-11-05---for:【QQYUN-9422】短信模板管理，阿里云---
        
        //组装请求对象-具体描述见控制台-文档部分内容
        SendSmsRequest request = new SendSmsRequest();
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/FileDownloadUtils.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/FileDownloadUtils.java
@@ -1,7 +1,7 @@
 package org.jeecg.common.util;

-import jakarta.servlet.http.HttpServletResponse;
 import cn.hutool.core.io.IoUtil;
+import jakarta.servlet.http.HttpServletResponse;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
 import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/HTMLUtils.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/HTMLUtils.java
@@ -38,14 +38,12 @@ public class HTMLUtils {
     * @return
     */
    public static String parseMarkdown(String markdownContent) {
-        //update-begin---author:wangshuai---date:2024-06-26---for:【TV360X-1344】JDK17 邮箱发送失败，需要换写法---
        /*PegDownProcessor pdp = new PegDownProcessor();
        return pdp.markdownToHtml(markdownContent);*/
        Parser parser = Parser.builder().build();
        Node document = parser.parse(markdownContent);
        HtmlRenderer renderer = HtmlRenderer.builder().build();
        return renderer.render(document);
-        //update-end---author:wangshuai---date:2024-06-26---for:【TV360X-1344】JDK17 邮箱发送失败，需要换写法---
    }

 }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MinioUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MinioUtil.java
@@ -161,11 +161,10 @@ public class MinioUtil {
    public static String getObjectUrl(String bucketName, String objectName, Integer expires) {
        initMinio(minioUrl, minioName,minioPass);
        try{
-            //update-begin---author:liusq  Date:20220121  for：获取文件外链报错提示method不能为空，导致文件下载和预览失败----
+            // 代码逻辑说明: 获取文件外链报错提示method不能为空，导致文件下载和预览失败----
            GetPresignedObjectUrlArgs objectArgs = GetPresignedObjectUrlArgs.builder().object(objectName)
                    .bucket(bucketName)
                    .expiry(expires).method(Method.GET).build();
-            //update-begin---author:liusq  Date:20220121  for：获取文件外链报错提示method不能为空，导致文件下载和预览失败----
            String url = minioClient.getPresignedObjectUrl(objectArgs);
            return URLDecoder.decode(url,"UTF-8");
        }catch (Exception e){
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MyCommonsMultipartFile.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MyCommonsMultipartFile.java
@@ -0,0 +1,78 @@
+package org.jeecg.common.util;
+
+import org.apache.commons.fileupload.FileItem;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.*;
+
+/**
+ * @date 2025-09-04
+ * @author scott
+ * 
+ * 升级springboot3 无法使用 CommonsMultipartFile
+ * 自定义 MultipartFile 实现类，支持从 FileItem 构造
+ */
+public class MyCommonsMultipartFile implements MultipartFile {
+
+    private final byte[] fileContent;
+    private final String fileName;
+    private final String contentType;
+
+    // 新增构造方法，支持 FileItem 参数
+    public MyCommonsMultipartFile(FileItem fileItem) throws IOException {
+        this.fileName = fileItem.getName();
+        this.contentType = fileItem.getContentType();
+        try (InputStream inputStream = fileItem.getInputStream()) {
+            this.fileContent = inputStream.readAllBytes();
+        }
+    }
+    
+    // 现有构造方法
+    public MyCommonsMultipartFile(InputStream inputStream, String fileName, String contentType) throws IOException {
+        this.fileName = fileName;
+        this.contentType = contentType;
+        this.fileContent = inputStream.readAllBytes();
+    }
+
+    @Override
+    public String getName() {
+        return fileName;
+    }
+
+    @Override
+    public String getOriginalFilename() {
+        return fileName;
+    }
+
+    @Override
+    public String getContentType() {
+        return contentType;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return fileContent.length == 0;
+    }
+
+    @Override
+    public long getSize() {
+        return fileContent.length;
+    }
+
+    @Override
+    public byte[] getBytes() {
+        return fileContent;
+    }
+
+    @Override
+    public InputStream getInputStream() {
+        return new ByteArrayInputStream(fileContent);
+    }
+
+    @Override
+    public void transferTo(File dest) throws IOException {
+        try (OutputStream os = new FileOutputStream(dest)) {
+            os.write(fileContent);
+        }
+    }
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/PasswordUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/PasswordUtil.java
@@ -99,9 +99,8 @@ public class PasswordUtil {
 			Cipher cipher = Cipher.getInstance(ALGORITHM);

 			cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
-			//update-begin-author:sccott date:20180815 for:中文作为用户名时，加密的密码windows和linux会得到不同的结果 gitee/issues/IZUD7
+			// 代码逻辑说明: 中文作为用户名时，加密的密码windows和linux会得到不同的结果 gitee/issues/IZUD7
 			encipheredData = cipher.doFinal(plaintext.getBytes("utf-8"));
-			//update-end-author:sccott date:20180815 for:中文作为用户名时，加密的密码windows和linux会得到不同的结果 gitee/issues/IZUD7
 		} catch (Exception e) {
 		}
 		return bytesToHexString(encipheredData);
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/RestUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/RestUtil.java
@@ -56,14 +56,12 @@ public class RestUtil {
    private final static RestTemplate RT;

    static {
-        //update-begin---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
+        // 解决[issues/8859]online表单java增强失效------------
        // 使用 Apache HttpClient 避免 JDK HttpURLConnection 的 too many bytes written 问题
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
-        //update-end---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
        requestFactory.setConnectTimeout(30000);
        requestFactory.setReadTimeout(30000);
        RT = new RestTemplate(requestFactory);
-        //update-begin---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
        // 解决乱码问题（替换 StringHttpMessageConverter 为 UTF-8）
        for (int i = 0; i < RT.getMessageConverters().size(); i++) {
            if (RT.getMessageConverters().get(i) instanceof StringHttpMessageConverter) {
@@ -71,7 +69,6 @@ public class RestUtil {
                break;
            }
        }
-        //update-end---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
    }

    public static RestTemplate getRestTemplate() {
@@ -226,6 +223,16 @@ public class RestUtil {
        if (variables != null && !variables.isEmpty()) {
            url += ("?" + asUrlVariables(variables));
        }
+        // 解决[issues/8951]从jeecgboot 3.8.2 升级到 3.8.3 在线表单java增强功能报错------------
+        // Content-Length 强制设置（解决可能出现的截断问题）
+        if (StringUtils.isNotEmpty(body)) {
+            int contentLength = body.getBytes(StandardCharsets.UTF_8).length;
+            String current = headers.getFirst(HttpHeaders.CONTENT_LENGTH);
+            if (current == null || !current.equals(String.valueOf(contentLength))) {
+                headers.setContentLength(contentLength);
+                log.info(" RestUtil  --- request --- 修正/设置 Content-Length = " + contentLength + (current!=null?" (原值="+current+")":""));
+            }
+        }
        // 发送请求
        HttpEntity<String> request = new HttpEntity<>(body, headers);
        return RT.exchange(url, method, request, responseType);
@@ -260,13 +267,11 @@ public class RestUtil {
        // 创建自定义RestTemplate（如果需要设置超时）
        RestTemplate restTemplate = RT;
        if (timeout > 0) {
-            //update-begin---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
+            // 代码逻辑说明: [issues/8859]online表单java增强失效------------
            HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
-            //update-end---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
            requestFactory.setConnectTimeout(timeout);
            requestFactory.setReadTimeout(timeout);
            restTemplate = new RestTemplate(requestFactory);
-            //update-begin---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
            // 解决乱码问题（替换 StringHttpMessageConverter 为 UTF-8）
            for (int i = 0; i < restTemplate.getMessageConverters().size(); i++) {
                if (restTemplate.getMessageConverters().get(i) instanceof StringHttpMessageConverter) {
@@ -274,7 +279,6 @@ public class RestUtil {
                    break;
                }
            }
-            //update-end---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
        }

        // 请求体
@@ -292,11 +296,21 @@ public class RestUtil {
            url += ("?" + asUrlVariables(variables));
        }

+        // Content-Length 强制设置（解决可能出现的截断问题）
+        if (StringUtils.isNotEmpty(body) && !headers.containsKey(HttpHeaders.CONTENT_LENGTH)) {
+            int contentLength = body.getBytes(StandardCharsets.UTF_8).length;
+            String current = headers.getFirst(HttpHeaders.CONTENT_LENGTH);
+            if (current == null || !current.equals(String.valueOf(contentLength))) {
+                headers.setContentLength(contentLength);
+                log.info(" RestUtil  --- request(timeout) --- 修正/设置 Content-Length = " + contentLength + (current!=null?" (原值="+current+")":""));
+            }
+        }
+
        // 发送请求
        HttpEntity<String> request = new HttpEntity<>(body, headers);
        return restTemplate.exchange(url, method, request, responseType);
    }
-    
+
    /**
     * 获取JSON请求头
     */
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/SqlInjectionUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/SqlInjectionUtil.java
@@ -335,13 +335,12 @@ public class SqlInjectionUtil {
 			return table;
 		}

-		//update-begin---author:scott ---date:2024-05-28  for：表单设计器列表翻译存在表名带条件，导致翻译出问题----
+		// 代码逻辑说明: 表单设计器列表翻译存在表名带条件，导致翻译出问题----
 		int index = table.toLowerCase().indexOf(" where ");
 		if (index != -1) {
 			table = table.substring(0, index);
 			log.info("截掉where之后的新表名：" + table);
 		}
-		//update-end---author:scott ---date::2024-05-28  for：表单设计器列表翻译存在表名带条件，导致翻译出问题----

 		table = table.trim();
 		/**
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/TencentSms.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/TencentSms.java
@@ -0,0 +1,184 @@
+package org.jeecg.common.util;
+
+import com.alibaba.fastjson.JSONObject;
+import com.tencentcloudapi.common.Credential;
+import com.tencentcloudapi.common.exception.TencentCloudSDKException;
+import com.tencentcloudapi.common.profile.ClientProfile;
+import com.tencentcloudapi.common.profile.HttpProfile;
+import com.tencentcloudapi.sms.v20210111.SmsClient;
+import com.tencentcloudapi.sms.v20210111.models.SendSmsRequest;
+import com.tencentcloudapi.sms.v20210111.models.SendSmsResponse;
+import com.tencentcloudapi.sms.v20210111.models.SendStatus;
+import org.apache.commons.lang3.StringUtils;
+import org.jeecg.common.constant.enums.DySmsEnum;
+import org.jeecg.config.JeecgSmsTemplateConfig;
+import org.jeecg.config.tencent.JeecgTencent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description: 腾讯发送短信
+ * @author: wangshuai
+ * @date: 2025/11/4 19:27
+ */
+public class TencentSms {
+
+    private final static Logger logger = LoggerFactory.getLogger(TencentSms.class);
+
+    /**
+     * 发送腾讯短信
+     *
+     * @param phone
+     * @param templateParamJson
+     * @param tencent
+     * @param dySmsEnum
+     * @return
+     */
+    public static boolean sendTencentSms(String phone, JSONObject templateParamJson, JeecgTencent tencent, DySmsEnum dySmsEnum) {
+        //获取客户端链接
+        SmsClient client = getSmsClient(tencent);
+        //构建腾讯云短信发送请求
+        SendSmsRequest req = buildSendSmsRequest(phone, templateParamJson, dySmsEnum, tencent);
+        try {
+            //发送短信
+            SendSmsResponse resp = client.SendSms(req);
+            // 处理响应
+            SendStatus[] statusSet = resp.getSendStatusSet();
+            if (statusSet != null && statusSet.length > 0) {
+                SendStatus status = statusSet[0];
+                if ("Ok".equals(status.getCode())) {
+                    logger.info("短信发送成功，手机号：{}", phone);
+                    return true;
+                } else {
+                    logger.error("短信发送失败，手机号：{}，错误码：{}，错误信息：{}",
+                            phone, status.getCode(), status.getMessage());
+                }
+            }
+        } catch (TencentCloudSDKException e) {
+            logger.error("短信发送失败{}", e.getMessage());
+        }
+        return false;
+    }
+
+    /**
+     * 获取sms客户端
+     *
+     * @param tencent 腾讯云配置
+     * @return SmsClient对象
+     */
+    private static SmsClient getSmsClient(JeecgTencent tencent) {
+        Credential cred = new Credential(tencent.getSecretId(), tencent.getSecretKey());
+        // 实例化一个http选项，可选的，没有特殊需求可以跳过
+        HttpProfile httpProfile = new HttpProfile();
+        //指定接入地域域名*/
+        httpProfile.setEndpoint(tencent.getEndpoint());
+        //实例化一个客户端配置对象
+        ClientProfile clientProfile = new ClientProfile();
+        clientProfile.setHttpProfile(httpProfile);
+        //实例化要请求产品的client对象，第二个参数是地域信息
+        return new SmsClient(cred, tencent.getRegion(), clientProfile);
+    }
+
+    /**
+     * 构建腾讯云短信发送请求
+     *
+     * @param phone             手机号码
+     * @param templateParamJson 模板参数JSON对象
+     * @param dySmsEnum         短信枚举配置
+     * @param tencent           腾讯云配置
+     * @return 构建好的SendSmsRequest对象
+     */
+    private static SendSmsRequest buildSendSmsRequest(
+            String phone,
+            JSONObject templateParamJson,
+            DySmsEnum dySmsEnum,
+            JeecgTencent tencent) {
+
+        SendSmsRequest req = new SendSmsRequest();
+
+        // 1. 设置短信应用ID
+        String sdkAppId = tencent.getSdkAppId();
+        req.setSmsSdkAppId(sdkAppId);
+        // 2. 设置短信签名
+        String signName = getSmsSignName(dySmsEnum);
+        req.setSignName(signName);
+        // 3. 设置模板ID
+        String templateId = getSmsTemplateId(dySmsEnum);
+        req.setTemplateId(templateId);
+        // 4. 设置模板参数
+        String[] templateParams = extractTemplateParams(templateParamJson);
+        req.setTemplateParamSet(templateParams);
+        // 5. 设置手机号码
+        String[] phoneNumberSet = { phone };
+        req.setPhoneNumberSet(phoneNumberSet);
+
+        logger.debug("构建短信请求完成 - 应用ID: {}, 签名: {}, 模板ID: {}, 手机号: {}",
+                sdkAppId, signName, templateId, phone);
+
+        return req;
+    }
+
+    /**
+     * 获取短信签名名称
+     *
+     * @param dySmsEnum 腾讯云对象
+     */
+    private static String getSmsSignName(DySmsEnum dySmsEnum) {
+        JeecgSmsTemplateConfig baseConfig = SpringContextUtils.getBean(JeecgSmsTemplateConfig.class);
+        String signName = dySmsEnum.getSignName();
+
+        if (StringUtils.isNotEmpty(baseConfig.getSignature())) {
+            logger.debug("yml中读取签名名称: {}", baseConfig.getSignature());
+            signName = baseConfig.getSignature();
+        }
+
+        return signName;
+    }
+
+    /**
+     * 获取短信模板ID
+     *
+     * @param dySmsEnum 腾讯云对象
+     */
+    private static String getSmsTemplateId(DySmsEnum dySmsEnum) {
+        JeecgSmsTemplateConfig baseConfig = SpringContextUtils.getBean(JeecgSmsTemplateConfig.class);
+        String templateCode = dySmsEnum.getTemplateCode();
+
+        if (StringUtils.isNotEmpty(baseConfig.getSignature())) {
+            Map<String, String> smsTemplate = baseConfig.getTemplateCode();
+            if (smsTemplate.containsKey(templateCode) &&
+                    StringUtils.isNotEmpty(smsTemplate.get(templateCode))) {
+                templateCode = smsTemplate.get(templateCode);
+                logger.debug("yml中读取短信模板ID: {}", templateCode);
+            }
+        }
+        return templateCode;
+    }
+
+    /**
+     * 从JSONObject中提取模板参数（按原始顺序）
+     *
+     * @param templateParamJson 模板参数
+     */
+    private static String[] extractTemplateParams(JSONObject templateParamJson) {
+        if (templateParamJson == null || templateParamJson.isEmpty()) {
+            return new String[0];
+        }
+        List<String> params = new ArrayList<>();
+        for (String key : templateParamJson.keySet()) {
+            Object value = templateParamJson.get(key);
+            if (value != null) {
+                params.add(value.toString());
+            } else {
+                // 处理null值
+                params.add("");
+            }
+        }
+        logger.debug("提取模板参数: {}", params);
+        return params.toArray(new String[0]);
+    }
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/dynamic/db/FreemarkerParseFactory.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/dynamic/db/FreemarkerParseFactory.java
@@ -54,11 +54,10 @@ public class FreemarkerParseFactory {
        //classic_compatible设置，解决报空指针错误
        SQL_CONFIG.setClassicCompatible(true);

-        //update-begin-author:taoyan date:2022-8-10 for: freemarker模板注入问题 禁止解析ObjectConstructor，Execute和freemarker.template.utility.JythonRuntime。
+        // 解决freemarker模板注入问题 禁止解析ObjectConstructor，Execute和freemarker.template.utility.JythonRuntime。
        //https://ackcent.com/in-depth-freemarker-template-injection/
        TPL_CONFIG.setNewBuiltinClassResolver(TemplateClassResolver.SAFER_RESOLVER);
        SQL_CONFIG.setNewBuiltinClassResolver(TemplateClassResolver.SAFER_RESOLVER);
-        //update-end-author:taoyan date:2022-8-10 for: freemarker模板注入问题 禁止解析ObjectConstructor，Execute和freemarker.template.utility.JythonRuntime。
    }

    /**
@@ -73,13 +72,12 @@ public class FreemarkerParseFactory {
                return false;
            }
        } catch (Exception e) {
-            //update-begin--Author:scott  Date:20180320 for：解决问题 - 错误提示sql文件不存在，实际问题是sql freemarker用法错误-----
+            // 代码逻辑说明: 解决问题 - 错误提示sql文件不存在，实际问题是sql freemarker用法错误-----
            if (e instanceof ParseException) {
                log.error(e.getMessage(), e.fillInStackTrace());
                throw new Exception(e);
            }
            log.debug("----isExistTemplate----" + e.toString());
-            //update-end--Author:scott  Date:20180320 for：解决问题 - 错误提示sql文件不存在，实际问题是sql freemarker用法错误------
            return false;
        }
        return true;
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/encryption/AesEncryptUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/encryption/AesEncryptUtil.java
@@ -1,123 +1,108 @@
 package org.jeecg.common.util.encryption;

-import java.util.Base64;
+import lombok.extern.slf4j.Slf4j;
+import org.jeecg.common.util.oConvertUtils;
+
 import javax.crypto.Cipher;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;

 /**
- * @Description: AES 加密
- * @author: jeecg-boot
- * @date: 2022/3/30 11:48
+ * AES 工具 (兼容历史 NoPadding + 新 PKCS5Padding)
 */
+@Slf4j
 public class AesEncryptUtil {

-    /**
-     * 使用AES-128-CBC加密模式 key和iv可以相同
-     */
-    private static String KEY = EncryptedString.key;
-    private static String IV = EncryptedString.iv;
+    private static final String KEY = EncryptedString.key;
+    private static final String IV  = EncryptedString.iv;

-    /**
-     * 加密方法
-     * @param data  要加密的数据
-     * @param key 加密key
-     * @param iv 加密iv
-     * @return 加密的结果
-     * @throws Exception
-     */
-    public static String encrypt(String data, String key, String iv) throws Exception {
-        try {
+    /* -------- 新版：CBC + PKCS5Padding (与前端 CryptoJS Pkcs7 兼容) -------- */
+    private static String decryptPkcs5(String cipherBase64) throws Exception {
+        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+        SecretKeySpec ks = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
+        IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8));
+        cipher.init(Cipher.DECRYPT_MODE, ks, ivSpec);
+        byte[] plain = cipher.doFinal(Base64.getDecoder().decode(cipherBase64));
+        return new String(plain, StandardCharsets.UTF_8);
+    }

-            //"算法/模式/补码方式"NoPadding PkcsPadding
+    /* -------- 旧版：CBC + NoPadding (手工补 0) -------- */
+    private static String decryptLegacyNoPadding(String cipherBase64) throws Exception {
+        Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
+        SecretKeySpec ks = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
+        IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8));
+        cipher.init(Cipher.DECRYPT_MODE, ks, ivSpec);
+        byte[] data = cipher.doFinal(Base64.getDecoder().decode(cipherBase64));
+        return new String(data, StandardCharsets.UTF_8)
+                .replace("\u0000",""); // 旧填充 0
+    }
+
+    /* -------- 兼容入口：登录使用 -------- */
+    public static String resolvePassword(String input){
+        if(oConvertUtils.isEmpty(input)){
+            return input;
+        }
+        // 1. 先尝试新版
+        try{
+            String p = decryptPkcs5(input);
+            return clean(p);
+        }catch(Exception ignore){
+            //log.debug("【AES解密】Password not AES PKCS5 cipher, try legacy.");
+        }
+
+        // 2. 回退旧版
+        try{
+            String legacy = decryptLegacyNoPadding(input);
+            return clean(legacy);
+        }catch(Exception e){
+            log.debug("【AES解密】Password not AES cipher, raw used.");
+        }
+
+        // 3. 视为明文
+        return input;
+    }
+
+    /* -------- 可选：统一清理尾部不可见控制字符 -------- */
+    private static String clean(String s){
+        if(s==null) return null;
+        // 去除结尾控制符/空白（不影响中间合法空格）
+        return s.replaceAll("[\\p{Cntrl}]+","").trim();
+    }
+
+    /* -------- 若仍需要旧接口，可保留 (不建议再用于新前端) -------- */
+    @Deprecated
+    public static String desEncrypt(String data) throws Exception {
+        return decryptLegacyNoPadding(data);
+    }
+
+    /* 加密（若前端不再使用，可忽略；保留旧实现避免影响历史） */
+    @Deprecated
+    public static String encrypt(String data) throws Exception {
+        try{
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            int blockSize = cipher.getBlockSize();
-
-            byte[] dataBytes = data.getBytes();
+            byte[] dataBytes = data.getBytes(StandardCharsets.UTF_8);
            int plaintextLength = dataBytes.length;
            if (plaintextLength % blockSize != 0) {
-                plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
+                plaintextLength += (blockSize - (plaintextLength % blockSize));
            }
-
            byte[] plaintext = new byte[plaintextLength];
            System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
-
-            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
-            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
-
+            SecretKeySpec keyspec = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
+            IvParameterSpec ivspec = new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8));
            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
            byte[] encrypted = cipher.doFinal(plaintext);
-
            return Base64.getEncoder().encodeToString(encrypted);
-
-        } catch (Exception e) {
-            e.printStackTrace();
-            return null;
+        }catch(Exception e){
+            throw new IllegalStateException("legacy encrypt error", e);
        }
    }

-    /**
-     * 解密方法
-     * @param data 要解密的数据
-     * @param key  解密key
-     * @param iv 解密iv
-     * @return 解密的结果
-     * @throws Exception
-     */
-    public static String desEncrypt(String data, String key, String iv) throws Exception {
-        //update-begin-author:taoyan date:2022-5-23 for:VUEN-1084 【vue3】online表单测试发现的新问题 6、解密报错 ---解码失败应该把异常抛出去，在外面处理
-        byte[] encrypted1 = Base64.getDecoder().decode(data);
-
-        Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
-        SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
-        IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
-
-        cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
-
-        byte[] original = cipher.doFinal(encrypted1);
-        String originalString = new String(original);
-        //加密解码后的字符串会出现\u0000
-        return originalString.replaceAll("\\u0000", "");
-        //update-end-author:taoyan date:2022-5-23 for:VUEN-1084 【vue3】online表单测试发现的新问题 6、解密报错 ---解码失败应该把异常抛出去，在外面处理
-    }
-
-    /**
-     * 使用默认的key和iv加密
-     * @param data
-     * @return
-     * @throws Exception
-     */
-    public static String encrypt(String data) throws Exception {
-        return encrypt(data, KEY, IV);
-    }
-
-    /**
-     * 使用默认的key和iv解密
-     * @param data
-     * @return
-     * @throws Exception
-     */
-    public static String desEncrypt(String data) throws Exception {
-        return desEncrypt(data, KEY, IV);
-    }
-
-
-
-//    /**
-//     * 测试
-//     */
-//    public static void main(String args[]) throws Exception {
-//        String test1 = "sa";
-//        String test =new String(test1.getBytes(),"UTF-8");
-//        String data = null;
-//        String key =  KEY;
-//        String iv = IV;
-//        // /g2wzfqvMOeazgtsUVbq1kmJawROa6mcRAzwG1/GeJ4=
-//        data = encrypt(test, key, iv);
-//        System.out.println("数据："+test);
-//        System.out.println("加密："+data);
-//        String jiemi =desEncrypt(data, key, iv).trim();
-//        System.out.println("解密："+jiemi);
+//    public static void main(String[] args) throws Exception {
+//        // 前端 CBC/Pkcs7 密文测试
+//        String frontCipher = encrypt("sa"); // 仅验证管道是否可用（旧方式）
+//        System.out.println(resolvePassword(frontCipher));
 //    }
-
-}
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/filter/SsrfFileTypeFilter.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/filter/SsrfFileTypeFilter.java
@@ -194,7 +194,7 @@ public class SsrfFileTypeFilter {
     */

    private static String getFileType(MultipartFile file, String customPath) throws Exception {
-        //update-begin-author:liusq date:20230404 for: [issue/4672]方法造成的文件被占用，注释掉此方法tomcat就能自动清理掉临时文件
+        // 代码逻辑说明: [issue/4672]方法造成的文件被占用，注释掉此方法tomcat就能自动清理掉临时文件
        String fileExtendName = null;
        InputStream is = null;
        try {
@@ -234,7 +234,6 @@ public class SsrfFileTypeFilter {
                is.close();
            }
        }
-        //update-end-author:liusq date:20230404 for: [issue/4672]方法造成的文件被占用，注释掉此方法tomcat就能自动清理掉临时文件
    }

    /**
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/oConvertUtils.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/oConvertUtils.java
@@ -11,6 +11,10 @@ import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
 import org.springframework.beans.BeanUtils;

 import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.beans.BeanWrapper;
+import org.springframework.beans.BeanWrapperImpl;
+
+import java.beans.PropertyDescriptor;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
@@ -23,6 +27,7 @@ import java.sql.Date;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Stream;

 /**
 * 
@@ -563,10 +568,8 @@ public class oConvertUtils {
 			return "";
 		} else if (!name.contains(SymbolConstant.UNDERLINE)) {
 			// 不含下划线，仅将首字母小写
-			//update-begin--Author:zhoujf  Date:20180503 for：TASK #2500 【代码生成器】代码生成器开发一通用模板生成功能
-			//update-begin--Author:zhoujf  Date:20180503 for：TASK #2500 【代码生成器】代码生成器开发一通用模板生成功能
+			// 代码逻辑说明: TASK #2500 【代码生成器】代码生成器开发一通用模板生成功能
 			return name.substring(0, 1).toLowerCase() + name.substring(1).toLowerCase();
-			//update-end--Author:zhoujf  Date:20180503 for：TASK #2500 【代码生成器】代码生成器开发一通用模板生成功能
 		}
 		// 用下划线将原始字符串分割
 		String[] camels = name.split("_");
@@ -611,7 +614,6 @@ public class oConvertUtils {
 		return result.substring(0, result.length() - 1);
 	}
 	
-	//update-begin--Author:zhoujf  Date:20180503 for：TASK #2500 【代码生成器】代码生成器开发一通用模板生成功能
 	/**
 	 * 将下划线大写方式命名的字符串转换为驼峰式。(首字母写)
 	 * 如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
@@ -644,7 +646,6 @@ public class oConvertUtils {
 		}
 		return result.toString();
 	}
-	//update-end--Author:zhoujf  Date:20180503 for：TASK #2500 【代码生成器】代码生成器开发一通用模板生成功能
 	
 	/**
 	 * 将驼峰命名转化成下划线
@@ -982,17 +983,18 @@ public class oConvertUtils {


 	/**
-	 * 判断 list1中的元素是否在list2中出现
+	 * 判断 sourceList中的元素是否在targetList中出现
+	 * 
 	 * QQYUN-5326【简流】获取组织人员 单/多 筛选条件 没有部门筛选
-	 * @param list1
-	 * @param list2
-	 * @return
+	 * @param sourceList 源列表，要检查的元素列表
+	 * @param targetList 目标列表，用于匹配的列表
+	 * @return 如果sourceList中有任何元素在targetList中存在则返回true，否则返回false
 	 */
-	public static boolean isInList(List<String> list1, List<String> list2){
-		for(String str1: list1){
+	public static boolean isInList(List<String> sourceList, List<String> targetList){
+		for(String sourceItem: sourceList){
 			boolean flag = false;
-			for(String str2: list2){
-				if(str1.equals(str2)){
+			for(String targetItem: targetList){
+				if(sourceItem.equals(targetItem)){
 					flag = true;
 					break;
 				}
@@ -1004,6 +1006,35 @@ public class oConvertUtils {
 		return false;
 	}

+	/**
+	 * 判断 sourceList中的所有元素是否都在targetList中存在
+	 * @param sourceList 源列表，要检查的元素列表
+	 * @param targetList 目标列表，用于匹配的列表
+	 * @return 如果sourceList中的所有元素都在targetList中存在则返回true，否则返回false
+	 */
+	public static boolean isAllInList(List<String> sourceList, List<String> targetList){
+		if(sourceList == null || sourceList.isEmpty()){
+			return true; // 空列表视为所有元素都存在
+		}
+		if(targetList == null || targetList.isEmpty()){
+			return false; // 目标列表为空，源列表非空时返回false
+		}
+
+		for(String sourceItem: sourceList){
+			boolean found = false;
+			for(String targetItem: targetList){
+				if(sourceItem.equals(targetItem)){
+					found = true;
+					break;
+				}
+			}
+			if(!found){
+				return false; // 有任何一个元素不在目标列表中，返回false
+			}
+		}
+		return true; // 所有元素都找到了
+	}
+	
 	/**
 	 * 计算文件大小转成MB
 	 * @param uploadCount
@@ -1168,5 +1199,37 @@ public class oConvertUtils {
 	public static boolean isEffectiveTenant(String tenantId) {
 		return MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL && isNotEmpty(tenantId) && !("0").equals(tenantId);
 	}
+
+    /**
+     * 复制源对象的非空属性到目标对象（同名属性）
+     * 
+     * @param source 源对象（页面）
+     * @param target 目标对象（数据库实体）
+     */
+    public static void copyNonNullFields(Object source, Object target) {
+        if (source == null || target == null) {
+            return;
+        }
+        // 获取源对象的非空属性名数组
+        String[] nullPropertyNames = getNullPropertyNames(source);
+        // 复制：忽略源对象的空属性，仅覆盖目标对象的对应非空属性
+        BeanUtils.copyProperties(source, target, nullPropertyNames);
+    }
+
+    /**
+     * 获取源对象中值为 null 的属性名数组
+     * 
+     * @param source 
+     */
+    private static String[] getNullPropertyNames(Object source) {
+        BeanWrapper beanWrapper = new BeanWrapperImpl(source);
+        //获取类的属性
+        PropertyDescriptor[] propertyDescriptors = beanWrapper.getPropertyDescriptors();
+        // 过滤出值为 null 的属性名
+        return Stream.of(propertyDescriptors)
+                .map(PropertyDescriptor::getName)
+                .filter(name -> beanWrapper.getPropertyValue(name) == null)
+                .toArray(String[]::new);
+    }
 	
 }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/oss/OssBootUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/oss/OssBootUtil.java
@@ -124,9 +124,8 @@ public class OssBootUtil {
            if (!fileDir.endsWith(SymbolConstant.SINGLE_SLASH)) {
                fileDir = fileDir.concat(SymbolConstant.SINGLE_SLASH);
            }
-            //update-begin-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
+            // 代码逻辑说明: 过滤上传文件夹名特殊字符，防止攻击
            fileDir=StrAttackFilter.filter(fileDir);
-            //update-end-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
            fileUrl = fileUrl.append(fileDir + fileName);

            if (oConvertUtils.isNotEmpty(staticDomain) && staticDomain.toLowerCase().startsWith(CommonConstant.STR_HTTP)) {
@@ -263,9 +262,8 @@ public class OssBootUtil {
                newBucket = bucket;
            }
            initOss(endPoint, accessKeyId, accessKeySecret);
-            //update-begin---author:liusq  Date:20220120  for：替换objectName前缀，防止key不一致导致获取不到文件----
+            // 代码逻辑说明: 替换objectName前缀，防止key不一致导致获取不到文件----
            objectName = OssBootUtil.replacePrefix(objectName,bucket);
-            //update-end---author:liusq  Date:20220120  for：替换objectName前缀，防止key不一致导致获取不到文件----
            OSSObject ossObject = ossClient.getObject(newBucket,objectName);
            inputStream = new BufferedInputStream(ossObject.getObjectContent());
        }catch (Exception e){
@@ -293,9 +291,8 @@ public class OssBootUtil {
    public static String getObjectUrl(String bucketName, String objectName, Date expires) {
        initOss(endPoint, accessKeyId, accessKeySecret);
        try{
-            //update-begin---author:liusq  Date:20220120  for：替换objectName前缀，防止key不一致导致获取不到文件----
+            // 代码逻辑说明: 替换objectName前缀，防止key不一致导致获取不到文件----
            objectName = OssBootUtil.replacePrefix(objectName,bucketName);
-            //update-end---author:liusq  Date:20220120  for：替换objectName前缀，防止key不一致导致获取不到文件----
            if(ossClient.doesObjectExist(bucketName,objectName)){
                URL url = ossClient.generatePresignedUrl(bucketName,objectName,expires);
                //log.info("原始url : {}", url.toString());
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/security/AbstractQueryBlackListHandler.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/security/AbstractQueryBlackListHandler.java
@@ -63,7 +63,7 @@ public abstract class AbstractQueryBlackListHandler {
        if(list==null){
            return true;
        }
-        log.info("  获取sql信息 ：{} ", list.toString());
+        log.debug("  获取sql信息 ：{} ", list.toString());
        boolean flag = checkTableAndFieldsName(list);
        if(flag == false){
            return false;
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/AutoPoiDictConfig.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/AutoPoiDictConfig.java
@@ -60,17 +60,15 @@ public class AutoPoiDictConfig implements AutoPoiDictServiceI {


 		for (DictModel t : dictList) {
-			//update-begin---author:liusq   Date:20230517  for：[issues/4917]excel 导出异常---
+			// 代码逻辑说明: [issues/4917]excel 导出异常---
 			if(t!=null && t.getText()!=null && t.getValue()!=null){
-			//update-end---author:liusq     Date:20230517  for：[issues/4917]excel 导出异常---
-				//update-begin---author:scott   Date:20211220  for：[issues/I4MBB3]@Excel dicText字段的值有下划线时，导入功能不能正确解析---
+				// 代码逻辑说明: [issues/I4MBB3]@Excel dicText字段的值有下划线时，导入功能不能正确解析---
 				if(t.getValue().contains(EXCEL_SPLIT_TAG)){
 					String val = t.getValue().replace(EXCEL_SPLIT_TAG,TEMP_EXCEL_SPLIT_TAG);
 					dictReplaces.add(t.getText() + EXCEL_SPLIT_TAG + val);
 				}else{
 					dictReplaces.add(t.getText() + EXCEL_SPLIT_TAG + t.getValue());
 				}
-				//update-end---author:20211220     Date:20211220  for：[issues/I4MBB3]@Excel dicText字段的值有下划线时，导入功能不能正确解析---
 			}
 		}
 		if (dictReplaces != null && dictReplaces.size() != 0) {
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/JeecgBaseConfig.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/JeecgBaseConfig.java
@@ -1,9 +1,11 @@
 package org.jeecg.config;

+import lombok.Getter;
+import lombok.Setter;
+import org.jeecg.config.tencent.JeecgTencent;
 import org.jeecg.config.vo.*;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Role;
 import org.springframework.stereotype.Component;

@@ -74,7 +76,35 @@ public class JeecgBaseConfig {
    /**
     * 百度开放API配置
     */
-    private BaiduApi baiduApi;    
+    private BaiduApi baiduApi;
+
+    /**
+     * minio配置
+     */
+    @Getter
+    @Setter
+    private JeecgMinio minio;
+
+    /**
+     * oss配置
+     */
+    @Getter
+    @Setter
+    private JeecgOSS oss;
+
+    /**
+     * 短信发送方式 aliyun阿里云短信 tencent腾讯云短信
+     */
+    @Getter
+    @Setter
+    private String smsSendType = "aliyun";
+    
+    /**
+     * 腾讯配置
+     */
+    @Getter
+    @Setter
+    private JeecgTencent tencent;

    public String getCustomResourcePrefixPath() {
        return customResourcePrefixPath;
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/Swagger2Config.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/Swagger2Config.java
@@ -95,13 +95,11 @@
 //        List<Parameter> pars = new ArrayList<>();
 //        tokenPar.name(CommonConstant.X_ACCESS_TOKEN).description("token").modelRef(new ModelRef("string")).parameterType("header").required(false).build();
 //        pars.add(tokenPar.build());
-//        //update-begin-author:liusq---date:2024-08-15--for:  开启多租户时，全局参数增加租户id
 //        if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
 //            ParameterBuilder tenantPar = new ParameterBuilder();
 //            tenantPar.name(CommonConstant.TENANT_ID).description("租户ID").modelRef(new ModelRef("string")).parameterType("header").required(false).build();
 //            pars.add(tenantPar.build());
 //        }
-//        //update-end-author:liusq---date:2024-08-15--for: 开启多租户时，全局参数增加租户id
 //
 //        return pars;
 //    }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/Swagger3Config.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/Swagger3Config.java
@@ -12,6 +12,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.jeecg.common.constant.CommonConstant;
 import org.springdoc.core.customizers.OperationCustomizer;
 import org.springdoc.core.filters.GlobalOpenApiMethodFilter;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.PropertySource;
@@ -22,18 +23,24 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;

 /**
 * @author eightmonth
 */
@Slf4j
@Configuration
+@ConditionalOnProperty(prefix = "knife4j", name = "production", havingValue = "false", matchIfMissing = true)
@PropertySource("classpath:config/default-spring-doc.properties")
 public class Swagger3Config implements WebMvcConfigurer {
+
+    // 路径匹配结果缓存，避免重复计算
+    private static final Map<String, Boolean> EXCLUDED_PATHS_CACHE = new ConcurrentHashMap<>();
    // 定义不需要注入安全要求的路径集合
-    Set<String> excludedPaths = new HashSet<>(Arrays.asList(
-            "/sys/randomImage/{key}",
+    private static final Set<String> excludedPaths = new HashSet<>(Arrays.asList(
+            "/sys/randomImage/**",
            "/sys/login",
            "/sys/phoneLogin",
            "/sys/mLogin",
@@ -43,7 +50,20 @@ public class Swagger3Config implements WebMvcConfigurer {
            "/sys/thirdLogin/**",
            "/sys/user/register"
    ));
-
+    // 预处理通配符模式，提高匹配效率
+    private static final Set<String> wildcardPatterns = new HashSet<>();
+    private static final Set<String> exactPatterns = new HashSet<>();
+    static {
+        // 初始化时分离精确匹配和通配符匹配
+        for (String pattern : excludedPaths) {
+            if (pattern.endsWith("/**")) {
+                wildcardPatterns.add(pattern.substring(0, pattern.length() - 3));
+            } else {
+                exactPatterns.add(pattern);
+            }
+        }
+    }
+    
    /**
     *
     * 显示swagger-ui.html文档展示页，还必须注入swagger资源：
@@ -97,19 +117,18 @@ public class Swagger3Config implements WebMvcConfigurer {

        return fullPath.toString();
    }
-    
-    
+
+
    private boolean isExcludedPath(String path) {
-        return excludedPaths.stream()
-                .anyMatch(pattern -> {
-                    if (pattern.endsWith("/**")) {
-                        // 处理通配符匹配
-                        String basePath = pattern.substring(0, pattern.length() - 3);
-                        return path.startsWith(basePath);
-                    }
-                    // 精确匹配
-                    return pattern.equals(path);
-                });
+        // 使用缓存避免重复计算
+        return EXCLUDED_PATHS_CACHE.computeIfAbsent(path, p -> {
+            // 精确匹配
+            if (exactPatterns.contains(p)) {
+                return true;
+            }
+            // 通配符匹配
+            return wildcardPatterns.stream().anyMatch(p::startsWith);
+        });
    }
    
    @Bean
@@ -117,7 +136,7 @@ public class Swagger3Config implements WebMvcConfigurer {
        return new OpenAPI()
                .info(new Info()
                        .title("JeecgBoot 后台服务API接口文档")
-                        .version("3.8.3")
+                        .version("3.9.0")
                        .contact(new Contact().name("北京国炬信息技术有限公司").url("www.jeccg.com").email("jeecgos@163.com"))
                        .description("后台API接口")
                        .termsOfService("NO terms of service")
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/UndertowCustomizer.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/UndertowCustomizer.java
@@ -1,19 +0,0 @@
-//package org.jeecg.config;
-//
-//import io.undertow.server.DefaultByteBufferPool;
-//import io.undertow.websockets.jsr.WebSocketDeploymentInfo;
-//import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory;
-//import org.springframework.boot.web.server.WebServerFactoryCustomizer;
-//import org.springframework.stereotype.Component;
-//
-//@Component
-//public class UndertowCustomizer implements WebServerFactoryCustomizer<UndertowServletWebServerFactory> {
-//    @Override
-//    public void customize(UndertowServletWebServerFactory factory) {
-//        factory.addDeploymentInfoCustomizers(deploymentInfo -> {
-//            WebSocketDeploymentInfo webSocketDeploymentInfo = new WebSocketDeploymentInfo();
-//            webSocketDeploymentInfo.setBuffers(new DefaultByteBufferPool(false, 1024));
-//            deploymentInfo.addServletContextAttribute("io.undertow.websockets.jsr.WebSocketDeploymentInfo", webSocketDeploymentInfo);
-//        });
-//    }
-//}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/WebMvcConfiguration.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/WebMvcConfiguration.java
@@ -142,7 +142,6 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
        return objectMapper;
    }

-    //update-begin---author:chenrui ---date:20240514  for：[QQYUN-9247]系统监控功能优化------------
 //    /**
 //     * SpringBootAdmin的Httptrace不见了
 //     * https://blog.csdn.net/u013810234/article/details/110097201
@@ -151,7 +150,6 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
 //    public InMemoryHttpTraceRepository getInMemoryHttpTrace(){
 //        return new InMemoryHttpTraceRepository();
 //    }
-    //update-end---author:chenrui ---date:20240514  for：[QQYUN-9247]系统监控功能优化------------


    /**
@@ -165,7 +163,7 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
        // 确保在应用启动早期就配置MeterFilter，避免警告
        if (null != meterRegistryPostProcessor && null != prometheusMeterRegistry) {
            meterRegistryPostProcessor.postProcessAfterInitialization(prometheusMeterRegistry, "prometheusMeterRegistry");
-            log.info("PrometheusMeterRegistry配置完成");
+            log.info("PrometheusMeterRegistry 配置完成");
        }
    }

--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisInterceptor.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisInterceptor.java
@@ -129,20 +129,18 @@ public class MybatisInterceptor implements Interceptor {
 			Field[] fields = null;
 			if (parameter instanceof ParamMap) {
 				ParamMap<?> p = (ParamMap<?>) parameter;
-				//update-begin-author:scott date:20190729 for:批量更新报错issues/IZA3Q--
+				// 代码逻辑说明: 批量更新报错issues/IZA3Q--
                String et = "et";
 				if (p.containsKey(et)) {
 					parameter = p.get(et);
 				} else {
 					parameter = p.get("param1");
 				}
-				//update-end-author:scott date:20190729 for:批量更新报错issues/IZA3Q-

-				//update-begin-author:scott date:20190729 for:更新指定字段时报错 issues/#516-
+				// 代码逻辑说明: 更新指定字段时报错 issues/#516-
 				if (parameter == null) {
 					return invocation.proceed();
 				}
-				//update-end-author:scott date:20190729 for:更新指定字段时报错 issues/#516-

 				fields = oConvertUtils.getAllFields(parameter);
 			} else {
@@ -184,7 +182,6 @@ public class MybatisInterceptor implements Interceptor {
 		// TODO Auto-generated method stub
 	}

-	//update-begin--Author:scott  Date:20191213 for：关于使用Quzrtz 开启线程任务， #465
    /**
     * 获取登录用户
     * @return
@@ -199,6 +196,5 @@ public class MybatisInterceptor implements Interceptor {
 		}
 		return sysUser;
 	}
-	//update-end--Author:scott  Date:20191213 for：关于使用Quzrtz 开启线程任务， #465

 }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/satoken/SaTokenConfig.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/satoken/SaTokenConfig.java
@@ -199,7 +199,7 @@ public class SaTokenConfig implements WebMvcConfigurer {
                    // 设置当前线程上下文的租户ID
                    String tenantId = SaHolder.getRequest().getHeader(CommonConstant.TENANT_ID);
                    TenantContext.setTenant(tenantId);
-                    log.info("===【TenantContext 线程设置】=== 请求路径: {}, 租户ID: {}", SaHolder.getRequest().getRequestPath(), tenantId);
+                    log.debug("===【TenantContext 线程设置】=== 请求路径: {}, 租户ID: {}", SaHolder.getRequest().getRequestPath(), tenantId);
                });
    }

--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthConfiguration.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthConfiguration.java
@@ -41,7 +41,7 @@ public class SignAuthConfiguration implements WebMvcConfigurer {
        registry.addInterceptor(signAuthInterceptor()).addPathPatterns(signUrlsArray);
    }

-    //update-begin-author:taoyan date:20220427 for: issues/I53J5E post请求X_SIGN签名拦截校验后报错, request body 为空
+    // 代码逻辑说明: issues/I53J5E post请求X_SIGN签名拦截校验后报错, request body 为空
    @Bean
    public RequestBodyReserveFilter requestBodyReserveFilter(){
        return new RequestBodyReserveFilter();
@@ -66,6 +66,5 @@ public class SignAuthConfiguration implements WebMvcConfigurer {
        registration.addUrlPatterns(signUrlsArray);
        return registration;
    }
-    //update-end-author:taoyan date:20220427 for: issues/I53J5E post请求X_SIGN签名拦截校验后报错, request body 为空

 }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthInterceptor.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthInterceptor.java
@@ -33,7 +33,7 @@ public class SignAuthInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
-        log.info("Sign Interceptor request URI = " + request.getRequestURI());
+        log.debug("Sign Interceptor request URI = " + request.getRequestURI());
        HttpServletRequest requestWrapper = new BodyReaderHttpServletRequestWrapper(request);
        //获取全部参数(包括URL和body上的)
        SortedMap<String, String> allParams = HttpUtils.getAllParams(requestWrapper);
@@ -79,7 +79,7 @@ public class SignAuthInterceptor implements HandlerInterceptor {
            log.debug("Sign 签名通过！Header Sign : {}",headerSign);
            return true;
        } else {
-            log.info("sign allParams: {}", allParams);
+            log.debug("sign allParams: {}", allParams);
            log.error("request URI = " + request.getRequestURI());
            log.error("Sign 签名校验失败！Header Sign : {}",headerSign);
            //校验失败返回前端
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/HttpUtils.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/HttpUtils.java
@@ -41,19 +41,19 @@ public class HttpUtils {
        // 获取URL上最后带逗号的参数变量 sys/dict/getDictItems/sys_user,realname,username
        String pathVariable = request.getRequestURI().substring(request.getRequestURI().lastIndexOf("/") + 1);
        if (pathVariable.contains(SymbolConstant.COMMA)) {
-            log.info(" pathVariable: {}",pathVariable);
+            log.debug(" pathVariable: {}",pathVariable);
            String deString = URLDecoder.decode(pathVariable, "UTF-8");
          
            //https://www.52dianzi.com/category/article/37/565371.html
            if(deString.contains("%")){
                try {
                    deString = URLDecoder.decode(deString, "UTF-8");
-                    log.info("存在%情况下，执行两次解码 — pathVariable decode: {}",deString);
+                    log.debug("存在%情况下，执行两次解码 — pathVariable decode: {}",deString);
                } catch (Exception e) {
                    //e.printStackTrace();
                }
            }
-            log.info(" pathVariable decode: {}",deString);
+            log.debug(" pathVariable decode: {}",deString);
            result.put(SignUtil.X_PATH_VARIABLE, deString);
        }
        // 获取URL上的参数
@@ -91,15 +91,15 @@ public class HttpUtils {
        // 获取URL上最后带逗号的参数变量 sys/dict/getDictItems/sys_user,realname,username
        String pathVariable = url.substring(url.lastIndexOf("/") + 1);
        if (pathVariable.contains(SymbolConstant.COMMA)) {
-            log.info(" pathVariable: {}",pathVariable);
+            log.debug(" pathVariable: {}",pathVariable);
            String deString = URLDecoder.decode(pathVariable, "UTF-8");
           
            //https://www.52dianzi.com/category/article/37/565371.html
            if(deString.contains("%")){
                deString = URLDecoder.decode(deString, "UTF-8");
-                log.info("存在%情况下，执行两次解码 — pathVariable decode: {}",deString);
+                log.debug("存在%情况下，执行两次解码 — pathVariable decode: {}",deString);
            }
-            log.info(" pathVariable decode: {}",deString);
+            log.debug(" pathVariable decode: {}",deString);
            result.put(SignUtil.X_PATH_VARIABLE, deString);
        }
        // 获取URL上的参数
@@ -174,11 +174,10 @@ public class HttpUtils {
        String[] params = param.split("&");
        for (String s : params) {
            int index = s.indexOf("=");
-            //update-begin---author:chenrui ---date:20240222  for：[issues/5879]数据查询传ds=“”造成的异常------------
+            // 代码逻辑说明: [issues/5879]数据查询传ds=“”造成的异常------------
            if (index != -1) {
                result.put(s.substring(0, index), s.substring(index + 1));
            }
-            //update-end---author:chenrui ---date:20240222  for：[issues/5879]数据查询传ds=“”造成的异常------------
        }
        return result;
    }
@@ -202,11 +201,10 @@ public class HttpUtils {
        String[] params = param.split("&");
        for (String s : params) {
            int index = s.indexOf("=");
-            //update-begin---author:chenrui ---date:20240222  for：[issues/5879]数据查询传ds=“”造成的异常------------
+            // 代码逻辑说明: [issues/5879]数据查询传ds=“”造成的异常------------
            if (index != -1) {
                result.put(s.substring(0, index), s.substring(index + 1));
            }
-            //update-end---author:chenrui ---date:20240222  for：[issues/5879]数据查询传ds=“”造成的异常------------
        }
        return result;
    }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/SignUtil.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/SignUtil.java
@@ -34,7 +34,7 @@ public class SignUtil {
        }
        // 把参数加密
        String paramsSign = getParamsSign(params);
-        log.info("Param Sign : {}", paramsSign);
+        log.debug("Param Sign : {}", paramsSign);
        return !StringUtils.isEmpty(paramsSign) && headerSign.equals(paramsSign);
    }

@@ -47,7 +47,7 @@ public class SignUtil {
        //去掉 Url 里的时间戳
        params.remove("_t");
        String paramsJsonStr = JSONObject.toJSONString(params);
-        log.info("Param paramsJsonStr : {}", paramsJsonStr);
+        log.debug("Param paramsJsonStr : {}", paramsJsonStr);
        //设置签名秘钥
        JeecgBaseConfig jeecgBaseConfig = SpringContextUtils.getBean(JeecgBaseConfig.class);
        String signatureSecret = jeecgBaseConfig.getSignatureSecret();
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/tencent/JeecgTencent.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/tencent/JeecgTencent.java
@@ -0,0 +1,38 @@
+package org.jeecg.config.tencent;
+
+import lombok.Data;
+
+/**
+* @Description: 腾讯短信配置
+*
+* @author: wangshuai
+* @date: 2025/10/30 18:22
+*/
+@Data
+public class JeecgTencent {
+
+    /**
+     * 接入域名
+     */
+    private String endpoint;
+    
+    /**
+     * api秘钥id
+     */
+    private String secretId;
+    
+    /**
+     * api秘钥key
+     */
+    private String secretKey;
+    
+    /**
+     * 应用id
+     */
+    private String sdkAppId;
+
+    /**
+     * 地域信息
+     */
+    private String region;
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Firewall.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Firewall.java
@@ -19,11 +19,38 @@ public class Firewall {
     * 低代码模式（dev:开发模式，prod:发布模式——关闭所有在线开发配置能力）
     */
    private String lowCodeMode;
+    /**
+     * 是否开启默认密码登录提醒（true 登录后提示必须修改默认密码）
+     */
+    private Boolean enableDefaultPwdCheck = false;
+
+    /**
+     * 是否开启登录验证码校验（true 开启；false 关闭并跳过验证码逻辑）
+     */
+    private Boolean enableLoginCaptcha = true;
+
 //    /**
 //     * 表字典安全模式（white:白名单——配置了白名单的表才能通过表字典方式访问，black:黑名单——配置了黑名单的表不允许表字典方式访问）
 //     */
 //    private String tableDictMode;

+
+    public Boolean getEnableLoginCaptcha() {
+        return enableLoginCaptcha;
+    }
+
+    public void setEnableLoginCaptcha(Boolean enableLoginCaptcha) {
+        this.enableLoginCaptcha = enableLoginCaptcha;
+    }
+
+    public Boolean getEnableDefaultPwdCheck() {
+        return enableDefaultPwdCheck;
+    }
+
+    public void setEnableDefaultPwdCheck(Boolean enableDefaultPwdCheck) {
+        this.enableDefaultPwdCheck = enableDefaultPwdCheck;
+    }
+
    public Boolean getDataSourceSafe() {
        return dataSourceSafe;
    }
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgMinio.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgMinio.java
@@ -0,0 +1,11 @@
+package org.jeecg.config.vo;
+
+import lombok.Data;
+
+@Data
+public class JeecgMinio {
+
+    private String minio_url;
+    private String bucketName;
+
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgOSS.java
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgOSS.java
@@ -0,0 +1,11 @@
+package org.jeecg.config.vo;
+
+import lombok.Data;
+
+@Data
+public class JeecgOSS {
+
+    private String endpoint;
+    private String bucketName;
+
+}
--- a/jeecg-boot/jeecg-boot-base-core/src/main/resources/META-INF/spring/org.springframework.boot.SpringApplicationRunListeners
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/resources/META-INF/spring/org.springframework.boot.SpringApplicationRunListeners
@@ -0,0 +1 @@
+org.jeecg.config.DruidWallConfigRegister
--- a/jeecg-boot/jeecg-boot-base-core/src/main/resources/static/favicon.ico
+++ b/jeecg-boot/jeecg-boot-base-core/src/main/resources/static/favicon.ico
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/pom.xml
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/pom.xml
@@ -6,7 +6,7 @@
    <parent>
        <groupId>org.jeecgframework.boot3</groupId>
        <artifactId>jeecg-boot-module</artifactId>
-        <version>3.8.3</version>
+        <version>3.9.0</version>
    </parent>

    <artifactId>jeecg-boot-module-airag</artifactId>
@@ -31,6 +31,8 @@
    </repositories>

    <properties>
+        <kotlin.version>2.2.0</kotlin.version>
+        <liteflow.version>2.15.0</liteflow.version>
        <apache-tika.version>2.9.1</apache-tika.version>
    </properties>

@@ -73,10 +75,24 @@
        <dependency>
            <groupId>org.jeecgframework.boot3</groupId>
            <artifactId>jeecg-aiflow</artifactId>
-            <version>3.8.3.1</version>
+            <version>3.9.0.1</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-io</groupId>
+                    <artifactId>commons-io</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>commons-beanutils</groupId>
+                    <artifactId>commons-beanutils</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>com.yomahub</groupId>
+                    <artifactId>liteflow-script-python</artifactId>
+                </exclusion>
+            </exclusions>
        </dependency>

-        <!-- beigin 这两个依赖太多每个包50M左右，如果你发布需要使用，请把<scope>provided</scope>删掉 -->
+        <!-- begin 注意：这几个依赖体积较大，每个约50MB。若发布时需要使用，请将 <scope>provided</scope> 删除 -->
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-scripting-jsr223</artifactId>
@@ -89,7 +105,14 @@
            <version>${liteflow.version}</version>
            <scope>provided</scope>
        </dependency>
-        <!-- end 这两个依赖太多每个包50M左右，如果你发布需要使用，请把<scope>provided</scope>删掉 -->
+        <dependency>
+            <groupId>com.yomahub</groupId>
+            <artifactId>liteflow-script-python</artifactId>
+            <version>${liteflow.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- end 注意：这几个依赖体积较大，每个约50MB。若发布时需要使用，请将 <scope>provided</scope> 删除 -->
+
        <!-- aiflow 脚本依赖 -->
        <dependency>
            <groupId>com.yomahub</groupId>
@@ -122,7 +145,7 @@
            </exclusions>
        </dependency>
        <!-- aiflow 脚本依赖 -->
-        
+
        <!-- langChain4j model support -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
@@ -164,6 +187,10 @@
                </exclusion>
            </exclusions>
        </dependency>
+        <dependency>
+            <groupId>dev.langchain4j</groupId>
+            <artifactId>langchain4j-anthropic</artifactId>
+        </dependency>
        <!-- langChain4j vextor support -->
        <dependency>
            <groupId>org.jeecgframework</groupId>
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/consts/AiAppConsts.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/consts/AiAppConsts.java
@@ -38,4 +38,10 @@ public class AiAppConsts {
     */
    public static final String APP_TYPE_CHAT_FLOW = "chatFLow";

+    /**
+     * 应用元数据:流程输入参数
+     * for [issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程
+     */
+    public static final String APP_METADATA_FLOW_INPUTS = "flowInputs";
+
 }
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/entity/AiragApp.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/entity/AiragApp.java
@@ -167,6 +167,12 @@ public class AiragApp implements Serializable {
    @Schema(description = "元数据")
    private java.lang.String metadata;

+    /**
+     * 插件 [{pluginId: '123213', pluginName: 'xxxx', category: 'mcp'}]
+     */
+    @Schema(description = "插件")
+    private java.lang.String plugins;
+
    /**
     * 知识库ids
     */
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/service/impl/AiragChatServiceImpl.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/service/impl/AiragChatServiceImpl.java
@@ -1,10 +1,13 @@
 package org.jeecg.modules.airag.app.service.impl;

+import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
+import dev.langchain4j.agent.tool.ToolExecutionRequest;
 import dev.langchain4j.data.image.Image;
 import dev.langchain4j.data.message.*;
 import dev.langchain4j.model.output.FinishReason;
 import dev.langchain4j.service.TokenStream;
+import jakarta.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.exception.JeecgBootBizTipException;
@@ -23,16 +26,19 @@ import org.jeecg.modules.airag.common.consts.AiragConsts;
 import org.jeecg.modules.airag.common.handler.AIChatParams;
 import org.jeecg.modules.airag.common.handler.IAIChatHandler;
 import org.jeecg.modules.airag.common.utils.AiragLocalCache;
+import org.jeecg.modules.airag.common.vo.LlmPlugin;
 import org.jeecg.modules.airag.common.vo.MessageHistory;
 import org.jeecg.modules.airag.common.vo.event.EventData;
 import org.jeecg.modules.airag.common.vo.event.EventFlowData;
 import org.jeecg.modules.airag.common.vo.event.EventMessageData;
 import org.jeecg.modules.airag.flow.consts.FlowConsts;
+import org.jeecg.modules.airag.flow.entity.AiragFlow;
 import org.jeecg.modules.airag.flow.service.IAiragFlowService;
 import org.jeecg.modules.airag.flow.vo.api.FlowRunParams;
 import org.jeecg.modules.airag.llm.entity.AiragModel;
 import org.jeecg.modules.airag.llm.handler.AIChatHandler;
 import org.jeecg.modules.airag.llm.handler.JeecgToolsProvider;
+import org.jeecg.modules.airag.llm.mapper.AiragModelMapper;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.BoundValueOperations;
@@ -40,7 +46,6 @@ import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

-import jakarta.servlet.http.HttpServletRequest;
 import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.*;
@@ -78,6 +83,9 @@ public class AiragChatServiceImpl implements IAiragChatService {
    @Autowired
    JeecgToolsProvider jeecgToolsProvider;

+    @Autowired
+    AiragModelMapper airagModelMapper;
+
    /**
     * 重新接收消息
     */
@@ -102,6 +110,12 @@ public class AiragChatServiceImpl implements IAiragChatService {
        if (oConvertUtils.isEmpty(chatConversation.getTitle())) {
            chatConversation.setTitle(userMessage.length() > 5 ? userMessage.substring(0, 5) : userMessage);
        }
+        //update-begin---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        // 保存工作流入参配置（如果有）
+        if (oConvertUtils.isObjectNotEmpty(chatSendParams.getFlowInputs())) {
+            chatConversation.setFlowInputs(chatSendParams.getFlowInputs());
+        }
+        //update-end---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
        // 发送消息
        return doChat(chatConversation, topicId, chatSendParams);
    }
@@ -117,6 +131,12 @@ public class AiragChatServiceImpl implements IAiragChatService {
        AiragApp app = appDebugParams.getApp();
        app.setId("__DEBUG_APP");
        ChatConversation chatConversation = getOrCreateChatConversation(app, topicId);
+        //update-begin---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        // 保存工作流入参配置（如果有）
+        if (oConvertUtils.isObjectNotEmpty(appDebugParams.getFlowInputs())) {
+            chatConversation.setFlowInputs(appDebugParams.getFlowInputs());
+        }
+        //update-end---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
        // 发送消息
        SseEmitter emitter = doChat(chatConversation, topicId, appDebugParams);
        //保存会话
@@ -237,7 +257,33 @@ public class AiragChatServiceImpl implements IAiragChatService {
        if (oConvertUtils.isObjectEmpty(chatConversation)) {
            return Result.ok(Collections.emptyList());
        }
-        return Result.ok(chatConversation.getMessages());
+        //update-begin---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        // 返回消息列表和会话设置信息
+        Map<String, Object> result = new HashMap<>();
+        // 过滤掉工具调用相关的消息（前端不需要展示）
+        List<MessageHistory> messages = chatConversation.getMessages();
+        if (oConvertUtils.isObjectNotEmpty(messages)) {
+            messages = messages.stream()
+                    .filter(msg -> !AiragConsts.MESSAGE_ROLE_TOOL.equals(msg.getRole()))
+                    .map(msg -> {
+                        // 克隆消息对象，移除工具执行请求信息（前端不需要）
+                        MessageHistory displayMsg = MessageHistory.builder()
+                                .conversationId(msg.getConversationId())
+                                .topicId(msg.getTopicId())
+                                .role(msg.getRole())
+                                .content(msg.getContent())
+                                .images(msg.getImages())
+                                .datetime(msg.getDatetime())
+                                .build();
+                        // 不设置toolExecutionRequests和toolExecutionResult
+                        return displayMsg;
+                    })
+                    .collect(Collectors.toList());
+        }
+        result.put("messages", messages);
+        result.put("flowInputs", chatConversation.getFlowInputs());
+        return Result.ok(result);
+        //update-end---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
    }

    @Override
@@ -258,6 +304,51 @@ public class AiragChatServiceImpl implements IAiragChatService {
    @Override
    public Result<?> initChat(String appId) {
        AiragApp app = airagAppMapper.getByIdIgnoreTenant(appId);
+        //update-begin---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        if(AiAppConsts.APP_TYPE_CHAT_FLOW.equalsIgnoreCase(app.getType())) {
+            AiragFlow flow = airagFlowService.getById(app.getFlowId());
+            String flowMetadata = flow.getMetadata();
+            if(oConvertUtils.isNotEmpty(flowMetadata)) {
+                JSONObject flowMetadataJson = JSONObject.parseObject(flowMetadata);
+                JSONArray flowMetadataInputs = flowMetadataJson.getJSONArray(FlowConsts.FLOW_METADATA_INPUTS);
+                if(oConvertUtils.isObjectNotEmpty(flowMetadataInputs)) {
+                    String appMetadataStr = app.getMetadata();
+                    JSONObject appMetadataJson;
+                    if(oConvertUtils.isEmpty(appMetadataStr)){
+                        appMetadataJson = new JSONObject();
+                    } else {
+                        appMetadataJson = JSONObject.parseObject(appMetadataStr);
+                    }
+                    appMetadataJson.put(AiAppConsts.APP_METADATA_FLOW_INPUTS, flowMetadataInputs);
+                    app.setMetadata(appMetadataJson.toJSONString());
+                }
+            }
+        }
+        //update-end---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        
+        //update-begin---author:chenrui ---date:202501XX  for：在initChat接口中返回模型供应商信息，避免前端多次调用模型查询接口------------
+        // 如果应用有模型ID，查询模型信息并将供应商、类型、名称等信息添加到metadata中
+        if (oConvertUtils.isNotEmpty(app.getModelId())) {
+            AiragModel model = airagModelMapper.getByIdIgnoreTenant(app.getModelId());
+            if (model != null) {
+                String appMetadataStr = app.getMetadata();
+                JSONObject appMetadataJson;
+                if(oConvertUtils.isEmpty(appMetadataStr)){
+                    appMetadataJson = new JSONObject();
+                } else {
+                    appMetadataJson = JSONObject.parseObject(appMetadataStr);
+                }
+                // 将模型信息添加到metadata中
+                JSONObject modelInfo = new JSONObject();
+                modelInfo.put("provider", model.getProvider());
+                modelInfo.put("modelType", model.getModelType());
+                modelInfo.put("modelName", model.getModelName());
+                appMetadataJson.put("modelInfo", modelInfo);
+                app.setMetadata(appMetadataJson.toJSONString());
+            }
+        }
+        //update-end---author:chenrui ---date:202501XX  for：在initChat接口中返回模型供应商信息，避免前端多次调用模型查询接口------------
+        
        return Result.ok(app);
    }

@@ -541,7 +632,30 @@ public class AiragChatServiceImpl implements IAiragChatService {
                        chatMessage = UserMessage.from(contents);
                        break;
                    case AiragConsts.MESSAGE_ROLE_AI:
-                        chatMessage = new AiMessage(history.getContent());
+                        // 重建AI消息，包括工具执行请求
+                        if (oConvertUtils.isObjectNotEmpty(history.getToolExecutionRequests())) {
+                            // 有工具执行请求，重建带工具调用的AiMessage
+                            List<ToolExecutionRequest> toolRequests = history.getToolExecutionRequests().stream()
+                                    .map(toolReq -> ToolExecutionRequest.builder()
+                                            .id(toolReq.getId())
+                                            .name(toolReq.getName())
+                                            .arguments(toolReq.getArguments())
+                                            .build())
+                                    .collect(Collectors.toList());
+                            chatMessage = AiMessage.from(history.getContent(), toolRequests);
+                        } else {
+                            chatMessage = new AiMessage(history.getContent());
+                        }
+                        break;
+                    case AiragConsts.MESSAGE_ROLE_TOOL:
+                        // 重建工具执行结果消息
+                        // 需要重建ToolExecutionRequest，第一个参数是request对象，第二个参数是result字符串
+                        ToolExecutionRequest recreatedRequest = ToolExecutionRequest.builder()
+                                .id(history.getContent()) // content字段存储的是工具执行的id
+                                .name("unknown") // 工具名称在重建时不重要，因为主要用于AI理解结果
+                                .arguments("{}")
+                                .build();
+                        chatMessage = ToolExecutionResultMessage.from(recreatedRequest, history.getToolExecutionResult());
                        break;
                }
                if (null == chatMessage) {
@@ -599,7 +713,26 @@ public class AiragChatServiceImpl implements IAiragChatService {
            historyMessage.setImages(images);
        } else if (message.type().equals(ChatMessageType.AI)) {
            historyMessage.setRole(AiragConsts.MESSAGE_ROLE_AI);
-            historyMessage.setContent(((AiMessage) message).text());
+            AiMessage aiMessage = (AiMessage) message;
+            historyMessage.setContent(aiMessage.text());
+            // 处理工具执行请求
+            if (oConvertUtils.isObjectNotEmpty(aiMessage.toolExecutionRequests())) {
+                List<MessageHistory.ToolExecutionRequestHistory> toolRequests = new ArrayList<>();
+                for (ToolExecutionRequest request : aiMessage.toolExecutionRequests()) {
+                    toolRequests.add(MessageHistory.ToolExecutionRequestHistory.from(
+                            request.id(),
+                            request.name(),
+                            request.arguments()
+                    ));
+                }
+                historyMessage.setToolExecutionRequests(toolRequests);
+            }
+        } else if (message.type().equals(ChatMessageType.TOOL_EXECUTION_RESULT)) {
+            // 工具执行结果消息
+            historyMessage.setRole(AiragConsts.MESSAGE_ROLE_TOOL);
+            ToolExecutionResultMessage toolMessage = (ToolExecutionResultMessage) message;
+            historyMessage.setContent(toolMessage.id());
+            historyMessage.setToolExecutionResult(toolMessage.text());
        }
        histories.add(historyMessage);
        chatConversation.setMessages(histories);
@@ -648,11 +781,15 @@ public class AiragChatServiceImpl implements IAiragChatService {
                    sendWithFlow(requestId, aiApp.getFlowId(), chatConversation, topicId, messages, sendParams);
                } else {
                    // AI应用-聊天助手(ChatAssistant):从应用信息组装模型和提示词
-                    sendWithAppChat(requestId, messages, chatConversation, topicId);
+                    sendWithAppChat(requestId, messages, chatConversation, topicId, sendParams);
                }
            } else {
                // 发消息
-                sendWithDefault(requestId, chatConversation, topicId, null, messages, null);
+                AIChatParams aiChatParams = new AIChatParams();
+                if (oConvertUtils.isObjectNotEmpty(sendParams.getEnableSearch())) {
+                    aiChatParams.setEnableSearch(sendParams.getEnableSearch());
+                }
+                sendWithDefault(requestId, chatConversation, topicId, null, messages, aiChatParams);
            }
            // 发送就绪消息
            EventData eventRequestId = new EventData(requestId, null, EventData.EVENT_INIT_REQUEST_ID, chatConversation.getId(), topicId);
@@ -698,6 +835,14 @@ public class AiragChatServiceImpl implements IAiragChatService {
        flowInputParams.put(FlowConsts.FLOW_INPUT_PARAM_HISTORY, histories);
        flowInputParams.put(FlowConsts.FLOW_INPUT_PARAM_QUESTION, sendParams.getContent());
        flowInputParams.put(FlowConsts.FLOW_INPUT_PARAM_IMAGES, sendParams.getImages());
+        
+        //update-begin---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        // 添加工作流的额外参数（从conversation的flowInputs中读取）
+        if (oConvertUtils.isObjectNotEmpty(chatConversation.getFlowInputs())) {
+            flowInputParams.putAll(chatConversation.getFlowInputs());
+        }
+        //update-end---author:chenrui ---date:20251106  for：[issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程------------
+        
        flowRunParams.setInputParams(flowInputParams);
        HttpServletRequest httpRequest = SpringContextUtils.getHttpServletRequest();
        flowRunParams.setHttpRequest(httpRequest);
@@ -762,11 +907,12 @@ public class AiragChatServiceImpl implements IAiragChatService {
     * @param messages
     * @param chatConversation
     * @param topicId
+     * @param sendParams
     * @return
     * @author chenrui
     * @date 2025/2/28 10:41
     */
-    private void sendWithAppChat(String requestId, List<ChatMessage> messages, ChatConversation chatConversation, String topicId) {
+    private void sendWithAppChat(String requestId, List<ChatMessage> messages, ChatConversation chatConversation, String topicId, ChatSendParams sendParams) {
        AiragApp aiApp = chatConversation.getApp();
        String modelId = aiApp.getModelId();
        AssertUtils.assertNotEmpty("请先选择模型", modelId);
@@ -799,6 +945,31 @@ public class AiragChatServiceImpl implements IAiragChatService {
                }
            }
        }
+
+        // AI应用插件（支持MCP和自定义插件）
+        String plugins = aiApp.getPlugins();
+        if (oConvertUtils.isNotEmpty(plugins)) {
+            List<String> pluginIds = new ArrayList<>();
+            JSONArray pluginArray = JSONArray.parseArray(plugins);
+            pluginArray.stream().filter(Objects::nonNull)
+                    .map(o -> JSONObject.parseObject(o.toString(), LlmPlugin.class))
+                    .forEach(plugin -> {
+                        // 支持MCP和插件类型
+                        if (plugin.getCategory().equals(AiragConsts.PLUGIN_CATEGORY_MCP) 
+                                || plugin.getCategory().equals(AiragConsts.PLUGIN_CATEGORY_PLUGIN)) {
+                            pluginIds.add(plugin.getPluginId());
+                        }
+                    });
+            if (oConvertUtils.isNotEmpty(pluginIds)) {
+                aiChatParams.setPluginIds(pluginIds);
+            }
+        }
+
+        // 设置网络搜索参数（如果前端传递了）
+        if (sendParams != null && oConvertUtils.isObjectNotEmpty(sendParams.getEnableSearch())) {
+            aiChatParams.setEnableSearch(sendParams.getEnableSearch());
+        }
+
        // 打印流程耗时日志
        printChatDuration(requestId, "构造应用自定义参数完成");
        // 发消息
@@ -828,6 +999,8 @@ public class AiragChatServiceImpl implements IAiragChatService {
        }
        aiChatParams.setKnowIds(chatConversation.getApp().getKnowIds());
        aiChatParams.setMaxMsgNumber(oConvertUtils.getInt(chatConversation.getApp().getMsgNum(), 5));
+        aiChatParams.setCurrentHttpRequest(SpringContextUtils.getHttpServletRequest());
+        aiChatParams.setReturnThinking(true);
        HttpServletRequest httpRequest = SpringContextUtils.getHttpServletRequest();
        TokenStream chatStream;
        try {
@@ -861,20 +1034,13 @@ public class AiragChatServiceImpl implements IAiragChatService {
        AtomicBoolean isThinking = new AtomicBoolean(false);
        // ai聊天响应逻辑
        chatStream.onPartialResponse((String resMessage) -> {
-            // 兼容推理模型
-            if ("<think>".equals(resMessage)) {
-                isThinking.set(true);
-                resMessage = "> ";
-            }
-            if ("</think>".equals(resMessage)) {
+            //update-begin---author:wangshuai---date:2025-11-07---for:[issues/8506]/[issues/8260]/[issues/8166]新增推理模型的支持---
+            if(isThinking.get()){
+                //思考过程结束
+                this.sendThinkEnd(requestId, chatConversation, topicId);
                isThinking.set(false);
-                resMessage = "\n\n";
-            }
-            if (isThinking.get()) {
-                if (null != resMessage && resMessage.contains("\n")) {
-                    resMessage = "\n> ";
-                }
            }
+            //update-end---author:wangshuai---date:2025-11-07---for:[issues/8506]/[issues/8260]/[issues/8166]新增推理模型的支持---
            EventData eventData = new EventData(requestId, null, EventData.EVENT_MESSAGE, chatConversation.getId(), topicId);
            EventMessageData messageEventData = EventMessageData.builder().message(resMessage).build();
            eventData.setData(messageEventData);
@@ -886,6 +1052,48 @@ public class AiragChatServiceImpl implements IAiragChatService {
                return;
            }
            sendMessage2Client(emitter, eventData);
+        }).onToolExecuted((toolExecution) -> {
+            // 打印工具执行结果
+            log.debug("[AI应用]工具执行结果: toolName={}, toolId={}, result={}",
+                    toolExecution.request().name(), 
+                    toolExecution.request().id(), 
+                    toolExecution.result());
+            // 将工具执行结果存储到消息历史中
+            ToolExecutionResultMessage toolResultMessage = ToolExecutionResultMessage.from(
+                    toolExecution.request(),
+                    toolExecution.result()
+            );
+            appendMessage(messages, toolResultMessage, chatConversation, topicId);
+        }).onIntermediateResponse((chatResponse) -> {
+            // 中间响应：包含tool_calls的AI消息
+            AiMessage aiMessage = chatResponse.aiMessage();
+            if (aiMessage != null && oConvertUtils.isObjectNotEmpty(aiMessage.toolExecutionRequests())) {
+                // 保存包含工具调用请求的AI消息
+                log.debug("[AI应用]保存包含工具调用的AI消息: toolCallsCount={}", aiMessage.toolExecutionRequests().size());
+                appendMessage(messages, aiMessage, chatConversation, topicId);
+            }
+        }).onPartialThinking((partialThinking) -> {
+            try {
+                if (oConvertUtils.isEmpty(partialThinking)) {
+                    return;
+                }
+                isThinking.set(true);
+                String text = partialThinking.text();
+                // 构造事件数据（EVENT_THINKING 以便前端统一处理）
+                EventData thinkingEvent = new EventData(requestId, null, EventData.EVENT_THINKING, chatConversation.getId(), topicId);
+                thinkingEvent.setData(EventMessageData.builder().message(text).build());
+                thinkingEvent.setRequestId(requestId);
+                // 获取当前缓存的 emitter
+                SseEmitter emitter = AiragLocalCache.get(AiragConsts.CACHE_TYPE_SSE, requestId);
+                if (null == emitter) {
+                    log.warn("[AI应用]思考过程发送失败，SSE 已关闭: {}", requestId);
+                    return;
+                }
+                // 发送给客户端并缓存历史
+                sendMessage2Client(emitter, thinkingEvent);
+            } catch (Exception e) {
+                log.error("发送思考过程异常", e);
+            }
        }).onCompleteResponse((responseMessage) -> {
            // 打印流程耗时日志
            printChatDuration(requestId, "LLM输出消息完成");
@@ -907,9 +1115,6 @@ public class AiragChatServiceImpl implements IAiragChatService {
                // 保存会话
                saveChatConversation(chatConversation, false, httpRequest);
                closeSSE(emitter, eventData);
-            } else if (FinishReason.TOOL_EXECUTION.equals(finishReason)) {
-                // 需要执行工具
-                // TODO author: chenrui for: date:2025/3/7
            } else if (FinishReason.LENGTH.equals(finishReason)) {
                // 上下文长度超过限制
                log.error("调用模型异常:上下文长度超过限制:{}", responseMessage.tokenUsage());
@@ -966,6 +1171,26 @@ public class AiragChatServiceImpl implements IAiragChatService {
        }).start();
    }

+    /**
+     * 发送思考过程结束
+     * 
+     * @param requestId
+     * @param chatConversation
+     * @param topicId
+     */
+    private void sendThinkEnd(String requestId, ChatConversation chatConversation, String topicId) {
+        EventData eventData = new EventData(requestId, null, EventData.EVENT_THINKING_END, chatConversation.getId(), topicId);
+        EventMessageData messageEventData = EventMessageData.builder().message("").build();
+        eventData.setData(messageEventData);
+        eventData.setRequestId(requestId);
+        SseEmitter emitter = AiragLocalCache.get(AiragConsts.CACHE_TYPE_SSE, requestId);
+        if (null == emitter) {
+            log.warn("[AI应用]接收LLM返回会话已关闭");
+            return;
+        }
+        sendMessage2Client(emitter, eventData);
+    }
+
    /**
     * 发送消息到客户端
     *
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/vo/ChatConversation.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/vo/ChatConversation.java
@@ -6,6 +6,7 @@ import org.jeecg.modules.airag.common.vo.MessageHistory;

 import java.util.Date;
 import java.util.List;
+import java.util.Map;

 /**
 * @Description: 聊天会话
@@ -39,4 +40,11 @@ public class ChatConversation {
     * 创建时间
     */
    private Date createTime;
+
+    /**
+     * 流程入参配置（工作流的额外参数设置）
+     * key: 参数field, value: 参数值
+     * for [issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程
+     */
+    private Map<String, Object> flowInputs;
 }
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/vo/ChatSendParams.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/vo/ChatSendParams.java
@@ -4,6 +4,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.util.List;
+import java.util.Map;

 /**
 * @Description: 发送消息的入参
@@ -46,4 +47,16 @@ public class ChatSendParams {
     */
    private List<String> images;

+    /**
+     * 工作流额外入参配置
+     * key: 参数field, value: 参数值
+     * for [issues/8545]新建AI应用的时候只能选择没有自定义参数的AI流程
+     */
+    private Map<String, Object> flowInputs;
+
+    /**
+     * 是否开启网络搜索（仅千问模型支持）
+     */
+    private Boolean enableSearch;
+
 }
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/consts/LLMConsts.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/consts/LLMConsts.java
@@ -80,4 +80,9 @@ public class LLMConsts {
     */
    public static final String KNOWLEDGE_DOC_METADATA_SOURCES_PATH = "sourcesPath";

+    /**
+     * DEEPSEEK推理模型
+     */
+    public static final String DEEPSEEK_REASONER = "deepseek-reasoner";
+
 }
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/controller/AiragMcpController.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/controller/AiragMcpController.java
@@ -0,0 +1,191 @@
+package org.jeecg.modules.airag.llm.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.jeecg.common.api.vo.Result;
+import org.jeecg.common.system.base.controller.JeecgController;
+import org.jeecg.common.system.query.QueryGenerator;
+import org.jeecg.modules.airag.llm.entity.AiragMcp;
+import org.jeecg.modules.airag.llm.service.IAiragMcpService;
+import org.jeecg.modules.airag.llm.dto.SaveToolsDTO;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.ModelAndView;
+
+/**
+ * @Description: MCP
+ * @Author: jeecg-boot
+ * @Date: 2025-10-20
+ * @Version: V1.0
+ */
+@Tag(name = "MCP")
+@RestController("airagMcpController")
+@RequestMapping("/airag/airagMcp")
+@Slf4j
+public class AiragMcpController extends JeecgController<AiragMcp, IAiragMcpService> {
+    @Autowired
+    private IAiragMcpService airagMcpService;
+
+    /**
+     * 分页列表查询
+     *
+     * @param airagMcp
+     * @param pageNo
+     * @param pageSize
+     * @param req
+     * @return
+     */
+    @Operation(summary = "MCP-分页列表查询")
+    @GetMapping(value = "/list")
+    public Result<IPage<AiragMcp>> queryPageList(AiragMcp airagMcp,
+                                                 @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
+                                                 @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
+                                                 HttpServletRequest req) {
+
+        QueryWrapper<AiragMcp> queryWrapper = QueryGenerator.initQueryWrapper(airagMcp, req.getParameterMap());
+        Page<AiragMcp> page = new Page<AiragMcp>(pageNo, pageSize);
+        IPage<AiragMcp> pageList = airagMcpService.page(page, queryWrapper);
+        return Result.OK(pageList);
+    }
+
+    /**
+     * 保存
+     *
+     * @param airagMcp
+     * @return
+     */
+    @Operation(summary = "MCP-保存")
+    @PostMapping(value = "/save")
+    public Result<String> save(@RequestBody AiragMcp airagMcp) {
+        return airagMcpService.edit(airagMcp);
+    }
+
+
+
+    /**
+     * 保存并同步
+     *
+     * @param airagMcp
+     * @return
+     * @author chenrui
+     * @date 2025/10/21 10:54
+     */
+    @Operation(summary = "MCP-保存并同步")
+    @PostMapping(value = "/saveAndSync")
+    public Result<?> saveAndSync(@RequestBody AiragMcp airagMcp) {
+        Result<String> saveResult = airagMcpService.edit(airagMcp);
+        if (!saveResult.isSuccess()) {
+            return saveResult;
+        }
+        String id = airagMcp.getId();
+        if (id == null || id.trim().isEmpty()) {
+            return Result.error("保存失败");
+        }
+        return airagMcpService.sync(id);
+    }
+
+    /**
+     * 同步MCP信息
+     *
+     * @param id
+     * @return
+     * @author chenrui
+     * @date 2025/10/20 20:09
+     */
+    @Operation(summary = "MCP-同步MCP信息")
+    @PostMapping(value = "/sync/{id}")
+    public Result<?> sync(@PathVariable(name = "id", required = true) String id) {
+        return airagMcpService.sync(id);
+    }
+
+
+    /**
+     * 启用/禁用MCP信息
+     *
+     * @param action 启用：enable，禁用：disable
+     * @return
+     * @author chenrui
+     * @date 2025/10/20 20:13
+     */
+    @Operation(summary = "MCP-启用/禁用MCP信息")
+    @PostMapping(value = "/status/{id}/{action}")
+    public Result<?> toggleStatus(@PathVariable(name = "id",required = true) String id,
+                                  @PathVariable(name = "action", required = true) String action) {
+        return airagMcpService.toggleStatus(id,action);
+    }
+
+    /**
+     * 保存插件工具
+     * for [QQYUN-12453]【AI】支持插件
+     * @param dto 包含插件ID和工具列表JSON字符串的DTO
+     * @return
+     * @author chenrui
+     * @date 2025/10/30
+     */
+    @Operation(summary = "MCP-保存插件工具")
+    @PostMapping(value = "/saveTools")
+    public Result<String> saveTools(@RequestBody SaveToolsDTO dto) {
+        return airagMcpService.saveTools(dto.getId(), dto.getTools());
+    }
+
+    /**
+     * 通过id删除
+     *
+     * @param id
+     * @return
+     */
+    @Operation(summary = "MCP-通过id删除")
+    @DeleteMapping(value = "/delete")
+    public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
+        airagMcpService.removeById(id);
+        return Result.OK("删除成功!");
+    }
+
+    /**
+     * 通过id查询
+     *
+     * @param id
+     * @return
+     */
+    @Operation(summary = "MCP-通过id查询")
+    @GetMapping(value = "/queryById")
+    public Result<AiragMcp> queryById(@RequestParam(name = "id", required = true) String id) {
+        AiragMcp airagMcp = airagMcpService.getById(id);
+        if (airagMcp == null) {
+            return Result.error("未找到对应数据");
+        }
+        return Result.OK(airagMcp);
+    }
+
+    /**
+     * 导出excel
+     *
+     * @param request
+     * @param airagMcp
+     */
+//    @SaCheckPermission("llm:airag_mcp:exportXls")
+    @RequestMapping(value = "/exportXls")
+    public ModelAndView exportXls(HttpServletRequest request, AiragMcp airagMcp) {
+        return super.exportXls(request, airagMcp, AiragMcp.class, "MCP");
+    }
+
+    /**
+     * 通过excel导入数据
+     *
+     * @param request
+     * @param response
+     * @return
+     */
+//    @SaCheckPermission("llm:airag_mcp:importExcel")
+    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
+    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
+        return super.importExcel(request, response, AiragMcp.class);
+    }
+
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/controller/AiragModelController.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/controller/AiragModelController.java
@@ -81,8 +81,9 @@ public class AiragModelController extends JeecgController<AiragModel, IAiragMode
        // 默认未激活
        if(oConvertUtils.isObjectEmpty(airagModel.getActivateFlag())){
            airagModel.setActivateFlag(0);
+        } else {
+            airagModel.setActivateFlag(1);
        }
-        airagModel.setActivateFlag(0);
        airagModelService.save(airagModel);
        return Result.OK("添加成功！");
    }
@@ -178,7 +179,7 @@ public class AiragModelController extends JeecgController<AiragModel, IAiragMode
            }
        }catch (Exception e){
            log.error("测试模型连接失败", e);
-            return Result.error("测试模型连接失败：" + e.getMessage());
+            return Result.error("测试模型连接失败，请检查模型配置是否正确！");
        }
        // 测试成功激活数据
        airagModel.setActivateFlag(1);
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/dto/SaveToolsDTO.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/dto/SaveToolsDTO.java
@@ -0,0 +1,23 @@
+package org.jeecg.modules.airag.llm.dto;
+
+import lombok.Data;
+
+/**
+ * 保存插件工具DTO
+ * fro [QQYUN-12453]【AI】支持插件
+ * @author chenrui
+ * @date 2025/10/30
+ */
+@Data
+public class SaveToolsDTO {
+    /**
+     * 插件ID
+     */
+    private String id;
+
+    /**
+     * 工具列表JSON字符串
+     */
+    private String tools;
+}
+
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/entity/AiragMcp.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/entity/AiragMcp.java
@@ -0,0 +1,138 @@
+package org.jeecg.modules.airag.llm.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+import org.jeecgframework.poi.excel.annotation.Excel;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+
+/**
+ * @Description: MCP
+ * @Author: jeecg-boot
+ * @Date: 2025-10-20
+ * @Version: V1.0
+ */
+@Data
+@TableName("airag_mcp")
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = false)
+@Schema(description = "MCP")
+public class AiragMcp implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * id
+     */
+    @TableId(type = IdType.ASSIGN_ID)
+    @Schema(description = "id")
+    private java.lang.String id;
+    /**
+     * 应用图标
+     */
+    @Excel(name = "应用图标", width = 15)
+    @Schema(description = "应用图标")
+    private java.lang.String icon;
+    /**
+     * 名称
+     */
+    @Excel(name = "名称", width = 15)
+    @Schema(description = "名称")
+    private java.lang.String name;
+    /**
+     * 描述
+     */
+    @Excel(name = "描述", width = 15)
+    @Schema(description = "描述")
+    private java.lang.String descr;
+    /**
+     * 类型（plugin=插件，mcp=MCP）
+     * for [QQYUN-12453]【AI】支持插件
+     */
+    @Excel(name = "类型（plugin=插件，mcp=MCP）", width = 15)
+    @Schema(description = "类型（plugin=插件，mcp=MCP）")
+    private java.lang.String category;
+    /**
+     * mcp类型（sse：sse类型；stdio：标准类型）
+     */
+    @Excel(name = "mcp类型（sse：sse类型；stdio：标准类型）", width = 15)
+    @Schema(description = "mcp类型（sse：sse类型；stdio：标准类型）")
+    private java.lang.String type;
+    /**
+     * 服务端点（SSE类型为URL，stdio类型为命令）
+     */
+    @Excel(name = "服务端点（SSE类型为URL，stdio类型为命令）", width = 15)
+    @Schema(description = "服务端点（SSE类型为URL，stdio类型为命令）")
+    private java.lang.String endpoint;
+    /**
+     * 请求头（sse类型）、环境变量（stdio类型）
+     */
+    @Excel(name = "请求头（sse类型）、环境变量（stdio类型）", width = 15)
+    @Schema(description = "请求头（sse类型）、环境变量（stdio类型）")
+    private java.lang.String headers;
+    /**
+     * 工具列表
+     */
+    @Excel(name = "工具列表", width = 15)
+    @Schema(description = "工具列表")
+    private java.lang.String tools;
+    /**
+     * 状态（enable=启用、disable=禁用）
+     */
+    @Excel(name = "状态（enable=启用、disable=禁用）", width = 15)
+    @Schema(description = "状态（enable=启用、disable=禁用）")
+    private java.lang.String status;
+    /**
+     * 是否同步
+     */
+    @Excel(name = "是否同步", width = 15)
+    @Schema(description = "是否同步")
+    private java.lang.Integer synced;
+    /**
+     * 元数据
+     */
+    @Excel(name = "元数据", width = 15)
+    @Schema(description = "元数据")
+    private java.lang.String metadata;
+    /**
+     * 创建人
+     */
+    @Schema(description = "创建人")
+    private java.lang.String createBy;
+    /**
+     * 创建日期
+     */
+    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @Schema(description = "创建日期")
+    private java.util.Date createTime;
+    /**
+     * 更新人
+     */
+    @Schema(description = "更新人")
+    private java.lang.String updateBy;
+    /**
+     * 更新日期
+     */
+    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @Schema(description = "更新日期")
+    private java.util.Date updateTime;
+    /**
+     * 所属部门
+     */
+    @Schema(description = "所属部门")
+    private java.lang.String sysOrgCode;
+    /**
+     * 租户id
+     */
+    @Excel(name = "租户id", width = 15)
+    @Schema(description = "租户id")
+    private java.lang.String tenantId;
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/handler/AIChatHandler.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/handler/AIChatHandler.java
@@ -1,9 +1,12 @@
 package org.jeecg.modules.airag.llm.handler;

 import com.alibaba.fastjson.JSONObject;
+import dev.langchain4j.agent.tool.ToolSpecification;
 import dev.langchain4j.data.message.*;
+import dev.langchain4j.mcp.McpToolProvider;
 import dev.langchain4j.rag.query.router.QueryRouter;
 import dev.langchain4j.service.TokenStream;
+import dev.langchain4j.service.tool.ToolExecutor;
 import lombok.extern.slf4j.Slf4j;
 import org.jeecg.ai.handler.LLMHandler;
 import org.jeecg.common.exception.JeecgBootException;
@@ -12,7 +15,9 @@ import org.jeecg.common.util.oConvertUtils;
 import org.jeecg.modules.airag.common.handler.AIChatParams;
 import org.jeecg.modules.airag.common.handler.IAIChatHandler;
 import org.jeecg.modules.airag.llm.consts.LLMConsts;
+import org.jeecg.modules.airag.llm.entity.AiragMcp;
 import org.jeecg.modules.airag.llm.entity.AiragModel;
+import org.jeecg.modules.airag.llm.mapper.AiragMcpMapper;
 import org.jeecg.modules.airag.llm.mapper.AiragModelMapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -25,6 +30,7 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.*;
 import java.util.regex.Matcher;
+import java.util.stream.Collectors;

 /**
 * 大模型聊天工具类
@@ -39,6 +45,9 @@ public class AIChatHandler implements IAIChatHandler {
    @Autowired
    AiragModelMapper airagModelMapper;

+    @Autowired
+    AiragMcpMapper airagMcpMapper;
+
    @Autowired
    EmbeddingHandler embeddingHandler;

@@ -105,12 +114,22 @@ public class AIChatHandler implements IAIChatHandler {
            // langchain4j 异常友好提示
            String errMsg = "调用大模型接口失败，详情请查看后台日志。";
            if (oConvertUtils.isNotEmpty(e.getMessage())) {
+                String exceptionMsg = e.getMessage();
+                
+                // 检查是否是工具调用消息序列不完整的异常
+                if (exceptionMsg.contains("messages with role 'tool' must be a response to a preceeding message with 'tool_calls'")) {
+                    errMsg = "消息序列不完整，可能是因为历史消息数量设置过小导致工具调用上下文丢失。建议增加历史消息数量后重试。";
+                    log.error("AI模型调用异常: 工具调用消息序列不完整，建议增加历史消息数量。异常详情: {}", exceptionMsg, e);
+                    throw new JeecgBootException(errMsg);
+                }
+                
                // 根据常见异常关键字做细致翻译
                for (Map.Entry<String, String> entry : MODEL_ERROR_MAP.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    if (errMsg.contains(key)) {
                        errMsg = value;
+                        break;
                    }
                }
            }
@@ -247,6 +266,9 @@ public class AIChatHandler implements IAIChatHandler {
            if (oConvertUtils.isObjectEmpty(params.getTimeout())) {
                params.setTimeout(modelParams.getInteger("timeout"));
            }
+            if (oConvertUtils.isObjectEmpty(params.getEnableSearch())) {
+                params.setEnableSearch(modelParams.getBoolean("enableSearch"));
+            }
        }

        // RAG
@@ -266,9 +288,77 @@ public class AIChatHandler implements IAIChatHandler {
            params.setTimeout(60);
        }

+        //deepseek-reasoner 推理模型不支持插件tool
+        String modelName = airagModel.getModelName();
+        if(!LLMConsts.DEEPSEEK_REASONER.equals(modelName)){
+            // 插件/MCP处理
+            buildPlugins(params);
+        }
+
        return params;
    }

+    /**
+     * 构造插件和MCP工具
+     * for [QQYUN-12453]【AI】支持插件
+     * @param params
+     * @author chenrui
+     * @date 2025/10/31 14:04
+     */
+    private void buildPlugins(AIChatParams params) {
+        List<String> pluginIds = params.getPluginIds();
+
+        if(oConvertUtils.isObjectNotEmpty(pluginIds)){
+            List<McpToolProvider> mcpToolProviders = new ArrayList<>();
+            Map<ToolSpecification, ToolExecutor> pluginTools = new HashMap<>();
+
+            for (String pluginId : pluginIds.stream().distinct().collect(Collectors.toList())) {
+                AiragMcp airagMcp = airagMcpMapper.selectById(pluginId);
+                if (airagMcp == null) {
+                    continue;
+                }
+
+                String category = airagMcp.getCategory();
+                if (oConvertUtils.isEmpty(category)) {
+                    // 兼容旧数据：如果没有category字段，默认为mcp
+                    category = "mcp";
+                }
+
+                if ("mcp".equalsIgnoreCase(category)) {
+                    // MCP类型：构建McpToolProvider
+                    McpToolProvider mcpToolProvider = buildMcpToolProvider(
+                            airagMcp.getName(),
+                            airagMcp.getType(),
+                            airagMcp.getEndpoint(),
+                            airagMcp.getHeaders()
+                    );
+                    if (mcpToolProvider != null) {
+                        mcpToolProviders.add(mcpToolProvider);
+                    }
+                } else if ("plugin".equalsIgnoreCase(category)) {
+                    // 插件类型：构建ToolSpecification和ToolExecutor
+                    Map<ToolSpecification, ToolExecutor> tools = PluginToolBuilder.buildTools(airagMcp, params.getCurrentHttpRequest());
+                    if (tools != null && !tools.isEmpty()) {
+                        pluginTools.putAll(tools);
+                    }
+                }
+            }
+
+            // 设置MCP工具提供者
+            if (!mcpToolProviders.isEmpty()) {
+                params.setMcpToolProviders(mcpToolProviders);
+            }
+
+            // 设置插件工具
+            if (!pluginTools.isEmpty()) {
+                if (params.getTools() == null) {
+                    params.setTools(new HashMap<>());
+                }
+                params.getTools().putAll(pluginTools);
+            }
+        }
+    }
+
    @Override
    public UserMessage buildUserMessage(String content, List<String> images) {
        AssertUtils.assertNotEmpty("请输入消息内容", content);
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/handler/PluginToolBuilder.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/handler/PluginToolBuilder.java
@@ -0,0 +1,540 @@
+package org.jeecg.modules.airag.llm.handler;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import dev.langchain4j.agent.tool.ToolSpecification;
+import dev.langchain4j.model.chat.request.json.JsonObjectSchema;
+import dev.langchain4j.service.tool.ToolExecutor;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.extern.slf4j.Slf4j;
+
+import org.jeecg.common.util.CommonUtils;
+import org.jeecg.common.util.RestUtil;
+import org.jeecg.common.util.TokenUtils;
+import org.jeecg.common.util.oConvertUtils;
+import org.jeecg.modules.airag.llm.entity.AiragMcp;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.HttpClientErrorException;
+
+import java.util.*;
+
+/**
+ * 插件工具构建器
+ * 根据插件配置构建ToolSpecification和ToolExecutor
+ * for [QQYUN-12453]【AI】支持插件
+ *
+ * @author chenrui
+ * @date 2025/10/30
+ */
+@Slf4j
+public class PluginToolBuilder {
+
+    /**
+     * 从插件配置构建工具Map
+     *
+     * @param airagMcp 插件配置
+     * @return Map<ToolSpecification, ToolExecutor>
+     */
+    public static Map<ToolSpecification, ToolExecutor> buildTools(AiragMcp airagMcp, HttpServletRequest currentHttpRequest) {
+        Map<ToolSpecification, ToolExecutor> tools = new HashMap<>();
+        if (airagMcp == null || oConvertUtils.isEmpty(airagMcp.getTools())) {
+            return tools;
+        }
+
+        try {
+            JSONArray toolsArray = JSONArray.parseArray(airagMcp.getTools());
+            if (toolsArray == null || toolsArray.isEmpty()) {
+                return tools;
+            }
+
+            String baseUrl = airagMcp.getEndpoint();
+            // 如果baseUrl为空，使用当前系统地址
+            if (oConvertUtils.isEmpty(baseUrl)) {
+                if (currentHttpRequest != null) {
+                    baseUrl = CommonUtils.getBaseUrl(currentHttpRequest);
+                    log.info("插件[{}]的BaseURL为空，使用系统地址: {}", airagMcp.getName(), baseUrl);
+                } else {
+                    log.warn("插件[{}]的BaseURL为空且无法获取系统地址，跳过工具构建", airagMcp.getName());
+                    return tools;
+                }
+            }
+
+            // 解析headers
+            Map<String, String> headersMap = parseHeaders(airagMcp.getHeaders());
+            
+            // 解析并应用授权配置（从metadata中读取）
+            applyAuthConfig(headersMap, airagMcp.getMetadata(), currentHttpRequest);
+
+            for (int i = 0; i < toolsArray.size(); i++) {
+                JSONObject toolConfig = toolsArray.getJSONObject(i);
+                if (toolConfig == null) {
+                    continue;
+                }
+
+                try {
+                    ToolSpecification spec = buildToolSpecification(toolConfig);
+                    ToolExecutor executor = buildToolExecutor(toolConfig, baseUrl, headersMap);
+                    if (spec != null && executor != null) {
+                        tools.put(spec, executor);
+                    }
+                } catch (Exception e) {
+                    log.error("构建插件工具失败，工具配置: {}", toolConfig.toJSONString(), e);
+                }
+            }
+        } catch (Exception e) {
+            log.error("解析插件工具配置失败，插件: {}", airagMcp.getName(), e);
+        }
+
+        return tools;
+    }
+
+    /**
+     * 构建ToolSpecification
+     */
+    private static ToolSpecification buildToolSpecification(JSONObject toolConfig) {
+        String name = toolConfig.getString("name");
+        String description = toolConfig.getString("description");
+
+        if (oConvertUtils.isEmpty(name) || oConvertUtils.isEmpty(description)) {
+            log.warn("工具配置缺少name或description字段");
+            return null;
+        }
+
+        // 构建完整的描述信息（包含响应参数配置）
+        StringBuilder fullDescription = new StringBuilder(description);
+        
+        // 解析响应参数并拼接到描述中
+        JSONArray responses = toolConfig.getJSONArray("responses");
+        if (responses != null && !responses.isEmpty()) {
+            fullDescription.append("\n\n返回值说明：");
+            for (int i = 0; i < responses.size(); i++) {
+                JSONObject responseParam = responses.getJSONObject(i);
+                if (responseParam == null) {
+                    continue;
+                }
+                String paramName = responseParam.getString("name");
+                String paramDesc = responseParam.getString("description");
+                String paramType = responseParam.getString("type");
+
+                if (oConvertUtils.isEmpty(paramName)) {
+                    continue;
+                }
+
+                fullDescription.append("\n- ").append(paramName);
+                if (oConvertUtils.isNotEmpty(paramType)) {
+                    fullDescription.append(" (").append(paramType).append(")");
+                }
+                if (oConvertUtils.isNotEmpty(paramDesc)) {
+                    fullDescription.append(": ").append(paramDesc);
+                }
+            }
+        }
+
+        JsonObjectSchema.Builder schemaBuilder = JsonObjectSchema.builder();
+
+        // 解析请求参数
+        JSONArray parameters = toolConfig.getJSONArray("parameters");
+        if (parameters != null && !parameters.isEmpty()) {
+            List<String> requiredParams = new ArrayList<>();
+            for (int i = 0; i < parameters.size(); i++) {
+                JSONObject param = parameters.getJSONObject(i);
+                if (param == null) {
+                    continue;
+                }
+                String paramName = param.getString("name");
+                String paramDesc = param.getString("description");
+                String paramType = param.getString("type");
+
+                if (oConvertUtils.isEmpty(paramName)) {
+                    continue;
+                }
+
+                // 根据参数类型添加属性
+                if ("String".equalsIgnoreCase(paramType) || "string".equalsIgnoreCase(paramType)) {
+                    schemaBuilder.addStringProperty(paramName, paramDesc != null ? paramDesc : "");
+                } else if ("Number".equalsIgnoreCase(paramType) || "number".equalsIgnoreCase(paramType)
+                        || "Integer".equalsIgnoreCase(paramType) || "integer".equalsIgnoreCase(paramType)) {
+                    schemaBuilder.addNumberProperty(paramName, paramDesc != null ? paramDesc : "");
+                } else if ("Boolean".equalsIgnoreCase(paramType) || "boolean".equalsIgnoreCase(paramType)) {
+                    schemaBuilder.addBooleanProperty(paramName, paramDesc != null ? paramDesc : "");
+                } else {
+                    // 默认作为String处理
+                    schemaBuilder.addStringProperty(paramName, paramDesc != null ? paramDesc : "");
+                }
+
+                // 检查是否必须
+                Boolean required = param.getBooleanValue("required");
+                if (required != null && required) {
+                    requiredParams.add(paramName);
+                }
+            }
+
+            if (!requiredParams.isEmpty()) {
+                schemaBuilder.required(requiredParams.toArray(new String[0]));
+            }
+        }
+
+        return ToolSpecification.builder()
+                .name(name)
+                .description(fullDescription.toString())
+                .parameters(schemaBuilder.build())
+                .build();
+    }
+
+    /**
+     * 构建ToolExecutor
+     */
+    private static ToolExecutor buildToolExecutor(JSONObject toolConfig, String baseUrl, Map<String, String> defaultHeaders) {
+        String path = toolConfig.getString("path");
+        String method = toolConfig.getString("method");
+        JSONArray parameters = toolConfig.getJSONArray("parameters");
+
+        if (oConvertUtils.isEmpty(path) || oConvertUtils.isEmpty(method)) {
+            log.warn("工具配置缺少path或method字段");
+            return null;
+        }
+
+        return (toolExecutionRequest, memoryId) -> {
+            try {
+                // 解析AI传入的参数
+                JSONObject args = JSONObject.parseObject(toolExecutionRequest.arguments());
+
+                // 构建完整URL
+                String url = buildUrl(baseUrl, path, parameters, args);
+
+                // 构建请求方法
+                HttpMethod httpMethod = parseHttpMethod(method);
+
+                // 构建请求头
+                HttpHeaders httpHeaders = buildHttpHeaders(parameters, args, defaultHeaders);
+
+                // 构建请求参数
+                JSONObject urlVariables = buildUrlVariables(parameters, args);
+                Object body = buildRequestBody(parameters, args, httpHeaders);
+
+                // 发送HTTP请求
+                ResponseEntity<String> response = RestUtil.request(url, httpMethod, httpHeaders, urlVariables, body, String.class);
+
+                // 直接返回原始响应字符串，不进行解析
+                return response.getBody() != null ? response.getBody() : "";
+            } catch (HttpClientErrorException e) {
+                log.error("插件工具HTTP请求失败: {}", e.getMessage(), e);
+                return "请求失败: " + e.getStatusCode() + " - " + e.getResponseBodyAsString();
+            } catch (Exception e) {
+                log.error("插件工具执行失败: {}", e.getMessage(), e);
+                return "工具执行失败: " + e.getMessage();
+            }
+        };
+    }
+
+    /**
+     * 构建完整URL（处理Path参数）
+     */
+    private static String buildUrl(String baseUrl, String path, JSONArray parameters, JSONObject args) {
+        String fullPath = path;
+        if (!path.startsWith("/")) {
+            fullPath = "/" + path;
+        }
+        // 拼接URL时防止出现双斜杠
+        if (baseUrl.endsWith("/") && fullPath.startsWith("/")) {
+            fullPath = fullPath.substring(1);
+        }
+        String url = baseUrl + fullPath;
+
+        // 替换Path参数
+        if (parameters != null && args != null) {
+            for (int i = 0; i < parameters.size(); i++) {
+                JSONObject param = parameters.getJSONObject(i);
+                if (param == null) {
+                    continue;
+                }
+                String paramName = param.getString("name");
+                String paramLocation = param.getString("location");
+
+                if (!"Path".equalsIgnoreCase(paramLocation)) {
+                    continue;
+                }
+
+                Object value = args.get(paramName);
+                if (value != null) {
+                    url = url.replace("{" + paramName + "}", value.toString());
+                }
+            }
+        }
+
+        return url;
+    }
+
+    /**
+     * 构建请求头
+     */
+    private static HttpHeaders buildHttpHeaders(JSONArray parameters, JSONObject args, Map<String, String> defaultHeaders) {
+        HttpHeaders httpHeaders = new HttpHeaders();
+
+        // 添加默认请求头
+        if (defaultHeaders != null) {
+            defaultHeaders.forEach(httpHeaders::set);
+        }
+
+        // 添加Header类型的参数
+        if (parameters != null && args != null) {
+            for (int i = 0; i < parameters.size(); i++) {
+                JSONObject param = parameters.getJSONObject(i);
+                if (param == null) {
+                    continue;
+                }
+                String paramName = param.getString("name");
+                String paramLocation = param.getString("location");
+
+                if (!"Header".equalsIgnoreCase(paramLocation)) {
+                    continue;
+                }
+
+                Object value = args.get(paramName);
+                if (value != null) {
+                    httpHeaders.set(paramName, value.toString());
+                }
+            }
+        }
+
+        // 如果请求体不为空且没有设置Content-Type，默认设置为application/json
+        if (!httpHeaders.containsKey(HttpHeaders.CONTENT_TYPE)) {
+            httpHeaders.setContentType(MediaType.APPLICATION_JSON);
+        }
+
+        return httpHeaders;
+    }
+
+    /**
+     * 构建URL查询参数
+     */
+    private static JSONObject buildUrlVariables(JSONArray parameters, JSONObject args) {
+        JSONObject urlVariables = new JSONObject();
+
+        if (parameters == null || args == null) {
+            return urlVariables;
+        }
+
+        for (int i = 0; i < parameters.size(); i++) {
+            JSONObject param = parameters.getJSONObject(i);
+            if (param == null) {
+                continue;
+            }
+            String paramName = param.getString("name");
+            String paramLocation = param.getString("location");
+
+            String location = paramLocation != null ? paramLocation : "";
+            // 显式指定Query类型，或者未指定类型（默认作为Query）
+            boolean isQueryParam = "Query".equalsIgnoreCase(location);
+            boolean isOtherType = "Body".equalsIgnoreCase(location) || "Form-Data".equalsIgnoreCase(location)
+                    || "Header".equalsIgnoreCase(location) || "Path".equalsIgnoreCase(location);
+            
+            if (isQueryParam || !isOtherType) {
+                Object value = args.get(paramName);
+                if (value != null) {
+                    urlVariables.put(paramName, value);
+                }
+            }
+        }
+
+        return urlVariables.isEmpty() ? null : urlVariables;
+    }
+
+    /**
+     * 构建请求体
+     */
+    private static Object buildRequestBody(JSONArray parameters, JSONObject args, HttpHeaders httpHeaders) {
+        if (parameters == null || args == null) {
+            return null;
+        }
+
+        boolean hasBody = false;
+        boolean hasFormData = false;
+
+        // 检查是否有Body或Form-Data类型的参数
+        for (int i = 0; i < parameters.size(); i++) {
+            JSONObject param = parameters.getJSONObject(i);
+            if (param == null) {
+                continue;
+            }
+            String paramLocation = param.getString("location");
+
+            if ("Body".equalsIgnoreCase(paramLocation)) {
+                hasBody = true;
+            } else if ("Form-Data".equalsIgnoreCase(paramLocation)) {
+                hasFormData = true;
+            }
+        }
+
+        // Body和Form-Data互斥
+        if (hasBody && hasFormData) {
+            log.warn("工具配置同时包含Body和Form-Data类型参数，优先使用Body");
+            hasFormData = false;
+        }
+
+        if (hasBody) {
+            // Body类型：构建JSON对象
+            JSONObject body = new JSONObject();
+            for (int i = 0; i < parameters.size(); i++) {
+                JSONObject param = parameters.getJSONObject(i);
+                if (param == null) {
+                    continue;
+                }
+                String paramName = param.getString("name");
+                String paramLocation = param.getString("location");
+
+                if (!"Body".equalsIgnoreCase(paramLocation) ) {
+                    continue;
+                }
+
+                Object value = args.get(paramName);
+                if (value != null) {
+                    body.put(paramName, value);
+                } else {
+                    // 检查是否有默认值
+                    String defaultValue = param.getString("defaultValue");
+                    if (oConvertUtils.isNotEmpty(defaultValue)) {
+                        body.put(paramName, defaultValue);
+                    }
+                }
+            }
+            httpHeaders.setContentType(MediaType.APPLICATION_JSON);
+            return body.isEmpty() ? null : body;
+        } else if (hasFormData) {
+            // Form-Data类型：构建JSON对象（RestUtil会处理）
+            JSONObject formData = new JSONObject();
+            for (int i = 0; i < parameters.size(); i++) {
+                JSONObject param = parameters.getJSONObject(i);
+                if (param == null) {
+                    continue;
+                }
+                String paramName = param.getString("name");
+                String paramLocation = param.getString("location");
+
+                if (!"Form-Data".equalsIgnoreCase(paramLocation)) {
+                    continue;
+                }
+
+                Object value = args.get(paramName);
+                if (value != null) {
+                    formData.put(paramName, value);
+                } else {
+                    String defaultValue = param.getString("defaultValue");
+                    if (oConvertUtils.isNotEmpty(defaultValue)) {
+                        formData.put(paramName, defaultValue);
+                    }
+                }
+            }
+            httpHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
+            return formData.isEmpty() ? null : formData;
+        }
+
+        return null;
+    }
+
+    /**
+     * 解析HTTP方法
+     */
+    private static HttpMethod parseHttpMethod(String method) {
+        try {
+            return HttpMethod.valueOf(method.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            log.warn("无效的HTTP方法: {}，使用默认GET", method);
+            return HttpMethod.GET;
+        }
+    }
+
+
+    /**
+     * 解析headers JSON字符串为Map
+     */
+    private static Map<String, String> parseHeaders(String headersStr) {
+        Map<String, String> headersMap = new HashMap<>();
+        if (oConvertUtils.isEmpty(headersStr)) {
+            return headersMap;
+        }
+
+        try {
+            JSONObject headersJson = JSONObject.parseObject(headersStr);
+            if (headersJson != null) {
+                headersJson.forEach((key, value) -> {
+                    if (value != null) {
+                        headersMap.put(key, value.toString());
+                    }
+                });
+            }
+        } catch (Exception e) {
+            log.warn("解析headers失败: {}", headersStr);
+        }
+
+        return headersMap;
+    }
+
+    /**
+     * 应用授权配置到headers
+     * 从metadata中读取授权配置，如果是Token授权，添加到headers中
+     * 如果授权类型为token但没有设置token值，则从TokenUtils获取当前请求的token
+     *
+     * @param headersMap 请求头Map
+     * @param metadataStr 元数据JSON字符串
+     */
+    private static void applyAuthConfig(Map<String, String> headersMap, String metadataStr, HttpServletRequest currentHttpRequest) {
+        if (oConvertUtils.isEmpty(metadataStr)) {
+            return;
+        }
+
+        try {
+            JSONObject metadata = JSONObject.parseObject(metadataStr);
+            if (metadata == null) {
+                return;
+            }
+
+            String authType = metadata.getString("authType");
+            if (oConvertUtils.isEmpty(authType) || !"token".equalsIgnoreCase(authType)) {
+                return;
+            }
+
+            // Token授权方式：从metadata中获取token配置并添加到headers
+            String tokenParamName = metadata.getString("tokenParamName");
+            String tokenParamValue = metadata.getString("tokenParamValue");
+
+            // 如果token参数名存在，但token值未设置，尝试从TokenUtils获取当前请求的token
+            if (oConvertUtils.isNotEmpty(tokenParamName) && oConvertUtils.isEmpty(tokenParamValue)) {
+                try {
+                    // 注意：TokenUtils需要获取当前线程的request，所以必须在同步调用中使用
+                    String currentToken = TokenUtils.getTokenByRequest();
+                    if(oConvertUtils.isEmpty(currentToken) && currentHttpRequest != null) {
+                        currentToken = TokenUtils.getTokenByRequest(currentHttpRequest);
+                    }
+                    if (oConvertUtils.isNotEmpty(currentToken)) {
+                        tokenParamValue = currentToken;
+                        log.debug("从TokenUtils获取Token并添加到请求头: {} = {}", tokenParamName, 
+                            currentToken.length() > 10 ? currentToken.substring(0, 10) + "..." : currentToken);
+                    } else {
+                        log.warn("Token授权配置中tokenParamValue为空，且无法从TokenUtils获取当前请求的token");
+                    }
+                } catch (Exception e) {
+                    log.warn("从TokenUtils获取token失败: {}", e.getMessage());
+                }
+            }
+
+            if (oConvertUtils.isNotEmpty(tokenParamName) && oConvertUtils.isNotEmpty(tokenParamValue)) {
+                // 如果headers中已存在同名header，优先使用metadata中的配置（覆盖）
+                headersMap.put(tokenParamName, tokenParamValue);
+                // 日志中只显示token的前几个字符，避免泄露完整token
+                String tokenPreview = tokenParamValue.length() > 10 
+                    ? tokenParamValue.substring(0, 10) + "..." 
+                    : tokenParamValue;
+                log.debug("添加Token授权到请求头: {} = {}", tokenParamName, tokenPreview);
+            } else {
+                log.warn("Token授权配置不完整: tokenParamName={}, tokenParamValue={}", tokenParamName, tokenParamValue != null ? "***" : null);
+            }
+        } catch (Exception e) {
+            log.warn("解析授权配置失败: {}", metadataStr, e);
+        }
+    }
+}
+
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/mapper/AiragMcpMapper.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/mapper/AiragMcpMapper.java
@@ -0,0 +1,14 @@
+package org.jeecg.modules.airag.llm.mapper;
+
+import org.jeecg.modules.airag.llm.entity.AiragMcp;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * @Description: MCP
+ * @Author: jeecg-boot
+ * @Date:   2025-10-20
+ * @Version: V1.0
+ */
+public interface AiragMcpMapper extends BaseMapper<AiragMcp> {
+
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/mapper/xml/AiragMcpMapper.xml
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/mapper/xml/AiragMcpMapper.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="org.jeecg.modules.airag.llm.mapper.AiragMcpMapper">
+
+</mapper>
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/service/IAiragMcpService.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/service/IAiragMcpService.java
@@ -0,0 +1,32 @@
+package org.jeecg.modules.airag.llm.service;
+
+import org.jeecg.common.api.vo.Result;
+import org.jeecg.modules.airag.llm.entity.AiragMcp;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * @Description: MCP
+ * @Author: jeecg-boot
+ * @Date:   2025-10-20
+ * @Version: V1.0
+ */
+public interface IAiragMcpService extends IService<AiragMcp> {
+
+    Result<String> edit(AiragMcp airagMcp);
+
+    Result<?> sync(String id);
+
+
+    Result<?> toggleStatus(String id, String action);
+
+    /**
+     * 保存插件工具（仅更新tools字段）
+     * for [QQYUN-12453]【AI】支持插件
+     * @param id 插件ID
+     * @param tools 工具列表JSON字符串
+     * @return 操作结果
+     * @author chenrui
+     * @date 2025/10/30
+     */
+    Result<String> saveTools(String id, String tools);
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/service/impl/AiragMcpServiceImpl.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/llm/service/impl/AiragMcpServiceImpl.java
@@ -0,0 +1,356 @@
+package org.jeecg.modules.airag.llm.service.impl;
+
+import com.alibaba.fastjson.JSONException;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import dev.langchain4j.agent.tool.ToolSpecification;
+import dev.langchain4j.mcp.client.DefaultMcpClient;
+import dev.langchain4j.mcp.client.McpClient;
+import dev.langchain4j.mcp.client.transport.http.HttpMcpTransport;
+import dev.langchain4j.model.chat.request.json.*;
+import lombok.extern.slf4j.Slf4j;
+import org.jeecg.common.api.vo.Result;
+import org.jeecg.common.constant.CommonConstant;
+import org.jeecg.common.util.oConvertUtils;
+import org.jeecg.modules.airag.llm.entity.AiragMcp;
+import org.jeecg.modules.airag.llm.mapper.AiragMcpMapper;
+import org.jeecg.modules.airag.llm.service.IAiragMcpService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @Description: MCP
+ * @Author: jeecg-boot
+ * @Date: 2025-10-20
+ * @Version: V1.0
+ */
+@Service("airagMcpServiceImpl")
+@Slf4j
+public class AiragMcpServiceImpl extends ServiceImpl<AiragMcpMapper, AiragMcp> implements IAiragMcpService {
+
+    @Autowired
+    private ObjectMapper objectMapper; // 使用全局配置的 Jackson ObjectMapper
+
+    /**
+     * 新增或编辑Mcpserver
+     *
+     * @param airagMcp MCP对象
+     * @return 返回保存后的MCP对象
+     * @author chenrui
+     * @date 2025/10/21
+     */
+    @Override
+    public Result<String> edit(AiragMcp airagMcp) {
+        // 校验必填项
+        if (airagMcp.getName() == null || airagMcp.getName().trim().isEmpty()) {
+            return Result.error("名称不能为空");
+        }
+        //update-begin---author:chenrui ---date:20251031  for：[QQYUN-12453]【AI】支持插件------------
+        // 设置默认category
+        if (oConvertUtils.isEmpty(airagMcp.getCategory())) {
+            airagMcp.setCategory("mcp");
+        }
+        // 对于MCP类型，需要校验type和endpoint
+        if ("mcp".equalsIgnoreCase(airagMcp.getCategory())) {
+            if (airagMcp.getType() == null || airagMcp.getType().trim().isEmpty()) {
+                return Result.error("MCP类型不能为空");
+            }
+            if (airagMcp.getEndpoint() == null || airagMcp.getEndpoint().trim().isEmpty()) {
+                return Result.error("服务端点不能为空");
+            }
+        } else if ("plugin".equalsIgnoreCase(airagMcp.getCategory())) {
+            // 对于插件类型，BaseURL可选，不填时使用当前系统地址
+            // 不再校验endpoint是否为空
+        } else {
+            // 未知类型，默认为MCP并校验
+            if (airagMcp.getEndpoint() == null || airagMcp.getEndpoint().trim().isEmpty()) {
+                return Result.error("服务端点不能为空");
+            }
+        }
+        //update-end---author:chenrui ---date:20251031  for：[QQYUN-12453]【AI】支持插件------------
+
+        if (airagMcp.getId() == null || airagMcp.getId().trim().isEmpty()) {
+            // 设置默认值
+            airagMcp.setStatus("enable");
+            //update-begin---author:chenrui ---date:20251031  for：[QQYUN-12453]【AI】支持插件------------
+            // 只有MCP类型才设置synced字段，插件类型不需要同步默认为已同步
+            if ("mcp".equalsIgnoreCase(airagMcp.getCategory())) {
+                airagMcp.setSynced(CommonConstant.STATUS_0_INT);
+            } else {
+                airagMcp.setSynced(CommonConstant.STATUS_1_INT);
+            }
+            //update-end---author:chenrui ---date:20251031  for：[QQYUN-12453]【AI】支持插件------------
+            // 新增
+            this.save(airagMcp);
+        } else {
+            // 编辑
+            this.updateById(airagMcp);
+        }
+        return Result.OK("保存成功");
+    }
+
+    /**
+     * 同步mcp的工具列表
+     *
+     * @param id mcp主键
+     * @return 工具列表
+     * @author chenrui
+     * @date 2025/10/21
+     */
+    @Override
+    public Result<?> sync(String id) {
+        AiragMcp mcp = this.getById(id);
+        if (mcp == null) {
+            return Result.error("未找到对应的MCP对象");
+        }
+        //update-begin---author:chenrui ---date:20251031  for：[QQYUN-12453]【AI】支持插件------------
+        // 只有MCP类型才支持同步，插件类型不支持
+        String category = mcp.getCategory();
+        if (oConvertUtils.isEmpty(category)) {
+            category = "mcp"; // 兼容旧数据
+        }
+        if (!"mcp".equalsIgnoreCase(category)) {
+            return Result.error("只有MCP类型才支持同步操作");
+        }
+        //update-end---author:chenrui ---date:20251031  for：[QQYUN-12453]【AI】支持插件------------
+        String type = mcp.getType();
+        String endpoint = mcp.getEndpoint();
+        Map<String, String> headers = null;
+        if (oConvertUtils.isNotEmpty(mcp.getHeaders())) {
+            try {
+                headers = JSONObject.parseObject(mcp.getHeaders(), Map.class);
+            } catch (JSONException e) {
+                headers = null;
+            }
+        }
+        if (type == null || endpoint == null) {
+            return Result.error("MCP类型或端点为空");
+        }
+        McpClient mcpClient = null;
+        try {
+            if ("sse".equalsIgnoreCase(type)) {
+                HttpMcpTransport.Builder builder = new HttpMcpTransport.Builder()
+                        .sseUrl(endpoint)
+                        .logRequests(true)
+                        .logResponses(true);
+                mcpClient = new DefaultMcpClient.Builder().transport(builder.build()).build();
+            } else if ("stdio".equalsIgnoreCase(type)) {
+                // stdio 类型：endpoint 可能是一个命令行，需要拆分为命令列表
+//                List<String> cmdParts = Arrays.asList(endpoint.trim().split("\\s+"));
+//                StdioMcpTransport.Builder builder = new StdioMcpTransport.Builder()
+//                        .command(cmdParts)
+//                        .environment(headers);
+//                mcpClient = new DefaultMcpClient.Builder().transport(builder.build()).build();
+                return Result.error("不支持的MCP类型:" + type);
+            } else {
+                return Result.error("不支持的MCP类型:" + type);
+            }
+            List<ToolSpecification> toolSpecifications = mcpClient.listTools();
+            // 先尝试直接使用 ObjectMapper 序列化，若结果为 {} 则回退到反射 Map
+            List<Map<String, Object>> specMaps = toolSpecifications.stream()
+                    .map(spec -> {
+                        try {
+                            String raw = objectMapper.writeValueAsString(spec);
+                            if (raw != null && raw.length() > 2) {
+                                // 直接反序列化成 Map，保留 Jackson 认出的字段
+                                return objectMapper.readValue(raw, new TypeReference<Map<String, Object>>() {
+                                });
+                            }
+                        } catch (Exception ignore) {
+                        }
+                        return convertToolSpec(spec);
+                    })
+                    .collect(Collectors.toList());
+            String jsonList;
+            try {
+                jsonList = objectMapper.writeValueAsString(specMaps);
+            } catch (JsonProcessingException e) {
+                jsonList = JSONObject.toJSONString(specMaps);
+            }
+            String firstJson = specMaps.isEmpty() ? "null" : safeWriteJson(specMaps.get(0));
+            log.info("MCP工具列表 id={}, size={}, first={}", id, toolSpecifications.size(), firstJson);
+            mcp.setTools(jsonList);
+            mcp.setSynced(1);
+
+            Map<String,Object> metadata = new HashMap<>();
+            metadata.put("tool_count", toolSpecifications.size());
+            mcp.setMetadata(objectMapper.writeValueAsString(metadata));
+            this.updateById(mcp);
+            return Result.OK(specMaps);
+        } catch (Exception e) {
+            String message = e.getMessage();
+            if (e instanceof IllegalArgumentException) {
+                message = "，MCP客户端参数错误";
+            }
+            log.error("同步MCP工具失败 id={}, error={}", id, message, e);
+            return Result.error("同步失败" + message);
+        } finally {
+            if (mcpClient != null) {
+                try {
+                    Method closeMethod = mcpClient.getClass().getMethod("close");
+                    closeMethod.invoke(mcpClient);
+                } catch (NoSuchMethodException ignore) {
+                } catch (Exception ex) {
+                    log.warn("关闭MCP客户端失败 id={}, error={}", id, ex.getMessage());
+                }
+            }
+        }
+    }
+
+    // 安全序列化单个对象为 JSON 字符串
+    private String safeWriteJson(Object obj) {
+        try {
+            return objectMapper.writeValueAsString(obj);
+        } catch (Exception e) {
+            return String.valueOf(obj);
+        }
+    }
+
+    // 反射将 ToolSpecification 转成 Map，兼容 record/私有字段/仅 Jackson 注解场景 -> 改为直接调用访问器
+    private Map<String, Object> convertToolSpec(ToolSpecification spec) {
+        Map<String, Object> map = new LinkedHashMap<>();
+        if (spec == null) {
+            return map;
+        }
+        map.put("name", spec.name());
+        map.put("description", spec.description());
+        try {
+            Object params = spec.parameters();
+            if (params != null) {
+                JsonObjectSchema obj = (JsonObjectSchema) params;
+                List<Map<String, Object>> fields = new ArrayList<>();
+                if (obj.properties() != null) {
+                    obj.properties().forEach((fieldName, fieldSchema) -> {
+                        Map<String, Object> fieldMap = new LinkedHashMap<>();
+                        fieldMap.put("name", fieldName);
+                        fieldMap.put("description", extractDescription(fieldSchema));
+                        // 若需要标记必填
+                        if (obj.required() != null && obj.required().contains(fieldName)) {
+                            fieldMap.put("required", true);
+                        }
+                        fields.add(fieldMap);
+                    });
+                }
+                map.put("parameters", fields);
+            }
+        } catch (Exception ignored) {
+        }
+        return map;
+    }
+
+    // 提取各类型 schema 的描述
+    private String extractDescription(Object schema) {
+        if (schema == null) return null;
+        try {
+            if (schema instanceof JsonStringSchema) return ((JsonStringSchema) schema).description();
+            if (schema instanceof JsonNumberSchema) return ((JsonNumberSchema) schema).description();
+            if (schema instanceof JsonBooleanSchema) return ((JsonBooleanSchema) schema).description();
+            if (schema instanceof JsonArraySchema) return ((JsonArraySchema) schema).description();
+            if (schema instanceof JsonEnumSchema) return ((JsonEnumSchema) schema).description();
+            if (schema instanceof JsonObjectSchema) return ((JsonObjectSchema) schema).description();
+        } catch (Exception ignored) {
+        }
+        return schema.toString();
+    }
+
+    /**
+     * 修改状态
+     *
+     * @param id     MCP主键
+     * @param action 操作（enable/disable）
+     * @return 操作结果
+     * @author chenrui
+     * @date 2025/10/21 11:00
+     */
+    @Override
+    public Result<?> toggleStatus(String id, String action) {
+        if (oConvertUtils.isEmpty(id)) {
+            return Result.error("id不能为空");
+        }
+        if (oConvertUtils.isEmpty(action)) {
+            return Result.error("action不能为空");
+        }
+        String normalized = action.toLowerCase();
+        if (!"enable".equals(normalized) && !"disable".equals(normalized)) {
+            return Result.error("action只能为enable或disable");
+        }
+        AiragMcp mcp = this.getById(id);
+        if (mcp == null) {
+            return Result.error("未找到对应的MCP服务");
+        }
+        if (normalized.equalsIgnoreCase(mcp.getStatus())) {
+            return Result.OK("操作成功");
+        }
+        mcp.setStatus(normalized);
+        this.updateById(mcp);
+        return Result.OK("操作成功");
+    }
+
+    /**
+     * 保存插件工具（仅更新tools字段）
+     * for [QQYUN-12453]【AI】支持插件
+     * @param id 插件ID
+     * @param tools 工具列表JSON字符串
+     * @return 操作结果
+     * @author chenrui
+     * @date 2025/10/30
+     */
+    @Override
+    public Result<String> saveTools(String id, String tools) {
+        if (oConvertUtils.isEmpty(id)) {
+            return Result.error("插件ID不能为空");
+        }
+        AiragMcp mcp = this.getById(id);
+        if (mcp == null) {
+            return Result.error("未找到对应的插件");
+        }
+        // 验证是否为插件类型
+        String category = mcp.getCategory();
+        if (oConvertUtils.isEmpty(category)) {
+            category = "mcp"; // 兼容旧数据
+        }
+        if (!"plugin".equalsIgnoreCase(category)) {
+            return Result.error("只有插件类型才能保存工具");
+        }
+        // 更新tools字段
+        mcp.setTools(tools);
+        
+        // 更新metadata中的tool_count
+        try {
+            com.alibaba.fastjson.JSONArray toolsArray = com.alibaba.fastjson.JSONArray.parseArray(tools);
+            int toolCount = toolsArray != null ? toolsArray.size() : 0;
+            
+            // 解析现有metadata
+            JSONObject metadata = new JSONObject();
+            if (oConvertUtils.isNotEmpty(mcp.getMetadata())) {
+                try {
+                    JSONObject metadataJson = JSONObject.parseObject(mcp.getMetadata());
+                    if (metadataJson != null) {
+                        metadata.putAll(metadataJson);
+                    }
+                } catch (Exception e) {
+                    log.warn("解析metadata失败，将重新创建: {}", mcp.getMetadata());
+                }
+            }
+            
+            // 更新tool_count
+            metadata.put("tool_count", toolCount);
+            
+            // 保存metadata
+            mcp.setMetadata(metadata.toJSONString());
+        } catch (Exception e) {
+            log.warn("更新工具数量失败: {}", e.getMessage());
+            // 即使更新tool_count失败，也不影响保存tools
+        }
+        
+        this.updateById(mcp);
+        return Result.OK("保存成功");
+    }
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/pom.xml
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/pom.xml
@@ -5,7 +5,7 @@
    <parent>
        <artifactId>jeecg-boot-module</artifactId>
        <groupId>org.jeecgframework.boot3</groupId>
-        <version>3.8.3</version>
+        <version>3.9.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/cloud/controller/JcloudDemoFeignController.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/cloud/controller/JcloudDemoFeignController.java
@@ -11,7 +11,7 @@
 //import org.springframework.web.bind.annotation.GetMapping;
 //import org.springframework.web.bind.annotation.RequestMapping;
 //import org.springframework.web.bind.annotation.RestController;
-//import javax.annotation.Resource;
+//import jakarta.annotation.Resource;
 //import java.util.List;
 //
 ///**
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/shop/controller/ShopController.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/shop/controller/ShopController.java
@@ -0,0 +1,333 @@
+package org.jeecg.modules.demo.shop.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.PostConstruct;
+import lombok.extern.slf4j.Slf4j;
+import org.jeecg.common.api.vo.Result;
+import org.jeecg.modules.demo.shop.entity.Order;
+import org.jeecg.modules.demo.shop.entity.Product;
+import org.springframework.web.bind.annotation.*;
+
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+/**
+ * 商品管理模拟接口
+ * 用于AI Agent通过工具帮助用户查询商品并采购的业务演示
+ * @Author: chenrui
+ * @Date: 2025-11-06
+ */
+@Tag(name = "商品管理Demo")
+@RestController
+@RequestMapping("/demo/shop")
+@Slf4j
+public class ShopController {
+    
+    /**
+     * 商品数据存储(内存)
+     */
+    private final Map<String, Product> productStore = new ConcurrentHashMap<>();
+    
+    /**
+     * 订单数据存储(内存)
+     */
+    private final Map<String, Order> orderStore = new ConcurrentHashMap<>();
+    
+    /**
+     * 订单ID生成器
+     */
+    private final AtomicInteger orderIdGenerator = new AtomicInteger(1000);
+    
+    /**
+     * 初始化商品数据
+     *
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @PostConstruct
+    public void initProducts() {
+        // 电子产品
+        productStore.put("P001", new Product("P001", "iPhone 15 Pro", new BigDecimal("7999.00"), "电子产品", "Apple最新旗舰手机,6.1英寸屏幕,钛金属边框", 50));
+        productStore.put("P002", new Product("P002", "MacBook Pro 14", new BigDecimal("14999.00"), "电子产品", "M3 Pro芯片,16GB内存,512GB存储", 30));
+        productStore.put("P003", new Product("P003", "AirPods Pro 2", new BigDecimal("1899.00"), "电子产品", "主动降噪无线耳机,支持空间音频", 100));
+        productStore.put("P004", new Product("P004", "iPad Air", new BigDecimal("4799.00"), "电子产品", "10.9英寸液晶显示屏,M1芯片", 60));
+        
+        // 图书
+        productStore.put("B001", new Product("B001", "Java核心技术卷I", new BigDecimal("119.00"), "图书", "Java编程经典教材,适合初学者和进阶开发者", 200));
+        productStore.put("B002", new Product("B002", "深入理解计算机系统", new BigDecimal("139.00"), "图书", "CSAPP经典教材,计算机系统必读书籍", 150));
+        productStore.put("B003", new Product("B003", "设计模式", new BigDecimal("89.00"), "图书", "软件设计经典著作,GoF四人组著作", 180));
+        
+        // 生活用品
+        productStore.put("L001", new Product("L001", "小米电动牙刷", new BigDecimal("199.00"), "生活用品", "声波震动,IPX7防水,续航18天", 300));
+        productStore.put("L002", new Product("L002", "戴森吹风机", new BigDecimal("2990.00"), "生活用品", "快速干发,智能温控,保护头发", 80));
+        productStore.put("L003", new Product("L003", "膳魔师保温杯", new BigDecimal("259.00"), "生活用品", "真空保温,304不锈钢,保温12小时", 500));
+        
+        // 食品
+        productStore.put("F001", new Product("F001", "三只松鼠坚果礼盒", new BigDecimal("159.00"), "食品", "混合坚果大礼包,1500g装", 400));
+        productStore.put("F002", new Product("F002", "茅台飞天53度", new BigDecimal("2899.00"), "食品", "贵州茅台酒,500ml", 20));
+        productStore.put("F003", new Product("F003", "星巴克咖啡豆", new BigDecimal("128.00"), "食品", "中度烘焙,派克市场,250g", 250));
+        
+        log.info("商品数据初始化完成,共{}个商品", productStore.size());
+    }
+    
+    /**
+     * 查询商品列表
+     *
+     * @param category 商品分类(可选)
+     * @param keyword 搜索关键词(可选)
+     * @return 商品列表
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "查询商品列表", description = "支持按分类和关键词搜索")
+    @GetMapping("/products")
+    public Result<List<Product>> getProducts(
+            @Parameter(description = "商品分类") @RequestParam(required = false) String category,
+            @Parameter(description = "搜索关键词") @RequestParam(required = false) String keyword) {
+        
+        log.info("查询商品列表 - 分类: {}, 关键词: {}", category, keyword);
+        
+        List<Product> products = new ArrayList<>(productStore.values());
+        
+        // 按分类过滤
+        if (category != null && !category.trim().isEmpty()) {
+            products = products.stream()
+                    .filter(p -> category.equals(p.getCategory()))
+                    .collect(Collectors.toList());
+        }
+        
+        // 按关键词过滤(搜索商品名称和描述)
+        if (keyword != null && !keyword.trim().isEmpty()) {
+            String searchKey = keyword.toLowerCase();
+            products = products.stream()
+                    .filter(p -> p.getName().toLowerCase().contains(searchKey) 
+                            || p.getDescription().toLowerCase().contains(searchKey))
+                    .collect(Collectors.toList());
+        }
+        
+        // 按价格排序
+        products.sort(Comparator.comparing(Product::getPrice));
+        
+        log.info("查询到{}个商品", products.size());
+        return Result.OK(products);
+    }
+    
+    /**
+     * 查询商品库存
+     *
+     * @param productId 商品ID
+     * @return 库存信息
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "查询商品库存", description = "根据商品ID查询库存数量")
+    @GetMapping("/stock")
+    public Result<Map<String, Object>> getStock(
+            @Parameter(description = "商品ID", required = true) @RequestParam String productId) {
+        
+        log.info("查询商品库存 - 商品ID: {}", productId);
+        
+        Product product = productStore.get(productId);
+        if (product == null) {
+            return Result.error("商品不存在: " + productId);
+        }
+        
+        Map<String, Object> stockInfo = new HashMap<>();
+        stockInfo.put("productId", product.getId());
+        stockInfo.put("productName", product.getName());
+        stockInfo.put("stock", product.getStock());
+        stockInfo.put("available", product.getStock() > 0);
+        
+        return Result.OK(stockInfo);
+    }
+    
+    /**
+     * 购买商品(下单)
+     *
+     * @param productId 商品ID
+     * @param quantity 购买数量
+     * @param userId 用户ID(可选)
+     * @return 订单信息
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "购买商品", description = "创建订单,但不立即扣减库存")
+    @PostMapping("/purchase")
+    public Result<Order> purchase(
+            @Parameter(description = "商品ID", required = true) @RequestParam String productId,
+            @Parameter(description = "购买数量", required = true) @RequestParam Integer quantity,
+            @Parameter(description = "用户ID") @RequestParam(required = false) String userId) {
+        
+        log.info("购买商品 - 商品ID: {}, 数量: {}, 用户: {}", productId, quantity, userId);
+        
+        // 参数校验
+        if (quantity == null || quantity <= 0) {
+            return Result.error("购买数量必须大于0");
+        }
+        
+        // 查询商品
+        Product product = productStore.get(productId);
+        if (product == null) {
+            return Result.error("商品不存在: " + productId);
+        }
+        
+        // 检查库存
+        if (product.getStock() < quantity) {
+            return Result.error("库存不足,当前库存: " + product.getStock());
+        }
+        
+        // 创建订单
+        String orderId = "O" + orderIdGenerator.incrementAndGet();
+        BigDecimal totalAmount = product.getPrice().multiply(new BigDecimal(quantity));
+        
+        Order order = new Order();
+        order.setId(orderId);
+        order.setProductId(productId);
+        order.setProductName(product.getName());
+        order.setQuantity(quantity);
+        order.setUnitPrice(product.getPrice());
+        order.setTotalAmount(totalAmount);
+        order.setStatus("pending");
+        order.setCreateTime(new Date());
+        order.setUserId(userId);
+        
+        orderStore.put(orderId, order);
+        
+        log.info("订单创建成功 - 订单ID: {}, 总金额: {}", orderId, totalAmount);
+        return Result.OK(order);
+    }
+    
+    /**
+     * 扣减商品库存
+     *
+     * @param orderId 订单ID
+     * @return 扣减结果
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "扣减商品库存", description = "根据订单ID扣减对应商品库存")
+    @PostMapping("/stock/deduct")
+    public Result<Map<String, Object>> deductStock(
+            @Parameter(description = "订单ID", required = true) @RequestParam String orderId) {
+        
+        log.info("扣减库存 - 订单ID: {}", orderId);
+        
+        // 查询订单
+        Order order = orderStore.get(orderId);
+        if (order == null) {
+            return Result.error("订单不存在: " + orderId);
+        }
+        
+        // 检查订单状态
+        if ("paid".equals(order.getStatus())) {
+            return Result.error("订单已支付,库存已扣减");
+        }
+        
+        if ("cancelled".equals(order.getStatus())) {
+            return Result.error("订单已取消");
+        }
+        
+        // 查询商品
+        Product product = productStore.get(order.getProductId());
+        if (product == null) {
+            return Result.error("商品不存在: " + order.getProductId());
+        }
+        
+        // 检查库存
+        synchronized (product) {
+            if (product.getStock() < order.getQuantity()) {
+                return Result.error("库存不足,当前库存: " + product.getStock() + ", 需要: " + order.getQuantity());
+            }
+            
+            // 扣减库存
+            int newStock = product.getStock() - order.getQuantity();
+            product.setStock(newStock);
+            
+            // 更新订单状态
+            order.setStatus("paid");
+            
+            log.info("库存扣减成功 - 商品: {}, 扣减数量: {}, 剩余库存: {}", 
+                    product.getName(), order.getQuantity(), newStock);
+        }
+        
+        Map<String, Object> result = new HashMap<>();
+        result.put("orderId", orderId);
+        result.put("productId", product.getId());
+        result.put("productName", product.getName());
+        result.put("deductedQuantity", order.getQuantity());
+        result.put("remainingStock", product.getStock());
+        result.put("orderStatus", order.getStatus());
+        
+        return Result.OK(result);
+    }
+    
+    /**
+     * 查询订单详情
+     *
+     * @param orderId 订单ID
+     * @return 订单详情
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "查询订单详情", description = "根据订单ID查询订单信息")
+    @GetMapping("/order")
+    public Result<Order> getOrder(
+            @Parameter(description = "订单ID", required = true) @RequestParam String orderId) {
+        
+        log.info("查询订单 - 订单ID: {}", orderId);
+        
+        Order order = orderStore.get(orderId);
+        if (order == null) {
+            return Result.error("订单不存在: " + orderId);
+        }
+        
+        return Result.OK(order);
+    }
+    
+    /**
+     * 获取所有商品分类
+     *
+     * @return 分类列表
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "获取商品分类", description = "获取所有商品的分类列表")
+    @GetMapping("/categories")
+    public Result<List<String>> getCategories() {
+        
+        Set<String> categories = productStore.values().stream()
+                .map(Product::getCategory)
+                .collect(Collectors.toSet());
+        
+        List<String> categoryList = new ArrayList<>(categories);
+        categoryList.sort(String::compareTo);
+        
+        return Result.OK(categoryList);
+    }
+    
+    /**
+     * 重置所有数据(仅用于测试)
+     *
+     * @return 重置结果
+     * @author chenrui
+     * @date 2025/11/6 14:30
+     */
+    @Operation(summary = "重置数据", description = "清空所有订单并重置商品库存(仅用于测试)")
+    @PostMapping("/reset")
+    public Result<String> reset() {
+        
+        log.info("重置商品和订单数据");
+        
+        orderStore.clear();
+        orderIdGenerator.set(1000);
+        productStore.clear();
+        initProducts();
+        
+        return Result.OK("数据重置成功");
+    }
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/shop/entity/Order.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/shop/entity/Order.java
@@ -0,0 +1,64 @@
+package org.jeecg.modules.demo.shop.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 订单实体
+ * @Author: chenrui
+ * @Date: 2025-11-06
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Order {
+    
+    /**
+     * 订单ID
+     */
+    private String id;
+    
+    /**
+     * 商品ID
+     */
+    private String productId;
+    
+    /**
+     * 商品名称
+     */
+    private String productName;
+    
+    /**
+     * 购买数量
+     */
+    private Integer quantity;
+    
+    /**
+     * 单价
+     */
+    private BigDecimal unitPrice;
+    
+    /**
+     * 总金额
+     */
+    private BigDecimal totalAmount;
+    
+    /**
+     * 订单状态: pending-待支付, paid-已支付, cancelled-已取消
+     */
+    private String status;
+    
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+    
+    /**
+     * 用户信息(可选)
+     */
+    private String userId;
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/shop/entity/Product.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/demo/shop/entity/Product.java
@@ -0,0 +1,48 @@
+package org.jeecg.modules.demo.shop.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+
+/**
+ * 商品实体
+ * @Author: chenrui
+ * @Date: 2025-11-06
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Product {
+    
+    /**
+     * 商品ID
+     */
+    private String id;
+    
+    /**
+     * 商品名称
+     */
+    private String name;
+    
+    /**
+     * 商品价格
+     */
+    private BigDecimal price;
+    
+    /**
+     * 商品分类
+     */
+    private String category;
+    
+    /**
+     * 商品描述
+     */
+    private String description;
+    
+    /**
+     * 库存数量
+     */
+    private Integer stock;
+}
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/controller/DlMockController.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/controller/DlMockController.java
@@ -1,438 +0,0 @@
-package org.jeecg.modules.dlglong.controller;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.jeecg.common.api.vo.Result;
-import org.jeecg.common.system.query.MatchTypeEnum;
-import org.jeecg.common.system.query.QueryCondition;
-import org.jeecg.common.system.query.QueryGenerator;
-import org.jeecg.common.constant.VxeSocketConst;
-import org.jeecg.modules.demo.mock.vxe.websocket.VxeSocket;
-import org.jeecg.modules.dlglong.entity.MockEntity;
-import org.springframework.web.bind.annotation.*;
-
-import jakarta.servlet.http.HttpServletRequest;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URLDecoder;
-import java.util.*;
-
-/**
- * @Description: DlMockController
- * @author: jeecg-boot
- */
-@Slf4j
-@RestController
-@RequestMapping("/mock/dlglong")
-public class DlMockController {
-
-    /**
-     * 模拟更改状态
-     *
-     * @param id
-     * @param status
-     * @return
-     */
-    @GetMapping("/change1")
-    public Result mockChange1(@RequestParam("id") String id, @RequestParam("status") String status) {
-        /* id 为 行的id（rowId），只要获取到rowId，那么只需要调用 VXESocket.sendMessageToAll() 即可 */
-
-        // 封装行数据
-        JSONObject rowData = new JSONObject();
-        // 这个字段就是要更改的行数据ID
-        rowData.put("id", id);
-        // 这个字段就是要更改的列的key和具体的值
-        rowData.put("status", status);
-        // 模拟更改数据
-        this.mockChange(rowData);
-
-        return Result.ok();
-    }
-
-    /**
-     * 模拟更改拖轮状态
-     *
-     * @param id
-     * @param tugStatus
-     * @return
-     */
-    @GetMapping("/change2")
-    public Result mockChange2(@RequestParam("id") String id, @RequestParam("tug_status") String tugStatus) {
-        /* id 为 行的id（rowId），只要获取到rowId，那么只需要调用 VXESocket.sendMessageToAll() 即可 */
-
-        // 封装行数据
-        JSONObject rowData = new JSONObject();
-        // 这个字段就是要更改的行数据ID
-        rowData.put("id", id);
-        // 这个字段就是要更改的列的key和具体的值
-        JSONObject status = JSON.parseObject(tugStatus);
-        rowData.put("tug_status", status);
-        // 模拟更改数据
-        this.mockChange(rowData);
-
-        return Result.ok();
-    }
-
-    /**
-     * 模拟更改进度条状态
-     *
-     * @param id
-     * @param progress
-     * @return
-     */
-    @GetMapping("/change3")
-    public Result mockChange3(@RequestParam("id") String id, @RequestParam("progress") String progress) {
-        /* id 为 行的id（rowId），只要获取到rowId，那么只需要调用 VXESocket.sendMessageToAll() 即可 */
-
-        // 封装行数据
-        JSONObject rowData = new JSONObject();
-        // 这个字段就是要更改的行数据ID
-        rowData.put("id", id);
-        // 这个字段就是要更改的列的key和具体的值
-        rowData.put("progress", progress);
-        // 模拟更改数据
-        this.mockChange(rowData);
-
-        return Result.ok();
-    }
-
-    private void mockChange(JSONObject rowData) {
-        // 封装socket数据
-        JSONObject socketData = new JSONObject();
-        // 这里的 socketKey 必须要和调度计划页面上写的 socketKey 属性保持一致
-        socketData.put("socketKey", "page-dispatch");
-        // 这里的 args 必须得是一个数组，下标0是行数据，下标1是caseId，一般不用传
-        socketData.put("args", new Object[]{rowData, ""});
-        // 封装消息字符串，这里的 type 必须是 VXESocketConst.TYPE_UVT
-        String message = VxeSocket.packageMessage(VxeSocketConst.TYPE_UVT, socketData);
-        // 调用 sendMessageToAll 发送给所有在线的用户
-        VxeSocket.sendMessageToAll(message);
-    }
-
-    /**
-     * 模拟更改【大船待审】状态
-     *
-     * @param status
-     * @return
-     */
-    @GetMapping("/change4")
-    public Result mockChange4(@RequestParam("status") String status) {
-        // 封装socket数据
-        JSONObject socketData = new JSONObject();
-        // 这里的 key 是前端注册时使用的key，必须保持一致
-        socketData.put("key", "dispatch-dcds-status");
-        // 这里的 args 必须得是一个数组，每一位都是注册方法的参数，按顺序传递
-        socketData.put("args", new Object[]{status});
-
-        // 封装消息字符串，这里的 type 必须是 VXESocketConst.TYPE_UVT
-        String message = VxeSocket.packageMessage(VxeSocketConst.TYPE_CSD, socketData);
-        // 调用 sendMessageToAll 发送给所有在线的用户
-        VxeSocket.sendMessageToAll(message);
-
-        return Result.ok();
-    }
-
-    /**
-     * 【模拟】即时保存单行数据
-     *
-     * @param rowData 行数据，实际使用时可以替换成一个实体类
-     */
-    @PutMapping("/immediateSaveRow")
-    public Result mockImmediateSaveRow(@RequestBody JSONObject rowData) throws Exception {
-        System.out.println("即时保存.rowData：" + rowData.toJSONString());
-        // 延时1.5秒，模拟网慢堵塞真实感
-        Thread.sleep(500);
-        return Result.ok();
-    }
-
-    /**
-     * 【模拟】即时保存整个表格的数据
-     *
-     * @param tableData 表格数据（实际使用时可以替换成一个List实体类）
-     */
-    @PostMapping("/immediateSaveAll")
-    public Result mockImmediateSaveAll(@RequestBody JSONArray tableData) throws Exception {
-        // 【注】：
-        // 1、tableData里包含该页所有的数据
-        // 2、如果你实现了“即时保存”，那么除了新增的数据，其他的都是已经保存过的了，
-        //    不需要再进行一次update操作了，所以可以在前端传数据的时候就遍历判断一下，
-        //    只传新增的数据给后台insert即可，否者将会造成性能上的浪费。
-        // 3、新增的行是没有id的，通过这一点，就可以判断是否是新增的数据
-
-        System.out.println("即时保存.tableData：" + tableData.toJSONString());
-        // 延时1.5秒，模拟网慢堵塞真实感
-        Thread.sleep(1000);
-        return Result.ok();
-    }
-
-    /**
-     * 获取模拟数据
-     *
-     * @param pageNo   页码
-     * @param pageSize 页大小
-     * @param parentId 父ID，不传则查询顶级
-     * @return
-     */
-    @GetMapping("/getData")
-    public Result getMockData(
-            @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
-            @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
-            // 父级id，根据父级id查询子级，如果为空则查询顶级
-            @RequestParam(name = "parentId", required = false) String parentId
-    ) {
-        // 模拟JSON数据路径
-        String path = "classpath:org/jeecg/modules/dlglong/json/dlglong.json";
-        // 读取JSON数据
-        JSONArray dataList = readJsonData(path);
-        if (dataList == null) {
-            return Result.error("读取数据失败！");
-        }
-        IPage<JSONObject> page = this.queryDataPage(dataList, parentId, pageNo, pageSize);
-        return Result.ok(page);
-    }
-
-    /**
-     * 获取模拟“调度计划”页面的数据
-     *
-     * @param pageNo   页码
-     * @param pageSize 页大小
-     * @param parentId 父ID，不传则查询顶级
-     * @return
-     */
-    @GetMapping("/getDdjhData")
-    public Result getMockDdjhData(
-            // SpringMVC 会自动将参数注入到实体里
-            MockEntity mockEntity,
-            @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
-            @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
-            // 父级id，根据父级id查询子级，如果为空则查询顶级
-            @RequestParam(name = "parentId", required = false) String parentId,
-            @RequestParam(name = "status", required = false) String status,
-            // 高级查询条件
-            @RequestParam(name = "superQueryParams", required = false) String superQueryParams,
-            // 高级查询模式
-            @RequestParam(name = "superQueryMatchType", required = false) String superQueryMatchType,
-            HttpServletRequest request
-    ) {
-        // 获取查询条件（前台传递的查询参数）
-        Map<String, String[]> parameterMap = request.getParameterMap();
-        // 遍历输出到控制台
-        System.out.println("\ngetDdjhData - 普通查询条件：");
-        for (String key : parameterMap.keySet()) {
-            System.out.println("-- " + key + ": " + JSON.toJSONString(parameterMap.get(key)));
-        }
-        // 输出高级查询
-        try {
-            System.out.println("\ngetDdjhData - 高级查询条件：");
-            // 高级查询模式
-            MatchTypeEnum matchType = MatchTypeEnum.getByValue(superQueryMatchType);
-            if (matchType == null) {
-                System.out.println("-- 高级查询模式：不识别（" + superQueryMatchType + "）");
-            } else {
-                System.out.println("-- 高级查询模式：" + matchType.getValue());
-            }
-            superQueryParams = URLDecoder.decode(superQueryParams, "UTF-8");
-            List<QueryCondition> conditions = JSON.parseArray(superQueryParams, QueryCondition.class);
-            if (conditions != null) {
-                for (QueryCondition condition : conditions) {
-                    System.out.println("-- " + JSON.toJSONString(condition));
-                }
-            } else {
-                System.out.println("-- 没有传递任何高级查询条件");
-            }
-            System.out.println();
-        } catch (Exception e) {
-            log.error("-- 高级查询操作失败：" + superQueryParams, e);
-            e.printStackTrace();
-        }
-
-        /* 注：实际使用中不用写上面那种繁琐的代码，这里只是为了直观的输出到控制台里而写的示例，
-              使用下面这种写法更简洁方便 */
-
-        // 封装成 MyBatisPlus 能识别的 QueryWrapper，可以直接使用这个对象进行SQL筛选条件拼接
-        // 这个方法也会自动封装高级查询条件，但是高级查询参数名必须是superQueryParams和superQueryMatchType
-        QueryWrapper<MockEntity> queryWrapper = QueryGenerator.initQueryWrapper(mockEntity, parameterMap);
-        System.out.println("queryWrapper： " + queryWrapper.getCustomSqlSegment());
-
-        // 模拟JSON数据路径
-        String path = "classpath:org/jeecg/modules/dlglong/json/ddjh.json";
-        String statusValue = "8";
-        if (statusValue.equals(status)) {
-            path = "classpath:org/jeecg/modules/dlglong/json/ddjh_s8.json";
-        }
-        // 读取JSON数据
-        JSONArray dataList = readJsonData(path);
-        if (dataList == null) {
-            return Result.error("读取数据失败！");
-        }
-
-        IPage<JSONObject> page = this.queryDataPage(dataList, parentId, pageNo, pageSize);
-        // 逐行查询子表数据，用于计算拖轮状态
-        List<JSONObject> records = page.getRecords();
-        for (JSONObject record : records) {
-            Map<String, Integer> tugStatusMap = new HashMap<>(5);
-            String id = record.getString("id");
-            // 查询出主表的拖轮
-            String tugMain = record.getString("tug");
-            // 判断是否有值
-            if (StringUtils.isNotBlank(tugMain)) {
-                // 拖轮根据分号分割
-                String[] tugs = tugMain.split(";");
-                // 查询子表数据
-                List<JSONObject> subRecords = this.queryDataPage(dataList, id, null, null).getRecords();
-                // 遍历子表和拖轮数据，找出进行计算反推拖轮状态
-                for (JSONObject subData : subRecords) {
-                    String subTug = subData.getString("tug");
-                    if (StringUtils.isNotBlank(subTug)) {
-                        for (String tug : tugs) {
-                            if (tug.equals(subTug)) {
-                                // 计算拖轮状态逻辑
-                                int statusCode = 0;
-
-                                /* 如果有发船时间、作业开始时间、作业结束时间、回船时间，则主表中的拖轮列中的每个拖轮背景色要即时变色 */
-
-                                // 有发船时间，状态 +1
-                                String departureTime = subData.getString("departure_time");
-                                if (StringUtils.isNotBlank(departureTime)) {
-                                    statusCode += 1;
-                                }
-                                // 有作业开始时间，状态 +1
-                                String workBeginTime = subData.getString("work_begin_time");
-                                if (StringUtils.isNotBlank(workBeginTime)) {
-                                    statusCode += 1;
-                                }
-                                // 有作业结束时间，状态 +1
-                                String workEndTime = subData.getString("work_end_time");
-                                if (StringUtils.isNotBlank(workEndTime)) {
-                                    statusCode += 1;
-                                }
-                                // 有回船时间，状态 +1
-                                String returnTime = subData.getString("return_time");
-                                if (StringUtils.isNotBlank(returnTime)) {
-                                    statusCode += 1;
-                                }
-                                // 保存拖轮状态，key是拖轮的值，value是状态，前端根据不同的状态码，显示不同的颜色，这个颜色也可以后台计算完之后返回给前端直接使用
-                                tugStatusMap.put(tug, statusCode);
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            // 新加一个字段用于保存拖轮状态，不要直接覆盖原来的，这个字段可以不保存到数据库里
-            record.put("tug_status", tugStatusMap);
-        }
-        page.setRecords(records);
-        return Result.ok(page);
-    }
-
-    /**
-     * 模拟查询数据，可以根据父ID查询，可以分页
-     *
-     * @param dataList 数据列表
-     * @param parentId 父ID
-     * @param pageNo   页码
-     * @param pageSize 页大小
-     * @return
-     */
-    private IPage<JSONObject> queryDataPage(JSONArray dataList, String parentId, Integer pageNo, Integer pageSize) {
-        // 根据父级id查询子级
-        JSONArray dataDb = dataList;
-        if (StringUtils.isNotBlank(parentId)) {
-            JSONArray results = new JSONArray();
-            List<String> parentIds = Arrays.asList(parentId.split(","));
-            this.queryByParentId(dataDb, parentIds, results);
-            dataDb = results;
-        }
-        // 模拟分页（实际中应用SQL自带的分页）
-        List<JSONObject> records = new ArrayList<>();
-        IPage<JSONObject> page;
-        long beginIndex, endIndex;
-        // 如果任意一个参数为null，则不分页
-        if (pageNo == null || pageSize == null) {
-            page = new Page<>(0, dataDb.size());
-            beginIndex = 0;
-            endIndex = dataDb.size();
-        } else {
-            page = new Page<>(pageNo, pageSize);
-            beginIndex = page.offset();
-            endIndex = page.offset() + page.getSize();
-        }
-        for (long i = beginIndex; (i < endIndex && i < dataDb.size()); i++) {
-            JSONObject data = dataDb.getJSONObject((int) i);
-            data = JSON.parseObject(data.toJSONString());
-            // 不返回 children
-            data.remove("children");
-            records.add(data);
-        }
-        page.setRecords(records);
-        page.setTotal(dataDb.size());
-        return page;
-    }
-
-    private void queryByParentId(JSONArray dataList, List<String> parentIds, JSONArray results) {
-        for (int i = 0; i < dataList.size(); i++) {
-            JSONObject data = dataList.getJSONObject(i);
-            JSONArray children = data.getJSONArray("children");
-            // 找到了该父级
-            if (parentIds.contains(data.getString("id"))) {
-                if (children != null) {
-                    // addAll 的目的是将多个子表的数据合并在一起
-                    results.addAll(children);
-                }
-            } else {
-                if (children != null) {
-                    queryByParentId(children, parentIds, results);
-                }
-            }
-        }
-        results.addAll(new JSONArray());
-    }
-
-    private JSONArray readJsonData(String path) {
-        try {
-            InputStream stream = getClass().getClassLoader().getResourceAsStream(path.replace("classpath:", ""));
-            if (stream != null) {
-                String json = IOUtils.toString(stream, "UTF-8");
-                return JSON.parseArray(json);
-            }
-        } catch (IOException e) {
-            log.error(e.getMessage(), e);
-        }
-        return null;
-    }
-
-    /**
-     * 获取车辆最后一个位置
-     *
-     * @return
-     */
-    @PostMapping("/findLatestCarLngLat")
-    public List findLatestCarLngLat() {
-        // 模拟JSON数据路径
-        String path = "classpath:org/jeecg/modules/dlglong/json/CarLngLat.json";
-        // 读取JSON数据
-        return readJsonData(path);
-    }
-
-    /**
-     * 获取车辆最后一个位置
-     *
-     * @return
-     */
-    @PostMapping("/findCarTrace")
-    public List findCarTrace() {
-        // 模拟JSON数据路径
-        String path = "classpath:org/jeecg/modules/dlglong/json/CarTrace.json";
-        // 读取JSON数据
-        return readJsonData(path);
-    }
-
-}
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/entity/MockEntity.java
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/entity/MockEntity.java
@@ -1,27 +0,0 @@
-package org.jeecg.modules.dlglong.entity;
-
-import lombok.Data;
-
-/**
- * 模拟实体
- * @author: jeecg-boot
- */
-@Data
-public class MockEntity {
-
-    /**
-     * id
-     */
-    private String id;
-    /**
-     * 父级ID
-     */
-    private String parentId;
-    /**
-     * 状态
-     */
-    private String status;
-
-    /* -- 省略其他字段 -- */
-
-}
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/CarLngLat.json
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/CarLngLat.json
@@ -1,14 +0,0 @@
-[
-  {
-    "id": "6891ba44421aa907bcb7390c",
-    "alarm": "0",
-    "altitude": "13",
-    "direction": "0",
-    "latitude": "38.918739",
-    "longitude": "117.758737",
-    "speed": "11",
-    "status": "4980739",
-    "timestamp": "2025-08-05T16:01:07",
-    "imei": "18441136860"
-  }
-]
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/CarTrace.json
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/CarTrace.json
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/ddjh.json
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/ddjh.json
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/ddjh_s8.json
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/ddjh_s8.json
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/dlglong.json
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/java/org/jeecg/modules/dlglong/json/dlglong.json
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_comm.png
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_comm.png
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_comm1.png
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_comm1.png
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_down.png
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_down.png
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_down1.png
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/content_down1.png
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/index.gif
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/index.gif
--- a/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/index1.gif
+++ b/jeecg-boot/jeecg-boot-module/jeecg-module-demo/src/main/resources/static/bigscreen/template1/images/index1.gif
--- a/Show More
+++ b/Show More