4.4.0版本发布

Merge pull request !312 from 高雄/N/A

.github/workflows/maven.yml

@@ -11,7 +11,7 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@v2
     - name: Set up JDK 8

Dockerfile

@@ -1,5 +1,4 @@
-FROM keking/kkfileview-jdk:latest
-MAINTAINER chenjh "842761733@qq.com"
+FROM keking/kkfileview-base:4.4.0
 ADD server/target/kkFileView-*.tar.gz /opt/
-ENV KKFILEVIEW_BIN_FOLDER /opt/kkFileView-4.4.0-SNAPSHOT/bin
-ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-Dspring.config.location=/opt/kkFileView-4.4.0-SNAPSHOT/config/application.properties","-jar","/opt/kkFileView-4.4.0-SNAPSHOT/bin/kkFileView-4.4.0-SNAPSHOT.jar"]
+ENV KKFILEVIEW_BIN_FOLDER=/opt/kkFileView-4.4.0/bin
+ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-Dspring.config.location=/opt/kkFileView-4.4.0/config/application.properties","-jar","/opt/kkFileView-4.4.0/bin/kkFileView-4.4.0.jar"]

README.cn.md

@@ -13,7 +13,7 @@
 11. 支持 epub 图书文档
 12. 支持 obj, 3ds, stl, ply, gltf, glb, off, 3dm, fbx, dae, wrl, 3mf, ifc, brep, step, iges, fcstd, bim 等 3D 模型文件
 13. 支持 dwg, dxf, dwf, iges , igs, dwt, dng, ifc, dwfx, stl, cf2, plt 等 CAD 模型文件
-14. 支持 txt, xml(渲染), md(渲染), java, php, py, js, css 等所有纯文本
+14. 支持 txt, xml(渲染), xbrl(渲染), md(渲染), java, php, py, js, css 等所有纯文本
 15. 支持 zip, rar, jar, tar, gzip, 7z 等压缩包
 16. 支持 jpg, jpeg, png, gif, bmp, ico, jfif, webp 等图片预览（翻转，缩放，镜像）
 17. 支持 tif, tiff 图信息模型文件
@@ -42,9 +42,7 @@
 地址：[https://file.kkview.cn](https://file.kkview.cn)
 
 ### 项目文档（Project documentation）
-1. 详细wiki文档：https://gitee.com/kekingcn/file-online-preview/wikis/pages
-1. 中文文档：https://gitee.com/kekingcn/file-online-preview/blob/master/README.md
-1. English document：https://gitee.com/kekingcn/file-online-preview/blob/master/README.en.md
+1. 详细使用文档：https://kkview.cn/zh-cn/docs/home.html
 
 ### 联系我们，加入组织
 > 我们会用心回答解决大家在项目使用中的问题，也请大家在提问前至少 Google 或 baidu 过，珍爱生命远离无效的交流沟通
@@ -53,7 +51,7 @@
 
 ### 文档预览效果
 #### 1. 文本预览
-支持所有类型的文本文档预览， 由于文本文档类型过多，无法全部枚举，默认开启的类型如下 txt,html,htm,asp,jsp,xml,json,properties,md,gitignore,log,java,py,c,cpp,sql,sh,bat,m,bas,prg,cmd  
+支持所有类型的文本文档预览， 由于文本文档类型过多，无法全部枚举，默认开启的类型如下 txt,html,htm,asp,jsp,xml,xbrl,json,properties,md,gitignore,log,java,py,c,cpp,sql,sh,bat,m,bas,prg,cmd  
 文本预览效果如下  
 ![文本预览效果如下](https://kkview.cn/img/preview/preview-text.png)      
 
@@ -110,12 +108,33 @@ pdf预览模式预览效果如下
 ![cad文档预览2](https://kkview.cn/img/preview/preview-cad-pdf.png)  
 考虑说明篇幅原因，就不贴其他格式文件的预览效果了，感兴趣的可以参考下面的实例搭建下
 
+#### 10. Excel文件纯前端渲染效果
+
+![Excel文件纯前端渲染效果](https://kkview.cn/img/preview/preview-xlsx-web.png)  
+
+#### 11. 流程图bpmn文件预览效果
+
+![流程图bpmn文件预览效果](https://kkview.cn/img/preview/preview-bpmn.png)  
+
+#### 12. 3D模型文件预览效果：
+
+![3D模型文件预览效果](https://kkview.cn/img/preview/preview-3ds.png)  
+
+#### 13. dcm医疗数位影像文件预览效果：
+
+![dcm医疗数位影像文件预览效果](https://kkview.cn/img/preview/preview-dcm.png) 
+
+#### 14. drawio流程图预览效果：
+
+![dcdrawio流程图预览效果](https://kkview.cn/img/preview/preview-drawio.png) 
+
 ### 快速开始
 > 项目使用技术
 - spring boot： [spring boot开发参考指南](http://www.kailing.pub/PdfReader/web/viewer.html?file=springboot)
 - freemarker
 - redisson 
 - jodconverter
+
 > 依赖外部环境
 - redis (可选，默认不用)
 - OpenOffice 或者 LibreOffice( Windows 下已内置，Linux 脚本启动模式会自动安装，Mac OS 下需要手动安装)
@@ -129,7 +148,82 @@ pdf预览模式预览效果如下
 
 ### 历史更新记录
 
-> 2022年12月14日，v4.1.0 版本发布 ：
+#### > 2023年07月05日，v4.3 版本发布 ：
+
+#### 新增功能:
+1. 新增dcm等医疗数位影像预 
+2. 新增drawio绘图预览
+3. 新增开启缓存的情况下重新生成的命令 &forceUpdatedCache=true
+4. 新增dwg CAD文件预览
+5. 新增PDF文件支持密码功能
+6. 新增PDF文件生成图片的dpi自定义配置
+7. 新增删除转换后OFFICE、CAD、TIFF、压缩包源文件配置 默认开启 节约磁盘空间
+8. 新增前端解析xlsx方法
+9. 新增pages,eps, iges , igs, dwt, dng, ifc, dwfx, stl, cf2, plt等格式支持 
+
+#### 优化:
+1. 调整生成的PDF文件 文件名称添加文件后缀 防止生成同名文件
+2. 调整SQL文件预览方式
+3. 优化OFD预览兼容性
+4. 美化TXT文本 分页框的显示
+5. 升级Linux、Docker版内置office为LibreOffice-7.5.3版本
+6. 升级Windows版内置office为LibreOffice-7.5.3 Portable版本
+7. 其他功能优化
+
+#### 修复:
+1. 修复反代情况下压缩包获取路径错误
+2. 修复预览图片的url中如果包含&会导致.click报错
+3. 修复OFD预览部分已知问题
+4. 修复预览压缩包时，如果点击的是文件目录（树节点），页面会报错
+5. 其他已知问题修复
+
+#### > 2023年04月18日，v4.2.1 版本发布 ：
+
+#### 更新日志:
+
+1. 修复 dwg 文件预览报空指针的 bug  
+
+#### > 2023年04月13日，v4.2.0 版本发布 ：
+
+#### 新增功能:
+1. 新增 SVG 格式文件预览支持
+2. 新增加密的 Office 文件预览支持
+3. 新增加密的 zip、rar 等压缩包文件预览支持
+4. 新增 xmind 软件模型文件预览支持
+5. 新增 bpmn 工作流模型文件预览支持
+6. 新增 eml 邮件文件预览支持
+7. 新增 epub 电子书文件预览支持
+8. 新增 dotm,ett,xlt,xltm,wpt,dot,xlam,xla,dotx 等格式的办公文档预览支持
+9. 新增 obj, 3ds, stl, ply, gltf, glb, off, 3dm, fbx, dae, wrl, 3mf, ifc, brep, step, iges, fcstd, bim 等 3D 模型文件预览支持
+10. 新增可配置限制高风险文件上传的功能，比如 exe 文件
+11. 新增可配置站点的备案信息
+12. 新增演示站点删除文件需要密码的功能  
+
+#### 优化:
+1. 文本文档预览加入缓存
+2. 美化 404、500 报错页
+3. 优化发票等 ofd 文件预览的印证渲染兼容性
+4. 移除 office-plugin 模块, 使用新版 jodconverter组件
+5. 优化 Excel 文件的预览效果
+6. 优化 CAD 文件的预览效果
+7. 更新 xstream 、junrar、pdfbox 等依赖的版本
+8. 更新 TIF 文件转换 PDF 的插件，添加转换缓存
+9. 优化演示页 UI 部署
+10. 压缩包文件预览支持目录
+
+#### 修复:
+1. 修复部分接口 XSS 问题
+2. 修复控制台打印的演示地址不跟着 content-path 配置走的问题
+3. 修复 ofd 文件预览跨域问题
+4. 修复内部自签证书 https 协议 url 文件无法下载的问题
+5. 修复特殊符号的文件无法删除的问题
+6. 修复 PDF 转图片,内存无法回收导致的 OOM
+7. 修复 xlsx7.4 以上版本文件预览乱码的问题
+8. 修复 TrustHostFilter 未拦截跨域接口的问题，这是一个安全问题，有使用到 TrustHost 功能的务必升级
+9. 修复压缩包文件预览在 Linux 系统下文件名乱码的问题
+10. 修复 ofd 文件预览页码只能显示10页的问题
+
+#### > 2022年12月14日，v4.1.0 版本发布 ：
 
 1. 全新首页视觉 @wsd7747 
 2. tif图片预览兼容多页tif的pdf转换、jpg转换，以及jpg在线多页预览功能 @zhangzhen1979
@@ -142,7 +236,7 @@ pdf预览模式预览效果如下
 
 感谢 @yl-yue @wsd7747 @zhangzhen1979 @tomhusky @shenghuadun @kischn.sun 的代码贡献
 
-> 2021年7月6日，v4.0.0 版本发布 ：
+#### > 2021年7月6日，v4.0.0 版本发布 ：
 
 1. 底层集成OpenOffice替换为LibreOffice，Office文件兼容性增强，预览效果提升
 2. 修复压缩文件目录穿越漏洞
@@ -153,7 +247,7 @@ pdf预览模式预览效果如下
 7. 优化Windows环境下，查找Office组件逻辑(内置的LibreOffice优先)
 8. 优化启动Office进程改同步执行
 
-> 2021年6月17日，v3.6.0 版本发布 ：
+#### > 2021年6月17日，v3.6.0 版本发布 ：
 
 ofd 类型文件支持版本，本次版本重要功能均由社区开发贡献，感谢 @gaoxingzaq、@zhangxiaoxiao9527 的代码贡献
 1. 新增 ofd 类型文件预览支持，ofd 是国产的类似 pdf 格式的文件
@@ -161,7 +255,7 @@ ofd 类型文件支持版本，本次版本重要功能均由社区开发贡献
 3. 美化了 ppt、pptx 类型文件预览效果，比之前版本好看太多
 4. 更新了 pdfbox、xstream、common-io 等依赖的版本
 
-> 2021年1月28日 ：
+#### > 2021年1月28日 ：
 
 2020农历年最后一个版本发布，主要包含了部分 UI 改进，和解决了 QQ 群友、 Issue 里反馈的 Bug 修复，最最重要的是发个新版，过个好年
 
@@ -184,7 +278,7 @@ ofd 类型文件支持版本，本次版本重要功能均由社区开发贡献
 17. escaping of dangerous characters to prevent reflected xss
 18. 修复重复编码导致文档转图片预览失败的问题&编码规范
 
-> 2020年12月27日 ：
+#### > 2020年12月27日 ：
 
 2020年年终大版本更新，架构全面设计，代码全面重构，代码质量全面提升，二次开发更便捷，欢迎拉源码品鉴，提issue、pr共同建设
 
@@ -204,7 +298,7 @@ ofd 类型文件支持版本，本次版本重要功能均由社区开发贡献
 14. 修复压缩包里文件再次预览失败的bug
 15. 修复图片预览的bug
 
-> 2020年05月20日 ：
+#### > 2020年05月20日 ：
 1. 新增支持全局水印，并支持通过参数动态改变水印内容
 2. 新增支持CAD文件预览
 3. 新增base.url配置，支持使用nginx反向代理和使用context-path
@@ -222,35 +316,35 @@ ofd 类型文件支持版本，本次版本重要功能均由社区开发贡献
 15. 官网建设：[https://kkview.cn](https://kkview.cn/)
 16. 官方Docker镜像仓库建设：[https://hub.docker.com/r/keking/kkfileview](https://hub.docker.com/r/keking/kkfileview)
 
-> 2019年06月18日 ：
+#### > 2019年06月18日 ：
 1. 支持自动清理缓存及预览文件
 2. 支持http/https下载流url文件预览
 3. 支持FTP url文件预览
 4. 加入Docker构建
 
-> 2019年04月08日 ：
+#### > 2019年04月08日 ：
 1. 缓存及队列实现抽象，提供JDK和REDIS两种实现(REDIS成为可选依赖)
 2. 打包方式提供zip和tar.gz包，并提供一键启动脚本
 
-> 2018年01月19日 ：
+#### > 2018年01月19日 ：
 
 1. 大文件入队提前处理
 1. 新增addTask文件转换入队接口 
 1. 采用redis队列，支持kkFIleView接口和异构系统入队两种方式
 
-> 2018年01月17日 ：
+#### > 2018年01月17日 ：
 
 1. 优化项目结构，抽象文件预览接口，更方便的加入更多的文件类型预览支持，方便二次开发
 1. 新增英文文档说明（@幻幻Fate，@汝辉）贡献
 1. 新增图片预览文件支持类型
 1. 修复压缩包内轮播图片总是从第一张开始的问题
 
-> 2018年01月12日 ：
+#### > 2018年01月12日 ：
 
 1. 新增多图片同时预览 
 1. 支持压缩包内图片轮番预览
 
-> 2018年01月02日 ： 
+#### > 2018年01月02日 ： 
 
 1. 修复txt等文本编码问题导致预览乱码 
 1. 修复项目模块依赖引入不到的问题 
@@ -265,14 +359,15 @@ xmind  引用于 [ xmind-embed-viewer](https://github.com/xmindltd/xmind-embed-v
 epub   引用于 [ epub.js](https://github.com/futurepress/epub.js) 开源协议 BSD许可证  
 压缩包 引用于 [sevenzipjbinding](https://github.com/borisbrodski/sevenzipjbinding )开源协议LGPL  
 3D     引用于 [Online3DViewer](https://github.com/kovacsv/Online3DViewer )开源协议MIT  
+drawio 引用于 [drawio](https://github.com/jgraph/drawio )开源协议 Apache-2.0  
+bpmn流程图     引用于 [bpmn-js](https://github.com/bpmn-io/bpmn-js ) 自定义协议 保留水印 具体自行查看  
+dcm医疗数位影像  引用于 [dcmjs](https://github.com/dcmjs-org/dcmjs )开源协议MIT  
 
 ### 使用登记
 如果这个项目解决了你的实际问题，可在 https://gitee.com/kekingcn/file-online-preview/issues/IGSBV
 登记下，如果节省了你的三方预览服务费用，也愿意支持下的话，可点击下方【捐助】请作者喝杯咖啡，也是非常感谢
 
-### Stars 趋势图
-#### Gitee
-[![Stargazers over time](https://whnb.wang/img/kekingcn/file-online-preview)](https://whnb.wang/kekingcn/file-online-preview?e=86400)
+### Stars
 
 #### GitHub
 

docker/kkfileview-base/Dockerfile

@@ -0,0 +1,28 @@
+FROM ubuntu:24.04
+
+RUN sed -i 's@//.*archive.ubuntu.com@//mirrors.aliyun.com@g' /etc/apt/sources.list.d/ubuntu.sources &&\
+    sed -i 's@//security.ubuntu.com@//mirrors.aliyun.com@g' /etc/apt/sources.list.d/ubuntu.sources &&\
+    sed -i 's@//ports.ubuntu.com@//mirrors.aliyun.com@g' /etc/apt/sources.list.d/ubuntu.sources &&\
+	apt-get update &&\
+    export DEBIAN_FRONTEND=noninteractive &&\
+	apt-get install -y --no-install-recommends openjdk-8-jre tzdata locales xfonts-utils fontconfig libreoffice-nogui &&\
+    echo 'Asia/Shanghai' > /etc/timezone &&\
+    ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime &&\
+    localedef -i zh_CN -c -f UTF-8 -A /usr/share/locale/locale.alias zh_CN.UTF-8 &&\
+    locale-gen zh_CN.UTF-8 &&\
+    apt-get install -y --no-install-recommends ttf-mscorefonts-installer &&\
+    apt-get install -y --no-install-recommends ttf-wqy-microhei ttf-wqy-zenhei xfonts-wqy &&\
+	apt-get autoremove -y &&\
+    apt-get clean &&\
+    rm -rf /var/lib/apt/lists/*
+
+# 内置一些常用的中文字体，避免普遍性乱码
+ADD fonts/* /usr/share/fonts/chinese/
+
+RUN cd /usr/share/fonts/chinese &&\
+    # 安装字体
+    mkfontscale &&\
+    mkfontdir &&\
+    fc-cache -fv
+
+ENV LANG=zh_CN.UTF-8 LC_ALL=zh_CN.UTF-8

docker/kkfileview-base/README.cn.md

@@ -0,0 +1,50 @@
+# 构建说明
+
+由于 kkfileview 的基础运行环境很少变动且制作耗时较久，而 kkfileview 本身代码开发会频繁改动，因此把制作其 Docker 镜像的步骤拆分为两次：
+
+首先制作 kkfileview 的基础镜像（kkfileview-base）。
+
+然后使用 kkfileview-base 作为基础镜像进行构建，加快 kkfileview docker 镜像构建与发布。
+
+执行如下命令即可构建基础镜像：
+> 这里镜像 tag 以 4.4.0 为例，本项目所维护的 Dockerfile 文件考虑了跨平台兼容性。 如果你需要用到 arm64 架构镜像, 则在arm64 架构机器上同样执行下面的构建命令即可
+
+```shell
+docker build --tag keking/kkfileview-base:4.4.0 .
+```
+
+
+
+## 跨平台构建
+
+`docker buildx` 支持在一台机器上构建出多种平台架构的镜像。推荐使用该能力进行跨平台的镜像构建。
+例如，执行 `docker buildx build` 命令时加上 `--platform=linux/arm64` 参数即可构建出 arm64 架构镜像。这极大方便了那些没有arm64 架构机器却想构建 arm64 架构镜像的用户。
+
+> 当前本项目仅支持构建 linux/amd64 和 linux/arm64 两种平台架构的镜像
+> buildx 的 builder driver 可以使用默认的 `docker` 类型, 若使用 `docker-container` 类型可以支持并行构建多种架构, 本文不再赘述, 有兴趣可以自行了解。参考 [Docker Buildx | Docker Documentation](https://docs.docker.com/buildx/working-with-buildx/#build-multi-platform-images)
+
+**前提要求**
+
+以当前机器为 amd64 (x86_64)架构为例。需要开启 docker 的 buildx 特性，以及开启 Linux 的 QEMU 用户模式：
+
+> 使用 WSL2 的 Windows 用户如果安装了最新的 DockerDesktop, 则这些前提要求已满足, 无需额外下述设置。 
+
+1. 安装 docker buildx 客户端插件：
+   > docker 版本要求 >=19.03
+   
+   若已安装, 则跳过。详情参考 https://github.com/docker/buildx
+
+2. 开启 QEMU 的用户模式功能, 并安装其它平台的模拟器:
+   > Linux 内核要求 >=4.8
+
+   使用 `tonistiigi/binfmt` 镜像可快速开启并安装模拟器，执行下面命令:
+
+   ```shell
+   docker run --privileged --rm tonistiigi/binfmt --install all
+   ```
+
+现在就可以愉快地开始构建了，构建命令示例:
+
+```shell
+docker buildx build --platform=linux/amd64,linux/arm64 -t keking/kkfileview-base:4.4.0 --push .
+```

docker/kkfileview-base/README.md

@@ -0,0 +1,53 @@
+# Build Instructions
+
+Since the base runtime environment for kkfileview rarely changes and takes a long time to build, while the kkfileview code itself is frequently updated, the process of building its Docker image is split into two steps:
+
+First, create the base image for kkfileview (kkfileview-base).
+
+Then, use kkfileview-base as the base image to build and speed up the kkfileview Docker image build and release process.
+
+To build the base image, run the following command:
+
+> In this example, the image tag is 4.4.0. The Dockerfile maintained in this project considers cross-platform compatibility. If you need an arm64 architecture image, run the same build command on an arm64 architecture machine.
+
+```shell
+docker build --tag keking/kkfileview-base:4.4.0 .
+```
+
+
+
+## Cross-Platform Build
+
+`docker buildx` supports building images for multiple platform architectures on a single machine. It is recommended to use this capability for cross-platform image builds.
+For example, adding the `--platform=linux/arm64` parameter when executing the `docker buildx build` command will allow you to build an arm64 architecture image. This is particularly convenient for users who want to build arm64 images but don't have an arm64 machine.
+
+> Currently, this project only supports building images for the linux/amd64 and linux/arm64 architectures.
+> The buildx builder driver can use the default `docker` type, but if you use the `docker-container` type, you can build multiple architectures in parallel. This README will not cover that in detail, you can learn more on your own. Refer to [Docker Buildx | Docker Documentation](https://docs.docker.com/buildx/working-with-buildx/#build-multi-platform-images)
+
+**Prerequisites**
+
+Assuming the current machine is amd64 (x86_64) architecture, you'll need to enable the docker buildx feature and enable Linux QEMU user mode:
+
+> Windows users with WSL2 who have installed a recent version of Docker Desktop will already meet these prerequisites, so no additional setup is required.
+
+1. Install the docker buildx client plugin:
+
+   > Docker version >=19.03 is required.
+
+   If it's already installed, you can skip this step. For more details, refer to https://github.com/docker/buildx.
+
+2. Enable QEMU user mode and install emulators for other platforms:
+
+   > Linux kernel version >=4.8 is required.
+
+   You can quickly enable and install emulators using the tonistiigi/binfmt image by running the following command:
+
+   ```shell
+   docker run --privileged --rm tonistiigi/binfmt --install all
+   ```
+
+Now you can enjoy the building. Here’s an example build command:
+
+```shell
+docker buildx build --platform=linux/amd64,linux/arm64 -t keking/kkfileview-base:4.4.0 --push .
+```

docker/kkfileview-jdk/Dockerfile

@@ -1,38 +0,0 @@
-FROM ubuntu:20.04
-MAINTAINER chenjh "842761733@qq.com"
-# 内置一些常用的中文字体，避免普遍性乱码
-COPY fonts/* /usr/share/fonts/chinese/
-RUN apt-get clean && apt-get update &&\
-	sed -i 's/http:\/\/archive.ubuntu.com/https:\/\/mirrors.aliyun.com/g' /etc/apt/sources.list &&\
-	sed -i 's/# deb/deb/g' /etc/apt/sources.list &&\
-	apt-get install -y --reinstall ca-certificates &&\
-	apt-get clean && apt-get update &&\
-	apt-get install -y locales language-pack-zh-hans &&\
-	localedef -i zh_CN -c -f UTF-8 -A /usr/share/locale/locale.alias zh_CN.UTF-8 && locale-gen zh_CN.UTF-8 &&\
-    export DEBIAN_FRONTEND=noninteractive &&\
-	apt-get install -y tzdata && ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime &&\
-	apt-get install -y fontconfig ttf-mscorefonts-installer ttf-wqy-microhei ttf-wqy-zenhei xfonts-wqy &&\
-	apt-get install -y wget &&\
-    cd /tmp &&\
-	wget https://kkview.cn/resource/server-jre-8u251-linux-x64.tar.gz &&\
-	tar -zxf /tmp/server-jre-8u251-linux-x64.tar.gz && mv /tmp/jdk1.8.0_251 /usr/local/ &&\
-
-# 安装 libreoffice
-    apt-get install -y libxrender1 libxinerama1 libxt6 libxext-dev libfreetype6-dev libcairo2 libcups2 libx11-xcb1 libnss3 &&\
-    wget https://downloadarchive.documentfoundation.org/libreoffice/old/7.5.3.2/deb/x86_64/LibreOffice_7.5.3.2_Linux_x86-64_deb.tar.gz -cO libreoffice_deb.tar.gz &&\
-    tar -zxf /tmp/libreoffice_deb.tar.gz && cd /tmp/LibreOffice_7.5.3.2_Linux_x86-64_deb/DEBS &&\
-    dpkg -i *.deb &&\
-
-#  清理临时文件
-	rm -rf /tmp/* && rm -rf /var/lib/apt/lists/* &&\
-    cd /usr/share/fonts/chinese &&\
-    mkfontscale &&\
-    mkfontdir &&\
-    fc-cache -fv
-
-ENV JAVA_HOME /usr/local/jdk1.8.0_251
-ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
-ENV PATH $PATH:$JAVA_HOME/bin
-ENV LANG zh_CN.UTF-8
-ENV LC_ALL zh_CN.UTF-8
-CMD ["/bin/bash"]

docker/kkfileview-jdk/docker build.txt

@@ -1,2 +0,0 @@
-# 执行如下命令构建基础镜像，加快kkfileview docker镜像构建与发布
-docker build --tag keking/kkfileview-jdk:4.3.0 .

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>cn.keking</groupId>
     <artifactId>kkFileView-parent</artifactId>
-    <version>4.4.0-SNAPSHOT</version>
+    <version>4.4.0</version>
 
     <properties>
         <java.version>1.8</java.version>
@@ -15,14 +15,14 @@
         <poi.version>5.2.2</poi.version>
         <xdocreport.version>1.0.6</xdocreport.version>
         <xstream.version>1.4.20</xstream.version>
-        <junrar.version>7.5.4</junrar.version>
+        <junrar.version>7.5.5</junrar.version>
         <redisson.version>3.2.0</redisson.version>
         <sevenzipjbinding.version>16.02-2.01</sevenzipjbinding.version>
         <jchardet.version>1.0</jchardet.version>
         <antlr.version>2.7.7</antlr.version>
         <concurrentlinkedhashmap.version>1.4.2</concurrentlinkedhashmap.version>
         <rocksdb.version>5.17.2</rocksdb.version>
-        <pdfbox.version>2.0.27</pdfbox.version>
+        <pdfbox.version>3.0.2</pdfbox.version>
         <jai-imageio.version>1.4.0</jai-imageio.version>
         <jbig2-imageio.version>3.0.4</jbig2-imageio.version>
         <galimatias.version>0.2.1</galimatias.version>
@@ -32,12 +32,14 @@
         <ffmpeg.version>4.2.1-1.5.2</ffmpeg.version>
         <itextpdf.version>5.5.13.3</itextpdf.version>
         <httpclient.version>3.1</httpclient.version>
-        <aspose-cad.version>23.1</aspose-cad.version>
+        <aspose-cad.version>23.9</aspose-cad.version>
         <bcprov-jdk15on.version>1.70</bcprov-jdk15on.version>
+        <juniversalchardet.version>1.0.3</juniversalchardet.version>
+        <httpcomponents.version>4.5.14</httpcomponents.version>
 
-        <commons-cli.version>1.2</commons-cli.version>
-        <commons-net.version>3.6</commons-net.version>
-        <commons-lang3.version>3.7</commons-lang3.version>
+        <commons-cli.version>1.5.0</commons-cli.version>
+        <commons-net.version>3.9.0</commons-net.version>
+        <commons-lang3.version>3.13.0</commons-lang3.version>
 
 
         <maven.compiler.source>${java.version}</maven.compiler.source>

server/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>kkFileView-parent</artifactId>
         <groupId>cn.keking</groupId>
-        <version>4.4.0-SNAPSHOT</version>
+        <version>4.4.0</version>
     </parent>
 
     <artifactId>kkFileView</artifactId>
@@ -99,6 +99,11 @@
             <version>${xdocreport.version}</version>
         </dependency>
         <!-- poi start -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+             <version>${httpcomponents.version}</version>
+        </dependency>
 
         <!-- 对 rar5 的支持 和其他众多压缩支持 可参考 package net.sf.sevenzipjbinding.ArchiveFormat; -->
         <dependency>
@@ -122,6 +127,14 @@
             <artifactId>redisson</artifactId>
             <version>${redisson.version}</version>
         </dependency>
+
+        <!-- 编码检测-JUniversalCharDet-->
+        <dependency>
+            <groupId>com.googlecode.juniversalchardet</groupId>
+            <artifactId>juniversalchardet</artifactId>
+            <version>${juniversalchardet.version}</version>
+        </dependency>
+
         <!-- 解压(rar)-->
         <dependency>
             <groupId>com.github.junrar</groupId>

server/src/main/assembly/dist-linux.xml

@@ -3,7 +3,7 @@
         xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/2.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
-    <id>make-assembly</id>
+    <id>assembly-linux</id>
     <formats>
         <format>tar.gz</format>
     </formats>

server/src/main/assembly/dist-win32.xml

@@ -3,7 +3,7 @@
         xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/2.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
-    <id>make-assembly</id>
+    <id>assembly-windows</id>
     <formats>
         <format>zip</format>
     </formats>

server/src/main/bin/install.sh

@@ -8,7 +8,7 @@ install_redhat() {
      yum install -y libSM.x86_64 libXrender.x86_64  libXext.x86_64
      yum groupinstall -y  "X Window System"
      yum localinstall -y *.rpm
-     echo 'install finshed...'
+     echo 'install finished...'
    else
      echo 'download package error...'
    fi
@@ -20,7 +20,7 @@ install_ubuntu() {
  if [ $? -eq 0 ];then
      apt-get install -y libxinerama1 libcairo2 libcups2 libx11-xcb1
      dpkg -i *.deb
-     echo 'install finshed...'
+     echo 'install finished...'
   else
     echo 'download package error...'
  fi

server/src/main/bin/startup.bat

@@ -7,4 +7,4 @@ echo Please check log file in ../log/kkFileView.log for more information
 echo You can get help in our official home site: https://kkview.cn
 echo If you need further help, please join our kk opensource community: https://t.zsxq.com/09ZHSXbsQ
 echo If this project is helpful to you, please star it on https://gitee.com/kekingcn/file-online-preview/stargazers
-java -Dspring.config.location=..\config\application.properties -jar kkFileView-4.4.0-SNAPSHOT.jar -> ..\log\kkFileView.log
+java -Dspring.config.location=..\config\application.properties -jar kkFileView-4.4.0.jar -> ..\log\kkFileView.log

server/src/main/bin/startup.sh

@@ -9,7 +9,7 @@
 # Description:  v1.1：修改进程启动机制为pid形式。
 #############################
 #
-DIR_HOME=("/opt/openoffice.org3" "/opt/libreoffice" "/opt/libreoffice6.1" "/opt/libreoffice7.0" "/opt/libreoffice7.1" "/opt/libreoffice7.2" "/opt/libreoffice7.3" "/opt/libreoffice7.4" "/opt/openoffice4" "/usr/lib/openoffice" "/usr/lib/libreoffice")
+DIR_HOME=("/opt/openoffice.org3" "/opt/libreoffice" "/opt/libreoffice6.1" "/opt/libreoffice7.0" "/opt/libreoffice7.1" "/opt/libreoffice7.2" "/opt/libreoffice7.3" "/opt/libreoffice7.4" "/opt/libreoffice7.5" "/opt/libreoffice7.6" "/opt/libreoffice24.2" "/opt/libreoffice24.8" "/opt/libreoffice25.2" "/opt/openoffice4" "/usr/lib/openoffice" "/usr/lib/libreoffice")
 FLAG=
 OFFICE_HOME=
 KKFILEVIEW_BIN_FOLDER=$(cd "$(dirname "$0")" || exit 1 ;pwd)
@@ -29,7 +29,7 @@ if [ -s "${PID_FILE}" ]; then
 else
   cd "$KKFILEVIEW_BIN_FOLDER" || exit 1
   echo "Using KKFILEVIEW_BIN_FOLDER $KKFILEVIEW_BIN_FOLDER"
-  grep 'office\.home' ../config/application.properties | grep '!^#'
+  grep 'office\.home' ../config/application.properties | grep -v '^#' | grep -v 'default'
   if [ $? -eq 0 ]; then
     echo "Using customized office.home"
   else
@@ -51,12 +51,12 @@ else
 
   ## 启动kkFileView
   echo "Starting kkFileView..."
-  nohup java -Dfile.encoding=UTF-8 -Dspring.config.location=../config/application.properties -jar kkFileView-4.4.0-SNAPSHOT.jar > ../log/kkFileView.log 2>&1 &
+  nohup java -Dfile.encoding=UTF-8 -Dspring.config.location=../config/application.properties -jar kkFileView-4.4.0.jar > ../log/kkFileView.log 2>&1 &
   echo "Please execute ./showlog.sh to check log for more information"
   echo "You can get help in our official home site: https://kkview.cn"
   echo "If you need further help, please join our kk opensource community: https://t.zsxq.com/09ZHSXbsQ"
   echo "If this project is helpful to you, please star it on https://gitee.com/kekingcn/file-online-preview/stargazers"
-  PROCESS=$(ps -ef | grep kkFileView | awk 'NR==1{print $2}')
+  PROCESS=$(ps -ef | grep -v grep | grep java | grep kkFileView | awk 'NR==1{print $2}')
   # 启动成功后将进程号写入pid文件
   echo "$PROCESS" > "$PID_FILE"
 fi

server/src/main/config/application.properties

@@ -2,7 +2,13 @@
 server.port = ${KK_SERVER_PORT:8012}
 server.servlet.context-path= ${KK_CONTEXT_PATH:/}
 server.servlet.encoding.charset = utf-8
-#文件上传限制前端
+#启用GZIP压缩功能
+server.compression.enabled = true
+#允许压缩的响应缓冲区最小字节数，默认2048
+server.compression.min-response-size = 2048
+#压缩格式
+server.compression.mime-types=application/javascript,text/css,application/json,application/xml,text/html,text/xml,text/plain,font/woff,application/font-woff,font/eot,image/svg+xml,image/x-icon
+# 文件上传限制前端
 spring.servlet.multipart.max-file-size=500MB
 #文件上传限制
 spring.servlet.multipart.max-request-size=500MB
@@ -17,28 +23,48 @@ spring.freemarker.expose-session-attributes = true
 spring.freemarker.request-context-attribute = request
 spring.freemarker.suffix = .ftl
 
-# office-plugin
-## office转换服务的进程数，默认开启两个进程
+# office设置
+#openoffice或LibreOffice  home路径
+#office.home = C:\\Program Files (x86)\\OpenOffice 4
+office.home = ${KK_OFFICE_HOME:default}
+## office转换服务的端口，默认开启两个进程
 office.plugin.server.ports = 2001,2002
 ## office 转换服务 task 超时时间，默认五分钟
 office.plugin.task.timeout = 5m
+#此属性设置office进程在重新启动之前可以执行的最大任务数。0表示无限数量的任务（永远不会重新启动）
+office.plugin.task.maxtasksperprocess = 200
+#此属性设置处理任务所允许的最长时间。如果任务的处理时间长于此超时，则此任务将中止，并处理下一个任务。
+office.plugin.task.taskexecutiontimeout = 5m
+#生成限制 默认不限制 使用方法 (1-5)
+office.pagerange = ${KK_OFFICE_PAGERANGE:false}
+#生成水印 默认不启用 使用方法 (kkFileView)
+office.watermark  = ${KK_OFFICE_WATERMARK:false}
+#OFFICE JPEG图片压缩
+office.quality = ${KK_OFFICE_QUALITY:80}
+#图像分辨率限制
+office.maximageresolution = ${KK_OFFICE_MAXIMAGERESOLUTION:150}
+#导出书签
+office.exportbookmarks = ${KK_OFFICE_EXPORTBOOKMARKS:true}
+#批注作为PDF的注释
+office.exportnotes = ${KK_OFFICE_EXPORTNOTES:true}
+#加密文档 生成的PDF文档 添加密码(密码为加密文档的密码)
+office.documentopenpasswords = ${KK_OFFICE_DOCUMENTOPENPASSWORD:true}
+#xlsx格式前端解析
+office.type.web = ${KK_OFFICE_TYPE_WEB:web}
 
+
+# 其他核心设置
 #预览生成资源路径（默认为打包根路径下的file目录下）
 #file.dir = D:\\kkFileview\\
 file.dir = ${KK_FILE_DIR:default}
-
 #允许预览的本地文件夹 默认不允许任何本地文件被预览
 #WINDOWS参考 local.preview.dir =  \D:\\kkFileview\\1\\1.txt (注意前面必须添加反斜杠)
 #LINUX参考   local.preview.dir =  /opt/1.txt (注意前面必须是正斜杠)
 #使用方法 windows  file://d:/1/1.txt  linux file:/opt/1/1.txt
 #file 协议参考：https://datatracker.ietf.org/doc/html/rfc8089
 local.preview.dir = ${KK_LOCAL_PREVIEW_DIR:default}
-
-
-#openoffice home路径
-#office.home = C:\\Program Files (x86)\\OpenOffice 4
-office.home = ${KK_OFFICE_HOME:default}
-
+#是否启用缓存
+cache.enabled = ${KK_CACHE_ENABLED:true}
 #缓存实现类型，不配默认为内嵌RocksDB(type = default)实现，可配置为redis(type = redis)实现（需要配置spring.redisson.address等参数）和 JDK 内置对象实现（type = jdk）,
 cache.type =  ${KK_CACHE_TYPE:jdk}
 #redis连接，只有当cache.type = redis时才有用
@@ -48,33 +74,50 @@ spring.redisson.password = ${KK_SPRING_REDISSON_PASSWORD:}
 cache.clean.enabled = ${KK_CACHE_CLEAN_ENABLED:true}
 #缓存自动清理时间，cache.clean.enabled = true时才有用，cron表达式，基于Quartz cron
 cache.clean.cron = ${KK_CACHE_CLEAN_CRON:0 0 3 * * ?}
-
 #######################################可在运行时动态配置#######################################
 #提供预览服务的地址，默认从请求url读，如果使用nginx等反向代理，需要手动设置
 #base.url = https://file.keking.cn
 base.url = ${KK_BASE_URL:default}
-
 #信任站点，多个用','隔开，设置了之后，会限制只能预览来自信任站点列表的文件，默认不限制
 #trust.host = kkview.cn
 trust.host = ${KK_TRUST_HOST:default}
-
-#是否启用缓存
-cache.enabled = ${KK_CACHE_ENABLED:true}
-
+#不信任站点，多个用','隔开，设置了之后，会限制来自不信任站点列表的文件，默认不限制
+#not.trust.host = kkview.cn
+not.trust.host= ${KK_NOT_TRUST_HOST:default}
 #文本类型，默认如下，可自定义添加
 simText = ${KK_SIMTEXT:txt,html,htm,asp,jsp,xml,json,properties,md,gitignore,log,java,py,c,cpp,sql,sh,bat,m,bas,prg,cmd}
+
+
+#FTP模块设置
+#预览源为FTP时 FTP用户名，可在ftp url后面加参数ftp.username=ftpuser指定，不指定默认用配置的
+ftp.username = ${KK_FTP_USERNAME:ftpuser}
+#预览源为FTP时 FTP密码，可在ftp url后面加参数ftp.password=123456指定，不指定默认用配置的
+ftp.password = ${KK_FTP_PASSWORD:123456}
+#预览源为FTP时, FTP连接默认ControlEncoding(根据FTP服务器操作系统选择，Linux一般为UTF-8，Windows一般为GBK)，可在ftp url后面加参数ftp.control.encoding=UTF-8指定，不指定默认用配置的
+ftp.control.encoding = ${KK_FTP_CONTROL_ENCODING:UTF-8}
+
+#视频设置
 #多媒体类型，默认如下，可自定义添加
-media = ${KK_MEDIA:mp3,wav,mp4,flv}
+media = ${KK_MEDIA:mp3,wav,mp4,flv,mpd,m3u8,ts,mpeg,m4a}
 #是否开启多媒体类型转视频格式转换,目前可转换视频格式有：avi,mov,wmv,3gp,rm
 #请谨慎开启此功能，建议异步调用添加到处理队列，并且增加任务队列处理线程，防止视频转换占用完线程资源，转换比较耗费时间,并且控制了只能串行处理转换任务
 media.convert.disable = ${KK_MEDIA_CONVERT_DISABLE:false}
 #支持转换的视频类型
 convertMedias = ${KK_CONVERTMEDIAS:avi,mov,wmv,mkv,3gp,rm}
-#office类型文档(word ppt)样式，默认为图片(image)，可配置为pdf（预览时也有按钮切换）
-office.preview.type = ${KK_OFFICE_PREVIEW_TYPE:image}
-#是否关闭office预览切换开关，默认为false，可配置为true关闭
-office.preview.switch.disabled = ${KK_OFFICE_PREVIEW_SWITCH_DISABLED:false}
 
+
+
+#PDF预览模块设置
+#配置PDF文件生成图片的像素大小，dpi 越高，图片质量越清晰，同时也会消耗更多的计算资源。
+pdf2jpg.dpi = ${KK_PDF2JPG_DPI:144}
+#PDF转换超时设置 (低于50页)  温馨提示这里数字仅供参考
+pdf.timeout =${KK_pdf_TIMEOUT:90}
+#PDF转换超时设置 (高于50小于200页)
+pdf.timeout80 =${KK_PDF_TIMEOUT80:180}
+#PDF转换超时设置 (大于200页)
+pdf.timeout200 =${KK_PDF_TIMEOUT200:300}
+#PDF转换线程设置
+pdf.thread =${KK_PDF_THREAD:5}
 #是否禁止演示模式
 pdf.presentationMode.disable = ${KK_PDF_PRESENTATION_MODE_DISABLE:true}
 #是否禁止打开文件
@@ -85,15 +128,13 @@ pdf.print.disable = ${KK_PDF_PRINT_DISABLE:true}
 pdf.download.disable = ${KK_PDF_DOWNLOAD_DISABLE:true}
 #是否禁止bookmark
 pdf.bookmark.disable = ${KK_PDF_BOOKMARK_DISABLE:true}
-#是否禁用首页文件上传
-file.upload.disable = ${KK_FILE_UPLOAD_ENABLED:false}
+#是否禁止签名
+pdf.disable.editing = ${KK_PDF_DISABLE_EDITING:false}
+#office类型文档(word ppt)样式，默认为图片(image)，可配置为pdf（预览时也有按钮切换）
+office.preview.type = ${KK_OFFICE_PREVIEW_TYPE:image}
+#是否关闭office预览切换开关，默认为false，可配置为true关闭
+office.preview.switch.disabled = ${KK_OFFICE_PREVIEW_SWITCH_DISABLED:false}
 
-#预览源为FTP时 FTP用户名，可在ftp url后面加参数ftp.username=ftpuser指定，不指定默认用配置的
-ftp.username = ${KK_FTP_USERNAME:ftpuser}
-#预览源为FTP时 FTP密码，可在ftp url后面加参数ftp.password=123456指定，不指定默认用配置的
-ftp.password = ${KK_FTP_PASSWORD:123456}
-#预览源为FTP时, FTP连接默认ControlEncoding(根据FTP服务器操作系统选择，Linux一般为UTF-8，Windows一般为GBK)，可在ftp url后面加参数ftp.control.encoding=UTF-8指定，不指定默认用配置的
-ftp.control.encoding = ${KK_FTP_CONTROL_ENCODING:UTF-8}
 
 #水印内容
 #例：watermark.txt = ${WATERMARK_TXT:凯京科技内部文件，严禁外泄}
@@ -118,17 +159,39 @@ watermark.height = ${WATERMARK_HEIGHT:80}
 #水印倾斜度数，要求设置在大于等于0，小于90
 watermark.angle = ${WATERMARK_ANGLE:10}
 
-#Tif类型图片浏览模式：tif（利用前端js插件浏览）；jpg（转换为jpg后前端显示）；pdf（转换为pdf后显示，便于打印）
-tif.preview.type = ${KK_TIF_PREVIEW_TYPE:tif}
+
+#首页功能设置
+#是否禁用首页文件上传
+file.upload.disable = ${KK_FILE_UPLOAD_DISABLE:false}
 # 备案信息，默认为空
 beian = ${KK_BEIAN:default}
 #禁止上传类型
 prohibit = ${KK_PROHIBIT:exe,dll,dat}
+#启用验证码删除文件 默认关闭
+delete.captcha= ${KK_DELETE_CAPTCHA:false}
 #删除密码
 delete.password = ${KK_DELETE_PASSWORD:123456}
 #删除 转换后OFFICE、CAD、TIFF、压缩包源文件 默认开启 节约磁盘空间
 delete.source.file = ${KK_DELETE_SOURCE_FILE:true}
-#配置PDF文件生成图片的像素大小，dpi 越高，图片质量越清晰，同时也会消耗更多的计算资源。
-pdf2jpg.dpi = ${KK_PDF2JPG_DPI:144}
-#xlsx格式前端解析
-office.type.web = ${KK_OFFICE_TYPE_WEB:web}
+#首页初始化加载第一页
+home.pagenumber = ${DEFAULT_HOME_PAGENUMBER:1}
+#首页是否分页
+home.pagination = ${DEFAULT_HOME_PAGINATION:true}
+#首页初始化单页记录数
+home.pagesize = ${DEFAULT_HOME_PAGSIZE:15}
+#首页显示查询框
+home.search = ${DEFAULT_HOME_SEARCH:true}
+
+#Tif类型设置
+#Tif类型图片浏览模式：tif（利用前端js插件浏览）；jpg（转换为jpg后前端显示）；pdf（转换为pdf后显示，便于打印）
+tif.preview.type = ${KK_TIF_PREVIEW_TYPE:tif}
+
+#Cad类型设置
+#Cad类型图片浏览模式：tif（利用前端js插件浏览）；svg（转换为svg显示）；pdf（转换为pdf后显示，便于打印）
+cad.preview.type = ${KK_CAD_PREVIEW_TYPE:svg}
+#Cad转换超时设置
+cad.timeout =${KK_CAD_TIMEOUT:90}
+#Cad转换线程设置
+cad.thread =${KK_CAD_THREAD:5}
+
+

server/src/main/java/cn/keking/config/ConfigRefreshComponent.java

@@ -46,11 +46,13 @@ public class ConfigRefreshComponent {
                 String configFilePath = ConfigUtils.getCustomizedConfigPath();
                 String baseUrl;
                 String trustHost;
+                String notTrustHost;
                 String pdfPresentationModeDisable;
                 String pdfOpenFileDisable;
                 String pdfPrintDisable;
                 String pdfDownloadDisable;
                 String pdfBookmarkDisable;
+                String pdfDisableEditing;
                 boolean fileUploadDisable;
                 String tifPreviewType;
                 String prohibit;
@@ -60,7 +62,26 @@ public class ConfigRefreshComponent {
                 String password;
                 int pdf2JpgDpi;
                 String officeTypeWeb;
+                String cadPreviewType;
                 boolean deleteSourceFile;
+                boolean deleteCaptcha;
+                String officPageRange;
+                String officWatermark;
+                String officQuality;
+                String officMaxImageResolution;
+                boolean officExportBookmarks;
+                boolean officeExportNotes;
+                boolean officeDocumentOpenPasswords;
+                String cadTimeout;
+                int cadThread;
+                String homePageNumber;
+                String homePagination;
+                String homePageSize;
+                String homeSearch;
+                int pdfTimeout;
+                int pdfTimeout80;
+                int pdfTimeout200;
+                int pdfThread;
                 while (true) {
                     FileReader fileReader = new FileReader(configFilePath);
                     BufferedReader bufferedReader = new BufferedReader(fileReader);
@@ -76,15 +97,18 @@ public class ConfigRefreshComponent {
                     ftpControlEncoding = properties.getProperty("ftp.control.encoding", ConfigConstants.DEFAULT_FTP_CONTROL_ENCODING);
                     textArray = text.split(",");
                     mediaArray = media.split(",");
-                    baseUrl = properties.getProperty("base.url", ConfigConstants.DEFAULT_BASE_URL);
-                    trustHost = properties.getProperty("trust.host", ConfigConstants.DEFAULT_TRUST_HOST);
+                    baseUrl = properties.getProperty("base.url", ConfigConstants.DEFAULT_VALUE);
+                    trustHost = properties.getProperty("trust.host", ConfigConstants.DEFAULT_VALUE);
+                    notTrustHost = properties.getProperty("not.trust.host", ConfigConstants.DEFAULT_VALUE);
                     pdfPresentationModeDisable = properties.getProperty("pdf.presentationMode.disable", ConfigConstants.DEFAULT_PDF_PRESENTATION_MODE_DISABLE);
                     pdfOpenFileDisable = properties.getProperty("pdf.openFile.disable", ConfigConstants.DEFAULT_PDF_OPEN_FILE_DISABLE);
                     pdfPrintDisable = properties.getProperty("pdf.print.disable", ConfigConstants.DEFAULT_PDF_PRINT_DISABLE);
                     pdfDownloadDisable = properties.getProperty("pdf.download.disable", ConfigConstants.DEFAULT_PDF_DOWNLOAD_DISABLE);
                     pdfBookmarkDisable = properties.getProperty("pdf.bookmark.disable", ConfigConstants.DEFAULT_PDF_BOOKMARK_DISABLE);
+                    pdfDisableEditing = properties.getProperty("pdf.disable.editing", ConfigConstants.DEFAULT_PDF_DISABLE_EDITING);
                     fileUploadDisable = Boolean.parseBoolean(properties.getProperty("file.upload.disable", ConfigConstants.DEFAULT_FILE_UPLOAD_DISABLE));
                     tifPreviewType = properties.getProperty("tif.preview.type", ConfigConstants.DEFAULT_TIF_PREVIEW_TYPE);
+                    cadPreviewType = properties.getProperty("cad.preview.type", ConfigConstants.DEFAULT_CAD_PREVIEW_TYPE);
                     size = properties.getProperty("spring.servlet.multipart.max-file-size", ConfigConstants.DEFAULT_SIZE);
                     beian = properties.getProperty("beian", ConfigConstants.DEFAULT_BEIAN);
                     prohibit = properties.getProperty("prohibit", ConfigConstants.DEFAULT_PROHIBIT);
@@ -92,6 +116,24 @@ public class ConfigRefreshComponent {
                     pdf2JpgDpi = Integer.parseInt(properties.getProperty("pdf2jpg.dpi", ConfigConstants.DEFAULT_PDF2_JPG_DPI));
                     officeTypeWeb = properties.getProperty("office.type.web", ConfigConstants.DEFAULT_OFFICE_TYPE_WEB);
                     deleteSourceFile =  Boolean.parseBoolean(properties.getProperty("delete.source.file", ConfigConstants.DEFAULT_DELETE_SOURCE_FILE));
+                    deleteCaptcha =  Boolean.parseBoolean(properties.getProperty("delete.captcha", ConfigConstants.DEFAULT_DELETE_CAPTCHA));
+                    officPageRange = properties.getProperty("office.pagerange", ConfigConstants.DEFAULT_OFFICE_PAQERANQE);
+                    officWatermark = properties.getProperty("office.watermark", ConfigConstants.DEFAULT_OFFICE_WATERMARK);
+                    officQuality = properties.getProperty("office.quality", ConfigConstants.DEFAULT_OFFICE_QUALITY);
+                    officMaxImageResolution = properties.getProperty("office.maximageresolution", ConfigConstants.DEFAULT_OFFICE_MAXIMAQERESOLUTION);
+                    officExportBookmarks = Boolean.parseBoolean(properties.getProperty("office.exportbookmarks", ConfigConstants.DEFAULT_OFFICE_EXPORTBOOKMARKS));
+                    officeExportNotes = Boolean.parseBoolean(properties.getProperty("office.exportnotes", ConfigConstants.DEFAULT_OFFICE_EXPORTNOTES));
+                    officeDocumentOpenPasswords =  Boolean.parseBoolean(properties.getProperty("office.documentopenpasswords", ConfigConstants.DEFAULT_OFFICE_EOCUMENTOPENPASSWORDS));
+                    cadTimeout = properties.getProperty("cad.timeout", ConfigConstants.DEFAULT_CAD_TIMEOUT);
+                    homePageNumber = properties.getProperty("home.pagenumber", ConfigConstants.DEFAULT_HOME_PAGENUMBER);
+                    homePagination = properties.getProperty("home.pagination", ConfigConstants.DEFAULT_HOME_PAGINATION);
+                    homePageSize = properties.getProperty("home.pagesize", ConfigConstants.DEFAULT_HOME_PAGSIZE);
+                    homeSearch = properties.getProperty("home.search", ConfigConstants.DEFAULT_HOME_SEARCH);
+                    cadThread = Integer.parseInt(properties.getProperty("cad.thread", ConfigConstants.DEFAULT_CAD_THREAD));
+                    pdfTimeout = Integer.parseInt(properties.getProperty("pdf.timeout", ConfigConstants.DEFAULT_PDF_TIMEOUT));
+                    pdfTimeout80 = Integer.parseInt(properties.getProperty("pdf.timeout80", ConfigConstants.DEFAULT_PDF_TIMEOUT80));
+                    pdfTimeout200 = Integer.parseInt(properties.getProperty("pdf.timeout200", ConfigConstants.DEFAULT_PDF_TIMEOUT200));
+                    pdfThread = Integer.parseInt(properties.getProperty("pdf.thread", ConfigConstants.DEFAULT_PDF_THREAD));
                     prohibitArray = prohibit.split(",");
 
                     ConfigConstants.setCacheEnabledValueValue(cacheEnabled);
@@ -103,21 +145,42 @@ public class ConfigRefreshComponent {
                     ConfigConstants.setFtpControlEncodingValue(ftpControlEncoding);
                     ConfigConstants.setBaseUrlValue(baseUrl);
                     ConfigConstants.setTrustHostValue(trustHost);
+                    ConfigConstants.setNotTrustHostValue(notTrustHost);
                     ConfigConstants.setOfficePreviewSwitchDisabledValue(officePreviewSwitchDisabled);
                     ConfigConstants.setPdfPresentationModeDisableValue(pdfPresentationModeDisable);
                     ConfigConstants.setPdfOpenFileDisableValue(pdfOpenFileDisable);
                     ConfigConstants.setPdfPrintDisableValue(pdfPrintDisable);
                     ConfigConstants.setPdfDownloadDisableValue(pdfDownloadDisable);
                     ConfigConstants.setPdfBookmarkDisableValue(pdfBookmarkDisable);
+                    ConfigConstants.setPdfDisableEditingValue(pdfDisableEditing);
                     ConfigConstants.setFileUploadDisableValue(fileUploadDisable);
                     ConfigConstants.setTifPreviewTypeValue(tifPreviewType);
+                    ConfigConstants.setCadPreviewTypeValue(cadPreviewType);
                     ConfigConstants.setBeianValue(beian);
                     ConfigConstants.setSizeValue(size);
                     ConfigConstants.setProhibitValue(prohibitArray);
                     ConfigConstants.setPasswordValue(password);
                     ConfigConstants.setPdf2JpgDpiValue(pdf2JpgDpi);
                     ConfigConstants.setOfficeTypeWebValue(officeTypeWeb);
+                    ConfigConstants.setOfficePageRangeValue(officPageRange);
+                    ConfigConstants.setOfficeWatermarkValue(officWatermark);
+                    ConfigConstants.setOfficeQualityValue(officQuality);
+                    ConfigConstants.setOfficeMaxImageResolutionValue(officMaxImageResolution);
+                    ConfigConstants.setOfficeExportBookmarksValue(officExportBookmarks);
+                    ConfigConstants.setOfficeExportNotesValue(officeExportNotes);
+                    ConfigConstants.setOfficeDocumentOpenPasswordsValue(officeDocumentOpenPasswords);
                     ConfigConstants.setDeleteSourceFileValue(deleteSourceFile);
+                    ConfigConstants.setDeleteCaptchaValue(deleteCaptcha);
+                    ConfigConstants.setCadTimeoutValue(cadTimeout);
+                    ConfigConstants.setCadThreadValue(cadThread);
+                    ConfigConstants.setHomePageNumberValue(homePageNumber);
+                    ConfigConstants.setHomePaginationValue(homePagination);
+                    ConfigConstants.setHomePageSizeValue(homePageSize);
+                    ConfigConstants.setHomeSearchValue(homeSearch);
+                    ConfigConstants.setPdfTimeoutValue(pdfTimeout);
+                    ConfigConstants.setPdfTimeout80Value(pdfTimeout80);
+                    ConfigConstants.setPdfTimeout200Value(pdfTimeout200);
+                    ConfigConstants.setPdfThreadValue(pdfThread);
                     setWatermarkConfig(properties);
                     bufferedReader.close();
                     fileReader.close();

server/src/main/java/cn/keking/config/WebConfig.java

@@ -30,11 +30,13 @@ public class WebConfig implements WebMvcConfigurer {
         registry.addResourceHandler("/**").addResourceLocations("classpath:/META-INF/resources/","classpath:/resources/","classpath:/static/","classpath:/public/","file:" + filePath);
     }
 
+
     @Bean
     public FilterRegistrationBean<ChinesePathFilter> getChinesePathFilter() {
         ChinesePathFilter filter = new ChinesePathFilter();
         FilterRegistrationBean<ChinesePathFilter> registrationBean = new FilterRegistrationBean<>();
         registrationBean.setFilter(filter);
+        registrationBean.setOrder(10);
         return registrationBean;
     }
 
@@ -67,14 +69,20 @@ public class WebConfig implements WebMvcConfigurer {
     @Bean
     public FilterRegistrationBean<BaseUrlFilter> getBaseUrlFilter() {
         Set<String> filterUri = new HashSet<>();
-        filterUri.add("/index");
-        filterUri.add("/");
-        filterUri.add("/onlinePreview");
-        filterUri.add("/picturesPreview");
         BaseUrlFilter filter = new BaseUrlFilter();
         FilterRegistrationBean<BaseUrlFilter> registrationBean = new FilterRegistrationBean<>();
         registrationBean.setFilter(filter);
         registrationBean.setUrlPatterns(filterUri);
+        registrationBean.setOrder(20);
+        return registrationBean;
+    }
+
+    @Bean
+    public FilterRegistrationBean<UrlCheckFilter> getUrlCheckFilter() {
+        UrlCheckFilter filter = new UrlCheckFilter();
+        FilterRegistrationBean<UrlCheckFilter> registrationBean = new FilterRegistrationBean<>();
+        registrationBean.setFilter(filter);
+        registrationBean.setOrder(30);
         return registrationBean;
     }
 

server/src/main/java/cn/keking/model/FileAttribute.java

@@ -12,13 +12,26 @@ public class FileAttribute {
     private String suffix;
     private String name;
     private String url;
-    private String fileKey;
+    private boolean isCompressFile = false;
+    private String compressFileKey;
     private String filePassword;
-    private String userToken;
+    private boolean usePasswordCache;
     private String officePreviewType = ConfigConstants.getOfficePreviewType();
     private String tifPreviewType;
     private Boolean skipDownLoad = false;
     private Boolean forceUpdatedCache = false;
+    private String cacheName;
+    private String outFilePath;
+    private String originFilePath;
+    private String cacheListName;
+    private boolean isHtmlView = false;
+
+    /**
+     * 代理请求到文件服务器的认证请求头，格式如下：
+     * {“username”:"test","password":"test"}
+     * 请求文件服务器时，会将 json 直接塞到请求头里
+     */
+    private String kkProxyAuthorization;
 
     public FileAttribute() {
     }
@@ -38,12 +51,12 @@ public class FileAttribute {
         this.officePreviewType = officePreviewType;
     }
 
-    public String getFileKey() {
-        return fileKey;
+    public boolean isCompressFile() {
+        return isCompressFile;
     }
 
-    public void setFileKey(String fileKey) {
-        this.fileKey = fileKey;
+    public void setCompressFile(boolean compressFile) {
+        isCompressFile = compressFile;
     }
 
     public String getFilePassword() {
@@ -54,12 +67,12 @@ public class FileAttribute {
         this.filePassword = filePassword;
     }
 
-    public String getUserToken() {
-        return userToken;
+    public boolean getUsePasswordCache() {
+        return usePasswordCache;
     }
 
-    public void setUserToken(String userToken) {
-        this.userToken = userToken;
+    public void setUsePasswordCache(boolean usePasswordCache) {
+        this.usePasswordCache = usePasswordCache;
     }
 
     public String getOfficePreviewType() {
@@ -86,10 +99,48 @@ public class FileAttribute {
         this.suffix = suffix;
     }
 
+    public String getCompressFileKey() {
+        return compressFileKey;
+    }
+
+    public void setCompressFileKey(String compressFileKey) {
+        this.compressFileKey = compressFileKey;
+    }
+
     public String getName() {
         return name;
     }
+    public String getCacheName() {
+        return cacheName;
+    }
+    public String getCacheListName() {
+        return cacheListName;
+    }
+    public String getOutFilePath() {
+        return outFilePath;
+    }
+    public String getOriginFilePath() {
+        return originFilePath;
+    }
+    public boolean isHtmlView() {
+        return isHtmlView;
+    }
 
+    public void setCacheName(String cacheName) {
+        this.cacheName = cacheName;
+    }
+    public void setCacheListName(String cacheListName) {
+        this.cacheListName = cacheListName;
+    }
+    public void setOutFilePath(String outFilePath) {
+        this.outFilePath = outFilePath;
+    }
+    public void setOriginFilePath(String originFilePath) {
+        this.originFilePath = originFilePath;
+    }
+    public void setHtmlView(boolean isHtmlView) {
+        this.isHtmlView = isHtmlView;
+    }
     public void setName(String name) {
         this.name = name;
     }
@@ -124,4 +175,11 @@ public class FileAttribute {
         this.forceUpdatedCache = forceUpdatedCache;
     }
 
+    public String getKkProxyAuthorization() {
+        return kkProxyAuthorization;
+    }
+
+    public void setKkProxyAuthorization(String kkProxyAuthorization) {
+        this.kkProxyAuthorization = kkProxyAuthorization;
+    }
 }

server/src/main/java/cn/keking/model/FileType.java

@@ -19,9 +19,9 @@ public enum FileType {
     CODE("codeFilePreviewImpl"),
     OTHER("otherFilePreviewImpl"),
     MEDIA("mediaFilePreviewImpl"),
+    MEDIACONVERT("mediaFilePreviewImpl"),
     MARKDOWN("markdownFilePreviewImpl"),
     XML("xmlFilePreviewImpl"),
-    FLV("flvFilePreviewImpl"),
     CAD("cadFilePreviewImpl"),
     TIFF("tiffFilePreviewImpl"),
     OFD("ofdFilePreviewImpl"),
@@ -43,6 +43,7 @@ public enum FileType {
     private static final String[] EPUB_TYPES = {"epub"};
     private static final String[] DCM_TYPES = {"dcm"};
     private static final String[] DRAWIO_TYPES = {"drawio"};
+    private static final String[] XML_TYPES = {"xml","xbrl"};
     private static final String[] TIFF_TYPES = {"tif", "tiff"};
     private static final String[] OFD_TYPES = {"ofd"};
     private static final String[] SVG_TYPES = {"svg"};
@@ -50,7 +51,7 @@ public enum FileType {
     private static final String[] SSIM_TEXT_TYPES = ConfigConstants.getSimText();
     private static final String[] CODES = {"java", "c", "php", "go", "python", "py", "js", "html", "ftl", "css", "lua", "sh", "rb", "yaml", "yml", "json", "h", "cpp", "cs", "aspx", "jsp", "sql"};
     private static final String[] MEDIA_TYPES = ConfigConstants.getMedia();
-    public static final String[] MEDIA_TYPES_CONVERT = ConfigConstants.getConvertMedias();
+    public static final String[] MEDIA_CONVERT_TYPES = ConfigConstants.getConvertMedias();
     private static final Map<String, FileType> FILE_TYPE_MAPPER = new HashMap<>();
 
     static {
@@ -69,8 +70,8 @@ public enum FileType {
         for (String media : MEDIA_TYPES) {
             FILE_TYPE_MAPPER.put(media, FileType.MEDIA);
         }
-        for (String media : MEDIA_TYPES_CONVERT) {
-            FILE_TYPE_MAPPER.put(media, FileType.MEDIA);
+        for (String  MEDIACONVERT : MEDIA_CONVERT_TYPES) {
+            FILE_TYPE_MAPPER.put( MEDIACONVERT, FileType. MEDIACONVERT);
         }
         for (String tif : TIFF_TYPES) {
             FILE_TYPE_MAPPER.put(tif, FileType.TIFF);
@@ -105,10 +106,11 @@ public enum FileType {
         for (String drawio : DRAWIO_TYPES) {
             FILE_TYPE_MAPPER.put(drawio, FileType.DRAWIO);
         }
+        for (String xml : XML_TYPES) {
+            FILE_TYPE_MAPPER.put(xml, FileType.XML);
+        }
         FILE_TYPE_MAPPER.put("md", FileType.MARKDOWN);
-        FILE_TYPE_MAPPER.put("xml", FileType.XML);
         FILE_TYPE_MAPPER.put("pdf", FileType.PDF);
-        FILE_TYPE_MAPPER.put("flv", FileType.FLV);
         FILE_TYPE_MAPPER.put("bpmn", FileType.BPMN);
     }
 

server/src/main/java/cn/keking/service/CompressFileReader.java

@@ -1,5 +1,7 @@
 package cn.keking.service;
 
+import cn.keking.config.ConfigConstants;
+import cn.keking.model.FileAttribute;
 import cn.keking.model.FileType;
 import cn.keking.utils.RarUtils;
 import cn.keking.web.filter.BaseUrlFilter;
@@ -10,11 +12,19 @@ import net.sf.sevenzipjbinding.SevenZipException;
 import net.sf.sevenzipjbinding.impl.RandomAccessFileInStream;
 import net.sf.sevenzipjbinding.simple.ISimpleInArchive;
 import net.sf.sevenzipjbinding.simple.ISimpleInArchiveItem;
-import org.apache.commons.io.IOUtils;
 import org.springframework.stereotype.Component;
 
-import java.io.*;
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -25,75 +35,79 @@ import java.util.List;
 @Component
 public class CompressFileReader {
     private final FileHandlerService fileHandlerService;
+    private static final String fileDir = ConfigConstants.getFileDir();
+
     public CompressFileReader(FileHandlerService fileHandlerService) {
         this.fileHandlerService = fileHandlerService;
     }
-    public String unRar(String paths, String passWord, String fileName) throws Exception {
+
+    public String unRar(String filePath, String filePassword, String fileName, FileAttribute fileAttribute) throws Exception {
         List<String> imgUrls = new ArrayList<>();
         String baseUrl = BaseUrlFilter.getBaseUrl();
-        String archiveFileName = fileHandlerService.getFileNameFromPath(paths);
-        RandomAccessFile randomAccessFile = null;
-        IInArchive inArchive = null;
-        try {
-            randomAccessFile = new RandomAccessFile(paths, "r");
-            inArchive = SevenZip.openInArchive(null, new RandomAccessFileInStream(randomAccessFile));
-            String folderName = paths.substring(paths.lastIndexOf(File.separator) + 1);
-            String extractPath = paths.substring(0, paths.lastIndexOf(folderName));
-            ISimpleInArchive   simpleInArchive = inArchive.getSimpleInterface();
-            final String[] str = {null};
+        String packagePath = "_";
+        String folderName = filePath.replace(fileDir, ""); //修复压缩包 多重目录获取路径错误
+        if (fileAttribute.isCompressFile()) {
+            folderName = "_decompression" + folderName;
+        }
+        Path folderPath = Paths.get(fileDir, folderName + packagePath);
+        Files.createDirectories(folderPath);
+
+        try (RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "r");
+             IInArchive inArchive = SevenZip.openInArchive(null, new RandomAccessFileInStream(randomAccessFile))) {
+
+            ISimpleInArchive simpleInArchive = inArchive.getSimpleInterface();
             for (final ISimpleInArchiveItem item : simpleInArchive.getArchiveItems()) {
                 if (!item.isFolder()) {
-                    ExtractOperationResult result;
-                    result = item.extractSlow(data -> {
-                        try {
-                             str[0] = RarUtils.getUtf8String(item.getPath());
-                            if (RarUtils.isMessyCode(str[0])){
-                                str[0] = new String(item.getPath().getBytes(StandardCharsets.ISO_8859_1), "gbk");
-                            }
-                            str[0] = str[0].replace("\\",  File.separator); //Linux 下路径错误
-                            String  str1 = str[0].substring(0, str[0].lastIndexOf(File.separator)+ 1);
-                            File file = new File(extractPath, folderName + "_" + File.separator + str1);
-                            if (!file.exists()) {
-                                file.mkdirs();
-                            }
-                            OutputStream out = new FileOutputStream( extractPath+ folderName + "_" + File.separator + str[0], true);
-                            IOUtils.write(data, out);
-                            out.close();
-                        } catch (Exception e) {
-                            e.printStackTrace();
+                    final Path filePathInsideArchive = getFilePathInsideArchive(item, folderPath);
+                    ExtractOperationResult result = item.extractSlow(data -> {
+                        try (OutputStream out = new BufferedOutputStream(new FileOutputStream(filePathInsideArchive.toFile(), true))) {
+                            out.write(data);
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
                         }
                         return data.length;
-                    }, passWord);
-                    if (result == ExtractOperationResult.OK) {
-                        FileType type = FileType.typeFromUrl(str[0]);
-                        if (type.equals(FileType.PICTURE)) {
-                            imgUrls.add(baseUrl +folderName + "_/" + str[0].replace("\\", "/"));
+                    }, filePassword);
+                    if (result != ExtractOperationResult.OK) {
+                        ExtractOperationResult result1 = ExtractOperationResult.valueOf("WRONG_PASSWORD");
+                        if (result1.equals(result)) {
+                            throw new Exception("Password");
+                        }else {
+                            throw new Exception("Failed to extract RAR file.");
                         }
-                        fileHandlerService.putImgCache(fileName, imgUrls);
-                    } else {
-                        return null;
+                    }
+
+                    FileType type = FileType.typeFromUrl(filePathInsideArchive.toString());
+                    if (type.equals(FileType.PICTURE)) {  //图片缓存到集合，为了特殊符号需要进行编码
+                        imgUrls.add(baseUrl + URLEncoder.encode(fileName + packagePath+"/"+ folderPath.relativize(filePathInsideArchive).toString().replace("\\", "/"), "UTF-8"));
                     }
                 }
             }
-            return archiveFileName + "_";
+            fileHandlerService.putImgCache(fileName + packagePath, imgUrls);
         } catch (Exception e) {
-            throw new Exception(e);
-        } finally {
-            if (inArchive != null) {
-                try {
-                    inArchive.close();
-                } catch (SevenZipException e) {
-                    System.err.println("Error closing archive: " + e);
-                }
-            }
-            if (randomAccessFile != null) {
-                try {
-                    randomAccessFile.close();
-                } catch (IOException e) {
-                    System.err.println("Error closing file: " + e);
-                }
-            }
+            throw new Exception("Error processing RAR file: " + e.getMessage(), e);
         }
+        return folderName + packagePath;
     }
 
-}
+    private Path getFilePathInsideArchive(ISimpleInArchiveItem item, Path folderPath) throws SevenZipException, UnsupportedEncodingException {
+        String insideFileName = RarUtils.getUtf8String(item.getPath());
+        if (RarUtils.isMessyCode(insideFileName)) {
+            insideFileName = new String(item.getPath().getBytes(StandardCharsets.ISO_8859_1), "gbk");
+        }
+
+        // 正规化路径并验证是否安全
+        Path normalizedPath = folderPath.resolve(insideFileName).normalize();
+        if (!normalizedPath.startsWith(folderPath)) {
+            throw new SecurityException("Unsafe path detected: " + insideFileName);
+        }
+
+        try {
+            Files.createDirectories(normalizedPath.getParent());
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to create directory: " + normalizedPath.getParent(), e);
+        }
+        return normalizedPath;
+    }
+
+
+}

server/src/main/java/cn/keking/service/FilePreview.java

@@ -9,7 +9,6 @@ import org.springframework.ui.Model;
  */
 public interface FilePreview {
 
-    String FLV_FILE_PREVIEW_PAGE = "flv";
     String PDF_FILE_PREVIEW_PAGE = "pdf";
     String PPT_FILE_PREVIEW_PAGE = "ppt";
     String COMPRESS_FILE_PREVIEW_PAGE = "compress";
@@ -33,6 +32,7 @@ public interface FilePreview {
     String DRAWUI_FILE_PREVIEW_PAGE = "drawio";
     String NOT_SUPPORTED_FILE_PAGE = "fileNotSupported";
     String XLSX_FILE_PREVIEW_PAGE = "officeweb";
+    String CSV_FILE_PREVIEW_PAGE = "csv";
 
     String filePreviewHandle(String url, Model model, FileAttribute fileAttribute);
 }

server/src/main/java/cn/keking/service/OfficePluginManager.java

@@ -43,6 +43,12 @@ public class OfficePluginManager {
     @Value("${office.plugin.task.timeout:5m}")
     private String timeOut;
 
+    @Value("${office.plugin.task.taskexecutiontimeout:5m}")
+    private String taskExecutionTimeout;
+
+    @Value("${office.plugin.task.maxtasksperprocess:5}")
+    private int maxTasksPerProcess;
+
     /**
      * 启动Office组件进程
      */
@@ -60,10 +66,13 @@ public class OfficePluginManager {
             String[] portsString = serverPorts.split(",");
             int[] ports = Arrays.stream(portsString).mapToInt(Integer::parseInt).toArray();
             long timeout = DurationStyle.detectAndParse(timeOut).toMillis();
+            long taskexecutiontimeout = DurationStyle.detectAndParse(taskExecutionTimeout).toMillis();
             officeManager = LocalOfficeManager.builder()
                     .officeHome(officeHome)
                     .portNumbers(ports)
                     .processTimeout(timeout)
+                    .maxTasksPerProcess(maxTasksPerProcess)
+                    .taskExecutionTimeout(taskexecutiontimeout)
                     .build();
             officeManager.start();
             InstalledOfficeManagerHolder.setInstance(officeManager);

server/src/main/java/cn/keking/service/OfficeToPdfService.java

@@ -1,5 +1,6 @@
 package cn.keking.service;
 
+import cn.keking.config.ConfigConstants;
 import cn.keking.model.FileAttribute;
 import com.sun.star.document.UpdateDocMode;
 import org.apache.commons.lang3.StringUtils;
@@ -33,15 +34,36 @@ public class OfficeToPdfService {
             logger.error("创建目录【{}】失败，请检查目录权限！",outputFilePath_end);
         }
         LocalConverter.Builder builder;
+        Map<String, Object> filterData = new HashMap<>();
+        filterData.put("EncryptFile", true);
+        if(!ConfigConstants.getOfficePageRange().equals("false")){
+            filterData.put("PageRange", ConfigConstants.getOfficePageRange()); //限制页面
+        }
+        if(!ConfigConstants.getOfficeWatermark().equals("false")){
+            filterData.put("Watermark", ConfigConstants.getOfficeWatermark());  //水印
+        }
+        filterData.put("Quality", ConfigConstants.getOfficeQuality()); //图片压缩
+        filterData.put("MaxImageResolution", ConfigConstants.getOfficeMaxImageResolution()); //DPI
+        if(ConfigConstants.getOfficeExportBookmarks()){
+            filterData.put("ExportBookmarks", true); //导出书签
+        }
+        if(ConfigConstants.getOfficeExportNotes()){
+            filterData.put("ExportNotes", true); //批注作为PDF的注释
+        }
+        if(ConfigConstants.getOfficeDocumentOpenPasswords()){
+            filterData.put("DocumentOpenPassword", fileAttribute.getFilePassword()); //给PDF添加密码
+        }
+        Map<String, Object> customProperties = new HashMap<>();
+        customProperties.put("FilterData", filterData);
         if (StringUtils.isNotBlank(fileAttribute.getFilePassword())) {
             Map<String, Object> loadProperties = new HashMap<>();
             loadProperties.put("Hidden", true);
             loadProperties.put("ReadOnly", true);
             loadProperties.put("UpdateDocMode", UpdateDocMode.NO_UPDATE);
             loadProperties.put("Password", fileAttribute.getFilePassword());
-            builder = LocalConverter.builder().loadProperties(loadProperties);
+            builder = LocalConverter.builder().loadProperties(loadProperties).storeProperties(customProperties);
         } else {
-            builder = LocalConverter.builder();
+            builder = LocalConverter.builder().storeProperties(customProperties);
         }
         builder.build().convert(inputFile).to(outputFile).execute();
     }

server/src/main/java/cn/keking/service/cache/NotResourceCache.java

@@ -2,9 +2,12 @@ package cn.keking.service.cache;
 
 import org.apache.pdfbox.cos.COSObject;
 import org.apache.pdfbox.pdmodel.DefaultResourceCache;
+import org.apache.pdfbox.pdmodel.documentinterchange.markedcontent.PDPropertyList;
 import org.apache.pdfbox.pdmodel.graphics.PDXObject;
-
-import java.io.IOException;
+import org.apache.pdfbox.pdmodel.graphics.color.PDColorSpace;
+import org.apache.pdfbox.pdmodel.graphics.pattern.PDAbstractPattern;
+import org.apache.pdfbox.pdmodel.graphics.shading.PDShading;
+import org.apache.pdfbox.pdmodel.graphics.state.PDExtendedGraphicsState;
 
 /**
  * @author: Sawyer.Yong
@@ -14,7 +17,21 @@ import java.io.IOException;
 public class NotResourceCache extends DefaultResourceCache {
 
     @Override
-    public void put(COSObject indirect, PDXObject xobject) throws IOException {
-        // do nothing
+    public void put(COSObject indirect, PDColorSpace colorSpace) {
+    }
+    @Override
+    public void put(COSObject indirect, PDExtendedGraphicsState extGState) {
+    }
+    @Override
+    public void put(COSObject indirect, PDShading shading) {
+    }
+    @Override
+    public void put(COSObject indirect, PDAbstractPattern pattern) {
+    }
+    @Override
+    public void  put(COSObject indirect, PDPropertyList propertyList) {
+    }
+    @Override
+    public void put(COSObject indirect, PDXObject xobject) {
     }
 }

server/src/main/java/cn/keking/service/cache/impl/CacheServiceJDKImpl.java

@@ -101,6 +101,7 @@ public class CacheServiceJDKImpl implements CacheService {
         initPDFCachePool(CacheService.DEFAULT_PDF_CAPACITY);
         initIMGCachePool(CacheService.DEFAULT_IMG_CAPACITY);
         initPdfImagesCachePool(CacheService.DEFAULT_PDFIMG_CAPACITY);
+        initMediaConvertCachePool(CacheService.DEFAULT_MEDIACONVERT_CAPACITY);
     }
 
     @Override

server/src/main/java/cn/keking/service/cache/impl/CacheServiceRedisImpl.java

@@ -107,6 +107,7 @@ public class CacheServiceRedisImpl implements CacheService {
         cleanPdfCache();
         cleanImgCache();
         cleanPdfImgCache();
+        cleanMediaConvertCache();
     }
 
     @Override
@@ -135,4 +136,9 @@ public class CacheServiceRedisImpl implements CacheService {
         RMapCache<String, Integer> pdfImg = redissonClient.getMapCache(FILE_PREVIEW_PDF_IMGS_KEY);
         pdfImg.clear();
     }
+
+    private void cleanMediaConvertCache() {
+        RMapCache<String, Integer> mediaConvertCache = redissonClient.getMapCache(FILE_PREVIEW_MEDIA_CONVERT_KEY);
+        mediaConvertCache.clear();
+    }
 }

server/src/main/java/cn/keking/service/cache/impl/CacheServiceRocksDBImpl.java

@@ -104,7 +104,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     @SuppressWarnings("unchecked")
     public Map<String, String> getPDFCache() {
         Map<String, String> result = new HashMap<>();
-        try{
+        try {
             result = (Map<String, String>) toObject(db.get(FILE_PREVIEW_PDF_KEY.getBytes()));
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
             LOGGER.error("Get from RocksDB Exception" + e);
@@ -116,7 +116,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     @SuppressWarnings("unchecked")
     public String getPDFCache(String key) {
         String result = "";
-        try{
+        try {
             Map<String, String> map = (Map<String, String>) toObject(db.get(FILE_PREVIEW_PDF_KEY.getBytes()));
             result = map.get(key);
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
@@ -129,7 +129,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     @SuppressWarnings("unchecked")
     public Map<String, List<String>> getImgCache() {
         Map<String, List<String>> result = new HashMap<>();
-        try{
+        try {
             result = (Map<String, List<String>>) toObject(db.get(FILE_PREVIEW_IMGS_KEY.getBytes()));
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
             LOGGER.error("Get from RocksDB Exception" + e);
@@ -142,7 +142,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     public List<String> getImgCache(String key) {
         List<String> result = new ArrayList<>();
         Map<String, List<String>> map;
-        try{
+        try {
             map = (Map<String, List<String>>) toObject(db.get(FILE_PREVIEW_IMGS_KEY.getBytes()));
             result = map.get(key);
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
@@ -156,7 +156,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     public Integer getPdfImageCache(String key) {
         Integer result = 0;
         Map<String, Integer> map;
-        try{
+        try {
             map = (Map<String, Integer>) toObject(db.get(FILE_PREVIEW_PDF_IMGS_KEY.getBytes()));
             result = map.get(key);
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
@@ -180,7 +180,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     @SuppressWarnings("unchecked")
     public Map<String, String> getMediaConvertCache() {
         Map<String, String> result = new HashMap<>();
-        try{
+        try {
             result = (Map<String, String>) toObject(db.get(FILE_PREVIEW_MEDIA_CONVERT_KEY.getBytes()));
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
             LOGGER.error("Get from RocksDB Exception" + e);
@@ -203,7 +203,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     @SuppressWarnings("unchecked")
     public String getMediaConvertCache(String key) {
         String result = "";
-        try{
+        try {
             Map<String, String> map = (Map<String, String>) toObject(db.get(FILE_PREVIEW_MEDIA_CONVERT_KEY.getBytes()));
             result = map.get(key);
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
@@ -218,6 +218,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
             cleanPdfCache();
             cleanImgCache();
             cleanPdfImgCache();
+            cleanMediaConvertCache();
         } catch (IOException | RocksDBException e) {
             LOGGER.error("Clean Cache Exception" + e);
         }
@@ -236,7 +237,7 @@ public class CacheServiceRocksDBImpl implements CacheService {
     @SuppressWarnings("unchecked")
     private Map<String, Integer> getPdfImageCaches() {
         Map<String, Integer> map = new HashMap<>();
-        try{
+        try {
             map = (Map<String, Integer>) toObject(db.get(FILE_PREVIEW_PDF_IMGS_KEY.getBytes()));
         } catch (RocksDBException | IOException | ClassNotFoundException e) {
             LOGGER.error("Get from RocksDB Exception" + e);
@@ -245,22 +246,22 @@ public class CacheServiceRocksDBImpl implements CacheService {
     }
 
 
-    private byte[] toByteArray (Object obj) throws IOException {
+    private byte[] toByteArray(Object obj) throws IOException {
         byte[] bytes;
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos);
         oos.writeObject(obj);
         oos.flush();
-        bytes = bos.toByteArray ();
+        bytes = bos.toByteArray();
         oos.close();
         bos.close();
         return bytes;
     }
 
-    private Object toObject (byte[] bytes) throws IOException, ClassNotFoundException {
+    private Object toObject(byte[] bytes) throws IOException, ClassNotFoundException {
         Object obj;
-        ByteArrayInputStream bis = new ByteArrayInputStream (bytes);
-        ObjectInputStream ois = new ObjectInputStream (bis);
+        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
+        ObjectInputStream ois = new ObjectInputStream(bis);
         obj = ois.readObject();
         ois.close();
         bis.close();
@@ -281,4 +282,9 @@ public class CacheServiceRocksDBImpl implements CacheService {
         Map<String, Integer> initPDFIMGCache = new HashMap<>();
         db.put(FILE_PREVIEW_PDF_IMGS_KEY.getBytes(), toByteArray(initPDFIMGCache));
     }
+
+    private void cleanMediaConvertCache() throws IOException, RocksDBException {
+        Map<String, String> initMediaConvertCache = new HashMap<>();
+        db.put(FILE_PREVIEW_MEDIA_CONVERT_KEY.getBytes(), toByteArray(initMediaConvertCache));
+    }
 }

server/src/main/java/cn/keking/service/impl/CadFilePreviewImpl.java

@@ -3,17 +3,16 @@ package cn.keking.service.impl;
 import cn.keking.config.ConfigConstants;
 import cn.keking.model.FileAttribute;
 import cn.keking.model.ReturnResponse;
+import cn.keking.service.FileHandlerService;
 import cn.keking.service.FilePreview;
 import cn.keking.utils.DownloadUtils;
-import cn.keking.service.FileHandlerService;
 import cn.keking.utils.KkFileUtils;
+import cn.keking.utils.WebUtils;
 import cn.keking.web.filter.BaseUrlFilter;
 import org.springframework.stereotype.Service;
 import org.springframework.ui.Model;
 import org.springframework.util.StringUtils;
 
-import java.util.List;
-
 import static cn.keking.service.impl.OfficeFilePreviewImpl.getPreviewType;
 
 /**
@@ -25,7 +24,6 @@ public class CadFilePreviewImpl implements FilePreview {
 
     private static final String OFFICE_PREVIEW_TYPE_IMAGE = "image";
     private static final String OFFICE_PREVIEW_TYPE_ALL_IMAGES = "allImages";
-    private static final String FILE_DIR = ConfigConstants.getFileDir();
 
     private final FileHandlerService fileHandlerService;
     private final OtherFilePreviewImpl otherFilePreview;
@@ -40,45 +38,50 @@ public class CadFilePreviewImpl implements FilePreview {
         // 预览Type，参数传了就取参数的，没传取系统默认
         String officePreviewType = fileAttribute.getOfficePreviewType() == null ? ConfigConstants.getOfficePreviewType() : fileAttribute.getOfficePreviewType();
         String baseUrl = BaseUrlFilter.getBaseUrl();
-        boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();
+        boolean forceUpdatedCache = fileAttribute.forceUpdatedCache();
         String fileName = fileAttribute.getName();
-        String suffix = fileAttribute.getSuffix();
-        String pdfName = fileName.substring(0, fileName.lastIndexOf(".")) + suffix +"." + "pdf" ; //生成文件添加类型后缀 防止同名文件
-        String outFilePath = FILE_DIR + pdfName;
+        String cadPreviewType = ConfigConstants.getCadPreviewType();
+        String cacheName = fileAttribute.getCacheName();
+        String outFilePath = fileAttribute.getOutFilePath();
         // 判断之前是否已转换过，如果转换过，直接返回，否则执行转换
-        if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(pdfName) || !ConfigConstants.isCacheEnabled()) {
-            String filePath;
-            ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, null);
+        if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(cacheName) || !ConfigConstants.isCacheEnabled()) {
+            ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
             if (response.isFailure()) {
                 return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
             }
-            filePath = response.getContent();
+            String filePath = response.getContent();
             String imageUrls = null;
             if (StringUtils.hasText(outFilePath)) {
                 try {
-                    imageUrls =  fileHandlerService.cadToPdf(filePath, outFilePath);
+                    imageUrls = fileHandlerService.cadToPdf(filePath, outFilePath, cadPreviewType, fileAttribute);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
-                if (imageUrls == null ) {
-                    return otherFilePreview.notSupportedFile(model, fileAttribute, "office转图片异常，请联系管理员");
+                if (imageUrls == null) {
+                    return otherFilePreview.notSupportedFile(model, fileAttribute, "CAD转换异常，请联系管理员");
                 }
                 //是否保留CAD源文件
-                if( ConfigConstants.getDeleteSourceFile()) {
+                if (!fileAttribute.isCompressFile() && ConfigConstants.getDeleteSourceFile()) {
                     KkFileUtils.deleteFileByPath(filePath);
                 }
                 if (ConfigConstants.isCacheEnabled()) {
                     // 加入缓存
-                    fileHandlerService.addConvertedFile(pdfName, fileHandlerService.getRelativePath(outFilePath));
+                    fileHandlerService.addConvertedFile(cacheName, fileHandlerService.getRelativePath(outFilePath));
                 }
             }
         }
-        if (baseUrl != null && (OFFICE_PREVIEW_TYPE_IMAGE.equals(officePreviewType) || OFFICE_PREVIEW_TYPE_ALL_IMAGES.equals(officePreviewType))) {
-            return getPreviewType(model, fileAttribute, officePreviewType, baseUrl, pdfName, outFilePath, fileHandlerService, OFFICE_PREVIEW_TYPE_IMAGE,otherFilePreview);
+        cacheName=  WebUtils.encodeFileName(cacheName);
+        if ("tif".equalsIgnoreCase(cadPreviewType)) {
+            model.addAttribute("currentUrl", cacheName);
+            return TIFF_FILE_PREVIEW_PAGE;
+        } else if ("svg".equalsIgnoreCase(cadPreviewType)) {
+            model.addAttribute("currentUrl", cacheName);
+            return SVG_FILE_PREVIEW_PAGE;
         }
-        model.addAttribute("pdfUrl", pdfName);
+        if (baseUrl != null && (OFFICE_PREVIEW_TYPE_IMAGE.equals(officePreviewType) || OFFICE_PREVIEW_TYPE_ALL_IMAGES.equals(officePreviewType))) {
+            return getPreviewType(model, fileAttribute, officePreviewType, cacheName, outFilePath, fileHandlerService, OFFICE_PREVIEW_TYPE_IMAGE, otherFilePreview);
+        }
+        model.addAttribute("pdfUrl", cacheName);
         return PDF_FILE_PREVIEW_PAGE;
     }
-
-
 }

server/src/main/java/cn/keking/service/impl/CompressFilePreviewImpl.java

@@ -10,6 +10,7 @@ import cn.keking.service.CompressFileReader;
 import cn.keking.utils.KkFileUtils;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.poi.EncryptedDocumentException;
+import org.slf4j.Logger;
 import org.springframework.stereotype.Service;
 import org.springframework.ui.Model;
 import org.springframework.util.ObjectUtils;
@@ -28,6 +29,9 @@ public class CompressFilePreviewImpl implements FilePreview {
     private final CompressFileReader compressFileReader;
     private final OtherFilePreviewImpl otherFilePreview;
     private static final String Rar_PASSWORD_MSG = "password";
+    private static final Logger logger = org.slf4j.LoggerFactory.getLogger(CompressFileReader.class);
+
+
     public CompressFilePreviewImpl(FileHandlerService fileHandlerService, CompressFileReader compressFileReader, OtherFilePreviewImpl otherFilePreview) {
         this.fileHandlerService = fileHandlerService;
         this.compressFileReader = compressFileReader;
@@ -36,47 +40,44 @@ public class CompressFilePreviewImpl implements FilePreview {
 
     @Override
     public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
-        String fileName=fileAttribute.getName();
+        String fileName = fileAttribute.getName();
         String filePassword = fileAttribute.getFilePassword();
-        boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();
+        boolean forceUpdatedCache = fileAttribute.forceUpdatedCache();
         String fileTree = null;
         // 判断文件名是否存在(redis缓存读取)
-        if (forceUpdatedCache || !StringUtils.hasText(fileHandlerService.getConvertedFile(fileName))  || !ConfigConstants.isCacheEnabled()) {
+        if (forceUpdatedCache || !StringUtils.hasText(fileHandlerService.getConvertedFile(fileName)) || !ConfigConstants.isCacheEnabled()) {
             ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
             if (response.isFailure()) {
                 return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
             }
             String filePath = response.getContent();
             try {
-                fileTree = compressFileReader.unRar(filePath, filePassword,fileName);
+                fileTree = compressFileReader.unRar(filePath, filePassword, fileName, fileAttribute);
             } catch (Exception e) {
-                Throwable[] throwableArray = ExceptionUtils.getThrowables(e);
-                for (Throwable throwable : throwableArray) {
-                    if (throwable instanceof IOException || throwable instanceof EncryptedDocumentException) {
-                        if (e.getMessage().toLowerCase().contains(Rar_PASSWORD_MSG)) {
-                            model.addAttribute("needFilePassword", true);
-                            return EXEL_FILE_PREVIEW_PAGE;
-                        }
-                    }
+                if (e.getMessage().toLowerCase().contains(Rar_PASSWORD_MSG)) {
+                    model.addAttribute("needFilePassword", true);
+                    return EXEL_FILE_PREVIEW_PAGE;
+                }else {
+                    logger.error("Error processing RAR file: " + e.getMessage(), e);
                 }
             }
             if (!ObjectUtils.isEmpty(fileTree)) {
                 //是否保留压缩包源文件
-                if (ConfigConstants.getDeleteSourceFile()) {
+                if (!fileAttribute.isCompressFile() && ConfigConstants.getDeleteSourceFile()) {
                     KkFileUtils.deleteFileByPath(filePath);
                 }
                 if (ConfigConstants.isCacheEnabled()) {
                     // 加入缓存
                     fileHandlerService.addConvertedFile(fileName, fileTree);
                 }
-            }else {
-                return otherFilePreview.notSupportedFile(model, fileAttribute, "压缩文件密码错误! 压缩文件损坏!  压缩文件类型不受支持!");
+            } else {
+                return otherFilePreview.notSupportedFile(model, fileAttribute, "该压缩包文件无法处理!");
             }
         } else {
             fileTree = fileHandlerService.getConvertedFile(fileName);
         }
-            model.addAttribute("fileName", fileName);
-            model.addAttribute("fileTree", fileTree);
-            return COMPRESS_FILE_PREVIEW_PAGE;
+        model.addAttribute("fileName", fileName);
+        model.addAttribute("fileTree", fileTree);
+        return COMPRESS_FILE_PREVIEW_PAGE;
     }
 }

server/src/main/java/cn/keking/service/impl/FlvFilePreviewImpl.java

@@ -1,27 +0,0 @@
-package cn.keking.service.impl;
-
-import cn.keking.model.FileAttribute;
-import cn.keking.service.FilePreview;
-import org.springframework.stereotype.Service;
-import org.springframework.ui.Model;
-
-/**
- * @author : kl
- * create : 2020-12-27 2:50 下午
- * flv文件预览处理实现
- **/
-@Service
-public class FlvFilePreviewImpl implements FilePreview {
-
-    private final MediaFilePreviewImpl mediaFilePreview;
-
-    public FlvFilePreviewImpl(MediaFilePreviewImpl mediaFilePreview) {
-        this.mediaFilePreview = mediaFilePreview;
-    }
-
-    @Override
-    public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
-        mediaFilePreview.filePreviewHandle(url,model,fileAttribute);
-        return FLV_FILE_PREVIEW_PAGE;
-    }
-}

server/src/main/java/cn/keking/service/impl/MediaFilePreviewImpl.java

@@ -4,17 +4,17 @@ import cn.keking.config.ConfigConstants;
 import cn.keking.model.FileAttribute;
 import cn.keking.model.FileType;
 import cn.keking.model.ReturnResponse;
-import cn.keking.service.FilePreview;
-import cn.keking.utils.ConfigUtils;
-import cn.keking.utils.DownloadUtils;
 import cn.keking.service.FileHandlerService;
-import cn.keking.web.filter.BaseUrlFilter;
+import cn.keking.service.FilePreview;
+import cn.keking.utils.DownloadUtils;
 import org.bytedeco.ffmpeg.global.avcodec;
 import org.bytedeco.javacv.FFmpegFrameGrabber;
 import org.bytedeco.javacv.FFmpegFrameRecorder;
 import org.bytedeco.javacv.Frame;
 import org.springframework.stereotype.Service;
 import org.springframework.ui.Model;
+import org.springframework.util.ObjectUtils;
+
 import java.io.File;
 
 /**
@@ -28,8 +28,7 @@ public class MediaFilePreviewImpl implements FilePreview {
 
     private final FileHandlerService fileHandlerService;
     private final OtherFilePreviewImpl otherFilePreview;
-
-    private static Object LOCK=new Object();
+    private static final String mp4 = "mp4";
 
     public MediaFilePreviewImpl(FileHandlerService fileHandlerService, OtherFilePreviewImpl otherFilePreview) {
         this.fileHandlerService = fileHandlerService;
@@ -38,129 +37,128 @@ public class MediaFilePreviewImpl implements FilePreview {
 
     @Override
     public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
-        // 不是http开头，浏览器不能直接访问，需下载到本地
-        if (url != null && !url.toLowerCase().startsWith("http")) {
-            ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileAttribute.getName());
-            if (response.isFailure()) {
-                return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
-            } else {
-                url=BaseUrlFilter.getBaseUrl() + fileHandlerService.getRelativePath(response.getContent());
-                fileAttribute.setUrl(url);
+        String fileName = fileAttribute.getName();
+        String suffix = fileAttribute.getSuffix();
+        String cacheName = fileAttribute.getCacheName();
+        String outFilePath = fileAttribute.getOutFilePath();
+        boolean forceUpdatedCache = fileAttribute.forceUpdatedCache();
+        FileType type = fileAttribute.getType();
+        String[] mediaTypesConvert = FileType.MEDIA_CONVERT_TYPES;  //获取支持的转换格式
+        boolean mediaTypes = false;
+        for (String temp : mediaTypesConvert) {
+            if (suffix.equals(temp)) {
+                mediaTypes = true;
+                break;
             }
         }
-
-        if(checkNeedConvert(fileAttribute.getSuffix())){
-            url=convertUrl(fileAttribute);
-        }else{
-            //正常media类型
-            String[] medias = ConfigConstants.getMedia();
-            for(String media:medias){
-                if(media.equals(fileAttribute.getSuffix())){
-                    model.addAttribute("mediaUrl", url);
-                    return MEDIA_FILE_PREVIEW_PAGE;
+        if (!url.toLowerCase().startsWith("http") || checkNeedConvert(mediaTypes)) {  //不是http协议的 //   开启转换方式并是支持转换格式的
+            if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(cacheName) || !ConfigConstants.isCacheEnabled()) {  //查询是否开启缓存
+                ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
+                if (response.isFailure()) {
+                    return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
                 }
-            }
-            return otherFilePreview.notSupportedFile(model, fileAttribute, "暂不支持");
-        }
-        model.addAttribute("mediaUrl", url);
-        return MEDIA_FILE_PREVIEW_PAGE;
-    }
-
-    /**
-     * 检查视频文件处理逻辑
-     * 返回处理过后的url
-     * @return url
-     */
-    private String convertUrl(FileAttribute fileAttribute) {
-        String url = fileAttribute.getUrl();
-        if(fileHandlerService.listConvertedMedias().containsKey(url)){
-            url= fileHandlerService.getConvertedMedias(url);
-        }else{
-            if(!fileHandlerService.listConvertedMedias().containsKey(url)){
-                synchronized(LOCK){
-                    if(!fileHandlerService.listConvertedMedias().containsKey(url)){
-                        String convertedUrl=convertToMp4(fileAttribute);
-                        //加入缓存
-                        fileHandlerService.addConvertedMedias(url,convertedUrl);
-                        url=convertedUrl;
+                String filePath = response.getContent();
+                String convertedUrl = null;
+                try {
+                    if (mediaTypes) {
+                        convertedUrl = convertToMp4(filePath, outFilePath, fileAttribute);
+                    } else {
+                        convertedUrl = outFilePath;  //其他协议的  不需要转换方式的文件 直接输出
                     }
+                } catch (Exception e) {
+                    e.printStackTrace();
                 }
+                if (convertedUrl == null) {
+                    return otherFilePreview.notSupportedFile(model, fileAttribute, "视频转换异常，请联系管理员");
+                }
+                if (ConfigConstants.isCacheEnabled()) {
+                    // 加入缓存
+                    fileHandlerService.addConvertedFile(cacheName, fileHandlerService.getRelativePath(outFilePath));
+                }
+                model.addAttribute("mediaUrl", fileHandlerService.getRelativePath(outFilePath));
+            } else {
+                model.addAttribute("mediaUrl", fileHandlerService.listConvertedFiles().get(cacheName));
             }
+            return MEDIA_FILE_PREVIEW_PAGE;
         }
-        return url;
+        if (type.equals(FileType.MEDIA)) {  // 支持输出 只限默认格式
+            model.addAttribute("mediaUrl", url);
+            return MEDIA_FILE_PREVIEW_PAGE;
+        }
+        return otherFilePreview.notSupportedFile(model, fileAttribute, "系统还不支持该格式文件的在线预览");
     }
 
     /**
      * 检查视频文件转换是否已开启，以及当前文件是否需要转换
+     *
      * @return
      */
-    private boolean checkNeedConvert(String suffix) {
+    private boolean checkNeedConvert(boolean mediaTypes) {
         //1.检查开关是否开启
-        if("false".equals(ConfigConstants.getMediaConvertDisable())){
-            return false;
-        }
-        //2.检查当前文件是否需要转换
-        String[] mediaTypesConvert = FileType.MEDIA_TYPES_CONVERT;
-        String type = suffix;
-        for(String temp : mediaTypesConvert){
-            if(type.equals(temp)){
-                return true;
-            }
+        if ("true".equals(ConfigConstants.getMediaConvertDisable())) {
+            return mediaTypes;
         }
         return false;
     }
 
-    /**
-     * 将浏览器不兼容视频格式转换成MP4
-     * @param fileAttribute
-     * @return
-     */
-    private static String convertToMp4(FileAttribute fileAttribute) {
-
-        //说明：这里做临时处理，取上传文件的目录
-        String homePath = ConfigUtils.getHomePath();
-        String filePath = homePath+File.separator+"file"+File.separator+"demo"+File.separator+fileAttribute.getName();
-        String convertFileName=fileAttribute.getUrl().replace(fileAttribute.getSuffix(),"mp4");
-
-        File file=new File(filePath);
-        FFmpegFrameGrabber frameGrabber = new FFmpegFrameGrabber(file);
-        String fileName = null;
-        Frame captured_frame = null;
+    private static String convertToMp4(String filePath, String outFilePath, FileAttribute fileAttribute) throws Exception {
+        FFmpegFrameGrabber frameGrabber = FFmpegFrameGrabber.createDefault(filePath);
+        Frame captured_frame;
         FFmpegFrameRecorder recorder = null;
         try {
-            fileName = file.getAbsolutePath().replace(fileAttribute.getSuffix(),"mp4");
-            File desFile=new File(fileName);
-            //判断一下防止穿透缓存
-            if(desFile.exists()){
-                return fileName;
+            File desFile = new File(outFilePath);
+            //判断一下防止重复转换
+            if (desFile.exists()) {
+                return outFilePath;
             }
-
-            frameGrabber.start();
-            recorder = new FFmpegFrameRecorder(fileName, frameGrabber.getImageWidth(), frameGrabber.getImageHeight(), frameGrabber.getAudioChannels());
-            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264); //avcodec.AV_CODEC_ID_H264  //AV_CODEC_ID_MPEG4
-            recorder.setFormat("mp4");
-            recorder.setFrameRate(frameGrabber.getFrameRate());
-            //recorder.setSampleFormat(frameGrabber.getSampleFormat()); //
-            recorder.setSampleRate(frameGrabber.getSampleRate());
-
-            recorder.setAudioChannels(frameGrabber.getAudioChannels());
-            recorder.setFrameRate(frameGrabber.getFrameRate());
-            recorder.start();
-            while ((captured_frame = frameGrabber.grabFrame()) != null) {
-                try {
-                    recorder.setTimestamp(frameGrabber.getTimestamp());
-                    recorder.record(captured_frame);
-                } catch (Exception e) {
+            if (fileAttribute.isCompressFile()) { //判断 是压缩包的创建新的目录
+                int index = outFilePath.lastIndexOf("/");  //截取最后一个斜杠的前面的内容
+                String folder = outFilePath.substring(0, index);
+                File path = new File(folder);
+                //目录不存在 创建新的目录
+                if (!path.exists()) {
+                    path.mkdirs();
                 }
             }
-            recorder.stop();
-            recorder.release();
-            frameGrabber.stop();
+            frameGrabber.start();
+            recorder = new FFmpegFrameRecorder(outFilePath, frameGrabber.getImageWidth(), frameGrabber.getImageHeight(), frameGrabber.getAudioChannels());
+            // recorder.setImageHeight(640);
+            // recorder.setImageWidth(480);
+            recorder.setFormat(mp4);
+            recorder.setFrameRate(frameGrabber.getFrameRate());
+            recorder.setSampleRate(frameGrabber.getSampleRate());
+            //视频编码属性配置 H.264 H.265 MPEG
+            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
+            //设置视频比特率,单位:b
+            recorder.setVideoBitrate(frameGrabber.getVideoBitrate());
+            recorder.setAspectRatio(frameGrabber.getAspectRatio());
+            // 设置音频通用编码格式
+            recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
+            //设置音频比特率,单位:b (比特率越高，清晰度/音质越好，当然文件也就越大 128000 = 182kb)
+            recorder.setAudioBitrate(frameGrabber.getAudioBitrate());
+            recorder.setAudioOptions(frameGrabber.getAudioOptions());
+            recorder.setAudioChannels(frameGrabber.getAudioChannels());
+            recorder.start();
+            while (true) {
+                captured_frame = frameGrabber.grabFrame();
+                if (captured_frame == null) {
+                    System.out.println("转码完成:" + filePath);
+                    break;
+                }
+                recorder.record(captured_frame);
+            }
         } catch (Exception e) {
             e.printStackTrace();
+            return null;
+        } finally {
+            if (recorder != null) {   //关闭
+                recorder.stop();
+                recorder.close();
+            }
+            frameGrabber.stop();
+            frameGrabber.close();
         }
-        //是否删除源文件
-        //file.delete();
-        return convertFileName;
+        return outFilePath;
     }
+
 }

server/src/main/java/cn/keking/service/impl/OfficeFilePreviewImpl.java

@@ -9,6 +9,7 @@ import cn.keking.service.OfficeToPdfService;
 import cn.keking.utils.DownloadUtils;
 import cn.keking.utils.KkFileUtils;
 import cn.keking.utils.OfficeUtils;
+import cn.keking.utils.WebUtils;
 import cn.keking.web.filter.BaseUrlFilter;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.poi.EncryptedDocumentException;
@@ -18,7 +19,6 @@ import org.springframework.ui.Model;
 import org.springframework.util.StringUtils;
 
 import java.io.IOException;
-import java.net.URLEncoder;
 import java.util.List;
 
 /**
@@ -30,7 +30,6 @@ public class OfficeFilePreviewImpl implements FilePreview {
 
     public static final String OFFICE_PREVIEW_TYPE_IMAGE = "image";
     public static final String OFFICE_PREVIEW_TYPE_ALL_IMAGES = "allImages";
-    private static final String FILE_DIR = ConfigConstants.getFileDir();
     private static final String OFFICE_PASSWORD_MSG = "password";
 
     private final FileHandlerService fileHandlerService;
@@ -47,58 +46,35 @@ public class OfficeFilePreviewImpl implements FilePreview {
     public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
         // 预览Type，参数传了就取参数的，没传取系统默认
         String officePreviewType = fileAttribute.getOfficePreviewType();
+        boolean userToken = fileAttribute.getUsePasswordCache();
         String baseUrl = BaseUrlFilter.getBaseUrl();
-        String suffix = fileAttribute.getSuffix();
-        String fileName = fileAttribute.getName();
-        String filePassword = fileAttribute.getFilePassword();
-        boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();
-        String userToken = fileAttribute.getUserToken();
-        boolean isHtml = suffix.equalsIgnoreCase("xls") || suffix.equalsIgnoreCase("xlsx") || suffix.equalsIgnoreCase("csv") || suffix.equalsIgnoreCase("xlsm") || suffix.equalsIgnoreCase("xlt") || suffix.equalsIgnoreCase("xltm") || suffix.equalsIgnoreCase("et") || suffix.equalsIgnoreCase("ett") || suffix.equalsIgnoreCase("xlam");
-        String pdfName = fileName.substring(0, fileName.lastIndexOf(".") ) + suffix +"." +(isHtml ? "html" : "pdf"); //生成文件添加类型后缀 防止同名文件
-        String cacheFileName = userToken == null ? pdfName : userToken + "_" + pdfName;
-        String outFilePath = FILE_DIR + cacheFileName;
+        String suffix = fileAttribute.getSuffix();  //获取文件后缀
+        String fileName = fileAttribute.getName(); //获取文件原始名称
+        String filePassword = fileAttribute.getFilePassword(); //获取密码
+        boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();  //是否启用强制更新命令
+        boolean isHtmlView = fileAttribute.isHtmlView();  //xlsx  转换成html
+        String cacheName = fileAttribute.getCacheName();  //转换后的文件名
+        String outFilePath = fileAttribute.getOutFilePath();  //转换后生成文件的路径
         if (!officePreviewType.equalsIgnoreCase("html")) {
             if (ConfigConstants.getOfficeTypeWeb() .equalsIgnoreCase("web")) {
                 if (suffix.equalsIgnoreCase("xlsx")) {
-                    model.addAttribute("pdfUrl", url);
+                    model.addAttribute("pdfUrl", KkFileUtils.htmlEscape(url)); //特殊符号处理
                     return XLSX_FILE_PREVIEW_PAGE;
                 }
+                if (suffix.equalsIgnoreCase("csv")) {
+                    model.addAttribute("csvUrl", KkFileUtils.htmlEscape(url));
+                    return CSV_FILE_PREVIEW_PAGE;
+                }
             }
         }
-        if (forceUpdatedCache|| !fileHandlerService.listConvertedFiles().containsKey(pdfName) || !ConfigConstants.isCacheEnabled()) {
+        if (forceUpdatedCache|| !fileHandlerService.listConvertedFiles().containsKey(cacheName) || !ConfigConstants.isCacheEnabled()) {
         // 下载远程文件到本地，如果文件在本地已存在不会重复下载
         ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
         if (response.isFailure()) {
             return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
         }
-        String filePath = response.getContent();
-        /*
-         * 1. 缓存判断-如果文件已经进行转换过，就直接返回，否则执行转换
-         * 2. 缓存判断-加密文件基于userToken进行缓存，如果没有就不缓存
-         */
-        boolean isCached = false;
-        boolean isUseCached = false;
-        boolean isPwdProtectedOffice = false;
-        if (ConfigConstants.isCacheEnabled()) {
-            // 全局开启缓存
-            isUseCached = true;
-            if (!forceUpdatedCache && fileHandlerService.listConvertedFiles().containsKey(cacheFileName)) {
-                // 存在缓存
-                isCached = true;
-            }
-            if (OfficeUtils.isPwdProtected(filePath)) {
-                isPwdProtectedOffice = true;
-                if (!StringUtils.hasLength(userToken)) {
-                    // 不缓存没有userToken的加密文件
-                    isUseCached = false;
-                }
-            }
-        } else {
-            isPwdProtectedOffice = OfficeUtils.isPwdProtected(filePath);
-        }
-
-        if (!isCached) {
-            // 没有缓存执行转换逻辑
+            String filePath = response.getContent();
+            boolean  isPwdProtectedOffice =  OfficeUtils.isPwdProtected(filePath);    // 判断是否加密文件
             if (isPwdProtectedOffice && !StringUtils.hasLength(filePassword)) {
                 // 加密文件需要密码
                 model.addAttribute("needFilePassword", true);
@@ -114,40 +90,37 @@ public class OfficeFilePreviewImpl implements FilePreview {
                             model.addAttribute("filePasswordError", true);
                             return EXEL_FILE_PREVIEW_PAGE;
                         }
-
                         return otherFilePreview.notSupportedFile(model, fileAttribute, "抱歉，该文件版本不兼容，文件版本错误。");
                     }
-
-                    if (isHtml) {
+                    if (isHtmlView) {
                         // 对转换后的文件进行操作(改变编码方式)
                         fileHandlerService.doActionConvertedFile(outFilePath);
                     }
                     //是否保留OFFICE源文件
-                    if (ConfigConstants.getDeleteSourceFile()) {
+                    if (!fileAttribute.isCompressFile() && ConfigConstants.getDeleteSourceFile()) {
                         KkFileUtils.deleteFileByPath(filePath);
                     }
-                    if (isUseCached) {
+                    if (userToken || !isPwdProtectedOffice) {
                         // 加入缓存
-                        fileHandlerService.addConvertedFile(cacheFileName, fileHandlerService.getRelativePath(outFilePath));
+                        fileHandlerService.addConvertedFile(cacheName, fileHandlerService.getRelativePath(outFilePath));
                     }
                 }
             }
+
         }
+        if (!isHtmlView && baseUrl != null && (OFFICE_PREVIEW_TYPE_IMAGE.equals(officePreviewType) || OFFICE_PREVIEW_TYPE_ALL_IMAGES.equals(officePreviewType))) {
+            return getPreviewType(model, fileAttribute, officePreviewType, cacheName, outFilePath, fileHandlerService, OFFICE_PREVIEW_TYPE_IMAGE, otherFilePreview);
         }
-        if (!isHtml && baseUrl != null && (OFFICE_PREVIEW_TYPE_IMAGE.equals(officePreviewType) || OFFICE_PREVIEW_TYPE_ALL_IMAGES.equals(officePreviewType))) {
-            return getPreviewType(model, fileAttribute, officePreviewType, baseUrl, cacheFileName, outFilePath, fileHandlerService, OFFICE_PREVIEW_TYPE_IMAGE, otherFilePreview);
-        }
-        cacheFileName =   URLEncoder.encode(cacheFileName).replaceAll("\\+", "%20");
-        model.addAttribute("pdfUrl", cacheFileName);
-        return isHtml ? EXEL_FILE_PREVIEW_PAGE : PDF_FILE_PREVIEW_PAGE;
+        model.addAttribute("pdfUrl", WebUtils.encodeFileName(cacheName));  //输出转义文件名 方便url识别
+        return isHtmlView ? EXEL_FILE_PREVIEW_PAGE : PDF_FILE_PREVIEW_PAGE;
     }
 
-    static String getPreviewType(Model model, FileAttribute fileAttribute, String officePreviewType, String baseUrl, String pdfName, String outFilePath, FileHandlerService fileHandlerService, String officePreviewTypeImage, OtherFilePreviewImpl otherFilePreview) {
+    static String getPreviewType(Model model, FileAttribute fileAttribute, String officePreviewType, String pdfName, String outFilePath, FileHandlerService fileHandlerService, String officePreviewTypeImage, OtherFilePreviewImpl otherFilePreview) {
         String suffix = fileAttribute.getSuffix();
         boolean isPPT = suffix.equalsIgnoreCase("ppt") || suffix.equalsIgnoreCase("pptx");
         List<String> imageUrls = null;
         try {
-            imageUrls =  fileHandlerService.pdf2jpg(outFilePath, pdfName, fileAttribute);
+            imageUrls =  fileHandlerService.pdf2jpg(outFilePath,outFilePath, pdfName, fileAttribute);
         } catch (Exception e) {
             Throwable[] throwableArray = ExceptionUtils.getThrowables(e);
             for (Throwable throwable : throwableArray) {

server/src/main/java/cn/keking/service/impl/PdfFilePreviewImpl.java

@@ -3,16 +3,16 @@ package cn.keking.service.impl;
 import cn.keking.config.ConfigConstants;
 import cn.keking.model.FileAttribute;
 import cn.keking.model.ReturnResponse;
+import cn.keking.service.FileHandlerService;
 import cn.keking.service.FilePreview;
 import cn.keking.utils.DownloadUtils;
-import cn.keking.service.FileHandlerService;
+import cn.keking.utils.WebUtils;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.poi.EncryptedDocumentException;
 import org.springframework.stereotype.Service;
 import org.springframework.ui.Model;
 
 import java.io.IOException;
-import java.net.URLEncoder;
 import java.util.List;
 
 /**
@@ -24,37 +24,34 @@ public class PdfFilePreviewImpl implements FilePreview {
 
     private final FileHandlerService fileHandlerService;
     private final OtherFilePreviewImpl otherFilePreview;
-    private static final String FILE_DIR = ConfigConstants.getFileDir();
     private static final String PDF_PASSWORD_MSG = "password";
-
     public PdfFilePreviewImpl(FileHandlerService fileHandlerService, OtherFilePreviewImpl otherFilePreview) {
         this.fileHandlerService = fileHandlerService;
         this.otherFilePreview = otherFilePreview;
     }
-
     @Override
     public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
-        String fileName = fileAttribute.getName();
-        String officePreviewType = fileAttribute.getOfficePreviewType();
-        boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();
-        String pdfName = fileName.substring(0, fileName.lastIndexOf(".") + 1) + "pdf";
-        String outFilePath = FILE_DIR + pdfName;
+        String pdfName = fileAttribute.getName();  //获取原始文件名
+        String officePreviewType = fileAttribute.getOfficePreviewType(); //转换类型
+        boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();  //是否启用强制更新命令
+        String outFilePath = fileAttribute.getOutFilePath();  //生成的文件路径
+        String originFilePath = fileAttribute.getOriginFilePath();  //原始文件路径
         if (OfficeFilePreviewImpl.OFFICE_PREVIEW_TYPE_IMAGE.equals(officePreviewType) || OfficeFilePreviewImpl.OFFICE_PREVIEW_TYPE_ALL_IMAGES.equals(officePreviewType)) {
             //当文件不存在时，就去下载
             if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(pdfName) || !ConfigConstants.isCacheEnabled()) {
-                ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
+                ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, pdfName);
                 if (response.isFailure()) {
                     return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
                 }
-                outFilePath = response.getContent();
+                originFilePath = response.getContent();
                 if (ConfigConstants.isCacheEnabled()) {
                     // 加入缓存
-                    fileHandlerService.addConvertedFile(pdfName, fileHandlerService.getRelativePath(outFilePath));
+                    fileHandlerService.addConvertedFile(pdfName, fileHandlerService.getRelativePath(originFilePath));
                 }
             }
             List<String> imageUrls;
             try {
-                imageUrls = fileHandlerService.pdf2jpg(outFilePath, pdfName, fileAttribute);
+                imageUrls = fileHandlerService.pdf2jpg(originFilePath,outFilePath, pdfName, fileAttribute);
             } catch (Exception e) {
                 Throwable[] throwableArray = ExceptionUtils.getThrowables(e);
                 for (Throwable throwable : throwableArray) {
@@ -91,8 +88,7 @@ public class PdfFilePreviewImpl implements FilePreview {
                         fileHandlerService.addConvertedFile(pdfName, fileHandlerService.getRelativePath(outFilePath));
                     }
                 } else {
-                    pdfName =   URLEncoder.encode(pdfName).replaceAll("\\+", "%20");
-                    model.addAttribute("pdfUrl", pdfName);
+                    model.addAttribute("pdfUrl", WebUtils.encodeFileName(pdfName));
                 }
             } else {
                 model.addAttribute("pdfUrl", url);

server/src/main/java/cn/keking/service/impl/PictureFilePreviewImpl.java

@@ -1,10 +1,7 @@
 package cn.keking.service.impl;
 
 import cn.keking.model.FileAttribute;
-import cn.keking.model.ReturnResponse;
 import cn.keking.service.FileHandlerService;
-import cn.keking.service.FilePreview;
-import cn.keking.utils.DownloadUtils;
 import cn.keking.utils.KkFileUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.ui.Model;
@@ -21,12 +18,10 @@ import java.util.List;
 public class PictureFilePreviewImpl extends CommonPreviewImpl {
 
     private final FileHandlerService fileHandlerService;
-    private final OtherFilePreviewImpl otherFilePreview;
 
     public PictureFilePreviewImpl(FileHandlerService fileHandlerService, OtherFilePreviewImpl otherFilePreview) {
         super(fileHandlerService, otherFilePreview);
         this.fileHandlerService = fileHandlerService;
-        this.otherFilePreview = otherFilePreview;
     }
 
     @Override
@@ -34,8 +29,8 @@ public class PictureFilePreviewImpl extends CommonPreviewImpl {
         url= KkFileUtils.htmlEscape(url);
         List<String> imgUrls = new ArrayList<>();
         imgUrls.add(url);
-        String fileKey = fileAttribute.getFileKey();
-        List<String> zipImgUrls = fileHandlerService.getImgCache(fileKey);
+        String compressFileKey = fileAttribute.getCompressFileKey();
+        List<String> zipImgUrls = fileHandlerService.getImgCache(compressFileKey);
         if (!CollectionUtils.isEmpty(zipImgUrls)) {
             imgUrls.addAll(zipImgUrls);
         }

server/src/main/java/cn/keking/service/impl/SimTextFilePreviewImpl.java

@@ -30,12 +30,12 @@ public class SimTextFilePreviewImpl implements FilePreview {
         this.fileHandlerService = fileHandlerService;
         this.otherFilePreview = otherFilePreview;
     }
-    private static final String FILE_DIR = ConfigConstants.getFileDir();
+
     @Override
     public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
         String fileName = fileAttribute.getName();
         boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();
-        String filePath = FILE_DIR + fileName;
+        String filePath = fileAttribute.getOriginFilePath();
         if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(fileName) || !ConfigConstants.isCacheEnabled()) {
             ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
             if (response.isFailure()) {

server/src/main/java/cn/keking/service/impl/TiffFilePreviewImpl.java

@@ -8,13 +8,10 @@ import cn.keking.service.FilePreview;
 import cn.keking.utils.ConvertPicUtil;
 import cn.keking.utils.DownloadUtils;
 import cn.keking.utils.KkFileUtils;
-import cn.keking.web.filter.BaseUrlFilter;
+import cn.keking.utils.WebUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.ui.Model;
-import org.springframework.util.StringUtils;
 
-import java.io.File;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -32,75 +29,99 @@ public class TiffFilePreviewImpl implements FilePreview {
         this.fileHandlerService = fileHandlerService;
         this.otherFilePreview = otherFilePreview;
     }
-    private final String fileDir = ConfigConstants.getFileDir();
     @Override
     public String filePreviewHandle(String url, Model model, FileAttribute fileAttribute) {
         String fileName = fileAttribute.getName();
-        String baseUrl = BaseUrlFilter.getBaseUrl();
         String tifPreviewType = ConfigConstants.getTifPreviewType();
-        String tifOnLinePreviewType = fileAttribute.getTifPreviewType();
-        String suffix = fileAttribute.getSuffix();
+        String cacheName =  fileAttribute.getCacheName();
+        String outFilePath = fileAttribute.getOutFilePath();
         boolean forceUpdatedCache=fileAttribute.forceUpdatedCache();
-        if (StringUtils.hasText(tifOnLinePreviewType)) {
-            tifPreviewType = tifOnLinePreviewType;
-        }
-        if ("tif".equalsIgnoreCase(tifPreviewType)) {
-            model.addAttribute("currentUrl", url);
-            return TIFF_FILE_PREVIEW_PAGE;
-        } else if ("jpg".equalsIgnoreCase(tifPreviewType) || "pdf".equalsIgnoreCase(tifPreviewType)) {
-            String pdfName = fileName.substring(0, fileName.lastIndexOf(".")) + suffix +"." + "pdf" ; //生成文件添加类型后缀 防止同名文件
-            String jpgName = fileName.substring(0, fileName.lastIndexOf(".")) + suffix; //生成文件添加类型后缀 防止同名文件
-            String strLocalTif = fileDir + fileName;
-            String outFilePath = fileDir + pdfName;
-            if ("pdf".equalsIgnoreCase(tifPreviewType)) {
-                //当文件不存在时，就去下载
-                if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(pdfName) || !ConfigConstants.isCacheEnabled()) {
-                    ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
-                    if (response.isFailure()) {
-                        return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
-                    }
-                    String filePath = response.getContent();
-                    if (ConvertPicUtil.convertJpg2Pdf(filePath, outFilePath)) {
-                        //是否保留TIFF源文件
-                        if (ConfigConstants.getDeleteSourceFile()) {
-                            KkFileUtils.deleteFileByPath(filePath);
+        if ("jpg".equalsIgnoreCase(tifPreviewType) || "pdf".equalsIgnoreCase(tifPreviewType)) {
+            if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(cacheName) || !ConfigConstants.isCacheEnabled()) {
+                ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
+                if (response.isFailure()) {
+                    return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
+                }
+                String filePath = response.getContent();
+                if ("pdf".equalsIgnoreCase(tifPreviewType)) {
+                    try {
+                       ConvertPicUtil.convertJpg2Pdf(filePath, outFilePath);
+                    } catch (Exception e) {
+                        if (e.getMessage().contains("Bad endianness tag (not 0x4949 or 0x4d4d)") ) {
+                            model.addAttribute("imgUrls", url);
+                            model.addAttribute("currentUrl", url);
+                            return PICTURE_FILE_PREVIEW_PAGE;
+                        }else {
+                            return otherFilePreview.notSupportedFile(model, fileAttribute, "TIF转pdf异常，请联系系统管理员!" );
                         }
-                        if (ConfigConstants.isCacheEnabled()) {
-                            // 加入缓存
-                            fileHandlerService.addConvertedFile(pdfName, fileHandlerService.getRelativePath(outFilePath));
-                        }
-                        model.addAttribute("pdfUrl", pdfName);
-                        return PDF_FILE_PREVIEW_PAGE;
-                    } else {
-                        return NOT_SUPPORTED_FILE_PAGE;
                     }
-                } else {
-                    model.addAttribute("pdfUrl", pdfName);
+                    //是否保留TIFF源文件
+                    if (!fileAttribute.isCompressFile() && ConfigConstants.getDeleteSourceFile()) {
+                      //  KkFileUtils.deleteFileByPath(filePath);
+                    }
+                    if (ConfigConstants.isCacheEnabled()) {
+                        // 加入缓存
+                        fileHandlerService.addConvertedFile(cacheName, fileHandlerService.getRelativePath(outFilePath));
+                    }
+                    model.addAttribute("pdfUrl", WebUtils.encodeFileName(cacheName));
                     return PDF_FILE_PREVIEW_PAGE;
+                }else {
+                    // 将tif转换为jpg，返回转换后的文件路径、文件名的list
+                    List<String> listPic2Jpg;
+                    try {
+                        listPic2Jpg = ConvertPicUtil.convertTif2Jpg(filePath, outFilePath,forceUpdatedCache);
+                    } catch (Exception e) {
+                        if (e.getMessage().contains("Bad endianness tag (not 0x4949 or 0x4d4d)") ) {
+                            model.addAttribute("imgUrls", url);
+                            model.addAttribute("currentUrl", url);
+                            return PICTURE_FILE_PREVIEW_PAGE;
+                        }else {
+                            return otherFilePreview.notSupportedFile(model, fileAttribute, "TIF转JPG异常，请联系系统管理员!" );
+                        }
+                    }
+                    //是否保留源文件,转换失败保留源文件,转换成功删除源文件
+                    if(!fileAttribute.isCompressFile() &&  ConfigConstants.getDeleteSourceFile()) {
+                        KkFileUtils.deleteFileByPath(filePath);
+                    }
+                    if (ConfigConstants.isCacheEnabled()) {
+                        // 加入缓存
+                        fileHandlerService.putImgCache(cacheName, listPic2Jpg);
+                        fileHandlerService.addConvertedFile(cacheName, fileHandlerService.getRelativePath(outFilePath));
+                    }
+                    model.addAttribute("imgUrls", listPic2Jpg);
+                    model.addAttribute("currentUrl", listPic2Jpg.get(0));
+                    return PICTURE_FILE_PREVIEW_PAGE;
+                }
+            }
+            if ("pdf".equalsIgnoreCase(tifPreviewType)) {
+                model.addAttribute("pdfUrl", WebUtils.encodeFileName(cacheName));
+                return PDF_FILE_PREVIEW_PAGE;
+            }
+            else if ("jpg".equalsIgnoreCase(tifPreviewType)) {
+                model.addAttribute("imgUrls",  fileHandlerService.getImgCache(cacheName));
+                model.addAttribute("currentUrl", fileHandlerService.getImgCache(cacheName).get(0));
+                return PICTURE_FILE_PREVIEW_PAGE;
+            }
+        }
+        // 不是http开头，浏览器不能直接访问，需下载到本地
+        if (url != null && !url.toLowerCase().startsWith("http")) {
+            if (forceUpdatedCache || !fileHandlerService.listConvertedFiles().containsKey(fileName) || !ConfigConstants.isCacheEnabled()) {
+                ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
+                if (response.isFailure()) {
+                    return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
+                }
+                model.addAttribute("currentUrl", fileHandlerService.getRelativePath(response.getContent()));
+                if (ConfigConstants.isCacheEnabled()) {
+                    // 加入缓存
+                    fileHandlerService.addConvertedFile(fileName, fileHandlerService.getRelativePath(outFilePath));
                 }
             } else {
-                File fileTiff = new File(strLocalTif);
-                // 如果本地不存在这个tif文件，则下载
-                if (!fileTiff.exists()) {
-                    ReturnResponse<String> response = DownloadUtils.downLoad(fileAttribute, fileName);
-                    if (response.isFailure()) {
-                        return otherFilePreview.notSupportedFile(model, fileAttribute, response.getMsg());
-                    }
-                    strLocalTif = response.getContent();
-                }
-                // 将tif转换为jpg，返回转换后的文件路径、文件名的list
-                List<String> listPic2Jpg = ConvertPicUtil.convertTif2Jpg(strLocalTif, jpgName);
-                // 将返回页面的图片url的list对象
-                List<String> listImageUrls = new ArrayList<>();
-                // 循环，拼装url的list对象
-                for (String strJpg : listPic2Jpg) {
-                    listImageUrls.add(baseUrl + strJpg);
-                }
-                model.addAttribute("imgUrls", listImageUrls);
-                model.addAttribute("currentUrl", listImageUrls.get(0));
+                model.addAttribute("currentUrl",  WebUtils.encodeFileName(fileName));
             }
-            return PICTURE_FILE_PREVIEW_PAGE;
+            return TIFF_FILE_PREVIEW_PAGE;
         }
-        return NOT_SUPPORTED_FILE_PAGE;
+        model.addAttribute("currentUrl", url);
+        return TIFF_FILE_PREVIEW_PAGE;
     }
 }
+

server/src/main/java/cn/keking/utils/CaptchaUtil.java

@@ -0,0 +1,74 @@
+package cn.keking.utils;
+
+import org.springframework.util.Assert;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.Random;
+
+public class CaptchaUtil {
+
+    public static final String CAPTCHA_CODE = "captchaCode";
+    public static final String CAPTCHA_GENERATE_TIME = "captchaTime";
+
+    private static final int WIDTH = 100;// 定义图片的width
+    private static final int HEIGHT = 30;// 定义图片的height
+    private static final int CODE_LENGTH = 4;// 定义图片上显示验证码的个数
+    private static final int FONT_HEIGHT = 28;
+    private static final char[] CODE_SEQUENCE = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'M', 'N', 'P', 'Q', 'R', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', '2', '3', '4', '5', '6', '7', '8', '9'};
+
+    /**
+     * 指定验证码、生成验证码图片。
+     * @param captchaCode 验证码
+     * @return 验证码图片
+     */
+    public static BufferedImage generateCaptchaPic(final String captchaCode) {
+        Assert.notNull(captchaCode, "captchaCode must not be null");
+        // 定义图像buffer
+        BufferedImage buffImg = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
+        Graphics gd = buffImg.getGraphics();
+        Random random = new Random();
+        // 将图像填充为白色
+        gd.setColor(Color.WHITE);
+        gd.fillRect(0, 0, WIDTH, HEIGHT);
+        Font font = new Font("Times New Roman", Font.BOLD, FONT_HEIGHT);
+        gd.setFont(font);
+        // 画边框。
+        gd.setColor(Color.BLACK);
+        gd.drawRect(0, 0, WIDTH - 1, HEIGHT - 1);
+
+        // 随机产生40条干扰线，使图象中的认证码不易被其它程序探测到。
+        gd.setColor(Color.BLACK);
+        for (int i = 0; i < 30; i++) {
+            int x = random.nextInt(WIDTH);
+            int y = random.nextInt(HEIGHT);
+            int xl = random.nextInt(12);
+            int yl = random.nextInt(12);
+            gd.drawLine(x, y, x + xl, y + yl);
+        }
+        // randomCode用于保存随机产生的验证码，以便用户登录后进行验证。
+        int red, green, blue;
+        // 产生随机的颜色分量来构造颜色值，这样输出的每位数字的颜色值都将不同。
+        red = random.nextInt(255);
+        green = random.nextInt(255);
+        blue = random.nextInt(255);
+        // 用随机产生的颜色将验证码绘制到图像中。
+        gd.setColor(new Color(red, green, blue));
+        gd.drawString(captchaCode, 18, 27);
+        return buffImg;
+    }
+
+    /**
+     * 生成随机字符串。
+     * @return 字符串
+     */
+    public static String generateCaptchaCode() {
+        Random random = new Random();
+        StringBuilder randomCode = new StringBuilder();
+        for (int i = 0; i < CODE_LENGTH; i++) {
+            randomCode.append(CODE_SEQUENCE[random.nextInt(52)]);
+        }
+        return randomCode.toString();
+    }
+}

server/src/main/java/cn/keking/utils/ConvertPicUtil.java

@@ -1,26 +1,26 @@
 package cn.keking.utils;
 
-
 import cn.keking.config.ConfigConstants;
-
-import com.sun.media.jai.codec.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import cn.keking.web.filter.BaseUrlFilter;
 import com.itextpdf.text.Document;
 import com.itextpdf.text.Image;
 import com.itextpdf.text.io.FileChannelRandomAccessSource;
 import com.itextpdf.text.pdf.PdfWriter;
 import com.itextpdf.text.pdf.RandomAccessFileOrArray;
 import com.itextpdf.text.pdf.codec.TiffImage;
+import com.sun.media.jai.codec.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import javax.media.jai.JAI;
 import javax.media.jai.RenderedOp;
 import java.awt.image.RenderedImage;
 import java.awt.image.renderable.ParameterBlock;
 import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.RandomAccessFile;
-import java.nio.file.Files;
-import java.nio.file.Paths;
+import java.nio.channels.FileChannel;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -28,7 +28,6 @@ public class ConvertPicUtil {
 
     private static final int FIT_WIDTH = 500;
     private static final int FIT_HEIGHT = 900;
-
     private final static Logger logger = LoggerFactory.getLogger(ConvertPicUtil.class);
     private final static String fileDir = ConfigConstants.getFileDir();
     /**
@@ -38,17 +37,14 @@ public class ConvertPicUtil {
      * @param strOutputFile 输出文件的路径和文件名
      * @return boolean 是否转换成功
      */
-    public static List<String> convertTif2Jpg(String strInputFile, String strOutputFile) {
+    public static List<String> convertTif2Jpg(String strInputFile, String strOutputFile, boolean forceUpdatedCache) throws Exception {
         List<String> listImageFiles = new ArrayList<>();
-
-        if (strInputFile == null || "".equals(strInputFile.trim())) {
-            return null;
-        }
+        String baseUrl = BaseUrlFilter.getBaseUrl();
         if (!new File(strInputFile).exists()) {
             logger.info("找不到文件【" + strInputFile + "】");
             return null;
         }
-        strInputFile = strInputFile.replaceAll("\\\\", "/");
+        strOutputFile = strOutputFile.replaceAll(".jpg", "");
         FileSeekableStream fileSeekStream = null;
         try {
             JPEGEncodeParam jpegEncodeParam = new JPEGEncodeParam();
@@ -58,20 +54,18 @@ public class ConvertPicUtil {
             fileSeekStream = new FileSeekableStream(strInputFile);
             ImageDecoder imageDecoder = ImageCodec.createImageDecoder("TIFF", fileSeekStream, null);
             int intTifCount = imageDecoder.getNumPages();
-            logger.info("该tif文件共有【" + intTifCount + "】页");
-            String  strJpgPath = fileDir+strOutputFile;
+            // logger.info("该tif文件共有【" + intTifCount + "】页");
             // 处理目标文件夹，如果不存在则自动创建
-            File fileJpgPath = new File(strJpgPath);
+            File fileJpgPath = new File(strOutputFile);
             if (!fileJpgPath.exists() && !fileJpgPath.mkdirs()) {
-                logger.error("{} 创建失败", strJpgPath);
+                logger.error("{} 创建失败", strOutputFile);
             }
             // 循环，处理每页tif文件，转换为jpg
             for (int i = 0; i < intTifCount; i++) {
-                String strJpg= strJpgPath + "/" + i + ".jpg";
-                String strJpgUrl = strOutputFile + "/" + i + ".jpg";
+                String strJpg= strOutputFile + "/" + i + ".jpg";
                 File fileJpg = new File(strJpg);
                 // 如果文件不存在，则生成
-                if (!fileJpg.exists()) {
+                if (forceUpdatedCache|| !fileJpg.exists()) {
                     RenderedImage renderedImage = imageDecoder.decodeAsRenderedImage(i);
                     ParameterBlock pb = new ParameterBlock();
                     pb.addSource(renderedImage);
@@ -80,24 +74,22 @@ public class ConvertPicUtil {
                     pb.add(jpegEncodeParam);
                     RenderedOp renderedOp = JAI.create("filestore", pb);
                     renderedOp.dispose();
-                    logger.info("每页分别保存至： " + fileJpg.getCanonicalPath());
+                    // logger.info("每页分别保存至： " + fileJpg.getCanonicalPath());
                 }
-                listImageFiles.add(strJpgUrl);
+                strJpg = baseUrl+strJpg.replace(fileDir, "");
+                listImageFiles.add(strJpg);
             }
-
-            return listImageFiles;
         } catch (IOException e) {
-            e.printStackTrace();
-            return null;
+            if (!e.getMessage().contains("Bad endianness tag (not 0x4949 or 0x4d4d)") ) {
+                logger.error("TIF转JPG异常，文件路径：" + strInputFile, e);
+            }
+            throw new Exception(e);
         } finally {
             if (fileSeekStream != null) {
-                try {
-                    fileSeekStream.close();
-                } catch (IOException e) {
-                    logger.error(e.getMessage(), e);
-                }
+                fileSeekStream.close();
             }
         }
+        return listImageFiles;
     }
 
     /**
@@ -106,44 +98,41 @@ public class ConvertPicUtil {
      * @param strJpgFile 输入的jpg的路径和文件名
      * @param strPdfFile 输出的pdf的路径和文件名
      */
-    public static boolean convertJpg2Pdf(String strJpgFile, String strPdfFile) {
-        Document document = null;
+    public static String convertJpg2Pdf(String strJpgFile, String strPdfFile) throws Exception {
+        Document document = new Document();
         RandomAccessFileOrArray rafa = null;
+        FileOutputStream outputStream = null;
         try {
-            document = new Document();
-            PdfWriter.getInstance(document, Files.newOutputStream(Paths.get(strPdfFile)));
-            document.open();
-            rafa = new RandomAccessFileOrArray(new FileChannelRandomAccessSource(new RandomAccessFile(strJpgFile, "r").getChannel()));
+            RandomAccessFile aFile = new RandomAccessFile(strJpgFile, "r");
+            FileChannel inChannel = aFile.getChannel();
+            FileChannelRandomAccessSource fcra =  new FileChannelRandomAccessSource(inChannel);
+            rafa = new RandomAccessFileOrArray(fcra);
             int pages = TiffImage.getNumberOfPages(rafa);
+            outputStream = new FileOutputStream(strPdfFile);
+            PdfWriter.getInstance(document, outputStream);
+            document.open();
             Image image;
             for (int i = 1; i <= pages; i++) {
-                try {
-                    image = TiffImage.getTiffImage(rafa, i);
-                    image.scaleToFit(FIT_WIDTH, FIT_HEIGHT);
-                    document.add(image);
-                } catch (Exception e) {
-                    document.close();
-                    rafa.close();
-                    e.printStackTrace();
-                }
+             image = TiffImage.getTiffImage(rafa, i);
+             image.scaleToFit(FIT_WIDTH, FIT_HEIGHT);
+             document.add(image);
             }
-            document.close();
-            rafa.close();
-            return true;
-        } catch (Exception e) {
-            logger.error("图片转PDF异常，图片文件路径：" + strJpgFile, e);
+        } catch (IOException e) {
+            if (!e.getMessage().contains("Bad endianness tag (not 0x4949 or 0x4d4d)") ) {
+                logger.error("TIF转JPG异常，文件路径：" + strPdfFile, e);
+            }
+            throw new Exception(e);
         } finally {
-            try {
-                if (document != null && document.isOpen()) {
-                    document.close();
-                }
-                if (rafa != null) {
-                    rafa.close();
-                }
-            } catch (IOException e) {
-                e.printStackTrace();
+            if (document != null) {
+                document.close();
+            }
+            if (rafa != null) {
+                rafa.close();
+            }
+            if (outputStream != null) {
+                outputStream.close();
             }
         }
-        return false;
+        return strPdfFile;
     }
 }

server/src/main/java/cn/keking/utils/DateUtils.java

@@ -0,0 +1,26 @@
+package cn.keking.utils;
+
+import java.time.Instant;
+
+/**
+ * @author kl (http://kailing.pub)
+ * @since 2023/8/11
+ */
+public class DateUtils {
+    /**
+     * 获取当前时间的秒级时间戳
+     * @return
+     */
+    public static long getCurrentSecond() {
+       return Instant.now().getEpochSecond();
+    }
+
+    /**
+     * 计算当前时间与指定时间的秒级时间戳差值
+     * @param datetime 指定时间
+     * @return 差值
+     */
+    public static long calculateCurrentTimeDifference(long datetime) {
+        return getCurrentSecond() - datetime;
+    }
+}

server/src/main/java/cn/keking/utils/DownloadUtils.java

@@ -3,16 +3,27 @@ package cn.keking.utils;
 import cn.keking.config.ConfigConstants;
 import cn.keking.model.FileAttribute;
 import cn.keking.model.ReturnResponse;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import io.mola.galimatias.GalimatiasParseException;
 import org.apache.commons.io.FileUtils;
+import org.apache.http.client.HttpClient;
+import org.apache.http.impl.client.DefaultRedirectStrategy;
+import org.apache.http.impl.client.HttpClientBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
 import org.springframework.util.StringUtils;
+import org.springframework.web.client.RequestCallback;
+import org.springframework.web.client.RestTemplate;
 
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.net.URL;
+import java.util.Arrays;
+import java.util.Map;
 import java.util.UUID;
 
 import static cn.keking.utils.KkFileUtils.isFtpUrl;
@@ -28,6 +39,10 @@ public class DownloadUtils {
     private static final String URL_PARAM_FTP_USERNAME = "ftp.username";
     private static final String URL_PARAM_FTP_PASSWORD = "ftp.password";
     private static final String URL_PARAM_FTP_CONTROL_ENCODING = "ftp.control.encoding";
+    private static final RestTemplate restTemplate = new RestTemplate();
+    private static  final HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
+    private static final ObjectMapper mapper = new ObjectMapper();
+
 
     /**
      * @param fileAttribute fileAttribute
@@ -39,32 +54,34 @@ public class DownloadUtils {
         String urlStr = null;
         try {
             SslUtils.ignoreSsl();
-            urlStr = fileAttribute.getUrl().replaceAll("\\+", "%20");
+            urlStr = fileAttribute.getUrl().replaceAll("\\+", "%20").replaceAll(" ", "%20");
         } catch (Exception e) {
             logger.error("忽略SSL证书异常:", e);
         }
         ReturnResponse<String> response = new ReturnResponse<>(0, "下载成功!!!", "");
         String realPath = getRelFilePath(fileName, fileAttribute);
+
+        // 判断是否非法地址
+        if (KkFileUtils.isIllegalFileName(realPath)) {
+            response.setCode(1);
+            response.setContent(null);
+            response.setMsg("下载失败:文件名不合法!" + urlStr);
+            return response;
+        }
         if (!KkFileUtils.isAllowedUpload(realPath)) {
             response.setCode(1);
             response.setContent(null);
             response.setMsg("下载失败:不支持的类型!" + urlStr);
             return response;
         }
-        assert urlStr != null;
-        if (urlStr.contains("?fileKey=")) {
+        if (fileAttribute.isCompressFile()) { //压缩包文件 直接赋予路径 不予下载
             response.setContent(fileDir + fileName);
             response.setMsg(fileName);
             return response;
         }
-        if(!StringUtils.hasText(realPath)){
-            response.setCode(1);
-            response.setContent(null);
-            response.setMsg("下载失败:文件名不合法!" + urlStr);
-            return response;
-        }
-        if(realPath.equals("cunzhai")){
-            response.setContent(fileDir + fileName);
+        // 如果文件是否已经存在、且不强制更新，则直接返回文件路径
+        if (KkFileUtils.isExist(realPath) && !fileAttribute.forceUpdatedCache()) {
+            response.setContent(realPath);
             response.setMsg(fileName);
             return response;
         }
@@ -73,7 +90,31 @@ public class DownloadUtils {
             if (!fileAttribute.getSkipDownLoad()) {
                 if (isHttpUrl(url)) {
                     File realFile = new File(realPath);
-                    FileUtils.copyURLToFile(url, realFile);
+                    factory.setConnectionRequestTimeout(2000);  //设置超时时间
+                    factory.setConnectTimeout(10000);
+                    factory.setReadTimeout(72000);
+                    HttpClient httpClient = HttpClientBuilder.create().setRedirectStrategy(new DefaultRedirectStrategy()).build();
+                    factory.setHttpClient(httpClient);  //加入重定向方法
+                    restTemplate.setRequestFactory(factory);
+                    RequestCallback requestCallback = request -> {
+                        request.getHeaders().setAccept(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM, MediaType.ALL));
+                        String proxyAuthorization = fileAttribute.getKkProxyAuthorization();
+                        if(StringUtils.hasText(proxyAuthorization)){
+                            Map<String,String>  proxyAuthorizationMap = mapper.readValue(proxyAuthorization, Map.class);
+                            proxyAuthorizationMap.forEach((key, value) -> request.getHeaders().set(key, value));
+                        }
+                    };
+                    try {
+                        restTemplate.execute(url.toURI(), HttpMethod.GET, requestCallback, fileResponse -> {
+                            FileUtils.copyToFile(fileResponse.getBody(), realFile);
+                            return null;
+                        });
+                    }  catch (Exception e) {
+                            response.setCode(1);
+                            response.setContent(null);
+                            response.setMsg("下载失败:" + e);
+                            return response;
+                    }
                 } else if (isFtpUrl(url)) {
                     String ftpUsername = WebUtils.getUrlParameterReg(fileAttribute.getUrl(), URL_PARAM_FTP_USERNAME);
                     String ftpPassword = WebUtils.getUrlParameterReg(fileAttribute.getUrl(), URL_PARAM_FTP_PASSWORD);
@@ -115,21 +156,12 @@ public class DownloadUtils {
         } else { // 文件后缀不一致时，以type为准(针对simText【将类txt文件转为txt】)
             fileName = fileName.replace(fileName.substring(fileName.lastIndexOf(".") + 1), type);
         }
-        // 判断是否非法地址
-        if (KkFileUtils.isIllegalFileName(fileName)) {
-            return null;
-        }
+
         String realPath = fileDir + fileName;
         File dirFile = new File(fileDir);
         if (!dirFile.exists() && !dirFile.mkdirs()) {
             logger.error("创建目录【{}】失败,可能是权限不够，请检查", fileDir);
         }
-        // 文件已在本地存在，跳过文件下载
-        File realFile = new File(realPath);
-        if (realFile.exists()) {
-            fileAttribute.setSkipDownLoad(true);
-            return "cunzhai";
-        }
         return realPath;
     }
 

server/src/main/java/cn/keking/utils/KkFileUtils.java

@@ -34,29 +34,33 @@ public class KkFileUtils {
 
     /**
      * 检查文件名是否合规
+     *
      * @param fileName 文件名
-     * @return 合规结果,true:不合规，false:合规
+     * @return 合规结果, true:不合规，false:合规
      */
-    public static boolean isIllegalFileName(String fileName){
-        for (String str: illegalFileStrList){
-            if(fileName.contains(str)){
+    public static boolean isIllegalFileName(String fileName) {
+        for (String str : illegalFileStrList) {
+            if (fileName.contains(str)) {
                 return true;
             }
         }
         return false;
     }
+
     /**
      * 检查是否是数字
+     *
      * @param str 文件名
-     * @return 合规结果,true:不合规，false:合规
+     * @return 合规结果, true:不合规，false:合规
      */
     public static boolean isInteger(String str) {
-        if(StringUtils.hasText(str)){
+        if (StringUtils.hasText(str)) {
             boolean strResult = str.matches("-?[0-9]+.?[0-9]*");
-            return strResult ;
+            return strResult;
         }
         return false;
     }
+
     /**
      * 判断url是否是http资源
      *
@@ -102,7 +106,7 @@ public class KkFileUtils {
 
 
     public static String htmlEscape(String input) {
-        if(StringUtils.hasText(input)){
+        if (StringUtils.hasText(input)) {
             //input = input.replaceAll("\\{", "%7B").replaceAll("}", "%7D").replaceAll("\\\\", "%5C");
             String htmlStr = HtmlUtils.htmlEscape(input, "UTF-8");
             //& -> &
@@ -186,11 +190,23 @@ public class KkFileUtils {
      */
     public static boolean isAllowedUpload(String file) {
         String fileType = suffixFromFileName(file);
-            for (String type : ConfigConstants.getProhibit()) {
-            if (type.equals(fileType))
+        for (String type : ConfigConstants.getProhibit()) {
+            if (type.equals(fileType)){
                 return false;
+            }
         }
         return !ObjectUtils.isEmpty(fileType);
     }
 
+    /**
+     * 判断文件是否存在
+     *
+     * @param filePath 文件路径
+     * @return 是否存在 true:存在，false:不存在
+     */
+    public static boolean isExist(String filePath) {
+        File file = new File(filePath);
+        return file.exists();
+    }
+
 }

server/src/main/java/cn/keking/utils/LocalOfficeUtils.java

@@ -86,6 +86,9 @@ public class LocalOfficeUtils {
                     "/opt/libreoffice7.4",
                     "/opt/libreoffice7.5",
                     "/opt/libreoffice7.6",
+                    "/opt/libreoffice24.2",
+                    "/opt/libreoffice24.8",
+                    "/opt/libreoffice25.2",
                     "/usr/lib64/libreoffice",
                     "/usr/lib/libreoffice",
                     "/usr/local/lib64/libreoffice",

server/src/main/java/cn/keking/utils/OfficeUtils.java

@@ -4,7 +4,6 @@ import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.poi.EncryptedDocumentException;
 import org.apache.poi.extractor.ExtractorFactory;
 import org.apache.poi.hssf.record.crypto.Biff8EncryptionKey;
-import org.springframework.lang.Nullable;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -63,7 +62,7 @@ public class OfficeUtils {
      * @param password 文件密码
      * @return 是否可打开（兼容）
      */
-    public static synchronized boolean isCompatible(String path, @Nullable String password) {
+    public static synchronized boolean isCompatible(String path, String password) {
         InputStream propStream = null;
         try {
             propStream = Files.newInputStream(Paths.get(path));

server/src/main/java/cn/keking/utils/RarUtils.java

@@ -75,15 +75,18 @@ public class RarUtils {
     public static boolean judge(char c){
         return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
     }
+    public static String specialSymbols(String str) {
+        //去除压缩包文件字符串中特殊符号
+        Pattern p = Pattern.compile("\\s|\t|\r|\n|\\+|#|&|=|<7C>|\\p{P}");
+  //    Pattern p = Pattern.compile("\\s|\\+|#|&|=|\\p{P}");
+        Matcher m = p.matcher(str);
+        return m.replaceAll("");
+    }
     public static boolean isMessyCode(String strName) {
         //去除字符串中的空格 制表符 换行 回车
-        Pattern p = Pattern.compile("\\s*|\t*|\r*|\n*");
-        Matcher m = p.matcher(strName);
-        String after = m.replaceAll("").replaceAll("\\+", "").replaceAll("#", "").replaceAll("&", "");
-        //去除字符串中的标点符号
-        String temp = after.replaceAll("\\p{P}", "");
+        strName = specialSymbols(strName);
         //处理之后转换成字符数组
-        char[] ch = temp.trim().toCharArray();
+        char[] ch = strName.trim().toCharArray();
         for (char c : ch) {
             //判断是否是数字或者英文字符
             if (!judge(c)) {