注解使用错误

# Conflicts:
#	.gitignore

.github/ISSUE_TEMPLATE/bug_report.md

@@ -10,6 +10,9 @@ assignees: getActivity
 ##### 版本号：
 
 
+##### 分支：
+
+
 ##### 问题描述：
 
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -6,10 +6,12 @@ assignees: getActivity
 
 ---
 
-
 ##### 版本号：
 
 
+##### 分支：
+
+
 ##### 问题描述：
 
 

.gitignore

@@ -13,3 +13,5 @@ os_del.cmd
 os_del_doc.cmd
 .svn
 derby.log
+.cursor
+.history

README-AI.md

@@ -0,0 +1,177 @@
+AIGC应用平台介绍
+===============
+
+一个全栈式 AI 开发平台，旨在帮助开发者快速构建和部署个性化的 AI 应用。
+
+> JDK说明：AI流程编排引擎暂时不支持jdk21，所以目前只能使用jdk8或者jdk17启动项目。
+
+
+JeecgBoot平台的AIGC功能模块，是一套类似`Dify`的`AIGC应用开发平台`+`知识库问答`，是一款基于LLM大语言模型AI应用平台和 RAG 的知识库问答系统。
+其直观的界面结合了 AI 流程编排、RAG 管道、知识库管理、模型管理、对接向量库、实时运行可观察等，让您可以快速从原型到生产，拥有AI服务能力。
+
+
+
+### AI视频介绍
+
+[![](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/jeecg_aivideo.png)](https://www.bilibili.com/video/BV1zmd7YFE4w)
+
+
+##### 功能大模块
+
+- AI应用开发平台
+- AI知识库系统
+- AI大模型管理
+- AI流程编排
+- AI对话支持图片
+- AI对话助手(智能问答)
+- AI建表（Online表单）
+- AI写文章（CMS）
+- AI表单字段建议（表单设计器）
+
+
+
+#### Dify `VS` JEECG AI
+
+> JEECG AI与Dify相比，在多个方面展现出显著的优势，特别是在文档处理、格式和图片保持方面。以下是一些具体的优点：
+> - Markdown文档库导入：
+> JEECG AI允许用户直接导入整个Markdown文档库，这不仅保留markdown格式，还支持图片的导入，确保文档内容的完整性和可视化效果。
+> - 对话回复格式美观：
+> 在对话过程中，JEECG AI能够保持回复内容的原格式，也不丢失图片，使得输出的文章更加美观，不会出现格式错乱的情况，还支持图片的渲染。
+> - PDF文档导入与格式转换：
+> JEECG AI在处理PDF文档时，能够更好地保持原始格式和图片，确保转换后的内容与原始文档一致。这个功能在许多AI产品中表现不佳，而JEECG AI在这方面做出了显著的优化
+
+
+| 功能         | Dify             | Jeecg AI                                |
+|------------|------------------|-----------------------------------------|
+| AI工作流      | 有                | 有                                       |
+| RAG 管道向量搜索 | 有                | 有                                       |
+| AI模型管理     | 有                | 有                                       |
+| AI应用管理     | 有                | 有                                       |
+| AI知识库      | 有                | 有                                       |
+| 产品方向       | 一款独立的 LLM 应用开发平台 | 低代码与AIGC应用二者结合的平台                       |
+| 业务集成       | 业务集成能力弱          | 更方便与业务系统集成，调用系统接口和逻辑更加方便                |
+| AI业务流      | 侧重AI逻辑流程         | AI流程编排作为低代码的业务引擎，用户可以通过AI流程配置各种业务流和AI流程 |
+| 实现语言       | python + react | JAVA + vue3                             |
+| 上传markdown文档库(支持图片) | 不支持 | 支持 |
+| AI对话支持发图和展示图片 | 支持 | 支持 |
+
+
+
+### 技术文档
+
+- [AIGC开发文档](https://help.jeecg.com/aigc)
+- [安装向量库 pgvector](https://help.jeecg.com/aigc/config)
+
+
+
+## 功能特点
+
+- AI流程: 提供强大的AI流程设计器引擎，支持编排 AI 工作过程，满足复杂业务场景，支持画布上构建和实时运行查看 AI流程运行情况。
+- AI流程即服务: 通过AI流程编排你需要的智能体，结合AI+自定义开发节点 实现功能性 API，让你瞬间拥有各种智能体API。
+- AI助手对话功能: 集成 ChatGPT、Deepseek、智普、私有大模型 等 AI 模型，提供智能对话和生成式 AI 功能，深度与知识库结合提供更精准的知识。
+- RAG 功能: 涵盖从文档摄入到检索的所有内容，支持从 PDF、PPT 和其他常见文档格式中提取文本，支持检索增强生成（RAG），将未训练数据与 AI 模型集成，提升智能交互能力。
+- AI 知识库: 通过导入文档或已有问答对进行训练，让 AI 模型能根据文档以交互式对话方式回答问题。
+- 模型管理：支持对接各种大模型，包括本地私有大模型（Deepseek/ Llama 3 / Qwen 2 等）、国内公共大模型（通义千问 / 腾讯混元 / 字节豆包 / 百度千帆 / 智谱 AI / Kimi 等）和国外公共大模型（OpenAI / Claude / Gemini 等）；
+- 无缝嵌入：Iframe一键嵌入,支持将AI聊天助手快速嵌入到第三方系统，让系统快速拥有智能问答能力，提高用户满意度。
+
+
+
+
+#### 在线体验
+
+- JeecgBoot演示：  https://boot3.jeecg.com
+- 敲敲云在线搭建AI知识库：https://app.qiaoqiaoyun.com
+
+
+## 技术交流
+
+- 开发文档：https://help.jeecg.com/aigc 
+- QQ群：964611995、716488839(满)
+
+
+## 功能列表
+
+- AI应用管理(普通应用、高级流程应用)
+- AI模型管理
+- AI知识库
+- AI应用平台(普通、对接AI流程)
+- AI流程编排
+- AI聊天支持嵌入第三方
+- AI向量库对接
+
+
+
+## 支持AI模型
+
+| AI大模型         |  支持   |
+|---------------| --- |
+| DeepSeek      |  √   |
+| ChatGTP       |  √   |
+| Qwq           |  √   |
+| 智库            |  √   |
+| Ollama本地搭建大模型 |  √   |
+| 等等。。          |  √   |
+
+
+
+
+##  AIGC能做什么
+
+AIGC模块是一个基于AI的自动化流程编排工具和聊天应用搭建平台，它可以帮助用户快速生成AI流程接口和聊天应用，提高效率。
+以下是一些具体的应用场景和示例：
+
+- 你可能需要一个翻译接口，可以通过AI流程编排搭建出来。
+- 你可能需要一个接口转换工具，可以通过AI流程编排搭建出来。（比如：jimureport所需要接口返回格式与你的系统不同，你通过AI接口实现自动转换）
+- 你可能需要一个聊天机器人，可以通过AI流程编排搭建出来。
+- 你可能需要一个自动化流程，可以通过AI流程编排搭建出来。
+- 你可能需要一个自动化处理文件的流程，可以通过AI流程结合python脚本实现操作电脑，文件等。
+
+
+## AI应用平台功能展示
+
+AI模型列表
+
+![](https://oscimg.oschina.net/oscnet//a5fb3e0d69ca1706b0de221535c7acaa.png)
+
+选择AI模型，配置你的参数
+
+![](https://oscimg.oschina.net/oscnet//1f941472758a5fc227f54f2683953b8e.png)
+
+
+AI知识库支持手工录入文本，导入pdf\\word\\excel等文档，支持问答对训练
+
+![](https://oscimg.oschina.net/oscnet//150bb33f48d6c8e2ae059e2a58f4200b.png)
+
+![](https://oscimg.oschina.net/oscnet//032d16c915b0f79318935484c81df260.png)
+
+
+
+AI流程，提供强大的AI流程设计器引擎，支持编排 AI 工作过程，满足复杂业务场景，支持画布上构建和实时运行查看 AI流程运行情况。
+
+![](https://oscimg.oschina.net/oscnet//f40f9aa275cd4aea94e1c209513151e2.png)
+
+
+目前支持的节点有：开始、结束、AI知识库节点、AI节点、分类节点、分支节点、JAVA节点、脚本节点、子流程节点、http请求节点、直接回复节点等节点
+
+![](https://oscimg.oschina.net/oscnet//6d86480ab1bbfab5b2e6992b416b2152.png)
+
+节点项配置
+
+![](https://oscimg.oschina.net/oscnet//90a5f76b6b4fc406e2e2b87245b35459.png)
+
+在线运行看结果
+
+![](https://oscimg.oschina.net/oscnet//bc9817a7bbd94936a5a3e885abe3cb38.png)
+
+
+AI应用配置，支持AI流程配置和简单的AI配置
+
+![](https://oscimg.oschina.net/oscnet//a853d9be4d3756806799ad025e722df8.png)![](https://oscimg.oschina.net/oscnet//d3bcbf5977c6fb75a8f996e1e40590be.png)
+
+可以关联多个知识库，右侧是AI智能回复，你可以搭建自己的智能体，比如搭建一个 “诗词达人” “翻译助手”
+
+![](https://oscimg.oschina.net/oscnet//c26a848136be3e22ec1e0651e78976c2.png)
+
+可以将创建的聊天应用，集成到第三方系统中
+
+![](https://oscimg.oschina.net/oscnet//39c6f589ef46f0454b229915ffa263f4.png)

README-EN.md

@@ -7,12 +7,12 @@
 JEECG BOOT AI Low Code Platform
 ===============
 
-Current version: 3.7.3 (Release date: 2025-02-10)
+Current version: 3.8.3 (Release date: 2025-10-09)
 
 
 [![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.7.3-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/version-3.8.2-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)
 
@@ -21,7 +21,7 @@ Current version: 3.7.3 (Release date: 2025-02-10)
 Project introduction
 -----------------------------------
 
-<h3 align="center">Java AI Low Code Platform for Enterprise web applications</h3>
+<h3 align="center">Java AI Low Code Platform</h3>
 
 JeecgBoot is a `AI low code platform` based on code `generators`! Front and back end separation architecture SpringBoot2.x, SpringCloud, Ant Design&Vue, Mybatis plus, Shiro, JWT, support for microservices. The powerful code generator makes the front and back end of the code generation, low code development! JeecgBoot leads a new low-code development paradigm (OnlineCoding-> Code Generator -> Manual MERGE) that helps resolve 70% of the duplication in Java projects and makes development more business-focused. Not only can quickly improve efficiency, save research and development costs, but also do not lose flexibility!
 
@@ -37,7 +37,7 @@ AI Empowering Low-Code: Currently, JeecgBoot supports AI large models such as Ch
 Technical support
 -----------------------------------
 
-Problems or bugs in use can be found in [Making on the Issues](https://github.com/jeecgboot/JeecgBoot/issues/new)
+Problems or bugs in use can be found in [Making on the Issues](https://github.com/jeecgboot/JeecgBoot/issues/new?template=bug_report.md)
 
 
 ##### Project description
@@ -49,6 +49,11 @@ Problems or bugs in use can be found in [Making on the Issues](https://github.co
 | `jeecg-uniapp` | [APP development framework, a code multi terminal adaptation, and support APP, small program, H5](https://github.com/jeecgboot/jeecg-uniapp) |
 
 
+### Video Introduction
+
+[![](https://upload.jeecg.com/jeecg/qiaoqiaoyunsite/jeecgvideo02.png)](https://www.bilibili.com/video/BV1Nk4y1o7Qc)
+
+
 
 Download other source code
 -----------------------------------
@@ -64,9 +69,13 @@ Jeecg-Boot AI low code platform can be applied in the development of any J2EE pr
 Starts the project
 -----------------------------------
 
-- [IDEA Quick start](https://help.jeecg.com/java/setup/idea/startup.html)
-- [Docker Quick start](https://help.jeecg.com/java/docker/quick.html)
+> Default account password： admin/123456
 
+- [Development Environment setup](https://help.jeecg.com/java/setup/tools)
+- [IDEA Quick start(single model)](https://help.jeecg.com/java/setup/idea/startup)
+- [Docker Quick start(single model)](https://help.jeecg.com/java/docker/quick)
+- [IDEA Quick start(microservices model)](https://help.jeecg.com/java/springcloud/switchcloud/monomer)
+- [Docker Quick start(microservices model)](https://help.jeecg.com/java/docker/quickcloud)
 
 
 Technical documentation
@@ -74,9 +83,9 @@ Technical documentation
 
 - Website：  [http://www.jeecg.com](http://www.jeecg.com)
 - Demo ： [OnlineDemo](http://boot3.jeecg.com) | [APP](http://jeecg.com/appIndex)
-- Doc：  [DocumentCenter](http://help.jeecg.com) | [AI Config](https://help.jeecg.com/java/ai/aichat.html)
+- Doc：  [DocumentCenter](http://help.jeecg.com) | [AI Config](https://help.jeecg.com/java/ai/aichat)
 - Newbie guide： [Quick start](http://www.jeecg.com/doc/quickstart) |   [Q&A ](http://www.jeecg.com/doc/qa)  |  [1 minute experience](https://my.oschina.net/jeecg/blog/3083313)
-- QQ group ： ⑩716488839、⑨808791225、⑧825232878、⑦791696430、⑥730954414(full)、683903138(full)、⑤860162132(full)、④774126647(full)、③816531124(full)、②769925425(full)、①284271917(full)
+- QQ group ： 964611995、⑩716488839(满)、⑨808791225(满)
 
 
 
@@ -176,7 +185,7 @@ Technical Architecture:
 
 #### Development Environment
 
-- Language: Java 8+ (17)
+- Language: Java Default Jdk17(support jdk8、jdk21)
 
 - IDE(JAVA) : IDEA (lombok plug-in must be installed)
 
@@ -193,17 +202,17 @@ Technical Architecture:
 
 - Basic framework: Spring Boot 2.7.18
 
-- Microservice framework: Spring Cloud Alibaba 2021.0.1.0
+- Microservice framework: Spring Cloud Alibaba 2021.0.6.2
 
 - Persistence layer framework: MybatisPlus 3.5.3.2
 
-- Report tool: JimuReport 1.9.3
+- Report tool: JimuReport 1.9.5
 
-- Security framework: Apache Shiro 1.12.0, Jwt 3.11.0
+- Security framework: Apache Shiro 1.13.0, Jwt 4.5.0
 
 - Microservice technology stack: Spring Cloud Alibaba, Nacos, Gateway, Sentinel, Skywalking
 
-- Database connection pool: Alibaba Druid 1.1.22
+- Database connection pool: Alibaba Druid 1.1.24
 
 - Log printing: logback
 
@@ -242,8 +251,16 @@ Technical Architecture:
 | --- | --- |
 | DeepSeek | √ |
 | ChatGPT | √ |
+| Qwq | √ |
+| 智库 | √ |
+| Ollama本地搭建大模型 | √ |
+| 等等。。 | √ |
+
+
+AI Config： https://help.jeecg.com/java/ai/aichat
+
+AI APP: https://help.jeecg.com/aigc
 
-AI Config： https://help.jeecg.com/java/ai/aichat.html
 
 ## Microservice solutions
 
@@ -255,7 +272,7 @@ AI Config： https://help.jeecg.com/java/ai/aichat.html
 - 6. Distributed files Minio and Alioss √
 - 7. Unified permission control
 - 8. Service monitoring SpringBootAdmin√
-- 9. link tracking Skywalking  [reference document](https://help.jeecg.com/java/springcloud/super/skywarking.html)
+- 9. link tracking Skywalking  [reference document](https://help.jeecg.com/java/springcloud/super/skywarking)
 - 10. Messaging middleware RabbitMQ √
 - 11. Distributed task xxl-job √
 - 12. Distributed Transaction Seata
@@ -272,8 +289,8 @@ AI Config： https://help.jeecg.com/java/ai/aichat.html
 ![功能蓝图](https://jeecgos.oss-cn-beijing.aliyuncs.com/upload/test/Jeecg-Boot-lantu202005_1590912449914.jpg "在这里输入图片标题")
 
 ### quick start
-- Microservice Development：  [Monomer upgrade to microservice](https://help.jeecg.com/java/springcloud/switchcloud/monomer.html)
-- [Docker starts the micro-service background](https://help.jeecg.com/java/docker/springcloud.html)
+- Microservice Development：  [Monomer upgrade to microservice](https://help.jeecg.com/java/springcloud/switchcloud/monomer)
+- [Docker starts the micro-service background](https://help.jeecg.com/java/docker/springcloud)
 
 
 ### Effect of system

README-Enterprise.md

@@ -0,0 +1,124 @@
+
+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)

README.md

@@ -2,12 +2,13 @@
 JeecgBoot AI低代码平台
 ===============
 
-当前最新版本： 3.7.3（发布日期：2025-02-10） 
+当前最新版本： 3.8.3（发布日期：2025-10-09） 
 
 
 [![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)](http://guojusoft.com)
-[![](https://img.shields.io/badge/version-3.7.3-brightgreen.svg)](https://github.com/jeecgboot/JeecgBoot)
+[![](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)
 [![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)
 
@@ -16,45 +17,50 @@ JeecgBoot AI低代码平台
 项目介绍
 -----------------------------------
 
-<h3 align="center">Java AI Low Code Platform for Enterprise web applications</h3>
+<h3 align="center">企业级AI低代码平台</h3>
 
-JeecgBoot 是一款基于`BPM`和`代码生成器`的 AI低代码平台！前后端分离架构 SpringBoot2.x/3.x，SpringCloud，Ant Design Vue3，Mybatis-plus，Shiro，JWT，支持微服务、多租户;支持 AI 大模型 DeepSeek 和 ChatGPT、Ollama本地模型; 强大的代码生成器让前后端代码一键生成，无需写任何代码!  JeecgBoot 引领 AI 低代码开发模式(AI生成-> OnlineCoding-> 代码生成器-> 手工MERGE)， 帮助解决Java项目80%的重复工作，让开发更多关注业务。既能快速提高效率，节省成本，同时又不失灵活性！AIGC能力：AI对话助手、AI建表、AI写文章、AI流程编排、AI知识库问答等等.
+JeecgBoot 是一款基于BPM流程和代码生成的AI低代码平台，助力企业快速实现低代码开发和构建AI应用。
+采用前后端分离架构（Ant Design&Vue3，SpringBoot3，SpringCloud Alibaba，Mybatis-plus），强大代码生成器实现前后端一键生成，无需手写代码。 
+平台引领AI低代码开发模式：AI生成→在线编码→代码生成→手工合并，解决Java项目80%重复工作，提升效率，节省成本，兼顾灵活性。 
+具备强大且颗粒化的权限控制，支持按钮权限和数据权限设置，满足大型业务系统需求。功能涵盖在线表单、表单设计、流程设计、门户设计、报表与大屏设计、OA办公、AI应用、AI知识库、大模型管理、AI流程编排、AI聊天，支持ChatGPT、DeepSeek、Ollama等多种AI大模型。
 
-JeecgBoot 提供了一系列 `AI能力` `低代码模块`，实现在线开发`真正的零代码`：Online表单开发、Online报表、报表配置能力、在线图表设计、仪表盘设计、大屏设计、移动配置能力、表单设计器、在线设计流程、流程自动化配置、插件能力（可插拔）、AI对话助手，AI建表、AI写文章、AI流程编排、AI知识库问答、AI赋能低代码等等！
+`AI赋能报表:` 积木报表是一款自主研发的强大开源企业级Web报表与大屏工具。它通过零编码的拖拽式操作，赋能用户如同搭积木般轻松构建各类复杂报表和数据大屏，全面满足企业数据可视化与分析需求，助力企业级数据产品的高效打造与应用。
+
+`AI赋能低代码:` 提供完善成熟的AI应用平台，涵盖AI应用管理、AI模型管理、智能对话助手、知识库问答、流程编排与设计器、AI建表等多项功能。平台兼容多种主流大模型，包括ChatGPT、DeepSeek、Ollama、智普、千问等，助力企业高效构建智能化应用，推动低代码开发与AI深度融合。
+
+`JEECG宗旨是:` JEECG旨在通过OnlineCoding平台实现简单功能的零代码快速搭建，同时针对复杂功能采用代码生成器生成代码并手工合并，打造智能且灵活的低代码开发模式，有效解决了当前低代码产品普遍缺乏灵活性的问题，提升开发效率的同时兼顾系统的扩展性和定制化能力。
+
+`JEECG业务流程:` JEECG业务流程采用BPM工作流引擎实现业务审批，扩展任务接口供开发人员编写业务逻辑，表单提供表单设计器、在线配置表单和编码表单等多种解决方案。通过流程与表单的分离设计（松耦合）及任务节点的灵活配置，既保障了企业流程的安全性与保密性，又大幅降低了开发人员的工作量。
 
 
-`JEECG宗旨是:` 简单功能由OnlineCoding配置实现，做到`零代码开发`；复杂功能由代码生成器生成进行手工Merge 实现`低代码开发`，既保证了`智能`又兼顾`灵活`；实现了低代码开发的同时又支持灵活编码，解决了当前低代码产品普遍不灵活的弊端！
 
-`JEECG业务流程:` 采用工作流来实现、扩展出任务接口，供开发编写业务逻辑，表单提供多种解决方案： 表单设计器、online配置表单、编码表单。同时实现了流程与表单的分离设计（松耦合）、并支持任务节点灵活配置，既保证了公司流程的保密性，又减少了开发人员的工作量。
-
-`AI赋能低代码:` 目前JeecgBoot支持AI大模型`ChatGPT`和`DeepSeek`，现在最新版默认使用`DeepSeek`，速度更快质量更高。目前提供了AI对话助手、AI建表、AI报表、AI写文章、AI流程编排、AI知识库问答等功能。
 
 
 适用项目
 -----------------------------------
-JeecgBoot AI低代码平台，可以应用在任何J2EE项目的开发中，支持信创国产化（默认适配达梦和人大金仓）。尤其适合SAAS项目、企业信息管理系统（MIS）、内部办公系统（OA）、企业资源计划系统（ERP）、客户关系管理系统（CRM）等，其半智能手工Merge的开发方式，可以显著提高开发效率70%以上，极大降低开发成本。
+JeecgBoot低代码平台兼容所有J2EE项目开发，支持信创国产化，特别适用于SAAS、企业信息管理系统（MIS）、内部办公系统（OA）、企业资源计划系统（ERP）、客户关系管理系统（CRM）及AI知识库等场景。其半智能手工Merge开发模式，可显著提升70%以上的开发效率，极大降低开发成本。同时，JeecgBoot还是一款全栈式AI开发平台，助力企业快速构建和部署个性化AI应用。。
 
 
-#### 项目说明
-
-| 项目名                | 说明                     | 
-|--------------------|------------------------|
-| `jeecg-boot`    | 后端源码JAVA（SpringBoot微服务架构）        |
-| `jeecgboot-vue3` | 前端源码VUE3（vue3+vite6+ts最新技术栈）  |
-| `jeecg-uniapp` | [配套APP框架](https://github.com/jeecgboot/jeecg-uniapp) 适配多个终端，支持APP、小程序、H5 |
+**信创兼容说明**
+- 操作系统：国产麒麟、银河麒麟等国产系统几乎都是基于 Linux 内核，因此它们具有良好的兼容性。
+- 数据库：达梦、人大金仓、TiDB
+- 中间件：东方通 TongWeb、TongRDS，宝兰德 AppServer、CacheDB, [信创配置文档](https://help.jeecg.com/java/tongweb-deploy/)
 
 
-
-技术文档
+版本说明
 -----------------------------------
 
-- 官方网站：  [http://www.jeecg.com](http://www.jeecg.com)
-- 在线演示 ：  [在线演示](http://boot3.jeecg.com)   | [APP演示](http://jeecg.com/appIndex)
-- 快速体验： [一分钟体验低代码](https://jeecg.blog.csdn.net/article/details/106079007?spm=1001.2014.3001.5502 "一分钟体验零代码") | [在线体验零代码](https://app.qiaoqiaoyun.com/myapps/index "在线体验零代码")
-- 开发文档：  [文档中心](https://help.jeecg.com) | [AI集成配置(支持DeepSeek)](https://help.jeecg.com/java/ai/aichat.html)
-- 反馈问题：  [在Github上提Issues](https://github.com/jeecgboot/JeecgBoot/issues/new)
-- 新手指南： [快速入门](http://www.jeecg.com/doc/quickstart) | [入门视频](http://jeecg.com/doc/video)
-- QQ交流群 ： ⑩716488839、⑨808791225(满)、其他(满)
+|下载 | 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)     分支 |
+
+
+- `jeecg-boot` 是后端JAVA源码项目Springboot3+SpringCloudAlibaba（支持单体和微服务切换）.
+- `jeecgboot-vue3` 是前端VUE3源码项目（vue3+vite6+ts最新技术栈）.
+- `JeecgUniapp`  是[配套APP框架](https://github.com/jeecgboot/JeecgUniapp) 适配多个终端，支持APP、小程序、H5、鸿蒙、鸿蒙Next.
+- 参考 [文档](https://help.jeecg.com/ui/2dev/mini) 可以删除不需要的demo，制作一个精简版本
+
 
 
 
@@ -62,69 +68,126 @@ JeecgBoot AI低代码平台，可以应用在任何J2EE项目的开发中，支
 启动项目
 -----------------------------------
 
-- [IDEA启动前后端项目](https://help.jeecg.com/java/setup/idea/startup.html)
-- [Docker一键启动前后端](https://help.jeecg.com/java/docker/quick.html)
+> 默认账号密码： admin/123456
+
+- [开发环境搭建](https://help.jeecg.com/java/setup/tools)
+- [IDEA启动前后端(单体模式)](https://help.jeecg.com/java/setup/idea/startup)
+- [Docker一键启动(单体模式)](https://help.jeecg.com/java/docker/quick)
+- [IDEA启动前后端(微服务方式)](https://help.jeecg.com/java/springcloud/switchcloud/monomer)
+- [Docker一键启动(微服务方式)](https://help.jeecg.com/java/docker/quickcloud)
 
 
-AIGC功能清单
+技术文档
 -----------------------------------
 
-- AI对聊天助手
-- AI建表（Online表单）
-- AI写文章（CMS）
-- AI表单建议（表单设计器）
-- AI流程编排（研发中）
-- AI知识库问答系统（研发中）
-- AI应用开发平台（研发中）
-- AI聊天窗口支持嵌入第三方（研发中）
+- 官方网站：  [http://www.jeecg.com](http://www.jeecg.com)
+- 在线演示：  [平台演示](https://boot3.jeecg.com) | [APP演示](https://jeecg.com/appIndex)
+- 入门指南：  [快速入门](http://www.jeecg.com/doc/quickstart)  | [代码生成使用](https://help.jeecg.com/java/codegen/online) | [开发文档](https://help.jeecg.com)  | [AI应用手册](https://help.jeecg.com/aigc) | [视频教程](http://jeecg.com/doc/video)
+- AI编程实战视频：  [JEECG低代码与Cursor+GitHub Copilot实现AI高效编程实战](https://www.bilibili.com/video/BV11XyaBVEoH)
+- 技术支持：  [反馈问题](https://github.com/jeecgboot/JeecgBoot/issues/new?template=bug_report.md)    | [低代码体验一分钟](https://jeecg.blog.csdn.net/article/details/106079007) 
+- QQ交流群 ： 964611995、⑩716488839(满)、⑨808791225(满)、其他(满)
 
 
-<b>关注公众号获取最新版资讯</b>
+AI 应用平台介绍
+-----------------------------------
+
+一个全栈式 AI 开发平台，旨在帮助开发者快速构建和部署个性化的 AI 应用。
+
+JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类似`Dify`的`AIGC应用开发平台`+`知识库问答`，是一款基于LLM大语言模型AI应用平台和 RAG 的知识库问答系统。
+其直观的界面结合了 AI 流程编排、RAG 管道、知识库管理、模型管理、对接向量库、实时运行可观察等，让您可以快速从原型到生产，拥有AI服务能力。 
+
+- [详细专题介绍，请点击查看](README-AI.md)
+
+- AI视频介绍
+
+[![](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/jeecg_aivideo.png)](https://www.bilibili.com/video/BV1zmd7YFE4w)
+
+
+为什么选择JeecgBoot?
+-----------------------------------
+- 1.采用最新主流前后分离框架（Spring Boot3 + MyBatis + Shiro/SpringAuthorizationServer + Ant Design4 + Vue3），容易上手；代码生成器依赖性低，灵活的扩展能力，可快速实现二次开发。
+- 2.前端大版本换代，最新版采用 Vue3.0 + TypeScript + Vite6 + Ant Design Vue4 等新技术方案。
+- 3.支持微服务Spring Cloud Alibaba（Nacos、Gateway、Sentinel、Skywalking），提供简易机制，支持单体和微服务自由切换（这样可以满足各类项目需求）。
+- 4.开发效率高，支持在线建表和AI建表，提供强大代码生成器，单表、树列表、一对多、一对一等数据模型，增删改查功能一键生成，菜单配置直接使用。
+- 5.代码生成器提供强大模板机制，支持自定义模板，目前提供四套风格模板（单表两套、树模型一套、一对多三套）。
+- 6.提供强大的报表和大屏可视化工具，支持丰富的数据源连接，能够通过拖拉拽方式快速制作报表、大屏和门户设计；支持多种图表类型：柱形图、折线图、散点图、饼图、环形图、面积图、漏斗图、进度图、仪表盘、雷达图、地图等。
+- 7.低代码能力：在线表单（无需编码，通过在线配置表单，实现表单的增删改查，支持单表、树、一对多、一对一等模型，实现人人皆可编码），在线配置零代码开发、所见即所得支持23种类控件。
+- 8.低代码能力：在线报表、在线图表（无需编码，通过在线配置方式，实现数据报表和图形报表，可以快速抽取数据，减轻开发压力，实现人人皆可编码）。
+- 9.Online支持在线增强开发，提供在线代码编辑器，支持代码高亮、代码提示等功能，支持多种语言（Java、SQL、JavaScript等）。
+- 10.封装完善的用户、角色、菜单、组织机构、数据字典、在线定时任务等基础功能，支持访问授权、按钮权限、数据权限等功能。
+- 11.前端UI提供丰富的组件库，支持各种常用组件，如表格、树形控件、下拉框、日期选择器等，满足各种复杂的业务需求 [UI组件库文档](https://help.jeecg.com/category/ui%E7%BB%84%E4%BB%B6%E5%BA%93)。
+- 12.提供APP配套框架，一份多代码多终端适配，一份代码多终端适配，小程序、H5、安卓、iOS、鸿蒙Next。
+- 13.新版APP框架采用Uniapp、Vue3.0、Vite、Wot-design-uni、TypeScript等最新技术栈，包括二次封装组件、路由拦截、请求拦截等功能。实现了与JeecgBoot完美对接：目前已经实现登录、用户信息、通讯录、公告、移动首页、九宫格、聊天、Online表单、仪表盘等功能，提供了丰富的组件。
+- 14.提供了一套成熟的AI应用平台功能，从AI模型、知识库到AI应用搭建，助力企业快速落地AI服务，加速智能化升级。
+- 15.AI能力：目前JeecgBoot支持AI大模型chatgpt和deepseek，现在最新版默认使用deepseek，速度更快质量更高。目前提供了AI对话助手、AI知识库、AI应用、AI建表、AI报表等功能。
+- 16.提供新行编辑表格JVXETable，轻松满足各种复杂ERP布局，拥有更高的性能、更灵活的扩展、更强大的功能。
+- 17.平台首页风格，提供多种组合模式，支持自定义风格；支持门户设计，支持自定义首页。
+- 18.常用共通封装，各种工具类（定时任务、短信接口、邮件发送、Excel导入导出等），基本满足80%项目需求。
+- 19.简易Excel导入导出，支持单表导出和一对多表模式导出，生成的代码自带导入导出功能。
+- 20.集成智能报表工具，报表打印、图像报表和数据导出非常方便，可极其方便地生成PDF、Excel、Word等报表。
+- 21.采用前后分离技术，页面UI风格精美，针对常用组件做了封装：时间、行表格控件、截取显示控件、报表组件、编辑器等。
+- 22.查询过滤器：查询功能自动生成，后台动态拼SQL追加查询条件；支持多种匹配方式（全匹配/模糊查询/包含查询/不匹配查询）。
+- 23.数据权限（精细化数据权限控制，控制到行级、列表级、表单字段级，实现不同人看不同数据，不同人对同一个页面操作不同字段）。
+- 24.接口安全机制，可细化控制接口授权，非常简便实现不同客户端只看自己数据等控制；也提供了基于AK和SK认证鉴权的OpenAPI功能。
+- 25.活跃的社区支持；近年来，随着网络威胁的日益增加，团队在安全和漏洞管理方面积累了丰富的经验，能够为企业提供全面的安全解决方案。
+- 26.权限控制采用RBAC（Role-Based Access Control，基于角色的访问控制）。
+- 27.页面校验自动生成（必须输入、数字校验、金额校验、时间空间等）。
+- 28.支持SaaS服务模式，提供SaaS多租户架构方案。
+- 29.分布式文件服务，集成MinIO、阿里OSS等优秀的第三方，提供便捷的文件上传与管理，同时也支持本地存储。
+- 30.主流数据库兼容，一套代码完全兼容MySQL、PostgreSQL、Oracle、SQL Server、MariaDB、达梦、人大金仓等主流数据库。
+- 31.集成工作流Flowable，并实现了只需在页面配置流程转向，可极大简化BPM工作流的开发；用BPM的流程设计器画出了流程走向，一个工作流基本就完成了，只需写很少量的Java代码。
+- 32.低代码能力：在线流程设计，采用开源Flowable流程引擎，实现在线画流程、自定义表单、表单挂靠、业务流转。
+- 33.多数据源：极其简易的使用方式，在线配置数据源配置，便捷地从其他数据抓取数据。
+- 34.提供单点登录CAS集成方案，项目中已经提供完善的对接代码。
+- 35.低代码能力：表单设计器，支持用户自定义表单布局，支持单表、一对多表单，支持select、radio、checkbox、textarea、date、popup、列表、宏等控件。
+- 36.专业接口对接机制，统一采用RESTful接口方式，集成Swagger-UI在线接口文档，JWT token安全验证，方便客户端对接。
+- 37.高级组合查询功能，在线配置支持主子表关联查询，可保存查询历史。
+- 38.提供各种系统监控，实时跟踪系统运行情况（监控Redis、Tomcat、JVM、服务器信息、请求追踪、SQL监控）。
+- 39.消息中心（支持短信、邮件、微信推送等）；集成WebSocket消息通知机制。
+- 40.支持多语言，提供国际化方案。
+- 41.数据变更记录日志，可记录数据每次变更内容，通过版本对比功能查看历史变化。
+- 42.提供简单易用的打印插件，支持谷歌、火狐、IE11+等各种浏览器。
+- 43.后端采用Maven分模块开发方式；前端支持菜单动态路由。
+- 44.提供丰富的示例代码，涵盖了常用的业务场景，便于学习和参考。
 
-![公众号](https://jeecg.com/images/jeecg/qrcode_ai_8.jpg "在这里输入图片标题")
 
 
 技术架构：
 -----------------------------------
 
+#### 前端
+
+- 前端环境要求：Node.js要求`Node 20+` 版本以上、pnpm 要求`9+` 版本以上
+
+ ` ( Vite 不再支持已结束生命周期（EOL）的 Node.js 18。现在需要使用 Node.js 20.19+ 或 22.12+)`
+
+- 依赖管理：node、npm、pnpm
+- 前端IDE建议：IDEA、WebStorm、Vscode
+- 采用 Vue3.0+TypeScript+Vite6+Ant-Design-Vue4等新技术方案，包括二次封装组件、utils、hooks、动态菜单、权限校验、按钮级别权限控制等功能
+- 最新技术栈：Vue3.0 + TypeScript + Vite6 + ant-design-vue4 + pinia + echarts + unocss + vxe-table + qiankun + es6
+
+
 #### 后端
 
 - IDE建议： IDEA (必须安装lombok插件 )
-- 语言：Java 8+ (支持17)
+- 语言：Java 默认jdk17(jdk21、jdk24)
 - 依赖管理：Maven
-- 基础框架：Spring Boot 2.7.18
-- 微服务框架： Spring Cloud Alibaba 2021.0.1.0
-- 持久层框架：MybatisPlus 3.5.3.2
-- 报表工具： JimuReport 1.9.3
-- 安全框架：Apache Shiro 1.12.0，Jwt 3.11.0
+- 基础框架：Spring Boot 3.5.5
+- 微服务框架： Spring Cloud Alibaba 2023.0.3.3
+- 持久层框架：MybatisPlus 3.5.12
+- 报表工具： JimuReport 2.1.3
+- 安全框架：Apache Shiro 2.0.4，Jwt 4.5.0
 - 微服务技术栈：Spring Cloud Alibaba、Nacos、Gateway、Sentinel、Skywalking
-- 数据库连接池：阿里巴巴Druid 1.1.22
-- AI大模型：支持 `ChatGPT` `DeepSeek`切换
+- 数据库连接池：阿里巴巴Druid 1.2.24
+- AI大模型：支持 `ChatGPT` `DeepSeek` `千问`等各种常规模式
 - 日志打印：logback
 - 缓存：Redis
 - 其他：autopoi, fastjson，poi，Swagger-ui，quartz, lombok（简化代码）等。
-- 默认数据库脚本：MySQL5.7+
-- [其他数据库，需要自己转](https://my.oschina.net/jeecg/blog/4905722)
+- 默认提供MySQL5.7+数据库脚本
 
+#### 数据库支持
 
-#### 前端
-
-- 前端IDE建议：WebStorm、Vscode
-- 采用 Vue3.0+TypeScript+Vite6+Ant-Design-Vue等新技术方案，包括二次封装组件、utils、hooks、动态菜单、权限校验、按钮级别权限控制等功能
-- 最新技术栈：Vue3.0 + TypeScript + Vite6 + ant-design-vue4 + pinia + echarts + unocss + vxe-table + qiankun + es6
-- 依赖管理：node、npm、pnpm
-
-
-#### 前端环境要求
-
-*   本地环境安装 `Node.js 、npm 、pnpm`
-*   pnpm 要求`9+` 版本以上
-*   Node.js 版本建议`v20.15.0`，要求`Node 20+` 版本以上
-
- ` ( 因为Vite6 需要 Node.js 18 / 20+ )`
-
-
-#### 支持库
+> jeecgboot平台支持以下数据库，默认我们只提供mysql脚本，其他数据库可以参考[转库文档](https://my.oschina.net/jeecg/blog/4905722)自己转。
 
 |  数据库   |  支持   |
 | --- | --- |
@@ -133,25 +196,16 @@ AIGC功能清单
 |  Sqlserver2017   |  √   |
 |   PostgreSQL   |  √   |
 |   MariaDB   |  √   |
-|   MariaDB   |  √   |
 |   达梦   |  √   |
 |   人大金仓   |  √   |
 |   TiDB     |  √   |
+|   kingbase8   |  √   |
 
-#### 支持AI大模型
 
-|  AI大模型   |  支持   |
-| --- | --- |
-|   DeepSeek   |  √   |
-|   ChatGTP   |  √   |
-|   Ollama本地搭建大模型   |  √   |
-
-AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 
  
 ## 微服务解决方案
 
-
 - 1、服务注册和发现 Nacos √
 - 2、统一配置中心 Nacos  √
 - 3、路由网关 gateway(三种加载方式) √
@@ -160,7 +214,7 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 - 6、分布式文件 Minio、阿里OSS √ 
 - 7、统一权限控制 JWT + Shiro √
 - 8、服务监控 SpringBootAdmin√
-- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking.html)
+- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking)
 - 10、消息中间件 RabbitMQ  √
 - 11、分布式任务 xxl-job  √ 
 - 12、分布式事务 Seata
@@ -169,62 +223,23 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 - 15、CAS 单点登录   √
 - 16、路由限流   √
 
-
-#### 微服务方式启动
-
-- [单体快速切换微服务](https://help.jeecg.com/java/springcloud/switchcloud/monomer.html)
-- [Docker一键启动微服务前后端](https://help.jeecg.com/java/docker/quickcloud.html)
-
-
 #### 微服务架构图
 ![微服务架构图](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/jeecgboot_springcloud2022.png "在这里输入图片标题")
 
 
 
-为什么选择JeecgBoot?
+
+
+开源版与企业版区别?
 -----------------------------------
-* 1.采用最新主流前后分离框架（Springboot+Mybatis+antd+vue3），容易上手; 代码生成器依赖性低,灵活的扩展能力，可快速实现二次开发;
-* 2.支持微服务SpringCloud Alibaba(Nacos、Gateway、Sentinel、Skywalking)，提供切换机制支持单体和微服务自由切换
-* 3.开发效率高,采用代码生成器，单表、树列表、一对多、一对一等数据模型，增删改查功能一键生成，菜单配置直接使用；引入AI能力，支持自动建表等功能；
-* 4.代码生成器提供强大模板机制，支持自定义模板，目前提供四套风格模板（单表两套、树模型一套、一对多三套）
-* 5.代码生成器非常智能，在线业务建模、在线配置、所见即所得支持23种类控件，一键生成前后端代码，大幅度提升开发效率，不再为重复工作发愁。
-* 6.AI能力：目前JeecgBoot支持AI大模型chatgpt和deepseek，现在最新版默认使用deepseek，速度更快质量更高。目前提供了AI对话助手、AI建表、AI报表等功能。
-* 6.低代码能力：Online在线表单（无需编码，通过在线配置表单，实现表单的增删改查，支持单表、树、一对多、一对一等模型，实现人人皆可编码）
-* 7.低代码能力：Online在线报表、Online在线图表（无需编码，通过在线配置方式，实现数据报表和图形报表，可以快速抽取数据，减轻开发压力，实现人人皆可编码）
-* 9.封装完善的用户、角色、菜单、组织机构、数据字典、在线定时任务等基础功能，支持访问授权、按钮权限、数据权限等功能
-* 10.常用共通封装，各种工具类(定时任务,短信接口,邮件发送,Excel导入导出等),基本满足80%项目需求
-* 11.简易Excel导入导出，支持单表导出和一对多表模式导出，生成的代码自带导入导出功能
-* 12.集成简易报表工具，图像报表和数据导出非常方便，可极其方便的生成图形报表、pdf、excel、word等报表；
-* 13.采用前后分离技术，页面UI风格精美，针对常用组件做了封装：时间、行表格控件、截取显示控件、报表组件，编辑器等等
-* 14.查询过滤器：查询功能自动生成，后台动态拼SQL追加查询条件；支持多种匹配方式（全匹配/模糊查询/包含查询/不匹配查询）；
-* 15.数据权限（精细化数据权限控制，控制到行级，列表级，表单字段级，实现不同人看不同数据，不同人对同一个页面操作不同字段
-* 16.页面校验自动生成(必须输入、数字校验、金额校验、时间空间等);
-* 17.支持SAAS服务模式，提供SaaS多租户架构方案。
-* 18.分布式文件服务，集成minio、阿里OSS等优秀的第三方，提供便捷的文件上传与管理，同时也支持本地存储。
-* 19.主流数据库兼容，一套代码完全兼容Mysql、Postgresql、Oracle、Sqlserver、MariaDB、达梦、人大金仓等主流数据库。
-* 20.集成工作流flowable，并实现了只需在页面配置流程转向，可极大的简化bpm工作流的开发；用bpm的流程设计器画出了流程走向，一个工作流基本就完成了，只需写很少量的java代码；
-* 21.低代码能力：在线流程设计，采用开源flowable流程引擎，实现在线画流程,自定义表单,表单挂靠,业务流转
-* 22.多数据源：及其简易的使用方式，在线配置数据源配置，便捷的从其他数据抓取数据；
-* 23.提供单点登录CAS集成方案，项目中已经提供完善的对接代码
-* 24.低代码能力：表单设计器，支持用户自定义表单布局，支持单表，一对多表单、支持select、radio、checkbox、textarea、date、popup、列表、宏等控件
-* 25.专业接口对接机制，统一采用restful接口方式，集成swagger-ui在线接口文档，Jwt token安全验证，方便客户端对接
-* 26.接口安全机制，可细化控制接口授权，非常简便实现不同客户端只看自己数据等控制
-* 27.高级组合查询功能，在线配置支持主子表关联查询，可保存查询历史
-* 28.提供各种系统监控，实时跟踪系统运行情况（监控 Redis、Tomcat、jvm、服务器信息、请求追踪、SQL监控）
-* 29.消息中心（支持短信、邮件、微信推送等等）
-* 30.集成Websocket消息通知机制
-* 31.移动自适应效果优秀，提供APP发布方案：
-* 32.支持多语言，提供国际化方案；
-* 33.数据变更记录日志，可记录数据每次变更内容，通过版本对比功能查看历史变化
-* 34.平台UI强大，实现了移动自适应
-* 35.平台首页风格，提供多种组合模式，支持自定义风格
-* 36.提供简单易用的打印插件，支持谷歌、火狐、IE11+ 等各种浏览器
-* 37.示例代码丰富，提供很多学习案例参考
-* 38.采用maven分模块开发方式
-* 39.支持菜单动态路由
-* 40.权限控制采用 RBAC（Role-Based Access Control，基于角色的访问控制）
-* 41.提供新行编辑表格JVXETable，轻松满足各种复杂ERP布局，拥有更高的性能、更灵活的扩展、更强大的功能
-* 42.提供仪表盘设计器，类大屏设计支持移动端，免费的数据可视化设计工具，支持丰富的数据源连接，能够通过拖拉拽方式快速制作图表和门户设计；目前支持多种图表类型：柱形图、折线图、散点图、饼图、环形图、面积图、漏斗图、进度图、仪表盘、雷达图、地图等等；
+
+ - 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 产品功能蓝图
@@ -232,47 +247,19 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 
 
 
+####  系统功能架构图
 
-### 分支说明
+![](https://oscimg.oschina.net/oscnet/up-1569487b95a07dbc3599fb1349a2e3aaae1.png)
 
-> 主干master更稳定，如果你对最新技术栈无要求，建议采用主干
 
-#### springboot3分支
- - 源码地址：https://github.com/jeecgboot/JeecgBoot/tree/springboot3
- - 架构说明：升级Spring Boot3 & JDK 17 + Undertow + springdoc + fastjson2
- 
-#### springboot3_sas分支
- - 源码地址：https://github.com/jeecgboot/JeecgBoot/tree/springboot3_sas
- - 架构说明：在springboot3分支基础上，采用SpringAuthorizationServer替换Shiro
- 
- 
 
-### 功能模块
+### 开源版功能清单
 ```
-├─AI开发
-│  ├─支持AI大模型ChatGPT和DeepSeek
-│  ├─AI对话助手
-│  ├─AI建表
-│  ├─AI写文章
-│  ├─AI流程编排（研发中）
-│  ├─AI知识库问答系统（研发中）
-│  ├─AI应用开发平台（研发中）
-│  ├─AI聊天窗口支持嵌入第三方（研发中）
-├─Online在线开发(低代码)
-│  ├─Online在线表单
-│  ├─Online代码生成器
-│  ├─Online在线报表
-│  ├─仪表盘设计器
-│  ├─系统编码规则
-│  ├─系统校验规则
-├─积木报表设计器
-│  ├─打印设计器
-│  ├─数据报表设计
-│  ├─图形报表设计（支持echart）
 ├─系统管理
 │  ├─用户管理
 │  ├─角色管理
 │  ├─菜单管理
+│  ├─首页配置
 │  ├─权限设置（支持按钮权限、数据权限）
 │  ├─表单权限（控制字段禁用、隐藏）
 │  ├─部门管理
@@ -283,7 +270,36 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 │  └─职务管理
 │  └─通讯录
 │  ├─多数据源管理
-│  └─多租户管理（租户管理、租户角色、我的租户）
+│  ├─白名单管理
+│  ├─第三方配置（对接钉钉和企业微信）
+│  └─多租户管理（租户管理、租户角色、我的租户、租户默认套餐管理）
+├─Online在线开发(低代码)
+│  ├─Online在线表单
+│  ├─Online代码生成器
+│  ├─Online在线报表
+│  ├─仪表盘设计器
+│  ├─系统编码规则
+│  ├─系统校验规则
+│  ├─APP版本管理
+├─AI应用平台
+│  ├─AI知识库问答系统
+│  ├─AI大模型管理
+│  ├─AI流程编排
+│  ├─AI流程设计器
+│  ├─AI对话支持图片
+│  ├─AI对话助手(智能问答)
+│  ├─AI建表（Online表单）
+│  ├─AI聊天窗口支持嵌入第三方
+│  ├─AI聊天窗口支持移动端
+│  ├─支持常见大模型ChatGPT和DeepSeek、ollama等等
+│  ├─AI OCR示例
+├─数据可视化
+│  ├─报表设计器(支持打印设计）
+│  ├─大屏设和仪表盘设计
+├─OpenAPI（基于AK和SK认证鉴权）
+│  ├─接口管理
+│  ├─接口授权
+│  ├─接口文档
 ├─消息中心
 │  ├─消息管理
 │  ├─模板管理
@@ -295,8 +311,12 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 │  ├─高级查询器（弹窗自动组合查询条件）
 │  ├─Excel导入导出工具集成（支持单表，一对多 导入导出）
 │  ├─平台移动自适应支持
+│  ├─提供新版uniapp3的代码生成器模板
 ├─系统监控
 │  ├─Gateway路由网关
+│  ├─基于AK和SK认证鉴权OpenAPI功能
+│  ├─定时任务
+│  ├─数据源管理
 │  ├─性能扫描监控
 │  │  ├─监控 Redis
 │  │  ├─Tomcat
@@ -304,13 +324,11 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 │  │  ├─服务器信息
 │  │  ├─请求追踪
 │  │  ├─磁盘监控
-│  ├─定时任务
 │  ├─系统日志
 │  ├─消息中心（支持短信、邮件、微信推送等等）
 │  ├─数据日志（记录数据快照，可对比快照，查看数据变更情况）
-│  ├─系统通知
 │  ├─SQL监控
-│  ├─swagger-ui(在线接口文档)
+│  ├─在线用户
 │─报表示例
 │  ├─曲线图
 │  └─饼状图
@@ -375,46 +393,16 @@ AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 │  ├─提供单点登录CAS集成方案
 │  ├─提供APP发布方案
 │  ├─集成Websocket消息通知机制
-│─更多商业功能
-│  ├─流程设计器
-│  ├─表单设计器
-│  ├─大屏设计器
-│  └─我的任务
-│  └─历史流程
-│  └─历史流程
-│  └─流程实例管理
-│  └─流程监听管理
-│  └─流程表达式
-│  └─我发起的流程
-│  └─我的抄送
-│  └─流程委派、抄送、跳转
-│  └─OA办公组件
-│  └─。。。
-   
+│  ├─支持electron桌面应用打包(支持windows、linux、macOS三大平台)
+│  ├─docker容器支持
+│  ├─提供移动APP框架及源码（Uniapp3版本）支持H5、小程序、APP、鸿蒙Next
+│  ├─提供移动APP低代码设计(Online表单、仪表盘)
 ```
 
 
 
 ### 系统效果
 
-
-##### AI功能
-
-AI聊天助手
-
-![](https://oscimg.oschina.net/oscnet//65298d5710b4e6039a5f802b5f8505c5.png)
-
-AI建表
-
-![](https://oscimg.oschina.net/oscnet/up-381423599f219a67def45dfd9a99df8ef3f.png)
-
-![](https://oscimg.oschina.net/oscnet/up-1508c2b0708c365605f68893044ee11f20d.png)
-
-AI写文章
-
-![](https://oscimg.oschina.net/oscnet/up-e3ee5b1fe497308805aa5e324b72994af79.png)
-
-
 ##### PC端
 ![](https://oscimg.oschina.net/oscnet/up-000530d95df337b43089ac77e562494f454.png)
 
@@ -434,6 +422,22 @@ AI写文章
 ![](https://oscimg.oschina.net/oscnet/up-16c07e000278329b69b228ae3189814b8e9.png)
 
 
+##### AI功能
+
+AI聊天助手
+
+![](https://oscimg.oschina.net/oscnet//65298d5710b4e6039a5f802b5f8505c5.png)
+
+AI建表
+
+![](https://oscimg.oschina.net/oscnet/up-381423599f219a67def45dfd9a99df8ef3f.png)
+
+![](https://oscimg.oschina.net/oscnet/up-1508c2b0708c365605f68893044ee11f20d.png)
+
+AI写文章
+
+![](https://oscimg.oschina.net/oscnet/up-e3ee5b1fe497308805aa5e324b72994af79.png)
+
 
 #####  仪表盘设计器
 
@@ -500,28 +504,6 @@ AI写文章
 ![](https://oscimg.oschina.net/oscnet/up-6b81781b43086819049c4421206810667c5.png)
 
 
-##### 流程设计
-![](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)
-
 
 
 

check_jeecgenv.py

@@ -0,0 +1,216 @@
+import os
+import subprocess
+import re
+import sys
+from typing import Tuple, Optional
+
+def run_command(cmd: str) -> Tuple[int, str]:
+    """执行命令并返回退出码和输出"""
+    try:
+        result = subprocess.run(cmd, shell=True, check=False, 
+                              stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                              text=True)
+        return result.returncode, result.stdout.strip()
+    except Exception as e:
+        return -1, str(e)
+
+def check_java() -> bool:
+    """检查JDK 17+是否安装"""
+    print("\n检查JDK 17+...")
+    rc, output = run_command("java -version 2>&1")
+    if rc != 0:
+        print("❌ 未检测到Java，请安装JDK 17+")
+        return False
+    
+    version_pattern = r'"(\d+)(?:\.\d+)*(?:_\d+)?'
+    match = re.search(version_pattern, output)
+    if not match:
+        print("❌ 无法解析Java版本")
+        return False
+    
+    version = int(match.group(1))
+    if version >= 17:
+        print(f"✅ JDK版本 {version} (满足17+要求)")
+        return True
+    else:
+        print(f"❌ JDK版本 {version} (需要17+)")
+        return False
+
+def check_maven() -> bool:
+    """检查Maven是否安装"""
+    print("\n检查Maven...")
+    rc, output = run_command("mvn -v")
+    if rc == 0:
+        print("✅ Maven已安装")
+        return True
+    else:
+        print("❌ Maven未安装")
+        return False
+
+def check_node() -> bool:
+    """检查Node.js 20+是否安装"""
+    print("\n检查Node.js 20+...")
+    rc, output = run_command("node -v")
+    if rc != 0:
+        print("❌ Node.js未安装")
+        return False
+    
+    version_pattern = r'v(\d+)\.\d+\.\d+'
+    match = re.search(version_pattern, output)
+    if not match:
+        print("❌ 无法解析Node.js版本")
+        return False
+    
+    version = int(match.group(1))
+    if version >= 20:
+        print(f"✅ Node.js版本 {version} (满足20+要求)")
+        return True
+    else:
+        print(f"❌ Node.js版本 {version} (需要20+)")
+        return False
+
+def check_pnpm() -> bool:
+    """检查PNPM 9+是否安装"""
+    print("\n检查PNPM 9+...")
+    rc, output = run_command("pnpm -v")
+    if rc != 0:
+        print("❌ PNPM未安装")
+        return False
+    
+    try:
+        # 处理可能的版本号格式：v9.0.0 或 9.0.0 或 9
+        version_str = output.strip().lstrip('v').split('.')[0]
+        version = int(version_str)
+        
+        if version >= 9:
+            print(f"✅ PNPM版本 {output.strip()} (满足9+要求)")
+            return True
+        else:
+            print(f"❌ PNPM版本 {output.strip()} (需要9+)")
+            return False
+    except (ValueError, IndexError):
+        print(f"❌ 无法解析PNPM版本: {output.strip()}")
+        return False
+
+def check_redis_connection() -> bool:
+    """检查Redis连接"""
+    print("\n检查Redis连接...")
+    print("⚠️ 请确保已配置Redis连接信息并在jeecg-boot项目中正确配置")
+    print("⚠️ 此检查需要根据实际项目配置进行验证")
+    print("⚠️ 配置文件位置: jeecg-boot/jeecg-module-system/jeecg-system-start/src/main/resources/application-dev.yml")
+    return True
+
+def check_mysql_connection() -> bool:
+    """检查MySQL连接"""
+    print("\n检查MySQL连接...")
+    print("⚠️ 请确保已配置MySQL连接信息并在jeecg-boot项目中正确配置")
+    print("⚠️ 此检查需要根据实际项目配置进行验证")
+    print("⚠️ 配置文件位置: jeecg-boot/jeecg-module-system/jeecg-system-start/src/main/resources/application-dev.yml")
+    return True
+
+def print_mysql_config():
+    """打印MySQL配置并提示需要修改的位置"""
+    print("\nMySQL配置参考 (请检查以下配置是否正确):")
+    print("""
+spring.datasource.dynamic.datasource:
+  master:
+    url: jdbc:mysql://127.0.0.1:3306/jeecg-boot?characterEncoding=UTF-8&useUnicode=true&useSSL=false&tinyInt1isBit=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
+    username: root       # ← 可能需要修改
+    password: root       # ← 可能需要修改
+    driver-class-name: com.mysql.cj.jdbc.Driver
+""")
+
+def check_ai_vector_db() -> bool:
+    """检查AI向量库(pgvector)配置"""
+    print("\n检查AI知识库向量库配置...")
+    print("⚠️ 如果需要使用AI知识库功能，请配置pgvector向量库")
+    print("⚠️ 配置文件位置: jeecg-boot/jeecg-module-system/jeecg-system-start/src/main/resources/application-dev.yml")
+    print("\n配置参考:")
+    print("""
+jeecg.ai-rag:
+    embed-store:
+      host: 127.0.0.1       # ← 可能需要修改
+      port: 5432            # ← 可能需要修改
+      database: postgres    # ← 可能需要修改
+      user: postgres        # ← 可能需要修改
+      password: postgres    # ← 可能需要修改
+      table: embeddings     # ← 可能需要修改
+""")
+    print("⚠️ 注意: 请确保已安装PostgreSQL并添加pgvector扩展！docker安装参考：https://help.jeecg.com/aigc/config")
+    return True
+
+def check_ai_config() -> bool:
+    """检查AI账号配置"""
+    print("\n检查AI功能配置...")
+    print("⚠️ 如果需要使用AI聊天功能，请配置AI账号信息")
+    print("⚠️ 配置文件位置: jeecg-boot/jeecg-module-system/jeecg-system-start/src/main/resources/application-dev.yml")
+    print("\n配置参考:")
+    print("""
+jeecg:
+  # AI集成
+  ai-chat:
+    enabled: true           # ← 启用AI功能
+    model: deepseek-chat    # ← 模型名称
+    apiKey: ??              # ← 必须修改为您的API Key
+    apiHost: https://api.deepseek.com/v1  # ← API地址
+    timeout: 60             # ← 超时时间(秒)
+""")
+    print("⚠️ 注意: 请确保已获取有效的API Key并正确配置！AI账号注册获取参考： https://help.jeecg.com/java/deepSeekSupport")
+    return True
+
+
+def print_redis_config():
+    """打印Redis配置并提示需要修改的位置"""
+    print("\nRedis配置参考 (请检查以下配置是否正确):")
+    print("""
+spring.redis:
+  database: 0
+  host: 127.0.0.1        # ← 可能需要修改
+  port: 6379             # ← 可能需要修改
+  password: ''           # ← 如果需要密码请修改
+""")
+
+def main():
+    print("="*50)
+    print("JeecgBoot 运行环境检查脚本")
+    print("="*50)
+    
+    all_checks_passed = True
+    
+    # 检查各项依赖
+    if not check_java():
+        all_checks_passed = False
+    
+    if not check_maven():
+        all_checks_passed = False
+    
+    if not check_node():
+        all_checks_passed = False
+    
+    if not check_pnpm():
+        all_checks_passed = False
+    
+    # 数据库提示
+    print("="*50)
+    check_redis_connection()
+    print_redis_config()
+    print("="*50)
+    check_mysql_connection()
+    print_mysql_config()
+    print("="*50)
+    check_ai_config()
+    print("="*50)
+    check_ai_vector_db()
+    
+    print("\n" + "="*50)
+    if all_checks_passed:
+        print("✅ 所有基础环境检查通过")
+        print("⚠️ 注意: 请确保Redis和MySQL、AI账号、向量库pgvector 已正确配置并连接成功")
+    else:
+        print("❌ 部分环境检查未通过，请根据上述提示解决问题")
+    
+    print("="*50)
+
+if __name__ == "__main__":
+    main()
+    input("\n按回车键退出...")  # 等待用户输入

docker-compose-cloud.yml

@@ -18,20 +18,33 @@ services:
       --max_allowed_packet=128M
       --default-authentication-plugin=caching_sha2_password
     ports:
-      - 3306:3306
+      - 13306:3306
     networks:
       - jeecg-boot
 
   jeecg-boot-redis:
     image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/redis:5.0
-    ports:
-      - 6379:6379
+#    ports:
+#      - 6379:6379
     restart: always
     hostname: jeecg-boot-redis
     container_name: jeecg-boot-redis
     networks:
       - jeecg-boot
 
+  jeecg-boot-pgvector:
+    image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/pgvector
+    container_name: jeecg-boot-pgvector
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: vector_db
+    ports:
+      - 5432:5432
+    restart: always
+    networks:
+      - jeecg-boot
+      
   jeecg-boot-nacos:
     restart: always
     build:
@@ -96,31 +109,37 @@ services:
 #    environment:
 #      RABBITMQ_DEFAULT_USER: guest
 #      RABBITMQ_DEFAULT_PASS: guest
-#  jeecg-boot-sentinel:
-#    restart: on-failure
-#    build:
-#      context: ./jeecg-visual/jeecg-cloud-sentinel
-#    ports:
-#      - 9000:9000
-#    depends_on:
-#      - jeecg-boot-nacos
-#      - jeecg-boot-demo
-#      - jeecg-boot-system
-#      - jeecg-boot-gateway
-#    container_name: jeecg-boot-sentinel
-#    hostname: jeecg-boot-sentinel
-#
-#  jeecg-boot-xxljob:
-#    build:
-#      context: ./jeecg-visual/jeecg-cloud-xxljob
-#    ports:
-#      - 9080:9080
-#    container_name: jeecg-boot-xxljob
-#    hostname: jeecg-boot-xxljob
 
+  jeecg-boot-sentinel:
+     restart: on-failure
+     build:
+       context: ./jeecg-boot/jeecg-server-cloud/jeecg-visual/jeecg-cloud-sentinel
+     ports:
+       - 9000:9000
+     depends_on:
+       - jeecg-boot-nacos
+       - jeecg-boot-demo
+       - jeecg-boot-system
+       - jeecg-boot-gateway
+     container_name: jeecg-boot-sentinel
+     hostname: jeecg-boot-sentinel
+     networks:
+       - jeecg-boot
+
+  jeecg-boot-xxljob:
+     build:
+       context: ./jeecg-boot/jeecg-server-cloud/jeecg-visual/jeecg-cloud-xxljob
+     ports:
+       - 9080:9080
+     container_name: jeecg-boot-xxljob
+     hostname: jeecg-boot-xxljob
+     networks:
+       - jeecg-boot
+       
   jeecg-vue:
     build:
       context: ./jeecgboot-vue3
+      dockerfile: Dockerfile.cloud
     container_name: jeecgboot-vue3-nginx
     image: jeecgboot-vue3
     depends_on:

docker-compose.yml

@@ -18,20 +18,33 @@ services:
       --max_allowed_packet=128M
       --default-authentication-plugin=caching_sha2_password
     ports:
-      - 3306:3306
+      - 13306:3306
     networks:
       - jeecg-boot
 
   jeecg-boot-redis:
     image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/redis:5.0
-    ports:
-      - 6379:6379
+    # ports:
+    #   - 3792:6379
     restart: always
     hostname: jeecg-boot-redis
     container_name: jeecg-boot-redis
     networks:
       - jeecg-boot
 
+  jeecg-boot-pgvector:
+    image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/pgvector
+    container_name: jeecg-boot-pgvector
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: vector_db
+    ports:
+      - 5432:5432
+    restart: always
+    networks:
+      - jeecg-boot
+      
   jeecg-boot-system:
     build:
       context: ./jeecg-boot/jeecg-module-system/jeecg-system-start

jeecg-boot/README.md

@@ -2,12 +2,12 @@
 JeecgBoot 低代码开发平台
 ===============
 
-当前最新版本： 3.7.3（发布日期：2025-02-10） 
+当前最新版本： 3.8.3（发布日期：2025-10-09） 
 
 
 [![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.7.3-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/version-3.8.3-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)
 
@@ -16,43 +16,127 @@ JeecgBoot 低代码开发平台
 项目介绍
 -----------------------------------
 
-<h3 align="center">Java Low Code Platform for Enterprise web applications</h3>
+<h3 align="center">企业级AI低代码平台</h3>
+
+JeecgBoot 是一款基于BPM流程和代码生成的AI低代码平台，助力企业快速实现低代码开发和构建AI应用。
+采用前后端分离架构（Ant Design&Vue3，SpringBoot3，SpringCloud Alibaba，Mybatis-plus），强大代码生成器实现前后端一键生成，无需手写代码。
+平台引领AI低代码开发模式：AI生成→在线编码→代码生成→手工合并，解决Java项目80%重复工作，提升效率，节省成本，兼顾灵活性。
+具备强大且颗粒化的权限控制，支持按钮权限和数据权限设置，满足大型业务系统需求。功能涵盖在线表单、表单设计、流程设计、门户设计、报表与大屏设计、OA办公、AI应用、AI知识库、大模型管理、AI流程编排、AI聊天，支持ChatGPT、DeepSeek、Ollama等多种AI大模型。
+
+`AI赋能报表:` 积木报表是一款自主研发的强大开源企业级Web报表与大屏工具。它通过零编码的拖拽式操作，赋能用户如同搭积木般轻松构建各类复杂报表和数据大屏，全面满足企业数据可视化与分析需求，助力企业级数据产品的高效打造与应用。
+
+`AI赋能低代码:` 提供完善成熟的AI应用平台，涵盖AI应用管理、AI模型管理、智能对话助手、知识库问答、流程编排与设计器、AI建表等多项功能。平台兼容多种主流大模型，包括ChatGPT、DeepSeek、Ollama、智普、千问等，助力企业高效构建智能化应用，推动低代码开发与AI深度融合。
+
+`JEECG宗旨是:` JEECG旨在通过OnlineCoding平台实现简单功能的零代码快速搭建，同时针对复杂功能采用代码生成器生成代码并手工合并，打造智能且灵活的低代码开发模式，有效解决了当前低代码产品普遍缺乏灵活性的问题，提升开发效率的同时兼顾系统的扩展性和定制化能力。
+
+`JEECG业务流程:` JEECG业务流程采用BPM工作流引擎实现业务审批，扩展任务接口供开发人员编写业务逻辑，表单提供表单设计器、在线配置表单和编码表单等多种解决方案。通过流程与表单的分离设计（松耦合）及任务节点的灵活配置，既保障了企业流程的安全性与保密性，又大幅降低了开发人员的工作量。
+
+
+适用项目
+-----------------------------------
+JeecgBoot低代码平台兼容所有J2EE项目开发，支持信创国产化，特别适用于SAAS、企业信息管理系统（MIS）、内部办公系统（OA）、企业资源计划系统（ERP）、客户关系管理系统（CRM）及AI知识库等场景。其半智能手工Merge开发模式，可显著提升70%以上的开发效率，极大降低开发成本。同时，JeecgBoot还是一款全栈式AI开发平台，助力企业快速构建和部署个性化AI应用。。
+
+
+**信创兼容说明**
+- 操作系统：国产麒麟、银河麒麟等国产系统几乎都是基于 Linux 内核，因此它们具有良好的兼容性。
+- 数据库：达梦、人大金仓、TiDB
+- 中间件：东方通 TongWeb、TongRDS，宝兰德 AppServer、CacheDB, [信创配置文档](https://help.jeecg.com/java/tongweb-deploy/)
+
 
-JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端分离架构 SpringBoot2.x和3.x，SpringCloud，Ant Design Vue3，Mybatis-plus，Shiro，JWT，支持微服务。强大的代码生成器让前后端代码一键生成，实现低代码开发!  JeecgBoot 引领新的低代码开发模式(OnlineCoding-> 代码生成器-> 手工MERGE)， 帮助解决Java项目70%的重复工作，让开发更多关注业务。既能快速提高效率，节省研发成本，同时又不失灵活性！
 
 
 #### 项目说明
 
-| 项目名                | 说明                     | 
-|--------------------|------------------------|
-| `jeecg-boot`    | 后端源码JAVA（SpringBoot微服务架构）        |
-| `jeecgboot-vue3` | 前端源码VUE3（vue3+vite5+ts最新技术栈）  |
-
-
-
-技术文档
------------------------------------
-
-- 官方网站：  [http://www.jeecg.com](http://www.jeecg.com)
-- 新手指南： [快速入门](http://www.jeecg.com/doc/quickstart)
-- QQ交流群 ： ⑩716488839、⑨808791225、其他(满)
-- 在线演示 ：  [在线演示](http://boot3.jeecg.com)   | [APP演示](http://jeecg.com/appIndex)
-> 演示系统的登录账号密码，请点击 [获取账号密码](http://jeecg.com/doc/demo) 获取 
+| 项目名                | 说明                                 | 
+|--------------------|------------------------------------|
+| `jeecg-boot`    | 后端源码JAVA（SpringBoot3微服务架构）         |
+| `jeecgboot-vue3` | 前端源码VUE3（vue3+vite6+antd4+ts最新技术栈） |
 
 
 
 启动项目
 -----------------------------------
 
-- [IDEA启动前后端项目](https://help.jeecg.com/java/setup/idea/startup.html)
-- [Docker一键启动前后端](https://help.jeecg.com/java/docker/quick.html)
+> 默认账号密码： admin/123456
+
+- [开发环境搭建](https://help.jeecg.com/java/setup/tools)
+- [IDEA启动前后端(单体模式)](https://help.jeecg.com/java/setup/idea/startup)
+- [Docker一键启动(单体模式)](https://help.jeecg.com/java/docker/quick)
+- [IDEA启动前后端(微服务方式)](https://help.jeecg.com/java/springcloud/switchcloud/monomer)
+- [Docker一键启动(微服务方式)](https://help.jeecg.com/java/docker/quickcloud)
 
 
-微服务启动
+技术文档
 -----------------------------------
-- [单体快速切换微服务](https://help.jeecg.com/java/springcloud/switchcloud/monomer.html)
-- [Docker启动微服务后台](https://help.jeecg.com/java/docker/springcloud.html)
 
+- 官方网站：  [http://www.jeecg.com](http://www.jeecg.com)
+- 在线演示：  [平台演示](https://boot3.jeecg.com) | [APP演示](https://jeecg.com/appIndex)
+- 入门指南：  [快速入门](http://www.jeecg.com/doc/quickstart)  | [代码生成使用](https://help.jeecg.com/java/codegen/online) | [开发文档](https://help.jeecg.com)  | [AI应用手册](https://help.jeecg.com/aigc) | [视频教程](http://jeecg.com/doc/video)
+- 技术支持：  [反馈问题](https://github.com/jeecgboot/JeecgBoot/issues/new?template=bug_report.md)    | [低代码体验一分钟](https://jeecg.blog.csdn.net/article/details/106079007)
+- QQ交流群 ： 964611995、⑩716488839(满)、⑨808791225(满)、其他(满)
+
+
+AI 应用平台介绍
+-----------------------------------
+
+一个全栈式 AI 开发平台，旨在帮助开发者快速构建和部署个性化的 AI 应用。
+
+JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类似`Dify`的`AIGC应用开发平台`+`知识库问答`，是一款基于LLM大语言模型AI应用平台和 RAG 的知识库问答系统。
+其直观的界面结合了 AI 流程编排、RAG 管道、知识库管理、模型管理、对接向量库、实时运行可观察等，让您可以快速从原型到生产，拥有AI服务能力。
+
+- [详细专题介绍，请点击查看](README-AI.md)
+
+- AI视频介绍
+
+[![](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/jeecg_aivideo.png)](https://www.bilibili.com/video/BV1zmd7YFE4w)
+
+
+为什么选择JeecgBoot?
+-----------------------------------
+- 1.采用最新主流前后分离框架（Spring Boot3 + MyBatis + Shiro/SpringAuthorizationServer + Ant Design4 + Vue3），容易上手；代码生成器依赖性低，灵活的扩展能力，可快速实现二次开发。
+- 2.前端大版本换代，最新版采用 Vue3.0 + TypeScript + Vite6 + Ant Design Vue4 等新技术方案。
+- 3.支持微服务Spring Cloud Alibaba（Nacos、Gateway、Sentinel、Skywalking），提供简易机制，支持单体和微服务自由切换（这样可以满足各类项目需求）。
+- 4.开发效率高，支持在线建表和AI建表，提供强大代码生成器，单表、树列表、一对多、一对一等数据模型，增删改查功能一键生成，菜单配置直接使用。
+- 5.代码生成器提供强大模板机制，支持自定义模板，目前提供四套风格模板（单表两套、树模型一套、一对多三套）。
+- 6.提供强大的报表和大屏可视化工具，支持丰富的数据源连接，能够通过拖拉拽方式快速制作报表、大屏和门户设计；支持多种图表类型：柱形图、折线图、散点图、饼图、环形图、面积图、漏斗图、进度图、仪表盘、雷达图、地图等。
+- 7.低代码能力：在线表单（无需编码，通过在线配置表单，实现表单的增删改查，支持单表、树、一对多、一对一等模型，实现人人皆可编码），在线配置零代码开发、所见即所得支持23种类控件。
+- 8.低代码能力：在线报表、在线图表（无需编码，通过在线配置方式，实现数据报表和图形报表，可以快速抽取数据，减轻开发压力，实现人人皆可编码）。
+- 9.Online支持在线增强开发，提供在线代码编辑器，支持代码高亮、代码提示等功能，支持多种语言（Java、SQL、JavaScript等）。
+- 10.封装完善的用户、角色、菜单、组织机构、数据字典、在线定时任务等基础功能，支持访问授权、按钮权限、数据权限等功能。
+- 11.前端UI提供丰富的组件库，支持各种常用组件，如表格、树形控件、下拉框、日期选择器等，满足各种复杂的业务需求 [UI组件库文档](https://help.jeecg.com/category/ui%E7%BB%84%E4%BB%B6%E5%BA%93)。
+- 12.提供APP配套框架，一份多代码多终端适配，一份代码多终端适配，小程序、H5、安卓、iOS、鸿蒙Next。
+- 13.新版APP框架采用Uniapp、Vue3.0、Vite、Wot-design-uni、TypeScript等最新技术栈，包括二次封装组件、路由拦截、请求拦截等功能。实现了与JeecgBoot完美对接：目前已经实现登录、用户信息、通讯录、公告、移动首页、九宫格、聊天、Online表单、仪表盘等功能，提供了丰富的组件。
+- 14.提供了一套成熟的AI应用平台功能，从AI模型、知识库到AI应用搭建，助力企业快速落地AI服务，加速智能化升级。
+- 15.AI能力：目前JeecgBoot支持AI大模型chatgpt和deepseek，现在最新版默认使用deepseek，速度更快质量更高。目前提供了AI对话助手、AI知识库、AI应用、AI建表、AI报表等功能。
+- 16.提供新行编辑表格JVXETable，轻松满足各种复杂ERP布局，拥有更高的性能、更灵活的扩展、更强大的功能。
+- 17.平台首页风格，提供多种组合模式，支持自定义风格；支持门户设计，支持自定义首页。
+- 18.常用共通封装，各种工具类（定时任务、短信接口、邮件发送、Excel导入导出等），基本满足80%项目需求。
+- 19.简易Excel导入导出，支持单表导出和一对多表模式导出，生成的代码自带导入导出功能。
+- 20.集成智能报表工具，报表打印、图像报表和数据导出非常方便，可极其方便地生成PDF、Excel、Word等报表。
+- 21.采用前后分离技术，页面UI风格精美，针对常用组件做了封装：时间、行表格控件、截取显示控件、报表组件、编辑器等。
+- 22.查询过滤器：查询功能自动生成，后台动态拼SQL追加查询条件；支持多种匹配方式（全匹配/模糊查询/包含查询/不匹配查询）。
+- 23.数据权限（精细化数据权限控制，控制到行级、列表级、表单字段级，实现不同人看不同数据，不同人对同一个页面操作不同字段）。
+- 24.接口安全机制，可细化控制接口授权，非常简便实现不同客户端只看自己数据等控制；也提供了基于AK和SK认证鉴权的OpenAPI功能。
+- 25.活跃的社区支持；近年来，随着网络威胁的日益增加，团队在安全和漏洞管理方面积累了丰富的经验，能够为企业提供全面的安全解决方案。
+- 26.权限控制采用RBAC（Role-Based Access Control，基于角色的访问控制）。
+- 27.页面校验自动生成（必须输入、数字校验、金额校验、时间空间等）。
+- 28.支持SaaS服务模式，提供SaaS多租户架构方案。
+- 29.分布式文件服务，集成MinIO、阿里OSS等优秀的第三方，提供便捷的文件上传与管理，同时也支持本地存储。
+- 30.主流数据库兼容，一套代码完全兼容MySQL、PostgreSQL、Oracle、SQL Server、MariaDB、达梦、人大金仓等主流数据库。
+- 31.集成工作流Flowable，并实现了只需在页面配置流程转向，可极大简化BPM工作流的开发；用BPM的流程设计器画出了流程走向，一个工作流基本就完成了，只需写很少量的Java代码。
+- 32.低代码能力：在线流程设计，采用开源Flowable流程引擎，实现在线画流程、自定义表单、表单挂靠、业务流转。
+- 33.多数据源：极其简易的使用方式，在线配置数据源配置，便捷地从其他数据抓取数据。
+- 34.提供单点登录CAS集成方案，项目中已经提供完善的对接代码。
+- 35.低代码能力：表单设计器，支持用户自定义表单布局，支持单表、一对多表单，支持select、radio、checkbox、textarea、date、popup、列表、宏等控件。
+- 36.专业接口对接机制，统一采用RESTful接口方式，集成Swagger-UI在线接口文档，JWT token安全验证，方便客户端对接。
+- 37.高级组合查询功能，在线配置支持主子表关联查询，可保存查询历史。
+- 38.提供各种系统监控，实时跟踪系统运行情况（监控Redis、Tomcat、JVM、服务器信息、请求追踪、SQL监控）。
+- 39.消息中心（支持短信、邮件、微信推送等）；集成WebSocket消息通知机制。
+- 40.支持多语言，提供国际化方案。
+- 41.数据变更记录日志，可记录数据每次变更内容，通过版本对比功能查看历史变化。
+- 42.提供简单易用的打印插件，支持谷歌、火狐、IE11+等各种浏览器。
+- 43.后端采用Maven分模块开发方式；前端支持菜单动态路由。
+- 44.提供丰富的示例代码，涵盖了常用的业务场景，便于学习和参考。
 
 
 技术架构：
@@ -61,28 +145,33 @@ JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端
 #### 后端
 
 - IDE建议： IDEA (必须安装lombok插件 )
-- 语言：Java 8+ (支持17)
+- 语言：Java 默认jdk17(jdk21、jdk24)
 - 依赖管理：Maven
-- 基础框架：Spring Boot 2.7.18
-- 微服务框架： Spring Cloud Alibaba 2021.0.1.0
-- 持久层框架：MybatisPlus 3.5.3.2
-- 报表工具： JimuReport 1.8.1
-- 安全框架：Apache Shiro 1.12.0，Jwt 3.11.0
+- 基础框架：Spring Boot 3.5.5
+- 微服务框架： Spring Cloud Alibaba 2023.0.3.3
+- 持久层框架：MybatisPlus 3.5.12
+- 报表工具： JimuReport 2.1.3
+- 安全框架：Apache Shiro 2.0.4，Jwt 4.5.0
 - 微服务技术栈：Spring Cloud Alibaba、Nacos、Gateway、Sentinel、Skywalking
-- 数据库连接池：阿里巴巴Druid 1.1.22
+- 数据库连接池：阿里巴巴Druid 1.2.24
+- AI大模型：支持 `ChatGPT` `DeepSeek` `千问`等各种常规模式
 - 日志打印：logback
 - 缓存：Redis
 - 其他：autopoi, fastjson，poi，Swagger-ui，quartz, lombok（简化代码）等。
-- 默认数据库脚本：MySQL5.7+
+- 默认提供MySQL5.7+数据库脚本
 - [其他数据库，需要自己转](https://my.oschina.net/jeecg/blog/4905722)
 
 
 #### 前端
 
-- 前端IDE建议：WebStorm、Vscode
-- 采用 Vue3.0+TypeScript+Vite+Ant-Design-Vue等新技术方案，包括二次封装组件、utils、hooks、动态菜单、权限校验、按钮级别权限控制等功能
-- 最新技术栈：Vue3.0 + TypeScript + Vite5 + ant-design-vue4 + pinia + echarts + unocss + vxe-table + qiankun + es6
+- 前端环境要求：Node.js要求`Node 20+` 版本以上、pnpm 要求`9+` 版本以上
+  ` ( Vite 不再支持已结束生命周期（EOL）的 Node.js 18。现在需要使用 Node.js 20.19+ 或 22.12+)`
+
 - 依赖管理：node、npm、pnpm
+- 前端IDE建议：IDEA、WebStorm、Vscode
+- 采用 Vue3.0+TypeScript+Vite6+Ant-Design-Vue4等新技术方案，包括二次封装组件、utils、hooks、动态菜单、权限校验、按钮级别权限控制等功能
+- 最新技术栈：Vue3.0 + TypeScript + Vite6 + ant-design-vue4 + pinia + echarts + unocss + vxe-table + qiankun + es6
+
 
 
 
@@ -113,7 +202,7 @@ JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端
 - 6、分布式文件 Minio、阿里OSS √ 
 - 7、统一权限控制 JWT + Shiro √
 - 8、服务监控 SpringBootAdmin√
-- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking.html)
+- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking)
 - 10、消息中间件 RabbitMQ  √
 - 11、分布式任务 xxl-job  √ 
 - 12、分布式事务 Seata

jeecg-boot/Shiro到Sa-Token迁移指南.md

@@ -0,0 +1,368 @@
+# `Shiro 到 Sa-Token 迁移指南`
+
+本项目已从 **Apache Shiro 2.0.4** 迁移到 **Sa-Token 1.44.0**，采用 JWT-Simple 模式，完全兼容原 JWT token 格式。
+
+---
+
+## 📦 1. 依赖配置
+
+### 1.1 Maven 依赖
+
+移除 Shiro 相关依赖，新增：
+
+```xml
+<dependency>
+    <groupId>cn.dev33</groupId>
+    <artifactId>sa-token-spring-boot3-starter</artifactId>
+    <version>1.44.0</version>
+</dependency>
+<dependency>
+    <groupId>cn.dev33</groupId>
+    <artifactId>sa-token-redis-jackson</artifactId>
+    <version>1.44.0</version>
+</dependency>
+<dependency>
+    <groupId>cn.dev33</groupId>
+    <artifactId>sa-token-jwt</artifactId>
+    <version>1.44.0</version>
+</dependency>
+```
+
+### 1.2 配置文件（application.yml）
+
+```yaml
+sa-token:
+  token-name: X-Access-Token
+  timeout: 2592000         # token有效期30天
+  is-concurrent: true      # 允许同账号并发登录
+  token-style: jwt-simple  # JWT模式（兼容原格式）
+  jwt-secret-key: "your-secret-key-here"
+```
+
+---
+
+## 💡 2. 核心代码实现
+
+### 2.1 登录逻辑（⚠️ 使用 username 作为 loginId）
+
+```java
+// 从数据库查询用户信息
+SysUser sysUser = userService.getUserByUsername(username);
+
+// 执行登录（自动完成：Sa-Token登录 + 存储Session + 返回token）
+String token = LoginUserUtils.doLogin(sysUser);
+
+// 返回token给前端
+return Result.ok(token);
+```
+
+**💡 设计说明：**
+- `doLogin()` 方法自动完成：
+  1. 调用 `StpUtil.login(username)` （使用 username 而非 userId）
+  2. 调用 `setSessionUser()` 存储用户信息（自动清除 password 等15个字段）
+  3. 返回生成的 token
+- 减少 Redis 存储约 50%，密码不再存储到 Session
+
+### 2.2 权限认证接口（⚠️ 必须手动实现缓存）
+
+```java
+@Component
+public class StpInterfaceImpl implements StpInterface {
+    
+    @Lazy @Resource
+    private CommonAPI commonApi;
+    
+    private static final long CACHE_TIMEOUT = 60 * 60 * 24 * 30;  // 30天
+    private static final String PERMISSION_CACHE_PREFIX = "satoken:user-permission:";
+    private static final String ROLE_CACHE_PREFIX = "satoken:user-role:";
+    
+    @Override
+    @SuppressWarnings("unchecked")
+    public List<String> getPermissionList(Object loginId, String loginType) {
+        String username = loginId.toString();
+        String cacheKey = PERMISSION_CACHE_PREFIX + username;
+        SaTokenDao dao = SaManager.getSaTokenDao();
+        
+        // 1. 先从缓存获取
+        List<String> permissionList = (List<String>) dao.getObject(cacheKey);
+        
+        if (permissionList == null) {
+            // 2. 缓存未命中，查询数据库
+            log.warn("权限缓存未命中，查询数据库 [ username={} ]", username);
+            
+            String userId = commonApi.getUserIdByName(username);
+            Set<String> permissionSet = commonApi.queryUserAuths(userId);
+            permissionList = new ArrayList<>(permissionSet);
+            
+            // 3. 将结果缓存起来
+            dao.setObject(cacheKey, permissionList, CACHE_TIMEOUT);
+        }
+        
+        return permissionList;
+    }
+    
+    @Override
+    public List<String> getRoleList(Object loginId, String loginType) {
+        // 实现类似 getPermissionList()，使用 ROLE_CACHE_PREFIX
+        // 详见：StpInterfaceImpl.java
+    }
+    
+    // 清除缓存的静态方法
+    public static void clearUserCache(List<String> usernameList) {
+        SaTokenDao dao = SaManager.getSaTokenDao();
+        for (String username : usernameList) {
+            dao.deleteObject(PERMISSION_CACHE_PREFIX + username);
+            dao.deleteObject(ROLE_CACHE_PREFIX + username);
+        }
+    }
+}
+```
+
+**⚠️ 关键：** Sa-Token 的 `StpInterface` **不提供自动缓存**，必须手动实现，否则每次请求都会查询数据库！
+
+### 2.3 Filter 配置（支持 URL 参数传递 token）
+
+```java
+@Bean
+@Primary
+public StpLogic getStpLogicJwt() {
+    return new StpLogicJwtForSimple() {
+        @Override
+        public String getTokenValue() {
+            SaRequest request = SaHolder.getRequest();
+            
+            // 优先级：Header > URL参数"token" > URL参数"X-Access-Token"
+            String tokenValue = request.getHeader(getConfigOrGlobal().getTokenName());
+            if (isEmpty(tokenValue)) {
+                tokenValue = request.getParam("token");  // 兼容 WebSocket、积木报表
+            }
+            if (isEmpty(tokenValue)) {
+                tokenValue = request.getParam(getConfigOrGlobal().getTokenName());
+            }
+            
+            return isEmpty(tokenValue) ? super.getTokenValue() : tokenValue;
+        }
+    };
+}
+
+@Bean
+public SaServletFilter getSaServletFilter() {
+    return new SaServletFilter()
+        .addInclude("/**")
+        .setExcludeList(getExcludeUrls())  // 排除登录、静态资源等
+        .setAuth(obj -> {
+            // 检查是否是免认证路径
+            String servletPath = SaHolder.getRequest().getRequestPath();
+            if (InMemoryIgnoreAuth.contains(servletPath)) {
+                return;
+            }
+            
+            // ⚠️ 关键：如果请求带 token，先切换到对应的登录会话
+            try {
+                String token = StpUtil.getTokenValue();
+                if (isNotEmpty(token)) {
+                    Object loginId = StpUtil.getLoginIdByToken(token);
+                    if (loginId != null) {
+                        StpUtil.switchTo(loginId);  // 切换登录会话
+                    }
+                }
+            } catch (Exception e) {
+                log.debug("切换登录会话失败: {}", e.getMessage());
+            }
+            
+            // 最终校验登录状态
+            StpUtil.checkLogin();
+        })
+        .setError(e -> {
+            // 返回401 JSON响应
+            SaHolder.getResponse()
+                .setStatus(401)
+                .setHeader("Content-Type", "application/json;charset=UTF-8");
+            return JwtUtil.responseErrorJson(401, "Token失效，请重新登录!");
+        });
+}
+```
+
+### 2.4 全局异常处理
+
+```java
+@ExceptionHandler(NotLoginException.class)
+public Result<?> handleNotLoginException(NotLoginException e) {
+    log.warn("用户未登录或Token失效: {}", e.getMessage());
+    return Result.error(401, "Token失效，请重新登录!");
+}
+
+@ExceptionHandler(NotPermissionException.class)
+public Result<?> handleNotPermissionException(NotPermissionException e) {
+    log.warn("权限不足: {}", e.getMessage());
+    return Result.error(403, "用户权限不足，无法访问！");
+}
+```
+
+---
+
+## 🔄 3. API 迁移对照表
+
+### 3.1 注解替换
+
+| Shiro | Sa-Token | 说明 |
+|-------|----------|------|
+| `@RequiresPermissions("user:add")` | `@SaCheckPermission("user:add")` | 权限校验 |
+| `@RequiresRoles("admin")` | `@SaCheckRole("admin")` | 角色校验 |
+
+### 3.2 API 替换
+
+| Shiro | Sa-Token | 说明 |
+|-------|----------|------|
+| `SecurityUtils.getSubject().getPrincipal()` | `LoginUserUtils.getSessionUser()` | 获取登录用户 |
+| `Subject.login(token)` | `LoginUserUtils.doLogin(sysUser)` | 登录（推荐） |
+| `Subject.login(token)` | `StpUtil.login(username)` | 登录（底层API） |
+| `Subject.logout()` | `StpUtil.logout()` | 退出登录 |
+| `Subject.isAuthenticated()` | `StpUtil.isLogin()` | 判断是否登录 |
+| `Subject.hasRole("admin")` | `StpUtil.hasRole("admin")` | 判断角色 |
+| `Subject.isPermitted("user:add")` | `StpUtil.hasPermission("user:add")` | 判断权限 |
+
+---
+
+## ⚠️ 4. 重要特性说明
+
+### 4.1 JWT-Simple 模式特性
+
+- ✅ **生成标准 JWT token**：与原 Shiro JWT 格式完全兼容
+- ✅ **仍然检查 Redis Session**：支持强制退出（与纯 JWT 无状态模式不同）
+- ✅ **支持 URL 参数传递**：兼容 WebSocket、积木报表等场景
+- ⚠️ **非完全无状态**：依赖 Redis 存储会话和权限缓存
+
+### 4.2 Session 数据优化
+
+`LoginUserUtils.setSessionUser()` 会自动清除以下字段：
+
+```
+password, workNo, birthday, sex, email, phone, status, 
+delFlag, activitiSync, createTime, userIdentity, post, 
+telephone, clientId, mainDepPostId
+```
+
+**优势：**
+- 减少 Redis 存储约 **50%**
+- 密码不再存储在 Session 中，**安全性提升**
+
+### 4.3 权限缓存动态更新
+
+修改角色权限后，系统会自动清除受影响用户的权限缓存：
+
+```java
+// SysPermissionController.saveRolePermission() 中
+@RequestMapping(value = "/saveRolePermission", method = RequestMethod.POST)
+public Result<String> saveRolePermission(@RequestBody JSONObject json) {
+    String roleId = json.getString("roleId");
+    String permissionIds = json.getString("permissionIds");
+    String lastPermissionIds = json.getString("lastpermissionIds");
+    
+    // 保存角色权限关系
+    sysRolePermissionService.saveRolePermission(roleId, permissionIds, lastPermissionIds);
+    
+    // ⚠️ 关键：清除拥有该角色的所有用户的权限缓存
+    clearRolePermissionCache(roleId);
+    
+    return Result.ok("保存成功！");
+}
+
+// 实现：查询该角色下的所有用户，批量清除缓存
+private void clearRolePermissionCache(String roleId) {
+    List<String> usernameList = new ArrayList<>();
+    
+    // 分页查询拥有该角色的用户
+    int pageNo = 1, pageSize = 100;
+    while (true) {
+        Page<SysUser> page = new Page<>(pageNo, pageSize);
+        IPage<SysUser> userPage = sysUserService.getUserByRoleId(page, roleId, null, null);
+        
+        if (userPage.getRecords().isEmpty()) break;
+        
+        for (SysUser user : userPage.getRecords()) {
+            usernameList.add(user.getUsername());
+        }
+        
+        if (pageNo >= userPage.getPages()) break;
+        pageNo++;
+    }
+    
+    // 批量清除用户权限和角色缓存
+    if (!usernameList.isEmpty()) {
+        StpInterfaceImpl.clearUserCache(usernameList);
+    }
+}
+```
+
+**结果：** 权限变更立即生效，用户无需重新登录。
+
+
+## ✅ 6. 测试清单
+
+### 6.1 登录功能测试
+
+| 测试项 | 测试状态 | 说明 |
+|--------|---------|------|
+| 账号密码登录 | ✅ 通过 | 验证 `/sys/login` 接口 |
+| 手机号登录 | ✅ 通过 | 验证 `/sys/phoneLogin` 接口 |
+| APP 登录 | ✅ 通过 | 验证 APP 端登录流程 |
+| 扫码登录 | ✅ 通过 | 验证二维码扫码登录 |
+| 第三方登录 | ⏳ 待测试 | 微信、QQ 等第三方登录 |
+| 钉钉 OAuth2.0 登录 | ⏳ 待测试 | 钉钉授权登录流程 |
+| 企业微信 OAuth2.0 登录 | ⏳ 待测试 | 企业微信授权登录流程 |
+| CAS 单点登录 | ⏳ 待测试 | CAS 单点登录集成 |
+
+### 6.2 核心功能测试
+
+| 测试项 | 测试状态 | 说明 |
+|--------|---------|------|
+| Token 权限拦截 | ✅ 通过 | 无 token 或失效 token 返回 401 |
+| 权限注解 `@SaCheckPermission` | ✅ 通过 | 无权限返回 403 |
+| 角色注解 `@SaCheckRole` | ✅ 通过 | 无角色返回 403 |
+| `@IgnoreAuth` 免认证 | ✅ 通过 | 无 token 也能正常访问 |
+| 自动续期（操作不掉线） | ✅ 通过 | 活跃用户 token 自动续期 |
+| 用户权限变更即刻生效 | ✅ 通过 | 修改角色权限后无需重新登录 |
+| 积木报表 token 参数模式 | ✅ 通过 | `/jmreport/**?token=xxx` 正常访问 |
+
+### 6.3 异步和网关测试
+
+| 测试项 | 测试状态 | 说明 |
+|--------|---------|------|
+| 异步接口（`@Async`） | ❌ 有问题 | **需排查：异步线程中获取登录用户失败** |
+| Gateway 模式权限验证 | ⏳ 待测试 | 网关模式下的权限拦截 |
+
+### 6.4 多租户测试
+
+| 测试项 | 测试状态 | 说明 |
+|--------|---------|------|
+| 租户 ID 校验 | ⚠️ 缺失 | **需补充：校验用户 tenant_id 和前端传参一致性** |
+
+### 6.5 测试说明
+
+**✅ 通过** - 功能正常，符合预期  
+**❌ 有问题** - 功能异常，需要修复  
+**⏳ 待测试** - 尚未测试  
+**⚠️ 缺失** - 功能缺失，需要补充
+
+
+---
+
+## 📊 7. 迁移总结
+
+| 优化项 | 说明 | 收益 |
+|--------|------|------|
+| **loginId 设计** | 使用 `username` 而非 `userId` | 语义清晰，与业务逻辑一致 |
+| **Session 优化** | 清除 15 个不必要字段 | Redis 存储减少 50%，安全性提升 |
+| **权限缓存** | 手动实现 30 天缓存 | 性能提升 99%，降低 DB 压力 |
+| **权限实时更新** | 角色权限修改后自动清除缓存 | 无需重新登录即生效 |
+| **URL Token 支持** | Filter 中实现 `switchTo` | 兼容 WebSocket、积木报表等场景 |
+| **JWT 兼容** | JWT-Simple 模式 | 完全兼容原 JWT token 格式 |
+
+---
+
+## 📚 参考资料
+
+- [Sa-Token 官方文档](https://sa-token.cc/)
+- [Sa-Token JWT-Simple 模式](https://sa-token.cc/doc.html#/plugin/jwt-extend)
+- [Sa-Token 权限缓存最佳实践](https://sa-token.cc/doc.html#/fun/jur-cache)

jeecg-boot/db/tables_xxl_job.sql

@@ -1,5 +1,5 @@
 #
-# XXL-JOB v2.2.0
+# XXL-JOB v2.4.0
 # Copyright (c) 2015-present, xuxueli.
 
 CREATE database if NOT EXISTS `xxl_job` default character set utf8mb4 collate utf8mb4_general_ci;

jeecg-boot/db/其他数据库脚本/oracle11g dmp说明.txt

@@ -0,0 +1,5 @@
+oracle导出编码：  export NLS_LANG=AMERICAN_AMERICA.ZHS16GBK
+
+导出用户：  jeecgbootos
+
+导入命令：  imp scott/tiger@orcl file=jeecgboot-oracle11g.dmp

jeecg-boot/docker-compose.yml

@@ -18,20 +18,47 @@ services:
       --max_allowed_packet=128M
       --default-authentication-plugin=caching_sha2_password
     ports:
-      - 3306:3306
+      - 13306:3306
     networks:
       - jeecg-boot
 
   jeecg-boot-redis:
     image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/redis:5.0
-    ports:
-      - 6379:6379
+#    ports:
+#      - 6379:6379
     restart: always
     hostname: jeecg-boot-redis
     container_name: jeecg-boot-redis
     networks:
       - jeecg-boot
 
+  jeecg-boot-pgvector:
+    image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/pgvector
+    container_name: jeecg-boot-pgvector
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: vector_db
+#    ports:
+#      - 5432:5432
+    restart: always
+    networks:
+      - jeecg-boot
+  
+#  jeecg-boot-rabbitmq:
+#    image: rabbitmq:3.7.7-management
+##    ports:
+##      - 5672:5672
+##      - 15672:15672
+#    restart: always
+#    container_name: jeecg-boot-rabbitmq
+#    hostname: jeecg-boot-rabbitmq
+#    environment:
+#      RABBITMQ_DEFAULT_USER: guest
+#      RABBITMQ_DEFAULT_PASS: guest
+#    networks:
+#      - jeecg-boot
+
   jeecg-boot-system:
     build:
       context: ./jeecg-module-system/jeecg-system-start
@@ -46,6 +73,8 @@ services:
       - 8080:8080
     networks:
       - jeecg-boot
+    volumes:
+      - ./config:/jeecg-boot/config
 
 networks:
   jeecg-boot:

jeecg-boot/jeecg-boot-base-core/pom.xml

@@ -2,9 +2,9 @@
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<parent>
-		<groupId>org.jeecgframework.boot</groupId>
+		<groupId>org.jeecgframework.boot3</groupId>
 		<artifactId>jeecg-boot-parent</artifactId>
-		<version>3.7.3</version>
+		<version>3.8.3</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jeecg-boot-base-core</artifactId>
@@ -42,7 +42,7 @@
 	<dependencies>
 		<!--jeecg-tools-->
 		<dependency>
-			<groupId>org.jeecgframework.boot</groupId>
+			<groupId>org.jeecgframework.boot3</groupId>
 			<artifactId>jeecg-boot-common</artifactId>
 		</dependency>
 		<!--集成springmvc框架并实现自动配置 -->
@@ -98,21 +98,31 @@
 		<!-- mybatis-plus -->
 		<dependency>
 			<groupId>com.baomidou</groupId>
-			<artifactId>mybatis-plus-boot-starter</artifactId>
+			<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
 			<version>${mybatis-plus.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>com.baomidou</groupId>
+			<artifactId>mybatis-plus-jsqlparser-4.9</artifactId>
+			<version>${mybatis-plus.version}</version>
+		</dependency>
+		<!-- minidao -->
+        <dependency>
+            <groupId>org.jeecgframework.boot3</groupId>
+            <artifactId>minidao-spring-boot-starter-jsqlparser-4.9</artifactId>
+        </dependency>
 
 		<!-- druid -->
 		<dependency>
 			<groupId>com.alibaba</groupId>
-			<artifactId>druid-spring-boot-starter</artifactId>
+			<artifactId>druid-spring-boot-3-starter</artifactId>
 			<version>${druid.version}</version>
 		</dependency>
 
 		<!-- 动态数据源 -->
 		<dependency>
 			<groupId>com.baomidou</groupId>
-			<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
+			<artifactId>dynamic-datasource-spring-boot3-starter</artifactId>
 			<version>${dynamic-datasource-spring-boot-starter.version}</version>
 		</dependency>
 
@@ -127,7 +137,7 @@
 		<!--  sqlserver-->
 		<dependency>
 			<groupId>com.microsoft.sqlserver</groupId>
-			<artifactId>sqljdbc4</artifactId>
+			<artifactId>mssql-jdbc</artifactId>
 			<version>${sqljdbc4.version}</version>
 			<scope>runtime</scope>
 		</dependency>
@@ -149,13 +159,13 @@
 		<dependency>
 			<groupId>org.jeecgframework</groupId>
 			<artifactId>kingbase8</artifactId>
-			<version>9.0.0</version>
+			<version>${kingbase8.version}</version>
 			<scope>runtime</scope>
 		</dependency>
 		<!--达梦数据库驱动 版本号1-3-26-2023.07.26-197096-20046-ENT -->
 		<dependency>
 			<groupId>com.dameng</groupId>
-			<artifactId>Dm8JdbcDriver18</artifactId>
+			<artifactId>DmJdbcDriver18</artifactId>
 			<version>${dm8.version}</version>
 		</dependency>
 		<dependency>
@@ -163,53 +173,48 @@
 			<artifactId>DmDialect-for-hibernate5.0</artifactId>
 			<version>${dm8.version}</version>
 		</dependency>
-      
+
 		<!-- Quartz定时任务 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-quartz</artifactId>
 		</dependency>
 
-		<!--JWT-->
+		<!-- Sa-Token 权限认证，在线文档：https://sa-token.cc -->
 		<dependency>
-			<groupId>com.auth0</groupId>
-			<artifactId>java-jwt</artifactId>
-			<version>${java-jwt.version}</version>
+			<groupId>cn.dev33</groupId>
+			<artifactId>sa-token-spring-boot3-starter</artifactId>
+			<version>${sa-token.version}</version>
+		</dependency>
+		<!-- Sa-Token 整合 Redis (使用 jackson 序列化方式) -->
+		<dependency>
+			<groupId>cn.dev33</groupId>
+			<artifactId>sa-token-redis-jackson</artifactId>
+			<version>${sa-token.version}</version>
+		</dependency>
+		<!-- Sa-Token 整合 jwt (Simple模式)，保持与原JWT token格式兼容 -->
+		<dependency>
+			<groupId>cn.dev33</groupId>
+			<artifactId>sa-token-jwt</artifactId>
+			<version>${sa-token.version}</version>
 		</dependency>
 
-		<!--shiro-->
-		<dependency>
-			<groupId>org.apache.shiro</groupId>
-			<artifactId>shiro-spring-boot-starter</artifactId>
-			<version>${shiro.version}</version>
-		</dependency>
-		<!-- shiro-redis -->
-		<dependency>
-			<groupId>org.crazycake</groupId>
-			<artifactId>shiro-redis</artifactId>
-			<version>${shiro-redis.version}</version>
-			<exclusions>
-				<exclusion>
-					<groupId>org.apache.shiro</groupId>
-					<artifactId>shiro-core</artifactId>
-				</exclusion>
-				<exclusion>
-					<artifactId>checkstyle</artifactId>
-					<groupId>com.puppycrawl.tools</groupId>
-				</exclusion>
-			</exclusions>
-		</dependency>
 
-		<!-- knife4j -->
-<!--		<dependency>
+		<!--	<dependency>
 			<groupId>com.github.xiaoymin</groupId>
-			<artifactId>knife4j-spring-boot-starter</artifactId>
-			<version>3.0.3</version>
-		</dependency>-->
-		<dependency>
-			<groupId>com.github.xiaoymin</groupId>
-			<artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
+			<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>
+			<version>${knife4j-spring-boot-starter.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.springdoc</groupId>
+			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+			<version>2.7.0</version>
 		</dependency>
 
 		<!-- 代码生成器 -->
@@ -218,23 +223,22 @@
 			<groupId>org.jeecgframework.boot</groupId>
 			<artifactId>codegenerate</artifactId>
 			<version>${codegenerate.version}</version>
+			<exclusions>
+				<exclusion>
+					<artifactId>commons-io</artifactId>
+					<groupId>commons-io</groupId>
+				</exclusion>
+				<exclusion>
+					<artifactId>mysql-connector-java</artifactId>
+					<groupId>mysql</groupId>
+				</exclusion>
+			</exclusions>
 		</dependency>
 
 		<!-- AutoPoi Excel工具类-->
 		<dependency>
-			<groupId>org.jeecgframework</groupId>
+			<groupId>org.jeecgframework.boot3</groupId>
 			<artifactId>autopoi-web</artifactId>
-			<version>${autopoi-web.version}</version>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-codec</groupId>
-					<artifactId>commons-codec</artifactId>
-				</exclusion>
-				<exclusion>
-					<artifactId>xercesImpl</artifactId>
-					<groupId>xerces</groupId>
-				</exclusion>
-			</exclusions>
 		</dependency>
 		<dependency>
 			<groupId>xerces</groupId>
@@ -247,6 +251,12 @@
 		<dependency>
 			<groupId>io.minio</groupId>
 			<artifactId>minio</artifactId>
+			<exclusions>
+				<exclusion>
+					<artifactId>checker-qual</artifactId>
+					<groupId>org.checkerframework</groupId>
+				</exclusion>
+			</exclusions>
 		</dependency>
 
 		<!-- 阿里云短信 -->
@@ -265,6 +275,16 @@
 		<dependency>
 			<groupId>com.xkcoding.justauth</groupId>
 			<artifactId>justauth-spring-boot-starter</artifactId>
+			<exclusions>
+				<exclusion>
+					<groupId>org.springframework.boot</groupId>
+					<artifactId>spring-boot-autoconfigure</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.springframework.boot</groupId>
+					<artifactId>spring-boot-configuration-processor</artifactId>
+				</exclusion>
+			</exclusions>
 		</dependency>
 		<dependency>
 			<groupId>com.squareup.okhttp3</groupId>
@@ -288,10 +308,9 @@
 			<groupId>cn.hutool</groupId>
 			<artifactId>hutool-crypto</artifactId>
 		</dependency>
-
 		<!-- chatgpt -->
 		<dependency>
-			<groupId>org.jeecgframework.boot</groupId>
+			<groupId>org.jeecgframework.boot3</groupId>
 			<artifactId>jeecg-boot-starter-chatgpt</artifactId>
 		</dependency>
 	</dependencies>

jeecg-boot/jeecg-boot-base-core/src/main/java/org/apache/shiro/SecurityUtils.java

@@ -0,0 +1,21 @@
+package org.apache.shiro;
+
+import org.apache.shiro.subject.Subject;
+
+/**
+ * 兼容处理Online功能使用处理，请勿修改
+ * @author eightmonth@qq.com
+ * @date 2024/4/29 14:05
+ */
+public class SecurityUtils {
+
+
+    public static Subject getSubject() {
+        return new Subject() {
+            @Override
+            public Object getPrincipal() {
+                return Subject.super.getPrincipal();
+            }
+        };
+    }
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/apache/shiro/subject/Subject.java

@@ -0,0 +1,15 @@
+package org.apache.shiro.subject;
+
+
+import org.jeecg.common.util.LoginUserUtils;
+
+/**
+ * 兼容处理Online功能使用处理，请勿修改
+ * @author eightmonth@qq.com
+ * @date 2024/4/29 14:18
+ */
+public interface Subject {
+    default Object getPrincipal() {
+        return LoginUserUtils.getSessionUser();
+    }
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/CommonAPI.java

@@ -1,5 +1,6 @@
 package org.jeecg.common.api;
 
+import org.jeecg.common.api.dto.AiragFlowDTO;
 import org.jeecg.common.system.vo.*;
 
 import java.util.List;
@@ -144,4 +145,15 @@ public interface CommonAPI {
     List<DictModel> translateDictFromTableByKeys(String table, String text, String code, String keys, String dataSource);
     //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
 
+    /**
+     * 16 运行AIRag流程
+     * for  [QQYUN-13634]在baseapi里面封装方法，方便其他模块调用
+     *
+     * @param airagFlowDTO
+     * @return 流程执行结果,可能是String或者Map
+     * @author chenrui
+     * @date 2025/9/2 11:43
+     */
+    Object runAiragFlow(AiragFlowDTO airagFlowDTO);
+
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/AiragFlowDTO.java

@@ -0,0 +1,36 @@
+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.Map;
+
+/**
+ * 调用AI流程入参
+ * for [QQYUN-13634]在baseapi里面封装方法，方便其他模块调用
+ * @author chenrui
+ * @date 2025/9/2 14:11
+ */
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class AiragFlowDTO implements Serializable {
+
+
+    private static final long serialVersionUID = 7431775881170684867L;
+
+    /**
+     * 流程id
+     */
+    private String flowId;
+
+
+    /**
+     * 输入参数
+     */
+    private Map<String, Object> inputParams;
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/FileDownDTO.java

@@ -2,7 +2,7 @@ package org.jeecg.common.api.dto;
 
 import lombok.Data;
 
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletResponse;
 import java.io.Serializable;
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/dto/message/MessageDTO.java

@@ -91,6 +91,12 @@ public class MessageDTO implements Serializable {
     private Boolean isTimeJob = false;
     
     //---【邮件相关参数】-------------------------------------------------------------
+
+    /**
+     * 枚举：org.jeecg.common.constant.enums.NoticeTypeEnum
+     * 通知类型(system:系统消息、file:知识库、flow:流程、plan:日程计划、meeting:会议)
+     */
+    private String noticeType;
     
     public MessageDTO(){
     }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/api/vo/Result.java

@@ -1,8 +1,8 @@
 package org.jeecg.common.api.vo;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
+
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import org.jeecg.common.constant.CommonConstant;
 
@@ -15,7 +15,7 @@ import java.io.Serializable;
  * @date  2019年1月19日
  */
 @Data
-@ApiModel(value="接口返回对象", description="接口返回对象")
+@Schema(description="接口返回对象")
 public class Result<T> implements Serializable {
 
 	private static final long serialVersionUID = 1L;
@@ -23,31 +23,31 @@ public class Result<T> implements Serializable {
 	/**
 	 * 成功标志
 	 */
-	@ApiModelProperty(value = "成功标志")
+	@Schema(description = "成功标志")
 	private boolean success = true;
 
 	/**
 	 * 返回处理消息
 	 */
-	@ApiModelProperty(value = "返回处理消息")
+	@Schema(description = "返回处理消息")
 	private String message = "";
 
 	/**
 	 * 返回代码
 	 */
-	@ApiModelProperty(value = "返回代码")
+	@Schema(description = "返回代码")
 	private Integer code = 0;
 	
 	/**
 	 * 返回数据对象 data
 	 */
-	@ApiModelProperty(value = "返回数据对象")
+	@Schema(description = "返回数据对象")
 	private T result;
 	
 	/**
 	 * 时间戳
 	 */
-	@ApiModelProperty(value = "时间戳")
+	@Schema(description = "时间戳")
 	private long timestamp = System.currentTimeMillis();
 
 	public Result() {

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/AutoLogAspect.java

@@ -2,7 +2,7 @@ package org.jeecg.common.aspect;
 
 import com.alibaba.fastjson.JSONObject;
 import com.alibaba.fastjson.serializer.PropertyFilter;
-import org.apache.shiro.SecurityUtils;
+import org.jeecg.common.util.LoginUserUtils;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
@@ -20,14 +20,14 @@ import org.jeecg.common.system.vo.LoginUser;
 import org.jeecg.common.util.IpUtils;
 import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.common.util.oConvertUtils;
-import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
+import org.springframework.core.StandardReflectionParameterNameDiscoverer;
 import org.springframework.stereotype.Component;
 import org.springframework.validation.BindingResult;
 import org.springframework.web.multipart.MultipartFile;
-import javax.annotation.Resource;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.annotation.Resource;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
 import java.lang.reflect.Method;
 import java.util.Date;
 
@@ -100,7 +100,7 @@ public class AutoLogAspect {
         //设置IP地址
         dto.setIp(IpUtils.getIpAddr(request));
         //获取登录用户信息
-        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+        LoginUser sysUser = LoginUserUtils.getSessionUser();
         if(sysUser!=null){
             dto.setUserid(sysUser.getUsername());
             dto.setUsername(sysUser.getRealname());
@@ -172,7 +172,7 @@ public class AutoLogAspect {
             // 请求的方法参数值
             Object[] args = joinPoint.getArgs();
             // 请求的方法参数名称
-            LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
+            StandardReflectionParameterNameDiscoverer u=new StandardReflectionParameterNameDiscoverer();
             String[] paramNames = u.getParameterNames(method);
             if (args != null && paramNames != null) {
                 for (int i = 0; i < args.length; i++) {
@@ -244,7 +244,7 @@ public class AutoLogAspect {
         sysLog.setIp(IPUtils.getIpAddr(request));
 
         //获取登录用户信息
-        LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
+        LoginUser sysUser = LoginUserUtils.getLoginUser();
         if(sysUser!=null){
             sysLog.setUserid(sysUser.getUsername());
             sysLog.setUsername(sysUser.getRealname());

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/PermissionDataAspect.java

@@ -21,7 +21,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 import java.lang.reflect.Method;
 import java.util.List;
 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java

@@ -87,13 +87,6 @@ public interface CommonConstant {
     /**访问权限认证未通过 510*/
     Integer SC_JEECG_NO_AUTHZ=510;
 
-    /** 登录用户Shiro权限缓存KEY前缀 */
-    public static String PREFIX_USER_SHIRO_CACHE  = "shiro:cache:org.jeecg.config.shiro.ShiroRealm.authorizationCache:";
-    /** 登录用户Token令牌缓存KEY前缀 */
-    String PREFIX_USER_TOKEN  = "prefix_user_token:";
-//    /** Token缓存时间：3600秒即一小时 */
-//    int  TOKEN_EXPIRE_TIME  = 3600;
-
     /** 登录二维码 */
     String  LOGIN_QRCODE_PRE  = "QRCODELOGIN:";
     String  LOGIN_QRCODE  = "LQ:";
@@ -303,6 +296,11 @@ public interface CommonConstant {
      */
     String SYS_USER_ID_MAPPING_CACHE = "sys:cache:user:id_mapping";
 
+    /**
+     * 系统角色管理员编码
+     */
+    String SYS_ROLE_ADMIN = "admin";
+
     /**
      * 考勤补卡业务状态 （1：同意  2：不同意）
      */
@@ -428,6 +426,11 @@ public interface CommonConstant {
     */
    String NOTICE_MSG_BUS_TYPE = "NOTICE_MSG_BUS_TYPE";
 
+    /**
+     * 通知类型，用于区分来源 file 知识 flow 流程 plan 日程 system 系统消息 
+     */
+    String NOTICE_TYPE = "noticeType";
+
     /**
      * 邮箱消息中地址登录时地址后携带的token,需要替换成真实的token值
      */
@@ -629,4 +632,74 @@ public interface CommonConstant {
     * 修改手机号验证码请求次数超出
     */
    Integer PHONE_SMS_FAIL_CODE = 40002;
+
+
+    /**
+     * 自定义首页关联关系(ROLE:表示角色 USER:表示用户 DEFAULT:默认首页)
+     *
+     */
+    String HOME_RELATION_ROLE = "ROLE";
+    String HOME_RELATION_USER = "USER";
+    String HOME_RELATION_DEFAULT = "DEFAULT";
+
+    /**
+     * 是否置顶(0否 1是)
+     */
+    Integer IZ_TOP_1 = 1;
+    Integer IZ_TOP_0 = 0;
+    
+    
+    //关注流程缓存前缀
+    String FLOW_FOCUS_NOTICE_PREFIX = "flow:runtimeData:focus:notice:";
+    //任务缓办时间缓存前缀
+    String FLOW_TASK_DELAY_PREFIX = "flow:runtimeData:task:delay:";
+    /**
+     * 用户代理类型：离职：quit 代理：agent
+     */
+    String USER_AGENT_TYPE_QUIT = "quit";
+    String USER_AGENT_TYPE_AGENT = "agent";
+    /**
+     * 督办流程首节点任务taskKey
+     */
+    String SUPERVISE_FIRST_TASK_KEY = "Task_1bhxpt0";
+
+    /**
+     * wps模板预览数据缓存前缀
+     */
+    String EOA_WPS_TEMPLATE_VIEW_DATA ="eoa:wps:templateViewData:";
+
+    /**
+     * wps模板预览版本号缓存前缀
+     */
+    String EOA_WPS_TEMPLATE_VIEW_VERSION ="eoa:wps:templateViewVersion:";
+    /**
+     * 表单设计器oa新增字段
+     * x_oa_timeout_date:逾期时间
+     * x_oa_archive_status:归档状态
+     */
+    String X_OA_TIMEOUT_DATE ="x_oa_timeout_date";
+    String X_OA_ARCHIVE_STATUS ="x_oa_archive_status";
+    /**
+     * 流程状态
+     * 待提交: 1
+     * 处理中: 2
+     * 已完成: 3
+     * 已作废: 4
+     * 已挂起: 5
+     */
+    String BPM_STATUS_1 ="1";
+    String BPM_STATUS_2 ="2";
+    String BPM_STATUS_3 ="3";
+    String BPM_STATUS_4 ="4";
+    String BPM_STATUS_5 ="5";
+
+    /**
+     * 默认租户产品包
+     */
+    String TENANT_PACK_DEFAULT = "default";
+
+    /**
+     * 部门名称redisKey(全路径)
+     */
+    String DEPART_NAME_REDIS_KEY_PRE = "sys:cache:departPathName:";
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/DataBaseConstant.java

@@ -4,6 +4,20 @@ package org.jeecg.common.constant;
  * @author: jeecg-boot
  */
 public interface DataBaseConstant {
+
+	/**
+	 * 内置的系统变量键列表
+	 */
+	public static final String[] SYSTEM_KEYS = {
+			DataBaseConstant.SYS_ORG_CODE, DataBaseConstant.SYS_ORG_CODE_TABLE, DataBaseConstant.SYS_MULTI_ORG_CODE,
+			DataBaseConstant.SYS_MULTI_ORG_CODE_TABLE, DataBaseConstant.SYS_ORG_ID, DataBaseConstant.SYS_ORG_ID_TABLE,
+			DataBaseConstant.SYS_ROLE_CODE, DataBaseConstant.SYS_ROLE_CODE_TABLE, DataBaseConstant.SYS_USER_CODE,
+			DataBaseConstant.SYS_USER_CODE_TABLE, DataBaseConstant.SYS_USER_ID, DataBaseConstant.SYS_USER_ID_TABLE,
+			DataBaseConstant.SYS_USER_NAME, DataBaseConstant.SYS_USER_NAME_TABLE, DataBaseConstant.SYS_DATE,
+			DataBaseConstant.SYS_DATE_TABLE, DataBaseConstant.SYS_TIME, DataBaseConstant.SYS_TIME_TABLE,
+			DataBaseConstant.SYS_BASE_PATH
+	};
+	
 	//*********数据库类型****************************************
 
     /**MYSQL数据库*/

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/PasswordConstant.java

@@ -0,0 +1,15 @@
+package org.jeecg.common.constant;
+
+/**
+* @Description: 密码常量类
+*
+* @author: wangshuai
+* @date: 2025/8/27 20:10
+*/
+public interface PasswordConstant {
+
+    /**
+     * 导入用户默认密码
+     */
+    String DEFAULT_PASSWORD = "123456";
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/ProvinceCityArea.java

@@ -121,7 +121,7 @@ public class ProvinceCityArea {
 
     public void getAreaByCode(String code,List<String> ls){
         for(Area area: areaList){
-            if(area.getId().equals(code)){
+            if(null != area && area.getId().equals(code)){
                 String pid = area.getPid();
                 ls.add(0,area.getText());
                 getAreaByCode(pid,ls);

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/DepartCategoryEnum.java

@@ -0,0 +1,97 @@
+package org.jeecg.common.constant.enums;
+
+import org.jeecg.common.util.oConvertUtils;
+
+/**
+* @Description: 部门类型枚举类
+*
+* @author: wangshuai
+* @date: 2025/8/19 21:37
+*/
+public enum DepartCategoryEnum {
+    
+    DEPART_CATEGORY_COMPANY("部门类型：公司","公司","1"),
+    DEPART_CATEGORY_DEPART("部门类型：部门","部门","2"),
+    DEPART_CATEGORY_POST("部门类型：岗位","岗位","3"),
+    DEPART_CATEGORY_SUB_COMPANY("部门类型：子公司","子公司","4");
+
+    DepartCategoryEnum(String described, String name, String value) {
+        this.value = value;
+        this.name = name;
+        this.described = described;
+    }
+
+    /**
+     * 描述
+     */
+    private String described;
+    /**
+     * 值
+     */
+    private String value;
+
+    /**
+     * 名称
+     */
+    private String name;
+
+    public String getDescribed() {
+        return described;
+    }
+
+    public void setDescribed(String described) {
+        this.described = described;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     * 根据值获取名称
+     * 
+     * @param value
+     * @return
+     */
+    public static String getNameByValue(String value){
+        if (oConvertUtils.isEmpty(value)) {
+            return null;
+        }
+        for (DepartCategoryEnum val : values()) {
+            if (val.getValue().equals(value)) {
+                return val.getName();
+            }
+        }
+        return value;
+    }
+    
+    /**
+     * 根据名称获取值
+     * 
+     * @param name
+     * @return
+     */
+    public static String getValueByName(String name){
+        if (oConvertUtils.isEmpty(name)) {
+            return null;
+        }
+        for (DepartCategoryEnum val : values()) {
+            if (val.getName().equals(name)) {
+                return val.getValue();
+            }
+        }
+        return name;
+    }
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/DySmsEnum.java

@@ -9,14 +9,14 @@ import org.apache.commons.lang3.StringUtils;
 public enum DySmsEnum {
 
     /**登录短信模板编码*/
-	LOGIN_TEMPLATE_CODE("SMS_175435174","敲敲云","code"),
+    LOGIN_TEMPLATE_CODE("SMS_175435174","敲敲云","code"),
     /**忘记密码短信模板编码*/
-	FORGET_PASSWORD_TEMPLATE_CODE("SMS_175435174","敲敲云","code"),
-	/**修改密码短信模板编码*/
-	CHANGE_PASSWORD_TEMPLATE_CODE("SMS_465391221","敲敲云","code"),
-	/**注册账号短信模板编码*/
-	REGISTER_TEMPLATE_CODE("SMS_175430166","敲敲云","code");
-
+    FORGET_PASSWORD_TEMPLATE_CODE("SMS_175435174","敲敲云","code"),
+    /**修改密码短信模板编码*/
+    CHANGE_PASSWORD_TEMPLATE_CODE("SMS_465391221","敲敲云","code"),
+    /**注册账号短信模板编码*/
+    REGISTER_TEMPLATE_CODE("SMS_175430166","敲敲云","code");
+	
 	/**
 	 * 短信模板编码
 	 */

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/EmailTemplateEnum.java

@@ -13,6 +13,10 @@ public enum EmailTemplateEnum {
      * 流程催办
      */
     BPM_CUIBAN_EMAIL("bpm_cuiban_email", "/templates/email/bpm_cuiban_email.ftl"),
+    /**
+     * 流程抄送
+     */
+    BPM_CC_EMAIL("bpm_cc_email", "/templates/email/bpm_cc_email.ftl"),
     /**
      * 流程新任务
      */

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/MessageTypeEnum.java

@@ -8,21 +8,30 @@ import java.util.List;
 
 /**
  * 消息类型
+ *
  * @author: jeecg-boot
  */
 @EnumDict("messageType")
 public enum MessageTypeEnum {
 
-    /** 系统消息 */
-    XT("system",  "系统消息"),
-    /** 邮件消息 */
-    YJ("email",  "邮件消息"),
-    /** 钉钉消息 */
+    /**
+     * 系统消息
+     */
+    XT("system", "系统消息"),
+    /**
+     * 邮件消息
+     */
+    YJ("email", "邮件消息"),
+    /**
+     * 钉钉消息
+     */
     DD("dingtalk", "钉钉消息"),
-    /** 企业微信 */
+    /**
+     * 企业微信
+     */
     QYWX("wechat_enterprise", "企业微信");
 
-    MessageTypeEnum(String type, String note){
+    MessageTypeEnum(String type, String note) {
         this.type = type;
         this.note = note;
     }
@@ -56,12 +65,13 @@ public enum MessageTypeEnum {
 
     /**
      * 获取字典数据
+     *
      * @return
      */
-    public static List<DictModel> getDictList(){
+    public static List<DictModel> getDictList() {
         List<DictModel> list = new ArrayList<>();
         DictModel dictModel = null;
-        for(MessageTypeEnum e: MessageTypeEnum.values()){
+        for (MessageTypeEnum e : MessageTypeEnum.values()) {
             dictModel = new DictModel();
             dictModel.setValue(e.getType());
             dictModel.setText(e.getNote());

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/NoticeTypeEnum.java

@@ -0,0 +1,84 @@
+package org.jeecg.common.constant.enums;
+
+/**
+* @Description: 文件类型枚举类
+*
+* @author: wangshuai
+* @date: 2025/6/26 17:29
+*/
+public enum NoticeTypeEnum {
+    
+    //VUE3专用
+    NOTICE_TYPE_FILE("知识库消息","file"),
+    NOTICE_TYPE_FLOW("工作流消息","flow"),
+    NOTICE_TYPE_PLAN("日程消息","plan"),
+    //暂时没用到
+    NOTICE_TYPE_MEETING("会议消息","meeting"),
+    NOTICE_TYPE_SYSTEM("系统消息","system"),
+    /**
+     * 协同工作
+     * for [JHHB-136]【vue3】协同工作系统消息需要添加一个类型
+     */
+    NOTICE_TYPE_COLLABORATION("协同工作", "collab"),
+    /**
+     * 督办
+     */
+    NOTICE_TYPE_SUPERVISE("督办管理", "supe");
+
+    /**
+     * 文件类型名称
+     */
+    private String name;
+
+    /**
+     * 文件类型值
+     */
+    private String value;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    NoticeTypeEnum(String name, String value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    /**
+     * 获取聊天通知类型
+     * 
+     * @param value
+     * @return
+     */
+    public static String getChatNoticeType(String value){
+        return value + "Notice";
+    }
+
+    /**
+     * 获取通知名称
+     *
+     * @param value
+     * @return
+     */
+    public static String getNoticeNameByValue(String value){
+        value = value.replace("Notice","");
+        for (NoticeTypeEnum e : NoticeTypeEnum.values()) {
+            if (e.getValue().equals(value)) {
+                return e.getName();
+            }
+        }
+        return "系统消息";
+    }
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/PositionLevelEnum.java

@@ -0,0 +1,180 @@
+package org.jeecg.common.constant.enums;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 职级枚举类
+ * 
+ * 注意：此枚举仅适用于天津临港控股OA项目,职级的名称和等级均为写死（需要与数据库配置一致）
+ * @date 2025-08-26
+ * @author scott
+ */
+public enum PositionLevelEnum {
+
+    // 领导层级（等级1-3）
+    CHAIRMAN("董事长", 1, PositionType.LEADER),
+    GENERAL_MANAGER("总经理", 2, PositionType.LEADER),
+    VICE_GENERAL_MANAGER("副总经理", 3, PositionType.LEADER),
+
+    // 职员层级（等级4-6）
+    MINISTER("部长", 4, PositionType.STAFF),
+    VICE_MINISTER("副部长", 5, PositionType.STAFF),
+    STAFF("职员", 6, PositionType.STAFF);
+
+    private final String name;
+    private final int level;
+    private final PositionType type;
+
+    PositionLevelEnum(String name, int level, PositionType type) {
+        this.name = name;
+        this.level = level;
+        this.type = type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getLevel() {
+        return level;
+    }
+
+    public PositionType getType() {
+        return type;
+    }
+
+    /**
+     * 职级类型枚举
+     */
+    public enum PositionType {
+        STAFF("职员层级"),
+        LEADER("领导层级");
+
+        private final String desc;
+
+        PositionType(String desc) {
+            this.desc = desc;
+        }
+
+        public String getDesc() {
+            return desc;
+        }
+    }
+
+    /**
+     * 根据职级名称获取枚举
+     * @param name 职级名称
+     * @return 职级枚举
+     */
+    public static PositionLevelEnum getByName(String name) {
+        for (PositionLevelEnum position : values()) {
+            if (position.getName().equals(name)) {
+                return position;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 根据职级等级获取枚举
+     * @param level 职级等级
+     * @return 职级枚举
+     */
+    public static PositionLevelEnum getByLevel(int level) {
+        for (PositionLevelEnum position : values()) {
+            if (position.getLevel() == level) {
+                return position;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 根据职级名称判断是否为职员层级
+     * @param name 职级名称
+     * @return true-职员层级，false-非职员层级
+     */
+    public static boolean isStaffLevel(String name) {
+        PositionLevelEnum position = getByName(name);
+        return position != null && position.getType() == PositionType.STAFF;
+    }
+
+    /**
+     * 根据职级名称判断是否为领导层级
+     * @param name 职级名称
+     * @return true-领导层级，false-非领导层级
+     */
+    public static boolean isLeaderLevel(String name) {
+        PositionLevelEnum position = getByName(name);
+        return position != null && position.getType() == PositionType.LEADER;
+    }
+
+    /**
+     * 比较两个职级的等级高低
+     * @param name1 职级名称1
+     * @param name2 职级名称2
+     * @return 正数表示name1等级更高，负数表示name2等级更高，0表示等级相同
+     */
+    public static int compareLevel(String name1, String name2) {
+        PositionLevelEnum pos1 = getByName(name1);
+        PositionLevelEnum pos2 = getByName(name2);
+
+        if (pos1 == null || pos2 == null) {
+            return 0;
+        }
+
+        // 等级数字越小代表职级越高
+        return pos2.getLevel() - pos1.getLevel();
+    }
+
+    /**
+     * 判断是否为更高等级
+     * @param currentName 当前职级名称
+     * @param targetName 目标职级名称
+     * @return true-目标职级更高，false-目标职级不高于当前职级
+     */
+    public static boolean isHigherLevel(String currentName, String targetName) {
+        return compareLevel(targetName, currentName) > 0;
+    }
+
+    /**
+     * 获取所有职员层级名称
+     * @return 职员层级名称列表
+     */
+    public static List<String> getStaffLevelNames() {
+        return Arrays.asList(MINISTER.getName(), VICE_MINISTER.getName(), STAFF.getName());
+    }
+
+    /**
+     * 获取所有领导层级名称
+     * @return 领导层级名称列表
+     */
+    public static List<String> getLeaderLevelNames() {
+        return Arrays.asList(CHAIRMAN.getName(), GENERAL_MANAGER.getName(), VICE_GENERAL_MANAGER.getName());
+    }
+
+    /**
+     * 获取所有职级名称（按等级排序）
+     * @return 所有职级名称列表
+     */
+    public static List<String> getAllPositionNames() {
+        return Arrays.asList(
+                CHAIRMAN.getName(), GENERAL_MANAGER.getName(), VICE_GENERAL_MANAGER.getName(),
+                MINISTER.getName(), VICE_MINISTER.getName(), STAFF.getName()
+        );
+    }
+
+    /**
+     * 获取指定等级范围的职级
+     * @param minLevel 最小等级
+     * @param maxLevel 最大等级
+     * @return 职级名称列表
+     */
+    public static List<String> getPositionsByLevelRange(int minLevel, int maxLevel) {
+        return Arrays.stream(values())
+                .filter(p -> p.getLevel() >= minLevel && p.getLevel() <= maxLevel)
+                .map(PositionLevelEnum::getName)
+                .collect(java.util.stream.Collectors.toList());
+    }
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/SysAnnmentTypeEnum.java

@@ -23,7 +23,25 @@ public enum SysAnnmentTypeEnum {
     /**
      * 邀请用户跳转到个人设置
      */
-    TENANT_INVITE("tenant_invite", "url", "/system/usersetting");
+    TENANT_INVITE("tenant_invite", "url", "/system/usersetting"),
+    /**
+     * 协同工作-待办通知
+     * for [JHHB-136]【vue3】协同工作系统消息需要添加一个类型
+     */
+    EOA_CO_NOTIFY("eoa_co_notify", "url", "/collaboration/pending"),
+    /**
+     * 协同工作-催办通知
+     * for [JHHB-136]【vue3】协同工作系统消息需要添加一个类型
+     */
+    EOA_CO_REMIND("eoa_co_remind", "url", "/collaboration/pending"),
+    /**
+     * 督办管理-催办
+     */
+    EOA_SUP_REMIND("eoa_sup_remind", "url", "/superivse/list"),
+    /**
+     * 督办管理-通知
+     */
+    EOA_SUP_NOTIFY("eoa_sup_notify", "url", "/superivse/list");
 
     /**
      * 业务类型(email:邮件 bpm:流程)

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/exception/JeecgBootAssertException.java

@@ -0,0 +1,21 @@
+package org.jeecg.common.exception;
+
+/**
+ * jeecgboot断言异常
+ * for [QQYUN-10990]AIRAG
+ * @author chenrui
+ * @date 2025/2/14 14:31
+ */
+public class JeecgBootAssertException extends JeecgBootException {
+	private static final long serialVersionUID = 1L;
+
+
+	public JeecgBootAssertException(String message) {
+		super(message);
+	}
+
+	public JeecgBootAssertException(String message, int errCode) {
+		super(message, errCode);
+	}
+
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/exception/JeecgBootExceptionHandler.java

@@ -1,11 +1,14 @@
 package org.jeecg.common.exception;
 
 import cn.hutool.core.util.ObjectUtil;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.apache.shiro.SecurityUtils;
-import org.apache.shiro.authz.AuthorizationException;
-import org.apache.shiro.authz.UnauthorizedException;
+import org.jeecg.common.util.LoginUserUtils;
+import cn.dev33.satoken.exception.NotLoginException;
+import cn.dev33.satoken.exception.NotPermissionException;
+import cn.dev33.satoken.exception.NotRoleException;
 import org.jeecg.common.api.dto.LogDTO;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.constant.CommonConstant;
@@ -23,16 +26,18 @@ import org.springframework.dao.DuplicateKeyException;
 import org.springframework.data.redis.connection.PoolException;
 import org.springframework.http.HttpStatus;
 import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
 import org.springframework.web.HttpRequestMethodNotSupportedException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
 import org.springframework.web.servlet.NoHandlerFoundException;
 
-import javax.annotation.Resource;
-import javax.servlet.http.HttpServletRequest;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * 异常处理器
@@ -47,6 +52,13 @@ public class JeecgBootExceptionHandler {
 	@Resource
 	BaseCommonService baseCommonService;
 
+	@ExceptionHandler(MethodArgumentNotValidException.class)
+	public Result<?> handleValidationExceptions(MethodArgumentNotValidException e) {
+		log.error(e.getMessage(), e);
+		addSysLog(e);
+		return Result.error("校验失败！" + e.getBindingResult().getAllErrors().stream().map(ObjectError::getDefaultMessage).collect(Collectors.joining(",")));
+	}
+	
 	/**
 	 * 处理自定义异常
 	 */
@@ -101,12 +113,34 @@ public class JeecgBootExceptionHandler {
 		return Result.error("数据库中已存在该记录");
 	}
 
-	@ExceptionHandler({UnauthorizedException.class, AuthorizationException.class})
-	public Result<?> handleAuthorizationException(AuthorizationException e){
+	/**
+	 * 处理Sa-Token未登录异常
+	 */
+	@ExceptionHandler(NotLoginException.class)
+	@ResponseStatus(HttpStatus.UNAUTHORIZED)
+	public Result<?> handleNotLoginException(NotLoginException e){
+		log.error("Sa-Token未登录异常: {}", e.getMessage());
+		return new Result(401, CommonConstant.TOKEN_IS_INVALID_MSG);
+	}
+
+	/**
+	 * 处理Sa-Token无权限异常
+	 */
+	@ExceptionHandler(NotPermissionException.class)
+	public Result<?> handleNotPermissionException(NotPermissionException e){
 		log.error(e.getMessage(), e);
 		return Result.noauth("没有权限，请联系管理员分配权限！");
 	}
 
+	/**
+	 * 处理Sa-Token无角色异常
+	 */
+	@ExceptionHandler(NotRoleException.class)
+	public Result<?> handleNotRoleException(NotRoleException e){
+		log.error(e.getMessage(), e);
+		return Result.noauth("没有角色权限，请联系管理员分配角色！");
+	}
+
 	@ExceptionHandler(Exception.class)
 	public Result<?> handleException(Exception e){
 		log.error(e.getMessage(), e);
@@ -156,6 +190,27 @@ public class JeecgBootExceptionHandler {
         return Result.error("文件大小超出10MB限制, 请压缩或降低文件质量! ");
     }
 
+	/**
+	 * 处理文件过大异常.
+	 * jdk17中的MultipartException异常类已经被拆分成了MultipartException和MaxUploadSizeExceededException
+	 * for [QQYUN-11716]上传大图片失败没有精确提示
+	 * @param e
+	 * @return
+	 * @author chenrui
+	 * @date 2025/4/8 16:13
+	 */
+	@ExceptionHandler(MultipartException.class)
+	public Result<?> handleMaxUploadSizeExceededException(MultipartException e) {
+		Throwable cause = e.getCause();
+		if (cause instanceof IllegalStateException) {
+			log.error("文件大小超出限制: {}", cause.getMessage(), e);
+			addSysLog(e);
+			return Result.error("文件大小超出限制, 请压缩或降低文件质量!");
+		} else {
+			return handleException(e);
+		}
+	}
+
     @ExceptionHandler(DataIntegrityViolationException.class)
     public Result<?> handleDataIntegrityViolationException(DataIntegrityViolationException e) {
     	log.error(e.getMessage(), e);
@@ -211,11 +266,16 @@ public class JeecgBootExceptionHandler {
         } catch (NullPointerException | BeansException ignored) {
         }
         if (null != request) {
+			//update-begin---author:chenrui ---date:20250408  for：[QQYUN-11716]上传大图片失败没有精确提示------------
 			//请求的参数
-			Map<String, String[]> parameterMap = request.getParameterMap();
-			if(!CollectionUtils.isEmpty(parameterMap)){
-				log.setMethod(oConvertUtils.mapToString(request.getParameterMap()));
+			if (!isTooBigException(e)) {
+				// 文件上传过大异常时不能获取参数,否则会报错
+				Map<String, String[]> parameterMap = request.getParameterMap();
+				if(!CollectionUtils.isEmpty(parameterMap)) {
+					log.setMethod(oConvertUtils.mapToString(request.getParameterMap()));
+				}
 			}
+			//update-end---author:chenrui ---date:20250408  for：[QQYUN-11716]上传大图片失败没有精确提示------------
             // 请求地址
             log.setRequestUrl(request.getRequestURI());
             //设置IP地址
@@ -230,7 +290,7 @@ public class JeecgBootExceptionHandler {
 
        
 		//获取登录用户信息
-		LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+		LoginUser sysUser = LoginUserUtils.getSessionUser();
 		if(sysUser!=null){
 			log.setUserid(sysUser.getUsername());
 			log.setUsername(sysUser.getRealname());
@@ -241,4 +301,26 @@ public class JeecgBootExceptionHandler {
     }
 	//update-end---author:chenrui ---date:20240423  for：[QQYUN-8732]把错误的日志都抓取了 方便后续处理，单独弄个日志类型------------
 
+	/**
+	 * 是否文件过大异常
+	 * for [QQYUN-11716]上传大图片失败没有精确提示
+	 * @param e
+	 * @return
+	 * @author chenrui
+	 * @date 2025/4/8 20:21
+	 */
+	private static boolean isTooBigException(Throwable e) {
+		boolean isTooBigException = false;
+		if(e instanceof MultipartException){
+			Throwable cause = e.getCause();
+			if (cause instanceof IllegalStateException){
+				isTooBigException = true;
+			}
+		}
+		if(e instanceof MaxUploadSizeExceededException){
+			isTooBigException = true;
+		}
+		return isTooBigException;
+	}
+
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/annotation/EnumDict.java

@@ -4,6 +4,11 @@ import java.lang.annotation.*;
 
 /**
  * 将枚举类转化成字典数据
+ * 
+ * <<使用说明>>
+ * 1. 枚举类需以 `Enum` 结尾，并且在类上添加 `@EnumDict` 注解。
+ * 2. 需要手动将枚举类所在包路径** 添加到 `org.jeecg.common.system.util.ResourceUtil.BASE_SCAN_PACKAGES` 配置数组中。
+ * 
  * @Author taoYan
  * @Date 2022/7/8 10:34
  **/

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/base/controller/JeecgController.java

@@ -6,10 +6,10 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.IService;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.beanutils.PropertyUtils;
-import org.apache.shiro.SecurityUtils;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.system.query.QueryGenerator;
 import org.jeecg.common.system.vo.LoginUser;
+import org.jeecg.common.util.LoginUserUtils;
 import org.jeecg.common.util.oConvertUtils;
 import org.jeecg.config.JeecgBaseConfig;
 import org.jeecgframework.poi.excel.ExcelImportUtil;
@@ -18,14 +18,15 @@ import org.jeecgframework.poi.excel.entity.ExportParams;
 import org.jeecgframework.poi.excel.entity.ImportParams;
 import org.jeecgframework.poi.excel.entity.enmus.ExcelType;
 import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
+import org.jeecgframework.poi.handler.inter.IExcelExportServer;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.multipart.MultipartHttpServletRequest;
 import org.springframework.web.servlet.ModelAndView;
 
-import javax.annotation.Resource;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.*;
 
@@ -51,7 +52,7 @@ public class JeecgController<T, S extends IService<T>> {
     protected ModelAndView exportXls(HttpServletRequest request, T object, Class<T> clazz, String title) {
         // Step.1 组装查询条件
         QueryWrapper<T> queryWrapper = QueryGenerator.initQueryWrapper(object, request.getParameterMap());
-        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+        LoginUser sysUser = LoginUserUtils.getSessionUser();
 
         // 过滤选中数据
         String selections = request.getParameter("selections");
@@ -89,7 +90,7 @@ public class JeecgController<T, S extends IService<T>> {
     protected ModelAndView exportXlsSheet(HttpServletRequest request, T object, Class<T> clazz, String title,String exportFields,Integer pageNum) {
         // Step.1 组装查询条件
         QueryWrapper<T> queryWrapper = QueryGenerator.initQueryWrapper(object, request.getParameterMap());
-        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+        LoginUser sysUser = LoginUserUtils.getSessionUser();
         // Step.2 计算分页sheet数据
         double total = service.count();
         int count = (int)Math.ceil(total/pageNum);
@@ -127,6 +128,53 @@ public class JeecgController<T, S extends IService<T>> {
         return mv;
     }
 
+    /**
+     * 大数据导出
+     * @param request
+     * @param object
+     * @param clazz
+     * @param title
+     * @param pageSize 每次查询的数据量
+     * @return
+     * @author chenrui
+     * @date 2025/8/11 16:11
+     */
+    protected ModelAndView exportXlsForBigData(HttpServletRequest request, T object, Class<T> clazz, String title,Integer pageSize) {
+        // 组装查询条件
+        QueryWrapper<T> queryWrapper = QueryGenerator.initQueryWrapper(object, request.getParameterMap());
+        LoginUser sysUser = LoginUserUtils.getSessionUser();
+        // 计算分页数
+        double total = service.count();
+        int count = (int) Math.ceil(total / pageSize);
+        // 过滤选中数据
+        String selections = request.getParameter("selections");
+        if (oConvertUtils.isNotEmpty(selections)) {
+            List<String> selectionList = Arrays.asList(selections.split(","));
+            queryWrapper.in("id", selectionList);
+        }
+
+        // 定义IExcelExportServer
+        IExcelExportServer excelExportServer = (queryParams, pageNum) -> {
+            if (pageNum > count) {
+                return null;
+            }
+            Page<T> page = new Page<T>(pageNum, pageSize);
+            IPage<T> pageList = service.page(page, (QueryWrapper<T>) queryParams);
+            return new ArrayList<>(pageList.getRecords());
+        };
+
+        // AutoPoi 导出Excel
+        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
+        //此处设置的filename无效 ,前端会重更新设置一下
+        mv.addObject(NormalExcelConstants.FILE_NAME, title);
+        mv.addObject(NormalExcelConstants.CLASS, clazz);
+        ExportParams exportParams = new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title, jeecgBaseConfig.getPath().getUpload());
+        mv.addObject(NormalExcelConstants.PARAMS, exportParams);
+        mv.addObject(NormalExcelConstants.EXPORT_SERVER, excelExportServer);
+        mv.addObject(NormalExcelConstants.QUERY_PARAMS, queryWrapper);
+        return mv;
+    }
+
 
     /**
      * 根据权限导出excel，传入导出字段参数

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/base/entity/JeecgEntity.java

@@ -9,10 +9,11 @@ import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.fasterxml.jackson.annotation.JsonFormat;
 
-import io.swagger.annotations.ApiModelProperty;
+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基类
@@ -30,20 +31,20 @@ public class JeecgEntity implements Serializable {
      * ID
      */
     @TableId(type = IdType.ASSIGN_ID)
-    @ApiModelProperty(value = "ID")
+    @Schema(description = "ID")
     private java.lang.String id;
 
     /**
      * 创建人
      */
-    @ApiModelProperty(value = "创建人")
+    @Schema(description = "创建人")
     @Excel(name = "创建人", width = 15)
     private java.lang.String createBy;
 
     /**
      * 创建时间
      */
-    @ApiModelProperty(value = "创建时间")
+    @Schema(description = "创建时间")
     @Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
     @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@@ -52,14 +53,14 @@ public class JeecgEntity implements Serializable {
     /**
      * 更新人
      */
-    @ApiModelProperty(value = "更新人")
+    @Schema(description = "更新人")
     @Excel(name = "更新人", width = 15)
     private java.lang.String updateBy;
 
     /**
      * 更新时间
      */
-    @ApiModelProperty(value = "更新时间")
+    @Schema(description = "更新时间")
     @Excel(name = "更新时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
     @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/query/QueryGenerator.java

@@ -11,6 +11,7 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+import com.baomidou.mybatisplus.core.metadata.OrderItem;
 import org.apache.commons.beanutils.PropertyUtils;
 import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.DataBaseConstant;
@@ -257,8 +258,69 @@ public class QueryGenerator {
 		if(parameterMap!=null&& parameterMap.containsKey(ORDER_TYPE)) {
 			order = parameterMap.get(ORDER_TYPE)[0];
 		}
-        log.debug("排序规则>>列:" + column + ",排序方式:" + order);
+		
+		if(oConvertUtils.isNotEmpty(column)){
+			log.info("单字段排序规则>> column:" + column + ",排序方式:" + order);
+		}
 
+		// 1. 列表多字段排序优先
+		if(parameterMap!=null&& parameterMap.containsKey("sortInfoString")) {
+			// 多字段排序
+			String sortInfoString = parameterMap.get("sortInfoString")[0];
+			log.info("多字段排序规则>> sortInfoString:" + sortInfoString);
+			List<OrderItem> orderItemList = SqlConcatUtil.getQueryConditionOrders(column, order, sortInfoString);
+			log.info(orderItemList.toString());
+			if (orderItemList != null && !orderItemList.isEmpty()) {
+				for (OrderItem item : orderItemList) {
+					// 一、获取排序数据库字段
+					String columnName = item.getColumn();
+					// 1.字典字段，去掉字典翻译文本后缀
+					if(columnName.endsWith(CommonConstant.DICT_TEXT_SUFFIX)) {
+						columnName = columnName.substring(0, column.lastIndexOf(CommonConstant.DICT_TEXT_SUFFIX));
+					}
+					// 2.实体驼峰字段转为数据库字段
+					columnName = SqlInjectionUtil.getSqlInjectSortField(columnName);
+
+					// 二、设置字段排序规则
+					if (item.isAsc()) {
+						queryWrapper.orderByAsc(columnName);
+					} else {
+						queryWrapper.orderByDesc(columnName);
+					}
+				}
+			}
+			return;
+		}
+
+		// 2. 列表单字段默认排序
+		if(oConvertUtils.isEmpty(column) && parameterMap!=null&& parameterMap.containsKey("defSortString")) {
+			// 多字段排序
+			String sortInfoString = parameterMap.get("defSortString")[0];
+			log.info("默认多字段排序规则>> defSortString:" + sortInfoString);
+			List<OrderItem> orderItemList = SqlConcatUtil.getQueryConditionOrders(column, order, sortInfoString);
+			log.info(orderItemList.toString());
+			if (orderItemList != null && !orderItemList.isEmpty()) {
+				for (OrderItem item : orderItemList) {
+					// 一、获取排序数据库字段
+					String columnName = item.getColumn();
+					// 1.字典字段，去掉字典翻译文本后缀
+					if(columnName.endsWith(CommonConstant.DICT_TEXT_SUFFIX)) {
+						columnName = columnName.substring(0, column.lastIndexOf(CommonConstant.DICT_TEXT_SUFFIX));
+					}
+					// 2.实体驼峰字段转为数据库字段
+					columnName = SqlInjectionUtil.getSqlInjectSortField(columnName);
+					
+					// 二、设置字段排序规则
+					if (item.isAsc()) {
+						queryWrapper.orderByAsc(columnName);
+					} else {
+						queryWrapper.orderByDesc(columnName);
+					}
+				}
+			}
+			return;
+		}
+		
 		//update-begin-author:scott date:2022-11-07 for:避免用户自定义表无默认字段{创建时间}，导致排序报错
 		//TODO 避免用户自定义表无默认字段创建时间，导致排序报错
 		if(DataBaseConstant.CREATE_TIME.equals(column) && !fieldColumnMap.containsKey(DataBaseConstant.CREATE_TIME)){
@@ -352,9 +414,11 @@ public class QueryGenerator {
                 }
 				// update-begin-author:sunjianlei date:20220119 for: 【JTC-573】 过滤空条件查询，防止 sql 拼接多余的 and
 				List<QueryCondition> filterConditions = conditions.stream().filter(
-						rule -> oConvertUtils.isNotEmpty(rule.getField())
-								&& oConvertUtils.isNotEmpty(rule.getRule())
-								&& oConvertUtils.isNotEmpty(rule.getVal())
+						rule -> (oConvertUtils.isNotEmpty(rule.getField())
+													&& oConvertUtils.isNotEmpty(rule.getRule())
+													&& oConvertUtils.isNotEmpty(rule.getVal())
+												 )
+												|| "empty".equals(rule.getRule())
 				).collect(Collectors.toList());
 				if (filterConditions.size() == 0) {
 					return;
@@ -365,9 +429,12 @@ public class QueryGenerator {
                 queryWrapper.and(andWrapper -> {
                     for (int i = 0; i < filterConditions.size(); i++) {
                         QueryCondition rule = filterConditions.get(i);
-                        if (oConvertUtils.isNotEmpty(rule.getField())
-                                && oConvertUtils.isNotEmpty(rule.getRule())
-                                && oConvertUtils.isNotEmpty(rule.getVal())) {
+                        if (
+								(
+								    oConvertUtils.isNotEmpty(rule.getField()) && oConvertUtils.isNotEmpty(rule.getRule()) && oConvertUtils.isNotEmpty(rule.getVal())
+								)
+							    || "empty".equals(rule.getRule())
+						) {
 
                             log.debug("SuperQuery ==> " + rule.toString());
 
@@ -654,7 +721,11 @@ public class QueryGenerator {
 	 * @param value        查询条件值
 	 */
 	public static void addEasyQuery(QueryWrapper<?> queryWrapper, String name, QueryRuleEnum rule, Object value) {
-		if (name==null || value == null || rule == null || oConvertUtils.isEmpty(value)) {
+		if (
+				(
+				   name==null || value == null || rule == null || oConvertUtils.isEmpty(value)
+				) 
+				  && !QueryRuleEnum.EMPTY.equals(rule)) {
 			return;
 		}
 		name = oConvertUtils.camelToUnderline(name);
@@ -666,6 +737,9 @@ public class QueryGenerator {
 		case GE:
 			queryWrapper.ge(name, value);
 			break;
+		case EMPTY:
+			queryWrapper.isNull(name);
+			break;
 		case LT:
 			queryWrapper.lt(name, value);
 			break;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/JeecgDataAutorUtils.java

@@ -5,7 +5,7 @@ import org.jeecg.common.system.vo.SysUserCacheInfo;
 import org.jeecg.common.util.SpringContextUtils;
 import org.springframework.util.StringUtils;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 import java.util.ArrayList;
 import java.util.List;
 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/JwtUtil.java

@@ -1,18 +1,23 @@
 package org.jeecg.common.system.util;
 
-import com.auth0.jwt.JWT;
-import com.auth0.jwt.JWTVerifier;
-import com.auth0.jwt.algorithms.Algorithm;
-import com.auth0.jwt.exceptions.JWTDecodeException;
-import com.auth0.jwt.interfaces.DecodedJWT;
+import cn.dev33.satoken.stp.StpUtil;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Joiner;
+
+import java.io.IOException;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpSession;
+
 import lombok.extern.slf4j.Slf4j;
-import org.apache.shiro.SecurityUtils;
-import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.constant.CommonConstant;
-import org.jeecg.common.constant.DataBaseConstant;
 import org.jeecg.common.constant.SymbolConstant;
 import org.jeecg.common.constant.TenantConstant;
+import org.jeecg.common.util.LoginUserUtils;
+import org.jeecg.common.api.vo.Result;
+import org.jeecg.common.constant.DataBaseConstant;
 import org.jeecg.common.exception.JeecgBootException;
 import org.jeecg.common.system.vo.LoginUser;
 import org.jeecg.common.system.vo.SysUserCacheInfo;
@@ -20,106 +25,77 @@ import org.jeecg.common.util.DateUtils;
 import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.common.util.oConvertUtils;
 
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.Date;
-import java.util.Objects;
-import java.util.stream.Collectors;
-
 /**
  * @Author Scott
  * @Date 2018-07-12 14:23
- * @Desc JWT工具类
+ * @Desc JWT工具类 - 已迁移到Sa-Token，此类作为兼容层保留
  **/
 @Slf4j
 public class JwtUtil {
-
-	/**Token有效期为7天（Token在reids中缓存时间为两倍）*/
-	public static final long EXPIRE_TIME = (7 * 12) * 60 * 60 * 1000;
+	
 	static final String WELL_NUMBER = SymbolConstant.WELL_NUMBER + SymbolConstant.LEFT_CURLY_BRACKET;
-
-    /**
-     *
-     * @param response
-     * @param code
-     * @param errorMsg
-     */
-    public static void responseError(ServletResponse response, Integer code, String errorMsg) {
-		HttpServletResponse httpServletResponse = (HttpServletResponse) response;
-		// issues/I4YH95浏览器显示乱码问题
-		httpServletResponse.setHeader("Content-type", "text/html;charset=UTF-8");
-        Result jsonResult = new Result(code, errorMsg);
-		jsonResult.setSuccess(false);
-        OutputStream os = null;
-        try {
-            os = httpServletResponse.getOutputStream();
-			httpServletResponse.setCharacterEncoding("UTF-8");
-			httpServletResponse.setStatus(code);
-            os.write(new ObjectMapper().writeValueAsString(jsonResult).getBytes("UTF-8"));
-            os.flush();
-            os.close();
-        } catch (IOException e) {
-			log.error(e.getMessage(), e);
-        }
-    }
-
+	
+	/**
+	 * 返回错误 JSON 字符串（用于 Sa-Token Filter）
+	 * @param code 错误码
+	 * @param errorMsg 错误信息
+	 * @return JSON 字符串
+	 */
+	public static String responseErrorJson(Integer code, String errorMsg) {
+		try {
+			Result jsonResult = new Result(code, errorMsg);
+			jsonResult.setSuccess(false);
+			ObjectMapper objectMapper = new ObjectMapper();
+			return objectMapper.writeValueAsString(jsonResult);
+		} catch (IOException e) {
+			log.error("生成错误 JSON 失败: {}", e.getMessage());
+			// 返回备用的硬编码 JSON
+			return "{\"success\":false,\"message\":\"" + errorMsg + "\",\"code\":" + code + ",\"result\":null,\"timestamp\":" + System.currentTimeMillis() + "}";
+		}
+	}
+	
 	/**
 	 * 校验token是否正确
-	 *
-	 * @param token  密钥
-	 * @param secret 用户的密码
-	 * @return 是否正确
+	 * 注意：此方法已废弃，使用Sa-Token自动校验
+	 * 
+	 * @param token
+	 * @return
 	 */
-	public static boolean verify(String token, String username, String secret) {
+	@Deprecated
+	public static boolean verify(String token){
 		try {
-			// 根据密码生成JWT效验器
-			Algorithm algorithm = Algorithm.HMAC256(secret);
-			JWTVerifier verifier = JWT.require(algorithm).withClaim("username", username).build();
-			// 效验TOKEN
-			DecodedJWT jwt = verifier.verify(token);
-			return true;
+			// 使用Sa-Token验证
+			return StpUtil.getLoginIdByToken(token) != null;
 		} catch (Exception e) {
-			log.error(e.getMessage(), e);
+			log.warn(e.getMessage(), e);
 			return false;
 		}
 	}
 
 	/**
-	 * 获得token中的信息无需secret解密也能获得
-	 *
-	 * @return token中包含的用户名
+	 * 获得Token中的用户名（不校验token是否有效）
+	 * <p>注意：现在 loginId 就是 username，直接返回
+	 * 
+	 * @param token JWT token
+	 * @return 用户名（username），如果 token 无效则返回 null
 	 */
-	public static String getUsername(String token) {
+	public static String getUsername(String token){
 		try {
-			DecodedJWT jwt = JWT.decode(token);
-			return jwt.getClaim("username").asString();
-		} catch (JWTDecodeException e) {
-			log.warn(e.getMessage(), e);
+			if(oConvertUtils.isEmpty(token)) {
+				return null;
+			}
+			// Sa-Token 的 loginId 现在就是 username，直接返回
+			Object loginId = StpUtil.getLoginIdByToken(token);
+			return loginId != null ? loginId.toString() : null;
+		} catch (Exception e) {
+			log.warn("获取用户名失败: {}", e.getMessage());
 			return null;
 		}
 	}
 
-	/**
-	 * 生成签名,5min后过期
-	 *
-	 * @param username 用户名
-	 * @param secret   用户的密码
-	 * @return 加密的token
-	 */
-	public static String sign(String username, String secret) {
-		Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
-		Algorithm algorithm = Algorithm.HMAC256(secret);
-		// 附带username信息
-		return JWT.create().withClaim("username", username).withExpiresAt(date).sign(algorithm);
-
-	}
-
 	/**
 	 * 根据request中的token获取用户账号
+	 * 注意：此方法已适配Sa-Token
 	 * 
 	 * @param request
 	 * @return
@@ -133,9 +109,9 @@ public class JwtUtil {
 		}
 		return username;
 	}
-	
+
 	/**
-	  *  从session中获取变量
+	 *  从session中获取变量
 	 * @param key
 	 * @return
 	 */
@@ -146,7 +122,7 @@ public class JwtUtil {
 		String wellNumber = WELL_NUMBER;
 
 		if(key.indexOf(SymbolConstant.RIGHT_CURLY_BRACKET)!=-1){
-			 moshi = key.substring(key.indexOf("}")+1);
+			moshi = key.substring(key.indexOf("}")+1);
 		}
 		String returnValue = null;
 		if (key.contains(wellNumber)) {
@@ -160,16 +136,16 @@ public class JwtUtil {
 		if(returnValue!=null){returnValue = returnValue + moshi;}
 		return returnValue;
 	}
-	
+
 	/**
-	  * 从当前用户中获取变量
+	 * 从当前用户中获取变量
 	 * @param key
 	 * @param user
 	 * @return
 	 */
 	public static String getUserSystemData(String key, SysUserCacheInfo user) {
 		//1.优先获取 SysUserCacheInfo
-		if(user==null) {
+		if (user == null) {
 			try {
 				user = JeecgDataAutorUtils.loadUserInfo();
 			} catch (Exception e) {
@@ -179,82 +155,82 @@ public class JwtUtil {
 		//2.通过shiro获取登录用户信息
 		LoginUser sysUser = null;
 		try {
-			sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+			sysUser = (LoginUser) LoginUserUtils.getSessionUser();
 		} catch (Exception e) {
 			log.warn("SecurityUtils.getSubject() 获取用户信息异常：" + e.getMessage());
 		}
 
 		//#{sys_user_code}%
 		String moshi = "";
-        String wellNumber = WELL_NUMBER;
-		if(key.indexOf(SymbolConstant.RIGHT_CURLY_BRACKET)!=-1){
-			 moshi = key.substring(key.indexOf("}")+1);
+		String wellNumber = WELL_NUMBER;
+		if (key.indexOf(SymbolConstant.RIGHT_CURLY_BRACKET) != -1) {
+			moshi = key.substring(key.indexOf("}") + 1);
 		}
 		String returnValue = null;
 		//针对特殊标示处理#{sysOrgCode}，判断替换
 		if (key.contains(wellNumber)) {
-			key = key.substring(2,key.indexOf("}"));
+			key = key.substring(2, key.indexOf("}"));
 		} else {
 			key = key;
 		}
-		//update-begin---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 		// 是否存在字符串标志
-		boolean multiStr = false;
-		if(oConvertUtils.isNotEmpty(key) && key.trim().matches("^\\[\\w+]$")){
-			key = key.substring(1,key.length()-1);
+		boolean multiStr;
+		if (oConvertUtils.isNotEmpty(key) && key.trim().matches("^\\[\\w+]$")) {
+			key = key.substring(1, key.length() - 1);
 			multiStr = true;
+		} else {
+			multiStr = false;
 		}
-		//update-end---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 		//替换为当前系统时间(年月日)
-		if (key.equals(DataBaseConstant.SYS_DATE)|| key.toLowerCase().equals(DataBaseConstant.SYS_DATE_TABLE)) {
+		if (key.equals(DataBaseConstant.SYS_DATE) || key.toLowerCase().equals(DataBaseConstant.SYS_DATE_TABLE)) {
 			returnValue = DateUtils.formatDate();
 		}
 		//替换为当前系统时间（年月日时分秒）
-		else if (key.equals(DataBaseConstant.SYS_TIME)|| key.toLowerCase().equals(DataBaseConstant.SYS_TIME_TABLE)) {
+		else if (key.equals(DataBaseConstant.SYS_TIME) || key.toLowerCase().equals(DataBaseConstant.SYS_TIME_TABLE)) {
 			returnValue = DateUtils.now();
 		}
 		//流程状态默认值（默认未发起）
-		else if (key.equals(DataBaseConstant.BPM_STATUS)|| key.toLowerCase().equals(DataBaseConstant.BPM_STATUS_TABLE)) {
+		else if (key.equals(DataBaseConstant.BPM_STATUS) || key.toLowerCase().equals(DataBaseConstant.BPM_STATUS_TABLE)) {
 			returnValue = "1";
 		}
 
 		//后台任务获取用户信息异常，导致程序中断
-		if(sysUser==null && user==null){
+		if (sysUser == null && user == null) {
 			return null;
 		}
-		
+
 		//替换为系统登录用户帐号
-		if (key.equals(DataBaseConstant.SYS_USER_CODE)|| key.toLowerCase().equals(DataBaseConstant.SYS_USER_CODE_TABLE)) {
-			if(user==null) {
+		if (key.equals(DataBaseConstant.SYS_USER_CODE) || key.toLowerCase().equals(DataBaseConstant.SYS_USER_CODE_TABLE)) {
+			if (user == null) {
 				returnValue = sysUser.getUsername();
-			}else {
+			} else {
 				returnValue = user.getSysUserCode();
 			}
 		}
 
 		// 替换为系统登录用户ID
 		else if (key.equals(DataBaseConstant.SYS_USER_ID) || key.equalsIgnoreCase(DataBaseConstant.SYS_USER_ID_TABLE)) {
-			if(user==null) {
+			if (user == null) {
 				returnValue = sysUser.getId();
-			}else {
+			} else {
 				returnValue = user.getSysUserId();
 			}
 		}
 
 		//替换为系统登录用户真实名字
-		else if (key.equals(DataBaseConstant.SYS_USER_NAME)|| key.toLowerCase().equals(DataBaseConstant.SYS_USER_NAME_TABLE)) {
-			if(user==null) {
+		else if (key.equals(DataBaseConstant.SYS_USER_NAME) || key.toLowerCase().equals(DataBaseConstant.SYS_USER_NAME_TABLE)) {
+			if (user == null) {
 				returnValue = sysUser.getRealname();
-			}else {
+			} else {
 				returnValue = user.getSysUserName();
 			}
 		}
-		
+
 		//替换为系统用户登录所使用的机构编码
-		else if (key.equals(DataBaseConstant.SYS_ORG_CODE)|| key.toLowerCase().equals(DataBaseConstant.SYS_ORG_CODE_TABLE)) {
-			if(user==null) {
+		else if (key.equals(DataBaseConstant.SYS_ORG_CODE) || key.toLowerCase().equals(DataBaseConstant.SYS_ORG_CODE_TABLE)) {
+			if (user == null) {
 				returnValue = sysUser.getOrgCode();
-			}else {
+			} else {
 				returnValue = user.getSysOrgCode();
 			}
 		}
@@ -269,26 +245,25 @@ public class JwtUtil {
 		}
 
 		//替换为系统用户所拥有的所有机构编码
-		else if (key.equals(DataBaseConstant.SYS_MULTI_ORG_CODE)|| key.toLowerCase().equals(DataBaseConstant.SYS_MULTI_ORG_CODE_TABLE)) {
-			if(user==null){
-				//TODO 暂时使用用户登录部门，存在逻辑缺陷，不是用户所拥有的部门
+		else if (key.equals(DataBaseConstant.SYS_MULTI_ORG_CODE) || key.toLowerCase().equals(DataBaseConstant.SYS_MULTI_ORG_CODE_TABLE)) {
+			if (user == null) {
 				returnValue = sysUser.getOrgCode();
-				//update-begin---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 				returnValue = multiStr ? "'" + returnValue + "'" : returnValue;
-				//update-end---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
-			}else{
-				if(user.isOneDepart()) {
+			} else {
+				if (user.isOneDepart()) {
 					returnValue = user.getSysMultiOrgCode().get(0);
-					//update-begin---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 					returnValue = multiStr ? "'" + returnValue + "'" : returnValue;
-					//update-end---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
-				}else {
-					//update-begin---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
+				} else {
 					returnValue = user.getSysMultiOrgCode().stream()
 							.filter(Objects::nonNull)
-							.map(orgCode -> "'" + orgCode + "'")
+							.map(orgCode -> {
+								if (multiStr) {
+									return "'" + orgCode + "'";
+								} else {
+									return orgCode;
+								}
+							})
 							.collect(Collectors.joining(", "));
-					//update-end---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 				}
 			}
 		}
@@ -302,21 +277,17 @@ public class JwtUtil {
 			}
 		}
 
-		//update-begin-author:taoyan date:20210330 for:多租户ID作为系统变量
-		else if (key.equals(TenantConstant.TENANT_ID) || key.toLowerCase().equals(TenantConstant.TENANT_ID_TABLE)){
+		// 多租户ID作为系统变量
+		else if (key.equals(TenantConstant.TENANT_ID) || key.toLowerCase().equals(TenantConstant.TENANT_ID_TABLE)) {
 			try {
 				returnValue = SpringContextUtils.getHttpServletRequest().getHeader(CommonConstant.TENANT_ID);
 			} catch (Exception e) {
 				log.warn("获取系统租户异常：" + e.getMessage());
 			}
 		}
-		//update-end-author:taoyan date:20210330 for:多租户ID作为系统变量
-		if(returnValue!=null){returnValue = returnValue + moshi;}
+		if (returnValue != null) {
+			returnValue = returnValue + moshi;
+		}
 		return returnValue;
 	}
-	
-//	public static void main(String[] args) {
-//		 String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjUzMzY1MTMsInVzZXJuYW1lIjoiYWRtaW4ifQ.xjhud_tWCNYBOg_aRlMgOdlZoWFFKB_givNElHNw3X0";
-//		 System.out.println(JwtUtil.getUsername(token));
-//	}
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/ResourceUtil.java

@@ -13,31 +13,33 @@ import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
 import org.springframework.core.type.classreading.MetadataReader;
 import org.springframework.core.type.classreading.MetadataReaderFactory;
 import org.springframework.util.ClassUtils;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.lang.reflect.Method;
+import java.util.*;
 
 /**
- * 资源加载工具类
+ * 枚举字典数据 资源加载工具类
+ *
  * @Author taoYan
  * @Date 2022/7/8 10:40
  **/
 @Slf4j
 public class ResourceUtil {
 
-
+    /**
+     * 多个包扫描根路径
+     *
+     * 之所以让用户手工配置扫描路径，是为了避免不必要的类加载开销，提升启动性能。
+     * 请务必将所有枚举类所在包路径添加到此配置中。
+     */
+    private final static String[] BASE_SCAN_PACKAGES = {
+            "org.jeecg.common.constant.enums",
+            "org.jeecg.modules.message.enums"
+    };
+    
     /**
      * 枚举字典数据
      */
     private final static Map<String, List<DictModel>> enumDictData = new HashMap<>(5);
-
-    /**
-     * 所有java类
-     */
-    private final static String CLASS_PATTERN="/**/*.class";
-
     /**
      * 所有枚举java类
      */
@@ -45,9 +47,9 @@ public class ResourceUtil {
     private final static String CLASS_ENUM_PATTERN="/**/*Enum.class";
 
     /**
-     * 包路径 org.jeecg
+     * 初始化状态标识
      */
-    private final static String BASE_PACKAGE = "org.jeecg";
+    private static volatile boolean initialized = false;
 
     /**
      * 枚举类中获取字典数据的方法名
@@ -55,59 +57,135 @@ public class ResourceUtil {
     private final static String METHOD_NAME = "getDictList";
 
     /**
+     * 获取枚举字典数据
      * 获取枚举类对应的字典数据 SysDictServiceImpl#queryAllDictItems()
-     * @return
+     *
+     * @return 枚举字典数据
      */
-    public static Map<String, List<DictModel>> getEnumDictData(){
-        if(enumDictData.keySet().size()>0){
-            return enumDictData;
-        }
-        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
-        String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(BASE_PACKAGE) + CLASS_ENUM_PATTERN;
-        try {
-            Resource[] resources = resourcePatternResolver.getResources(pattern);
-            MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(resourcePatternResolver);
-            for (Resource resource : resources) {
-                MetadataReader reader = readerFactory.getMetadataReader(resource);
-                String classname = reader.getClassMetadata().getClassName();
-                Class<?> clazz = Class.forName(classname);
-                EnumDict enumDict = clazz.getAnnotation(EnumDict.class);
-                if (enumDict != null) {
-                    EnumDict annotation = clazz.getAnnotation(EnumDict.class);
-                    String key = annotation.value();
-                    if(oConvertUtils.isNotEmpty(key)){
-                        List<DictModel> list = (List<DictModel>) clazz.getDeclaredMethod(METHOD_NAME).invoke(null);
-                        enumDictData.put(key, list);
-                    }
+    public static Map<String, List<DictModel>> getEnumDictData() {
+        if (!initialized) {
+            synchronized (ResourceUtil.class) {
+                if (!initialized) {
+                    long startTime = System.currentTimeMillis();
+                    log.info("【枚举字典加载】开始初始化枚举字典数据...");
+
+                    initEnumDictData();
+                    initialized = true;
+
+                    long endTime = System.currentTimeMillis();
+                    log.info("【枚举字典加载】枚举字典数据初始化完成，共加载 {} 个字典，总耗时: {}ms", enumDictData.size(), endTime - startTime);
                 }
             }
-        }catch (Exception e){
-            log.error("获取枚举类字典数据异常", e.getMessage());
-            // e.printStackTrace();
         }
         return enumDictData;
     }
 
     /**
-     * 用于后端字典翻译 SysDictServiceImpl#queryManyDictByKeys(java.util.List, java.util.List)
-     * @param dictCodeList
-     * @param keys
-     * @return
+     * 使用多包路径扫描方式初始化枚举字典数据
      */
-    public static Map<String, List<DictModel>> queryManyDictByKeys(List<String> dictCodeList, List<String> keys){
-        if(enumDictData.keySet().size()==0){
-            getEnumDictData();
+    private static void initEnumDictData() {
+        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
+
+        long scanStartTime = System.currentTimeMillis();
+        List<Resource> allResources = new ArrayList<>();
+
+        // 扫描多个包路径
+        for (String basePackage : BASE_SCAN_PACKAGES) {
+            String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(basePackage) + CLASS_ENUM_PATTERN;
+
+            try {
+                Resource[] resources = resourcePatternResolver.getResources(pattern);
+                allResources.addAll(Arrays.asList(resources));
+                log.debug("【枚举字典加载】扫描包 {} 找到 {} 个枚举类文件", basePackage, resources.length);
+            } catch (Exception e) {
+                log.warn("【枚举字典加载】扫描包 {} 时出现异常: {}", basePackage, e.getMessage());
+            }
         }
+
+        long scanEndTime = System.currentTimeMillis();
+        log.info("【枚举字典加载】文件扫描完成，总共找到 {} 个枚举类文件，扫描耗时: {}ms", allResources.size(), scanEndTime - scanStartTime);
+
+        MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(resourcePatternResolver);
+
+        long processStartTime = System.currentTimeMillis();
+        int processedCount = 0;
+
+        for (Resource resource : allResources) {
+            try {
+                MetadataReader reader = readerFactory.getMetadataReader(resource);
+                String classname = reader.getClassMetadata().getClassName();
+
+                // 提前检查是否有@EnumDict注解，避免不必要的Class.forName
+                if (hasEnumDictAnnotation(reader)) {
+                    processEnumClass(classname);
+                    processedCount++;
+                }
+            } catch (Exception e) {
+                log.debug("处理资源异常: {} - {}", resource.getFilename(), e.getMessage());
+            }
+        }
+
+        long processEndTime = System.currentTimeMillis();
+        log.info("【枚举字典加载】处理完成，实际处理 {} 个带注解的枚举类，处理耗时: {}ms", processedCount, processEndTime - processStartTime);
+    }
+
+    /**
+     * 检查类是否有EnumDict注解（通过元数据，避免类加载）
+     */
+    private static boolean hasEnumDictAnnotation(MetadataReader reader) {
+        try {
+            return reader.getAnnotationMetadata().hasAnnotation(EnumDict.class.getName());
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    /**
+     * 处理单个枚举类
+     */
+    private static void processEnumClass(String classname) {
+        try {
+            Class<?> clazz = Class.forName(classname);
+            EnumDict enumDict = clazz.getAnnotation(EnumDict.class);
+
+            if (enumDict != null) {
+                String key = enumDict.value();
+                if (oConvertUtils.isNotEmpty(key)) {
+                    Method method = clazz.getDeclaredMethod(METHOD_NAME);
+                    List<DictModel> list = (List<DictModel>) method.invoke(null);
+                    enumDictData.put(key, list);
+                    log.debug("成功加载枚举字典: {} -> {}", key, classname);
+                }
+            }
+        } catch (Exception e) {
+            log.debug("处理枚举类异常: {} - {}", classname, e.getMessage());
+        }
+    }
+
+    /**
+     * 用于后端字典翻译 SysDictServiceImpl#queryManyDictByKeys(java.util.List, java.util.List)
+     *
+     * @param dictCodeList 字典编码列表
+     * @param keys         键值列表
+     * @return 字典数据映射
+     */
+    public static Map<String, List<DictModel>> queryManyDictByKeys(List<String> dictCodeList, List<String> keys) {
+        Map<String, List<DictModel>> enumDict = getEnumDictData();
         Map<String, List<DictModel>> map = new HashMap<>();
-        for (String code : enumDictData.keySet()) {
-            if(dictCodeList.indexOf(code)>=0){
-                List<DictModel> dictItemList = enumDictData.get(code);
-                for(DictModel dm: dictItemList){
+
+        // 使用更高效的查找方式
+        Set<String> dictCodeSet = new HashSet<>(dictCodeList);
+        Set<String> keySet = new HashSet<>(keys);
+
+        for (String code : enumDict.keySet()) {
+            if (dictCodeSet.contains(code)) {
+                List<DictModel> dictItemList = enumDict.get(code);
+                for (DictModel dm : dictItemList) {
                     String value = dm.getValue();
-                    if(keys.indexOf(value)>=0){
+                    if (keySet.contains(value)) {
                         List<DictModel> list = new ArrayList<>();
                         list.add(new DictModel(value, dm.getText()));
-                        map.put(code,list);
+                        map.put(code, list);
                         break;
                     }
                 }
@@ -115,22 +193,5 @@ public class ResourceUtil {
         }
         return map;
     }
-
-    /**
-     * 获取实现类
-     * 
-     * @param classPath 
-     */
-    public static Object getImplementationClass(String classPath){
-        try {
-            Class<?> aClass = Class.forName(classPath);
-            return SpringContextUtils.getBean(aClass);
-        } catch (ClassNotFoundException e) {
-            log.error("类没有找到",e);
-            return null;
-        } catch (NoSuchBeanDefinitionException e){
-            log.error(classPath + "没有实现",e);
-            return null;
-        }
-    }
-}
+    
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/SqlConcatUtil.java

@@ -1,13 +1,22 @@
 package org.jeecg.common.system.util;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.metadata.OrderItem;
 import lombok.extern.slf4j.Slf4j;
+import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.DataBaseConstant;
 import org.jeecg.common.constant.SymbolConstant;
+import org.jeecg.common.exception.JeecgBootException;
 import org.jeecg.common.system.query.QueryGenerator;
 import org.jeecg.common.system.query.QueryRuleEnum;
 import org.jeecg.common.util.CommonUtils;
 import org.jeecg.common.util.oConvertUtils;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -239,5 +248,47 @@ public class SqlConcatUtil {
     private static String getDbType() {
         return CommonUtils.getDatabaseType();
     }
+
+    /**
+     * 获取前端传过来的 "多字段排序信息: sortInfoString"
+     * @return
+     */
+    public static List<OrderItem> getQueryConditionOrders(String column, String order, String queryInfoString){
+        List<OrderItem> list = new ArrayList<>();
+        if(oConvertUtils.isEmpty(queryInfoString)){
+            //默认以创建时间倒序查询
+            if(CommonConstant.ORDER_TYPE_DESC.equalsIgnoreCase(order)){
+                list.add(OrderItem.desc(column));
+            }else{
+                list.add(OrderItem.asc(column));
+            }
+        }else{
+            // 【TV360X-967】URL解码（微服务下需要）
+            if (queryInfoString.contains("%22column%22")) {
+                log.info("queryInfoString 原生 = {}", queryInfoString);
+                try {
+                    queryInfoString = URLDecoder.decode(queryInfoString, "UTF-8");
+                } catch (UnsupportedEncodingException e) {
+                    throw new JeecgBootException(e);
+                }
+                log.info("queryInfoString 解码 = {}", queryInfoString);
+            }
+            JSONArray array = JSONArray.parseArray(queryInfoString);
+            Iterator it = array.iterator();
+            while(it.hasNext()){
+                JSONObject json = (JSONObject)it.next();
+                String tempColumn = json.getString("column");
+                if(oConvertUtils.isNotEmpty(tempColumn)){
+                    String tempOrder = json.getString("order");
+                    if(CommonConstant.ORDER_TYPE_DESC.equalsIgnoreCase(tempOrder)){
+                        list.add(OrderItem.desc(tempColumn));
+                    }else{
+                        list.add(OrderItem.asc(tempColumn));
+                    }
+                }
+            }
+        }
+        return list;
+    }
     
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/system/vo/LoginUser.java

@@ -68,6 +68,12 @@ public class LoginUser {
 	@SensitiveField
 	private String avatar;
 
+	/**
+	 * 工号
+	 */
+	@SensitiveField
+	private String workNo;
+
 	/**
 	 * 生日
 	 */
@@ -138,4 +144,8 @@ public class LoginUser {
 	/**设备id uniapp推送用*/
 	private String clientId;
 
+	/**
+	 * 主岗位
+	 */
+	private String mainDepPostId;
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/AssertUtils.java

@@ -0,0 +1,239 @@
+package org.jeecg.common.util;
+
+
+import org.jeecg.common.exception.JeecgBootAssertException;
+
+/**
+ * 断言检查工具
+ * for for [QQYUN-10990]AIRAG
+ * @author chenrui
+ * @date 2017-06-22 10:05:56
+ */
+public class AssertUtils {
+
+    /**
+     * 确保对象为空,如果不为空抛出异常
+     *
+     * @param msg
+     * @param obj
+     * @throws JeecgBootAssertException
+     * @author chenrui
+     * @date 2017-06-22 10:05:56
+     */
+    public static void assertEmpty(String msg, Object obj) {
+        if (oConvertUtils.isObjectNotEmpty(obj)) {
+            throw new JeecgBootAssertException(msg);
+        }
+    }
+
+
+    /**
+     * 确保对象不为空,如果为空抛出异常
+     *
+     * @param msg
+     * @param obj
+     * @throws JeecgBootAssertException
+     * @author chenrui
+     * @date 2017-06-22 10:05:56
+     */
+    public static void assertNotEmpty(String msg, Object obj) {
+        if (oConvertUtils.isObjectEmpty(obj)) {
+            throw new JeecgBootAssertException(msg);
+        }
+    }
+
+
+    /**
+     * 验证对象是否相同
+     *
+     * @param message
+     * @param expected
+     * @param actual
+     * @author chenrui
+     * @date 2018/9/12 15:45
+     */
+    public static void assertEquals(String message, Object expected,
+                                    Object actual) {
+        if (oConvertUtils.isEqual(expected, actual)) {
+            return;
+        }
+        throw new JeecgBootAssertException(message);
+    }
+
+    /**
+     * 验证不相同
+     *
+     * @param message
+     * @param expected
+     * @param actual
+     * @author chenrui
+     * @date 2018/9/12 15:45
+     */
+    public static void assertNotEquals(String message, Object expected,
+                                       Object actual) {
+        if (oConvertUtils.isEqual(expected, actual)) {
+            throw new JeecgBootAssertException(message);
+        }
+
+    }
+
+    /**
+     * 验证是否相等
+     *
+     * @param message
+     * @param expected
+     * @param actual
+     * @author chenrui
+     * @date 2018/9/12 15:45
+     */
+    public static void assertSame(String message, Object expected,
+                                  Object actual) {
+        if (expected == actual) {
+            return;
+        }
+        throw new JeecgBootAssertException(message);
+    }
+
+    /**
+     * 验证不相等
+     *
+     * @param message
+     * @param unexpected
+     * @param actual
+     * @author chenrui
+     * @date 2018/9/12 15:45
+     */
+    public static void assertNotSame(String message, Object unexpected,
+                                     Object actual) {
+        if (unexpected == actual) {
+            throw new JeecgBootAssertException(message);
+        }
+    }
+
+    /**
+     * 验证是否为真
+     *
+     * @param message
+     * @param condition
+     */
+    public static void assertTrue(String message, boolean condition) {
+        if (!condition) {
+            throw new JeecgBootAssertException(message);
+        }
+    }
+
+    /**
+     * 验证 condition是否为false
+     *
+     * @param message
+     * @param condition
+     */
+    public static void assertFalse(String message, boolean condition) {
+        assertTrue(message, !condition);
+    }
+
+
+    /**
+     * 验证是否存在
+     *
+     * @param message
+     * @param obj
+     * @param objs
+     * @param <T>
+     * @throws JeecgBootAssertException
+     * @author chenrui
+     * @date 2018/1/31 22:14
+     */
+    public static <T> void assertIn(String message, T obj, T... objs) {
+        assertNotEmpty(message, obj);
+        assertNotEmpty(message, objs);
+        if (!oConvertUtils.isIn(obj, objs)) {
+            throw new JeecgBootAssertException(message);
+        }
+    }
+
+    /**
+     * 验证是否不存在
+     *
+     * @param message
+     * @param obj
+     * @param objs
+     * @param <T>
+     * @throws JeecgBootAssertException
+     * @author chenrui
+     * @date 2018/1/31 22:14
+     */
+
+    public static <T> void assertNotIn(String message, T obj, T... objs) {
+        assertNotEmpty(message, obj);
+        assertNotEmpty(message, objs);
+        if (oConvertUtils.isIn(obj, objs)) {
+            throw new JeecgBootAssertException(message);
+        }
+    }
+
+
+    /**
+     * 确保src大于des
+     *
+     * @param message
+     * @param src
+     * @param des
+     * @author chenrui
+     * @date 2018/9/19 15:30
+     */
+    public static void assertGt(String message, Number src, Number des) {
+        if (oConvertUtils.isGt(src, des)) {
+            return;
+        }
+        throw new JeecgBootAssertException(message);
+    }
+
+    /**
+     * 确保src大于等于des
+     *
+     * @param message
+     * @param src
+     * @param des
+     * @author chenrui
+     * @date 2018/9/19 15:30
+     */
+    public static void assertGe(String message, Number src, Number des) {
+        if (oConvertUtils.isGe(src, des)) {
+            return;
+        }
+        throw new JeecgBootAssertException(message);
+    }
+
+
+    /**
+     * 确保src小于des
+     *
+     * @param message
+     * @param src
+     * @param des
+     * @author chenrui
+     * @date 2018/9/19 15:30
+     */
+    public static void assertLt(String message, Number src, Number des) {
+        if (oConvertUtils.isGe(src, des)) {
+            throw new JeecgBootAssertException(message);
+        }
+    }
+
+    /**
+     * 确保src小于等于des
+     *
+     * @param message
+     * @param src
+     * @param des
+     * @author chenrui
+     * @date 2018/9/19 15:30
+     */
+    public static void assertLe(String message, Number src, Number des) {
+        if (oConvertUtils.isGt(src, des)) {
+            throw new JeecgBootAssertException(message);
+        }
+    }
+
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/BrowserUtils.java

@@ -5,7 +5,7 @@ import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 
 /**
  * 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/CommonUtils.java

@@ -19,12 +19,13 @@ import org.springframework.jdbc.datasource.DriverManagerDataSource;
 import org.springframework.util.FileCopyUtils;
 import org.springframework.web.multipart.MultipartFile;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 import javax.sql.DataSource;
 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
@@ -152,9 +153,9 @@ public class CommonUtils {
      */
     public static String uploadLocal(MultipartFile mf,String bizPath,String uploadpath){
         try {
-            //update-begin-author:liusq date:20210809 for: 过滤上传文件类型
-            SsrfFileTypeFilter.checkUploadFileType(mf);
-            //update-end-author:liusq date:20210809 for: 过滤上传文件类型
+            // 文件安全校验，防止上传漏洞文件
+            SsrfFileTypeFilter.checkUploadFileType(mf, bizPath);
+            
             String fileName = null;
             File file = new File(uploadpath + File.separator + bizPath + File.separator );
             if (!file.exists()) {
@@ -163,6 +164,10 @@ public class CommonUtils {
             }
             // 获取文件名
             String orgName = mf.getOriginalFilename();
+            // 无中文情况下进行转码
+            if (orgName != null && !CommonUtils.ifContainChinese(orgName)) {
+                orgName = new String(orgName.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
+            }
             orgName = CommonUtils.getFileName(orgName);
             if(orgName.indexOf(SymbolConstant.SPOT)!=-1){
                 fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."));
@@ -242,6 +247,10 @@ public class CommonUtils {
         try {
             DataSource dataSource = SpringContextUtils.getApplicationContext().getBean(DataSource.class);
             dbTypeEnum = JdbcUtils.getDbType(dataSource.getConnection().getMetaData().getURL());
+            //【采用SQL_SERVER2005引擎】QQYUN-13298 解决升级mybatisPlus后SqlServer分页使用OFFSET，无排序字段报错问题
+            if (dbTypeEnum == DbType.SQL_SERVER) {
+                dbTypeEnum = DbType.SQL_SERVER2005;
+            }
             return dbTypeEnum;
         } catch (SQLException e) {
             log.warn(e.getMessage(), e);

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/DateUtils.java

@@ -13,6 +13,8 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
@@ -814,4 +816,44 @@ public class DateUtils extends PropertyEditorSupport {
         return calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR);
     }
 
+    /**
+     * 获取两个日期之间的所有日期列表，包含开始和结束日期
+     *
+     * @param begin
+     * @param end
+     * @return
+     */
+    public static List<Date> getDateRangeList(Date begin, Date end) {
+        List<Date> dateList = new ArrayList<>();
+        if (begin == null || end == null) {
+            return dateList;
+        }
+
+        // 清除时间部分，只比较日期
+        Calendar beginCal = Calendar.getInstance();
+        beginCal.setTime(begin);
+        beginCal.set(Calendar.HOUR_OF_DAY, 0);
+        beginCal.set(Calendar.MINUTE, 0);
+        beginCal.set(Calendar.SECOND, 0);
+        beginCal.set(Calendar.MILLISECOND, 0);
+
+        Calendar endCal = Calendar.getInstance();
+        endCal.setTime(end);
+        endCal.set(Calendar.HOUR_OF_DAY, 0);
+        endCal.set(Calendar.MINUTE, 0);
+        endCal.set(Calendar.SECOND, 0);
+        endCal.set(Calendar.MILLISECOND, 0);
+
+        if (endCal.before(beginCal)) {
+            return dateList;
+        }
+
+        dateList.add(beginCal.getTime());
+        while (beginCal.before(endCal)) {
+            beginCal.add(Calendar.DAY_OF_YEAR, 1);
+            dateList.add(beginCal.getTime());
+        }
+        return dateList;
+    }
+
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/FileDownloadUtils.java

@@ -1,14 +1,22 @@
 package org.jeecg.common.util;
 
+import jakarta.servlet.http.HttpServletResponse;
+import cn.hutool.core.io.IoUtil;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
+import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
 import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.io.IOUtils;
+import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.exception.JeecgBootException;
+import org.jeecg.common.util.filter.SsrfFileTypeFilter;
 
-import javax.servlet.http.HttpServletResponse;
 import java.io.*;
+import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.List;
 import java.util.zip.ZipEntry;
@@ -203,4 +211,150 @@ public class FileDownloadUtils {
             dir.mkdirs();
         }
     }
+
+
+    /**
+     * 下载单个文件到ZIP流
+     * 核心功能：获取文件流，写入ZIP条目
+     * @param fileUrl 文件URL（可以是HTTP URL或本地路径）
+     * @param fileName ZIP内的文件名
+     * @param zous ZIP输出流
+     */
+    public static void downLoadSingleFile(String fileUrl, String fileName, String uploadUrl,ZipArchiveOutputStream zous) {
+        InputStream inputStream = null;
+        try {
+            // 创建ZIP条目：每个文件在ZIP中都是一个独立条目
+            ZipArchiveEntry entry = new ZipArchiveEntry(fileName);
+            zous.putArchiveEntry(entry);
+
+            // 获取文件输入流：区分普通文件和快捷方式
+            if (fileUrl.endsWith(".url")) {
+                // 处理快捷方式：生成.url文件内容
+                inputStream = FileDownloadUtils.createInternetShortcut(fileName, fileUrl, "");
+            } else {
+                // 普通文件下载：从URL或本地路径获取流
+                inputStream = getDownInputStream(fileUrl,uploadUrl);
+            }
+
+            if (inputStream != null) {
+                // 将文件流写入ZIP
+                IOUtils.copy(inputStream, zous);
+            }
+            // 关闭当前ZIP条目
+            zous.closeArchiveEntry();
+        } catch (IOException e) {
+            log.error("文件下载失败: {}",  e);
+        } finally {
+            // 确保输入流关闭
+            IoUtil.close(inputStream);
+        }
+    }
+
+    /**
+     * 获取下载文件输入流
+     * 功能：根据URL类型（HTTP或本地）获取文件流
+     * @param fileUrl 文件URL（支持HTTP和本地路径）
+     * @return 文件输入流，失败返回null
+     */
+    public static InputStream getDownInputStream(String fileUrl, String uploadUrl) {
+        try {
+            // 处理HTTP URL：通过网络下载
+            if (oConvertUtils.isNotEmpty(fileUrl) && fileUrl.startsWith(CommonConstant.STR_HTTP)) {
+                URL url = new URL(fileUrl);
+                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+                connection.setConnectTimeout(5000); // 连接超时5秒
+                connection.setReadTimeout(30000);  // 读取超时30秒
+                return connection.getInputStream();
+            } else {
+                // 处理本地文件：直接读取文件系统
+                String downloadFilePath = uploadUrl + File.separator + fileUrl;
+                // 安全检查：防止下载危险文件类型
+                SsrfFileTypeFilter.checkDownloadFileType(downloadFilePath);
+                return new BufferedInputStream(new FileInputStream(downloadFilePath));
+            }
+        } catch (IOException e) {
+            // 异常时返回null，上层会处理空流情况
+            return null;
+        }
+    }
+
+    /**
+     * 获取文件扩展名
+     * 功能：从文件名中提取扩展名
+     * @param fileName 文件名
+     * @return 文件扩展名（不含点），如"txt"、"png"
+     */
+    public static String getFileExtension(String fileName) {
+        int dotIndex = fileName.lastIndexOf('.');
+        return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1);
+    }
+
+    /**
+     * 创建快捷方式（.url文件内容）
+     * 功能：生成Internet快捷方式文件内容
+     * @param name 快捷方式名称
+     * @param url 目标URL地址
+     * @param icon 图标路径（可选）
+     * @return 包含.url文件内容的输入流
+     */
+    public static InputStream createInternetShortcut(String name, String url, String icon) {
+        StringWriter sw = new StringWriter();
+        try {
+            // 按照Windows快捷方式格式写入内容
+            sw.write("[InternetShortcut]\n");
+            sw.write("URL=" + url + "\n");
+            if (oConvertUtils.isNotEmpty(icon)) {
+                sw.write("IconFile=" + icon + "\n");
+            }
+            // 将字符串内容转换为输入流
+            return new ByteArrayInputStream(sw.toString().getBytes(StandardCharsets.UTF_8));
+        } finally {
+            IoUtil.close(sw);
+        }
+    }
+    /**
+     * 从URL中提取文件名
+     * 功能：从HTTP URL或本地路径中提取纯文件名
+     * @param fileUrl 文件URL
+     * @return 文件名（不含路径）
+     */
+    public static String getFileNameFromUrl(String fileUrl) {
+        try {
+            // 处理HTTP URL：从路径部分提取文件名
+            if (fileUrl.startsWith(CommonConstant.STR_HTTP)) {
+                URL url = new URL(fileUrl);
+                String path = url.getPath();
+                return path.substring(path.lastIndexOf('/') + 1);
+            }
+
+            // 处理本地文件路径：从文件路径提取文件名
+            return fileUrl.substring(fileUrl.lastIndexOf(File.separator) + 1);
+        } catch (Exception e) {
+            // 如果解析失败，使用时间戳作为文件名
+            return "file_" + System.currentTimeMillis();
+        }
+    }
+    /**
+     * 生成ZIP中的文件名
+     * 功能：避免文件名冲突，为多个文件添加序号
+     * @param fileUrl 文件URL（用于提取原始文件名）
+     * @param index 文件序号（从0开始）
+     * @param total 文件总数
+     * @return 处理后的文件名（带序号）
+     */
+    public static String generateFileName(String fileUrl, int index, int total) {
+        // 从URL中提取原始文件名
+        String originalFileName = getFileNameFromUrl(fileUrl);
+
+        // 如果只有一个文件，直接使用原始文件名
+        if (total == 1) {
+            return originalFileName;
+        }
+
+        // 多个文件时，使用序号+原始文件名
+        String extension = getFileExtension(originalFileName);
+        String nameWithoutExtension = originalFileName.replace("." + extension, "");
+
+        return String.format("%s_%d.%s", nameWithoutExtension, index + 1, extension);
+    }
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/FillRuleUtil.java

@@ -4,13 +4,13 @@ import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import jakarta.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.jeecg.common.constant.SymbolConstant;
 import org.jeecg.common.handler.IFillRuleHandler;
 import org.jeecg.common.system.query.QueryGenerator;
 
-import javax.servlet.http.HttpServletRequest;
 
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/IpUtils.java

@@ -1,6 +1,6 @@
 package org.jeecg.common.util;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 
 import org.apache.commons.lang3.StringUtils;
 import org.jeecg.common.constant.CommonConstant;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/LoginUserUtils.java

@@ -0,0 +1,175 @@
+package org.jeecg.common.util;
+
+import cn.dev33.satoken.stp.StpUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.jeecg.common.system.vo.LoginUser;
+
+/**
+ * 登录用户工具类
+ * 替代原有的Shiro SecurityUtils工具类
+ * @author jeecg-boot
+ */
+@Slf4j
+public class LoginUserUtils {
+
+    /**
+     * Session中存储登录用户信息的key
+     */
+    private static final String SESSION_KEY_LOGIN_USER = "loginUser";
+
+    /**
+     * 执行登录并设置用户信息到Session（推荐）
+     *
+     * <p>此方法会：
+     * <ul>
+     *   <li>1. 调用 StpUtil.login(username) 生成token和session</li>
+     *   <li>2. 将 LoginUser 存入 Session 缓存（清除不必要的字段（密码等15个字段）</li>
+     *   <li>3. 返回生成的 token</li>
+     * </ul>
+     *
+     * @param sysUser 完整的用户对象（从数据库查询得到）
+     * @return 生成的 token
+     */
+    public static String doLogin(LoginUser sysUser) {
+        if (sysUser == null) {
+            throw new IllegalArgumentException("用户对象不能为空");
+        }
+
+        try {
+            // 1. 获取 username
+            String username = sysUser.getUsername();
+
+            if (username == null || username.trim().isEmpty()) {
+                throw new IllegalArgumentException("用户名不能为空");
+            }
+
+            // 2. Sa-Token 登录（使用 username 作为 loginId）
+            StpUtil.login(username);
+
+            // 3. 用户信息到 LoginUser 并存入 Session
+            setSessionUser(sysUser);
+
+            // 4. 返回生成的 token
+            return StpUtil.getTokenValue();
+
+        } catch (Exception e) {
+            throw new RuntimeException("登录失败: " + e.getMessage(), e);
+        }
+    }
+    
+    /**
+     * 获取当前登录用户信息
+     *
+     * <p>说明：
+     * <ul>
+     *   <li>对于需要认证的接口：Sa-Token Filter 已经校验过登录状态，此方法必然能获取到用户</li>
+     *   <li>对于已排除拦截的接口：如果未登录或获取失败则返回 null，由业务代码自行判断处理</li>
+     * </ul>
+     *
+     * @return 登录用户对象，如果未登录或session中没有则返回null
+     */
+    public static LoginUser getSessionUser() {
+        // 尝试从Sa-Token的Session中获取用户信息
+        Object loginUser = StpUtil.getSession().get(SESSION_KEY_LOGIN_USER);
+        if (loginUser instanceof LoginUser) {
+            return (LoginUser) loginUser;
+        }
+        return null;
+    }
+    
+    /**
+     * 根据指定的 token 获取登录用户信息
+     * 
+     * <p>适用场景：已排除拦截的接口（如 WebSocket），需要显式传入 token 来获取用户信息
+     * 
+     * <p>实现方式：临时切换到该 token 对应的会话，然后获取用户信息
+     * 
+     * @param token JWT token
+     * @return 登录用户对象，如果 token 无效或session中没有则返回null
+     */
+    public static LoginUser getSessionUser(String token) {
+        try {
+            // 根据 token 获取登录ID
+            Object loginId = StpUtil.getLoginIdByToken(token);
+            if (loginId == null) {
+                return null;
+            }
+            
+            // 临时切换到该 token 对应的登录会话
+            StpUtil.switchTo(loginId);
+            
+            // 直接调用无参方法获取用户信息
+            return getSessionUser();
+            
+        } catch (Exception e) {
+            log.debug("根据token获取用户信息失败: {}", e.getMessage());
+            return null;
+        }
+    }
+    
+    
+    /**
+     * 设置当前登录用户信息到Session
+     * 
+     * <p>为减少 Redis 存储和保障安全，只保留必要的核心字段：
+     * <ul>
+     *   <li>id, username, realname - 基础用户信息</li>
+     *   <li>orgCode, orgId, departIds - 部门和数据权限</li>
+     *   <li>roleCode - 角色权限</li>
+     *   <li>loginTenantId, relTenantIds - 多租户</li>
+     *   <li>avatar - 用户头像</li>
+     * </ul>
+     * 
+     * <p>⚠️ 注意：调用此方法前需要先调用 StpUtil.login()
+     * 
+     * @param loginUser 登录用户对象
+     */
+    public static void setSessionUser(LoginUser loginUser) {
+        if (loginUser == null) {
+            return;
+        }
+        
+        // ⚠️ 安全与性能：清除不必要的字段，减少 Redis 存储
+        loginUser.setPassword(null);        // 密码（安全）
+        loginUser.setWorkNo(null);          // 工号
+        loginUser.setBirthday(null);        // 生日
+        loginUser.setSex(null);             // 性别
+        loginUser.setEmail(null);           // 邮箱
+        loginUser.setPhone(null);           // 手机号
+        loginUser.setStatus(null);          // 状态
+        loginUser.setDelFlag(null);         // 删除标志
+        loginUser.setActivitiSync(null);    // 工作流同步
+        loginUser.setCreateTime(null);      // 创建时间
+        loginUser.setUserIdentity(null);    // 用户身份
+        loginUser.setPost(null);            // 职务
+        loginUser.setTelephone(null);       // 座机
+        loginUser.setRelTenantIds(null);   // 关联租户
+        loginUser.setMainDepPostId(null);   // 主岗位
+        
+        StpUtil.getSession().set(SESSION_KEY_LOGIN_USER, loginUser);
+    }
+
+    /**
+     * 获取当前登录用户名（推荐使用此方法，语义更清晰）
+     * @return 用户名（username）
+     */
+    public static String getUsername() {
+        return StpUtil.getLoginIdAsString();
+    }
+
+    /**
+     * 检查是否已登录
+     * @return true-已登录，false-未登录
+     */
+    public static boolean isLogin() {
+        return StpUtil.isLogin();
+    }
+
+    /**
+     * 退出登录
+     */
+    public static void logout() {
+        StpUtil.logout();
+    }
+}
+

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MinioUtil.java

@@ -55,13 +55,11 @@ public class MinioUtil {
      */
     public static String upload(MultipartFile file, String bizPath, String customBucket) throws Exception {
         String fileUrl = "";
-        //update-begin-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
+        // 业务路径过滤，防止攻击
         bizPath = StrAttackFilter.filter(bizPath);
-        //update-end-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
 
-        //update-begin-author:liusq date:20210809 for: 过滤上传文件类型
-        SsrfFileTypeFilter.checkUploadFileType(file);
-        //update-end-author:liusq date:20210809 for: 过滤上传文件类型
+        // 文件安全校验，防止上传漏洞文件
+        SsrfFileTypeFilter.checkUploadFileType(file, bizPath);
 
         String newBucket = bucketName;
         if(oConvertUtils.isNotEmpty(customBucket)){

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/PmsUtil.java

@@ -2,6 +2,7 @@ package org.jeecg.common.util;
 
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
 import java.io.BufferedWriter;
@@ -16,6 +17,7 @@ import java.util.List;
  */
 @Slf4j
 @Component
+@Lazy(false)
 public class PmsUtil {
 
 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/RestUtil.java

@@ -4,7 +4,7 @@ import com.alibaba.fastjson.JSONObject;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.http.*;
-import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
 import org.springframework.http.converter.StringHttpMessageConverter;
 import org.springframework.web.client.RestTemplate;
 
@@ -56,12 +56,22 @@ public class RestUtil {
     private final static RestTemplate RT;
 
     static {
-        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
+        //update-begin---author:chenrui ---date:20251011  for：[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);
-        // 解决乱码问题
-        RT.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
+        //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) {
+                RT.getMessageConverters().set(i, new StringHttpMessageConverter(StandardCharsets.UTF_8));
+                break;
+            }
+        }
+        //update-end---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
     }
 
     public static RestTemplate getRestTemplate() {
@@ -221,6 +231,72 @@ public class RestUtil {
         return RT.exchange(url, method, request, responseType);
     }
 
+    /**
+     * 发送请求（支持自定义超时时间）
+     *
+     * @param url          请求地址
+     * @param method       请求方式
+     * @param headers      请求头  可空
+     * @param variables    请求url参数 可空
+     * @param params       请求body参数 可空
+     * @param responseType 返回类型
+     * @param timeout      超时时间（毫秒），如果为0或负数则使用默认超时
+     * @return ResponseEntity<responseType>
+     */
+    public static <T> ResponseEntity<T> request(String url, HttpMethod method, HttpHeaders headers,
+                                                JSONObject variables, Object params, Class<T> responseType, int timeout) {
+        log.info(" RestUtil  --- request ---  url = "+ url + ", timeout = " + timeout);
+
+        if (StringUtils.isEmpty(url)) {
+            throw new RuntimeException("url 不能为空");
+        }
+        if (method == null) {
+            throw new RuntimeException("method 不能为空");
+        }
+        if (headers == null) {
+            headers = new HttpHeaders();
+        }
+
+        // 创建自定义RestTemplate（如果需要设置超时）
+        RestTemplate restTemplate = RT;
+        if (timeout > 0) {
+            //update-begin---author:chenrui ---date:20251011  for：[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) {
+                    restTemplate.getMessageConverters().set(i, new StringHttpMessageConverter(StandardCharsets.UTF_8));
+                    break;
+                }
+            }
+            //update-end---author:chenrui ---date:20251011  for：[issues/8859]online表单java增强失效------------
+        }
+
+        // 请求体
+        String body = "";
+        if (params != null) {
+            if (params instanceof JSONObject) {
+                body = ((JSONObject) params).toJSONString();
+            } else {
+                body = params.toString();
+            }
+        }
+
+        // 拼接 url 参数
+        if (variables != null && !variables.isEmpty()) {
+            url += ("?" + asUrlVariables(variables));
+        }
+
+        // 发送请求
+        HttpEntity<String> request = new HttpEntity<>(body, headers);
+        return restTemplate.exchange(url, method, request, responseType);
+    }
+    
     /**
      * 获取JSON请求头
      */

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/SpringContextUtils.java

@@ -1,13 +1,14 @@
 package org.jeecg.common.util;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.ServiceNameConstants;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
@@ -16,6 +17,7 @@ import org.springframework.web.context.request.ServletRequestAttributes;
  * @Description: spring上下文工具类
  * @author: jeecg-boot
  */
+@Lazy(false)
 @Component
 public class SpringContextUtils implements ApplicationContextAware {
 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/SqlInjectionUtil.java

@@ -16,7 +16,13 @@ import java.util.regex.Pattern;
  * @author zhoujf
  */
 @Slf4j
-public class SqlInjectionUtil {	
+public class SqlInjectionUtil {
+
+	/**
+	 * sql注入黑名单数据库名
+	 */
+	public final static String XSS_STR_TABLE = "peformance_schema|information_schema";
+
 	/**
 	 * 默认—sql注入关键词
 	 */
@@ -167,7 +173,28 @@ public class SqlInjectionUtil {
 		}
 		return false;
 	}
-	
+
+	/**
+	 * 判断是否存在SQL注入关键词字符串
+	 *
+	 * @param keyword
+	 * @return
+	 */
+	@SuppressWarnings("AlibabaUndefineMagicConstant")
+	private static boolean isExistSqlInjectTableKeyword(String sql, String keyword) {
+		// 需要匹配的，sql注入关键词
+		String[] matchingTexts = new String[]{"`" + keyword, "(" + keyword, "(`" + keyword};
+		for (String matchingText : matchingTexts) {
+			String[] checkTexts = new String[]{" " + matchingText, "from" + matchingText};
+			for (String checkText : checkTexts) {
+				if (sql.contains(checkText)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * sql注入过滤处理，遇到注入关键字抛异常
 	 * 
@@ -208,6 +235,14 @@ public class SqlInjectionUtil {
 				throw new JeecgSqlInjectionException(SqlInjectionUtil.SQL_INJECTION_TIP + value);
 			}
 		}
+		String[] xssTableArr = XSS_STR_TABLE.split("\\|");
+		for (String xssTableStr : xssTableArr) {
+            if (isExistSqlInjectTableKeyword(value, xssTableStr)) {
+                log.error(SqlInjectionUtil.SQL_INJECTION_KEYWORD_TIP, xssTableStr);
+                log.error(SqlInjectionUtil.SQL_INJECTION_TIP_VARIABLE, value);
+                throw new JeecgSqlInjectionException(SqlInjectionUtil.SQL_INJECTION_TIP + value);
+            }
+        }
 
 		// 三、SQL注入检测存在绕过风险 (正则校验)
 		for (String regularOriginal : XSS_REGULAR_STR_ARRAY) {
@@ -244,6 +279,14 @@ public class SqlInjectionUtil {
 				throw new JeecgSqlInjectionException(SqlInjectionUtil.SQL_INJECTION_TIP + value);
 			}
 		}
+		String[] xssTableArr = XSS_STR_TABLE.split("\\|");
+		for (String xssTableStr : xssTableArr) {
+			if (isExistSqlInjectTableKeyword(value, xssTableStr)) {
+				log.error(SqlInjectionUtil.SQL_INJECTION_KEYWORD_TIP, xssTableStr);
+				log.error(SqlInjectionUtil.SQL_INJECTION_TIP_VARIABLE, value);
+				throw new JeecgSqlInjectionException(SqlInjectionUtil.SQL_INJECTION_TIP + value);
+			}
+		}
 
 		// 三、SQL注入检测存在绕过风险 (正则校验)
 		for (String regularOriginal : XSS_REGULAR_STR_ARRAY) {

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/TokenUtils.java

@@ -1,5 +1,6 @@
 package org.jeecg.common.util;
 
+import cn.dev33.satoken.stp.StpUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.jeecg.common.api.CommonAPI;
@@ -11,7 +12,7 @@ import org.jeecg.common.exception.JeecgBoot401Exception;
 import org.jeecg.common.system.util.JwtUtil;
 import org.jeecg.common.system.vo.LoginUser;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 
 /**
  * @Author scott
@@ -65,6 +66,10 @@ public class TokenUtils {
         if (tenantId == null) {
             tenantId = oConvertUtils.getString(request.getHeader(CommonConstant.TENANT_ID));
         }
+
+        if (oConvertUtils.isNotEmpty(tenantId) && "undefined".equals(tenantId)) {
+            return null;
+        }
         return tenantId;
     }
 
@@ -83,68 +88,42 @@ public class TokenUtils {
     }
 
     /**
-     * 验证Token
+     * 验证Token（已重写为Sa-Token实现）
      */
-    public static boolean verifyToken(HttpServletRequest request, CommonAPI commonApi, RedisUtil redisUtil) {
+    public static boolean verifyToken(HttpServletRequest request, CommonAPI commonApi) {
         log.debug(" -- url --" + request.getRequestURL());
         String token = getTokenByRequest(request);
-        return TokenUtils.verifyToken(token, commonApi, redisUtil);
+        return TokenUtils.verifyToken(token, commonApi);
     }
 
     /**
-     * 验证Token
+     * 验证Token（已重写为Sa-Token实现）
      */
-    public static boolean verifyToken(String token, CommonAPI commonApi, RedisUtil redisUtil) {
+    public static boolean verifyToken(String token, CommonAPI commonApi) {
         if (StringUtils.isBlank(token)) {
             throw new JeecgBoot401Exception("token不能为空!");
         }
 
-        // 解密获得username，用于和数据库进行对比
-        String username = JwtUtil.getUsername(token);
+        // 使用Sa-Token校验token
+        Object username = StpUtil.getLoginIdByToken(token);
         if (username == null) {
             throw new JeecgBoot401Exception("token非法无效!");
         }
 
         // 查询用户信息
-        LoginUser user = TokenUtils.getLoginUser(username, commonApi, redisUtil);
-        //LoginUser user = commonApi.getUserByName(username);
+        LoginUser user = commonApi.getUserByName(username.toString());
         if (user == null) {
             throw new JeecgBoot401Exception("用户不存在!");
         }
+        
         // 判断用户状态
         if (user.getStatus() != 1) {
             throw new JeecgBoot401Exception("账号已被锁定,请联系管理员!");
         }
-        // 校验token是否超时失效 & 或者账号密码是否错误
-        if (!jwtTokenRefresh(token, username, user.getPassword(), redisUtil)) {
-            throw new JeecgBoot401Exception(CommonConstant.TOKEN_IS_INVALID_MSG);
-        }
+        
         return true;
     }
 
-    /**
-     * 刷新token（保证用户在线操作不掉线）
-     * @param token
-     * @param userName
-     * @param passWord
-     * @param redisUtil
-     * @return
-     */
-    private static boolean jwtTokenRefresh(String token, String userName, String passWord, RedisUtil redisUtil) {
-        String cacheToken = oConvertUtils.getString(redisUtil.get(CommonConstant.PREFIX_USER_TOKEN + token));
-        if (oConvertUtils.isNotEmpty(cacheToken)) {
-            // 校验token有效性
-            if (!JwtUtil.verify(cacheToken, userName, passWord)) {
-                String newAuthorization = JwtUtil.sign(userName, passWord);
-                // 设置Toekn缓存有效时间
-                redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, newAuthorization);
-                redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME * 2 / 1000);
-            }
-            return true;
-        }
-        return false;
-    }
-
     /**
      * 获取登录用户
      *
@@ -170,4 +149,5 @@ public class TokenUtils {
         }
         return loginUser;
     }
+
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/dynamic/db/DbTypeUtils.java

@@ -68,6 +68,13 @@ public class DbTypeUtils {
         return dbTypeIf(dbType, DbType.ORACLE, DbType.ORACLE_12C, DbType.DM);
     }
 
+    /**
+     * 是否是达梦
+     */
+    public static boolean dbTypeIsDm(DbType dbType) {
+        return dbTypeIf(dbType, DbType.DM);
+    }
+
     public static boolean dbTypeIsSqlServer(DbType dbType) {
         return dbTypeIf(dbType, DbType.SQL_SERVER, DbType.SQL_SERVER2005);
     }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/encryption/AesEncryptUtil.java

@@ -1,7 +1,6 @@
 package org.jeecg.common.util.encryption;
 
-import org.apache.shiro.codec.Base64;
-
+import java.util.Base64;
 import javax.crypto.Cipher;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
@@ -49,7 +48,7 @@ public class AesEncryptUtil {
             cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
             byte[] encrypted = cipher.doFinal(plaintext);
 
-            return Base64.encodeToString(encrypted);
+            return Base64.getEncoder().encodeToString(encrypted);
 
         } catch (Exception e) {
             e.printStackTrace();
@@ -67,7 +66,7 @@ public class AesEncryptUtil {
      */
     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.decode(data);
+        byte[] encrypted1 = Base64.getDecoder().decode(data);
 
         Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
         SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/filter/SsrfFileTypeFilter.java

@@ -2,6 +2,7 @@ package org.jeecg.common.util.filter;
 
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
+import org.jeecg.common.exception.JeecgBootException;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.IOException;
@@ -34,6 +35,7 @@ public class SsrfFileTypeFilter {
         FILE_TYPE_WHITE_LIST.add("bmp");
         FILE_TYPE_WHITE_LIST.add("svg");
         FILE_TYPE_WHITE_LIST.add("ico");
+        FILE_TYPE_WHITE_LIST.add("heic");
 
         //文本文件
         FILE_TYPE_WHITE_LIST.add("txt");
@@ -42,6 +44,7 @@ public class SsrfFileTypeFilter {
         FILE_TYPE_WHITE_LIST.add("pdf");
         FILE_TYPE_WHITE_LIST.add("csv");
 //        FILE_TYPE_WHITE_LIST.add("xml");
+        FILE_TYPE_WHITE_LIST.add("md");
 
         //音视频文件
         FILE_TYPE_WHITE_LIST.add("mp4");
@@ -65,6 +68,10 @@ public class SsrfFileTypeFilter {
         FILE_TYPE_WHITE_LIST.add("apk");
         FILE_TYPE_WHITE_LIST.add("wgt");
 
+        //幻灯片文件后缀
+        FILE_TYPE_WHITE_LIST.add("ppt");
+        FILE_TYPE_WHITE_LIST.add("pptx");
+
         //设置禁止文件的头部标记
         FILE_TYPE_MAP.put("3c25402070616765206c", "jsp");
         FILE_TYPE_MAP.put("3c3f7068700a0a2f2a2a0a202a205048", "php");
@@ -143,29 +150,38 @@ public class SsrfFileTypeFilter {
     public static void checkDownloadFileType(String filePath) throws IOException {
         //文件后缀
         String suffix = getFileTypeBySuffix(filePath);
-        log.info("suffix:{}", suffix);
+        log.debug(" 【文件下载校验】文件后缀 suffix: {}", suffix);
         boolean isAllowExtension = FILE_TYPE_WHITE_LIST.contains(suffix.toLowerCase());
         //是否允许下载的文件
         if (!isAllowExtension) {
-            throw new IOException("下载失败，存在非法文件类型：" + suffix);
+            throw new JeecgBootException("下载失败，存在非法文件类型：" + suffix);
         }
     }
 
-
     /**
      * 上传文件类型过滤
      *
      * @param file
      */
     public static void checkUploadFileType(MultipartFile file) throws Exception {
-        //获取文件真是后缀
-        String suffix = getFileType(file);
-
-        log.info("suffix:{}", suffix);
+        checkUploadFileType(file, null);
+    }
+    
+    /**
+     * 上传文件类型过滤
+     *
+     * @param file
+     */
+    public static void checkUploadFileType(MultipartFile file, String customPath) throws Exception {
+        //1. 路径安全校验
+        validatePathSecurity(customPath);
+        //2. 校验文件后缀和头
+        String suffix = getFileType(file, customPath);
+        log.info("【文件上传校验】文件后缀 suffix: {}，customPath：{}", suffix, customPath);
         boolean isAllowExtension = FILE_TYPE_WHITE_LIST.contains(suffix.toLowerCase());
         //是否允许下载的文件
         if (!isAllowExtension) {
-            throw new Exception("上传失败，存在非法文件类型：" + suffix);
+            throw new JeecgBootException("上传失败，存在非法文件类型：" + suffix);
         }
     }
 
@@ -177,7 +193,7 @@ public class SsrfFileTypeFilter {
      * @throws Exception
      */
 
-    private static String getFileType(MultipartFile file) throws Exception {
+    private static String getFileType(MultipartFile file, String customPath) throws Exception {
         //update-begin-author:liusq date:20230404 for: [issue/4672]方法造成的文件被占用，注释掉此方法tomcat就能自动清理掉临时文件
         String fileExtendName = null;
         InputStream is = null;
@@ -197,7 +213,7 @@ public class SsrfFileTypeFilter {
                     break;
                 }
             }
-            log.info("-----获取到的指定文件类型------"+fileExtendName);
+            log.debug("-----获取到的指定文件类型------"+fileExtendName);
             // 如果不是上述类型，则判断扩展名
             if (StringUtils.isBlank(fileExtendName)) {
                 String fileName = file.getOriginalFilename();
@@ -208,7 +224,6 @@ public class SsrfFileTypeFilter {
                 // 如果有扩展名，则返回扩展名
                 return getFileTypeBySuffix(fileName);
             }
-            log.info("-----最終的文件类型------"+fileExtendName);
             is.close();
             return fileExtendName;
         } catch (Exception e) {
@@ -243,4 +258,34 @@ public class SsrfFileTypeFilter {
         }
         return stringBuilder.toString();
     }
+
+    /**
+     * 路径安全校验
+     */
+    private static void validatePathSecurity(String customPath) throws JeecgBootException {
+        if (customPath == null || customPath.trim().isEmpty()) {
+            return;
+        }
+
+        // 统一分隔符为 /
+        String normalized = customPath.replace("\\", "/");
+
+        // 1. 防止路径遍历攻击
+        if (normalized.contains("..") || normalized.contains("~")) {
+            throw new JeecgBootException("上传业务路径包含非法字符！");
+        }
+
+        // 2. 限制路径深度
+        int depth = normalized.split("/").length;
+        if (depth > 5) {
+            throw new JeecgBootException("上传业务路径深度超出限制！");
+        }
+
+        // 3. 限制字符集（只允许字母、数字、下划线、横线、斜杠）
+        if (!normalized.matches("^[a-zA-Z0-9/_-]+$")) {
+            throw new JeecgBootException("上传业务路径包含非法字符！");
+        }
+    }
+
+    
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/oConvertUtils.java

@@ -7,12 +7,14 @@ import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.SymbolConstant;
+import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
 import org.springframework.beans.BeanUtils;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -463,7 +465,7 @@ public class oConvertUtils {
 			return false;
 		}
 
-		String[] childs = childArray.toArray(new String[]{});
+		List<String> childs = childArray.toJavaList(String.class);
 		for (String v : childs) {
 			if (!isIn(v, all)) {
 				return false;
@@ -472,6 +474,23 @@ public class oConvertUtils {
 		return true;
 	}
 
+	/**
+	 * 判断字符串是否为JSON格式
+	 * @param str
+	 * @return
+	 */
+	public static boolean isJson(String str) {
+		if (str == null || str.trim().isEmpty()) {
+			return false;
+		}
+		try {
+			com.alibaba.fastjson.JSON.parse(str);
+			return true;
+		} catch (Exception e) {
+			return false;
+		}
+	}
+	
 	/**
 	 * 获取Map对象
 	 */
@@ -1028,5 +1047,126 @@ public class oConvertUtils {
 		}
 		return result;
 	}
+
+	/**
+	 * 判断对象是否为空 <br/>
+	 * 支持各种类型的对象
+	 * for for [QQYUN-10990]AIRAG
+	 * @param obj
+	 * @return
+	 * @author chenrui
+	 * @date 2025/2/13 18:34
+	 */
+	public static boolean isObjectEmpty(Object obj) {
+		if (null == obj) {
+			return true;
+		}
+
+		if (obj instanceof CharSequence) {
+			return isEmpty(obj);
+		} else if (obj instanceof Map) {
+			return ((Map<?, ?>) obj).isEmpty();
+		} else if (obj instanceof Iterable) {
+			return isObjectEmpty(((Iterable<?>) obj).iterator());
+		} else if (obj instanceof Iterator) {
+			return !((Iterator<?>) obj).hasNext();
+		} else if (isArray(obj)) {
+			return 0 == Array.getLength(obj);
+		}
+		return false;
+	}
+
+	/**
+	 * iterator 是否为空
+	 * for for [QQYUN-10990]AIRAG
+	 * @param iterator Iterator对象
+	 * @return 是否为空
+	 */
+	public static boolean isEmptyIterator(Iterator<?> iterator) {
+		return null == iterator || false == iterator.hasNext();
+	}
+
+
+	/**
+	 * 判断对象是否不为空
+	 * for for [QQYUN-10990]AIRAG
+	 * @param object
+	 * @return
+	 * @author chenrui
+	 * @date 2025/2/13 18:35
+	 */
+	public static boolean isObjectNotEmpty(Object object) {
+		return !isObjectEmpty(object);
+	}
+
+	/**
+	 * 如果src大于des返回true
+	 * for [QQYUN-10990]AIRAG
+	 * @param src
+	 * @param des
+	 * @return
+	 * @author: chenrui
+	 * @date: 2018/9/19 15:30
+	 */
+	public static boolean isGt(Number src, Number des) {
+		if (null == src || null == des) {
+			throw new IllegalArgumentException("参数不能为空");
+		}
+		if (src.doubleValue() > des.doubleValue()) {
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * 如果src大于等于des返回true
+	 * for [QQYUN-10990]AIRAG
+	 * @param src
+	 * @param des
+	 * @return
+	 * @author: chenrui
+	 * @date: 2018/9/19 15:30
+	 */
+	public static boolean isGe(Number src, Number des) {
+		if (null == src || null == des) {
+			throw new IllegalArgumentException("参数不能为空");
+		}
+		if (src.doubleValue() < des.doubleValue()) {
+			return false;
+		}
+		return true;
+	}
+
+
+	/**
+	 * 判断是否存在
+	 * for [QQYUN-10990]AIRAG
+	 * @param obj
+	 * @param objs
+	 * @param <T>
+	 * @return
+	 * @author chenrui
+	 * @date 2020/9/12 15:50
+	 */
+	public static <T> boolean isIn(T obj, T... objs) {
+		if (isEmpty(objs)) {
+			return false;
+		}
+		for (T obj1 : objs) {
+			if (isEqual(obj, obj1)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * 判断租户ID是否有效
+	 * @param tenantId
+	 * @return
+	 */
+	public static boolean isEffectiveTenant(String tenantId) {
+		return MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL && isNotEmpty(tenantId) && !("0").equals(tenantId);
+	}
 	
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/oss/OssBootUtil.java

@@ -97,9 +97,8 @@ public class OssBootUtil {
      * @return oss 中的相对文件路径
      */
     public static String upload(MultipartFile file, String fileDir,String customBucket) throws Exception {
-        //update-begin-author:liusq date:20210809 for: 过滤上传文件类型
+        // 文件安全校验，防止上传漏洞文件
         SsrfFileTypeFilter.checkUploadFileType(file);
-        //update-end-author:liusq date:20210809 for: 过滤上传文件类型
 
         String filePath = null;
         initOss(endPoint, accessKeyId, accessKeySecret);

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/security/AbstractQueryBlackListHandler.java

@@ -3,6 +3,8 @@ package org.jeecg.common.util.security;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang.StringUtils;
 import org.jeecg.common.exception.JeecgSqlInjectionException;
+import org.jeecg.common.util.SqlInjectionUtil;
+import org.jeecg.common.util.oConvertUtils;
 
 import java.util.*;
 import java.util.regex.Matcher;
@@ -66,6 +68,8 @@ public abstract class AbstractQueryBlackListHandler {
         if(flag == false){
             return false;
         }
+        Set<String> xssTableSet = new HashSet<>(Arrays.asList(SqlInjectionUtil.XSS_STR_TABLE.split("\\|")));
+
         for (QueryTable table : list) {
             String name = table.getName();
             String fieldRule = ruleMap.get(name);
@@ -81,6 +85,16 @@ public abstract class AbstractQueryBlackListHandler {
                 }
 
             }
+            // 判断是否调用了黑名单数据库
+            String dbName = table.getDbName();
+            if (oConvertUtils.isNotEmpty(dbName)) {
+                dbName = dbName.toLowerCase().trim();
+                if (xssTableSet.contains(dbName)) {
+                    flag = false;
+                    log.warn("sql黑名单校验，数据库【" + dbName + "】禁止查询");
+                    break;
+                }
+            }
         }
 
         // 返回黑名单校验结果（不合法直接抛出异常）
@@ -135,6 +149,8 @@ public abstract class AbstractQueryBlackListHandler {
      * 查询的表的信息
      */
     protected class QueryTable {
+        //数据库名
+        private String dbName;
         //表名
         private String name;
         //表的别名
@@ -158,6 +174,14 @@ public abstract class AbstractQueryBlackListHandler {
             this.fields.add(field);
         }
 
+        public String getDbName() {
+            return dbName;
+        }
+
+        public void setDbName(String dbName) {
+            this.dbName = dbName;
+        }
+
         public String getName() {
             return name;
         }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlInjection/InjectionAstNodeVisitor.java

@@ -1,33 +0,0 @@
-package org.jeecg.common.util.sqlInjection;
-
-import net.sf.jsqlparser.parser.CCJSqlParserDefaultVisitor;
-import net.sf.jsqlparser.parser.SimpleNode;
-import net.sf.jsqlparser.statement.select.UnionOp;
-import org.jeecg.common.exception.JeecgSqlInjectionException;
-
-/**
- * 基于抽象语法树(AST)的注入攻击分析实现
- *
- * @author guyadong
- */
-public class InjectionAstNodeVisitor extends CCJSqlParserDefaultVisitor {
-    public InjectionAstNodeVisitor() {
-    }
-
-    /**
-     * 处理禁止联合查询
-     *
-     * @param node
-     * @param data
-     * @return
-     */
-    @Override
-    public Object visit(SimpleNode node, Object data) {
-        Object value = node.jjtGetValue();
-        if (value instanceof UnionOp) {
-            throw new JeecgSqlInjectionException("DISABLE UNION");
-        }
-        return super.visit(node, data);
-    }
-}
-

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlInjection/InjectionSyntaxObjectAnalyzer.java

@@ -1,172 +0,0 @@
-package org.jeecg.common.util.sqlInjection;
-
-
-import net.sf.jsqlparser.expression.BinaryExpression;
-import net.sf.jsqlparser.expression.Expression;
-import net.sf.jsqlparser.expression.Function;
-import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
-import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
-import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
-import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.statement.select.Join;
-import net.sf.jsqlparser.statement.select.OrderByElement;
-import net.sf.jsqlparser.statement.select.PlainSelect;
-import net.sf.jsqlparser.statement.select.SelectItem;
-import net.sf.jsqlparser.statement.select.SubSelect;
-import net.sf.jsqlparser.statement.select.WithItem;
-import net.sf.jsqlparser.util.TablesNamesFinder;
-import org.jeecg.common.exception.JeecgSqlInjectionException;
-import org.jeecg.common.util.sqlInjection.parse.ConstAnalyzer;
-import org.jeecg.common.util.sqlInjection.parse.ParserSupport;
-
-/**
- * 基于SQL语法对象的SQL注入攻击分析实现
- *
- * @author guyadong
- */
-public class InjectionSyntaxObjectAnalyzer extends TablesNamesFinder {
-    /**
-     * 危险函数名
-     */
-    private static final String DANGROUS_FUNCTIONS = "(sleep|benchmark|extractvalue|updatexml|ST_LatFromGeoHash|ST_LongFromGeoHash|GTID_SUBSET|GTID_SUBTRACT|floor|ST_Pointfromgeohash"
-            + "|geometrycollection|multipoint|polygon|multipolygon|linestring|multilinestring)";
-
-    private static ThreadLocal<Boolean> disableSubselect = new ThreadLocal<Boolean>() {
-        @Override
-        protected Boolean initialValue() {
-            return true;
-        }
-    };
-    private ConstAnalyzer constAnalyzer = new ConstAnalyzer();
-
-    public InjectionSyntaxObjectAnalyzer() {
-        super();
-        init(true);
-
-    }
-
-    @Override
-    public void visitBinaryExpression(BinaryExpression binaryExpression) {
-        if (binaryExpression instanceof ComparisonOperator) {
-            if (isConst(binaryExpression.getLeftExpression()) && isConst(binaryExpression.getRightExpression())) {
-                /** 禁用恒等式 */
-                throw new JeecgSqlInjectionException("DISABLE IDENTICAL EQUATION " + binaryExpression);
-            }
-        }
-        super.visitBinaryExpression(binaryExpression);
-    }
-
-    @Override
-    public void visit(AndExpression andExpression) {
-        super.visit(andExpression);
-        checkConstExpress(andExpression.getLeftExpression());
-        checkConstExpress(andExpression.getRightExpression());
-    }
-
-    @Override
-    public void visit(OrExpression orExpression) {
-        super.visit(orExpression);
-        checkConstExpress(orExpression.getLeftExpression());
-        checkConstExpress(orExpression.getRightExpression());
-    }
-
-    @Override
-    public void visit(Function function) {
-        if (function.getName().matches(DANGROUS_FUNCTIONS)) {
-            /** 禁用危险函数 */
-            throw new JeecgSqlInjectionException("DANGROUS FUNCTION: " + function.getName());
-        }
-        super.visit(function);
-    }
-
-    @Override
-    public void visit(WithItem withItem) {
-        try {
-            /** 允许 WITH 语句中的子查询 */
-            disableSubselect.set(false);
-            super.visit(withItem);
-        } finally {
-            disableSubselect.set(true);
-        }
-    }
-
-    @Override
-    public void visit(SubSelect subSelect) {
-        try {
-            /** 允许语句中的子查询 */
-            disableSubselect.set(false);
-            super.visit(subSelect);
-        } finally {
-            disableSubselect.set(true);
-        }
-//        if (disableSubselect.get()) {
-//            // 禁用子查询
-//            throw new JeecgSqlInjectionException("DISABLE subselect " + subSelect);
-//        }
-    }
-
-    @Override
-    public void visit(Column tableColumn) {
-        if (ParserSupport.isBoolean(tableColumn)) {
-            throw new JeecgSqlInjectionException("DISABLE CONST BOOL " + tableColumn);
-        }
-        super.visit(tableColumn);
-    }
-
-    @Override
-    public void visit(PlainSelect plainSelect) {
-        if (plainSelect.getSelectItems() != null) {
-            for (SelectItem item : plainSelect.getSelectItems()) {
-                item.accept(this);
-            }
-        }
-
-        if (plainSelect.getFromItem() != null) {
-            plainSelect.getFromItem().accept(this);
-        }
-
-        if (plainSelect.getJoins() != null) {
-            for (Join join : plainSelect.getJoins()) {
-                join.getRightItem().accept(this);
-                for (Expression e : join.getOnExpressions()) {
-                    e.accept(this);
-                }
-            }
-        }
-        if (plainSelect.getWhere() != null) {
-            plainSelect.getWhere().accept(this);
-            checkConstExpress(plainSelect.getWhere());
-        }
-
-        if (plainSelect.getHaving() != null) {
-            plainSelect.getHaving().accept(this);
-        }
-
-        if (plainSelect.getOracleHierarchical() != null) {
-            plainSelect.getOracleHierarchical().accept(this);
-        }
-        if (plainSelect.getOrderByElements() != null) {
-            for (OrderByElement orderByElement : plainSelect.getOrderByElements()) {
-                orderByElement.getExpression().accept(this);
-            }
-        }
-        if (plainSelect.getGroupBy() != null) {
-            for (Expression expression : plainSelect.getGroupBy().getGroupByExpressionList().getExpressions()) {
-                expression.accept(this);
-            }
-        }
-    }
-
-    private boolean isConst(Expression expression) {
-        return constAnalyzer.isConstExpression(expression);
-    }
-
-    private void checkConstExpress(Expression expression) {
-        if (constAnalyzer.isConstExpression(expression)) {
-            /** 禁用常量表达式 */
-            throw new JeecgSqlInjectionException("DISABLE CONST EXPRESSION " + expression);
-        }
-    }
-}
-
-

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlInjection/SqlInjectionAnalyzer.java

@@ -1,65 +0,0 @@
-package org.jeecg.common.util.sqlInjection;
-
-import org.jeecg.common.exception.JeecgSqlInjectionException;
-import org.jeecg.common.util.sqlInjection.parse.ParserSupport;
-;
-
-/**
- * SQL注入攻击分析器
- *
- * @author guyadong
- * 参考:
- * https://blog.csdn.net/10km/article/details/127767358
- * https://gitee.com/l0km/sql2java/tree/dev/sql2java-manager/src/main/java/gu/sql2java/parser
- */
-public class SqlInjectionAnalyzer {
-
-    //启用/关闭注入攻击检查
-    private boolean injectCheckEnable = true;
-    //防止SQL注入攻击分析实现
-    private final InjectionSyntaxObjectAnalyzer injectionChecker;
-    private final InjectionAstNodeVisitor injectionVisitor;
-
-    public SqlInjectionAnalyzer() {
-        this.injectionChecker = new InjectionSyntaxObjectAnalyzer();
-        this.injectionVisitor = new InjectionAstNodeVisitor();
-    }
-
-    /**
-     * 启用/关闭注入攻击检查,默认启动
-     *
-     * @param enable
-     * @return
-     */
-    public SqlInjectionAnalyzer injectCheckEnable(boolean enable) {
-        injectCheckEnable = enable;
-        return this;
-    }
-
-    /**
-     * 对解析后的SQL对象执行注入攻击分析，有注入攻击的危险则抛出异常{@link JeecgSqlInjectionException}
-     *
-     * @param sqlParserInfo
-     * @throws JeecgSqlInjectionException
-     */
-    public ParserSupport.SqlParserInfo injectAnalyse(ParserSupport.SqlParserInfo sqlParserInfo) throws JeecgSqlInjectionException {
-        if (null != sqlParserInfo && injectCheckEnable) {
-            /** SQL注入攻击检查 */
-            sqlParserInfo.statement.accept(injectionChecker);
-            sqlParserInfo.simpleNode.jjtAccept(injectionVisitor, null);
-        }
-        return sqlParserInfo;
-    }
-
-    /**
-     * sql校验
-     */
-    public static void checkSql(String sql,boolean check){
-        SqlInjectionAnalyzer sqlInjectionAnalyzer = new SqlInjectionAnalyzer();
-        sqlInjectionAnalyzer.injectCheckEnable(check);
-        ParserSupport.SqlParserInfo sqlParserInfo = ParserSupport.parse0(sql, null,null);
-        sqlInjectionAnalyzer.injectAnalyse(sqlParserInfo);
-    }
-}
-
-

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlInjection/parse/ConstAnalyzer.java

@@ -1,569 +0,0 @@
-package org.jeecg.common.util.sqlInjection.parse;
-
-import net.sf.jsqlparser.expression.*;
-import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
-import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd;
-import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseLeftShift;
-import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseOr;
-import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseRightShift;
-import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor;
-import net.sf.jsqlparser.expression.operators.arithmetic.Concat;
-import net.sf.jsqlparser.expression.operators.arithmetic.Division;
-import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision;
-import net.sf.jsqlparser.expression.operators.arithmetic.Modulo;
-import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication;
-import net.sf.jsqlparser.expression.operators.arithmetic.Subtraction;
-import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
-import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
-import net.sf.jsqlparser.expression.operators.conditional.XorExpression;
-import net.sf.jsqlparser.expression.operators.relational.Between;
-import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
-import net.sf.jsqlparser.expression.operators.relational.ExistsExpression;
-import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
-import net.sf.jsqlparser.expression.operators.relational.FullTextSearch;
-import net.sf.jsqlparser.expression.operators.relational.GeometryDistance;
-import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
-import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
-import net.sf.jsqlparser.expression.operators.relational.InExpression;
-import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression;
-import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression;
-import net.sf.jsqlparser.expression.operators.relational.IsNullExpression;
-import net.sf.jsqlparser.expression.operators.relational.ItemsListVisitor;
-import net.sf.jsqlparser.expression.operators.relational.JsonOperator;
-import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
-import net.sf.jsqlparser.expression.operators.relational.Matches;
-import net.sf.jsqlparser.expression.operators.relational.MinorThan;
-import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
-import net.sf.jsqlparser.expression.operators.relational.MultiExpressionList;
-import net.sf.jsqlparser.expression.operators.relational.NamedExpressionList;
-import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
-import net.sf.jsqlparser.expression.operators.relational.RegExpMatchOperator;
-import net.sf.jsqlparser.expression.operators.relational.RegExpMySQLOperator;
-import net.sf.jsqlparser.expression.operators.relational.SimilarToExpression;
-import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.statement.select.AllColumns;
-import net.sf.jsqlparser.statement.select.AllTableColumns;
-import net.sf.jsqlparser.statement.select.OrderByElement;
-import net.sf.jsqlparser.statement.select.SubSelect;
-
-/**
- * 判断表达是否为常量的分析器
- *
- * @author guyadong
- */
-public class ConstAnalyzer implements ExpressionVisitor, ItemsListVisitor {
-
-    private static ThreadLocal<Boolean> constFlag = new ThreadLocal<Boolean>() {
-        @Override
-        protected Boolean initialValue() {
-            return true;
-        }
-    };
-
-    @Override
-    public void visit(NullValue value) {
-    }
-
-    @Override
-    public void visit(Function function) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(SignedExpression expr) {
-        expr.getExpression().accept(this);
-    }
-
-    @Override
-    public void visit(JdbcParameter parameter) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(JdbcNamedParameter parameter) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(DoubleValue value) {
-
-    }
-
-    @Override
-    public void visit(LongValue value) {
-
-    }
-
-    @Override
-    public void visit(DateValue value) {
-
-    }
-
-    @Override
-    public void visit(TimeValue value) {
-
-    }
-
-    @Override
-    public void visit(TimestampValue value) {
-
-    }
-
-    @Override
-    public void visit(Parenthesis parenthesis) {
-        parenthesis.getExpression().accept(this);
-    }
-
-    @Override
-    public void visit(StringValue value) {
-
-    }
-
-    @Override
-    public void visit(Addition expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(Division expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(IntegerDivision expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(Multiplication expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(Subtraction expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(AndExpression expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(OrExpression expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(XorExpression expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(Between expr) {
-        expr.getLeftExpression().accept(this);
-        expr.getBetweenExpressionStart().accept(this);
-        expr.getBetweenExpressionEnd().accept(this);
-    }
-
-    /**
-     * 用于处理 OverlapsCondition 类型的表达式
-     * @param overlapsCondition
-     */
-    @Override
-    public void visit(OverlapsCondition overlapsCondition) {
-        constFlag.set(false);
-    }
-    /**
-     * 用于处理 SafeCastExpression 类型的表达式。
-     * @param safeCastExpression
-     */
-    @Override
-    public void visit(SafeCastExpression safeCastExpression) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(EqualsTo expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(GreaterThan expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(GreaterThanEquals expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(InExpression expr) {
-        if (expr.getLeftExpression() != null) {
-            expr.getLeftExpression().accept(this);
-        }
-    }
-
-    @Override
-    public void visit(IsNullExpression expr) {
-        expr.getLeftExpression().accept(this);
-    }
-
-    @Override
-    public void visit(FullTextSearch expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(IsBooleanExpression expr) {
-        expr.getLeftExpression().accept(this);
-    }
-
-    @Override
-    public void visit(LikeExpression expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(MinorThan expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(MinorThanEquals expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(NotEqualsTo expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(Column column) {
-        if (!ParserSupport.isBoolean(column)) {
-            constFlag.set(false);
-        }
-    }
-
-    @Override
-    public void visit(SubSelect subSelect) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(CaseExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(WhenClause expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(ExistsExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(AnyComparisonExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(Concat expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(Matches expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(BitwiseAnd expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(BitwiseOr expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(BitwiseXor expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(CastExpression expr) {
-        expr.getLeftExpression().accept(this);
-    }
-
-    @Override
-    public void visit(TryCastExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(Modulo expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(AnalyticExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(ExtractExpression expr) {
-        expr.getExpression().accept(this);
-    }
-
-    @Override
-    public void visit(IntervalExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(OracleHierarchicalExpression expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(RegExpMatchOperator expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(ExpressionList expressionList) {
-        for (Expression expr : expressionList.getExpressions()) {
-            expr.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(NamedExpressionList namedExpressionList) {
-        for (Expression expr : namedExpressionList.getExpressions()) {
-            expr.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(MultiExpressionList multiExprList) {
-        for (ExpressionList list : multiExprList.getExpressionLists()) {
-            visit(list);
-        }
-    }
-
-    @Override
-    public void visit(NotExpression notExpr) {
-        notExpr.getExpression().accept(this);
-    }
-
-    @Override
-    public void visit(BitwiseRightShift expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(BitwiseLeftShift expr) {
-        visitBinaryExpression(expr);
-    }
-
-    protected void visitBinaryExpression(BinaryExpression expr) {
-        expr.getLeftExpression().accept(this);
-        expr.getRightExpression().accept(this);
-    }
-
-    @Override
-    public void visit(JsonExpression jsonExpr) {
-        jsonExpr.getExpression().accept(this);
-    }
-
-    @Override
-    public void visit(JsonOperator expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(RegExpMySQLOperator expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(UserVariable var) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(NumericBind bind) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(KeepExpression expr) {
-        for (OrderByElement element : expr.getOrderByElements()) {
-            element.getExpression().accept(this);
-        }
-    }
-
-    @Override
-    public void visit(MySQLGroupConcat groupConcat) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(ValueListExpression valueListExpression) {
-        for (Expression expr : valueListExpression.getExpressionList().getExpressions()) {
-            expr.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(AllColumns allColumns) {
-
-    }
-
-    @Override
-    public void visit(AllTableColumns allTableColumns) {
-
-    }
-
-    @Override
-    public void visit(AllValue allValue) {
-
-    }
-
-    @Override
-    public void visit(IsDistinctExpression isDistinctExpression) {
-        visitBinaryExpression(isDistinctExpression);
-    }
-
-    @Override
-    public void visit(RowGetExpression rowGetExpression) {
-        rowGetExpression.getExpression().accept(this);
-    }
-
-    @Override
-    public void visit(HexValue hexValue) {
-
-    }
-
-    @Override
-    public void visit(OracleHint hint) {
-
-    }
-
-    @Override
-    public void visit(TimeKeyExpression timeKeyExpression) {
-
-    }
-
-    @Override
-    public void visit(DateTimeLiteralExpression literal) {
-    }
-
-    @Override
-    public void visit(NextValExpression nextVal) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(CollateExpression col) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(SimilarToExpression expr) {
-        visitBinaryExpression(expr);
-    }
-
-    @Override
-    public void visit(ArrayExpression array) {
-        array.getObjExpression().accept(this);
-        if (array.getIndexExpression() != null) {
-            array.getIndexExpression().accept(this);
-        }
-        if (array.getStartIndexExpression() != null) {
-            array.getStartIndexExpression().accept(this);
-        }
-        if (array.getStopIndexExpression() != null) {
-            array.getStopIndexExpression().accept(this);
-        }
-    }
-
-    @Override
-    public void visit(ArrayConstructor aThis) {
-        for (Expression expression : aThis.getExpressions()) {
-            expression.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(VariableAssignment var) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(XMLSerializeExpr expr) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(TimezoneExpression expr) {
-        expr.getLeftExpression().accept(this);
-    }
-
-    @Override
-    public void visit(JsonAggregateFunction expression) {
-        Expression expr = expression.getExpression();
-        if (expr != null) {
-            expr.accept(this);
-        }
-
-        expr = expression.getFilterExpression();
-        if (expr != null) {
-            expr.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(JsonFunction expression) {
-        for (JsonFunctionExpression expr : expression.getExpressions()) {
-            expr.getExpression().accept(this);
-        }
-    }
-
-    @Override
-    public void visit(ConnectByRootOperator connectByRootOperator) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(OracleNamedFunctionParameter oracleNamedFunctionParameter) {
-        constFlag.set(false);
-    }
-
-    @Override
-    public void visit(GeometryDistance geometryDistance) {
-        visitBinaryExpression(geometryDistance);
-    }
-
-    @Override
-    public void visit(RowConstructor rowConstructor) {
-        constFlag.set(false);
-    }
-
-    public boolean isConstExpression(Expression expression) {
-        if (null != expression) {
-            constFlag.set(true);
-            expression.accept(this);
-            return constFlag.get();
-        }
-        return false;
-    }
-}
-

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlInjection/parse/ParserSupport.java

@@ -1,177 +0,0 @@
-package org.jeecg.common.util.sqlInjection.parse;
-
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.JSQLParserException;
-import net.sf.jsqlparser.parser.*;
-import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.statement.Statement;
-import net.sf.jsqlparser.statement.select.PlainSelect;
-import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectBody;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import com.google.common.base.Throwables;
-import org.jeecg.common.exception.JeecgBootException;
-import org.jeecg.common.exception.JeecgSqlInjectionException;
-
-/**
- * 解析sql支持
- */
-@Slf4j
-public class ParserSupport {
-    /**
-     * 解析SELECT SQL语句,解析失败或非SELECT语句则抛出异常
-     *
-     * @param sql
-     * @return
-     */
-    public static Select parseSelect(String sql) {
-        Statement stmt;
-        try {
-            stmt = CCJSqlParserUtil.parse(checkNotNull(sql, "sql is null"));
-        } catch (JSQLParserException e) {
-            throw new JeecgBootException(e);
-        }
-        checkArgument(stmt instanceof Select, "%s is not  SELECT statment", sql);
-        Select select = (Select) stmt;
-        SelectBody selectBody = select.getSelectBody();
-        // 暂时只支持简单的SELECT xxxx FROM ....语句不支持复杂语句如WITH
-        checkArgument(selectBody instanceof PlainSelect, "ONLY SUPPORT plain select statement %s", sql);
-        return (Select) stmt;
-    }
-
-    /**
-     * 解析SELECT SQL语句,解析失败或非SELECT语句则
-     *
-     * @param sql
-     * @return
-     */
-    public static Select parseSelectUnchecked(String sql) {
-        try {
-            return parseSelect(sql);
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    /**
-     * 实现SQL语句解析,解析成功则返回解析后的{@link Statement}，
-     * 并通过{@code visitor}参数提供基于AST(抽象语法树)的遍历所有节点的能力。
-     *
-     * @param sql                 SQL语句
-     * @param visitor             遍历所有节点的{@link SimpleNodeVisitor}接口实例，为{@code null}忽略
-     * @param sqlSyntaxNormalizer SQL语句分析转换器，为{@code null}忽略
-     * @throws JSQLParserException 输入的SQL语句有语法错误
-     * @see #parse0(String, CCJSqlParserVisitor, SqlSyntaxNormalizer)
-     */
-    public static Statement parse(String sql, CCJSqlParserVisitor visitor, SqlSyntaxNormalizer sqlSyntaxNormalizer) throws JSQLParserException {
-        return parse0(sql, visitor, sqlSyntaxNormalizer).statement;
-    }
-
-    /**
-     * 参照{@link CCJSqlParserUtil#parseAST(String)}和{@link CCJSqlParserUtil#parse(String)}实现SQL语句解析,
-     * 解析成功则返回解析后的{@link SqlParserInfo}对象，
-     * 并通过{@code visitor}参数提供基于AST(抽象语法树)的遍历所有节点的能力。
-     *
-     * @param sql               SQL语句
-     * @param visitor           遍历所有节点的{@link SimpleNodeVisitor}接口实例，为{@code null}忽略
-     * @param sqlSyntaxAnalyzer SQL语句分析转换器，为{@code null}忽略
-     * @throws JSQLParserException 输入的SQL语句有语法错误
-     * @see net.sf.jsqlparser.parser.Node#jjtAccept(SimpleNodeVisitor, Object)
-     */
-    public static SqlParserInfo parse0(String sql, CCJSqlParserVisitor visitor, SqlSyntaxNormalizer sqlSyntaxAnalyzer) throws JeecgSqlInjectionException {
-
-        //检查是否非select开头，暂不支持
-        if(!sql.toLowerCase().trim().startsWith("select ")) {
-            log.warn("传入sql 非select开头，不支持非select开头的语句解析！");
-            return null;
-        }
-
-        //检查是否存储过程，暂不支持
-        if(sql.toLowerCase().trim().startsWith("call ")){
-            log.warn("传入call 开头存储过程，不支持存储过程解析！");
-            return null;
-        }
-
-        //检查特殊语义的特殊字符，目前检查冒号、$、#三种特殊语义字符
-        String specialCharacters = "[:$#]";
-        Pattern pattern = Pattern.compile(specialCharacters);
-        Matcher matcher = pattern.matcher(sql);
-        if (matcher.find()) {
-            sql = sql.replaceAll("[:$#]", "@");
-        }
-
-        checkArgument(null != sql, "sql is null");
-        boolean allowComplexParsing = CCJSqlParserUtil.getNestingDepth(sql) <= CCJSqlParserUtil.ALLOWED_NESTING_DEPTH;
-
-        CCJSqlParser parser = CCJSqlParserUtil.newParser(sql).withAllowComplexParsing(allowComplexParsing);
-        Statement stmt;
-        try {
-            stmt = parser.Statement();
-        } catch (Exception ex) {
-            log.error("请注意，SQL语法可能存在问题---> {}", ex.getMessage());
-            throw new JeecgSqlInjectionException("请注意，SQL语法可能存在问题:"+sql);
-        }
-        if (null != visitor) {
-            parser.getASTRoot().jjtAccept(visitor, null);
-        }
-        if (null != sqlSyntaxAnalyzer) {
-            stmt.accept(sqlSyntaxAnalyzer.resetChanged());
-        }
-        return new SqlParserInfo(stmt.toString(), stmt, (SimpleNode) parser.getASTRoot());
-    }
-
-    /**
-     * 调用{@link CCJSqlParser}解析SQL语句部件返回解析生成的对象,如{@code 'ORDER BY id DESC'}
-     *
-     * @param <T>
-     * @param input
-     * @param method     指定调用的{@link CCJSqlParser}解析方法
-     * @param targetType 返回的解析对象类型
-     * @return
-     * @since 3.18.3
-     */
-    public static <T> T parseComponent(String input, String method, Class<T> targetType) {
-        try {
-            CCJSqlParser parser = new CCJSqlParser(new StringProvider(input));
-            try {
-                return checkNotNull(targetType, "targetType is null").cast(parser.getClass().getMethod(method).invoke(parser));
-            } catch (InvocationTargetException e) {
-                Throwables.throwIfUnchecked(e.getTargetException());
-                throw new RuntimeException(e.getTargetException());
-            }
-        } catch (IllegalAccessException | NoSuchMethodException | SecurityException e) {
-            Throwables.throwIfUnchecked(e);
-            throw new RuntimeException(e);
-        }
-    }
-
-    /**
-     * 如果{@link Column}没有定义table,且字段名为true/false(不区分大小写)则视为布尔常量
-     *
-     * @param column
-     */
-    public static boolean isBoolean(Column column) {
-        return null != column && null == column.getTable() &&
-                Pattern.compile("(true|false)", Pattern.CASE_INSENSITIVE).matcher(column.getColumnName()).matches();
-    }
-
-    public static class SqlParserInfo {
-        public String nativeSql;
-        public Statement statement;
-        public SimpleNode simpleNode;
-
-        SqlParserInfo(String nativeSql, Statement statement, SimpleNode simpleNode) {
-            this.nativeSql = nativeSql;
-            this.statement = statement;
-            this.simpleNode = simpleNode;
-        }
-    }
-}
-

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlInjection/parse/SqlSyntaxNormalizer.java

@@ -1,37 +0,0 @@
-package org.jeecg.common.util.sqlInjection.parse;
-
-import net.sf.jsqlparser.util.TablesNamesFinder;
-
-/**
- *  SQL语句分析转换器基类<br>
- * 基于SQL语法对象实现对SQL的修改
- * （暂时用不到）
- *
- * @author guyadong
- * @since 3.17.0
- */
-public class SqlSyntaxNormalizer extends TablesNamesFinder {
-    protected static final ThreadLocal<Boolean> changed = new ThreadLocal<>();
-
-    public SqlSyntaxNormalizer() {
-        super();
-        init(true);
-
-    }
-
-    /**
-     * 语句改变返回{@code true},否则返回{@code false}
-     */
-    public boolean changed() {
-        return Boolean.TRUE.equals(changed.get());
-    }
-
-    /**
-     * 复位线程局部变量{@link #changed}状态
-     */
-    public SqlSyntaxNormalizer resetChanged() {
-        changed.remove();
-        return this;
-    }
-}
-

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlparse/JSqlParserAllTableManager.java

@@ -1,255 +1,255 @@
-package org.jeecg.common.util.sqlparse;
-
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.JSQLParserException;
-import net.sf.jsqlparser.expression.*;
-import net.sf.jsqlparser.parser.CCJSqlParserManager;
-import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.schema.Table;
-import net.sf.jsqlparser.statement.Statement;
-import net.sf.jsqlparser.statement.select.*;
-import org.jeecg.common.exception.JeecgBootException;
-import org.jeecg.common.util.sqlparse.vo.SelectSqlInfo;
-
-import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 解析所有表名和字段的类
- */
-@Slf4j
-public class JSqlParserAllTableManager {
-
-    private final String sql;
-    private final Map<String, SelectSqlInfo> allTableMap = new HashMap<>();
-    /**
-     * 别名对应实际表名
-     */
-    private final Map<String, String> tableAliasMap = new HashMap<>();
-
-    /**
-     * 解析后的sql
-     */
-    private String parsedSql = null;
-
-    JSqlParserAllTableManager(String selectSql) {
-        this.sql = selectSql;
-    }
-
-    /**
-     * 开始解析
-     *
-     * @return
-     * @throws JSQLParserException
-     */
-    public Map<String, SelectSqlInfo> parse() throws JSQLParserException {
-        // 1. 创建解析器
-        CCJSqlParserManager mgr = new CCJSqlParserManager();
-        // 2. 使用解析器解析sql生成具有层次结构的java类
-        Statement stmt = mgr.parse(new StringReader(this.sql));
-        if (stmt instanceof Select) {
-            Select selectStatement = (Select) stmt;
-            SelectBody selectBody = selectStatement.getSelectBody();
-            this.parsedSql = selectBody.toString();
-            // 3. 解析select查询sql的信息
-            if (selectBody instanceof PlainSelect) {
-                PlainSelect plainSelect = (PlainSelect) selectBody;
-                // 4. 合并 fromItems
-                List<FromItem> fromItems = new ArrayList<>();
-                fromItems.add(plainSelect.getFromItem());
-                // 4.1 处理join的表
-                List<Join> joins = plainSelect.getJoins();
-                if (joins != null) {
-                    joins.forEach(join -> fromItems.add(join.getRightItem()));
-                }
-                // 5. 处理 fromItems
-                for (FromItem fromItem : fromItems) {
-                    // 5.1 通过表名的方式from
-                    if (fromItem instanceof Table) {
-                        this.addSqlInfoByTable((Table) fromItem);
-                    }
-                    // 5.2 通过子查询的方式from
-                    else if (fromItem instanceof SubSelect) {
-                        this.handleSubSelect((SubSelect) fromItem);
-                    }
-                }
-                // 6. 解析 selectFields
-                List<SelectItem> selectItems = plainSelect.getSelectItems();
-                for (SelectItem selectItem : selectItems) {
-                    // 6.1 查询的是全部字段
-                    if (selectItem instanceof AllColumns) {
-                        // 当 selectItem 为 AllColumns 时，fromItem 必定为 Table
-                        String tableName = plainSelect.getFromItem(Table.class).getName();
-                        // 此处必定不为空，因为在解析 fromItem 时，已经将表名添加到 allTableMap 中
-                        SelectSqlInfo sqlInfo = this.allTableMap.get(tableName);
-                        assert sqlInfo != null;
-                        // 设置为查询全部字段
-                        sqlInfo.setSelectAll(true);
-                        sqlInfo.setSelectFields(null);
-                        sqlInfo.setRealSelectFields(null);
-                    }
-                    // 6.2 查询的是带表别名（ u.* )的全部字段
-                    else if (selectItem instanceof AllTableColumns) {
-                        AllTableColumns allTableColumns = (AllTableColumns) selectItem;
-                        String aliasName = allTableColumns.getTable().getName();
-                        // 通过别名获取表名
-                        String tableName = this.tableAliasMap.get(aliasName);
-                        if (tableName == null) {
-                            tableName = aliasName;
-                        }
-                        SelectSqlInfo sqlInfo = this.allTableMap.get(tableName);
-                        // 如果此处为空，则说明该字段是通过子查询获取的，所以可以不处理，只有实际表才需要处理
-                        if (sqlInfo != null) {
-                            // 设置为查询全部字段
-                            sqlInfo.setSelectAll(true);
-                            sqlInfo.setSelectFields(null);
-                            sqlInfo.setRealSelectFields(null);
-                        }
-                    }
-                    // 6.3 各种字段表达式处理
-                    else if (selectItem instanceof SelectExpressionItem) {
-                        SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
-                        Expression expression = selectExpressionItem.getExpression();
-                        Alias alias = selectExpressionItem.getAlias();
-                        this.handleExpression(expression, alias, plainSelect.getFromItem());
-                    }
-                }
-            } else {
-                log.warn("暂时尚未处理该类型的 SelectBody: {}", selectBody.getClass().getName());
-                throw new JeecgBootException("暂时尚未处理该类型的 SelectBody");
-            }
-        } else {
-            // 非 select 查询sql，不做处理
-            throw new JeecgBootException("非 select 查询sql，不做处理");
-        }
-        return this.allTableMap;
-    }
-
-    /**
-     * 处理子查询
-     *
-     * @param subSelect
-     */
-    private void handleSubSelect(SubSelect subSelect) {
-        try {
-            String subSelectSql = subSelect.getSelectBody().toString();
-            // 递归调用解析
-            Map<String, SelectSqlInfo> map = JSqlParserUtils.parseAllSelectTable(subSelectSql);
-            if (map != null) {
-                this.assignMap(map);
-            }
-        } catch (Exception e) {
-            log.error("解析子查询出错", e);
-        }
-    }
-
-    /**
-     * 处理查询字段表达式
-     *
-     * @param expression
-     */
-    private void handleExpression(Expression expression, Alias alias, FromItem fromItem) {
-        // 处理函数式字段  CONCAT(name,'(',age,')')
-        if (expression instanceof Function) {
-            Function functionExp = (Function) expression;
-            List<Expression> expressions = functionExp.getParameters().getExpressions();
-            for (Expression expItem : expressions) {
-                this.handleExpression(expItem, null, fromItem);
-            }
-            return;
-        }
-        // 处理字段上的子查询
-        if (expression instanceof SubSelect) {
-            this.handleSubSelect((SubSelect) expression);
-            return;
-        }
-        // 不处理字面量
-        if (expression instanceof StringValue ||
-                expression instanceof NullValue ||
-                expression instanceof LongValue ||
-                expression instanceof DoubleValue ||
-                expression instanceof HexValue ||
-                expression instanceof DateValue ||
-                expression instanceof TimestampValue ||
-                expression instanceof TimeValue
-        ) {
-            return;
-        }
-
-        // 处理字段
-        if (expression instanceof Column) {
-            Column column = (Column) expression;
-            // 查询字段名
-            String fieldName = column.getColumnName();
-            String aliasName = fieldName;
-            if (alias != null) {
-                aliasName = alias.getName();
-            }
-            String tableName;
-            if (column.getTable() != null) {
-                // 通过列的表名获取 sqlInfo
-                // 例如 user.name，这里的 tableName 就是 user
-                tableName = column.getTable().getName();
-                // 有可能是别名，需要转换为真实表名
-                if (this.tableAliasMap.get(tableName) != null) {
-                    tableName = this.tableAliasMap.get(tableName);
-                }
-            } else {
-                // 当column的table为空时，说明是 fromItem 中的字段
-                tableName = ((Table) fromItem).getName();
-            }
-            SelectSqlInfo $sqlInfo = this.allTableMap.get(tableName);
-            if ($sqlInfo != null) {
-                $sqlInfo.addSelectField(aliasName, fieldName);
-            } else {
-                log.warn("发生意外情况，未找到表名为 {} 的 SelectSqlInfo", tableName);
-            }
-        }
-    }
-
-    /**
-     * 根据表名添加sqlInfo
-     *
-     * @param table
-     */
-    private void addSqlInfoByTable(Table table) {
-        String tableName = table.getName();
-        // 解析 aliasName
-        if (table.getAlias() != null) {
-            this.tableAliasMap.put(table.getAlias().getName(), tableName);
-        }
-        SelectSqlInfo sqlInfo = new SelectSqlInfo(this.parsedSql);
-        sqlInfo.setFromTableName(table.getName());
-        this.allTableMap.put(sqlInfo.getFromTableName(), sqlInfo);
-    }
-
-    /**
-     * 合并map
-     *
-     * @param source
-     */
-    private void assignMap(Map<String, SelectSqlInfo> source) {
-        for (Map.Entry<String, SelectSqlInfo> entry : source.entrySet()) {
-            SelectSqlInfo sqlInfo = this.allTableMap.get(entry.getKey());
-            if (sqlInfo == null) {
-                this.allTableMap.put(entry.getKey(), entry.getValue());
-            } else {
-                // 合并
-                if (sqlInfo.getSelectFields() == null) {
-                    sqlInfo.setSelectFields(entry.getValue().getSelectFields());
-                } else {
-                    sqlInfo.getSelectFields().addAll(entry.getValue().getSelectFields());
-                }
-                if (sqlInfo.getRealSelectFields() == null) {
-                    sqlInfo.setRealSelectFields(entry.getValue().getRealSelectFields());
-                } else {
-                    sqlInfo.getRealSelectFields().addAll(entry.getValue().getRealSelectFields());
-                }
-            }
-        }
-    }
-
-}
+//package org.jeecg.common.util.sqlparse;
+//
+//import lombok.extern.slf4j.Slf4j;
+//import net.sf.jsqlparser.JSQLParserException;
+//import net.sf.jsqlparser.expression.*;
+//import net.sf.jsqlparser.parser.CCJSqlParserManager;
+//import net.sf.jsqlparser.schema.Column;
+//import net.sf.jsqlparser.schema.Table;
+//import net.sf.jsqlparser.statement.Statement;
+//import net.sf.jsqlparser.statement.select.*;
+//import org.jeecg.common.exception.JeecgBootException;
+//import org.jeecg.common.util.sqlparse.vo.SelectSqlInfo;
+//
+//import java.io.StringReader;
+//import java.util.ArrayList;
+//import java.util.HashMap;
+//import java.util.List;
+//import java.util.Map;
+//
+///**
+// * 解析所有表名和字段的类
+// */
+//@Slf4j
+//public class JSqlParserAllTableManager {
+//
+//    private final String sql;
+//    private final Map<String, SelectSqlInfo> allTableMap = new HashMap<>();
+//    /**
+//     * 别名对应实际表名
+//     */
+//    private final Map<String, String> tableAliasMap = new HashMap<>();
+//
+//    /**
+//     * 解析后的sql
+//     */
+//    private String parsedSql = null;
+//
+//    JSqlParserAllTableManager(String selectSql) {
+//        this.sql = selectSql;
+//    }
+//
+//    /**
+//     * 开始解析
+//     *
+//     * @return
+//     * @throws JSQLParserException
+//     */
+//    public Map<String, SelectSqlInfo> parse() throws JSQLParserException {
+//        // 1. 创建解析器
+//        CCJSqlParserManager mgr = new CCJSqlParserManager();
+//        // 2. 使用解析器解析sql生成具有层次结构的java类
+//        Statement stmt = mgr.parse(new StringReader(this.sql));
+//        if (stmt instanceof Select) {
+//            Select selectStatement = (Select) stmt;
+//            SelectBody selectBody = selectStatement.getSelectBody();
+//            this.parsedSql = selectBody.toString();
+//            // 3. 解析select查询sql的信息
+//            if (selectBody instanceof PlainSelect) {
+//                PlainSelect plainSelect = (PlainSelect) selectBody;
+//                // 4. 合并 fromItems
+//                List<FromItem> fromItems = new ArrayList<>();
+//                fromItems.add(plainSelect.getFromItem());
+//                // 4.1 处理join的表
+//                List<Join> joins = plainSelect.getJoins();
+//                if (joins != null) {
+//                    joins.forEach(join -> fromItems.add(join.getRightItem()));
+//                }
+//                // 5. 处理 fromItems
+//                for (FromItem fromItem : fromItems) {
+//                    // 5.1 通过表名的方式from
+//                    if (fromItem instanceof Table) {
+//                        this.addSqlInfoByTable((Table) fromItem);
+//                    }
+//                    // 5.2 通过子查询的方式from
+//                    else if (fromItem instanceof SubSelect) {
+//                        this.handleSubSelect((SubSelect) fromItem);
+//                    }
+//                }
+//                // 6. 解析 selectFields
+//                List<SelectItem> selectItems = plainSelect.getSelectItems();
+//                for (SelectItem selectItem : selectItems) {
+//                    // 6.1 查询的是全部字段
+//                    if (selectItem instanceof AllColumns) {
+//                        // 当 selectItem 为 AllColumns 时，fromItem 必定为 Table
+//                        String tableName = plainSelect.getFromItem(Table.class).getName();
+//                        // 此处必定不为空，因为在解析 fromItem 时，已经将表名添加到 allTableMap 中
+//                        SelectSqlInfo sqlInfo = this.allTableMap.get(tableName);
+//                        assert sqlInfo != null;
+//                        // 设置为查询全部字段
+//                        sqlInfo.setSelectAll(true);
+//                        sqlInfo.setSelectFields(null);
+//                        sqlInfo.setRealSelectFields(null);
+//                    }
+//                    // 6.2 查询的是带表别名（ u.* )的全部字段
+//                    else if (selectItem instanceof AllTableColumns) {
+//                        AllTableColumns allTableColumns = (AllTableColumns) selectItem;
+//                        String aliasName = allTableColumns.getTable().getName();
+//                        // 通过别名获取表名
+//                        String tableName = this.tableAliasMap.get(aliasName);
+//                        if (tableName == null) {
+//                            tableName = aliasName;
+//                        }
+//                        SelectSqlInfo sqlInfo = this.allTableMap.get(tableName);
+//                        // 如果此处为空，则说明该字段是通过子查询获取的，所以可以不处理，只有实际表才需要处理
+//                        if (sqlInfo != null) {
+//                            // 设置为查询全部字段
+//                            sqlInfo.setSelectAll(true);
+//                            sqlInfo.setSelectFields(null);
+//                            sqlInfo.setRealSelectFields(null);
+//                        }
+//                    }
+//                    // 6.3 各种字段表达式处理
+//                    else if (selectItem instanceof SelectExpressionItem) {
+//                        SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
+//                        Expression expression = selectExpressionItem.getExpression();
+//                        Alias alias = selectExpressionItem.getAlias();
+//                        this.handleExpression(expression, alias, plainSelect.getFromItem());
+//                    }
+//                }
+//            } else {
+//                log.warn("暂时尚未处理该类型的 SelectBody: {}", selectBody.getClass().getName());
+//                throw new JeecgBootException("暂时尚未处理该类型的 SelectBody");
+//            }
+//        } else {
+//            // 非 select 查询sql，不做处理
+//            throw new JeecgBootException("非 select 查询sql，不做处理");
+//        }
+//        return this.allTableMap;
+//    }
+//
+//    /**
+//     * 处理子查询
+//     *
+//     * @param subSelect
+//     */
+//    private void handleSubSelect(SubSelect subSelect) {
+//        try {
+//            String subSelectSql = subSelect.getSelectBody().toString();
+//            // 递归调用解析
+//            Map<String, SelectSqlInfo> map = JSqlParserUtils.parseAllSelectTable(subSelectSql);
+//            if (map != null) {
+//                this.assignMap(map);
+//            }
+//        } catch (Exception e) {
+//            log.error("解析子查询出错", e);
+//        }
+//    }
+//
+//    /**
+//     * 处理查询字段表达式
+//     *
+//     * @param expression
+//     */
+//    private void handleExpression(Expression expression, Alias alias, FromItem fromItem) {
+//        // 处理函数式字段  CONCAT(name,'(',age,')')
+//        if (expression instanceof Function) {
+//            Function functionExp = (Function) expression;
+//            List<Expression> expressions = functionExp.getParameters().getExpressions();
+//            for (Expression expItem : expressions) {
+//                this.handleExpression(expItem, null, fromItem);
+//            }
+//            return;
+//        }
+//        // 处理字段上的子查询
+//        if (expression instanceof SubSelect) {
+//            this.handleSubSelect((SubSelect) expression);
+//            return;
+//        }
+//        // 不处理字面量
+//        if (expression instanceof StringValue ||
+//                expression instanceof NullValue ||
+//                expression instanceof LongValue ||
+//                expression instanceof DoubleValue ||
+//                expression instanceof HexValue ||
+//                expression instanceof DateValue ||
+//                expression instanceof TimestampValue ||
+//                expression instanceof TimeValue
+//        ) {
+//            return;
+//        }
+//
+//        // 处理字段
+//        if (expression instanceof Column) {
+//            Column column = (Column) expression;
+//            // 查询字段名
+//            String fieldName = column.getColumnName();
+//            String aliasName = fieldName;
+//            if (alias != null) {
+//                aliasName = alias.getName();
+//            }
+//            String tableName;
+//            if (column.getTable() != null) {
+//                // 通过列的表名获取 sqlInfo
+//                // 例如 user.name，这里的 tableName 就是 user
+//                tableName = column.getTable().getName();
+//                // 有可能是别名，需要转换为真实表名
+//                if (this.tableAliasMap.get(tableName) != null) {
+//                    tableName = this.tableAliasMap.get(tableName);
+//                }
+//            } else {
+//                // 当column的table为空时，说明是 fromItem 中的字段
+//                tableName = ((Table) fromItem).getName();
+//            }
+//            SelectSqlInfo $sqlInfo = this.allTableMap.get(tableName);
+//            if ($sqlInfo != null) {
+//                $sqlInfo.addSelectField(aliasName, fieldName);
+//            } else {
+//                log.warn("发生意外情况，未找到表名为 {} 的 SelectSqlInfo", tableName);
+//            }
+//        }
+//    }
+//
+//    /**
+//     * 根据表名添加sqlInfo
+//     *
+//     * @param table
+//     */
+//    private void addSqlInfoByTable(Table table) {
+//        String tableName = table.getName();
+//        // 解析 aliasName
+//        if (table.getAlias() != null) {
+//            this.tableAliasMap.put(table.getAlias().getName(), tableName);
+//        }
+//        SelectSqlInfo sqlInfo = new SelectSqlInfo(this.parsedSql);
+//        sqlInfo.setFromTableName(table.getName());
+//        this.allTableMap.put(sqlInfo.getFromTableName(), sqlInfo);
+//    }
+//
+//    /**
+//     * 合并map
+//     *
+//     * @param source
+//     */
+//    private void assignMap(Map<String, SelectSqlInfo> source) {
+//        for (Map.Entry<String, SelectSqlInfo> entry : source.entrySet()) {
+//            SelectSqlInfo sqlInfo = this.allTableMap.get(entry.getKey());
+//            if (sqlInfo == null) {
+//                this.allTableMap.put(entry.getKey(), entry.getValue());
+//            } else {
+//                // 合并
+//                if (sqlInfo.getSelectFields() == null) {
+//                    sqlInfo.setSelectFields(entry.getValue().getSelectFields());
+//                } else {
+//                    sqlInfo.getSelectFields().addAll(entry.getValue().getSelectFields());
+//                }
+//                if (sqlInfo.getRealSelectFields() == null) {
+//                    sqlInfo.setRealSelectFields(entry.getValue().getRealSelectFields());
+//                } else {
+//                    sqlInfo.getRealSelectFields().addAll(entry.getValue().getRealSelectFields());
+//                }
+//            }
+//        }
+//    }
+//
+//}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlparse/JSqlParserUtils.java

@@ -1,190 +1,190 @@
-package org.jeecg.common.util.sqlparse;
-
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.JSQLParserException;
-import net.sf.jsqlparser.expression.*;
-import net.sf.jsqlparser.parser.CCJSqlParserManager;
-import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.schema.Table;
-import net.sf.jsqlparser.statement.Statement;
-import net.sf.jsqlparser.statement.select.*;
-import org.jeecg.common.exception.JeecgBootException;
-import org.jeecg.common.util.oConvertUtils;
-import org.jeecg.common.util.sqlparse.vo.SelectSqlInfo;
-
-import java.io.StringReader;
-import java.util.List;
-import java.util.Map;
-
-@Slf4j
-public class JSqlParserUtils {
-
-    /**
-     * 解析 查询（select）sql的信息，
-     * 此方法会展开所有子查询到一个map里，
-     * key只存真实的表名，如果查询的没有真实的表名，则会被忽略。
-     * value只存真实的字段名，如果查询的没有真实的字段名，则会被忽略。
-     * <p>
-     * 例如：SELECT a.*,d.age,(SELECT count(1) FROM sys_depart) AS count FROM (SELECT username AS foo, realname FROM sys_user) a, demo d
-     * 解析后的结果为：{sys_user=[username, realname], demo=[age], sys_depart=[]}
-     *
-     * @param selectSql
-     * @return
-     */
-    public static Map<String, SelectSqlInfo> parseAllSelectTable(String selectSql) throws JSQLParserException {
-        if (oConvertUtils.isEmpty(selectSql)) {
-            return null;
-        }
-        // log.info("解析查询Sql：{}", selectSql);
-        JSqlParserAllTableManager allTableManager = new JSqlParserAllTableManager(selectSql);
-        return allTableManager.parse();
-    }
-
-    /**
-     * 解析 查询（select）sql的信息，子查询嵌套
-     *
-     * @param selectSql
-     * @return
-     */
-    public static SelectSqlInfo parseSelectSqlInfo(String selectSql) throws JSQLParserException {
-        if (oConvertUtils.isEmpty(selectSql)) {
-            return null;
-        }
-        // log.info("解析查询Sql：{}", selectSql);
-        // 使用 JSqlParer 解析sql
-        // 1、创建解析器
-        CCJSqlParserManager mgr = new CCJSqlParserManager();
-        // 2、使用解析器解析sql生成具有层次结构的java类
-        Statement stmt = mgr.parse(new StringReader(selectSql));
-        if (stmt instanceof Select) {
-            Select selectStatement = (Select) stmt;
-            // 3、解析select查询sql的信息
-            return JSqlParserUtils.parseBySelectBody(selectStatement.getSelectBody());
-        } else {
-            // 非 select 查询sql，不做处理
-            throw new JeecgBootException("非 select 查询sql，不做处理");
-        }
-    }
-
-    /**
-     * 解析 select 查询sql的信息
-     *
-     * @param selectBody
-     * @return
-     */
-    private static SelectSqlInfo parseBySelectBody(SelectBody selectBody) {
-        // 判断是否使用了union等操作
-        if (selectBody instanceof SetOperationList) {
-            // 如果使用了union等操作，则只解析第一个查询
-            List<SelectBody> selectBodyList = ((SetOperationList) selectBody).getSelects();
-            return JSqlParserUtils.parseBySelectBody(selectBodyList.get(0));
-        }
-        // 简单的select查询
-        if (selectBody instanceof PlainSelect) {
-            SelectSqlInfo sqlInfo = new SelectSqlInfo(selectBody);
-            PlainSelect plainSelect = (PlainSelect) selectBody;
-            FromItem fromItem = plainSelect.getFromItem();
-            // 解析 aliasName
-            if (fromItem.getAlias() != null) {
-                sqlInfo.setFromTableAliasName(fromItem.getAlias().getName());
-            }
-            // 解析 表名
-            if (fromItem instanceof Table) {
-                // 通过表名的方式from
-                Table fromTable = (Table) fromItem;
-                sqlInfo.setFromTableName(fromTable.getName());
-            } else if (fromItem instanceof SubSelect) {
-                // 通过子查询的方式from
-                SubSelect fromSubSelect = (SubSelect) fromItem;
-                SelectSqlInfo subSqlInfo = JSqlParserUtils.parseBySelectBody(fromSubSelect.getSelectBody());
-                sqlInfo.setFromSubSelect(subSqlInfo);
-            }
-            // 解析 selectFields
-            List<SelectItem> selectItems = plainSelect.getSelectItems();
-            for (SelectItem selectItem : selectItems) {
-                if (selectItem instanceof AllColumns || selectItem instanceof AllTableColumns) {
-                    // 全部字段
-                    sqlInfo.setSelectAll(true);
-                    sqlInfo.setSelectFields(null);
-                    sqlInfo.setRealSelectFields(null);
-                    break;
-                } else if (selectItem instanceof SelectExpressionItem) {
-                    // 获取单个查询字段名
-                    SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
-                    Expression expression = selectExpressionItem.getExpression();
-                    Alias alias = selectExpressionItem.getAlias();
-                    JSqlParserUtils.handleExpression(sqlInfo, expression, alias);
-                }
-            }
-            return sqlInfo;
-        } else {
-            log.warn("暂时尚未处理该类型的 SelectBody: {}", selectBody.getClass().getName());
-            throw new JeecgBootException("暂时尚未处理该类型的 SelectBody");
-        }
-    }
-
-    /**
-     * 处理查询字段表达式
-     *
-     * @param sqlInfo
-     * @param expression
-     * @param alias      是否有别名，无传null
-     */
-    private static void handleExpression(SelectSqlInfo sqlInfo, Expression expression, Alias alias) {
-        // 处理函数式字段  CONCAT(name,'(',age,')')
-        if (expression instanceof Function) {
-            JSqlParserUtils.handleFunctionExpression((Function) expression, sqlInfo);
-            return;
-        }
-        // 处理字段上的子查询
-        if (expression instanceof SubSelect) {
-            SubSelect subSelect = (SubSelect) expression;
-            SelectSqlInfo subSqlInfo = JSqlParserUtils.parseBySelectBody(subSelect.getSelectBody());
-            // 注：字段上的子查询，必须只查询一个字段，否则会报错，所以可以放心合并
-            sqlInfo.getSelectFields().addAll(subSqlInfo.getSelectFields());
-            sqlInfo.getRealSelectFields().addAll(subSqlInfo.getAllRealSelectFields());
-            return;
-        }
-        // 不处理字面量
-        if (expression instanceof StringValue ||
-                expression instanceof NullValue ||
-                expression instanceof LongValue ||
-                expression instanceof DoubleValue ||
-                expression instanceof HexValue ||
-                expression instanceof DateValue ||
-                expression instanceof TimestampValue ||
-                expression instanceof TimeValue
-        ) {
-            return;
-        }
-
-        // 查询字段名
-        String selectField = expression.toString();
-        // 实际查询字段名
-        String realSelectField = selectField;
-        // 判断是否有别名
-        if (alias != null) {
-            selectField = alias.getName();
-        }
-        // 获取真实字段名
-        if (expression instanceof Column) {
-            Column column = (Column) expression;
-            realSelectField = column.getColumnName();
-        }
-        sqlInfo.addSelectField(selectField, realSelectField);
-    }
-
-    /**
-     * 处理函数式字段
-     *
-     * @param functionExp
-     * @param sqlInfo
-     */
-    private static void handleFunctionExpression(Function functionExp, SelectSqlInfo sqlInfo) {
-        List<Expression> expressions = functionExp.getParameters().getExpressions();
-        for (Expression expression : expressions) {
-            JSqlParserUtils.handleExpression(sqlInfo, expression, null);
-        }
-    }
-
-}
+//package org.jeecg.common.util.sqlparse;
+//
+//import lombok.extern.slf4j.Slf4j;
+//import net.sf.jsqlparser.JSQLParserException;
+//import net.sf.jsqlparser.expression.*;
+//import net.sf.jsqlparser.parser.CCJSqlParserManager;
+//import net.sf.jsqlparser.schema.Column;
+//import net.sf.jsqlparser.schema.Table;
+//import net.sf.jsqlparser.statement.Statement;
+//import net.sf.jsqlparser.statement.select.*;
+//import org.jeecg.common.exception.JeecgBootException;
+//import org.jeecg.common.util.oConvertUtils;
+//import org.jeecg.common.util.sqlparse.vo.SelectSqlInfo;
+//
+//import java.io.StringReader;
+//import java.util.List;
+//import java.util.Map;
+//
+//@Slf4j
+//public class JSqlParserUtils {
+//
+//    /**
+//     * 解析 查询（select）sql的信息，
+//     * 此方法会展开所有子查询到一个map里，
+//     * key只存真实的表名，如果查询的没有真实的表名，则会被忽略。
+//     * value只存真实的字段名，如果查询的没有真实的字段名，则会被忽略。
+//     * <p>
+//     * 例如：SELECT a.*,d.age,(SELECT count(1) FROM sys_depart) AS count FROM (SELECT username AS foo, realname FROM sys_user) a, demo d
+//     * 解析后的结果为：{sys_user=[username, realname], demo=[age], sys_depart=[]}
+//     *
+//     * @param selectSql
+//     * @return
+//     */
+//    public static Map<String, SelectSqlInfo> parseAllSelectTable(String selectSql) throws JSQLParserException {
+//        if (oConvertUtils.isEmpty(selectSql)) {
+//            return null;
+//        }
+//        // log.info("解析查询Sql：{}", selectSql);
+//        JSqlParserAllTableManager allTableManager = new JSqlParserAllTableManager(selectSql);
+//        return allTableManager.parse();
+//    }
+//
+//    /**
+//     * 解析 查询（select）sql的信息，子查询嵌套
+//     *
+//     * @param selectSql
+//     * @return
+//     */
+//    public static SelectSqlInfo parseSelectSqlInfo(String selectSql) throws JSQLParserException {
+//        if (oConvertUtils.isEmpty(selectSql)) {
+//            return null;
+//        }
+//        // log.info("解析查询Sql：{}", selectSql);
+//        // 使用 JSqlParer 解析sql
+//        // 1、创建解析器
+//        CCJSqlParserManager mgr = new CCJSqlParserManager();
+//        // 2、使用解析器解析sql生成具有层次结构的java类
+//        Statement stmt = mgr.parse(new StringReader(selectSql));
+//        if (stmt instanceof Select) {
+//            Select selectStatement = (Select) stmt;
+//            // 3、解析select查询sql的信息
+//            return JSqlParserUtils.parseBySelectBody(selectStatement.getSelectBody());
+//        } else {
+//            // 非 select 查询sql，不做处理
+//            throw new JeecgBootException("非 select 查询sql，不做处理");
+//        }
+//    }
+//
+//    /**
+//     * 解析 select 查询sql的信息
+//     *
+//     * @param selectBody
+//     * @return
+//     */
+//    private static SelectSqlInfo parseBySelectBody(SelectBody selectBody) {
+//        // 判断是否使用了union等操作
+//        if (selectBody instanceof SetOperationList) {
+//            // 如果使用了union等操作，则只解析第一个查询
+//            List<SelectBody> selectBodyList = ((SetOperationList) selectBody).getSelects();
+//            return JSqlParserUtils.parseBySelectBody(selectBodyList.get(0));
+//        }
+//        // 简单的select查询
+//        if (selectBody instanceof PlainSelect) {
+//            SelectSqlInfo sqlInfo = new SelectSqlInfo(selectBody);
+//            PlainSelect plainSelect = (PlainSelect) selectBody;
+//            FromItem fromItem = plainSelect.getFromItem();
+//            // 解析 aliasName
+//            if (fromItem.getAlias() != null) {
+//                sqlInfo.setFromTableAliasName(fromItem.getAlias().getName());
+//            }
+//            // 解析 表名
+//            if (fromItem instanceof Table) {
+//                // 通过表名的方式from
+//                Table fromTable = (Table) fromItem;
+//                sqlInfo.setFromTableName(fromTable.getName());
+//            } else if (fromItem instanceof SubSelect) {
+//                // 通过子查询的方式from
+//                SubSelect fromSubSelect = (SubSelect) fromItem;
+//                SelectSqlInfo subSqlInfo = JSqlParserUtils.parseBySelectBody(fromSubSelect.getSelectBody());
+//                sqlInfo.setFromSubSelect(subSqlInfo);
+//            }
+//            // 解析 selectFields
+//            List<SelectItem> selectItems = plainSelect.getSelectItems();
+//            for (SelectItem selectItem : selectItems) {
+//                if (selectItem instanceof AllColumns || selectItem instanceof AllTableColumns) {
+//                    // 全部字段
+//                    sqlInfo.setSelectAll(true);
+//                    sqlInfo.setSelectFields(null);
+//                    sqlInfo.setRealSelectFields(null);
+//                    break;
+//                } else if (selectItem instanceof SelectExpressionItem) {
+//                    // 获取单个查询字段名
+//                    SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
+//                    Expression expression = selectExpressionItem.getExpression();
+//                    Alias alias = selectExpressionItem.getAlias();
+//                    JSqlParserUtils.handleExpression(sqlInfo, expression, alias);
+//                }
+//            }
+//            return sqlInfo;
+//        } else {
+//            log.warn("暂时尚未处理该类型的 SelectBody: {}", selectBody.getClass().getName());
+//            throw new JeecgBootException("暂时尚未处理该类型的 SelectBody");
+//        }
+//    }
+//
+//    /**
+//     * 处理查询字段表达式
+//     *
+//     * @param sqlInfo
+//     * @param expression
+//     * @param alias      是否有别名，无传null
+//     */
+//    private static void handleExpression(SelectSqlInfo sqlInfo, Expression expression, Alias alias) {
+//        // 处理函数式字段  CONCAT(name,'(',age,')')
+//        if (expression instanceof Function) {
+//            JSqlParserUtils.handleFunctionExpression((Function) expression, sqlInfo);
+//            return;
+//        }
+//        // 处理字段上的子查询
+//        if (expression instanceof SubSelect) {
+//            SubSelect subSelect = (SubSelect) expression;
+//            SelectSqlInfo subSqlInfo = JSqlParserUtils.parseBySelectBody(subSelect.getSelectBody());
+//            // 注：字段上的子查询，必须只查询一个字段，否则会报错，所以可以放心合并
+//            sqlInfo.getSelectFields().addAll(subSqlInfo.getSelectFields());
+//            sqlInfo.getRealSelectFields().addAll(subSqlInfo.getAllRealSelectFields());
+//            return;
+//        }
+//        // 不处理字面量
+//        if (expression instanceof StringValue ||
+//                expression instanceof NullValue ||
+//                expression instanceof LongValue ||
+//                expression instanceof DoubleValue ||
+//                expression instanceof HexValue ||
+//                expression instanceof DateValue ||
+//                expression instanceof TimestampValue ||
+//                expression instanceof TimeValue
+//        ) {
+//            return;
+//        }
+//
+//        // 查询字段名
+//        String selectField = expression.toString();
+//        // 实际查询字段名
+//        String realSelectField = selectField;
+//        // 判断是否有别名
+//        if (alias != null) {
+//            selectField = alias.getName();
+//        }
+//        // 获取真实字段名
+//        if (expression instanceof Column) {
+//            Column column = (Column) expression;
+//            realSelectField = column.getColumnName();
+//        }
+//        sqlInfo.addSelectField(selectField, realSelectField);
+//    }
+//
+//    /**
+//     * 处理函数式字段
+//     *
+//     * @param functionExp
+//     * @param sqlInfo
+//     */
+//    private static void handleFunctionExpression(Function functionExp, SelectSqlInfo sqlInfo) {
+//        List<Expression> expressions = functionExp.getParameters().getExpressions();
+//        for (Expression expression : expressions) {
+//            JSqlParserUtils.handleExpression(sqlInfo, expression, null);
+//        }
+//    }
+//
+//}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/sqlparse/vo/SelectSqlInfo.java

@@ -1,101 +1,101 @@
-package org.jeecg.common.util.sqlparse.vo;
-
-import lombok.Data;
-import net.sf.jsqlparser.statement.select.SelectBody;
-
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * select 查询 sql 的信息
- */
-@Data
-public class SelectSqlInfo {
-
-    /**
-     * 查询的表名，如果是子查询，则此处为null
-     */
-    private String fromTableName;
-    /**
-     * 表别名
-     */
-    private String fromTableAliasName;
-    /**
-     * 通过子查询获取的表信息，例如：select name from (select * from user) u
-     * 如果不是子查询，则为null
-     */
-    private SelectSqlInfo fromSubSelect;
-    /**
-     * 查询的字段集合，如果是 * 则为null，如果设了别名则为别名
-     */
-    private Set<String> selectFields;
-    /**
-     * 真实的查询字段集合，如果是 * 则为null，如果设了别名则为原始字段名
-     */
-    private Set<String> realSelectFields;
-    /**
-     * 是否是查询所有字段
-     */
-    private boolean selectAll;
-
-    /**
-     * 解析之后的 SQL （关键字都是大写）
-     */
-    private final String parsedSql;
-
-    public SelectSqlInfo(String parsedSql) {
-        this.parsedSql = parsedSql;
-    }
-
-    public SelectSqlInfo(SelectBody selectBody) {
-        this.parsedSql = selectBody.toString();
-    }
-
-    public void addSelectField(String selectField, String realSelectField) {
-        if (this.selectFields == null) {
-            this.selectFields = new HashSet<>();
-        }
-        if (this.realSelectFields == null) {
-            this.realSelectFields = new HashSet<>();
-        }
-        this.selectFields.add(selectField);
-        this.realSelectFields.add(realSelectField);
-    }
-
-    /**
-     * 获取所有字段，包括子查询里的。
-     *
-     * @return
-     */
-    public Set<String> getAllRealSelectFields() {
-        Set<String> fields = new HashSet<>();
-        // 递归获取所有字段，起个直观的方法名为：
-        this.recursiveGetAllFields(this, fields);
-        return fields;
-    }
-
-    /**
-     * 递归获取所有字段
-     */
-    private void recursiveGetAllFields(SelectSqlInfo sqlInfo, Set<String> fields) {
-        if (!sqlInfo.isSelectAll() && sqlInfo.getRealSelectFields() != null) {
-            fields.addAll(sqlInfo.getRealSelectFields());
-        }
-        if (sqlInfo.getFromSubSelect() != null) {
-            recursiveGetAllFields(sqlInfo.getFromSubSelect(), fields);
-        }
-    }
-
-    @Override
-    public String toString() {
-        return "SelectSqlInfo{" +
-                "fromTableName='" + fromTableName + '\'' +
-                ", fromSubSelect=" + fromSubSelect +
-                ", aliasName='" + fromTableAliasName + '\'' +
-                ", selectFields=" + selectFields +
-                ", realSelectFields=" + realSelectFields +
-                ", selectAll=" + selectAll +
-                "}";
-    }
-
-}
+//package org.jeecg.common.util.sqlparse.vo;
+//
+//import lombok.Data;
+//import net.sf.jsqlparser.statement.select.SelectBody;
+//
+//import java.util.HashSet;
+//import java.util.Set;
+//
+///**
+// * select 查询 sql 的信息
+// */
+//@Data
+//public class SelectSqlInfo {
+//
+//    /**
+//     * 查询的表名，如果是子查询，则此处为null
+//     */
+//    private String fromTableName;
+//    /**
+//     * 表别名
+//     */
+//    private String fromTableAliasName;
+//    /**
+//     * 通过子查询获取的表信息，例如：select name from (select * from user) u
+//     * 如果不是子查询，则为null
+//     */
+//    private SelectSqlInfo fromSubSelect;
+//    /**
+//     * 查询的字段集合，如果是 * 则为null，如果设了别名则为别名
+//     */
+//    private Set<String> selectFields;
+//    /**
+//     * 真实的查询字段集合，如果是 * 则为null，如果设了别名则为原始字段名
+//     */
+//    private Set<String> realSelectFields;
+//    /**
+//     * 是否是查询所有字段
+//     */
+//    private boolean selectAll;
+//
+//    /**
+//     * 解析之后的 SQL （关键字都是大写）
+//     */
+//    private final String parsedSql;
+//
+//    public SelectSqlInfo(String parsedSql) {
+//        this.parsedSql = parsedSql;
+//    }
+//
+//    public SelectSqlInfo(SelectBody selectBody) {
+//        this.parsedSql = selectBody.toString();
+//    }
+//
+//    public void addSelectField(String selectField, String realSelectField) {
+//        if (this.selectFields == null) {
+//            this.selectFields = new HashSet<>();
+//        }
+//        if (this.realSelectFields == null) {
+//            this.realSelectFields = new HashSet<>();
+//        }
+//        this.selectFields.add(selectField);
+//        this.realSelectFields.add(realSelectField);
+//    }
+//
+//    /**
+//     * 获取所有字段，包括子查询里的。
+//     *
+//     * @return
+//     */
+//    public Set<String> getAllRealSelectFields() {
+//        Set<String> fields = new HashSet<>();
+//        // 递归获取所有字段，起个直观的方法名为：
+//        this.recursiveGetAllFields(this, fields);
+//        return fields;
+//    }
+//
+//    /**
+//     * 递归获取所有字段
+//     */
+//    private void recursiveGetAllFields(SelectSqlInfo sqlInfo, Set<String> fields) {
+//        if (!sqlInfo.isSelectAll() && sqlInfo.getRealSelectFields() != null) {
+//            fields.addAll(sqlInfo.getRealSelectFields());
+//        }
+//        if (sqlInfo.getFromSubSelect() != null) {
+//            recursiveGetAllFields(sqlInfo.getFromSubSelect(), fields);
+//        }
+//    }
+//
+//    @Override
+//    public String toString() {
+//        return "SelectSqlInfo{" +
+//                "fromTableName='" + fromTableName + '\'' +
+//                ", fromSubSelect=" + fromSubSelect +
+//                ", aliasName='" + fromTableAliasName + '\'' +
+//                ", selectFields=" + selectFields +
+//                ", realSelectFields=" + realSelectFields +
+//                ", selectAll=" + selectAll +
+//                "}";
+//    }
+//
+//}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/AutoPoiConfig.java

@@ -3,13 +3,14 @@ package org.jeecg.config;
 import org.jeecgframework.core.util.ApplicationContextUtil;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Lazy;
 
 /**
  * @Author: Scott
  * @Date: 2018/2/7
  * @description: autopoi 配置类
  */
-
+@Lazy(false)
 @Configuration
 public class AutoPoiConfig {
 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/AutoPoiDictConfig.java

@@ -3,7 +3,7 @@ package org.jeecg.config;
 import java.util.ArrayList;
 import java.util.List;
 
-import javax.annotation.Resource;
+import jakarta.annotation.Resource;
 
 import org.jeecg.common.api.CommonAPI;
 import org.jeecg.common.system.vo.DictModel;
@@ -25,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
  * @Version:1.0
  */
 @Slf4j
+@Lazy(false)
 @Service
 public class AutoPoiDictConfig implements AutoPoiDictServiceI {
 	final static String EXCEL_SPLIT_TAG = "_";

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/DruidConfig.java

@@ -2,7 +2,9 @@ package org.jeecg.config;
 
 import java.io.IOException;
 
-import javax.servlet.*;
+import com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure;
+import com.alibaba.druid.spring.boot3.autoconfigure.properties.DruidStatProperties;
+import jakarta.servlet.*;
 
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
@@ -11,8 +13,6 @@ import org.springframework.boot.web.servlet.FilterRegistrationBean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
-import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
-import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
 import com.alibaba.druid.util.Utils;
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/DruidWallConfigRegister.java

@@ -12,6 +12,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 /**
+ * @author eightmonth@qq.com
  * 启动程序修改DruidWallConfig配置
  * 允许SELECT语句的WHERE子句是一个永真条件
  * @author eightmonth

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/JeecgBaseConfig.java

@@ -1,7 +1,10 @@
 package org.jeecg.config;
 
 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;
 
 
@@ -11,12 +14,17 @@ import org.springframework.stereotype.Component;
  */
 @Component("jeecgBaseConfig")
 @ConfigurationProperties(prefix = "jeecg")
+@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 public class JeecgBaseConfig {
     /**
      * 签名密钥串(字典等敏感接口)
      * @TODO 降低使用成本加的默认值,实际以 yml配置 为准
      */
     private String signatureSecret = "dd05f1c54d63749eda95f9fa6d49v442a";
+    /**
+     * 自定义后台资源前缀，解决表单设计器无法通过前端nginx转发访问
+     */
+    private String customResourcePrefixPath;
     /**
      * 需要加强校验的接口清单
      */
@@ -66,7 +74,15 @@ public class JeecgBaseConfig {
     /**
      * 百度开放API配置
      */
-    private BaiduApi baiduApi;
+    private BaiduApi baiduApi;    
+
+    public String getCustomResourcePrefixPath() {
+        return customResourcePrefixPath;
+    }
+
+    public void setCustomResourcePrefixPath(String customResourcePrefixPath) {
+        this.customResourcePrefixPath = customResourcePrefixPath;
+    }
 
     public Elasticsearch getElasticsearch() {
         return elasticsearch;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/JeecgGaodeBaseConfig.java

@@ -0,0 +1,29 @@
+package org.jeecg.config;
+
+import org.jeecg.config.vo.GaoDeApi;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Lazy;
+
+/**
+ * 高德账号配置
+ */
+@Lazy(false)
+@Configuration("jeecgGaodeBaseConfig")
+@ConfigurationProperties(prefix = "jeecg.jmreport")
+public class JeecgGaodeBaseConfig {
+
+    /**
+     * 高德开放API配置
+     */
+    private GaoDeApi gaoDeApi;
+
+    public GaoDeApi getGaoDeApi() {
+        return gaoDeApi;
+    }
+
+    public void setGaoDeApi(GaoDeApi gaoDeApi) {
+        this.gaoDeApi = gaoDeApi;
+    }
+    
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/StaticConfig.java

@@ -2,12 +2,14 @@ package org.jeecg.config;
 
 import lombok.Data;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
 /**
  * 设置静态参数初始化
  * @author: jeecg-boot
  */
+@Lazy(false)
 @Component
 @Data
 public class StaticConfig {

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/Swagger2Config.java

@@ -1,188 +1,188 @@
-package org.jeecg.config;
-
-
-import io.swagger.annotations.ApiOperation;
-import org.jeecg.common.constant.CommonConstant;
-import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.config.BeanPostProcessor;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.util.ReflectionUtils;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
-import org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping;
-import springfox.bean.validators.configuration.BeanValidatorPluginsConfiguration;
-import springfox.documentation.builders.ApiInfoBuilder;
-import springfox.documentation.builders.ParameterBuilder;
-import springfox.documentation.builders.PathSelectors;
-import springfox.documentation.builders.RequestHandlerSelectors;
-import springfox.documentation.schema.ModelRef;
-import springfox.documentation.service.*;
-import springfox.documentation.spi.DocumentationType;
-import springfox.documentation.spi.service.contexts.SecurityContext;
-import springfox.documentation.spring.web.plugins.Docket;
-import springfox.documentation.spring.web.plugins.WebMvcRequestHandlerProvider;
-import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * @Author scott
- */
-@Configuration
-@EnableSwagger2WebMvc
-@Import(BeanValidatorPluginsConfiguration.class)
-public class Swagger2Config implements WebMvcConfigurer {
-
-    /**
-     *
-     * 显示swagger-ui.html文档展示页，还必须注入swagger资源：
-     *
-     * @param registry
-     */
-    @Override
-    public void addResourceHandlers(ResourceHandlerRegistry registry) {
-        registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
-        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
-        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
-    }
-
-    /**
-     * swagger2的配置文件，这里可以配置swagger2的一些基本的内容，比如扫描的包等等
-     *
-     * @return Docket
-     */
-    @Bean(value = "defaultApi2")
-    public Docket defaultApi2() {
-        return new Docket(DocumentationType.SWAGGER_2)
-                .apiInfo(apiInfo())
-                .select()
-                //此包路径下的类，才生成接口文档
-                .apis(RequestHandlerSelectors.basePackage("org.jeecg"))
-                //加了ApiOperation注解的类，才生成接口文档
-                .apis(RequestHandlerSelectors.withClassAnnotation(RestController.class))
-                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
-                .paths(PathSelectors.any())
-                .build()
-                .securitySchemes(Collections.singletonList(securityScheme()))
-                .securityContexts(securityContexts())
-                .globalOperationParameters(setHeaderToken());
-    }
-
-    /***
-     * oauth2配置
-     * 需要增加swagger授权回调地址
-     * http://localhost:8888/webjars/springfox-swagger-ui/o2c.html
-     * @return
-     */
-    @Bean
-    SecurityScheme securityScheme() {
-        return new ApiKey(CommonConstant.X_ACCESS_TOKEN, CommonConstant.X_ACCESS_TOKEN, "header");
-    }
-    /**
-     * JWT token
-     * @return
-     */
-    private List<Parameter> setHeaderToken() {
-        ParameterBuilder tokenPar = new ParameterBuilder();
-        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;
-    }
-
-    /**
-     * api文档的详细信息函数,注意这里的注解引用的是哪个
-     *
-     * @return
-     */
-    private ApiInfo apiInfo() {
-        return new ApiInfoBuilder()
-                // //大标题
-                .title("JeecgBoot 后台服务API接口文档")
-                // 版本号
-                .version("1.0")
-//				.termsOfServiceUrl("NO terms of service")
-                // 描述
-                .description("后台API接口")
-                // 作者
-                .contact(new Contact("北京国炬信息技术有限公司","www.jeccg.com","jeecgos@163.com"))
-                .license("The Apache License, Version 2.0")
-                .licenseUrl("http://www.apache.org/licenses/LICENSE-2.0.html")
-                .build();
-    }
-
-    /**
-     * 新增 securityContexts 保持登录状态
-     */
-    private List<SecurityContext> securityContexts() {
-        return new ArrayList(
-                Collections.singleton(SecurityContext.builder()
-                        .securityReferences(defaultAuth())
-                        .forPaths(PathSelectors.regex("^(?!auth).*$"))
-                        .build())
-        );
-    }
-
-    private List<SecurityReference> defaultAuth() {
-        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
-        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
-        authorizationScopes[0] = authorizationScope;
-        return new ArrayList(
-                Collections.singleton(new SecurityReference(CommonConstant.X_ACCESS_TOKEN, authorizationScopes)));
-    }
-
-    /**
-     * 解决springboot2.6 和springfox不兼容问题
-     * @return
-     */
-    @Bean
-    public static BeanPostProcessor springfoxHandlerProviderBeanPostProcessor() {
-        return new BeanPostProcessor() {
-
-            @Override
-            public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
-                if (bean instanceof WebMvcRequestHandlerProvider) {
-                    customizeSpringfoxHandlerMappings(getHandlerMappings(bean));
-                }
-                return bean;
-            }
-
-            private <T extends RequestMappingInfoHandlerMapping> void customizeSpringfoxHandlerMappings(List<T> mappings) {
-                List<T> copy = mappings.stream()
-                        .filter(mapping -> mapping.getPatternParser() == null)
-                        .collect(Collectors.toList());
-                mappings.clear();
-                mappings.addAll(copy);
-            }
-
-            @SuppressWarnings("unchecked")
-            private List<RequestMappingInfoHandlerMapping> getHandlerMappings(Object bean) {
-                try {
-                    Field field = ReflectionUtils.findField(bean.getClass(), "handlerMappings");
-                    field.setAccessible(true);
-                    return (List<RequestMappingInfoHandlerMapping>) field.get(bean);
-                } catch (IllegalArgumentException | IllegalAccessException e) {
-                    throw new IllegalStateException(e);
-                }
-            }
-        };
-    }
-
-
-}
+//package org.jeecg.config;
+//
+//
+//import io.swagger.v3.oas.annotations.Operation;
+//import org.jeecg.common.constant.CommonConstant;
+//import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
+//import org.springframework.beans.BeansException;
+//import org.springframework.beans.factory.config.BeanPostProcessor;
+//import org.springframework.context.annotation.Bean;
+//import org.springframework.context.annotation.Configuration;
+//import org.springframework.context.annotation.Import;
+//import org.springframework.util.ReflectionUtils;
+//import org.springframework.web.bind.annotation.RestController;
+//import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+//import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+//import org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping;
+//import springfox.bean.validators.configuration.BeanValidatorPluginsConfiguration;
+//import springfox.documentation.builders.ApiInfoBuilder;
+//import springfox.documentation.builders.ParameterBuilder;
+//import springfox.documentation.builders.PathSelectors;
+//import springfox.documentation.builders.RequestHandlerSelectors;
+//import springfox.documentation.schema.ModelRef;
+//import springfox.documentation.service.*;
+//import springfox.documentation.spi.DocumentationType;
+//import springfox.documentation.spi.service.contexts.SecurityContext;
+//import springfox.documentation.spring.web.plugins.Docket;
+//import springfox.documentation.spring.web.plugins.WebMvcRequestHandlerProvider;
+//import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;
+//
+//import java.lang.reflect.Field;
+//import java.util.ArrayList;
+//import java.util.Collections;
+//import java.util.List;
+//import java.util.stream.Collectors;
+//
+///**
+// * @Author scott
+// */
+//@Configuration
+//@EnableSwagger2WebMvc
+//@Import(BeanValidatorPluginsConfiguration.class)
+//public class Swagger2Config implements WebMvcConfigurer {
+//
+//    /**
+//     *
+//     * 显示swagger-ui.html文档展示页，还必须注入swagger资源：
+//     *
+//     * @param registry
+//     */
+//    @Override
+//    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+//        registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
+//        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
+//        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
+//    }
+//
+//    /**
+//     * swagger2的配置文件，这里可以配置swagger2的一些基本的内容，比如扫描的包等等
+//     *
+//     * @return Docket
+//     */
+//    @Bean(value = "defaultApi2")
+//    public Docket defaultApi2() {
+//        return new Docket(DocumentationType.SWAGGER_2)
+//                .apiInfo(apiInfo())
+//                .select()
+//                //此包路径下的类，才生成接口文档
+//                .apis(RequestHandlerSelectors.basePackage("org.jeecg"))
+//                //加了ApiOperation注解的类，才生成接口文档
+//                .apis(RequestHandlerSelectors.withClassAnnotation(RestController.class))
+//                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
+//                .paths(PathSelectors.any())
+//                .build()
+//                .securitySchemes(Collections.singletonList(securityScheme()))
+//                .securityContexts(securityContexts())
+//                .globalOperationParameters(setHeaderToken());
+//    }
+//
+//    /***
+//     * oauth2配置
+//     * 需要增加swagger授权回调地址
+//     * http://localhost:8888/webjars/springfox-swagger-ui/o2c.html
+//     * @return
+//     */
+//    @Bean
+//    SecurityScheme securityScheme() {
+//        return new ApiKey(CommonConstant.X_ACCESS_TOKEN, CommonConstant.X_ACCESS_TOKEN, "header");
+//    }
+//    /**
+//     * JWT token
+//     * @return
+//     */
+//    private List<Parameter> setHeaderToken() {
+//        ParameterBuilder tokenPar = new ParameterBuilder();
+//        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;
+//    }
+//
+//    /**
+//     * api文档的详细信息函数,注意这里的注解引用的是哪个
+//     *
+//     * @return
+//     */
+//    private ApiInfo apiInfo() {
+//        return new ApiInfoBuilder()
+//                // //大标题
+//                .title("JeecgBoot 后台服务API接口文档")
+//                // 版本号
+//                .version("1.0")
+////				.termsOfServiceUrl("NO terms of service")
+//                // 描述
+//                .description("后台API接口")
+//                // 作者
+//                .contact(new Contact("北京国炬信息技术有限公司","www.jeccg.com","jeecgos@163.com"))
+//                .license("The Apache License, Version 2.0")
+//                .licenseUrl("http://www.apache.org/licenses/LICENSE-2.0.html")
+//                .build();
+//    }
+//
+//    /**
+//     * 新增 securityContexts 保持登录状态
+//     */
+//    private List<SecurityContext> securityContexts() {
+//        return new ArrayList(
+//                Collections.singleton(SecurityContext.builder()
+//                        .securityReferences(defaultAuth())
+//                        .forPaths(PathSelectors.regex("^(?!auth).*$"))
+//                        .build())
+//        );
+//    }
+//
+//    private List<SecurityReference> defaultAuth() {
+//        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
+//        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
+//        authorizationScopes[0] = authorizationScope;
+//        return new ArrayList(
+//                Collections.singleton(new SecurityReference(CommonConstant.X_ACCESS_TOKEN, authorizationScopes)));
+//    }
+//
+//    /**
+//     * 解决springboot2.6 和springfox不兼容问题
+//     * @return
+//     */
+//    @Bean
+//    public static BeanPostProcessor springfoxHandlerProviderBeanPostProcessor() {
+//        return new BeanPostProcessor() {
+//
+//            @Override
+//            public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+//                if (bean instanceof WebMvcRequestHandlerProvider) {
+//                    customizeSpringfoxHandlerMappings(getHandlerMappings(bean));
+//                }
+//                return bean;
+//            }
+//
+//            private <T extends RequestMappingInfoHandlerMapping> void customizeSpringfoxHandlerMappings(List<T> mappings) {
+//                List<T> copy = mappings.stream()
+//                        .filter(mapping -> mapping.getPatternParser() == null)
+//                        .collect(Collectors.toList());
+//                mappings.clear();
+//                mappings.addAll(copy);
+//            }
+//
+//            @SuppressWarnings("unchecked")
+//            private List<RequestMappingInfoHandlerMapping> getHandlerMappings(Object bean) {
+//                try {
+//                    Field field = ReflectionUtils.findField(bean.getClass(), "handlerMappings");
+//                    field.setAccessible(true);
+//                    return (List<RequestMappingInfoHandlerMapping>) field.get(bean);
+//                } catch (IllegalArgumentException | IllegalAccessException e) {
+//                    throw new IllegalStateException(e);
+//                }
+//            }
+//        };
+//    }
+//
+//
+//}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/Swagger3Config.java

@@ -0,0 +1,133 @@
+package org.jeecg.config;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Contact;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.info.License;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+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.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author eightmonth
+ */
+@Slf4j
+@Configuration
+@PropertySource("classpath:config/default-spring-doc.properties")
+public class Swagger3Config implements WebMvcConfigurer {
+    // 定义不需要注入安全要求的路径集合
+    Set<String> excludedPaths = new HashSet<>(Arrays.asList(
+            "/sys/randomImage/{key}",
+            "/sys/login",
+            "/sys/phoneLogin",
+            "/sys/mLogin",
+            "/sys/sms",
+            "/sys/cas/client/validateLogin",
+            "/test/jeecgDemo/demo3",
+            "/sys/thirdLogin/**",
+            "/sys/user/register"
+    ));
+
+    /**
+     *
+     * 显示swagger-ui.html文档展示页，还必须注入swagger资源：
+     *
+     * @param registry
+     */
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
+        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
+        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
+    }
+
+    @Bean
+    public GlobalOpenApiMethodFilter globalOpenApiMethodFilter() {
+        return method -> method.isAnnotationPresent(Operation.class);
+    }
+
+    @Bean
+    public OperationCustomizer operationCustomizer() {
+        return (operation, handlerMethod) -> {
+            String path = getFullPath(handlerMethod);
+            if (!isExcludedPath(path)) {
+                operation.addSecurityItem(new SecurityRequirement().addList(CommonConstant.X_ACCESS_TOKEN));
+            }else{
+                log.info("忽略加入 X_ACCESS_TOKEN 的 PATH:" + path);
+            }
+            return operation;
+        };
+    }
+
+    private String getFullPath(HandlerMethod handlerMethod) {
+        StringBuilder fullPath = new StringBuilder();
+
+        // 获取类级别的路径
+        RequestMapping classMapping = handlerMethod.getBeanType().getAnnotation(RequestMapping.class);
+        if (classMapping != null && classMapping.value().length > 0) {
+            fullPath.append(classMapping.value()[0]);
+        }
+
+        // 获取方法级别的路径
+        RequestMapping methodMapping = handlerMethod.getMethodAnnotation(RequestMapping.class);
+        if (methodMapping != null && methodMapping.value().length > 0) {
+            String methodPath = methodMapping.value()[0];
+            // 确保路径正确拼接，处理斜杠
+            if (!fullPath.toString().endsWith("/") && !methodPath.startsWith("/")) {
+                fullPath.append("/");
+            }
+            fullPath.append(methodPath);
+        }
+
+        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);
+                });
+    }
+    
+    @Bean
+    public OpenAPI customOpenAPI() {
+        return new OpenAPI()
+                .info(new Info()
+                        .title("JeecgBoot 后台服务API接口文档")
+                        .version("3.8.3")
+                        .contact(new Contact().name("北京国炬信息技术有限公司").url("www.jeccg.com").email("jeecgos@163.com"))
+                        .description("后台API接口")
+                        .termsOfService("NO terms of service")
+                        .license(new License().name("Apache 2.0").url("http://www.apache.org/licenses/LICENSE-2.0.html")))
+                .addSecurityItem(new SecurityRequirement().addList(CommonConstant.X_ACCESS_TOKEN))
+                .components(new Components().addSecuritySchemes(CommonConstant.X_ACCESS_TOKEN,
+                        new SecurityScheme()
+                                .name(CommonConstant.X_ACCESS_TOKEN)
+                                .type(SecurityScheme.Type.APIKEY)
+                                .in(SecurityScheme.In.HEADER) // 关键：指定为 header
+                ));
+    }
+}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/UndertowCustomizer.java

@@ -0,0 +1,19 @@
+//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);
+//        });
+//    }
+//}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/WebMvcConfiguration.java

@@ -10,16 +10,19 @@ import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
-import io.micrometer.prometheus.PrometheusMeterRegistry;
-import org.springframework.beans.factory.InitializingBean;
+import io.micrometer.prometheusmetrics.PrometheusMeterRegistry;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.Resource;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.config.BeanPostProcessor;
-import org.springframework.boot.actuate.trace.http.InMemoryHttpTraceRepository;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
+import org.springframework.http.CacheControl;
 import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
 import org.springframework.web.cors.CorsConfiguration;
@@ -30,13 +33,13 @@ import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry
 import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-import javax.annotation.Resource;
 import java.text.SimpleDateFormat;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Spring Boot 2.0 解决跨域问题
@@ -44,6 +47,7 @@ import java.util.List;
  * @Author qinfeng
  *
  */
+@Slf4j
 @Configuration
 public class WebMvcConfiguration implements WebMvcConfigurer {
 
@@ -55,6 +59,14 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
     @Autowired(required = false)
     private PrometheusMeterRegistry prometheusMeterRegistry;
 
+    /**
+     * meterRegistryPostProcessor
+     * for [QQYUN-12558]【监控】系统监控的头两个tab不好使，接口404
+     */
+    @Autowired(required = false)
+    @Qualifier("meterRegistryPostProcessor")
+    private BeanPostProcessor meterRegistryPostProcessor;
+
     /**
      * 静态资源的配置 - 使得可以从磁盘中读取 Html、图片、视频、音频等
      */
@@ -67,6 +79,8 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
                     .addResourceLocations("file:" + jeecgBaseConfig.getPath().getWebapp() + "//");
         }
         resourceHandlerRegistration.addResourceLocations(staticLocations.split(","));
+        // 设置缓存控制标头 Cache-Control有效期为30天
+        resourceHandlerRegistration.setCacheControl(CacheControl.maxAge(30, TimeUnit.DAYS));
     }
 
     /**
@@ -75,7 +89,7 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
      */
     @Override
     public void addViewControllers(ViewControllerRegistry registry) {
-        registry.addViewController("/").setViewName("doc.html");
+        registry.addViewController("/").setViewName("redirect:/doc.html");
     }
 
     @Bean
@@ -141,11 +155,18 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
 
 
     /**
-     * 解决metrics端点不显示jvm信息的问题(zyf)
+     * 在Bean初始化完成后立即配置PrometheusMeterRegistry，避免在Meter注册后才配置MeterFilter
+     * for [QQYUN-12558]【监控】系统监控的头两个tab不好使，接口404
+     * @author chenrui
+     * @date 2025/5/26 16:46
      */
-    @Bean
-    InitializingBean forcePrometheusPostProcessor(BeanPostProcessor meterRegistryPostProcessor) {
-        return () -> meterRegistryPostProcessor.postProcessAfterInitialization(prometheusMeterRegistry, "");
+    @PostConstruct
+    public void initPrometheusMeterRegistry() {
+        // 确保在应用启动早期就配置MeterFilter，避免警告
+        if (null != meterRegistryPostProcessor && null != prometheusMeterRegistry) {
+            meterRegistryPostProcessor.postProcessAfterInitialization(prometheusMeterRegistry, "prometheusMeterRegistry");
+            log.info("PrometheusMeterRegistry配置完成");
+        }
     }
 
 //    /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/filter/RequestBodyReserveFilter.java

@@ -3,8 +3,8 @@ package org.jeecg.config.filter;
 import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.config.sign.util.BodyReaderHttpServletRequestWrapper;
 
-import javax.servlet.*;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
 import java.io.IOException;
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/filter/WebsocketFilter.java

@@ -7,9 +7,9 @@ import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.common.util.TokenUtils;
 import org.jeecg.common.util.oConvertUtils;
 
-import javax.servlet.*;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
 /**
@@ -24,23 +24,18 @@ public class WebsocketFilter implements Filter {
 
     private static CommonAPI commonApi;
 
-    private static RedisUtil redisUtil;
-
     @Override
     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
         if (commonApi == null) {
             commonApi = SpringContextUtils.getBean(CommonAPI.class);
         }
-        if (redisUtil == null) {
-            redisUtil = SpringContextUtils.getBean(RedisUtil.class);
-        }
         HttpServletRequest request = (HttpServletRequest)servletRequest;
         String token = request.getHeader(TOKEN_KEY);
 
         log.debug("Websocket连接 Token安全校验，Path = {}，token:{}", request.getRequestURI(), token);
 
         try {
-            TokenUtils.verifyToken(token, commonApi, redisUtil);
+            TokenUtils.verifyToken(token, commonApi);
         } catch (Exception exception) {
             //log.error("Websocket连接 Token安全校验失败，IP:{}, Token:{}, Path = {}，异常：{}", oConvertUtils.getIpAddrByRequest(request), token, request.getRequestURI(), exception.getMessage());
             log.debug("Websocket连接 Token安全校验失败，IP:{}, Token:{}, Path = {}，异常：{}", oConvertUtils.getIpAddrByRequest(request), token, request.getRequestURI(), exception.getMessage());

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/LowCodeModeConfiguration.java

@@ -8,12 +8,14 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 @Configuration
 public class LowCodeModeConfiguration implements WebMvcConfigurer {
 
-    public LowCodeModeInterceptor payInterceptor() {
-        return new LowCodeModeInterceptor();
+    private final LowCodeModeInterceptor lowCodeModeInterceptor;
+
+    public LowCodeModeConfiguration(LowCodeModeInterceptor lowCodeModeInterceptor) {
+        this.lowCodeModeInterceptor = lowCodeModeInterceptor;
     }
 
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
-        registry.addInterceptor(payInterceptor()).addPathPatterns(LowCodeUrlsEnum.getLowCodeInterceptUrls());
+        registry.addInterceptor(lowCodeModeInterceptor).addPathPatterns(LowCodeUrlsEnum.getLowCodeInterceptUrls());
     }
 }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/LowCodeModeInterceptor.java

@@ -2,24 +2,21 @@ package org.jeecg.config.firewall.interceptor;
 
 import com.alibaba.fastjson.JSON;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.shiro.SecurityUtils;
+import org.jeecg.common.util.LoginUserUtils;
 import org.jeecg.common.api.CommonAPI;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.constant.CommonConstant;
-import org.jeecg.common.exception.JeecgBootException;
 import org.jeecg.common.system.util.JwtUtil;
 import org.jeecg.common.system.vo.LoginUser;
 import org.jeecg.common.util.CommonUtils;
 import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.config.JeecgBaseConfig;
-import org.jeecg.config.firewall.interceptor.enums.LowCodeUrlsEnum;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.util.AntPathMatcher;
+import org.springframework.stereotype.Component;
 import org.springframework.web.servlet.HandlerInterceptor;
 
-import javax.annotation.Resource;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.Set;
@@ -41,6 +38,7 @@ import java.util.Set;
  * @date 20230904
  */
 @Slf4j
+@Component
 public class LowCodeModeInterceptor implements HandlerInterceptor {
     /**
      * 低代码开发模式
@@ -50,26 +48,33 @@ public class LowCodeModeInterceptor implements HandlerInterceptor {
 
     @Resource
     private JeecgBaseConfig jeecgBaseConfig;
-    @Autowired
-    private CommonAPI commonAPI;
-
+    
     /**
      * 在请求处理之前进行调用
      */
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        CommonAPI commonAPI = null;
+        log.info("低代码模式，拦截请求路径：" + request.getRequestURI());
+        
         //1、验证是否开启低代码开发模式控制
         if (jeecgBaseConfig == null) {
             jeecgBaseConfig = SpringContextUtils.getBean(JeecgBaseConfig.class);
         }
+        if (commonAPI == null) {
+            commonAPI = SpringContextUtils.getBean(CommonAPI.class);
+        }
 
         if (jeecgBaseConfig.getFirewall()!=null && LowCodeModeInterceptor.LOW_CODE_MODE_PROD.equals(jeecgBaseConfig.getFirewall().getLowCodeMode())) {
             String requestURI = request.getRequestURI().substring(request.getContextPath().length());
             log.info("低代码模式，拦截请求路径：" + requestURI);
-            LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+            LoginUser loginUser = LoginUserUtils.getSessionUser();
             Set<String> hasRoles = null;
             if (loginUser == null) {
                 loginUser = commonAPI.getUserByName(JwtUtil.getUserNameByToken(SpringContextUtils.getHttpServletRequest()));
+            }
+
+            if (loginUser != null) {
                 //当前登录人拥有的角色
                 hasRoles = commonAPI.queryUserRolesById(loginUser.getId());
             }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisInterceptor.java

@@ -6,7 +6,7 @@ import org.apache.ibatis.executor.Executor;
 import org.apache.ibatis.mapping.MappedStatement;
 import org.apache.ibatis.mapping.SqlCommandType;
 import org.apache.ibatis.plugin.*;
-import org.apache.shiro.SecurityUtils;
+import org.jeecg.common.util.LoginUserUtils;
 import org.jeecg.common.config.TenantContext;
 import org.jeecg.common.constant.TenantConstant;
 import org.jeecg.common.system.vo.LoginUser;
@@ -192,7 +192,7 @@ public class MybatisInterceptor implements Interceptor {
 	private LoginUser getLoginUser() {
 		LoginUser sysUser = null;
 		try {
-			sysUser = SecurityUtils.getSubject().getPrincipal() != null ? (LoginUser) SecurityUtils.getSubject().getPrincipal() : null;
+			sysUser = LoginUserUtils.getSessionUser() != null ? LoginUserUtils.getSessionUser() : null;
 		} catch (Exception e) {
 			//e.printStackTrace();
 			sysUser = null;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisPlusSaasConfig.java

@@ -1,11 +1,18 @@
 package org.jeecg.config.mybatis;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.annotation.DbType;
+import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
 import com.baomidou.mybatisplus.extension.plugins.inner.DynamicTableNameInnerInterceptor;
 import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
+import com.baomidou.mybatisplus.extension.toolkit.JdbcUtils;
+import lombok.extern.slf4j.Slf4j;
+import me.zhyd.oauth.log.Log;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.LongValue;
 import org.jeecg.common.config.TenantContext;
 import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.TenantConstant;
@@ -13,26 +20,27 @@ import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.common.util.TokenUtils;
 import org.jeecg.common.util.oConvertUtils;
 import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
-import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
-import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
-import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
-import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
-
-import net.sf.jsqlparser.expression.Expression;
-import net.sf.jsqlparser.expression.LongValue;
+import javax.sql.DataSource;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * 单数据源配置（jeecg.datasource.open = false时生效）
  * @Author zhoujf
  *
  */
+@Slf4j
 @Configuration
 @MapperScan(value={"org.jeecg.**.mapper*"})
 public class MybatisPlusSaasConfig {
-
+    @Autowired
+    private DataSource dataSource;
+    
     /**
      * 是否开启系统模块的租户隔离
      *  控制范围：用户、角色、部门、我的部门、字典、分类字典、多数据源、职务、通知公告
@@ -60,7 +68,18 @@ public class MybatisPlusSaasConfig {
             TENANT_TABLE.add("sys_category");
             TENANT_TABLE.add("sys_data_source");
             TENANT_TABLE.add("sys_position");
-            //TENANT_TABLE.add("sys_announcement");
+            //b-2.仪表盘
+            TENANT_TABLE.add("onl_drag_page");
+            TENANT_TABLE.add("onl_drag_dataset_head");
+            TENANT_TABLE.add("jimu_report_data_source");
+            TENANT_TABLE.add("jimu_report");
+            TENANT_TABLE.add("jimu_dict");
+            //b-4.AIRAG
+            TENANT_TABLE.add("airag_app");
+            TENANT_TABLE.add("airag_flow");
+            TENANT_TABLE.add("airag_knowledge");
+            TENANT_TABLE.add("airag_knowledge_doc");
+            TENANT_TABLE.add("airag_model");
         }
 
         //2.示例测试
@@ -111,7 +130,23 @@ public class MybatisPlusSaasConfig {
         //update-begin-author:zyf date:20220425 for:【VUEN-606】注入动态表名适配拦截器解决多表名问题
         interceptor.addInnerInterceptor(dynamicTableNameInnerInterceptor());
         //update-end-author:zyf date:20220425 for:【VUEN-606】注入动态表名适配拦截器解决多表名问题
-        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
+        
+        //update-begin---author:scott ---date:2025-08-02  for：【issues/8666】升级mybatisPlus后SqlServer分页使用OFFSET ？ ROWS FETCH NEXT ？ ROWS ONLY，导致online报表报错---
+        DbType dbType = null;
+        try {
+             dbType = JdbcUtils.getDbType(dataSource.getConnection().getMetaData().getURL());
+             log.info("当前数据库类型: {}", dbType);
+        } catch (SQLException e) {
+            Log.error(e.getMessage(), e);
+        }
+        if (dbType!=null && (dbType == DbType.SQL_SERVER || dbType == DbType.SQL_SERVER2005)) {
+            // 如果是SQL Server则覆盖为2005分页方式
+            interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQL_SERVER2005));
+        } else {
+            interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
+        }
+        //update-end---author:scott ---date::2025-08-02  for：【issues/8666】升级mybatisPlus后SqlServer分页使用OFFSET ？ ROWS FETCH NEXT ？ ROWS ONLY，导致online报表报错---
+        
         //【jeecg-boot/issues/3847】增加@Version乐观锁支持 
         interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
         return interceptor;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/aspect/DynamicTableAspect.java

@@ -11,7 +11,7 @@ import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.config.mybatis.ThreadLocalDataHelper;
 import org.springframework.stereotype.Component;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 import java.lang.reflect.Method;
 
 /**