Merge pull request #8256 from MuShan-bit/springboot3-chore-upgrade-shiro

upgrade shiro to 2.0.4

README-AI.md

@@ -1,177 +0,0 @@
-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.8.2 (Release date: 2025-08-04)
+Current version: 3.7.3 (Release date: 2025-02-10)
 
 
 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/zhangdaiscott/jeecg-boot/blob/master/LICENSE)
 [![](https://img.shields.io/badge/Author-guojusoft-orange.svg)](http://www.jeecg.com)
-[![](https://img.shields.io/badge/version-3.8.2-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/version-3.7.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)
 
@@ -21,7 +21,7 @@ Current version: 3.8.2 (Release date: 2025-08-04)
 Project introduction
 -----------------------------------
 
-<h3 align="center">Java AI Low Code Platform</h3>
+<h3 align="center">Java AI Low Code Platform for Enterprise web applications</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?template=bug_report.md)
+Problems or bugs in use can be found in [Making on the Issues](https://github.com/jeecgboot/JeecgBoot/issues/new)
 
 
 ##### Project description
@@ -49,11 +49,6 @@ 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
 -----------------------------------
@@ -69,8 +64,8 @@ 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)
-- [Docker Quick start](https://help.jeecg.com/java/docker/quick)
+- [IDEA Quick start](https://help.jeecg.com/java/setup/idea/startup.html)
+- [Docker Quick start](https://help.jeecg.com/java/docker/quick.html)
 
 
 
@@ -79,9 +74,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)
+- Doc：  [DocumentCenter](http://help.jeecg.com) | [AI Config](https://help.jeecg.com/java/ai/aichat.html)
 - 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 ： 964611995、⑩716488839(满)、⑨808791225(满)
+- QQ group ： ⑩716488839、⑨808791225、⑧825232878、⑦791696430、⑥730954414(full)、683903138(full)、⑤860162132(full)、④774126647(full)、③816531124(full)、②769925425(full)、①284271917(full)
 
 
 
@@ -181,7 +176,7 @@ Technical Architecture:
 
 #### Development Environment
 
-- Language: Java Default Jdk17(support jdk8、jdk21)
+- Language: Java 8+ (17)
 
 - IDE(JAVA) : IDEA (lombok plug-in must be installed)
 
@@ -198,17 +193,17 @@ Technical Architecture:
 
 - Basic framework: Spring Boot 2.7.18
 
-- Microservice framework: Spring Cloud Alibaba 2021.0.6.2
+- Microservice framework: Spring Cloud Alibaba 2021.0.1.0
 
 - Persistence layer framework: MybatisPlus 3.5.3.2
 
-- Report tool: JimuReport 1.9.5
+- Report tool: JimuReport 1.9.3
 
-- Security framework: Apache Shiro 1.13.0, Jwt 4.5.0
+- Security framework: Apache Shiro 1.12.0, Jwt 3.11.0
 
 - Microservice technology stack: Spring Cloud Alibaba, Nacos, Gateway, Sentinel, Skywalking
 
-- Database connection pool: Alibaba Druid 1.1.24
+- Database connection pool: Alibaba Druid 1.1.22
 
 - Log printing: logback
 
@@ -247,16 +242,8 @@ 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
 
@@ -268,7 +255,7 @@ AI APP: https://help.jeecg.com/aigc
 - 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)
+- 9. link tracking Skywalking  [reference document](https://help.jeecg.com/java/springcloud/super/skywarking.html)
 - 10. Messaging middleware RabbitMQ √
 - 11. Distributed task xxl-job √
 - 12. Distributed Transaction Seata
@@ -285,8 +272,8 @@ AI APP: https://help.jeecg.com/aigc
 ![功能蓝图](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)
-- [Docker starts the micro-service background](https://help.jeecg.com/java/docker/springcloud)
+- 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)
 
 
 ### Effect of system

README-Enterprise.md

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

README.md

@@ -2,13 +2,12 @@
 JeecgBoot AI低代码平台
 ===============
 
-当前最新版本： 3.8.2（发布日期：2025-08-04） 
+当前最新版本： 3.7.3（发布日期：2025-02-10） 
 
 
 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/jeecgboot/JeecgBoot/blob/master/LICENSE)
-[![](https://img.shields.io/badge/Author-北京国炬软件-orange.svg)](https://jeecg.com)
-[![](https://img.shields.io/badge/blog-技术博客-orange.svg)](https://jeecg.blog.csdn.net)
-[![](https://img.shields.io/badge/version-3.8.2-brightgreen.svg)](https://github.com/jeecgboot/JeecgBoot)
+[![](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)
 [![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)
 
@@ -17,57 +16,38 @@ JeecgBoot AI低代码平台
 项目介绍
 -----------------------------------
 
-<h3 align="center">企业级AI低代码平台</h3>
+<h3 align="center">Java AI Low Code Platform for Enterprise web applications</h3>
 
-JeecgBoot是一款企业级低代码平台集成了AI应用平台功能，旨在帮助开发者快速实现低代码开发和构建、部署个性化的 AI 应用。
-前后端分离架构Ant Design4、Vue3，SpringBoot，SpringCloud Alibaba，Mybatis-plus，Shiro/SpringAuthorizationServer，强大的代码生成器让前后端代码一键生成，无需写任何代码；提供强大的报表和大屏工具，满足企业级数据产品需求！
-引领AI低代码开发模式: AI生成->OnlineCoding-> 代码生成-> 手工MERGE， 帮助Java项目解决80%的重复工作，让开发更多关注业务，提高效率、节省成本，同时又不失灵活性！低代码能力：Online表单、表单设计、流程设计、Online报表、大屏/仪表盘设计、报表设计; AI应用平台功能：AI知识库问答、AI模型管理、AI流程编排、AI聊天等，支持含ChatGPT、DeepSeek、Ollama等多种AI大模型
+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 提供了一系列 `AI能力` `低代码模块`，实现在线开发`真正的零代码`：Online表单开发、Online报表、报表配置能力、在线图表设计、仪表盘设计、大屏设计、移动配置能力、表单设计器、在线设计流程、流程自动化配置、插件能力（可插拔）、AI对话助手，AI建表、AI写文章、AI流程编排、AI知识库问答、AI赋能低代码等等！
 
 
-`AI赋能低代码:` 提供一套成熟AI应用平台功能：包含AI应用管理、AI模型管理、AI对话助手、AI知识库问答、AI流程编排、AI流程设计器，AI建表等功能; 支持各种AI大模型ChatGPT、DeepSeek、Ollama、智普、千问等.
-
-`JEECG宗旨是:` 简单功能由OnlineCoding零代码搭建，做到`零代码开发`；复杂功能由代码生成器生成进行手工Merge 实现`低代码开发`，既保证了`智能`又兼顾`灵活`，解决了当前低代码产品普遍不灵活的弊端！
+`JEECG宗旨是:` 简单功能由OnlineCoding配置实现，做到`零代码开发`；复杂功能由代码生成器生成进行手工Merge 实现`低代码开发`，既保证了`智能`又兼顾`灵活`；实现了低代码开发的同时又支持灵活编码，解决了当前低代码产品普遍不灵活的弊端！
 
 `JEECG业务流程:` 采用工作流来实现、扩展出任务接口，供开发编写业务逻辑，表单提供多种解决方案： 表单设计器、online配置表单、编码表单。同时实现了流程与表单的分离设计（松耦合）、并支持任务节点灵活配置，既保证了公司流程的保密性，又减少了开发人员的工作量。
 
-
-
+`AI赋能低代码:` 目前JeecgBoot支持AI大模型`ChatGPT`和`DeepSeek`，现在最新版默认使用`DeepSeek`，速度更快质量更高。目前提供了AI对话助手、AI建表、AI报表、AI写文章、AI流程编排、AI知识库问答等功能。
 
 
 适用项目
 -----------------------------------
-JeecgBoot低代码平台，可以应用在任何J2EE项目的开发中，支持信创国产化。尤其适合SAAS项目、企业信息管理系统（MIS）、内部办公系统（OA）、企业资源计划系统（ERP）、客户关系管理系统（CRM）、AI知识库等，其半智能手工Merge的开发方式，可以显著提高开发效率70%以上，极大降低开发成本。
-又是一个全栈式 AI 开发平台，快速帮助企业构建和部署个性化的 AI 应用。
-
-**信创兼容说明**
-- 操作系统：国产麒麟、银河麒麟等国产系统几乎都是基于 Linux 内核，因此它们具有良好的兼容性。
-- 数据库：达梦、人大金仓、TiDB
-- 中间件：东方通 TongWeb、TongRDS，宝兰德 AppServer、CacheDB, [信创配置文档](https://help.jeecg.com/java/tongweb-deploy/)
-
-
-版本说明
------------------------------------
-
-|下载    | JDK17/JDK8 + SpringBoot2.7                              | JDK17 + SpringBoot3.3 + Shiro                                               |JDK17 + SpringBoot3.3+ SpringAuthorizationServer   |
-|------|----------------------------------------------------|-----------------------------------------------------------------------------|--------------------------------------------|
-| Github | [`master`](https://github.com/jeecgboot/JeecgBoot) | [`springboot3`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3) 分支 | [`springboot3_sas`](https://github.com/jeecgboot/JeecgBoot/tree/springboot3_sas) 分支 |
-| Gitee | [`master`](https://gitee.com/jeecg/JeecgBoot)      | [`springboot3`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3/) 分支     | [`springboot3_sas`](https://gitee.com/jeecg/JeecgBoot/tree/springboot3_sas) 分支 |
-
-
-- `jeecg-boot` 是后端JAVA源码项目（支持单体和微服务切换）.
-- `jeecgboot-vue3` 是前端VUE3源码项目（vue3+vite6+ts最新技术栈）.
-- `JeecgUniapp`  是[配套APP框架](https://github.com/jeecgboot/JeecgUniapp) 适配多个终端，支持APP、小程序、H5、鸿蒙、鸿蒙Next.
-- 参考 [文档](https://help.jeecg.com/ui/2dev/mini) 可以删除不需要的demo，制作一个精简版本
+JeecgBoot AI低代码平台，可以应用在任何J2EE项目的开发中，支持信创国产化（默认适配达梦和人大金仓）。尤其适合SAAS项目、企业信息管理系统（MIS）、内部办公系统（OA）、企业资源计划系统（ERP）、客户关系管理系统（CRM）等，其半智能手工Merge的开发方式，可以显著提高开发效率70%以上，极大降低开发成本。
 
 
 
+### 视频介绍
+
+[![](https://upload.jeecg.com/jeecg/qiaoqiaoyunsite/jeecgvideo02.png)](https://www.bilibili.com/video/BV1Nk4y1o7Qc)
 
 
-启动项目
------------------------------------
+#### 项目说明
 
-- [IDEA启动前后端项目](https://help.jeecg.com/java/setup/idea/startup)
-- [Docker一键启动前后端](https://help.jeecg.com/java/docker/quick)
+| 项目名                | 说明                     | 
+|--------------------|------------------------|
+| `jeecg-boot`    | 后端源码JAVA（SpringBoot微服务架构）        |
+| `jeecgboot-vue3` | 前端源码VUE3（vue3+vite6+ts最新技术栈）  |
+| `jeecg-uniapp` | [配套APP框架](https://github.com/jeecgboot/jeecg-uniapp) 适配多个终端，支持APP、小程序、H5 |
 
 
 
@@ -75,108 +55,82 @@ JeecgBoot低代码平台，可以应用在任何J2EE项目的开发中，支持
 -----------------------------------
 
 - 官方网站：  [http://www.jeecg.com](http://www.jeecg.com)
-- 入门指南：  [快速入门](http://www.jeecg.com/doc/quickstart)  | [开发文档](https://help.jeecg.com)  | [AI应用使用手册](https://help.jeecg.com/aigc)  |  [技术博客](https://jeecg.blog.csdn.net)
-- 技术支持：  [反馈问题](https://github.com/jeecgboot/JeecgBoot/issues/new?template=bug_report.md)  | [视频教程](http://jeecg.com/doc/video)  | [低代码体验一分钟](https://jeecg.blog.csdn.net/article/details/106079007) 
-- QQ交流群 ： 964611995、⑩716488839(满)、⑨808791225(满)、其他(满)
+- 在线演示 ：  [在线演示](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(满)、其他(满)
 
 
-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)
+- [IDEA启动前后端项目](https://help.jeecg.com/java/setup/idea/startup.html)
+- [Docker一键启动前后端](https://help.jeecg.com/java/docker/quick.html)
 
 
-为什么选择JeecgBoot?
+AIGC功能清单
 -----------------------------------
-- 1.采用最新主流前后分离框架（Spring Boot + MyBatis + 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.提供丰富的示例代码，涵盖了常用的业务场景，便于学习和参考。
 
+- AI对聊天助手
+- AI建表（Online表单）
+- AI写文章（CMS）
+- AI表单建议（表单设计器）
+- AI流程编排（研发中）
+- AI知识库问答系统（研发中）
+- AI应用开发平台（研发中）
+- AI聊天窗口支持嵌入第三方（研发中）
+
+
+<b>关注公众号了解官方动态</b>
+
+![公众号](https://jeecg.com/images/jeecg/qrcode_jeecgboot.jpg "在这里输入图片标题")
 
 
 技术架构：
 -----------------------------------
 
-#### 前端
-
-- 前端环境要求：Node.js要求`Node 20+` 版本以上、pnpm 要求`9+` 版本以上
-- 依赖管理：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 默认jdk17(支持jdk8、jdk21)
+- 语言：Java 8+ (支持17)
 - 依赖管理：Maven
 - 基础框架：Spring Boot 2.7.18
-- 微服务框架： Spring Cloud Alibaba 2021.0.6.2
+- 微服务框架： Spring Cloud Alibaba 2021.0.1.0
 - 持久层框架：MybatisPlus 3.5.3.2
-- 报表工具： JimuReport 1.9.5
-- 安全框架：Apache Shiro 1.13.0，Jwt 4.5.0
+- 报表工具： JimuReport 1.9.3
+- 安全框架：Apache Shiro 1.12.0，Jwt 3.11.0
 - 微服务技术栈：Spring Cloud Alibaba、Nacos、Gateway、Sentinel、Skywalking
-- 数据库连接池：阿里巴巴Druid 1.1.24
+- 数据库连接池：阿里巴巴Druid 1.1.22
 - AI大模型：支持 `ChatGPT` `DeepSeek`切换
 - 日志打印：logback
 - 缓存：Redis
 - 其他：autopoi, fastjson，poi，Swagger-ui，quartz, lombok（简化代码）等。
-- 默认提供MySQL5.7+数据库脚本
+- 默认数据库脚本：MySQL5.7+
+- [其他数据库，需要自己转](https://my.oschina.net/jeecg/blog/4905722)
 
-#### 数据库支持
 
-> jeecgboot平台支持以下数据库，默认我们只提供mysql脚本，其他数据库可以参考[转库文档](https://my.oschina.net/jeecg/blog/4905722)自己转。
+#### 前端
+
+- 前端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+ )`
+
+
+#### 支持库
 
 |  数据库   |  支持   |
 | --- | --- |
@@ -185,21 +139,24 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 |  Sqlserver2017   |  √   |
 |   PostgreSQL   |  √   |
 |   MariaDB   |  √   |
+|   MariaDB   |  √   |
 |   达梦   |  √   |
 |   人大金仓   |  √   |
 |   TiDB     |  √   |
-|   kingbase8   |  √   |
 
+#### 支持AI大模型
 
+|  AI大模型   |  支持   |
+| --- | --- |
+|   DeepSeek   |  √   |
+|   ChatGTP   |  √   |
+|   Ollama本地搭建大模型   |  √   |
+
+AI集成文档： https://help.jeecg.com/java/ai/aichat.html
 
  
 ## 微服务解决方案
 
-> 微服务方式快速启动
-> - [单体快速切换微服务](https://help.jeecg.com/java/springcloud/switchcloud/monomer)
-> - [Docker一键启动微服务前后端](https://help.jeecg.com/java/docker/quickcloud)
-
-
 
 - 1、服务注册和发现 Nacos √
 - 2、统一配置中心 Nacos  √
@@ -209,7 +166,7 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 - 6、分布式文件 Minio、阿里OSS √ 
 - 7、统一权限控制 JWT + Shiro √
 - 8、服务监控 SpringBootAdmin√
-- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking)
+- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking.html)
 - 10、消息中间件 RabbitMQ  √
 - 11、分布式任务 xxl-job  √ 
 - 12、分布式事务 Seata
@@ -218,23 +175,62 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 - 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?
 -----------------------------------
-
- - JeecgBoot开源版采用 [Apache-2.0 license](LICENSE) 协议附加补充条款：允许商用使用，不会造成侵权行为，允许基于本平台软件开展业务系统开发（但在任何情况下，您不得使用本软件开发可能被认为与本软件竞争的软件).
- - 商业版与开源版主要区别在于商业版提供了技术支持 和 更多的企业级功能(例如：Online图表、流程监控、流程设计、流程审批、表单设计器、表单视图、积木报表企业版、OA办公、商业APP、零代码应用、Online模块源码等功能). [更多商业功能介绍，点击查看](README-Enterprise.md)
- - JeecgBoot未来发展方向是：零代码平台的建设，也就是团队的另外一款产品 [敲敲云零代码](https://www.qiaoqiaoyun.com) ，无需编码即可通过拖拽快速搭建企业级应用，与JeecgBoot低代码平台形成互补，满足从简单业务到复杂系统的全场景开发需求，目前已经开源，[欢迎下载](https://qiaoqiaoyun.com/downloadCode)
-
-
-
-
+* 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.提供仪表盘设计器，类大屏设计支持移动端，免费的数据可视化设计工具，支持丰富的数据源连接，能够通过拖拉拽方式快速制作图表和门户设计；目前支持多种图表类型：柱形图、折线图、散点图、饼图、环形图、面积图、漏斗图、进度图、仪表盘、雷达图、地图等等；
 
 
 ### Jeecg Boot 产品功能蓝图
@@ -242,19 +238,47 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 
 
 
-####  系统功能架构图
 
-![](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）
 ├─系统管理
 │  ├─用户管理
 │  ├─角色管理
 │  ├─菜单管理
-│  ├─首页配置
 │  ├─权限设置（支持按钮权限、数据权限）
 │  ├─表单权限（控制字段禁用、隐藏）
 │  ├─部门管理
@@ -265,36 +289,7 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 │  └─职务管理
 │  └─通讯录
 │  ├─多数据源管理
-│  ├─白名单管理
-│  ├─第三方配置（对接钉钉和企业微信）
-│  └─多租户管理（租户管理、租户角色、我的租户、租户默认套餐管理）
-├─Online在线开发(低代码)
-│  ├─Online在线表单
-│  ├─Online代码生成器
-│  ├─Online在线报表
-│  ├─仪表盘设计器
-│  ├─系统编码规则
-│  ├─系统校验规则
-│  ├─APP版本管理
-├─AI应用平台
-│  ├─AI知识库问答系统
-│  ├─AI大模型管理
-│  ├─AI流程编排
-│  ├─AI流程设计器
-│  ├─AI对话支持图片
-│  ├─AI对话助手(智能问答)
-│  ├─AI建表（Online表单）
-│  ├─AI聊天窗口支持嵌入第三方
-│  ├─AI聊天窗口支持移动端
-│  ├─支持常见大模型ChatGPT和DeepSeek、ollama等等
-│  ├─AI OCR示例
-├─数据可视化
-│  ├─报表设计器(支持打印设计）
-│  ├─大屏设和仪表盘设计
-├─OpenAPI（基于AK和SK认证鉴权）
-│  ├─接口管理
-│  ├─接口授权
-│  ├─接口文档
+│  └─多租户管理（租户管理、租户角色、我的租户）
 ├─消息中心
 │  ├─消息管理
 │  ├─模板管理
@@ -306,12 +301,8 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 │  ├─高级查询器（弹窗自动组合查询条件）
 │  ├─Excel导入导出工具集成（支持单表，一对多 导入导出）
 │  ├─平台移动自适应支持
-│  ├─提供新版uniapp3的代码生成器模板
 ├─系统监控
 │  ├─Gateway路由网关
-│  ├─基于AK和SK认证鉴权OpenAPI功能
-│  ├─定时任务
-│  ├─数据源管理
 │  ├─性能扫描监控
 │  │  ├─监控 Redis
 │  │  ├─Tomcat
@@ -319,11 +310,13 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 │  │  ├─服务器信息
 │  │  ├─请求追踪
 │  │  ├─磁盘监控
+│  ├─定时任务
 │  ├─系统日志
 │  ├─消息中心（支持短信、邮件、微信推送等等）
 │  ├─数据日志（记录数据快照，可对比快照，查看数据变更情况）
+│  ├─系统通知
 │  ├─SQL监控
-│  ├─在线用户
+│  ├─swagger-ui(在线接口文档)
 │─报表示例
 │  ├─曲线图
 │  └─饼状图
@@ -388,16 +381,46 @@ JeecgBoot平台提供了一套完善的AI应用管理系统模块，是一套类
 │  ├─提供单点登录CAS集成方案
 │  ├─提供APP发布方案
 │  ├─集成Websocket消息通知机制
-│  ├─支持electron桌面应用打包(支持windows、linux、macOS三大平台)
-│  ├─docker容器支持
-│  ├─提供移动APP框架及源码（Uniapp3版本）支持H5、小程序、APP、鸿蒙Next
-│  ├─提供移动APP低代码设计(Online表单、仪表盘)
+│─更多商业功能
+│  ├─流程设计器
+│  ├─表单设计器
+│  ├─大屏设计器
+│  └─我的任务
+│  └─历史流程
+│  └─历史流程
+│  └─流程实例管理
+│  └─流程监听管理
+│  └─流程表达式
+│  └─我发起的流程
+│  └─我的抄送
+│  └─流程委派、抄送、跳转
+│  └─OA办公组件
+│  └─。。。
+   
 ```
 
 
 
 ### 系统效果
 
+
+##### 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)
 
@@ -417,22 +440,6 @@ JeecgBoot平台提供了一套完善的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)
-
 
 #####  仪表盘设计器
 
@@ -499,6 +506,28 @@ 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)
+
 
 
 

docker-compose-cloud.yml

@@ -18,33 +18,20 @@ services:
       --max_allowed_packet=128M
       --default-authentication-plugin=caching_sha2_password
     ports:
-      - 13306:3306
+      - 3306: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:
@@ -134,7 +121,6 @@ services:
   jeecg-vue:
     build:
       context: ./jeecgboot-vue3
-      dockerfile: Dockerfile.cloud
     container_name: jeecgboot-vue3-nginx
     image: jeecgboot-vue3
     depends_on:

docker-compose.yml

@@ -18,33 +18,20 @@ services:
       --max_allowed_packet=128M
       --default-authentication-plugin=caching_sha2_password
     ports:
-      - 13306:3306
+      - 3306:3306
     networks:
       - jeecg-boot
 
   jeecg-boot-redis:
     image: registry.cn-hangzhou.aliyuncs.com/jeecgdocker/redis:5.0
-    # ports:
-    #   - 3792: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-system:
     build:
       context: ./jeecg-boot/jeecg-module-system/jeecg-system-start

jeecg-boot/README.md

@@ -2,12 +2,12 @@
 JeecgBoot 低代码开发平台
 ===============
 
-当前最新版本： 3.8.2（发布日期：2025-08-04） 
+当前最新版本： 3.7.3（发布日期：2025-02-10） 
 
 
 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/zhangdaiscott/jeecg-boot/blob/master/LICENSE)
 [![](https://img.shields.io/badge/Author-北京国炬软件-orange.svg)](http://jeecg.com/aboutusIndex)
-[![](https://img.shields.io/badge/version-3.8.2-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/version-3.7.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)
 
@@ -35,7 +35,7 @@ JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端
 
 - 官方网站：  [http://www.jeecg.com](http://www.jeecg.com)
 - 新手指南： [快速入门](http://www.jeecg.com/doc/quickstart)
-- QQ交流群 ： 964611995、⑩716488839(满)、⑨808791225(满)、其他(满)
+- QQ交流群 ： ⑩716488839、⑨808791225、其他(满)
 - 在线演示 ：  [在线演示](http://boot3.jeecg.com)   | [APP演示](http://jeecg.com/appIndex)
 > 演示系统的登录账号密码，请点击 [获取账号密码](http://jeecg.com/doc/demo) 获取 
 
@@ -44,14 +44,14 @@ JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端
 启动项目
 -----------------------------------
 
-- [IDEA启动前后端项目](https://help.jeecg.com/java/setup/idea/startup)
-- [Docker一键启动前后端](https://help.jeecg.com/java/docker/quick)
+- [IDEA启动前后端项目](https://help.jeecg.com/java/setup/idea/startup.html)
+- [Docker一键启动前后端](https://help.jeecg.com/java/docker/quick.html)
 
 
 微服务启动
 -----------------------------------
-- [单体快速切换微服务](https://help.jeecg.com/java/springcloud/switchcloud/monomer)
-- [Docker启动微服务后台](https://help.jeecg.com/java/docker/springcloud)
+- [单体快速切换微服务](https://help.jeecg.com/java/springcloud/switchcloud/monomer.html)
+- [Docker启动微服务后台](https://help.jeecg.com/java/docker/springcloud.html)
 
 
 
@@ -66,10 +66,10 @@ JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端
 - 基础框架：Spring Boot 2.7.18
 - 微服务框架： Spring Cloud Alibaba 2021.0.1.0
 - 持久层框架：MybatisPlus 3.5.3.2
-- 报表工具： JimuReport 1.9.4
+- 报表工具： JimuReport 1.8.1
 - 安全框架：Apache Shiro 1.12.0，Jwt 3.11.0
 - 微服务技术栈：Spring Cloud Alibaba、Nacos、Gateway、Sentinel、Skywalking
-- 数据库连接池：阿里巴巴Druid 1.1.24
+- 数据库连接池：阿里巴巴Druid 1.1.22
 - 日志打印：logback
 - 缓存：Redis
 - 其他：autopoi, fastjson，poi，Swagger-ui，quartz, lombok（简化代码）等。
@@ -113,7 +113,7 @@ JeecgBoot 是一款基于代码生成器的`低代码开发平台`！前后端
 - 6、分布式文件 Minio、阿里OSS √ 
 - 7、统一权限控制 JWT + Shiro √
 - 8、服务监控 SpringBootAdmin√
-- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking)
+- 9、链路跟踪 Skywalking   [参考文档](https://help.jeecg.com/java/springcloud/super/skywarking.html)
 - 10、消息中间件 RabbitMQ  √
 - 11、分布式任务 xxl-job  √ 
 - 12、分布式事务 Seata

jeecg-boot/db/版本升级说明.md

@@ -3,6 +3,7 @@
 > JeecgBoot属于平台级产品，每次升级改动较大，目前做不到平滑升级。
 
 ### 增量升级方案
+
 #### 1.代码合并
  本地通过svn或git做好主干，在分支上做业务开发，jeecg每次版本发布，可以手工覆盖主干的代码，对比合并代码；
 
@@ -11,5 +12,12 @@
 - 其他库请手工执行SQL, 目录： `jeecg-module-system\jeecg-system-start\src\main\resources\flyway\sql\mysql`
 > 注意： 升级sql只提供mysql版本；如果有权限升级, 还需要手工角色授权，退出重新登录才好使。
 
-#### 3.兼容问题
+#### 3.其他数据库脚本说明
+  原先官方默认提供oracle和SqlServer的脚本，但是维护成本太高，未提供脚本的数据库，可以参考下面的文档自己转
+   https://my.oschina.net/jeecg/blog/4905722
+   （注意：定时任务的表qrtz_*，需要删掉用原始的脚本重新执行一下）
+   quartz-2.2.3-distribution.tar.gz放到百度网盘中，大家自己下载，执行所需数据库脚本
+   https://pan.baidu.com/s/1WrmZdUuAPg3iBwJ-LoHWyg?pwd=8mdz 
+
+#### 4.兼容问题
  每次发版，会针对不兼容地方重点说明。

jeecg-boot/docker-compose.yml

@@ -18,7 +18,7 @@ services:
       --max_allowed_packet=128M
       --default-authentication-plugin=caching_sha2_password
     ports:
-      - 13306:3306
+      - 3306:3306
     networks:
       - jeecg-boot
 
@@ -32,19 +32,6 @@ services:
     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-module-system/jeecg-system-start

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

@@ -4,11 +4,15 @@
 	<parent>
 		<groupId>org.jeecgframework.boot</groupId>
 		<artifactId>jeecg-boot-parent</artifactId>
-		<version>3.8.2</version>
+		<version>3.7.3</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jeecg-boot-base-core</artifactId>
 
+	<properties>
+		<spring-boot.version>3.1.5</spring-boot.version>
+	</properties>
+
 	<repositories>
 		<repository>
 			<id>aliyun</id>
@@ -43,7 +47,7 @@
 		<!--jeecg-tools-->
 		<dependency>
 			<groupId>org.jeecgframework.boot</groupId>
-			<artifactId>jeecg-boot-common</artifactId>
+			<artifactId>jeecg-boot-common3</artifactId>
 		</dependency>
 		<!--集成springmvc框架并实现自动配置 -->
 		<dependency>
@@ -111,28 +115,18 @@
 			<artifactId>mybatis-plus-boot-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</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>
 
@@ -183,6 +177,7 @@
 			<artifactId>DmDialect-for-hibernate5.0</artifactId>
 			<version>${dm8.version}</version>
 		</dependency>
+      
 
 		<!-- Quartz定时任务 -->
 		<dependency>
@@ -201,7 +196,14 @@
 		<dependency>
 			<groupId>org.apache.shiro</groupId>
 			<artifactId>shiro-spring-boot-starter</artifactId>
+			<classifier>jakarta</classifier>
 			<version>${shiro.version}</version>
+			<exclusions>
+				<exclusion>
+					<groupId>org.apache.shiro</groupId>
+					<artifactId>shiro-spring</artifactId>
+				</exclusion>
+			</exclusions>
 		</dependency>
 		<!-- shiro-redis -->
 		<dependency>
@@ -217,13 +219,61 @@
 					<artifactId>checkstyle</artifactId>
 					<groupId>com.puppycrawl.tools</groupId>
 				</exclusion>
+				<!-- TODO shiro 无法使用 spring boot 3.X 自带的jedis，降版本处理 -->
+				<exclusion>
+					<artifactId>jedis</artifactId>
+					<groupId>redis.clients</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<!-- TODO shiro 无法使用 spring boot 3.X 自带的jedis，降版本处理 -->
+		<dependency>
+			<groupId>redis.clients</groupId>
+			<artifactId>jedis</artifactId>
+			<version>${jedis.version}</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.apache.shiro</groupId>
+			<artifactId>shiro-spring</artifactId>
+			<classifier>jakarta</classifier>
+			<version>${shiro.version}</version>
+			<!-- 排除仍使用了javax.servlet的依赖 -->
+			<exclusions>
+				<exclusion>
+					<groupId>org.apache.shiro</groupId>
+					<artifactId>shiro-core</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.apache.shiro</groupId>
+					<artifactId>shiro-web</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<!-- 引入适配jakarta的依赖包 -->
+		<dependency>
+			<groupId>org.apache.shiro</groupId>
+			<artifactId>shiro-core</artifactId>
+			<classifier>jakarta</classifier>
+			<version>${shiro.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.shiro</groupId>
+			<artifactId>shiro-web</artifactId>
+			<classifier>jakarta</classifier>
+			<version>${shiro.version}</version>
+			<exclusions>
+				<exclusion>
+					<groupId>org.apache.shiro</groupId>
+					<artifactId>shiro-core</artifactId>
+				</exclusion>
 			</exclusions>
 		</dependency>
 
 		<!-- knife4j -->
 		<dependency>
 			<groupId>com.github.xiaoymin</groupId>
-			<artifactId>knife4j-openapi3-spring-boot-starter</artifactId>
+			<artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
 			<version>${knife4j-spring-boot-starter.version}</version>
 		</dependency>
 
@@ -233,21 +283,11 @@
 			<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>
@@ -272,12 +312,6 @@
 		<dependency>
 			<groupId>io.minio</groupId>
 			<artifactId>minio</artifactId>
-			<exclusions>
-				<exclusion>
-					<artifactId>checker-qual</artifactId>
-					<groupId>org.checkerframework</groupId>
-				</exclusion>
-			</exclusions>
 		</dependency>
 
 		<!-- 阿里云短信 -->
@@ -296,6 +330,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>
@@ -319,10 +363,11 @@
 			<groupId>cn.hutool</groupId>
 			<artifactId>hutool-crypto</artifactId>
 		</dependency>
+
 		<!-- chatgpt -->
 		<dependency>
 			<groupId>org.jeecgframework.boot</groupId>
-			<artifactId>jeecg-boot-starter-chatgpt</artifactId>
+			<artifactId>jeecg-boot-starter3-chatgpt</artifactId>
 		</dependency>
 	</dependencies>
 </project>

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,12 +91,6 @@ 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,7 +1,6 @@
 package org.jeecg.common.api.vo;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import org.jeecg.common.constant.CommonConstant;

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

@@ -21,13 +21,14 @@ 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;
 
@@ -172,7 +173,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++) {

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

@@ -303,11 +303,6 @@ public interface CommonConstant {
      */
     String SYS_USER_ID_MAPPING_CACHE = "sys:cache:user:id_mapping";
 
-    /**
-     * 系统角色管理员编码
-     */
-    String SYS_ROLE_ADMIN = "admin";
-
     /**
      * 考勤补卡业务状态 （1：同意  2：不同意）
      */
@@ -433,11 +428,6 @@ public interface CommonConstant {
     */
    String NOTICE_MSG_BUS_TYPE = "NOTICE_MSG_BUS_TYPE";
 
-    /**
-     * 通知类型，用于区分来源 file 知识 flow 流程 plan 日程 system 系统消息 
-     */
-    String NOTICE_TYPE = "noticeType";
-
     /**
      * 邮箱消息中地址登录时地址后携带的token,需要替换成真实的token值
      */
@@ -639,24 +629,4 @@ public interface CommonConstant {
     * 修改手机号验证码请求次数超出
     */
    Integer PHONE_SMS_FAIL_CODE = 40002;
-
-
-    /**
-     * 自定义首页关联关系(ROLE:表示角色 USER:表示用户)
-     *
-     */
-    String HOME_RELATION_ROLE = "ROLE";
-    String HOME_RELATION_USER = "USER";
-
-    /**
-     * 是否置顶(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:";
 }

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

@@ -4,20 +4,6 @@ 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/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,10 +13,6 @@ 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/NoticeTypeEnum.java

@@ -1,75 +0,0 @@
-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");
-
-    /**
-     * 文件类型名称
-     */
-    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/exception/JeecgBootAssertException.java

@@ -1,21 +0,0 @@
-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,7 +1,8 @@
 package org.jeecg.common.exception;
 
 import cn.hutool.core.util.ObjectUtil;
-import io.undertow.server.RequestTooBigException;
+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;
@@ -24,20 +25,14 @@ 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;
 
 /**
  * 异常处理器
@@ -52,13 +47,6 @@ 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(",")));
-	}
-	
 	/**
 	 * 处理自定义异常
 	 */
@@ -168,27 +156,6 @@ 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 && cause.getCause() instanceof RequestTooBigException) {
-			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);
@@ -244,16 +211,11 @@ public class JeecgBootExceptionHandler {
         } catch (NullPointerException | BeansException ignored) {
         }
         if (null != request) {
-			//update-begin---author:chenrui ---date:20250408  for：[QQYUN-11716]上传大图片失败没有精确提示------------
 			//请求的参数
-			if (!isTooBigException(e)) {
-				// 文件上传过大异常时不能获取参数,否则会报错
-				Map<String, String[]> parameterMap = request.getParameterMap();
-				if(!CollectionUtils.isEmpty(parameterMap)) {
-					log.setMethod(oConvertUtils.mapToString(request.getParameterMap()));
-				}
+			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地址
@@ -279,26 +241,4 @@ 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 && cause.getCause() instanceof RequestTooBigException){
-				isTooBigException = true;
-			}
-		}
-		if(e instanceof MaxUploadSizeExceededException){
-			isTooBigException = true;
-		}
-		return isTooBigException;
-	}
-
 }

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

@@ -23,9 +23,9 @@ 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.*;
 

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

@@ -9,10 +9,10 @@ import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.fasterxml.jackson.annotation.JsonFormat;
 
-import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
+import io.swagger.v3.oas.annotations.media.Schema;
 
 /**
  * @Description: Entity基类

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

@@ -6,16 +6,18 @@ import com.auth0.jwt.algorithms.Algorithm;
 import com.auth0.jwt.exceptions.JWTDecodeException;
 import com.auth0.jwt.interfaces.DecodedJWT;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Joiner;
 
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Date;
 import java.util.Objects;
 import java.util.stream.Collectors;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
+
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpSession;
 
 import lombok.extern.slf4j.Slf4j;
 import org.apache.shiro.SecurityUtils;
@@ -200,13 +202,11 @@ public class JwtUtil {
 		}
 		//update-begin---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 		// 是否存在字符串标志
-		boolean multiStr;
+		boolean multiStr = false;
 		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)) {
@@ -289,15 +289,7 @@ public class JwtUtil {
 					//update-begin---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 					returnValue = user.getSysMultiOrgCode().stream()
 							.filter(Objects::nonNull)
-							//update-begin---author:chenrui ---date:20250224  for：[issues/7288]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
-							.map(orgCode -> {
-								if (multiStr) {
-									return "'" + orgCode + "'";
-								} else {
-									return orgCode;
-								}
-							})
-							//update-end---author:chenrui ---date:20250224  for：[issues/7288]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
+							.map(orgCode -> "'" + orgCode + "'")
 							.collect(Collectors.joining(", "));
 					//update-end---author:chenrui ---date:20250107  for：[QQYUN-10785]数据权限，查看自己拥有部门的权限中存在问题 #7288------------
 				}

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

@@ -68,12 +68,6 @@ public class LoginUser {
 	@SensitiveField
 	private String avatar;
 
-	/**
-	 * 工号
-	 */
-	@SensitiveField
-	private String workNo;
-
 	/**
 	 * 生日
 	 */

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

@@ -1,239 +0,0 @@
-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,7 +19,7 @@ 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;

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

@@ -1,10 +1,10 @@
 package org.jeecg.common.util;
 
+import jakarta.servlet.http.HttpServletResponse;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.io.FilenameUtils;
 import org.jeecg.common.exception.JeecgBootException;
 
-import javax.servlet.http.HttpServletResponse;
 import java.io.*;
 import java.net.URL;
 import java.net.URLConnection;

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/SpringContextUtils.java

@@ -1,14 +1,13 @@
 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;
@@ -17,7 +16,6 @@ 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,13 +16,7 @@ import java.util.regex.Pattern;
  * @author zhoujf
  */
 @Slf4j
-public class SqlInjectionUtil {
-
-	/**
-	 * sql注入黑名单数据库名
-	 */
-	public final static String XSS_STR_TABLE = "peformance_schema|information_schema";
-
+public class SqlInjectionUtil {	
 	/**
 	 * 默认—sql注入关键词
 	 */
@@ -173,28 +167,7 @@ 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注入过滤处理，遇到注入关键字抛异常
 	 * 
@@ -235,14 +208,6 @@ 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) {
@@ -279,14 +244,6 @@ 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

@@ -11,7 +11,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

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

@@ -68,13 +68,6 @@ 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,6 +1,6 @@
 package org.jeecg.common.util.encryption;
 
-import org.apache.shiro.codec.Base64;
+import org.apache.shiro.lang.codec.Base64;
 
 import javax.crypto.Cipher;
 import javax.crypto.spec.IvParameterSpec;

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

@@ -34,7 +34,6 @@ 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");
@@ -43,7 +42,6 @@ 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");
@@ -67,10 +65,6 @@ 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");

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

@@ -7,14 +7,12 @@ 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;
@@ -465,7 +463,7 @@ public class oConvertUtils {
 			return false;
 		}
 
-		List<String> childs = childArray.toJavaList(String.class);
+		String[] childs = (String[]) childArray.toArray();
 		for (String v : childs) {
 			if (!isIn(v, all)) {
 				return false;
@@ -1030,118 +1028,5 @@ 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) {
-		return isIn(obj, objs);
-	}
-
-	/**
-	 * 判断租户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/security/AbstractQueryBlackListHandler.java

@@ -3,8 +3,6 @@ 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;
@@ -68,8 +66,6 @@ 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);
@@ -85,16 +81,6 @@ 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;
-                }
-            }
         }
 
         // 返回黑名单校验结果（不合法直接抛出异常）
@@ -149,8 +135,6 @@ public abstract class AbstractQueryBlackListHandler {
      * 查询的表的信息
      */
     protected class QueryTable {
-        //数据库名
-        private String dbName;
         //表名
         private String name;
         //表的别名
@@ -174,14 +158,6 @@ 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

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

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

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

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

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

@@ -0,0 +1,37 @@
+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/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;

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

@@ -17,10 +17,6 @@ public class JeecgBaseConfig {
      * @TODO 降低使用成本加的默认值,实际以 yml配置 为准
      */
     private String signatureSecret = "dd05f1c54d63749eda95f9fa6d49v442a";
-    /**
-     * 自定义后台资源前缀，解决表单设计器无法通过前端nginx转发访问
-     */
-    private String customResourcePrefixPath;
     /**
      * 需要加强校验的接口清单
      */
@@ -70,20 +66,7 @@ public class JeecgBaseConfig {
     /**
      * 百度开放API配置
      */
-    private BaiduApi baiduApi;    
-    
-    /**
-     * 高德开放API配置
-     */
-    private GaoDeApi gaoDeApi;
-
-    public String getCustomResourcePrefixPath() {
-        return customResourcePrefixPath;
-    }
-
-    public void setCustomResourcePrefixPath(String customResourcePrefixPath) {
-        this.customResourcePrefixPath = customResourcePrefixPath;
-    }
+    private BaiduApi baiduApi;
 
     public Elasticsearch getElasticsearch() {
         return elasticsearch;
@@ -173,11 +156,4 @@ public class JeecgBaseConfig {
         this.baiduApi = baiduApi;
     }
 
-    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/Swagger2Config.java

@@ -1,7 +1,7 @@
 //package org.jeecg.config;
 //
 //
-//import io.swagger.v3.oas.annotations.Operation;
+//import io.swagger.annotations.ApiOperation;
 //import org.jeecg.common.constant.CommonConstant;
 //import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
 //import org.springframework.beans.BeansException;

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

@@ -66,17 +66,19 @@ public class Swagger3Config implements WebMvcConfigurer {
             // 全局添加鉴权参数
             if (openApi.getPaths() != null) {
                 openApi.getPaths().forEach((path, pathItem) -> {
-                    //log.debug("path: {}", path);
+                    log.info("path: {}", path);
                     // 检查当前路径是否在排除列表中
-                    boolean isExcluded = excludedPaths.stream().anyMatch(
-                            excludedPath -> excludedPath.equals(path) || (excludedPath.endsWith("**") && path.startsWith(excludedPath.substring(0, excludedPath.length() - 2)))
+                    boolean isExcluded = excludedPaths.stream().anyMatch(excludedPath ->
+                            excludedPath.equals(path) ||
+                                    (excludedPath.endsWith("**") && path.startsWith(excludedPath.substring(0, excludedPath.length() - 2)))
                     );
 
                     if (!isExcluded) {
                         // 接口添加鉴权参数
-                        pathItem.readOperations().forEach(operation ->
-                                operation.addSecurityItem(new SecurityRequirement().addList(CommonConstant.X_ACCESS_TOKEN))
-                        );
+                        pathItem.readOperations()
+                                .forEach(operation ->
+                                        operation.addSecurityItem(new SecurityRequirement().addList(CommonConstant.X_ACCESS_TOKEN))
+                                );
                     }
                 });
             }
@@ -88,7 +90,7 @@ public class Swagger3Config implements WebMvcConfigurer {
         return new OpenAPI()
                 .info(new Info()
                         .title("JeecgBoot 后台服务API接口文档")
-                        .version("3.8.2")
+                        .version("3.7.4")
                         .contact(new Contact().name("北京国炬信息技术有限公司").url("www.jeccg.com").email("jeecgos@163.com"))
                         .description( "后台API接口")
                         .termsOfService("NO terms of service")

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

@@ -11,18 +11,20 @@ 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 jakarta.annotation.Resource;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.ObjectProvider;
 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.context.event.ApplicationReadyEvent;
+import org.springframework.boot.actuate.web.exchanges.InMemoryHttpExchangeRepository;
+import org.springframework.boot.autoconfigure.jackson.JacksonProperties;
 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.context.event.EventListener;
-import org.springframework.http.CacheControl;
 import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
 import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
@@ -32,14 +34,12 @@ 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 解决跨域问题
@@ -58,14 +58,6 @@ 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、图片、视频、音频等
      */
@@ -78,8 +70,6 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
                     .addResourceLocations("file:" + jeecgBaseConfig.getPath().getWebapp() + "//");
         }
         resourceHandlerRegistration.addResourceLocations(staticLocations.split(","));
-        // 设置缓存控制标头 Cache-Control有效期为30天
-        resourceHandlerRegistration.setCacheControl(CacheControl.maxAge(30, TimeUnit.DAYS));
     }
 
     /**
@@ -88,7 +78,7 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
      */
     @Override
     public void addViewControllers(ViewControllerRegistry registry) {
-        registry.addViewController("/").setViewName("redirect:/doc.html");
+        registry.addViewController("/").setViewName("doc.html");
     }
 
     @Bean
@@ -154,17 +144,11 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
 
 
     /**
-     * 监听应用启动完成事件，确保 PrometheusMeterRegistry 已经初始化
-     * for [QQYUN-12558]【监控】系统监控的头两个tab不好使，接口404
-     * @param event
-     * @author chenrui
-     * @date 2025/5/26 16:46
+     * 解决metrics端点不显示jvm信息的问题(zyf)
      */
-    @EventListener
-    public void onApplicationReady(ApplicationReadyEvent event) {
-        if(null != meterRegistryPostProcessor){
-            meterRegistryPostProcessor.postProcessAfterInitialization(prometheusMeterRegistry, "");
-        }
+    @Bean
+    InitializingBean forcePrometheusPostProcessor(BeanPostProcessor meterRegistryPostProcessor) {
+        return () -> meterRegistryPostProcessor.postProcessAfterInitialization(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;
 
 /**

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

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

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

@@ -6,17 +6,20 @@ import org.apache.shiro.SecurityUtils;
 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.springframework.stereotype.Component;
+import org.jeecg.config.firewall.interceptor.enums.LowCodeUrlsEnum;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.AntPathMatcher;
 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;
@@ -38,7 +41,6 @@ import java.util.Set;
  * @date 20230904
  */
 @Slf4j
-@Component
 public class LowCodeModeInterceptor implements HandlerInterceptor {
     /**
      * 低代码开发模式
@@ -48,22 +50,18 @@ 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());
@@ -72,9 +70,6 @@ public class LowCodeModeInterceptor implements HandlerInterceptor {
             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/MybatisPlusSaasConfig.java

@@ -1,16 +1,11 @@
 package org.jeecg.config.mybatis;
 
-import java.sql.SQLException;
 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.inner.DynamicTableNameInnerInterceptor;
 import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
-import com.baomidou.mybatisplus.extension.toolkit.JdbcUtils;
-import lombok.extern.slf4j.Slf4j;
-import me.zhyd.oauth.log.Log;
 import org.jeecg.common.config.TenantContext;
 import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.constant.TenantConstant;
@@ -18,7 +13,6 @@ 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;
 
@@ -29,20 +23,16 @@ import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerIntercept
 
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.LongValue;
-import javax.sql.DataSource;
 
 /**
  * 单数据源配置（jeecg.datasource.open = false时生效）
  * @Author zhoujf
  *
  */
-@Slf4j
 @Configuration
 @MapperScan(value={"org.jeecg.**.mapper*"})
 public class MybatisPlusSaasConfig {
-    @Autowired
-    private DataSource dataSource;
-    
+
     /**
      * 是否开启系统模块的租户隔离
      *  控制范围：用户、角色、部门、我的部门、字典、分类字典、多数据源、职务、通知公告
@@ -70,18 +60,7 @@ public class MybatisPlusSaasConfig {
             TENANT_TABLE.add("sys_category");
             TENANT_TABLE.add("sys_data_source");
             TENANT_TABLE.add("sys_position");
-            //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");
+            //TENANT_TABLE.add("sys_announcement");
         }
 
         //2.示例测试
@@ -132,23 +111,7 @@ public class MybatisPlusSaasConfig {
         //update-begin-author:zyf date:20220425 for:【VUEN-606】注入动态表名适配拦截器解决多表名问题
         interceptor.addInnerInterceptor(dynamicTableNameInnerInterceptor());
         //update-end-author:zyf date:20220425 for:【VUEN-606】注入动态表名适配拦截器解决多表名问题
-        
-        //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报表报错---
-        
+        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
         //【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;
 
 /**

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

@@ -6,8 +6,8 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 /**
  * 动态数据源切换拦截器

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

@@ -32,9 +32,9 @@ import org.springframework.web.filter.DelegatingFilterProxy;
 import redis.clients.jedis.HostAndPort;
 import redis.clients.jedis.JedisCluster;
 
-import javax.annotation.Resource;
-import javax.servlet.DispatcherType;
-import javax.servlet.Filter;
+import jakarta.annotation.Resource;
+import jakarta.servlet.Filter;
+import jakarta.servlet.DispatcherType;
 import java.lang.reflect.Method;
 import java.util.*;
 
@@ -109,7 +109,7 @@ public class ShiroConfig {
         filterChainDefinitionMap.put("/sys/getLoginQrcode/**", "anon"); //登录二维码
         filterChainDefinitionMap.put("/sys/getQrcodeToken/**", "anon"); //监听扫码
         filterChainDefinitionMap.put("/sys/checkAuth", "anon"); //授权接口排除
-        filterChainDefinitionMap.put("/openapi/call/**", "anon"); // 开放平台接口排除
+
 
         //update-begin--Author:scott Date:20221116 for：排除静态资源后缀
         filterChainDefinitionMap.put("/", "anon");
@@ -153,11 +153,7 @@ public class ShiroConfig {
         filterChainDefinitionMap.put("/drag/share/view/**", "anon");
         filterChainDefinitionMap.put("/drag/onlDragDatasetHead/getAllChartData", "anon");
         filterChainDefinitionMap.put("/drag/onlDragDatasetHead/getTotalData", "anon");
-        filterChainDefinitionMap.put("/drag/onlDragDatasetHead/getMapDataByCode", "anon");
-        filterChainDefinitionMap.put("/drag/onlDragDatasetHead/getTotalDataByCompId", "anon");
         filterChainDefinitionMap.put("/drag/mock/json/**", "anon");
-        filterChainDefinitionMap.put("/drag/onlDragDatasetHead/getDictByCodes", "anon");
-
         filterChainDefinitionMap.put("/jimubi/view", "anon");
         filterChainDefinitionMap.put("/jimubi/share/view/**", "anon");
 
@@ -173,11 +169,7 @@ public class ShiroConfig {
         filterChainDefinitionMap.put("/websocket/**", "anon");//系统通知和公告
         filterChainDefinitionMap.put("/newsWebsocket/**", "anon");//CMS模块
         filterChainDefinitionMap.put("/vxeSocket/**", "anon");//JVxeTable无痕刷新示例
-        //App vue3版本查询版本接口
-        filterChainDefinitionMap.put("/sys/version/app3version", "anon");
-        //仪表盘（按钮通信）
-        filterChainDefinitionMap.put("/dragChannelSocket/**","anon");
-        
+
         //性能监控——安全隐患泄露TOEKN（durid连接池也有）
         //filterChainDefinitionMap.put("/actuator/**", "anon");
         //测试模块排除
@@ -187,7 +179,9 @@ public class ShiroConfig {
         filterChainDefinitionMap.put("/error", "anon");
         // 企业微信证书排除
         filterChainDefinitionMap.put("/WW_verify*", "anon");
-        
+
+        filterChainDefinitionMap.put("/openapi/call/**", "anon");
+
         // 添加自己的过滤器并且取名为jwt
         Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
         //如果cloudServer为空 则说明是单体 需要加载跨域配置【微服务跨域切换】
@@ -223,11 +217,6 @@ public class ShiroConfig {
         //update-begin---author:chenrui ---date:20241202  for：[issues/7491]运行时间好长，效率慢 ------------
         registration.addUrlPatterns("/test/ai/chat/send");
         //update-end---author:chenrui ---date:20241202  for：[issues/7491]运行时间好长，效率慢 ------------
-        registration.addUrlPatterns("/airag/flow/run");
-        registration.addUrlPatterns("/airag/flow/debug");
-        registration.addUrlPatterns("/airag/chat/send");
-        registration.addUrlPatterns("/airag/app/debug");
-        registration.addUrlPatterns("/airag/app/prompt/generate");
         //支持异步
         registration.setAsyncSupported(true);
         registration.setDispatcherTypes(DispatcherType.REQUEST, DispatcherType.ASYNC);

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

@@ -23,8 +23,8 @@ import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
-import javax.annotation.Resource;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
 import java.util.Set;
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/filters/CustomShiroFilterFactoryBean.java

@@ -12,7 +12,7 @@ import org.apache.shiro.web.servlet.AbstractShiroFilter;
 import org.apache.shiro.mgt.SecurityManager;
 import org.springframework.beans.factory.BeanInitializationException;
 
-import javax.servlet.Filter;
+import jakarta.servlet.Filter;
 import java.util.Map;
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/filters/JwtFilter.java

@@ -13,10 +13,10 @@ import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.RequestMethod;
 
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 /**
  * @Description: 鉴权登录拦截器

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/filters/ResourceCheckFilter.java

@@ -1,9 +1,9 @@
 package org.jeecg.config.shiro.filters;
 
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 import org.apache.shiro.subject.Subject;
 import org.apache.shiro.web.filter.AccessControlFilter;
 import lombok.extern.slf4j.Slf4j;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/ignore/IgnoreAuthPostProcessor.java

@@ -91,10 +91,6 @@ public class IgnoreAuthPostProcessor implements InitializingBean {
         if (bases.length > 0) {
             for (String base : bases) {
                 for (String uri : uris) {
-                    // 如果uri包含路径占位符, 则需要将其替换为*
-                    if (uri.matches(".*\\{.*}.*")) {
-                        uri = uri.replaceAll("\\{.*?}", "*");
-                    }
                     urls.add(prefix(base) + prefix(uri));
                 }
             }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/ignore/InMemoryIgnoreAuth.java

@@ -1,7 +1,5 @@
 package org.jeecg.config.shiro.ignore;
 
-import org.springframework.util.AntPathMatcher;
-import org.springframework.util.PathMatcher;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -14,7 +12,6 @@ import java.util.List;
 public class InMemoryIgnoreAuth {
     private static final List<String> IGNORE_AUTH_LIST = new ArrayList<>();
 
-    private static PathMatcher MATCHER = new AntPathMatcher();
     public InMemoryIgnoreAuth() {}
 
     public static void set(List<String> list) {
@@ -31,7 +28,7 @@ public class InMemoryIgnoreAuth {
 
     public static boolean contains(String url) {
         for (String ignoreAuth : IGNORE_AUTH_LIST) {
-            if(MATCHER.match(ignoreAuth,url)){
+            if (url.endsWith(ignoreAuth)) {
                 return true;
             }
         }

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthConfiguration.java

@@ -10,7 +10,7 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-import javax.annotation.Resource;
+import jakarta.annotation.Resource;
 
 /**
  * 签名 拦截器配置

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthInterceptor.java

@@ -4,8 +4,8 @@ package org.jeecg.config.sign.interceptor;
 import java.io.PrintWriter;
 import java.util.SortedMap;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.constant.CommonConstant;

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/BodyReaderHttpServletRequestWrapper.java

@@ -1,10 +1,10 @@
 package org.jeecg.config.sign.util;
 
-import javax.servlet.ReadListener;
-import javax.servlet.ServletInputStream;
-import javax.servlet.ServletRequest;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletRequestWrapper;
+import jakarta.servlet.ReadListener;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequestWrapper;
 import java.io.*;
 import java.nio.charset.Charset;
 

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/HttpUtils.java

@@ -10,7 +10,7 @@ import java.util.Map;
 import java.util.SortedMap;
 import java.util.TreeMap;
 
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 
 import lombok.extern.slf4j.Slf4j;
 import org.jeecg.common.constant.SymbolConstant;

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

@@ -1,17 +0,0 @@
-package org.jeecg.config.vo;
-
-import lombok.Data;
-
-/**
-* @Description: 高德开放api配置
-*
-* @author: wangshuai
-* @date: 2025/7/17 20:32
-*/
-@Data
-public class GaoDeApi {
-    /**应用key*/
-    private String apiKey;
-    /**应用秘钥*/
-    private String secretKey;
-}

jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/service/impl/BaseCommonServiceImpl.java

@@ -14,8 +14,8 @@ import org.jeecg.common.util.SpringContextUtils;
 import org.jeecg.common.util.oConvertUtils;
 import org.springframework.stereotype.Service;
 
-import javax.annotation.Resource;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
 import java.util.*;
 
 /**

jeecg-boot/jeecg-boot-base-core/src/main/resources/templates/email/bpm_cc_email.ftl

@@ -1,104 +0,0 @@
-<html>
-<head>
-    <meta http-equiv="content-type" content="text/html;charset=utf-8">
-</head>
-
-<body>
-<div  class="box-content">
-    <div  class="info-top">
-        <img src="https://www.jeecg.com/images/logo.png" style="float: left; margin: 0 10px 0 0; width: 32px;height:32px" /><div style="color:#fff"><strong>【重要】流程抄送的通知</strong></div>
-    </div>
-    <div class="info-wrap">
-        <div class="tips" style="padding:15px;">
-            <p style="margin: 10px 0;">
-               您好，您有一个新的流程抄送任务亟待查看，任务内容如下：：
-            </p>
-            <table style="width: 400px; border-spacing: 0px; border-collapse: collapse; border: none; margin-top: 20px;"><tbody>
-                <tr style="height: 45px;">
-                    <td style="width: 150px; height: 40px; background: #F6F6F6;border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        流程名称
-                    </td>
-                    <td style="width: 250px;height: 40px; border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        ${bpm_name}<a style="color: #006eff;" href="${url}" target="_blank" rel="noopener">[立刻查看]</a>
-                    </td>
-                </tr>
-                <tr style="height: 45px;">
-                    <td style="width: 150px;height: 40px; background: #F6F6F6;border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        抄送任务
-                    </td>
-                    <td style="width: 250px;height: 40px; border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        ${bpm_task}
-                    </td>
-                </tr>
-                <tr style="height: 45px;">
-                    <td style="width: 150px; height: 40px; background: #F6F6F6;border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        抄送时间
-                    </td>
-                    <td style="width: 250px;height: 40px; border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        ${datetime}
-                    </td>
-                </tr>
-                <tr style="height: 45px;">
-                    <td style="width: 150px; height: 40px; background: #F6F6F6;border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        抄送内容
-                    </td>
-                    <td style="width: 250px;height: 40px; border: 1px solid #DBDBDB; font-size: 14px; font-weight: normal; text-align: left; padding-left: 14px;">
-                        ${remark}
-                    </td>
-                </tr>
-                </tbody>
-            </table>
-        </div>
-        <div class="footer">北京国炬平台</div>
-    </div>
-    <div style="margin-top: 60px;margin-bottom: 10px;">
-        <span style="font-size: 13px; font-weight: bold; color: #666;">温馨提醒</span>
-        <div style="line-height: 24px; margin-top: 10px;">
-            <div style="font-size: 13px; color: #666;">使用过程中如有任何问题，请联系系统管理员。</div>
-        </div>
-    </div>
-    <div style="width: 600px; margin: 0 auto;  margin-top: 50px; font-size: 12px; -webkit-font-smoothing: subpixel-antialiased; text-size-adjust: 100%;">
-        <p style="text-align: center; line-height: 20.4px; text-size-adjust: 100%; font-family: 'Microsoft YaHei'!important; padding: 0px !important; margin: 0px !important; color: #7e8890 !important;">
-            <span class="appleLinks">Copyright © 2023-2024 北京国炬信息技术有限公司. 保留所有权利。</span>
-        </p>
-        <p style="text-align: center;line-height: 20.4px; text-size-adjust: 100%; font-family: 'Microsoft YaHei'!important; padding: 0px !important; margin: 0px; color: #7e8890 !important; margin-top: 10px;">
-            <span class="appleLinks">邮件由系统自动发送，请勿直接回复本邮件！</span>
-        </p>
-    </div>
-</div>
-</body>
-
-<style>
-    .box-content{
-        width: 80%;
-        margin: 20px auto;
-        max-width: 800px;
-        min-width: 600px;
-    }
-
-    .info-top{
-        padding: 15px 25px;
-        border-top-left-radius: 10px;
-        border-top-right-radius: 10px;
-        background: #4ea3f2;
-        color: #fff;
-        overflow: hidden;
-        line-height: 32px;
-    }
-
-    .info-wrap{
-        border-bottom-left-radius: 10px;
-        border-bottom-right-radius: 10px;
-        border:1px solid #ddd;
-        overflow: hidden;
-        padding: 15px 15px 20px;
-    }
-
-    .footer{
-        text-align: right;
-        color: #999;
-        padding: 0 15px 15px;
-    }
-</style>
-
-</html>

jeecg-boot/jeecg-boot-base-core/src/test/java/org/jeecg/test/sqlinjection/TestInjectWithSqlParser.java

@@ -0,0 +1,75 @@
+package org.jeecg.test.sqlinjection;
+
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
+import org.jeecg.common.util.SqlInjectionUtil;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+/**
+ * SQL注入攻击检查测试
+ * @author: liusq
+ * @date: 2023年09月08日
+ */
+@Slf4j
+public class TestInjectWithSqlParser {
+    /**
+     * 注入测试
+     *
+     * @param sql
+     * @return
+     */
+    private boolean isExistSqlInject(String sql) {
+        try {
+            SqlInjectionUtil.specialFilterContentForOnlineReport(sql);
+            return false;
+        } catch (Exception e) {
+            log.info("===================================================");
+            return true;
+        }
+    }
+
+
+    @Test
+    public void test() throws JSQLParserException {
+        //不存在sql注入
+        assertFalse(isExistSqlInject("select * from fm_time where dept_id=:sqlparamsmap.id and time=:sqlparamsmap.time"));
+        assertFalse(isExistSqlInject("select * from test"));
+        assertFalse(isExistSqlInject("select load_file(\"C:\\\\benben.txt\")"));
+        assertFalse(isExistSqlInject("WITH SUB1 AS (SELECT user FROM t1) SELECT * FROM T2 WHERE id > 123 "));
+
+        //存在sql注入
+        assertTrue(isExistSqlInject("or 1= 1 --"));
+        assertTrue(isExistSqlInject("select * from test where sleep(%23)"));
+        assertTrue(isExistSqlInject("select * from test where id=1 and multipoint((select * from(select * from(select user())a)b));"));
+        assertTrue(isExistSqlInject("select * from users;show databases;"));
+        assertTrue(isExistSqlInject("select * from dc_device where id=1 and length((select group_concat(table_name) from information_schema.tables where table_schema=database()))>13"));
+        assertTrue(isExistSqlInject("update user set name = '123'"));
+        assertTrue(isExistSqlInject("SELECT * FROM users WHERE username = 'admin' AND password = '123456' OR 1=1;--"));
+        assertTrue(isExistSqlInject("select * from users where id=1 and (select count(*) from information_schema.tables where table_schema='数据库名')>4 %23"));
+        assertTrue(isExistSqlInject("select * from dc_device where sleep(5) %23"));
+        assertTrue(isExistSqlInject("select * from dc_device where id in (select id from other)"));
+        assertTrue(isExistSqlInject("select * from dc_device where id in (select id from other)"));
+        assertTrue(isExistSqlInject("select * from dc_device where 2=2.0 or 2 != 4"));
+        assertTrue(isExistSqlInject("select * from dc_device where 1!=2.0"));
+        assertTrue(isExistSqlInject("select * from dc_device where id=floor(2.0)"));
+        assertTrue(isExistSqlInject("select * from dc_device where not true"));
+        assertTrue(isExistSqlInject("select * from dc_device where 1 or id > 0"));
+        assertTrue(isExistSqlInject("select * from dc_device where 'tom' or id > 0"));
+        assertTrue(isExistSqlInject("select * from dc_device where '-2.3' "));
+        assertTrue(isExistSqlInject("select * from dc_device where 2 "));
+        assertTrue(isExistSqlInject("select * from dc_device where (3+2) "));
+        assertTrue(isExistSqlInject("select * from dc_device where  -1 IS TRUE"));
+        assertTrue(isExistSqlInject("select * from dc_device where 'hello' is null "));
+        assertTrue(isExistSqlInject("select * from dc_device where '2022-10-31' and id > 0"));
+        assertTrue(isExistSqlInject("select * from dc_device where id > 0 or 1!=2.0 "));
+        assertTrue(isExistSqlInject("select * from dc_device where id > 0 or 1 in (1,3,4) "));
+        assertTrue(isExistSqlInject("select * from dc_device  UNION select name from other"));
+        assertTrue(isExistSqlInject("(SELECT 6240 FROM (SELECT(SLEEP(5))and 1=2)vidl)"));
+    }
+
+}
+

jeecg-boot/jeecg-boot-base-core/src/test/java/org/jeecg/test/sqlinjection/TestSqlInjectForDict.java

@@ -0,0 +1,50 @@
+package org.jeecg.test.sqlinjection;
+
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
+import org.jeecg.common.util.SqlInjectionUtil;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+/**
+ * SQL注入攻击检查测试
+ * @author: liusq
+ * @date: 2023年09月08日
+ */
+@Slf4j
+public class TestSqlInjectForDict {
+    /**
+     * 注入测试
+     *
+     * @param sql
+     * @return
+     */
+    private boolean isExistSqlInject(String sql) {
+        try {
+            SqlInjectionUtil.specialFilterContentForDictSql(sql);
+            return false;
+        } catch (Exception e) {
+            log.info("===================================================");
+            return true;
+        }
+    }
+
+
+    @Test
+    public void test() throws JSQLParserException {
+        //不存在sql注入
+        assertFalse(isExistSqlInject("sys_user,realname,id"));
+        assertFalse(isExistSqlInject("oa_officialdoc_organcode,organ_name,id"));
+        assertFalse(isExistSqlInject("onl_cgform_head where table_type!=3 and copy_type=0,table_txt,table_name"));
+        assertFalse(isExistSqlInject("onl_cgform_head where copy_type = 0,table_txt,table_name"));
+
+        //存在sql注入
+        assertTrue(isExistSqlInject("or 1= 1 --"));
+        assertTrue(isExistSqlInject("select * from test where sleep(%23)"));
+    }
+
+}
+

jeecg-boot/jeecg-boot-base-core/src/test/java/org/jeecg/test/sqlinjection/TestSqlInjectForOnlineReport.java

@@ -0,0 +1,60 @@
+package org.jeecg.test.sqlinjection;
+
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
+import org.jeecg.common.util.SqlInjectionUtil;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+/**
+ * SQL注入攻击检查测试
+ * @author: liusq
+ * @date: 2023年09月08日
+ */
+@Slf4j
+public class TestSqlInjectForOnlineReport {
+    /**
+     * 注入测试
+     *
+     * @param sql
+     * @return
+     */
+    private boolean isExistSqlInject(String sql) {
+        try {
+            SqlInjectionUtil.specialFilterContentForOnlineReport(sql);
+            return false;
+        } catch (Exception e) {
+            log.info("===================================================");
+            return true;
+        }
+    }
+
+
+    @Test
+    public void test() throws JSQLParserException {
+        //不存在sql注入
+        assertFalse(isExistSqlInject("select * from fm_time where dept_id=:sqlparamsmap.id and time=:sqlparamsmap.time"));
+        assertFalse(isExistSqlInject("select * from test"));
+        assertFalse(isExistSqlInject("select load_file(\"C:\\\\benben.txt\")"));
+        assertFalse(isExistSqlInject("select * from dc_device where id in (select id from other)"));
+        assertFalse(isExistSqlInject("select * from dc_device  UNION select name from other"));
+
+        //存在sql注入
+        assertTrue(isExistSqlInject("(SELECT 6240 FROM (SELECT(SLEEP(5))and 1=2)vidl)"));
+        assertTrue(isExistSqlInject("or 1= 1 --"));
+        assertTrue(isExistSqlInject("select * from test where sleep(%23)"));
+        assertTrue(isExistSqlInject("select * from test where SLEEP(3)"));
+        assertTrue(isExistSqlInject("select * from test where id=1 and multipoint((select * from(select * from(select user())a)b));"));
+        assertTrue(isExistSqlInject("select * from users;show databases;"));
+        assertTrue(isExistSqlInject("select * from dc_device where id=1 and length((select group_concat(table_name) from information_schema.tables where table_schema=database()))>13"));
+        assertTrue(isExistSqlInject("update user set name = '123'"));
+        assertTrue(isExistSqlInject("SELECT * FROM users WHERE username = 'admin' AND password = '123456' OR 1=1;--"));
+        assertTrue(isExistSqlInject("select * from users where id=1 and (select count(*) from information_schema.tables where table_schema='数据库名')>4 %23"));
+        assertTrue(isExistSqlInject("select * from dc_device where sleep(5) %23"));
+    }
+
+}
+

jeecg-boot/jeecg-boot-base-core/src/test/java/org/jeecg/test/sqlinjection/TestSqlInjection.java

@@ -0,0 +1,103 @@
+package org.jeecg.test.sqlinjection;
+
+import com.baomidou.mybatisplus.core.toolkit.sql.SqlInjectionUtils;
+import org.jeecg.common.util.SqlInjectionUtil;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Description: SQL注入测试类
+ * @author: scott
+ * @date: 2023年08月14日 9:55
+ */
+public class TestSqlInjection {
+
+    
+    /**
+     * 表名带别名，同时有html编码字符
+     */
+    @Test
+    public void testSpecialSQL() {
+        String tableName = "sys_user    t";
+        //解决使用参数tableName=sys_user t&复测，漏洞仍然存在
+        if (tableName.contains(" ")) {
+            tableName = tableName.substring(0, tableName.indexOf(" "));
+        }
+        //【issues/4393】 sys_user , (sys_user), sys_user%20, %60sys_user%60
+        String reg = "\\s+|\\(|\\)|`";
+        tableName = tableName.replaceAll(reg, "");
+        System.out.println(tableName);
+    }
+
+
+    /**
+     * 测试sql是否含sql注入风险
+     * <p>
+     * mybatis plus的方法
+     */
+    @Test
+    public void sqlInjectionCheck() {
+        String sql = "select * from sys_user";
+        System.out.println(SqlInjectionUtils.check(sql));
+    }
+
+
+    /**
+     * 测试sql是否有SLEEP风险
+     * <p>
+     *  mybatisPlus的方法
+     */
+    @Test
+    public void sqlSleepCheck() {
+        SqlInjectionUtil.checkSqlAnnotation("(SELECT 6240 FROM (SELECT(SLEEP(5))and 1=2)vidl)");
+    }
+
+    /**
+     * 测试sql是否含sql注入风险
+     * <p>
+     * 自定义方法
+     */
+    @Test
+    public void sqlInjectionCheck2() {
+        String sql = "select * from sys_user";
+        SqlInjectionUtil.specialFilterContentForOnlineReport(sql);
+    }
+
+    /**
+     * 字段定义只能是是字母 数字 下划线的组合（不允许有空格、转义字符串等）
+     * <p>
+     * 判断字段名是否符合规范
+     */
+    @Test
+    public void testFieldSpecification() {
+        List<String> list = new ArrayList();
+        list.add("Hello World!");
+        list.add("Hello%20World!");
+        list.add("HelloWorld!");
+        list.add("Hello World");
+        list.add("age");
+        list.add("user_name");
+        list.add("user_name%20");
+        list.add("user_name%20 ");
+
+        for (String input : list) {
+            boolean containsSpecialChars = isValidString(input);
+            System.out.println("input:" + input + " ,包含空格和特殊字符: " + containsSpecialChars);
+        }
+    }
+
+    /**
+     * 字段定义只能是是字母 数字 下划线的组合（不允许有空格、转义字符串等）
+     *
+     * @param input
+     * @return
+     */
+    private static boolean isValidString(String input) {
+        Pattern pattern = Pattern.compile("^[a-zA-Z0-9_]+$");
+        return pattern.matcher(input).matches();
+    }
+
+}

jeecg-boot/jeecg-boot-base-core/src/test/java/org/jeecg/test/sqlparse/JSqlParserUtilsTest.java

@@ -0,0 +1,109 @@
+package org.jeecg.test.sqlparse;
+
+import net.sf.jsqlparser.JSQLParserException;
+import org.jeecg.common.util.oConvertUtils;
+import org.jeecg.common.util.sqlparse.JSqlParserUtils;
+import org.jeecg.common.util.sqlparse.vo.SelectSqlInfo;
+import org.junit.Test;
+
+import java.util.Map;
+
+/**
+ * 针对 JSqlParserUtils 的单元测试
+ */
+public class JSqlParserUtilsTest {
+
+    private static final String[] sqlList = new String[]{
+            "select * from sys_user",
+            "select u.* from sys_user u",
+            "select u.*, c.name from sys_user u, demo c",
+            "select u.age, c.name from sys_user u, demo c",
+            "select sex, age, c.name from sys_user, demo c",
+            // 别名测试
+            "select username as realname from sys_user",
+            "select username as realname, u.realname as aaa, u.id bbb from sys_user u",
+            // 不存在真实地查询字段
+            "select count(1) from sys_user",
+            // 函数式字段
+            "select max(sex), id from sys_user",
+            // 复杂嵌套函数式字段
+            "select CONCAT(CONCAT(' _ ', sex), ' - ' , birthday) as info, id from sys_user",
+            // 更复杂的嵌套函数式字段
+            "select CONCAT(CONCAT(101,'_',NULL, DATE(create_time),'_',sex),' - ',birthday) as info, id from sys_user",
+            // 子查询SQL
+            "select u.name1 as name2 from (select username as name1 from sys_user) u",
+            // 多层嵌套子查询SQL
+            "select u2.name2 as name3 from (select u1.name1 as name2 from (select username as name1 from sys_user) u1) u2",
+            // 字段子查询SQL
+            "select id, (select username as name1 from sys_user u2 where u1.id = u2.id) as name2 from sys_user u1",
+            // 带条件的SQL（不解析where条件里的字段，但不影响解析查询字段）
+            "select username as name1 from sys_user where realname LIKE '%张%'",
+            // 多重复杂关联表查询解析，包含的表为：sys_user, sys_depart, sys_dict_item, demo
+            "" +
+                    "SELECT " +
+                    "    u.*, d.age, sd.item_text AS sex, (SELECT count(sd.id) FROM sys_depart sd) AS count " +
+                    "FROM " +
+                    "    (SELECT sd.username AS foo, sd.realname FROM sys_user sd) u, " +
+                    "    demo d " +
+                    "LEFT JOIN sys_dict_item AS sd ON d.sex = sd.item_value " +
+                    "WHERE sd.dict_id = '3d9a351be3436fbefb1307d4cfb49bf2'",
+    };
+
+    @Test
+    public void testParseSelectSql() {
+        System.out.println("-----------------------------------------");
+        for (String sql : sqlList) {
+            System.out.println("待测试的sql：" + sql);
+            try {
+                // 解析所有的表名，key=表名，value=解析后的sql信息
+                Map<String, SelectSqlInfo> parsedMap = JSqlParserUtils.parseAllSelectTable(sql);
+                assert parsedMap != null;
+                for (Map.Entry<String, SelectSqlInfo> entry : parsedMap.entrySet()) {
+                    System.out.println("表名：" + entry.getKey());
+                    this.printSqlInfo(entry.getValue(), 1);
+                }
+            } catch (JSQLParserException e) {
+                System.out.println("SQL解析出现异常：" + e.getMessage());
+            }
+            System.out.println("-----------------------------------------");
+        }
+    }
+
+    private void printSqlInfo(SelectSqlInfo sqlInfo, int level) {
+        String beforeStr = this.getBeforeStr(level);
+        if (sqlInfo.getFromTableName() == null) {
+            // 子查询
+            System.out.println(beforeStr + "子查询：" + sqlInfo.getFromSubSelect().getParsedSql());
+            this.printSqlInfo(sqlInfo.getFromSubSelect(), level + 1);
+        } else {
+            // 非子查询
+            System.out.println(beforeStr + "查询的表名：" + sqlInfo.getFromTableName());
+        }
+        if (oConvertUtils.isNotEmpty(sqlInfo.getFromTableAliasName())) {
+            System.out.println(beforeStr + "查询的表别名：" + sqlInfo.getFromTableAliasName());
+        }
+        if (sqlInfo.isSelectAll()) {
+            System.out.println(beforeStr + "查询的字段：*");
+        } else {
+            System.out.println(beforeStr + "查询的字段：" + sqlInfo.getSelectFields());
+            System.out.println(beforeStr + "真实的字段：" + sqlInfo.getRealSelectFields());
+            if (sqlInfo.getFromTableName() == null) {
+                System.out.println(beforeStr + "所有的字段（包括子查询）：" + sqlInfo.getAllRealSelectFields());
+            }
+        }
+    }
+
+    // 打印前缀，根据层级来打印
+    private String getBeforeStr(int level) {
+        if (level == 0) {
+            return "";
+        }
+        StringBuilder beforeStr = new StringBuilder();
+        for (int i = 0; i < level; i++) {
+            beforeStr.append("  ");
+        }
+        beforeStr.append("- ");
+        return beforeStr.toString();
+    }
+
+}

jeecg-boot/jeecg-boot-base-core/src/test/java/org/jeecg/test/sqlparse/TestIpUtil.java

@@ -1,12 +1,17 @@
 package org.jeecg.test.sqlparse;
 
+import net.sf.jsqlparser.JSQLParserException;
 import org.jeecg.common.util.IpUtils;
 import org.jeecg.common.util.oConvertUtils;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 /**
  * @author: scott
  * @date: 2024年04月29日 16:48

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/pom.xml

@@ -1,188 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         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">
-    <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>org.jeecgframework.boot</groupId>
-        <artifactId>jeecg-boot-module</artifactId>
-        <version>3.8.2</version>
-    </parent>
-
-    <artifactId>jeecg-boot-module-airag</artifactId>
-
-    <repositories>
-        <repository>
-            <id>aliyun</id>
-            <name>aliyun Repository</name>
-            <url>https://maven.aliyun.com/repository/public</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </repository>
-        <repository>
-            <id>jeecg</id>
-            <name>jeecg Repository</name>
-            <url>https://maven.jeecg.org/nexus/content/repositories/jeecg</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </repository>
-    </repositories>
-
-    <properties>
-        <kotlin.version>1.6.21</kotlin.version>
-        <liteflow.version>2.12.4.1</liteflow.version>
-        <langchain4j.version>0.35.0</langchain4j.version>
-        <apache-tika.version>2.9.1</apache-tika.version>
-    </properties>
-
-    <dependencies>
-        <!-- system单体 api-->
-        <dependency>
-            <groupId>org.jeecgframework.boot</groupId>
-            <artifactId>jeecg-system-local-api</artifactId>
-        </dependency>
-        <!-- 微服务starter和system微服务 api
-        <dependency>
-            <groupId>org.jeecgframework.boot</groupId>
-            <artifactId>jeecg-boot-starter-cloud</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.jeecgframework.boot</groupId>
-            <artifactId>jeecg-system-cloud-api</artifactId>
-        </dependency>-->
-
-        <!-- aiflow依赖 -->
-        <dependency>
-            <groupId>org.jeecgframework.boot</groupId>
-            <artifactId>jeecg-aiflow</artifactId>
-            <version>1.1.1</version>
-        </dependency>
-
-        <!-- beigin 这两个依赖太多每个包50M左右，如果你发布需要使用，请把<scope>provided</scope>删掉 -->
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-scripting-jsr223</artifactId>
-            <version>${kotlin.version}</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.yomahub</groupId>
-            <artifactId>liteflow-script-graaljs</artifactId>
-            <version>${liteflow.version}</version>
-            <scope>provided</scope>
-        </dependency>
-        <!-- end 这两个依赖太多每个包50M左右，如果你发布需要使用，请把<scope>provided</scope>删掉 -->
-
-        <!-- aiflow 脚本依赖 -->
-        <dependency>
-            <groupId>com.yomahub</groupId>
-            <artifactId>liteflow-script-groovy</artifactId>
-            <version>${liteflow.version}</version>
-            <scope>runtime</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.yomahub</groupId>
-            <artifactId>liteflow-script-kotlin</artifactId>
-            <version>${liteflow.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.jetbrains.kotlin</groupId>
-                    <artifactId>kotlin-scripting-jsr223</artifactId>
-                </exclusion>
-            </exclusions>
-            <scope>runtime</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.yomahub</groupId>
-            <artifactId>liteflow-script-aviator</artifactId>
-            <version>${liteflow.version}</version>
-            <scope>runtime</scope>
-            <exclusions>
-                <exclusion>
-                    <artifactId>aviator</artifactId>
-                    <groupId>com.googlecode.aviator</groupId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <!-- aiflow 脚本依赖 -->
-
-        <!-- langChain4j model support -->
-        <dependency>
-            <groupId>dev.langchain4j</groupId>
-            <artifactId>langchain4j-ollama</artifactId>
-            <version>${langchain4j.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>dev.langchain4j</groupId>
-            <artifactId>langchain4j-zhipu-ai</artifactId>
-            <version>${langchain4j.version}</version>
-            <exclusions>
-                <exclusion>
-                    <artifactId>checker-qual</artifactId>
-                    <groupId>org.checkerframework</groupId>
-                </exclusion>
-                <exclusion>
-                    <artifactId>guava</artifactId>
-                    <groupId>com.google.guava</groupId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>dev.langchain4j</groupId>
-            <artifactId>langchain4j-qianfan</artifactId>
-            <version>${langchain4j.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>dev.langchain4j</groupId>
-            <artifactId>langchain4j-dashscope</artifactId>
-            <version>${langchain4j.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.slf4j</groupId>
-                    <artifactId>slf4j-simple</artifactId>
-                </exclusion>
-                <exclusion>
-                    <artifactId>okio</artifactId>
-                    <groupId>com.squareup.okio</groupId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <!-- langChain4j vextor support -->
-        <dependency>
-            <groupId>org.jeecgframework</groupId>
-            <artifactId>langchain4j-pgvector</artifactId>
-            <version>0.35.0</version>
-        </dependency>
-        <!-- langChain4j Document Parser -->
-        <dependency>
-            <groupId>org.apache.tika</groupId>
-            <artifactId>tika-core</artifactId>
-            <version>${apache-tika.version}</version>
-            <exclusions>
-                <exclusion>
-                    <artifactId>commons-io</artifactId>
-                    <groupId>commons-io</groupId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.tika</groupId>
-            <artifactId>tika-parser-html-module</artifactId>
-            <version>${apache-tika.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.tika</groupId>
-            <artifactId>tika-parser-pdf-module</artifactId>
-            <version>${apache-tika.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.tika</groupId>
-            <artifactId>tika-parser-text-module</artifactId>
-            <version>${apache-tika.version}</version>
-        </dependency>
-
-    </dependencies>
-
-</project>

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/JeecgAiRagApplication.java

@@ -1,12 +0,0 @@
-//package org.jeecg;
-//
-//import org.springframework.boot.SpringApplication;
-//import org.springframework.boot.autoconfigure.SpringBootApplication;
-//
-//@SpringBootApplication
-//public class JeecgAiRagApplication {
-//
-//    public static void main(String[] args) {
-//        SpringApplication.run(JeecgAiRagApplication.class, args);
-//    }
-//}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/consts/AiAppConsts.java

@@ -1,41 +0,0 @@
-package org.jeecg.modules.airag.app.consts;
-
-/**
- * AI应用常量类
- *
- * @author chenrui
- * @date 2025/2/25 14:52
- */
-public class AiAppConsts {
-
-    /**
-     * 状态:启用
-     */
-    public static final String STATUS_ENABLE = "enable";
-    /**
-     * 状态:禁用
-     */
-    public static final String STATUS_DISABLE = "disable";
-    /**
-     * 状态:发布
-     */
-    public static final String STATUS_RELEASE = "release";
-
-
-    /**
-     * 默认应用id
-     */
-    public static final String DEFAULT_APP_ID = "default";
-
-
-    /**
-     * 应用类型:简单聊天
-     */
-    public static final String APP_TYPE_CHAT_SIMPLE = "chatSimple";
-
-    /**
-     * 应用类型:聊天流(高级编排)
-     */
-    public static final String APP_TYPE_CHAT_FLOW = "chatFLow";
-
-}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/consts/Prompts.java

@@ -1,107 +0,0 @@
-package org.jeecg.modules.airag.app.consts;
-
-/**
- * @Description: 提示词常量
- * @Author: chenrui
- * @Date: 2025/3/12 15:03
- */
-public class Prompts {
-
-    /**
-     * 根据提示生成智能体提示词
-     */
-    public static final String GENERATE_LLM_PROMPT = "# 角色\n" +
-            "你是一位专业且高效的AI提示词工程师，擅长根据用户多样化需求自动生成高质量的结构化提示词模板，具备全面而敏锐的分析能力和出色的创造力。\n" +
-            "## 要求：\n" +
-            "1. \"\"\"只输出提示词，不要输出多余解释\"\"\"\n" +
-            "2. \"\"\"不要在前后增加代码块的md语法.\"\"\"\n" +
-            "2. 贴合用户需求，描述智能助手的定位、能力、知识储备\n" +
-            "3. 提示词应清晰、精确、易于理解，在保持质量的同时，尽可能简洁\n" +
-            "4. 严格按照给定的流程和格式执行任务，确保输出规范准确。\n" +
-            "\n" +
-            "## 流程\n" +
-            "### 1: 需求分析\n" +
-            "1. 当用户描述需求时，严格运用SCQA框架确认核心要素，精准分析和联想：\"当前场景(Situation)是什么？主要矛盾(Complication)有哪些？需要解决的关键问题(Question)是？预期达成什么效果(Answer)？\"\n" +
-            "2. 通过5W1H细致分析和联想细节：\"目标受众(Who)？使用场景(Where/When)？具体要实现什么(What)？为什么需要这些特征(Why)？如何量化效果(How)？\"\n" +
-            "\n" +
-            "### 2: 框架选择\n" +
-            "根据需求从给定模板库中匹配最佳提示词类型：\n" +
-            "* 角色扮演型：\n" +
-            "```\n" +
-            "你将扮演一个人物角色<角色名称>，以下是关于这个角色的详细设定，请根据这些信息来构建你的回答。 \n" +
-            "\n" +
-            "**人物基本信息：**\n" +
-            "- 你是：<角色的名称、身份等基本介绍>\n" +
-            "- 人称：第一人称\n" +
-            "- 出身背景与上下文：<交代角色背景信息和上下文>\n" +
-            "**性格特点：**\n" +
-            "- <性格特点描述>\n" +
-            "**语言风格：**\n" +
-            "- <语言风格描述> \n" +
-            "**人际关系：**\n" +
-            "- <人际关系描述>\n" +
-            "**过往经历：**\n" +
-            "- <过往经历描述>\n" +
-            "**经典台词或口头禅：**\n" +
-            "补充信息: 即你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。\n" +
-            "- 台词1：<角色台词示例1> \n" +
-            "- 台词2：<角色台词示例2>\n" +
-            "- ...\n" +
-            "\n" +
-            "要求： \n" +
-            "- 要求1\n" +
-            "- 要求2\n" +
-            "- ... \n" +
-            "```\n" +
-            "* 多步骤型：\n" +
-            "```\n" +
-            "# 角色 \n" +
-            "你是<角色设定(比如:xx领域的专家)>\n" +
-            "你的目标是<希望模型执行什么任务，达成什么目标>\n" +
-            "\n" +
-            "{#以下可以采用先总括，再展开详细说明的方式，描述你希望智能体在每一个步骤如何进行工作，具体的工作步骤数量可以根据实际需求增删#}\n" +
-            "## 工作步骤 \n" +
-            "1. <工作流程1的一句话概括> \n" +
-            "2. <工作流程2的一句话概括> \n" +
-            "3. <工作流程3的一句话概括>\n" +
-            "\n" +
-            "### 第一步 <工作流程1标题> \n" +
-            "<工作流程步骤1的具体工作要求和举例说明，可以分点列出希望在本步骤做哪些事情，需要完成什么阶段性的工作目标>\n" +
-            "### 第二步 <工作流程2标题> \n" +
-            "<工作流程步骤2的具体工作要求和举例说明，可以分点列出希望在本步骤做哪些事情，需要完成什么阶段性的工作目标>\n" +
-            "### 第三步 <工作流程3标题>\n" +
-            "<工作流程步骤3的具体工作要求和举例说明，可以分点列出希望在本步骤做哪些事情，需要完成什么阶段性的工作目标>\n" +
-            "```\n" +
-            "* 限制性模板：\n" +
-            "```\n" +
-            "# 角色：<角色名称>\n" +
-            "<角色概述和主要职责的一句话描述>\n" +
-            "\n" +
-            "## 目标：\n" +
-            "<角色的工作目标，如果有多目标可以分点列出，但建议更聚焦1-2个目标>\n" +
-            "\n" +
-            "## 技能：\n" +
-            "1.  <为了实现目标，角色需要具备的技能1>\n" +
-            "2. <为了实现目标，角色需要具备的技能2>\n" +
-            "3. <为了实现目标，角色需要具备的技能3>\n" +
-            "\n" +
-            "## 工作流：\n" +
-            "1. <描述角色工作流程的第一步>\n" +
-            "2. <描述角色工作流程的第二步>\n" +
-            "3. <描述角色工作流程的第三步>\n" +
-            "\n" +
-            "## 输出格式：\n" +
-            "<如果对角色的输出格式有特定要求，可以在这里强调并举例说明想要的输出格式>\n" +
-            "\n" +
-            "## 限制：\n" +
-            "- <描述角色在互动过程中需要遵循的限制条件1>\n" +
-            "- <描述角色在互动过程中需要遵循的限制条件2>\n" +
-            "- <描述角色在互动过程中需要遵循的限制条件3>\n" +
-            "```\n" +
-            "\n" +
-            "### 3: 生成优化\n" +
-            "1. 输出时自动添加三重保障机制：\n" +
-            "    - 反幻觉校验：\"所有数据需标注来源，不确定信息用[需核实]标记\"\n" +
-            "    - 风格校准器：\"对比[目标风格]与生成内容的余弦相似度，低于0.7时启动重写\"\n" +
-            "    - 伦理审查模块：\"自动过滤涉及隐私/偏见/违法内容，替换为[合规表达]\"";
-}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/controller/AiragAppController.java

@@ -1,181 +0,0 @@
-package org.jeecg.modules.airag.app.controller;
-
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.shiro.authz.annotation.RequiresPermissions;
-import org.jeecg.common.api.vo.Result;
-import org.jeecg.common.system.base.controller.JeecgController;
-import org.jeecg.common.system.query.QueryGenerator;
-import org.jeecg.common.util.AssertUtils;
-import org.jeecg.common.util.TokenUtils;
-import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
-import org.jeecg.config.shiro.IgnoreAuth;
-import org.jeecg.modules.airag.app.consts.AiAppConsts;
-import org.jeecg.modules.airag.app.entity.AiragApp;
-import org.jeecg.modules.airag.app.service.IAiragAppService;
-import org.jeecg.modules.airag.app.service.IAiragChatService;
-import org.jeecg.modules.airag.app.vo.AppDebugParams;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
-
-import javax.servlet.http.HttpServletRequest;
-
-/**
- * @Description: AI应用
- * @Author: jeecg-boot
- * @Date: 2025-02-26
- * @Version: V1.0
- */
-@RestController
-@RequestMapping("/airag/app")
-@Slf4j
-public class AiragAppController extends JeecgController<AiragApp, IAiragAppService> {
-    @Autowired
-    private IAiragAppService airagAppService;
-
-    @Autowired
-    private IAiragChatService airagChatService;
-
-    /**
-     * 分页列表查询
-     *
-     * @param airagApp
-     * @param pageNo
-     * @param pageSize
-     * @param req
-     * @return
-     */
-    @GetMapping(value = "/list")
-    public Result<IPage<AiragApp>> queryPageList(AiragApp airagApp,
-                                                 @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
-                                                 @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
-                                                 HttpServletRequest req) {
-        QueryWrapper<AiragApp> queryWrapper = QueryGenerator.initQueryWrapper(airagApp, req.getParameterMap());
-        Page<AiragApp> page = new Page<AiragApp>(pageNo, pageSize);
-        IPage<AiragApp> pageList = airagAppService.page(page, queryWrapper);
-        return Result.OK(pageList);
-    }
-
-    /**
-     * 新增或编辑
-     *
-     * @param airagApp
-     * @return
-     */
-    @RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
-    @RequiresPermissions("airag:app:edit")
-    public Result<String> edit(@RequestBody AiragApp airagApp) {
-        AssertUtils.assertNotEmpty("参数异常", airagApp);
-        AssertUtils.assertNotEmpty("请输入应用名称", airagApp.getName());
-        AssertUtils.assertNotEmpty("请选择应用类型", airagApp.getType());
-        airagApp.setStatus(AiAppConsts.STATUS_ENABLE);
-        airagAppService.saveOrUpdate(airagApp);
-        return Result.OK("保存完成!", airagApp.getId());
-    }
-
-    /**
-     * 发布应用
-     *
-     * @return
-     */
-    @RequestMapping(value = "/release", method = RequestMethod.POST)
-    public Result<String> release(@RequestParam(name = "id") String id, @RequestParam(name = "release") Boolean release) {
-        AssertUtils.assertNotEmpty("id必须填写", id);
-        if (release == null) {
-            release = true;
-        }
-        AiragApp airagApp = new AiragApp();
-        airagApp.setId(id);
-        if (release) {
-            airagApp.setStatus(AiAppConsts.STATUS_RELEASE);
-        } else {
-            airagApp.setStatus(AiAppConsts.STATUS_ENABLE);
-        }
-        airagAppService.updateById(airagApp);
-        return Result.OK(release ? "发布成功" : "取消发布成功");
-    }
-
-    /**
-     * 通过id删除
-     *
-     * @param id
-     * @return
-     */
-    @DeleteMapping(value = "/delete")
-    @RequiresPermissions("airag:app:delete")
-    public Result<String> delete(HttpServletRequest request,@RequestParam(name = "id", required = true) String id) {
-        //update-begin---author:chenrui ---date:20250606  for：[issues/8337]关于ai工作列表的数据权限问题 #8337------------
-        //如果是saas隔离的情况下，判断当前租户id是否是当前租户下的
-        if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
-            AiragApp app = airagAppService.getById(id);
-            //获取当前租户
-            String currentTenantId = TokenUtils.getTenantIdByRequest(request);
-            if (null == app || !app.getTenantId().equals(currentTenantId)) {
-                return Result.error("删除AI应用失败，不能删除其他租户的AI应用！");
-            }
-        }
-        //update-end---author:chenrui ---date:20250606  for：[issues/8337]关于ai工作列表的数据权限问题 #8337------------
-        airagAppService.removeById(id);
-        return Result.OK("删除成功!");
-    }
-
-    /**
-     * 通过id查询
-     *
-     * @param id
-     * @return
-     */
-    @IgnoreAuth
-    @GetMapping(value = "/queryById")
-    public Result<AiragApp> queryById(@RequestParam(name = "id", required = true) String id) {
-        AiragApp airagApp = airagAppService.getById(id);
-        if (airagApp == null) {
-            return Result.error("未找到对应数据");
-        }
-        return Result.OK(airagApp);
-    }
-
-
-    /**
-     * 调试应用
-     *
-     * @param appDebugParams
-     * @return
-     * @author chenrui
-     * @date 2025/2/28 10:49
-     */
-    @PostMapping(value = "/debug")
-    public SseEmitter debugApp(@RequestBody AppDebugParams appDebugParams) {
-        return airagChatService.debugApp(appDebugParams);
-    }
-
-    /**
-     * 根据需求生成提示词
-     *
-     * @param prompt
-     * @return
-     * @author chenrui
-     * @date 2025/3/12 15:30
-     */
-    @GetMapping(value = "/prompt/generate")
-    public Result<?> generatePrompt(@RequestParam(name = "prompt", required = true) String prompt) {
-        return (Result<?>) airagAppService.generatePrompt(prompt,true);
-    }
-
-    /**
-     * 根据需求生成提示词
-     *
-     * @param prompt
-     * @return
-     * @author chenrui
-     * @date 2025/3/12 15:30
-     */
-    @PostMapping(value = "/prompt/generate")
-    public SseEmitter generatePromptSse(@RequestParam(name = "prompt", required = true) String prompt) {
-        return (SseEmitter) airagAppService.generatePrompt(prompt,false);
-    }
-
-}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/controller/AiragChatController.java

@@ -1,206 +0,0 @@
-package org.jeecg.modules.airag.app.controller;
-
-import lombok.extern.slf4j.Slf4j;
-import org.jeecg.common.api.vo.Result;
-import org.jeecg.common.constant.CommonConstant;
-import org.jeecg.common.util.CommonUtils;
-import org.jeecg.config.shiro.IgnoreAuth;
-import org.jeecg.modules.airag.app.service.IAiragChatService;
-import org.jeecg.modules.airag.app.vo.ChatConversation;
-import org.jeecg.modules.airag.app.vo.ChatSendParams;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.multipart.MultipartHttpServletRequest;
-import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-
-/**
- * airag应用-chat
- *
- * @Author: chenrui
- * @Date: 2025-02-25 11:40
- */
-@Slf4j
-@RestController
-@RequestMapping("/airag/chat")
-public class AiragChatController {
-
-    @Autowired
-    IAiragChatService chatService;
-
-    @Value(value = "${jeecg.path.upload}")
-    private String uploadpath;
-
-    /**
-     * 本地：local minio：minio 阿里：alioss
-     */
-    @Value(value="${jeecg.uploadType}")
-    private String uploadType;
-
-
-    /**
-     * 发送消息
-     *
-     * @return 返回一个Result对象，表示发送消息的结果
-     * @author chenrui
-     * @date 2025/2/25 11:42
-     */
-    @IgnoreAuth
-    @PostMapping(value = "/send")
-    public SseEmitter send(@RequestBody ChatSendParams chatSendParams) {
-        return chatService.send(chatSendParams);
-    }
-
-    /**
-     * 发送消息 <br/>
-     * 兼容旧版浏览器
-     * @param content
-     * @param conversationId
-     * @param topicId
-     * @param appId
-     * @return
-     * @author chenrui
-     * @date 2025/2/25 18:13
-     */
-    @GetMapping(value = "/send")
-    public SseEmitter sendByGet(@RequestParam("content") String content,
-                                @RequestParam(value = "conversationId", required = false) String conversationId,
-                                @RequestParam(value = "topicId", required = false) String topicId,
-                                @RequestParam(value = "appId", required = false) String appId) {
-        ChatSendParams chatSendParams = new ChatSendParams(content, conversationId, topicId, appId);
-        return chatService.send(chatSendParams);
-    }
-
-    /**
-     * 获取所有对话
-     *
-     * @return 返回一个Result对象，包含所有对话的信息
-     * @author chenrui
-     * @date 2025/2/25 11:42
-     */
-    @IgnoreAuth
-    @GetMapping(value = "/init")
-    public Result<?> initChat(@RequestParam(name = "id", required = true) String id) {
-        return chatService.initChat(id);
-    }
-
-    /**
-     * 获取所有对话
-     *
-     * @return 返回一个Result对象，包含所有对话的信息
-     * @author chenrui
-     * @date 2025/2/25 11:42
-     */
-    @IgnoreAuth
-    @GetMapping(value = "/conversations")
-    public Result<?> getConversations(@RequestParam(value = "appId", required = false) String appId) {
-        return chatService.getConversations(appId);
-    }
-
-    /**
-     * 删除会话
-     *
-     * @param id
-     * @return
-     * @author chenrui
-     * @date 2025/3/3 16:55
-     */
-    @IgnoreAuth
-    @DeleteMapping(value = "/conversation/{id}")
-    public Result<?> deleteConversation(@PathVariable("id") String id) {
-        return chatService.deleteConversation(id);
-    }
-
-    /**
-     * 更新会话标题
-     *
-     * @param updateTitleParams
-     * @return
-     * @author chenrui
-     * @date 2025/3/3 16:55
-     */
-    @IgnoreAuth
-    @PutMapping(value = "/conversation/update/title")
-    public Result<?> updateConversationTitle(@RequestBody ChatConversation updateTitleParams) {
-        return chatService.updateConversationTitle(updateTitleParams);
-    }
-
-    /**
-     * 获取消息
-     *
-     * @return 返回一个Result对象，包含消息的信息
-     * @author chenrui
-     * @date 2025/2/25 11:42
-     */
-    @IgnoreAuth
-    @GetMapping(value = "/messages")
-    public Result<?> getMessages(@RequestParam(value = "conversationId", required = true) String conversationId) {
-        return chatService.getMessages(conversationId);
-    }
-
-    /**
-     * 清空消息
-     *
-     * @return
-     * @author chenrui
-     * @date 2025/2/25 11:42
-     */
-    @IgnoreAuth
-    @GetMapping(value = "/messages/clear/{conversationId}")
-    public Result<?> clearMessage(@PathVariable(value = "conversationId") String conversationId) {
-        return chatService.clearMessage(conversationId);
-    }
-
-
-    /**
-     * 根据请求ID停止某个请求的处理
-     *
-     * @param requestId 请求的唯一标识符，用于识别和停止特定的请求
-     * @return 返回一个Result对象，表示停止请求的结果
-     * @author chenrui
-     * @date 2025/2/25 11:42
-     */
-    @IgnoreAuth
-    @GetMapping(value = "/stop/{requestId}")
-    public Result<?> stop(@PathVariable(name = "requestId", required = true) String requestId) {
-        return chatService.stop(requestId);
-    }
-
-
-    /**
-     * 上传文件
-     * for [QQYUN-12135]AI聊天，上传图片提示非法token
-     *
-     * @param request
-     * @param response
-     * @return
-     * @throws Exception
-     * @author chenrui
-     * @date 2025/4/25 11:04
-     */
-    @IgnoreAuth
-    @PostMapping(value = "/upload")
-    public Result<?> upload(HttpServletRequest request, HttpServletResponse response) throws Exception {
-        String bizPath = "airag";
-
-        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
-        // 获取上传文件对象
-        MultipartFile file = multipartRequest.getFile("file");
-        String savePath;
-        if (CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)) {
-            savePath = CommonUtils.uploadLocal(file, bizPath, uploadpath);
-        } else {
-            savePath = CommonUtils.upload(file, bizPath, uploadType);
-        }
-        Result<?> result = new Result<>();
-        result.setMessage(savePath);
-        result.setSuccess(true);
-        return result;
-    }
-
-}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/entity/AiragApp.java

@@ -1,191 +0,0 @@
-package org.jeecg.modules.airag.app.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import com.fasterxml.jackson.annotation.JsonFormat;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.experimental.Accessors;
-import org.jeecg.common.aspect.annotation.Dict;
-import org.jeecg.common.util.oConvertUtils;
-import org.jeecgframework.poi.excel.annotation.Excel;
-import org.springframework.format.annotation.DateTimeFormat;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * @Description: AI应用
- * @Author: jeecg-boot
- * @Date: 2025-02-26
- * @Version: V1.0
- */
-@Data
-@TableName("airag_app")
-@Accessors(chain = true)
-@EqualsAndHashCode(callSuper = false)
-@Schema(description="AI应用")
-public class AiragApp implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * 主键
-     */
-    @TableId(type = IdType.ASSIGN_ID)
-    @Schema(description = "主键")
-    private java.lang.String id;
-    /**
-     * 创建人
-     */
-    @Schema(description = "创建人")
-    @Dict(dictTable = "sys_user",dicCode = "username",dicText = "realname")
-    private java.lang.String createBy;
-    /**
-     * 创建日期
-     */
-    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @Schema(description = "创建日期")
-    private java.util.Date createTime;
-    /**
-     * 更新人
-     */
-    @Schema(description = "更新人")
-    private java.lang.String updateBy;
-    /**
-     * 更新日期
-     */
-    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @Schema(description = "更新日期")
-    private java.util.Date updateTime;
-    /**
-     * 所属部门
-     */
-    @Schema(description = "所属部门")
-    private java.lang.String sysOrgCode;
-    /**
-     * 租户id
-     */
-    @Excel(name = "租户id", width = 15)
-    @Schema(description = "租户id")
-    private java.lang.String tenantId;
-    /**
-     * 应用名称
-     */
-    @Excel(name = "应用名称", width = 15)
-    @Schema(description = "应用名称")
-    private java.lang.String name;
-    /**
-     * 应用描述
-     */
-    @Excel(name = "应用描述", width = 15)
-    @Schema(description = "应用描述")
-    private java.lang.String descr;
-    /**
-     * 应用图标
-     */
-    @Excel(name = "应用图标", width = 15)
-    @Schema(description = "应用图标")
-    private java.lang.String icon;
-    /**
-     * 应用类型
-     */
-    @Excel(name = "应用类型", width = 15, dicCode = "ai_app_type")
-    @Dict(dicCode = "ai_app_type")
-    @Schema(description = "应用类型")
-    private java.lang.String type;
-    /**
-     * 开场白
-     */
-    @Excel(name = "开场白", width = 15)
-    @Schema(description = "开场白")
-    private java.lang.String prologue;
-    /**
-     * 预设问题
-     */
-    @Excel(name = "预设问题", width = 15)
-    @Schema(description = "预设问题")
-    private java.lang.String presetQuestion;
-    /**
-     * 提示词
-     */
-    @Excel(name = "提示词", width = 15)
-    @Schema(description = "提示词")
-    private java.lang.String prompt;
-    /**
-     * 模型配置
-     */
-    @Excel(name = "模型配置", width = 15, dictTable = "airag_model where model_type = 'LLM' ", dicText = "name", dicCode = "id")
-    @Dict(dictTable = "airag_model where model_type = 'LLM' ", dicText = "name", dicCode = "id")
-    @Schema(description = "模型配置")
-    private java.lang.String modelId;
-    /**
-     * 历史消息数
-     */
-    @Excel(name = "历史消息数", width = 15)
-    @Schema(description = "历史消息数")
-    private java.lang.Integer msgNum;
-    /**
-     * 知识库
-     */
-    @Excel(name = "知识库", width = 15, dictTable = "airag_knowledge where status = 'enable'", dicText = "name", dicCode = "id")
-    @Dict(dictTable = "airag_knowledge where status = 'enable'", dicText = "name", dicCode = "id")
-    @Schema(description = "知识库")
-    private java.lang.String knowledgeIds;
-    /**
-     * 流程
-     */
-    @Excel(name = "流程", width = 15, dictTable = "airag_flow where status = 'enable' ", dicText = "name", dicCode = "id")
-    @Dict(dictTable = "airag_flow where status = 'enable' ", dicText = "name", dicCode = "id")
-    @Schema(description = "流程")
-    private java.lang.String flowId;
-    /**
-     * 快捷指令
-     */
-    @Excel(name = "快捷指令", width = 15)
-    @Schema(description = "快捷指令")
-    private java.lang.String quickCommand;
-    /**
-     * 状态（enable=启用、disable=禁用、release=发布）
-     */
-    @Excel(name = "状态", width = 15)
-    @Schema(description = "状态")
-    private java.lang.String status;
-
-
-    /**
-     * 元数据
-     */
-    @Excel(name = "元数据", width = 15)
-    @Schema(description = "元数据")
-    private java.lang.String metadata;
-
-    /**
-     * 知识库ids
-     */
-    @TableField(exist = false)
-    private List<String> knowIds;
-
-    /**
-     * 获取知识库id
-     *
-     * @return
-     * @author chenrui
-     * @date 2025/2/28 11:45
-     */
-    public List<String> getKnowIds() {
-        if (oConvertUtils.isNotEmpty(knowledgeIds)) {
-            String[] knowIds = knowledgeIds.split(",");
-            return Arrays.asList(knowIds);
-        } else {
-            return new ArrayList<>(0);
-        }
-    }
-}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/mapper/AiragAppMapper.java

@@ -1,25 +0,0 @@
-package org.jeecg.modules.airag.app.mapper;
-
-import com.baomidou.mybatisplus.annotation.InterceptorIgnore;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import org.jeecg.modules.airag.app.entity.AiragApp;
-
-/**
- * @Description: AI应用
- * @Author: jeecg-boot
- * @Date:   2025-02-26
- * @Version: V1.0
- */
-public interface AiragAppMapper extends BaseMapper<AiragApp> {
-
-    /**
-     * 根据ID查询app信息(忽略租户)
-     * @param id
-     * @return
-     * @author chenrui
-     * @date 2025/4/21 16:03
-     */
-    @InterceptorIgnore(tenantLine = "true")
-    AiragApp getByIdIgnoreTenant(String id);
-
-}

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/mapper/xml/AiragAppMapper.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="org.jeecg.modules.airag.app.mapper.AiragAppMapper">
-
-    <select id="getByIdIgnoreTenant" resultType="org.jeecg.modules.airag.app.entity.AiragApp">
-        SELECT * FROM airag_app WHERE id = #{id}
-    </select>
-
-</mapper>

jeecg-boot/jeecg-boot-module/jeecg-boot-module-airag/src/main/java/org/jeecg/modules/airag/app/service/IAiragAppService.java

@@ -1,24 +0,0 @@
-package org.jeecg.modules.airag.app.service;
-
-import com.baomidou.mybatisplus.extension.service.IService;
-import org.jeecg.common.api.vo.Result;
-import org.jeecg.modules.airag.app.entity.AiragApp;
-
-/**
- * @Description: AI应用
- * @Author: jeecg-boot
- * @Date:   2025-02-26
- * @Version: V1.0
- */
-public interface IAiragAppService extends IService<AiragApp> {
-
-    /**
-     * 生成提示词
-     * @param prompt
-     * @return blocking 是否阻塞
-     * @return
-     * @author chenrui
-     * @date 2025/3/12 14:45
-     */
-    Object generatePrompt(String prompt,boolean blocking);
-}