4.4.0-beta版本

maven-assembly插件区分Linux和Windows的assembly-id, 解决maven构建warning
移除@Nullable注解，解决编译warning:未知的枚举常量 javax.annotation.meta.When.MAYBE
2026-04-28 19:16:43 +00:00 · 2024-04-15 09:19:13 +08:00 · 2024-03-26 16:56:11 +08:00 · 2024-03-26 16:47:21 +08:00 · 2024-03-26 08:29:41 +00:00 · 2024-03-25 13:49:53 +08:00
561 changed files with 286948 additions and 385341 deletions
--- a/.github/workflows/maven.yml
+++ b/.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
--- a/4
+++ b/4
@@ -1,5 +1,5 @@
 FROM keking/kkfileview-jdk:latest
 MAINTAINER chenjh "842761733@qq.com"
 ADD server/target/kkFileView-*.tar.gz /opt/
-ENV KKFILEVIEW_BIN_FOLDER /opt/kkFileView-4.3.0/bin
-ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-Dspring.config.location=/opt/kkFileView-4.3.0/config/application.properties","-jar","/opt/kkFileView-4.3.0/bin/kkFileView-4.3.0.jar"]
+ENV KKFILEVIEW_BIN_FOLDER /opt/kkFileView-4.4.0-beta/bin
+ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-Dspring.config.location=/opt/kkFileView-4.4.0-beta/config/application.properties","-jar","/opt/kkFileView-4.4.0-beta/bin/kkFileView-4.4.0-beta.jar"]
--- a/README.cn.md
+++ b/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

--- a/docker/kkfileview-jdk/Dockerfile_arm64
+++ b/docker/kkfileview-jdk/Dockerfile_arm64
@@ -0,0 +1,77 @@
+FROM arm64v8/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
+# 安装 arm64-jre8
+RUN apt-get install -y openjdk-8-jre
+# 编译 libreoffice
+RUN apt-get install -y git build-essential zip ccache junit4 libkrb5-dev nasm graphviz python3 python3-dev qtbase5-dev libkf5coreaddons-dev libkf5i18n-dev libkf5config-dev libkf5windowsystem-dev libkf5kio-dev autoconf libcups2-dev libfontconfig1-dev gperf default-jdk doxygen libxslt1-dev xsltproc libxml2-utils libxrandr-dev libx11-dev bison flex libgtk-3-dev libgstreamer-plugins-base1.0-dev libgstreamer1.0-dev ant ant-optional libnss3-dev libavahi-client-dev libxt-dev &&\
+    # 安装 ccache（重复编译时加快速度）
+    apt-get install ccache &&\
+    ccache -M 10G &&\
+    # clone主代码
+    mkdir /opt/libreoffice
+WORKDIR /opt/libreoffice
+RUN git clone --depth=1 --branch libreoffice-7-5 git://go.suokunlong.cn/lo/core ./libreoffice-7-5
+    # 配置&抓取子模块
+WORKDIR /opt/libreoffice/libreoffice-7-5
+RUN git submodule init &&\
+    git config --unset-all submodule.dictionaries.active &&\
+    git config --unset-all submodule.dictionaries.url &&\
+    git config --unset-all submodule.helpcontent2.active &&\
+    git config --unset-all submodule.helpcontent2.url &&\
+    git submodule update --progress --depth=1 &&\
+    # 下载第三方依赖
+    mkdir -p /opt/libreoffice/ext &&\
+    wget --recursive --no-parent --no-check-certificate -P /opt/libreoffice/ext https://go.suokunlong.cn:88/dl/libreoffice/external_tarballs/ 
+RUN mv /opt/libreoffice/ext/go.suokunlong.cn:88/dl/libreoffice/external_tarballs/* /opt/libreoffice/ext
+    # 配置编译选项
+RUN cat << EOF > autogen.input \
+    && echo "--without-help" >> autogen.input \
+    && echo "--without-helppack-integration" >> autogen.input \
+    && echo "--with-lang=zh-CN zh-TW" >> autogen.input \
+    && echo "--disable-online-update" >> autogen.input \
+    && echo "--disable-breakpad" >> autogen.input \
+    && echo "--disable-odk" >> autogen.input \
+    && echo "--without-doxygen" >> autogen.input \
+    && echo "--with-external-tar=/opt/libreoffice/ext" >> autogen.input \
+    && echo "--without-java" >> autogen.input \
+    && echo "--enable-firebird-sdbc" >> autogen.input \
+    && echo "--without-system-firebird" >> autogen.input \
+    && echo "--enable-python=internal" >> autogen.input
+    # 预编译
+RUN ./autogen.sh
+    # 因为libreoffice的安全策略，不允许root用户执行编译操作（可以改Makefile文件解决），所以新建用户
+RUN useradd libreoffice
+    # 切换用户
+RUN su libreoffice
+    # 在普通用户下编译
+RUN make || true
+    # !!!编译40分钟左右会报错，此时需要执行以下操作重新编译
+RUN cp ./workdir/UnpackedTarball/python3/build/lib.linux-aarch64-3.8/_sysconfigdata__linux_aarch64-linux-gnu.py ./workdir/UnpackedTarball/python3/build/lib.linux-aarch64-3.8/_sysconfigdata__linux_aarch64-unknown-linux-gnu.py
+    # 重新编译
+RUN make &&\
+    make install
+
+RUN ln -s /usr/local/lib/libreoffice/program/soffice /usr/bin/libreoffice
+
+# 清理临时文件
+RUN rm -rf /tmp/* && rm -rf /var/lib/apt/lists/* &&\
+cd /usr/share/fonts/chinese &&\
+mkfontscale &&\
+mkfontdir &&\
+fc-cache -fv
+ENV LANG zh_CN.UTF-8
+ENV LC_ALL zh_CN.UTF-8
+CMD ["/bin/bash"]
--- a/docker/kkfileview-jdk/docker
+++ b/docker/kkfileview-jdk/docker
@@ -1,2 +1,5 @@
 # 执行如下命令构建基础镜像，加快kkfileview docker镜像构建与发布
-docker build --tag keking/kkfileview-jdk:4.3.0 .
+docker build --tag keking/kkfileview-jdk:4.3.0 .
+
+# arm64架构执行如下命令
+docker build -f Dockerfile_arm64 --tag keking/kkfileview-jdk:4.3.0 .
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@

    <groupId>cn.keking</groupId>
    <artifactId>kkFileView-parent</artifactId>
-    <version>4.3.0</version>
+    <version>4.4.0-beta</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>2.0.29</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>
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -6,7 +6,7 @@
    <parent>
        <artifactId>kkFileView-parent</artifactId>
        <groupId>cn.keking</groupId>
-        <version>4.3.0</version>
+        <version>4.4.0-beta</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>
--- a/server/src/main/assembly/dist-linux.xml
+++ b/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>
--- a/server/src/main/assembly/dist-win32.xml
+++ b/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>
--- a/server/src/main/bin/startup.bat
+++ b/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.3.0.jar -> ..\log\kkFileView.log
+java -Dspring.config.location=..\config\application.properties -jar kkFileView-4.4.0-beta.jar -> ..\log\kkFileView.log
--- a/server/src/main/bin/startup.sh
+++ b/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/openoffice4" "/usr/lib/openoffice" "/usr/lib/libreoffice")
 FLAG=
 OFFICE_HOME=
 KKFILEVIEW_BIN_FOLDER=$(cd "$(dirname "$0")" || exit 1 ;pwd)
@@ -51,12 +51,12 @@ else

  ## 启动kkFileView
  echo "Starting kkFileView..."
-  nohup java -Dfile.encoding=UTF-8 -Dspring.config.location=../config/application.properties -jar kkFileView-4.3.0.jar > ../log/kkFileView.log 2>&1 &
+  nohup java -Dfile.encoding=UTF-8 -Dspring.config.location=../config/application.properties -jar kkFileView-4.4.0-beta.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
--- a/server/src/main/config/application.properties
+++ b/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.enable= 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,42 @@ 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.presentationMode.disable = ${KK_PDF_PRESENTATION_MODE_DISABLE:true}
 #是否禁止打开文件
@@ -85,15 +120,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 +151,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_ENABLED: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}
+
+
--- a/server/src/main/java/cn/keking/config/ConfigConstants.java
+++ b/server/src/main/java/cn/keking/config/ConfigConstants.java
--- a/server/src/main/java/cn/keking/config/ConfigRefreshComponent.java
+++ b/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,22 @@ 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;
                while (true) {
                    FileReader fileReader = new FileReader(configFilePath);
                    BufferedReader bufferedReader = new BufferedReader(fileReader);
@@ -76,15 +93,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 +112,20 @@ 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));
                    prohibitArray = prohibit.split(",");

                    ConfigConstants.setCacheEnabledValueValue(cacheEnabled);
@@ -103,21 +137,38 @@ 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);
                    setWatermarkConfig(properties);
                    bufferedReader.close();
                    fileReader.close();
--- a/server/src/main/java/cn/keking/config/WebConfig.java
+++ b/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;
    }

--- a/server/src/main/java/cn/keking/model/FileAttribute.java
+++ b/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;
+    }
 }
--- a/server/src/main/java/cn/keking/model/FileType.java
+++ b/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);
    }

--- a/server/src/main/java/cn/keking/service/CompressFileReader.java
+++ b/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;
@@ -12,6 +14,7 @@ import net.sf.sevenzipjbinding.simple.ISimpleInArchive;
 import net.sf.sevenzipjbinding.simple.ISimpleInArchiveItem;
 import org.apache.commons.io.IOUtils;
 import org.springframework.stereotype.Component;
+import org.springframework.util.ObjectUtils;

 import java.io.*;
 import java.nio.charset.StandardCharsets;
@@ -25,57 +28,64 @@ 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);
+        String packagePath = "_"; //防止文件名重复 压缩包统一生成文件添加_符号
+        String folderName = filePath.replace(fileDir, ""); //修复压缩包 多重目录获取路径错误
+        if (fileAttribute.isCompressFile()) { //压缩包文件 直接赋予路径 不予下载
+            folderName = "_decompression" + folderName;  //重新修改多重压缩包 生成文件路径
+        }
        RandomAccessFile randomAccessFile = null;
        IInArchive inArchive = null;
        try {
-            randomAccessFile = new RandomAccessFile(paths, "r");
+            randomAccessFile = new RandomAccessFile(filePath, "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();
+            ISimpleInArchive simpleInArchive = inArchive.getSimpleInterface();
            final String[] str = {null};
            for (final ISimpleInArchiveItem item : simpleInArchive.getArchiveItems()) {
                if (!item.isFolder()) {
                    ExtractOperationResult result;
+                    String finalFolderName = folderName;
                    result = item.extractSlow(data -> {
                        try {
-                             str[0] = RarUtils.getUtf8String(item.getPath());
-                            if (RarUtils.isMessyCode(str[0])){
+                            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);
+                            str[0] = str[0].replace("\\", File.separator); //Linux 下路径错误
+                            String str1 = str[0].substring(0, str[0].lastIndexOf(File.separator) + 1);
+                            File file = new File(fileDir, finalFolderName + packagePath + File.separator + str1);
                            if (!file.exists()) {
                                file.mkdirs();
                            }
-                            OutputStream out = new FileOutputStream( extractPath+ folderName + "_" + File.separator + str[0], true);
+                            OutputStream out = new FileOutputStream(fileDir + finalFolderName + packagePath + File.separator + str[0], true);
                            IOUtils.write(data, out);
                            out.close();
                        } catch (Exception e) {
                            e.printStackTrace();
+                            return Integer.parseInt(null);
                        }
                        return data.length;
-                    }, passWord);
+                    }, filePassword);
                    if (result == ExtractOperationResult.OK) {
                        FileType type = FileType.typeFromUrl(str[0]);
                        if (type.equals(FileType.PICTURE)) {
-                            imgUrls.add(baseUrl +folderName + "_/" + str[0].replace("\\", "/"));
+                            imgUrls.add(baseUrl + folderName + packagePath + "/" + str[0].replace("\\", "/"));
                        }
-                        fileHandlerService.putImgCache(fileName, imgUrls);
+                        fileHandlerService.putImgCache(fileName + packagePath, imgUrls);
                    } else {
                        return null;
                    }
                }
            }
-            return archiveFileName + "_";
+            return folderName + packagePath;
        } catch (Exception e) {
            throw new Exception(e);
        } finally {
--- a/server/src/main/java/cn/keking/service/FileHandlerService.java
+++ b/server/src/main/java/cn/keking/service/FileHandlerService.java
--- a/server/src/main/java/cn/keking/service/FilePreview.java
+++ b/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);
 }
--- a/server/src/main/java/cn/keking/service/OfficePluginManager.java
+++ b/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);
--- a/server/src/main/java/cn/keking/service/OfficeToPdfService.java
+++ b/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();
    }
--- a/server/src/main/java/cn/keking/service/cache/impl/CacheServiceJDKImpl.java
+++ b/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
--- a/server/src/main/java/cn/keking/service/cache/impl/CacheServiceRedisImpl.java
+++ b/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();
+    }
 }
--- a/server/src/main/java/cn/keking/service/cache/impl/CacheServiceRocksDBImpl.java
+++ b/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));
+    }
 }
--- a/server/src/main/java/cn/keking/service/impl/CadFilePreviewImpl.java
+++ b/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;
    }
-
-
 }
--- a/server/src/main/java/cn/keking/service/impl/CompressFilePreviewImpl.java
+++ b/server/src/main/java/cn/keking/service/impl/CompressFilePreviewImpl.java
@@ -48,7 +48,7 @@ public class CompressFilePreviewImpl implements FilePreview {
            }
            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) {
@@ -62,7 +62,7 @@ public class CompressFilePreviewImpl implements FilePreview {
            }
            if (!ObjectUtils.isEmpty(fileTree)) {
                //是否保留压缩包源文件
-                if (ConfigConstants.getDeleteSourceFile()) {
+                if (!fileAttribute.isCompressFile() && ConfigConstants.getDeleteSourceFile()) {
                    KkFileUtils.deleteFileByPath(filePath);
                }
                if (ConfigConstants.isCacheEnabled()) {
--- a/server/src/main/java/cn/keking/service/impl/FlvFilePreviewImpl.java
+++ b/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;
-    }
-}
--- a/server/src/main/java/cn/keking/service/impl/MediaFilePreviewImpl.java
+++ b/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;
    }
+
 }
--- a/server/src/main/java/cn/keking/service/impl/OfficeFilePreviewImpl.java
+++ b/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) {
--- a/server/src/main/java/cn/keking/service/impl/PdfFilePreviewImpl.java
+++ b/server/src/main/java/cn/keking/service/impl/PdfFilePreviewImpl.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.web.filter.BaseUrlFilter;
+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;

 /**
@@ -25,38 +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();
-        String baseUrl = BaseUrlFilter.getBaseUrl();
-        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) {
@@ -93,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);
--- a/server/src/main/java/cn/keking/service/impl/PictureFilePreviewImpl.java
+++ b/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);
        }
--- a/server/src/main/java/cn/keking/service/impl/SimTextFilePreviewImpl.java
+++ b/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()) {
--- a/server/src/main/java/cn/keking/service/impl/TiffFilePreviewImpl.java
+++ b/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;
    }
 }
+
--- a/server/src/main/java/cn/keking/utils/CaptchaUtil.java
+++ b/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();
+    }
+}
--- a/server/src/main/java/cn/keking/utils/ConvertPicUtil.java
+++ b/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;
    }
 }
--- a/server/src/main/java/cn/keking/utils/DateUtils.java
+++ b/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;
+    }
+}
--- a/server/src/main/java/cn/keking/utils/DownloadUtils.java
+++ b/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;
    }

--- a/server/src/main/java/cn/keking/utils/EncodingDetects.java
+++ b/server/src/main/java/cn/keking/utils/EncodingDetects.java
--- a/server/src/main/java/cn/keking/utils/KkFileUtils.java
+++ b/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");
            //& -> &amp;
@@ -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();
+    }
+
 }
--- a/server/src/main/java/cn/keking/utils/OfficeUtils.java
+++ b/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));
--- a/server/src/main/java/cn/keking/utils/RarUtils.java
+++ b/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|\\+|#|&|=|\\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)) {
--- a/server/src/main/java/cn/keking/utils/SimpleEncodingDetects.java
+++ b/server/src/main/java/cn/keking/utils/SimpleEncodingDetects.java
--- a/server/src/main/java/cn/keking/utils/UrlEncoderUtils.java
+++ b/server/src/main/java/cn/keking/utils/UrlEncoderUtils.java
@@ -0,0 +1,82 @@
+package cn.keking.utils;
+import java.util.BitSet;
+
+
+public class UrlEncoderUtils {
+
+    private static BitSet dontNeedEncoding;
+
+    static {
+        dontNeedEncoding = new BitSet(256);
+        int i;
+        for (i = 'a'; i <= 'z'; i++) {
+            dontNeedEncoding.set(i);
+        }
+        for (i = 'A'; i <= 'Z'; i++) {
+            dontNeedEncoding.set(i);
+        }
+        for (i = '0'; i <= '9'; i++) {
+            dontNeedEncoding.set(i);
+        }
+        dontNeedEncoding.set('+');
+        /**
+         * 这里会有误差,比如输入一个字符串 123+456,它到底是原文就是123+456还是123 456做了urlEncode后的内容呢？<br>
+         * 其实问题是一样的，比如遇到123%2B456,它到底是原文即使如此，还是123+456 urlEncode后的呢？ <br>
+         * 在这里，我认为只要符合urlEncode规范的，就当作已经urlEncode过了<br>
+         * 毕竟这个方法的初衷就是判断string是否urlEncode过<br>
+         */
+
+        dontNeedEncoding.set('-');
+        dontNeedEncoding.set('_');
+        dontNeedEncoding.set('.');
+        dontNeedEncoding.set('*');
+    }
+
+    /**
+     * 判断str是否urlEncoder.encode过<br>
+     * 经常遇到这样的情况，拿到一个URL,但是搞不清楚到底要不要encode.<Br>
+     * 不做encode吧，担心出错，做encode吧，又怕重复了<Br>
+     *
+     * @param str
+     * @return
+     */
+    public static boolean hasUrlEncoded(String str) {
+
+        /**
+         * 支持JAVA的URLEncoder.encode出来的string做判断。 即: 将' '转成'+' <br>
+         * 0-9a-zA-Z保留 <br>
+         * '-'，'_'，'.'，'*'保留 <br>
+         * 其他字符转成%XX的格式，X是16进制的大写字符，范围是[0-9A-F]
+         */
+        boolean needEncode = false;
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            if (dontNeedEncoding.get((int) c)) {
+                continue;
+            }
+            if (c == '%' && (i + 2) < str.length()) {
+                // 判断是否符合urlEncode规范
+                char c1 = str.charAt(++i);
+                char c2 = str.charAt(++i);
+                if (isDigit16Char(c1) && isDigit16Char(c2)) {
+                    continue;
+                }
+            }
+            // 其他字符，肯定需要urlEncode
+            needEncode = true;
+            break;
+        }
+
+        return !needEncode;
+    }
+
+    /**
+     * 判断c是否是16进制的字符
+     *
+     * @param c
+     * @return
+     */
+    private static boolean isDigit16Char(char c) {
+        return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F');
+    }
+}
--- a/server/src/main/java/cn/keking/utils/WebUtils.java
+++ b/server/src/main/java/cn/keking/utils/WebUtils.java
@@ -9,6 +9,8 @@ import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.util.HtmlUtils;

 import javax.servlet.ServletRequest;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
 import java.io.UnsupportedEncodingException;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -27,7 +29,7 @@ import java.util.regex.Pattern;
 public class WebUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(WebUtils.class);
-
+    private static final String BASE64_MSG = "base64";
    /**
     * 获取标准的URL
     *
@@ -38,6 +40,57 @@ public class WebUtils {
        return io.mola.galimatias.URL.parse(urlStr).toJavaURL();
    }

+
+    /**
+     * 对文件名进行编码
+     *
+     */
+    public static String encodeFileName(String name) {
+        try {
+            name = URLEncoder.encode(name, "UTF-8").replaceAll("\\+", "%20");
+        } catch (UnsupportedEncodingException e) {
+            return null;
+        }
+        return name;
+    }
+
+
+    /**
+     * 去除fullfilename参数
+     *
+     * @param urlStr
+     * @return
+     */
+    public static String clearFullfilenameParam(String urlStr) {
+        // 去除特定参数字段
+        Pattern pattern = Pattern.compile("(&fullfilename=[^&]*)");
+        Matcher matcher = pattern.matcher(urlStr);
+        return matcher.replaceAll("");
+    }
+
+    /**
+     * 对URL进行编码
+     */
+    public static String  urlEncoderencode(String urlStr) {
+
+        String fullFileName = getUrlParameterReg(urlStr, "fullfilename");  //获取流文件名
+        if (org.springframework.util.StringUtils.hasText(fullFileName)) {
+            // 移除fullfilename参数
+            urlStr = clearFullfilenameParam(urlStr);
+        } else {
+            fullFileName = getFileNameFromURL(urlStr); //获取文件名
+
+        }
+        if (!UrlEncoderUtils.hasUrlEncoded(fullFileName)) {  //判断文件名是否转义
+            try {
+                urlStr = URLEncoder.encode(urlStr, "UTF-8").replaceAll("\\+", "%20").replaceAll("%3A", ":").replaceAll("%2F", "/").replaceAll("%3F", "?").replaceAll("%26", "&").replaceAll("%3D", "=");
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+            }
+        }
+        return urlStr;
+    }
+
    /**
     * 获取url中的参数
     *
@@ -205,13 +258,7 @@ public class WebUtils {
        Matcher matcher = pattern.matcher(url);
        return matcher.find();
    }
-    public static boolean kuayu(String host, String wjl) {  //查询域名是否相同
-        if (wjl.contains(host)) {
-            return true;
-        }else {
-            return false;
-        }
-    }
+
    /**
     * 将 Base64 字符串解码，再解码URL参数, 默认使用 UTF-8
     * @param source 原始 Base64 字符串
@@ -243,7 +290,11 @@ public class WebUtils {
        try {
            return new String(Base64Utils.decodeFromString(source.replaceAll(" ", "+").replaceAll("\n", "")), charsets);
        } catch (Exception e) {
-            LOGGER.error("url解码异常，可能是接入方法错误或者未使用BASE64", e);
+            if (e.getMessage().toLowerCase().contains(BASE64_MSG)) {
+                LOGGER.error("url解码异常，接入方法错误未使用BASE64");
+            }else {
+                LOGGER.error("url解码异常，其他错误", e);
+            }
            return null;
        }
    }
@@ -261,4 +312,61 @@ public class WebUtils {
        }
        return null;
    }
+
+    /**
+     * 获取 session 中的 String 属性
+     * @param request 请求
+     * @return 属性值
+     */
+    public static String getSessionAttr(HttpServletRequest request, String key) {
+        HttpSession session = request.getSession();
+        if (session == null) {
+            return null;
+        }
+        Object value = session.getAttribute(key);
+        if (value == null) {
+            return null;
+        }
+        return value.toString();
+    }
+
+    /**
+     * 获取 session 中的 long 属性
+     * @param request 请求
+     * @param key 属性名
+     * @return 属性值
+     */
+    public static long getLongSessionAttr(HttpServletRequest request, String key) {
+        String value = getSessionAttr(request, key);
+        if (value == null) {
+            return 0;
+        }
+        return Long.parseLong(value);
+    }
+
+    /**
+     * session 中设置属性
+     * @param request 请求
+     * @param key 属性名
+     */
+    public static void setSessionAttr(HttpServletRequest request, String key, Object value) {
+        HttpSession session = request.getSession();
+        if (session == null) {
+            return;
+        }
+        session.setAttribute(key, value);
+    }
+
+    /**
+     * 移除 session 中的属性
+     * @param request 请求
+     * @param key 属性名
+     */
+    public static void removeSessionAttr(HttpServletRequest request, String key) {
+        HttpSession session = request.getSession();
+        if (session == null) {
+            return;
+        }
+        session.removeAttribute(key);
+    }
 }
--- a/server/src/main/java/cn/keking/web/controller/FileController.java
+++ b/server/src/main/java/cn/keking/web/controller/FileController.java
@@ -2,6 +2,8 @@ package cn.keking.web.controller;

 import cn.keking.config.ConfigConstants;
 import cn.keking.model.ReturnResponse;
+import cn.keking.utils.CaptchaUtil;
+import cn.keking.utils.DateUtils;
 import cn.keking.utils.KkFileUtils;
 import cn.keking.utils.RarUtils;
 import cn.keking.utils.WebUtils;
@@ -11,21 +13,34 @@ import org.springframework.util.ObjectUtils;
 import org.springframework.util.StreamUtils;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.multipart.MultipartFile;

+import javax.imageio.ImageIO;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import static cn.keking.utils.CaptchaUtil.CAPTCHA_CODE;
+import static cn.keking.utils.CaptchaUtil.CAPTCHA_GENERATE_TIME;

 /**
 * @author yudian-it
- *  2017/12/1
+ * 2017/12/1
 */
@RestController
 public class FileController {
@@ -34,6 +49,7 @@ public class FileController {

    private final String fileDir = ConfigConstants.getFileDir();
    private final String demoDir = "demo";
+
    private final String demoPath = demoDir + File.separator;
    public static final String BASE64_DECODE_ERROR_MSG = "Base64解码失败，请检查你的 %s 是否采用 Base64 + urlEncode 双重编码了！";

@@ -59,16 +75,12 @@ public class FileController {
    }

    @GetMapping("/deleteFile")
-    public ReturnResponse<Object> deleteFile(String fileName,String password) {
-        ReturnResponse<Object> checkResult = this.deleteFileCheck(fileName);
+    public ReturnResponse<Object> deleteFile(HttpServletRequest request, String fileName, String password) {
+        ReturnResponse<Object> checkResult = this.deleteFileCheck(request, fileName, password);
        if (checkResult.isFailure()) {
            return checkResult;
        }
-         fileName = checkResult.getContent().toString();
-        if(!ConfigConstants.getPassword().equalsIgnoreCase(password)) {
-            logger.error("删除文件【{}】失败，密码错误！",fileName);
-            return ReturnResponse.failure("删除文件失败，密码错误！");
-        }
+        fileName = checkResult.getContent().toString();
        File file = new File(fileDir + demoPath + fileName);
        logger.info("删除文件：{}", file.getAbsolutePath());
        if (file.exists() && !file.delete()) {
@@ -76,9 +88,42 @@ public class FileController {
            logger.error(msg);
            return ReturnResponse.failure(msg);
        }
+        WebUtils.removeSessionAttr(request, CAPTCHA_CODE); //删除缓存验证码
        return ReturnResponse.success();
    }

+    /**
+     * 验证码方法
+     */
+    @RequestMapping("/deleteFile/captcha")
+    public void captcha(HttpServletRequest request, HttpServletResponse response) throws Exception {
+        if (!ConfigConstants.getDeleteCaptcha()) {
+            return;
+        }
+
+        response.setContentType("image/jpeg");
+        response.setHeader("Pragma", "no-cache");
+        response.setHeader("Cache-Control", "no-cache");
+        response.setDateHeader("Expires", -1);
+        String captchaCode = WebUtils.getSessionAttr(request, CAPTCHA_CODE);
+        long captchaGenerateTime = WebUtils.getLongSessionAttr(request, CAPTCHA_GENERATE_TIME);
+        long timeDifference = DateUtils.calculateCurrentTimeDifference(captchaGenerateTime);
+
+        // 验证码为空，且生成验证码超过50秒，重新生成验证码
+        if (timeDifference > 50 && ObjectUtils.isEmpty(captchaCode)) {
+            captchaCode = CaptchaUtil.generateCaptchaCode();
+            // 更新验证码
+            WebUtils.setSessionAttr(request, CAPTCHA_CODE, captchaCode);
+            WebUtils.setSessionAttr(request, CAPTCHA_GENERATE_TIME, DateUtils.getCurrentSecond());
+        } else {
+            captchaCode = ObjectUtils.isEmpty(captchaCode) ? "wait" : captchaCode;
+        }
+
+        ServletOutputStream outputStream = response.getOutputStream();
+        ImageIO.write(CaptchaUtil.generateCaptchaPic(captchaCode), "jpeg", outputStream);
+        outputStream.close();
+    }
+
    @GetMapping("/listFiles")
    public List<Map<String, String>> getFiles() {
        List<Map<String, String>> list = new ArrayList<>();
@@ -106,7 +151,7 @@ public class FileController {
            return ReturnResponse.failure("文件传接口已禁用");
        }
        String fileName = WebUtils.getFileNameFromMultipartFile(file);
-        if(fileName.lastIndexOf(".")==-1){
+        if (fileName.lastIndexOf(".") == -1) {
            return ReturnResponse.failure("不允许上传的类型");
        }
        if (!KkFileUtils.isAllowedUpload(fileName)) {
@@ -129,7 +174,7 @@ public class FileController {
     * @param fileName 文件名
     * @return 校验结果
     */
-    private ReturnResponse<Object> deleteFileCheck(String fileName) {
+    private ReturnResponse<Object> deleteFileCheck(HttpServletRequest request, String fileName, String password) {
        if (ObjectUtils.isEmpty(fileName)) {
            return ReturnResponse.failure("文件名为空，删除失败！");
        }
@@ -146,6 +191,16 @@ public class FileController {
        if (KkFileUtils.isIllegalFileName(fileName)) {
            return ReturnResponse.failure("非法文件名，删除失败！");
        }
+        if (ObjectUtils.isEmpty(password)) {
+            return ReturnResponse.failure("密码 or 验证码为空，删除失败！");
+        }
+
+        String expectedPassword = ConfigConstants.getDeleteCaptcha() ? WebUtils.getSessionAttr(request, CAPTCHA_CODE) : ConfigConstants.getPassword();
+
+        if (!password.equalsIgnoreCase(expectedPassword)) {
+            logger.error("删除文件【{}】失败，密码错误！", fileName);
+            return ReturnResponse.failure("删除文件失败，密码错误！");
+        }
        return ReturnResponse.success(fileName);
    }

--- a/server/src/main/java/cn/keking/web/controller/OnlinePreviewController.java
+++ b/server/src/main/java/cn/keking/web/controller/OnlinePreviewController.java
@@ -8,25 +8,33 @@ import cn.keking.service.cache.CacheService;
 import cn.keking.service.impl.OtherFilePreviewImpl;
 import cn.keking.utils.KkFileUtils;
 import cn.keking.utils.WebUtils;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import fr.opensagres.xdocreport.core.io.IOUtils;
-import io.mola.galimatias.GalimatiasParseException;
 import org.apache.commons.codec.binary.Base64;
+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.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.client.RequestCallback;
+import org.springframework.web.client.RestTemplate;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;

 import static cn.keking.service.FilePreview.PICTURE_FILE_PREVIEW_PAGE;

@@ -43,6 +51,9 @@ public class OnlinePreviewController {
    private final CacheService cacheService;
    private final FileHandlerService fileHandlerService;
    private final OtherFilePreviewImpl otherFilePreview;
+    private static final RestTemplate restTemplate = new RestTemplate();
+    private static  final HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
+    private static final ObjectMapper mapper = new ObjectMapper();

    public OnlinePreviewController(FilePreviewFactory filePreviewFactory, FileHandlerService fileHandlerService, CacheService cacheService, OtherFilePreviewImpl otherFilePreview) {
        this.previewFactory = filePreviewFactory;
@@ -53,6 +64,7 @@ public class OnlinePreviewController {

    @GetMapping( "/onlinePreview")
    public String onlinePreview(String url, Model model, HttpServletRequest req) {
+
        String fileUrl;
        try {
            fileUrl = WebUtils.decodeUrl(url);
@@ -60,11 +72,11 @@ public class OnlinePreviewController {
            String errorMsg = String.format(BASE64_DECODE_ERROR_MSG, "url");
            return otherFilePreview.notSupportedFile(model, errorMsg);
        }
-        FileAttribute fileAttribute = fileHandlerService.getFileAttribute(fileUrl, req);
+        FileAttribute fileAttribute = fileHandlerService.getFileAttribute(fileUrl, req);  //这里不在进行URL 处理了
        model.addAttribute("file", fileAttribute);
        FilePreview filePreview = previewFactory.get(fileAttribute);
        logger.info("预览文件url：{}，previewType：{}", fileUrl, fileAttribute.getType());
-        return filePreview.filePreviewHandle(fileUrl, model, fileAttribute);
+        return filePreview.filePreviewHandle(WebUtils.urlEncoderencode(fileUrl), model, fileAttribute);  //统一在这里处理 url
    }

    @GetMapping( "/picturesPreview")
@@ -102,58 +114,53 @@ public class OnlinePreviewController {
     * @param response response
     */
    @GetMapping("/getCorsFile")
-    public void getCorsFile(String urlPath, HttpServletResponse response) throws IOException {
+    public void getCorsFile(String urlPath, HttpServletResponse response,FileAttribute fileAttribute) throws IOException {
+        URL url;
        try {
            urlPath = WebUtils.decodeUrl(urlPath);
+            url = WebUtils.normalizedURL(urlPath);
        } catch (Exception ex) {
            logger.error(String.format(BASE64_DECODE_ERROR_MSG, urlPath),ex);
            return;
        }
-        HttpURLConnection urlcon = null;
-        InputStream inputStream = null;
        assert urlPath != null;
        if (!urlPath.toLowerCase().startsWith("http") && !urlPath.toLowerCase().startsWith("https") && !urlPath.toLowerCase().startsWith("ftp")) {
            logger.info("读取跨域文件异常，可能存在非法访问，urlPath：{}", urlPath);
            return;
        }
-        logger.info("下载跨域pdf文件url：{}", urlPath);
-        if (!urlPath.toLowerCase().startsWith("ftp:")){
+        InputStream inputStream = null;
+        logger.info("读取跨域pdf文件url：{}", urlPath);
+        if (!urlPath.toLowerCase().startsWith("ftp:")) {
+            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 {
-                URL url = WebUtils.normalizedURL(urlPath);
-                urlcon=(HttpURLConnection)url.openConnection();
-                urlcon.setConnectTimeout(30000);
-                urlcon.setReadTimeout(30000);
-                urlcon.setInstanceFollowRedirects(false);
-                int responseCode = urlcon.getResponseCode();
-                if (responseCode == HttpURLConnection.HTTP_MOVED_PERM || responseCode == HttpURLConnection.HTTP_MOVED_TEMP) { //301 302
-                    url =new URL(urlcon.getHeaderField("Location"));
-                    urlcon=(HttpURLConnection)url.openConnection();
-                }
-                if (responseCode  == HttpURLConnection.HTTP_NOT_FOUND  ||responseCode  == HttpURLConnection.HTTP_FORBIDDEN  || responseCode == HttpURLConnection.HTTP_INTERNAL_ERROR ) { //403 404 500
-                    logger.error("读取跨域文件异常，url：{}，错误：{}", urlPath,responseCode);
-                } else {
-                    if(urlPath.contains( ".svg")) {
-                        response.setContentType("image/svg+xml");
-                    }
-                    inputStream=(url).openStream();
-                    IOUtils.copy(inputStream, response.getOutputStream());
-                }
-            } catch (IOException | GalimatiasParseException e) {
-                logger.error("读取跨域文件异常，url：{}", urlPath);
-            } finally {
-                assert urlcon != null;
-                urlcon.disconnect();
-                IOUtils.closeQuietly(inputStream);
+                restTemplate.execute(url.toURI(), HttpMethod.GET, requestCallback, fileResponse -> {
+                    IOUtils.copy(fileResponse.getBody(), response.getOutputStream());
+                    return null;
+                });
+            }  catch (Exception e) {
+                System.out.println(e);
            }
-        } else {
+        }else{
            try {
-                URL url = WebUtils.normalizedURL(urlPath);
                if(urlPath.contains(".svg")) {
                    response.setContentType("image/svg+xml");
                }
                inputStream = (url).openStream();
                IOUtils.copy(inputStream, response.getOutputStream());
-            } catch (IOException | GalimatiasParseException e) {
+            } catch (IOException e) {
                logger.error("读取跨域文件异常，url：{}", urlPath);
            } finally {
                IOUtils.closeQuietly(inputStream);
--- a/server/src/main/java/cn/keking/web/filter/AttributeSetFilter.java
+++ b/server/src/main/java/cn/keking/web/filter/AttributeSetFilter.java
@@ -37,11 +37,16 @@ public class AttributeSetFilter implements Filter {
        request.setAttribute("pdfPrintDisable", ConfigConstants.getPdfPrintDisable());
        request.setAttribute("pdfDownloadDisable", ConfigConstants.getPdfDownloadDisable());
        request.setAttribute("pdfBookmarkDisable", ConfigConstants.getPdfBookmarkDisable());
-        request.setAttribute("fileKey", httpRequest.getParameter("fileKey"));
+        request.setAttribute("pdfDisableEditing", ConfigConstants.getPdfDisableEditing());
        request.setAttribute("switchDisabled", ConfigConstants.getOfficePreviewSwitchDisabled());
        request.setAttribute("fileUploadDisable", ConfigConstants.getFileUploadDisable());
        request.setAttribute("beian", ConfigConstants.getBeian());
        request.setAttribute("size", ConfigConstants.maxSize());
+        request.setAttribute("deleteCaptcha", ConfigConstants.getDeleteCaptcha());
+        request.setAttribute("homePageNumber", ConfigConstants.getHomePageNumber());
+        request.setAttribute("homePagination", ConfigConstants.getHomePagination());
+        request.setAttribute("homePageSize", ConfigConstants.getHomePageSize());
+        request.setAttribute("homeSearch", ConfigConstants.getHomeSearch());
    }

    /**
--- a/server/src/main/java/cn/keking/web/filter/BaseUrlFilter.java
+++ b/server/src/main/java/cn/keking/web/filter/BaseUrlFilter.java
@@ -43,7 +43,7 @@ public class BaseUrlFilter implements Filter {
        final String urlInHeader = servletRequest.getHeader("X-Base-Url");
        if (StringUtils.isNotEmpty(urlInHeader)) {
            baseUrl = urlInHeader;
-        } else if (configBaseUrl != null && !ConfigConstants.DEFAULT_BASE_URL.equalsIgnoreCase(configBaseUrl)) {
+        } else if (configBaseUrl != null && !ConfigConstants.DEFAULT_VALUE.equalsIgnoreCase(configBaseUrl)) {
            //2、如果配置文件中配置了 baseUrl 且不为 default 则以配置文件为准
            baseUrl = configBaseUrl;
        } else {
--- a/server/src/main/java/cn/keking/web/filter/TrustHostFilter.java
+++ b/server/src/main/java/cn/keking/web/filter/TrustHostFilter.java
@@ -2,6 +2,7 @@ package cn.keking.web.filter;

 import cn.keking.config.ConfigConstants;
 import cn.keking.utils.WebUtils;
+
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import javax.servlet.Filter;
@@ -10,6 +11,8 @@ import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
+
+import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.util.FileCopyUtils;

@@ -19,7 +22,7 @@ import org.springframework.util.FileCopyUtils;
 */
 public class TrustHostFilter implements Filter {

-    private String notTrustHost;
+    private String notTrustHostHtmlView;

    @Override
    public void init(FilterConfig filterConfig) {
@@ -27,7 +30,7 @@ public class TrustHostFilter implements Filter {
        try {
            classPathResource.getInputStream();
            byte[] bytes = FileCopyUtils.copyToByteArray(classPathResource.getInputStream());
-            this.notTrustHost = new String(bytes, StandardCharsets.UTF_8);
+            this.notTrustHostHtmlView = new String(bytes, StandardCharsets.UTF_8);
        } catch (IOException e) {
            e.printStackTrace();
        }
@@ -37,16 +40,26 @@ public class TrustHostFilter implements Filter {
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String url = WebUtils.getSourceUrl(request);
        String host = WebUtils.getHost(url);
-        if (host != null &&!ConfigConstants.getTrustHostSet().isEmpty() && !ConfigConstants.getTrustHostSet().contains(host)) {
-            String html = this.notTrustHost.replace("${current_host}", host);
+        assert host != null;
+        if (isNotTrustHost(host)) {
+            String html = this.notTrustHostHtmlView.replace("${current_host}", host);
            response.getWriter().write(html);
            response.getWriter().close();
-        }
-        else {
+        } else {
            chain.doFilter(request, response);
        }
    }

+    public boolean isNotTrustHost(String host) {
+        if (CollectionUtils.isNotEmpty(ConfigConstants.getNotTrustHostSet())) {
+            return ConfigConstants.getNotTrustHostSet().contains(host);
+        }
+        if (CollectionUtils.isNotEmpty(ConfigConstants.getTrustHostSet())) {
+            return !ConfigConstants.getTrustHostSet().contains(host);
+        }
+        return false;
+    }
+
    @Override
    public void destroy() {

--- a/Show More
+++ b/Show More