Tio Boot DocsTio Boot Docs
Home
  • java-db
  • api-table
  • Enjoy
  • Tio Boot Admin
  • ai_agent
  • translator
  • knowlege_base
  • ai-search
  • 案例
Abount
  • Github
  • Gitee
Home
  • java-db
  • api-table
  • Enjoy
  • Tio Boot Admin
  • ai_agent
  • translator
  • knowlege_base
  • ai-search
  • 案例
Abount
  • Github
  • Gitee
  • 01_tio-boot 简介

    • tio-boot:新一代高性能 Java Web 开发框架
    • tio-boot 入门示例
    • Tio-Boot 配置 : 现代化的配置方案
    • tio-boot 整合 Logback
    • tio-boot 整合 hotswap-classloader 实现热加载
    • 自行编译 tio-boot
    • 最新版本
    • 开发规范
  • 02_部署

    • 使用 Maven Profile 实现分环境打包 tio-boot 项目
    • Maven 项目配置详解:依赖与 Profiles 配置
    • tio-boot 打包成 FastJar
    • 使用 GraalVM 构建 tio-boot Native 程序
    • 使用 Docker 部署 tio-boot
    • 部署到 Fly.io
    • 部署到 AWS Lambda
    • 到阿里云云函数
    • 使用 Deploy 工具部署
    • 胖包与瘦包的打包与部署
    • 使用 Jenkins 部署 Tio-Boot 项目
    • 使用 Nginx 反向代理 Tio-Boot
    • 使用 Supervisor 管理 Java 应用
  • 03_配置

    • 配置参数
    • 服务器监听器
    • 内置缓存系统 AbsCache
    • 使用 Redis 作为内部 Cache
    • 静态文件处理器
    • 基于域名的静态资源隔离
    • DecodeExceptionHandler
  • 04_原理

    • 生命周期
    • 请求处理流程
    • 重要的类
  • 05_json

    • Json
    • 接受 JSON 和响应 JSON
    • 响应实体类
  • 06_web

    • 概述
    • 文件上传
    • 接收请求参数
    • 接收日期参数
    • 接收数组参数
    • 返回字符串
    • 返回文本数据
    • 返回网页
    • 请求和响应字节
    • 文件下载
    • 返回视频文件并支持断点续传
    • http Session
    • Cookie
    • HttpRequest
    • HttpResponse
    • Resps
    • RespBodyVo
    • /zh/06_web/19.html
    • 全局异常处理器
    • 异步
    • 动态 返回 CSS 实现
    • 返回图片
    • Transfer-Encoding: chunked 实时音频播放
    • Server-Sent Events (SSE)
    • 接口访问统计
    • 接口请求和响应数据记录
    • 自定义 Handler 转发请求
    • 使用 HttpForwardHandler 转发所有请求
    • 跨域
    • 添加 Controller
    • 常用工具类
    • HTTP Basic 认证
    • WebJars
    • JProtobuf
  • 07_validate

    • 数据紧校验规范
    • 参数校验
  • 08_websocket

    • 使用 tio-boot 搭建 WebSocket 服务
    • WebSocket 聊天室项目示例
  • 09_java-db

    • java‑db
    • 操作数据库入门示例
    • SQL 模板
    • 数据源配置与使用
    • ActiveRecord
    • Model
    • 生成器与 Model
    • Db 工具类
    • 批量操作
    • 数据库事务处理
    • Cache 缓存
    • Dialect 多数据库支持
    • 表关联操作
    • 复合主键
    • Oracle 支持
    • Enjoy SQL 模板
    • Java-DB 整合 Enjoy 模板最佳实践
    • 多数据源支持
    • 独立使用 ActiveRecord
    • 调用存储过程
    • java-db 整合 Guava 的 Striped 锁优化
    • 生成 SQL
    • 通过实体类操作数据库
    • java-db 读写分离
    • Spring Boot 整合 Java-DB
    • like 查询
    • 常用操作示例
    • Druid 监控集成指南
    • SQL 统计
  • 10_api-table

    • ApiTable 概述
    • 使用 ApiTable 连接 SQLite
    • 使用 ApiTable 连接 Mysql
    • 使用 ApiTable 连接 Postgres
    • 使用 ApiTable 连接 TDEngine
    • 使用 api-table 连接 oracle
    • 使用 api-table 连接 mysql and tdengine 多数据源
    • EasyExcel 导出
    • EasyExcel 导入
    • TQL(Table SQL)前端输入规范
    • ApiTable 实现增删改查
    • 数组类型
    • 单独使用 ApiTable
  • 11_aop

    • JFinal-aop
    • Aop 工具类
    • 配置
    • 配置
    • 独立使用 JFinal Aop
    • @AImport
    • 原理解析
  • 12_cache

    • Caffine
    • Jedis-redis
    • hutool RedisDS
    • Redisson
    • Caffeine and redis
    • CacheUtils 工具类
    • 使用 CacheUtils 整合 caffeine 和 redis 实现的两级缓存
    • 使用 java-db 整合 ehcache
    • 使用 java-db 整合 redis
    • Java DB Redis 相关 Api
    • redis 使用示例
  • 13_认证和权限

    • hutool-JWT
    • FixedTokenInterceptor
    • 使用内置 TokenManager 实现登录
    • 用户系统
    • 重置密码
    • 匿名登录
    • Google 登录
    • 权限校验注解
    • Sa-Token
    • sa-token 登录注册
    • StpUtil.isLogin() 源码解析
    • 短信登录
    • 移动端微信登录实现指南
    • 移动端重置密码
  • 14_i18n

    • i18n
  • 15_enjoy

    • tio-boot 整合 Enjoy 模版引擎文档
    • 引擎配置
    • 表达式
    • 指令
    • 注释
    • 原样输出
    • Shared Method 扩展
    • Shared Object 扩展
    • Extension Method 扩展
    • Spring boot 整合
    • 独立使用 Enjoy
    • tio-boot enjoy 自定义指令 localeDate
    • PromptEngine
    • Enjoy 入门示例-擎渲染大模型请求体
    • Enjoy 使用示例
  • 16_定时任务

    • Quartz 定时任务集成指南
    • 分布式定时任务 xxl-jb
    • cron4j 使用指南
  • 17_tests

    • TioBootTest 类
  • 18_tio

    • TioBootServer
    • tio-core
    • 内置 TCP 处理器
    • 独立启动 UDPServer
    • 使用内置 UDPServer
    • t-io 消息处理流程
    • tio-运行原理详解
    • TioConfig
    • ChannelContext
    • Tio 工具类
    • 业务数据绑定
    • 业务数据解绑
    • 发送数据
    • 关闭连接
    • Packet
    • 监控: 心跳
    • 监控: 客户端的流量数据
    • 监控: 单条 TCP 连接的流量数据
    • 监控: 端口的流量数据
    • 单条通道统计: ChannelStat
    • 所有通道统计: GroupStat
    • 资源共享
    • 成员排序
    • ssl
    • DecodeRunnable
    • 使用 AsynchronousSocketChannel 响应数据
    • 拉黑 IP
    • 深入解析 Tio 源码:构建高性能 Java 网络应用
  • 19_aio

    • ByteBuffer
    • AIO HTTP 服务器
    • 自定义和线程池和池化 ByteBuffer
    • AioHttpServer 应用示例 IP 属地查询
    • 手写 AIO Http 服务器
  • 20_netty

    • Netty TCP Server
    • Netty Web Socket Server
    • 使用 protoc 生成 Java 包文件
    • Netty WebSocket Server 二进制数据传输
    • Netty 组件详解
  • 21_netty-boot

    • Netty-Boot
    • 原理解析
    • 整合 Hot Reload
    • 整合 数据库
    • 整合 Redis
    • 整合 Elasticsearch
    • 整合 Dubbo
    • Listener
    • 文件上传
    • 拦截器
    • Spring Boot 整合 Netty-Boot
    • SSL 配置指南
    • ChannelInitializer
    • Reserve
  • 22_MQ

    • Mica-mqtt
    • EMQX
    • Disruptor
  • 23_tio-utils

    • tio-utils
    • HttpUtils
    • Notification
    • 邮箱
    • JSON
    • 读取文件
    • Base64
    • 上传和下载
    • Http
    • Telegram
    • RsaUtils
    • EnvUtils 使用文档
    • 系统监控
    • 毫秒并发 ID (MCID) 生成方案
  • 24_tio-http-server

    • 使用 Tio-Http-Server 搭建简单的 HTTP 服务
    • tio-boot 添加 HttpRequestHandler
    • 在 Android 上使用 tio-boot 运行 HTTP 服务
    • tio-http-server-native
    • handler 常用操作
  • 25_tio-websocket

    • WebSocket 服务器
    • WebSocket Client
  • 26_tio-im

    • 通讯协议文档
    • ChatPacket.proto 文档
    • java protobuf
    • 数据表设计
    • 创建工程
    • 登录
    • 历史消息
    • 发消息
  • 27_mybatis

    • Tio-Boot 整合 MyBatis
    • 使用配置类方式整合 MyBatis
    • 整合数据源
    • 使用 mybatis-plus 整合 tdengine
    • 整合 mybatis-plus
  • 28_mongodb

    • tio-boot 使用 mongo-java-driver 操作 mongodb
  • 29_elastic-search

    • Elasticsearch
    • JavaDB 整合 ElasticSearch
    • Elastic 工具类使用指南
    • Elastic-search 注意事项
    • ES 课程示例文档
  • 30_magic-script

    • tio-boot 整合 magic-script
  • 31_groovy

    • tio-boot 整合 Groovy
  • 32_firebase

    • 整合 google firebase
    • Firebase Storage
    • Firebase Authentication
    • 使用 Firebase Admin SDK 进行匿名用户管理与自定义状态标记
    • 导出用户
    • 注册回调
    • 登录注册
  • 33_文件存储

    • 文件上传数据表
    • 本地存储
    • 使用 AWS S3 存储文件并整合到 Tio-Boot 项目中
    • 存储文件到 腾讯 COS
  • 34_spider

    • jsoup
    • 爬取 z-lib.io 数据
    • 整合 WebMagic
    • WebMagic 示例:爬取学校课程数据
    • Playwright
    • Flexmark (Markdown 处理器)
    • tio-boot 整合 Playwright
    • 缓存网页数据
  • 36_integration_thirty_party

    • tio-boot 整合 okhttp
    • 整合 GrpahQL
    • 集成 Mailjet
    • 整合 ip2region
    • 整合 GeoLite 离线库
    • 整合 Lark 机器人指南
    • 集成 Lark Mail 实现邮件发送
    • Thymeleaf
    • Swagger
    • Clerk 验证
  • 37_dubbo

    • 概述
    • dubbo 2.6.0
    • dubbo 2.6.0 调用过程
    • dubbo 3.2.0
  • 38_spring

    • Spring Boot Web 整合 Tio Boot
    • spring-boot-starter-webflux 整合 tio-boot
    • Tio Boot 整合 Spring Boot Starter
    • Tio Boot 整合 Spring Boot Starter Data Redis 指南
  • 39_spring-cloud

    • tio-boot spring-cloud
  • 40_mysql

    • 使用 Docker 运行 MySQL
    • /zh/42_mysql/02.html
  • 41_postgresql

    • PostgreSQL 安装
    • PostgreSQL 主键自增
    • PostgreSQL 日期类型
    • Postgresql 金融类型
    • PostgreSQL 数组类型
    • PostgreSQL 全文检索
    • PostgreSQL 查询优化
    • 获取字段类型
    • PostgreSQL 向量
    • PostgreSQL 优化向量查询
    • PostgreSQL 其他
  • 43_oceanbase

    • 快速体验 OceanBase 社区版
    • 快速上手 OceanBase 数据库单机部署与管理
    • 诊断集群性能
    • 优化 SQL 性能指南
    • /zh/43_oceanbase/05.html
  • 50_media

    • JAVE 提取视频中的声音
    • Jave 提取视频中的图片
    • /zh/50_media/03.html
  • 51_asr

    • Whisper-JNI
  • 54_native-media

    • java-native-media
    • JNI 入门示例
    • mp3 拆分
    • mp4 转 mp3
    • 使用 libmp3lame 实现高质量 MP3 编码
    • Linux 编译
    • macOS 编译
    • 从 JAR 包中加载本地库文件
    • 支持的音频和视频格式
    • 任意格式转为 mp3
    • 通用格式转换
    • 通用格式拆分
    • 视频合并
    • VideoToHLS
    • split_video_to_hls 支持其他语言
    • 持久化 HLS 会话
  • 55_telegram4j

    • 数据库设计
    • /zh/55_telegram4j/02.html
    • 基于 MTProto 协议开发 Telegram 翻译机器人
    • 过滤旧消息
    • 保存机器人消息
    • 定时推送
    • 增加命令菜单
    • 使用 telegram-Client
    • 使用自定义 StoreLayout
    • 延迟测试
    • Reactor 错误处理
    • Telegram4J 常见错误处理指南
  • 56_telegram-bots

    • TelegramBots 入门指南
    • 使用工具库 telegram-bot-base 开发翻译机器人
  • 60_LLM

    • 简介
    • AI 问答
    • /zh/60_LLM/03.html
    • /zh/60_LLM/04.html
    • 增强检索(RAG)
    • 结构化数据检索
    • 搜索+AI
    • 集成第三方 API
    • 后置处理
    • 推荐问题生成
    • 连接代码执行器
    • 避免 GPT 混乱
    • /zh/60_LLM/13.html
  • 61_ai_agent

    • 数据库设计
    • 示例问题管理
    • 会话管理
    • 历史记录
    • 对接 Perplexity API
    • 意图识别与生成提示词
    • 智能问答模块设计与实现
    • 文件上传与解析文档
    • 翻译
    • 名人搜索功能实现
    • Ai studio gemini youbue 问答使用说明
    • 自建 YouTube 字幕问答系统
    • 自建 获取 youtube 字幕服务
    • 通用搜索
    • /zh/61_ai_agent/15.html
    • 16
    • 17
    • 18
    • 在 tio-boot 应用中整合 ai-agent
    • 16
  • 62_translator

    • 简介
  • 63_knowlege_base

    • 数据库设计
    • 用户登录实现
    • 模型管理
    • 知识库管理
    • 文档拆分
    • 片段向量
    • 命中测试
    • 文档管理
    • 片段管理
    • 问题管理
    • 应用管理
    • 向量检索
    • 推理问答
    • 问答模块
    • 统计分析
    • 用户管理
    • api 管理
    • 存储文件到 S3
    • 文档解析优化
    • 片段汇总
    • 段落分块与检索
    • 多文档解析
    • 对话日志
    • 检索性能优化
    • Milvus
    • 文档解析方案和费用对比
    • 离线运行向量模型
  • 64_ai-search

    • ai-search 项目简介
    • ai-search 数据库文档
    • ai-search SearxNG 搜索引擎
    • ai-search Jina Reader API
    • ai-search Jina Search API
    • ai-search 搜索、重排与读取内容
    • ai-search PDF 文件处理
    • ai-search 推理问答
    • Google Custom Search JSON API
    • ai-search 意图识别
    • ai-search 问题重写
    • ai-search 系统 API 接口 WebSocket 版本
    • ai-search 搜索代码实现 WebSocket 版本
    • ai-search 生成建议问
    • ai-search 生成问题标题
    • ai-search 历史记录
    • Discover API
    • 翻译
    • Tavily Search API 文档
    • 对接 Tavily Search
    • 火山引擎 DeepSeek
    • 对接 火山引擎 DeepSeek
    • ai-search 搜索代码实现 SSE 版本
    • jar 包部署
    • Docker 部署
    • 爬取一个静态网站的所有数据
    • 网页数据预处理
    • 网页数据检索与问答流程整合
  • 65_java-linux

    • Java 执行 python 代码
    • 通过大模型执行 Python 代码
    • MCP 协议
    • Cline 提示词
    • Cline 提示词-中文版本
  • 66_manim

    • 简介
    • Manim 开发环境搭建
    • 生成场景提示词
    • 生成代码
    • 完整脚本示例
    • 语音合成系统
    • Fish.audio TTS 接口说明文档与 Java 客户端封装
    • 整合 fishaudio 到 java-uni-ai-server 项目
    • 执行 Python (Manim) 代码
    • 使用 SSE 流式传输生成进度的实现文档
    • 整合全流程完整文档
    • HLS 动态推流技术文档
    • manim 分场景生成代码
    • 分场景运行代码及流式播放支持
    • 分场景业务端完整实现流程
    • Maiim布局管理器
    • 仅仅生成场景代码
    • 使用 modal 运行 manim 代码
    • Python 使用 Modal GPU 加速渲染
    • Modal 平台 GPU 环境下运行 Manim
    • Modal Manim OpenGL 安装与使用
    • 优化 GPU 加速
    • 生成视频封面流程
    • Java 调用 manim 命令 执行代码 生成封面
    • Manim 图像生成服务客户端文档
    • manim render help
    • 显示 中文公式
    • manimgl
    • EGL
    • /zh/66_manim/30.html
    • /zh/66_manim/31.html
    • 成本核算
    • /zh/66_manim/33.html
  • 70_tio-boot-admin

    • 入门指南
    • 初始化数据
    • token 存储
    • 与前端集成
    • 文件上传
    • 网络请求
    • 图片管理
    • /zh/70_tio-boot-admin/08.html
    • Word 管理
    • PDF 管理
    • 文章管理
    • 富文本编辑器
  • 71_tio-boot

    • /zh/71_tio-boot/01.html
    • Swagger 整合到 Tio-Boot 中的指南
    • HTTP/1.1 Pipelining 性能测试报告
  • 80_性能测试

    • 压力测试 - tio-http-serer
    • 压力测试 - tio-boot
    • 压力测试 - tio-boot-native
    • 压力测试 - netty-boot
    • 性能测试对比
    • TechEmpower FrameworkBenchmarks
    • 压力测试 - tio-boot 12 C 32G
  • 99_案例

    • 封装 IP 查询服务
    • tio-boot 案例 - 全局异常捕获与企业微信群通知
    • tio-boot 案例 - 文件上传和下载
    • tio-boot 案例 - 整合 ant design pro 增删改查
    • tio-boot 案例 - 流失响应
    • tio-boot 案例 - 增强检索
    • tio-boot 案例 - 整合 function call
    • tio-boot 案例 - 定时任务 监控 PostgreSQL、Redis 和 Elasticsearch
    • Tio-Boot 案例:使用 SQLite 整合到登录注册系统
    • tio-boot 案例 - 执行 shell 命令

文档拆分

  • 项目目标
  • 系统核心概念
  • 功能实现步骤
  • 接口
    • POST /api/dataset/document/split
  • 文档上传
    • 数据模型
    • 控制器
    • 文件服务
    • 数据访问对象 (DAO)
  • 文档解析和拆分
    • 文件解析提示词
    • PDF 文件解析流程
    • 单并发方案
    • 多并发方案

项目目标

本项目旨在构建一个功能完备的 RAG(Retrieval-Augmented Generation)系统,主要目标包括:

  • 知识库管理:支持创建、更新和删除知识库,便于用户高效维护内容。
  • 文档处理:包括文档的拆分、片段的向量化处理,以提升检索效率和准确性。
  • 问答系统:提供高效的向量检索和实时生成回答的能力,支持复杂汇总类问题的处理。
  • 系统优化:通过统计分析和推理问答调试,不断优化系统性能和用户体验。

系统核心概念

在 RAG 系统中,以下是几个核心概念:

  • 应用:知识库的集合。每个应用可以自定义提示词,以满足不同的个性化需求。
  • 知识库:由多个文档组成,便于用户对内容进行分类和管理。
  • 文档:系统中对应的真实文档内容。
  • 片段:文档经过拆分后的最小内容单元,用于更高效的处理和检索。

功能实现步骤

  1. 数据库设计 查看 01.md
    设计并实现项目所需的数据表结构与数据库方案,为后续的数据操作打下坚实基础。

  2. 用户登录 查看 02.md
    实现了安全可靠的用户认证系统,保护用户数据并限制未经授权的访问。

  3. 模型管理 查看 03.md
    支持针对不同平台的模型(如 OpenAI、Google Gemini、Claude)进行管理与配置。

  4. 知识库管理 查看 04.md
    提供创建、更新及删除知识库的功能,方便用户维护与管理文档内容。

  5. 文档拆分 查看 05.md
    可将文档拆分为多个片段,便于后续向量化和检索操作。

  6. 片段向量 查看 06.md
    将文本片段进行向量化处理,以便进行语义相似度计算及高效检索。

  7. 命中率测试 查看 07.md
    通过语义相似度和 Top-N 算法,检索并返回与用户问题最相关的文档片段,用于评估检索的准确性。

  8. 文档管理 查看 08.md
    提供上传和管理文档的功能,上传后可自动拆分为片段便于进一步处理。

  9. 片段管理 查看 09.md
    允许对已拆分的片段进行增、删、改、查等操作,确保内容更新灵活可控。

  10. 问题管理 查看 10.md
    为片段指定相关问题,以提升检索时的准确性与关联度。

  11. 应用管理 查看 11.md
    提供创建和配置应用(智能体)的功能,并可关联指定模型和知识库。

  12. 向量检索 查看 12.md
    基于语义相似度,在知识库中高效检索与用户问题最匹配的片段。

  13. 推理问答调试 查看 13.md
    提供检索与问答性能的评估工具,帮助开发者进行系统优化与调试。

  14. 对话问答 查看 14.md
    为用户提供友好的人机交互界面,结合检索到的片段与用户问题实时生成回答。

  15. 统计分析 查看 15.md
    对用户的提问与系统回答进行数据化分析,并以可视化图表的形式呈现系统使用情况。

  16. 用户管理 查看 16.md
    提供多用户管理功能,包括用户的增删改查及权限控制。

  17. API 管理 查看 17.md
    对外提供标准化 API,便于外部系统集成和调用本系统的功能。

  18. 存储文件到 S3 查看 18.md
    将用户上传的文件存储至 S3 等对象存储平台,提升文件管理的灵活性与可扩展性。

  19. 文档解析优化 查看 19.md
    介绍与对比常见的文档解析方案,并提供提升文档解析速度和准确性的优化建议。

  20. 片段汇总 查看 20.md
    对片段内容进行汇总,以提升总结类问题的查询与回答效率。

  21. 文档多分块与检索 查看 21.md
    将片段进一步拆分为句子并进行向量检索,提升检索的准确度与灵活度。

  22. 多文档支持 查看 22.md
    兼容多种文档格式,包括 .doc, .docx, .xls, .xlsx, .ppt, .pptx 等。

  23. 对话日志 查看 23.md
    记录并展示对话日志,用于后续分析和问题回溯。

  24. 检索性能优化 查看 24.md
    提供整库扫描和分区检索等多种方式,进一步提高检索速度和效率。

  25. Milvus 查看 25.md
    将向量数据库切换至 Milvus,以在大规模向量检索场景中获得更佳的性能与可扩展性。

  26. 文档解析方案和费用对比 查看 26.md
    对比不同文档解析方案在成本、速度、稳定性等方面的差异,为用户提供更加经济高效的选择。

  27. 爬取网页数据 查看 27.md
    支持从网页中抓取所需内容,后续处理流程与本地文档一致:分段、向量化、存储与检索。

接口

POST /api/dataset/document/split

请求参数

  • file(二进制文件):需要上传并拆分的文档文件。

响应

{
  "code": 200,
  "message": "成功",
  "data": [
    {
      "name": "ICS111_31391_Miller_Syllabus_F24.pdf",
      "id": "file_id"
      "content": [
        {
          "title": "",
          "content": "ICS 111- Introduction to Computer Science I, ...n"
        }
      ]
    }
  ]
}

文档上传

用于接收文档上传并存储到本地系统。

数据模型

package com.litongjava.maxkb.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class UploadResultVo {
  private Long id;
  private String filename;
  private String url;
  private String md5;
}

控制器

package com.litongjava.maxkb.controller;

import com.litongjava.annotation.RequestPath;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.maxkb.service.SystemFileService;
import com.litongjava.maxkb.service.kb.MaxKbDocumentSplitService;
import com.litongjava.maxkb.vo.UploadResultVo;
import com.litongjava.model.result.ResultVo;
import com.litongjava.tio.http.common.UploadFile;

@RequestPath("/api/dataset/document")
public class ApiDatasetDocumentController {

  public ResultVo split(UploadFile file) throws Exception {
    if (file == null) {
      return ResultVo.fail("请求体中未找到文件");
    }
    SystemFileService systemFileService = Aop.get(SystemFileService.class);
    UploadResultVo vo = systemFileService.upload(file, "default", "default");
    return Aop.get(MaxKbDocumentSplitService.class).split(file.getData(), vo);
  }
}

文件服务

package com.litongjava.maxkb.service;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import com.litongjava.db.activerecord.Row;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.maxkb.dao.SystemUploadFileDao;
import com.litongjava.maxkb.model.UploadResultVo;
import com.litongjava.tio.http.common.UploadFile;
import com.litongjava.tio.utils.crypto.Md5Utils;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.hutool.FileUtil;
import com.litongjava.tio.utils.hutool.FilenameUtils;
import com.litongjava.tio.utils.snowflake.SnowflakeIdUtils;

public class SystemFileService {

  /**
   * 上传文件并存储到本地文件系统
   *
   * @param uploadFile 上传的文件
   * @param bucketName 存储桶名称
   * @param category 文件分类
   * @return UploadResultVo 文件上传结果
   */
  public UploadResultVo upload(UploadFile uploadFile, String bucketName, String category) {
    if (uploadFile != null) {
      byte[] fileData = uploadFile.getData();
      String digestHex = Md5Utils.digestHex(fileData);
      SystemUploadFileDao systemUploadFileDao = Aop.get(SystemUploadFileDao.class);
      Row row = systemUploadFileDao.getFileBasicInfoByMd5(bucketName, digestHex);

      // 如果文件已存在,返回已有文件信息
      if (row != null) {
        Long id = row.getLong("id");
        String filename = row.getStr("filename");
        String targetName = row.getStr("target_name");
        String url = getUrl(bucketName, targetName);
        return new UploadResultVo(id, filename, url, digestHex);
      }

      // 生成新的文件名和路径
      String originFilename = uploadFile.getName();
      String suffix = FilenameUtils.getSuffix(originFilename);
      long id = SnowflakeIdUtils.id();
      String filename = id + "." + suffix;
      Path path = Paths.get("pages", bucketName, category);

      // 创建目录(如果不存在)
      try {
        Files.createDirectories(path);
      } catch (IOException e) {
        e.printStackTrace();
        return null;
      }

      // 完整文件路径
      Path filePath = path.resolve(filename);
      File file = filePath.toFile();

      // 将文件数据写入指定路径
      FileUtil.writeBytes(fileData, file);

      String targetName = category + "/" + filename;
      String url = getUrl(bucketName, targetName);
      systemUploadFileDao.save(id, digestHex, originFilename, fileData.length, "local", bucketName, targetName);
      return new UploadResultVo(id, originFilename, url, digestHex);
    }
    return null;
  }

  /**
   * 根据存储桶和目标名称生成文件访问 URL
   *
   * @param bucketName 存储桶名称
   * @param targetName 目标名称
   * @return 文件访问 URL
   */
  public String getUrl(String bucketName, String targetName) {
    String prefixUrl = EnvUtils.getStr("file_prefix_url");
    return prefixUrl + "/" + bucketName + "/" + targetName;
  }

  /**
   * 根据文件 ID 获取文件 URL
   *
   * @param id 文件 ID
   * @return UploadResultVo 文件上传结果
   */
  public UploadResultVo getUrlById(Long id) {
    SystemUploadFileDao systemUploadFileDao = Aop.get(SystemUploadFileDao.class);
    Row row = systemUploadFileDao.getFileBasicInfoById(id);
    String md5 = row.getStr("md5");
    String filename = row.getStr("filename");
    String bucketName = row.getStr("bucket_name");
    String targetName = row.getStr("target_name");
    String url = getUrl(bucketName, targetName);
    return new UploadResultVo(id, filename, url, md5);
  }

  /**
   * 根据文件 MD5 获取文件 URL
   *
   * @param bucketName 存储桶名称
   * @param md5 文件 MD5 值
   * @return UploadResultVo 文件上传结果
   */
  public UploadResultVo getUrlByMd5(String bucketName, String md5) {
    SystemUploadFileDao systemUploadFileDao = Aop.get(SystemUploadFileDao.class);
    Row row = systemUploadFileDao.getFileBasicInfoByMd5(bucketName, md5);
    Long id = row.getLong("id");
    String filename = row.getStr("filename");
    String targetName = row.getStr("target_name");
    String url = getUrl(bucketName, targetName);
    return new UploadResultVo(id, filename, url, md5);
  }
}

数据访问对象 (DAO)

package com.litongjava.maxkb.dao;

import com.litongjava.db.activerecord.Db;
import com.litongjava.db.activerecord.Row;

public class SystemUploadFileDao {
  public static final String tableName = "max_kb_file";

  /**
   * 根据 MD5 获取文件基本信息
   *
   * @param bucketName 存储桶名称
   * @param md5 文件 MD5 值
   * @return Row 文件基本信息
   */
  public Row getFileBasicInfoByMd5(String bucketName, String md5) {
    String sql = String.format("SELECT id, filename, bucket_name, target_name FROM %s WHERE bucket_name=? AND md5=? AND deleted=0", tableName);
    return Db.findFirst(sql, bucketName, md5);
  }

  /**
   * 根据文件 ID 获取文件基本信息
   *
   * @param id 文件 ID
   * @return Row 文件基本信息
   */
  public Row getFileBasicInfoById(long id) {
    String sql = String.format("SELECT md5, filename, bucket_name, target_name FROM %s WHERE id=? AND deleted=0", tableName);
    return Db.findFirst(sql, id);
  }

  /**
   * 保存文件信息
   *
   * @param id 文件 ID
   * @param md5 文件 MD5 值
   * @param originFilename 原始文件名
   * @param fileSize 文件大小
   * @param platform 上传平台
   * @param bucketName 存储桶名称
   * @param targetName 目标名称
   * @return 是否保存成功
   */
  public boolean save(long id, String md5, String originFilename, int fileSize, String platform, String bucketName, String targetName) {
    Row row = Row.by("id", id)
        .set("md5", md5)
        .set("filename", originFilename)
        .set("file_size", fileSize)
        .set("platform", platform)
        .set("bucket_name", bucketName)
        .set("target_name", targetName);

    return Db.save(tableName, row);
  }
}

文档解析和拆分

文档解析的方案有很多种,这里采用大模型进行文档解析,通过解析提示词和图片完成文档解析。

image_to_text_prompt_en.txt

文件解析提示词

Your task is to transcribe and format the content of the file into markdown. Your goal is to create a well-structured, highly readable markdown document that accurately represents the original content while applying appropriate formatting and tags.

Please complete the task according to the following instructions:
1. Transcribe the content into markdown format, paying close attention to the existing formatting and structure.
2. Maintain the structure of the document and ensure the use of markdown headings to correctly format sections and subsections (# for main titles, ## for subtitles, etc.).
3. Do not add any additional information or explanations during the conversion process.
4. Do not include page breaks in the transcription.
5. Identify mathematical, physical, and chemical symbols and formulas in the original content and maintain their formatting.
6. Identify page numbers in the original content.
7. Ignore the watermark in the original content during the conversion process.

8. When transcribing tables:
   - If a table spans multiple pages, merge the content into one coherent table.
   - Use proper markdown table formatting, with table structures defined by vertical bars (|) and hyphens (-).

9. When transcribing images:
   - If an image is identified, return the coordinates of the image in the format [name](images/name.png).

10. Use appropriate markdown syntax for other formatting elements, such as bold, italics, lists, and code blocks, as needed.

11. Return only the parsed content in markdown format, including the specified tags for tables, headings, and the table of contents.

12. If you cannot recognize , please output "not_working"

PDF 文件解析流程

  1. 将 PDF 每一页转成图片
    使用 PDFBox 将 PDF 文件的每一页渲染为图片。

  2. 开启指定的并发线路数量
    根据配置开启多个并发线程,将图片与提示词一同发送给大模型进行解析。

  3. 单张图片解析后进行缓存
    为防止相同的图片重复解析,解析结果进行缓存。

  4. 解析完成后拼接成一个文档并存储到本地
    将所有解析后的文本拼接成完整文档,并保存到本地。

  5. 对文档进行分片
    使用文档分割工具将文档按指定规则分片,便于后续处理和存储。

  6. 将分片后的文档返回前端
    将处理后的文档分片结果以 JSON 格式返回给前端应用。

单并发方案

文档拆分服务(单并发)

package com.litongjava.maxkb.service;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.imageio.ImageIO;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;

import com.jfinal.kit.Kv;
import com.litongjava.db.TableInput;
import com.litongjava.db.activerecord.Db;
import com.litongjava.maxkb.constant.MaxKbPrompt;
import com.litongjava.maxkb.constant.TableNames;
import com.litongjava.maxkb.model.UploadResultVo;
import com.litongjava.model.result.ResultVo;
import com.litongjava.openai.chat.ChatResponseUsage;
import com.litongjava.openai.chat.ChatResponseVo;
import com.litongjava.openai.client.OpenAiClient;
import com.litongjava.openai.consts.OpenAiModels;
import com.litongjava.table.services.ApiTable;
import com.litongjava.tio.utils.crypto.Md5Utils;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.hutool.FileUtil;

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentSplitter;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.openai.OpenAiTokenizer;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class DatasetDocumentSplitService {

  /**
   * 拆分文档
   *
   * @param data 文档二进制数据
   * @param vo 上传结果对象
   * @return 拆分后的结果
   * @throws IOException 可能的IO异常
   */
  public ResultVo split(byte[] data, UploadResultVo vo) throws IOException {
    String filename = vo.getFilename();
    String suffix = "png";
    String apiKey = EnvUtils.getStr("OPENAI_API_KEY");
    String markdown = toMarkdown(apiKey, data, suffix);

    Document document = new Document(markdown);
    DocumentSplitter splitter = DocumentSplitters.recursive(500, 100, new OpenAiTokenizer());
    List<TextSegment> segments = splitter.split(document);

    Kv fileSplitResult = Kv.by("name", filename);
    List<Kv> contents = new ArrayList<>();
    for (TextSegment textSegment : segments) {
      contents.add(Kv.by("title", "").set("content", textSegment.text()));
    }
    fileSplitResult.set("content", contents);
    List<Kv> results = new ArrayList<>();

    results.add(fileSplitResult);

    return ResultVo.ok(results);
  }

  /**
   * 将文档转换为 Markdown 格式
   *
   * @param apiKey OpenAI API 密钥
   * @param data 文档二进制数据
   * @param suffix 文件后缀
   * @return Markdown 文本
   * @throws IOException 可能的IO异常
   */
  private String toMarkdown(String apiKey, byte[] data, String suffix) throws IOException {
    String md5 = Md5Utils.digestHex(data);
    TableInput ti = TableInput.create().columns("target");
    String target = ApiTable.queryStr(TableNames.max_kb_document_markdown_cache, md5, ti);
    boolean exists = false;
    if (target != null) {
      false = true;
      // 读取缓存文件并返回
      File file = new File(target);
      if (file.exists()) {
        return FileUtil.readString(file);
      }
    }

    // 加载 PDF 文档并获取总页数
    List<byte[]> documentBytes = new ArrayList<>();
    int totalPages = 0;
    try (PDDocument document = PDDocument.load(new ByteArrayInputStream(data))) {
      totalPages = document.getNumberOfPages();
      log.info("Total pages: {}", totalPages);

      PDFRenderer renderer = new PDFRenderer(document);
      for (int i = 0; i < totalPages; i++) {
        BufferedImage bufferedImage = renderer.renderImageWithDPI(i, 144);
        byte[] imageBytes = toBytes(bufferedImage, suffix);
        documentBytes.add(imageBytes);
      }
    } catch (IOException e) {
      log.error("Error loading PDF document: {}", e.getMessage(), e);
      throw e;
    }

    List<String> markdowns = new ArrayList<>(documentBytes.size());
    for (byte[] imageBytes : documentBytes) {
      String markdown = convertPdfToMarkdown(apiKey, imageBytes, suffix);
      markdowns.add(markdown);
    }

    StringBuilder combinedMarkdown = new StringBuilder();
    for (String string : markdowns) {
      combinedMarkdown.append(string);
    }

    target = "markdowns/" + md5 + ".md";
    new File(target).getParentFile().mkdirs();
    // 保存到缓存
    FileUtil.writeString(combinedMarkdown.toString(), target, "UTF-8");

    return combinedMarkdown.toString();
  }

  /**
   * 将 BufferedImage 转换为字节数组
   *
   * @param bufferedImage 图片对象
   * @param suffix 文件后缀
   * @return 字节数组
   * @throws IOException 可能的IO异常
   */
  public byte[] toBytes(BufferedImage bufferedImage, String suffix) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ImageIO.write(bufferedImage, suffix, baos);
    baos.flush();
    byte[] imageBytes = baos.toByteArray();
    baos.close();
    return imageBytes;
  }

  /**
   * 将 PDF 页面转换为 Markdown
   *
   * @param apiKey OpenAI API 密钥
   * @param imageBytes 图片字节数组
   * @param suffix 文件后缀
   * @return Markdown 文本
   * @throws IOException 可能的IO异常
   */
  private String convertPdfToMarkdown(String apiKey, byte[] imageBytes, String suffix) throws IOException {
    String id = Md5Utils.digestHex(imageBytes);
    String sql = String.format("SELECT content FROM %s WHERE id=?", TableNames.max_kb_document_markdown_page_cache);

    String content = Db.queryStr(sql, id);
    if (content != null) {
      return content;
    }
    String imageName = id + "." + suffix;
    String imagePath = "images/" + imageName;
    File imageFile = new File(imagePath);
    imageFile.getParentFile().mkdirs();
    FileUtil.writeBytes(imageBytes, imageFile);

    long start = System.currentTimeMillis();
    // 调用大模型进行解析
    ChatResponseVo chatResponseVo = OpenAiClient.chatWithImage(apiKey, MaxKbPrompt.image_to_text, imageBytes, suffix);
    long end = System.currentTimeMillis();
    content = chatResponseVo.getChoices().get(0).getMessage().getContent();
    if (content.startsWith("```markdown")) {
      content = content.substring(11, content.length() - 3);
    }

    ChatResponseUsage usage = chatResponseVo.getUsage();

    long elapsed = end - start;
    TableInput saveInput = TableInput.by("id", id)
        .set("target", imagePath)
        .set("content", content)
        .set("elapsed", elapsed)
        .set("model", OpenAiModels.gpt_4o)
        .set("system_fingerprint", chatResponseVo.getSystem_fingerprint())
        .set("completion_tokens", usage.getCompletion_tokens())
        .set("prompt_tokens", usage.getPrompt_tokens())
        .set("total_tokens", usage.getTotal_tokens());
    ApiTable.save(TableNames.max_kb_document_markdown_page_cache, saveInput);
    return content;
  }
}

多并发方案

CompletionService

CompletionService 是 Java 并发库中的接口,用于管理和组织一组并发任务的执行。它提供了一种方便的方式来提交任务并按完成顺序获取结果,而不需要关注任务的提交顺序或执行时间。

核心方法包括:

  • submit(Callable task):提交任务给内部的执行器(Executor)。
  • take():等待并获取完成的任务结果,按完成顺序返回结果。
  • poll():非阻塞地获取完成的任务结果,如果没有已完成的任务,则返回 null。

使用场景:

使用 CompletionService 可以方便地在一组异步任务中处理已经完成的结果,比如批量处理多个文件的解析、数据库查询等。它会按完成顺序提供结果,方便进一步处理。

注意事项:

CompletionService 无法保证结果的顺序,因为它会按任务完成的先后顺序返回结果,而不考虑页面的顺序。

解决方案:

要保证解析结果的顺序,可以在提交任务时将每个任务的页码与 Future 绑定,然后在所有任务完成后根据页码重新排序。

package com.litongjava.maxkb.utils;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceUtils {

  private static final int CONCURRENT_REQUESTS = 100;
  private static final ExecutorService executorService = Executors.newFixedThreadPool(CONCURRENT_REQUESTS);

  public static ExecutorService getExecutorService() {
    return executorService;
  }
}

MaxKbDocumentSplitService

package com.litongjava.maxkb.service.kb;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;

import com.jfinal.kit.Kv;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.maxkb.vo.UploadResultVo;
import com.litongjava.model.result.ResultVo;
import com.litongjava.openai.token.OpenAiTokenizer;
import com.litongjava.tio.utils.environment.EnvUtils;

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentSplitter;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.segment.TextSegment;
import lombok.extern.slf4j.Slf4j;

/**
 * MaxKbDocumentSplitService
 *
 * 该服务用于将上传的PDF文档拆分为多个Markdown段落,利用OpenAI API将图像转换为文本。
 * 支持多线程并发处理,提高处理效率。
 *
 * @author
 * @date
 */
@Slf4j
public class MaxKbDocumentSplitService {
  /**
   * 拆分文档(多并发)
   *
   * @param data 文档二进制数据
   * @param vo 上传结果对象
   * @return 拆分后的结果
   * @throws IOException 可能的IO异常
   * @throws InterruptedException 线程中断异常
   * @throws ExecutionException 执行异常
   */
  public ResultVo split(byte[] data, UploadResultVo vo) throws IOException, InterruptedException, ExecutionException {
    MaxKbDocumentConvertService maxKbDocumentConvertService = Aop.get(MaxKbDocumentConvertService.class);
    String filename = vo.getFilename();
    String suffix = "png";
    String apiKey = EnvUtils.getStr("OPENAI_API_KEY");
    String markdown = maxKbDocumentConvertService.toMarkdown(apiKey, data, suffix);
    List<TextSegment> segments = split(markdown);
    // 创建包含文件名和ID的KV对象
    Kv fileSplitResult = Kv.by("name", filename).set("id", vo.getId());
    List<Kv> contents = new ArrayList<>();

    for (TextSegment textSegment : segments) {
      contents.add(Kv.by("title", "").set("content", textSegment.text()));
    }
    fileSplitResult.set("content", contents);
    List<Kv> results = new ArrayList<>();

    results.add(fileSplitResult);

    return ResultVo.ok(results);
  }

  public List<TextSegment> split(String markdown) {
    Document document = new Document(markdown);
    // 使用较大的块大小(2000)和相同的重叠(400)
    DocumentSplitter splitter = DocumentSplitters.recursive(2000, 400, new OpenAiTokenizer());
    List<TextSegment> segments = splitter.split(document);
    return segments;
  }
}

MaxKbDocumentConvertService

package com.litongjava.maxkb.service.kb;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Future;
import java.util.concurrent.locks.Lock;

import javax.imageio.ImageIO;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;

import com.google.common.util.concurrent.Striped;
import com.jfinal.template.Engine;
import com.litongjava.db.TableInput;
import com.litongjava.db.TableResult;
import com.litongjava.db.activerecord.Db;
import com.litongjava.db.activerecord.Row;
import com.litongjava.maxkb.constant.TableNames;
import com.litongjava.maxkb.utils.ExecutorServiceUtils;
import com.litongjava.openai.chat.ChatResponseUsage;
import com.litongjava.openai.chat.OpenAiChatResponseVo;
import com.litongjava.openai.client.OpenAiClient;
import com.litongjava.openai.consts.OpenAiModels;
import com.litongjava.table.services.ApiTable;
import com.litongjava.tio.utils.crypto.Md5Utils;
import com.litongjava.tio.utils.hutool.FileUtil;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MaxKbDocumentConvertService {
  Striped<Lock> locks = Striped.lock(1024);
  private static final int MAX_HEIGHT = 2200;

  /**
   * 将文档转换为 Markdown 格式(多并发)
   *
   * @param apiKey OpenAI API 密钥
   * @param data 文档二进制数据
   * @param suffix 文件后缀
   * @return Markdown 文本
   * @throws IOException 可能的IO异常
   * @throws InterruptedException 线程中断异常
   * @throws ExecutionException 执行异常
   */
  public String toMarkdown(String apiKey, byte[] data, String suffix) throws IOException, InterruptedException, ExecutionException {
    String md5 = Md5Utils.digestHex(data);
    log.info("Processing document with MD5: {}", md5);

    // 查询缓存以检查是否已经处理过该文档
    TableInput ti = TableInput.create().columns("target,content").set("id", md5);
    TableResult<Row> tableResult = ApiTable.get(TableNames.max_kb_document_markdown_cache, ti);
    Row record = tableResult.getData();
    boolean exists = false;
    String target = null;

    if (record != null) {
      target = record.getStr("target");
      if (target != null) {
        exists = true;
        File file = new File(target);
        if (file.exists()) {
          log.info("Markdown found in cache at {}", target);
          return FileUtil.readString(file);
        }
      }
      String content = record.getStr("content");
      if (content != null) {
        log.info("Markdown content found in cache");
        return content;
      }
    }

    // 将PDF每一页转换为图像字节数组,并处理可能过大的图像
    List<byte[]> documentBytes = new ArrayList<>();
    int totalPages = 0;
    try (PDDocument document = PDDocument.load(new ByteArrayInputStream(data))) {
      totalPages = document.getNumberOfPages();
      PDFRenderer renderer = new PDFRenderer(document);
      for (int i = 0; i < totalPages; i++) {
        BufferedImage bufferedImage = renderer.renderImageWithDPI(i, 144);
        // 分割图像以处理高度超过MAX_HEIGHT的情况
        List<byte[]> splitImages = toBytes(bufferedImage, suffix);
        documentBytes.addAll(splitImages);
      }
    }

    // 使用CompletionService来管理并发任务
    CompletionService<String> completionService = new ExecutorCompletionService<>(ExecutorServiceUtils.getExecutorService());
    List<Future<String>> futures = new ArrayList<>();
    for (byte[] imageBytes : documentBytes) {
      futures.add(completionService.submit(() -> convertPdfPageToMarkdown(apiKey, imageBytes, suffix)));
    }

    // 等待所有任务完成并按提交顺序存储结果
    List<String> markdowns = new ArrayList<>(Collections.nCopies(documentBytes.size(), null));
    for (int i = 0; i < futures.size(); i++) {
      Future<String> future = completionService.take();
      int pageIndex = futures.indexOf(future); // 获取任务对应的索引
      markdowns.set(pageIndex, future.get()); // 按索引顺序存储结果
    }

    // 组合所有Markdown内容
    StringBuilder combinedMarkdown = new StringBuilder();
    for (String markdown : markdowns) {
      combinedMarkdown.append(markdown);
    }

    // 保存Markdown到文件
    target = "markdowns/" + md5 + ".md";
    new File(target).getParentFile().mkdirs();
    FileUtil.writeString(combinedMarkdown.toString(), target, "UTF-8");
    log.info("Markdown saved to {}", target);

    // 更新或保存缓存记录
    if (exists) {
      Db.update(TableNames.max_kb_document_markdown_cache, Row.by("id", md5).set("target", target).set("content", combinedMarkdown));
      log.info("Cache updated for document MD5: {}", md5);
    } else {
      Db.save(TableNames.max_kb_document_markdown_cache, Row.by("id", md5).set("target", target).set("content", combinedMarkdown));
      log.info("Cache saved for new document MD5: {}", md5);
    }

    return combinedMarkdown.toString();
  }

  /**
   * 将 PDF 页面转换为 Markdown(多并发)
   *
   * @param apiKey OpenAI API 密钥
   * @param imageBytes 图片字节数组
   * @param suffix 文件后缀
   * @return Markdown 文本
   * @throws IOException 可能的IO异常
   */
  public String convertPdfPageToMarkdown(String apiKey, byte[] imageBytes, String suffix) throws IOException {
    String id = Md5Utils.digestHex(imageBytes);
    String sql = String.format("SELECT content FROM %s WHERE id=?", TableNames.max_kb_document_markdown_page_cache);

    // 查询缓存以避免重复处理
    String content = Db.queryStr(sql, id);
    if (content != null) {
      log.debug("Content found in page cache for ID: {}", id);
      return content;
    }

    // 保存图像文件
    String imageName = id + "." + suffix;
    String imagePath = "images/" + imageName;
    File imageFile = new File(imagePath);
    imageFile.getParentFile().mkdirs();
    FileUtil.writeBytes(imageBytes, imageFile);
    log.debug("Image saved to {}", imagePath);

    // 调用OpenAI API将图像转换为文本
    long start = System.currentTimeMillis();
    OpenAiChatResponseVo chatResponseVo = null;
    String imageToTextPrompt = Engine.use().getTemplate("image_to_text_prompt.txt").renderToString();
    try {
      chatResponseVo = OpenAiClient.chatWithImage(apiKey, imageToTextPrompt, imageBytes, suffix);
    } catch (Exception e) {
      try {
        chatResponseVo = OpenAiClient.chatWithImage(apiKey, imageToTextPrompt, imageBytes, suffix);
      } catch (Exception e1) {
        chatResponseVo = OpenAiClient.chatWithImage(apiKey, imageToTextPrompt, imageBytes, suffix);
      }
    }

    content = chatResponseVo.getChoices().get(0).getMessage().getContent();
    if (content.startsWith("```markdown")) {
      content = content.substring(11, content.length() - 3);
    }

    ChatResponseUsage usage = chatResponseVo.getUsage();
    TableInput saveInput = TableInput.by("id", id).set("target", imagePath).set("content", content).set("elapsed", System.currentTimeMillis() - start).set("model", OpenAiModels.GPT_4O)
        .set("system_fingerprint", chatResponseVo.getSystem_fingerprint()).set("completion_tokens", usage.getCompletion_tokens()).set("prompt_tokens", usage.getPrompt_tokens())
        .set("total_tokens", usage.getTotal_tokens());

    // 再次检查缓存以防止并发情况下的重复保存
    String cacheContent = Db.queryStr(sql, id);
    if (cacheContent != null) {
      log.debug("Content found in page cache during save for ID: {}", id);
      return cacheContent;
    }

    // 同步保存操作,避免多线程同时写入
    Lock lock = locks.get(id);
    lock.lock();
    try {
      // 再次检查以确保线程安全
      cacheContent = Db.queryStr(sql, id);
      if (cacheContent == null) {
        ApiTable.save(TableNames.max_kb_document_markdown_page_cache, saveInput);
        log.debug("Content cached for page ID: {}", id);
        return content;
      } else {
        return cacheContent;
      }
    } finally {
      lock.unlock();
    }
  }

  /**
   * 将 BufferedImage 转换为字节数组,如果图像高度超过MAX_HEIGHT,则进行垂直分割
   *
   * @param bufferedImage 图片对象
   * @param suffix 文件后缀
   * @return 字节数组列表
   * @throws IOException 可能的IO异常
   */
  private List<byte[]> toBytes(BufferedImage bufferedImage, String suffix) throws IOException {
    List<byte[]> imageBytesList = new ArrayList<>();
    if (bufferedImage.getHeight() <= MAX_HEIGHT) {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ImageIO.write(bufferedImage, suffix, baos);
      imageBytesList.add(baos.toByteArray());
    } else {
      int numParts = (int) Math.ceil((double) bufferedImage.getHeight() / MAX_HEIGHT);
      for (int i = 0; i < numParts; i++) {
        int y = i * MAX_HEIGHT;
        int height = Math.min(MAX_HEIGHT, bufferedImage.getHeight() - y);
        BufferedImage subImage = bufferedImage.getSubimage(0, y, bufferedImage.getWidth(), height);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(subImage, suffix, baos);
        imageBytesList.add(baos.toByteArray());
        log.debug("Image split into part {}/{}", i + 1, numParts);
      }
    }
    return imageBytesList;
  }
}
Edit this page
Last Updated:
Contributors: Tong Li
Prev
知识库管理
Next
片段向量