:fire:修复部分情况不能部署成功问题

This reverts commit dd11dd2589.

.gitattributes

@@ -1,6 +0,0 @@
-*.js linguist-language=java
-
-*.css linguist-language=java
-
-*.html linguist-language=java
-

README.md

@@ -1,108 +1,170 @@
-# Hellohao图像托管程序 - 也许这会是最优秀的图床程序
-
-![宣传图Banner](https://upload.cc/i1/2022/02/11/HSg5tX.png)
+# Hellohao图像托管 - 也许这会是最优秀的图像托管程序
 
+<p align="center">
+  <a href="https://www.hellohao.cn/" target="_blank">
+    <img width="1920px" src="https://upload.cc/i1/2022/02/11/HSg5tX.png">
+  </a>
+</p>
 
 ![Visual Studio Marketplace Rating (Stars)](https://img.shields.io/visual-studio-marketplace/stars/ritwickdey.LiveServer?style=flat-square)
 ![https://img.shields.io/badge/license-AGPL-blue.svg?style=flat-square](https://img.shields.io/badge/license-AGPL-blue.svg?longCache=true&style=flat-square)
 ![https://img.shields.io/badge/language-java-orange.svg?style=flat-square](https://img.shields.io/badge/language-java-yellow.svg?longCache=true&style=popout-square)
 
+<h3 align="center">赞助商</h3>
+
+<p align="center">
+  <a href="https://www.eltyun.com/" target="_blank">
+    <img width="350px" src="https://t.tdo.ink/hellohao/s9ugmihq.png">
+  </a>
+</p>
+
+>:exclamation: 托管的所有开源代码可能存在作者修改/测试/调整等行为，均为实验性代码，故并不保证程序或功能的可用性，如果你想要部署程序，请下载我们提供的编译整合包进行安装部署。
+
+
+### 引导
+
+[官网](https://tbed.hellohao.cn) | [文档](https://doc.hellohao.cn) | [演示站](https://pic.hellohao.cn) | [桌面客户端](https://tbed.hellohao.cn/app) | [微信小程序](https://tbed.hellohao.cn/wechat) | [前端源码](https://github.com/Hello-hao/tbed-web)
 
 
 ### 前言
 
-**Hellohao图像托管程序**(图床)这是一个由JAVA语言编写SpringBoot框架开发的开源图像托管程序。具备多对象存储源对接，采用`前后端分离`式设计的一款专门托管图像的程序，支持多种格式的图像 多功能的图床系统。
+**Hellohao图像托管程序**(图床)这是一个由JAVA语言编写SpringBoot框架开发的开源图像托管程序。具备多对象存储源对接，采用`前后端分离`式设计的一款专门托管图像的程序，支持多种格式的图像 多功能的图床系统。该程序支持除了`web端`之外，同时支持`客户端（win/mac）`,`移动端（小程序）`等常用全平台支持。
 
 程序主要使用领域：`个人照片存储`，`团队共享图像`，`博客/商城等网站图片托管`，`图像批量云分享`等。具备优秀的多用户图像上传功能和完善的图像查询管理逻辑，同时支持对接多家对象存储。
 
-> 无论你使用开源版或者Core版，都希望你能给我点个赞，你的`star`是对一名开发者最大的支持
-
 **存储源支持：**
 
-开源版：`本地`,`阿里OSS`,`又拍USS`,`七牛KODO`,`腾讯COS`,`网易NOS`,~~`U-File`~~,`FTP`
+开源版：`本地`,`阿里OSS`,`又拍USS`,`七牛KODO`,`腾讯COS`,`网易NOS`,`FTP`,`AWS S3协议`(`百度云BOS`,`青云Qingstor`,`Ucloud US3`,`Minio`等兼容S3协议)
 
-Core版：`本地`,`阿里OSS`,`又拍USS`,`七牛KODO`,`腾讯COS`,`网易NOS`,~~`U-File`~~,`FTP`,`Backblaze(B2)`,`百度云BOS`,`青云Qingstor`,`Ucloud US3`,`Minio`,`AWS S3`
+[Core版](https://hellohao.cn)：开源版的基础上增加`Backblaze(B2)` 并且可`同个对象存储商家`可开多个存储源（可添加至90+存储源）
 
 
-### 更新日志 `20220328`
-- **修复** 修复部分情况下开启图像查重后，出现上传失败的问题
-- **修复** 部分场景下操作图片时出现的异常错误
-- **优化** 多个页面显示
-
-### 引导
-
-程序宣传视频：[自制宣传视频](https://www.bilibili.com/video/BV11r4y1y7mH/)
-
-开源版编译包下载: [下载开源版程序包](https://github.com/Hello-hao/Tbed/releases/)
-
-[^_^]:官网(含Core版)：[https://tbed.hellohao.cn](https://tbed.hellohao.cn)
-
-[^_^]:前端源码：[https://github.com/Hello-hao/tbed-web](https://github.com/Hello-hao/tbed-web)
-
-[^_^]:文档地址：[https://doc.hellohao.cn](https://doc.hellohao.cn)
-
-[^_^]:程序展示：[https://tc.hellohao.cn](https://tc.hellohao.cn)
-
-[^_^]:作者博客：[https://www.hellohao.cn](https://www.hellohao.cn)
-
-域名`hellohao.cn`目前正在转移备案，请使用一下备用地址进行访问
-
- --- **备用地址** ---
-
-官网(含Core版)(备用)：[http://tbed.wwery.com](http://tbed.wwery.com)
-
-文档地址(备用)：[http://doc.wwery.com](http://doc.wwery.com)
-
-程序展示(备用)：[http://tc.wwery.com](http://tc.wwery.com)
-
-[^_^]:作者博客(备用)：[http://www.wwery.com](http://www.wwery.com)
+### 更新日志 `20240319`
 
+- 修复部分部署场景部署不成功的问题
+- 提高系统稳定性
 
 
 
 ### 主要功能
 
-- 前后端分离式架构设计，部署更方便
+- [x] 全端支持，不限于(`web端`/`桌面端Windows/Mac`/`移动端小程序`)
 
-- 个人相册浏览，图像详细资料展示卡片
+- [x] 前后端分离式架构设计，部署更方便
 
-- 支持 图片拖拽、截图直接(Ctrl+V)
+- [x] 个人相册浏览，图像详细资料展示卡片
 
-- 支持URL地址批量上传
+- [x] 支持 图片拖拽、截图直接(Ctrl+V)
 
-- 一键复制嵌入式链接代码，也可以自定义嵌入式代码格式
+- [x] 支持URL地址批量上传
 
-- 对接邮箱服务，注册/找回密码等功能
+- [x] 一键复制嵌入式链接代码，也可以自定义嵌入式代码格式
 
-- 违规图像实时多线程鉴别
+- [x] 对接邮箱服务，注册/找回密码等功能
 
-- 图片定期暂存
+- [x] 违规图像实时多线程鉴别
 
-- 支持多种图像格式如:`jfif`,`webp`,`ico`,`svg`等
+- [x] 图片定期暂存
 
-- 支持画廊批量分享模式
+- [x] 图片名称记录/修改
 
-- 账户图像查重上传
+- [x] 支持常见多种图像格式如:`webp`,`ico`,`svg`等等
 
-- 配置IP黑名单操作
+- [x] 支持画廊批量分享模式
 
-- 站点上传可控API接口
+- [x] 账户图像查重上传
 
-- 设置用户可用容量
+- [x] 配置IP黑名单操作
 
-- 账户扩容码批量生成
+- [x] 站点上传可控API接口
 
-- 细致的上传分发配置，分发群组功能
+- [x] 设置用户可用容量
 
-- 游客、用户的上传管理
+- [x] 账户扩容码批量生成
 
-- 图像直链二维码生成
+- [x] 细致的上传分发配置，分发群组功能
 
+- [x] 游客、用户的上传管理
+
+- [x] 图像直链二维码生成
+
+### 快速开始
+
+**Docker-compose部署:**
+
+1. 创建`docker-compose.yml`文件
+
+   > 在服务器的任意目录创建的文件夹中创建`docker-compose.yml`文件，内容如下：
+   >
+   > (修改下方前`端域名`，`后端域名`，`数据库密码`等注释的信息，特别要注意文件格式缩进不可以乱改)
+
+   ```yml
+   version: "3"
+   services:
+     tbed-free:
+       # 具体版本号需要填写目前发行的最新版本
+       image: hellohao/tbed-free:2023xxxx
+       networks:
+         hellohao_network:
+       ports:
+         - "10088:10088"
+         - "10089:10089"
+       volumes:
+         - /HellohaoData/:/HellohaoData/
+       environment:
+         MYSQL_URL: jdbc:mysql://hellohaodb/tbed?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+         # 数据库用户名（一般使用本镜像数据库无需修改，如果使用外部三方数据库自行修改自己的用户名）
+         MYSQL_USERNAME: root
+         # 自定设置一个MySQL的密码，请保证与下方 POSTGRES_PASSWORD 的变量值一致
+         MYSQL_PASS: tIaNGg@SHa&hIo56
+         # 前端域名(反代10089端口的域名)
+         HELLOHAO_WEB_HOST: http://pic.example.com
+         # 后端域名(反代10088端口的域名)
+         HELLOHAO_SERVER_HOST: http://server.example.com
+     hellohaodb:
+       image: hellohao/mysql-free:1.0
+       networks:
+         hellohao_network:
+       command:
+         - --default-authentication-plugin=mysql_native_password
+         - --character-set-server=utf8mb4
+         - --collation-server=utf8mb4_general_ci
+         - --explicit_defaults_for_timestamp=true
+       ports:
+         - "3307:3306"
+       volumes:
+         - /HellohaoData/mysql:/var/lib/mysql
+       environment:
+         # MySQL的密码
+         MYSQL_ROOT_PASSWORD: tIaNGg@SHa&hIo56
+   networks:
+     hellohao_network:
+   
+   
+   ```
+
+2. 启动 Hellohao 服务
+
+   ```shell
+   docker-compose up -d
+   ```
+
+更多部署教程参考程序[相关文档](http://doc.hellohao.cn)
+
+更强大的功能可[购买Core版](http://tbed.hellohao.cn/pay)程序
+
+
+### 启动项目
+> 访问你的前端域名即可
+
+初始用户名：`admin`
+初始邮箱：`admin`
+初始密码：`admin`
 
 
 ### 系统预览
 
-![首页](https://upload.cc/i1/2022/02/11/t2wCEF.png)
+![首页](https://upload.cc/i1/2023/05/23/Lsdivj.png)
 
 ![控制台详情](https://upload.cc/i1/2022/02/11/Al8UrH.png)
 
@@ -112,17 +174,27 @@ Core版：`本地`,`阿里OSS`,`又拍USS`,`七牛KODO`,`腾讯COS`,`网易NOS`,
 
 ![站点设置](https://upload.cc/i1/2022/02/11/Hj7pWM.png)
 
-[^_^]: ![首页](http://img.wwery.com/Hellohao/xI9TSKcI.png)
-[^_^]: ![控制台详情](http://img.wwery.com/Hellohao/klytOMWr.png)
-[^_^]: ![相册](http://img.wwery.com/Hellohao/2UQkXTHw.png)
-[^_^]: ![多存储源](http://img.wwery.com/Hellohao/xXSMlsTg.png)
-[^_^]: ![站点设置](http://img.wwery.com/Hellohao/n5zXistG.png)
+### 桌面客户端(win/mac)
+> 获取地址：[官网获取](https://www.hellohao.cn/app)
+
+> `开源版`/`Core版` 都可以使用
+> ![桌面客户端软件](https://upload.cc/i1/2022/07/13/5W8Pxh.png)
+
+### 微信小程序
+
+> 仅适用于对接`Core付费版`，开源版暂不可对接使用。
+> 获取地址：[官网获取](https://www.hellohao.cn/pay)
+
+
+![Hellohao图像托管](https://hellohao.cn/newassets/img/twechat.png)
+
+[//]: # "![Hellohao图像托管]&#40;https://upload.cc/i1/2022/03/28/Vnp0bT.png&#41;"
 
 
 ### 运行环境
 
 - JDK 1.8
-- MySQL5.5+
+- MySQL5.7+
 - Redis
 
 ### 所用技术
@@ -143,31 +215,9 @@ Core版：`本地`,`阿里OSS`,`又拍USS`,`七牛KODO`,`腾讯COS`,`网易NOS`,
 - JWT认证
 - Shiro
 
-
-### 部署
-
-> 部署方式分为两种：
-> 1.一键脚本部署：`Tbed-together.zip`（操作简单）
-> 2.自定义部署 前后端分离式部署:`Tbed.zip`（拓展性高适合有一定java前后端分离部署经验的人）
-> 需要注意：一键部署的端口为：服务器：`10088` 前端：`10089`
-
-详细部署教程参考程序文档：[开源版部署教程](http://doc.hellohao.cn/#/opensource)
-
-### 启动项目
-
-初始用户名：`admin`
-初始邮箱：`admin`
-初始密码`admin`
-
-### 微信小程序
-> 目前已有测试版，更多功能开发中，开发进度的快慢要根据作者的工作压力、心情状况等自身情况进行评估。
-> 暂时无法给出具体发布小程序的时间。大家期待吧。
-
-![Hellohao图像托管](https://upload.cc/i1/2022/03/28/Vnp0bT.png)
-
-[^_^]: ![小程序UI](https://upload.cc/i1/2022/02/11/6kPmr8.png)
-
 ### 声明
+Hellohao图像托管已申请[**中国国家版权局计算机软件著作权**](https://register.ccopyright.com.cn/query.html)登记，受法律法规保护。
+> 登记号：2023SR1210640
 
 本项目遵循[GNU Affero General Public License v3.0](https://choosealicense.com/licenses/agpl-3.0/#)开源协议，使用前请悉知。
 如果你想商用或程序定制，请先与我们联系，分享你的利益。
@@ -175,14 +225,13 @@ Core版：`本地`,`阿里OSS`,`又拍USS`,`七牛KODO`,`腾讯COS`,`网易NOS`,
 
 ### 反馈交流
 
-**如果你遇到BUG可以去我的博客反馈**
-Hellohao博客: [http://www.hellohao.cn/](http://www.hellohao.cn/)
+**如果你遇到BUG欢迎反馈**
 
-欢迎加入Hellohao开发者交流群，群聊号码：**864800972**
+- 前往论坛发帖反馈、求助：[Hellohao开发者交流论坛](http://bbs.hellohao.cn)
+- 也可加QQ群探讨：864800972
 
-### 捐赠开发者
+### 更多
 
-**如果你也支持Hellohao图床，可以请我喝杯咖啡。我会持续更新Hellohao图床**
-
-**捐赠地址:** [**https://tbed.hellohao.cn/pay**](https://tbed.hellohao.cn/pay)
+**如需程序定制或其他业务，请与我们取得联系**
+[Hellohao图像托管官网](http://hellohao.cn)
 

docker/Dockerfile-tbed

@@ -0,0 +1,17 @@
+FROM openjdk:8
+
+MAINTAINER 923453645@qq.com
+
+ADD hellohaotbed/ /hellohaotbed
+
+COPY appstart.sh /appstart.sh
+
+COPY application.properties /application.properties
+
+COPY Tbed.jar /Tbed.jar
+
+EXPOSE 10088
+
+EXPOSE 10089
+
+CMD ["/bin/bash","/appstart.sh"]

pom.xml

@@ -67,7 +67,7 @@
         <dependency>
             <groupId>org.apache.shiro</groupId>
             <artifactId>shiro-spring</artifactId>
-            <version>1.7.1</version>
+            <version>1.9.0</version>
         </dependency>
         <dependency>
             <groupId>com.auth0</groupId>
@@ -90,11 +90,11 @@
             <artifactId>spring-boot-starter-validation</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>commons-logging</groupId>
-            <artifactId>commons-logging</artifactId>
-            <version>1.2</version>
-        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>commons-logging</groupId>-->
+<!--            <artifactId>commons-logging</artifactId>-->
+<!--            <version>1.2</version>-->
+<!--        </dependency>-->
         <dependency>
             <groupId>com.github.pagehelper</groupId>
             <artifactId>pagehelper-spring-boot-starter</artifactId>
@@ -108,7 +108,7 @@
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>fastjson</artifactId>
-            <version>1.2.76</version>
+            <version>2.0.7</version>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
@@ -120,17 +120,31 @@
             <artifactId>pebble</artifactId>
             <version>3.1.5</version>
         </dependency>
-
+        <dependency>
+            <groupId>com.amazonaws</groupId>
+            <artifactId>aws-java-sdk-s3</artifactId>
+            <version>1.12.334</version>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-mail</artifactId>
             <version>2.5.1</version>
         </dependency>
-
+<!--        webdav-->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.14</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.lookfirst</groupId>
+            <artifactId>sardine</artifactId>
+            <version>5.10</version>
+        </dependency>
         <dependency>
             <groupId>com.baidu.aip</groupId>
             <artifactId>java-sdk</artifactId>
-            <version>4.11.0</version>
+            <version>4.16.14</version>
         </dependency>
         <dependency>
             <groupId>net.coobird</groupId>
@@ -192,7 +206,7 @@
         <dependency>
             <groupId>com.qiniu</groupId>
             <artifactId>qiniu-java-sdk</artifactId>
-            <version>7.2.22</version>
+            <version>7.14.0</version>
         </dependency>
         <dependency>
             <groupId>com.qcloud</groupId>
@@ -234,7 +248,7 @@
                 <configuration>
                     <testFailureIgnore>true</testFailureIgnore>
                 </configuration>
-            </plugin>
+            </plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>8</source><target>8</target></configuration></plugin>
         </plugins>
     </build>
 

sql/tbed.sql

@@ -1,17 +1,17 @@
 /*
  Navicat Premium Data Transfer
 
- Source Server         : localhost
+ Source Server         : locMysql
  Source Server Type    : MySQL
- Source Server Version : 50720
+ Source Server Version : 80028
  Source Host           : localhost:3306
  Source Schema         : tbed
 
  Target Server Type    : MySQL
- Target Server Version : 50720
+ Target Server Version : 80028
  File Encoding         : 65001
 
- Date: 29/10/2021 14:42:28
+ Date: 01/01/2023 23:02:40
 */
 
 SET NAMES utf8mb4;
@@ -26,23 +26,42 @@ CREATE TABLE `album`  (
   `albumtitle` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `createdate` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `userid` int(10) NULL DEFAULT NULL
+  `userid` int(0) NULL DEFAULT NULL
 ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
 -- ----------------------------
 -- Records of album
 -- ----------------------------
 
+-- ----------------------------
+-- Table structure for appclient
+-- ----------------------------
+DROP TABLE IF EXISTS `appclient`;
+CREATE TABLE `appclient`  (
+  `id` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
+  `isuse` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
+  `winpackurl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `macpackurl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `appname` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `applogo` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `appupdate` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL
+) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
+
+-- ----------------------------
+-- Records of appclient
+-- ----------------------------
+INSERT INTO `appclient` VALUES ('app', 'on', '', '', 'Hellohao图像托管', 'https://hellohao.nos-eastchina1.126.net/TbedClient/app.png', '1.0.1');
+
 -- ----------------------------
 -- Table structure for code
 -- ----------------------------
 DROP TABLE IF EXISTS `code`;
 CREATE TABLE `code`  (
-  `id` int(255) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `value` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `code` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
   PRIMARY KEY (`id`) USING BTREE
-) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
+) ENGINE = InnoDB AUTO_INCREMENT = 11 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
 -- ----------------------------
 -- Records of code
@@ -53,24 +72,24 @@ CREATE TABLE `code`  (
 -- ----------------------------
 DROP TABLE IF EXISTS `config`;
 CREATE TABLE `config`  (
-  `id` int(4) NOT NULL AUTO_INCREMENT,
-  `sourcekey` int(4) NULL DEFAULT NULL,
-  `emails` int(4) NULL DEFAULT NULL COMMENT '邮箱配置',
+  `id` int(0) NOT NULL AUTO_INCREMENT,
+  `sourcekey` int(0) NULL DEFAULT NULL,
+  `emails` int(0) NULL DEFAULT NULL COMMENT '邮箱配置',
   `webname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '网站名',
-  `explain` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `explain` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
   `video` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `backtype` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '背景类型',
-  `links` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `notice` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `baidu` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `links` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
+  `notice` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
+  `baidu` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
   `domain` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `background1` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `background2` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `sett` int(2) NOT NULL COMMENT '首页样式',
+  `sett` int(0) NOT NULL COMMENT '首页样式',
   `webms` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `webkeywords` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `webfavicons` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `theme` int(4) NULL DEFAULT 1 COMMENT '主题',
+  `theme` int(0) NULL DEFAULT 1 COMMENT '主题',
   `websubtitle` mediumtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
   `logo` mediumtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
   `aboutinfo` mediumtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
@@ -80,20 +99,20 @@ CREATE TABLE `config`  (
 -- ----------------------------
 -- Records of config
 -- ----------------------------
-INSERT INTO `config` VALUES (1, 7, 1, 'Hellohao图床', 'Hellohao图像托管，是一家免费开源的图像托管，即时分享你的美好瞬间。', 'https://hellohao-cloud.oss-cn-beijing.aliyuncs.com/books_x264.mp4http://cdn.wwery.com/Hellohao/439550606022825.jpg', '1', '<p style=\"color:#7c7c88;\">&copy; 2019 <a href=\"http://www.Hellohao.cn/\" target=\"_blank\" title=\"Hellohao\">Hellohao</a><span>&nbsp;&nbsp;- All Rights Reserved</span> </p>', '也许...|这将是最好用的图床|为了更好的用户体验，建议您注册本站继续免费使用Hellohao图床。本站不得上传任何形式的非法图片，一旦发现，永久删除并禁封账户。情节严重者将相关资料交于相关部门处理。', 'var _hmt = _hmt || [];\n(function() {\n  var hm = document.createElement(\"script\");\n  hm.src = \"https://hm.baidu.com/hm.js?16c326e608c984c9bae6a63eda861888\";\n  var s = document.getElementsByTagName(\"script\")[0]; \n  s.parentNode.insertBefore(hm, s);\n})();\n\n', 'http://api.hellohao.cn', '', 'http://cdn.wwery.com/Hellohao/3e1901120091153.jpg', 1, 'Hellohao图像托管，是一家免费开源的图像托管，即时分享你的美好瞬间。', 'hellohao图床,图床,图片上传,开源图床,hellohao,图像托管，图片分享', 'https://hellohao.nos-eastchina1.126.net/BlogImg/favicon.ico', 2, '这将是你用过最优秀的图像托管程序', NULL, '<img width=\"300px\" src=\"http://img.wwery.com/Hellohao/rPscRYwz.png\">\n            <br />\n            <br />\n            <p>也许,这将是你用到最优秀的图像托管程序</p>\n            <p>本程序为Hellohao图象托管程序</p>\n            <br/>\n            <p style=\"color: #656565;\">作者：hellohao独立开发</p>\n            <p style=\"color: #656565;\">www.hellohao.cn</p>');
+INSERT INTO `config` VALUES (1, 7, 1, 'Hellohao图床', 'Hellohao图像托管，是一家免费开源的图像托管，即时分享你的美好瞬间。', 'https://hellohao-cloud.oss-cn-beijing.aliyuncs.com/books_x264.mp4http://cdn.wwery.com/Hellohao/439550606022825.jpg', '1', '<p style=\"color:#7c7c88;\">版权所有&copy;<a href=\"http://tbed.Hellohao.cn/\" target=\"_blank\" title=\"Hellohao\">Hellohao图像托管</a><span>&nbsp;2019- 2023 </span> </p>', '也许...|这将是最好用的图床|为了更好的用户体验，建议您注册本站继续免费使用Hellohao图床。本站不得上传任何形式的非法图片，一旦发现，永久删除并禁封账户。情节严重者将相关资料交于相关部门处理。', 'var _hmt = _hmt || [];\n(function() {\n  var hm = document.createElement(\"script\");\n  hm.src = \"https://hm.baidu.com/hm.js?16c326e608c984c9bae6a63eda861888\";\n  var s = document.getElementsByTagName(\"script\")[0]; \n  s.parentNode.insertBefore(hm, s);\n})();\n\n', 'http://api.hellohao.cn', '', 'http://cdn.wwery.com/Hellohao/3e1901120091153.jpg', 1, 'Hellohao图像托管，是一家免费开源的图像托管，即时分享你的美好瞬间。', 'hellohao图床,图床,图片上传,开源图床,hellohao,图像托管，图片分享', 'https://hellohao.nos-eastchina1.126.net/BlogImg/favicon.ico', 2, '这将是你用过最优秀的图像托管程序', NULL, '<img width=\"300px\" src=\"http://img.wwery.com/Hellohao/rPscRYwz.png\">\n            <br />\n            <br />\n            <p>也许,这将是你用到最优秀的图像托管程序</p>\n            <p>本程序为Hellohao图象托管程序</p>\n            <br/>\n            <p style=\"color: #656565;\">作者：hellohao独立开发</p>\n            <p style=\"color: #656565;\">www.hellohao.cn</p>');
 
 -- ----------------------------
 -- Table structure for emailconfig
 -- ----------------------------
 DROP TABLE IF EXISTS `emailconfig`;
 CREATE TABLE `emailconfig`  (
-  `id` int(2) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `emails` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '邮箱',
   `emailkey` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '授权码',
   `emailurl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '服务器',
   `port` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '端口',
   `emailname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户名',
-  `using` int(4) NULL DEFAULT NULL COMMENT '1为可用，其他为不使用',
+  `using` int(0) NULL DEFAULT NULL COMMENT '1为可用，其他为不使用',
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
@@ -107,11 +126,11 @@ INSERT INTO `emailconfig` VALUES (1, '', '', '', '465', 'Hellohao图床', 0);
 -- ----------------------------
 DROP TABLE IF EXISTS `group`;
 CREATE TABLE `group`  (
-  `id` int(255) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `groupname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '组名称',
-  `keyid` int(255) NULL DEFAULT NULL,
-  `usertype` int(4) NULL DEFAULT NULL,
-  `compress` int(4) NULL DEFAULT NULL,
+  `keyid` int(0) NULL DEFAULT NULL,
+  `usertype` int(0) NULL DEFAULT NULL,
+  `compress` int(0) NULL DEFAULT NULL,
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
@@ -140,24 +159,25 @@ INSERT INTO `imgandalbum` VALUES ('http://img.wwery.com/ccx51/5GBv93Ks.jpg', 'TO
 -- ----------------------------
 DROP TABLE IF EXISTS `imgdata`;
 CREATE TABLE `imgdata`  (
-  `id` int(255) NOT NULL AUTO_INCREMENT COMMENT '主键',
+  `id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
   `imgname` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '图片名',
   `imgurl` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '图片链接',
-  `userid` int(10) NULL DEFAULT NULL COMMENT '用户名',
+  `userid` int(0) NULL DEFAULT NULL COMMENT '用户名',
   `updatetime` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '上传时间',
   `sizes` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `abnormal` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `source` int(2) NULL DEFAULT NULL COMMENT '存储源',
-  `imgtype` int(2) NULL DEFAULT NULL,
+  `source` int(0) NULL DEFAULT NULL COMMENT '存储源',
+  `imgtype` int(0) NULL DEFAULT NULL,
   `explains` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `md5key` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `imguid` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `format` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `about` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
   `violation` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
+  `idname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '未命名图像',
   PRIMARY KEY (`id`) USING BTREE,
   INDEX `index_md5key_url`(`md5key`(255), `imgurl`(255)) USING BTREE
-) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compressed;
+) ENGINE = InnoDB AUTO_INCREMENT = 12 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compressed;
 
 -- ----------------------------
 -- Records of imgdata
@@ -168,12 +188,12 @@ CREATE TABLE `imgdata`  (
 -- ----------------------------
 DROP TABLE IF EXISTS `imgreview`;
 CREATE TABLE `imgreview`  (
-  `id` int(4) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `app_id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `api_key` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `secret_key` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `Using` int(4) NULL DEFAULT NULL,
-  `count` int(255) NULL DEFAULT NULL COMMENT '拦截数量',
+  `Using` int(0) NULL DEFAULT NULL,
+  `count` int(0) NULL DEFAULT NULL COMMENT '拦截数量',
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
@@ -187,7 +207,7 @@ INSERT INTO `imgreview` VALUES (1, '', '', '', 0, 0);
 -- ----------------------------
 DROP TABLE IF EXISTS `imgtemp`;
 CREATE TABLE `imgtemp`  (
-  `id` int(255) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `imguid` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `deltime` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   PRIMARY KEY (`id`) USING BTREE
@@ -202,13 +222,13 @@ CREATE TABLE `imgtemp`  (
 -- ----------------------------
 DROP TABLE IF EXISTS `keys`;
 CREATE TABLE `keys`  (
-  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `AccessKey` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `AccessSecret` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `Endpoint` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `Bucketname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `RequestAddress` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `storageType` int(11) NULL DEFAULT NULL,
+  `storageType` int(0) NULL DEFAULT NULL,
   `keyname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '未定义策略名称' COMMENT '策略名称',
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 14 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
@@ -230,8 +250,8 @@ INSERT INTO `keys` VALUES (13, '', '', '', '0', '', 7, 'ftp');
 -- ----------------------------
 DROP TABLE IF EXISTS `sysconfig`;
 CREATE TABLE `sysconfig`  (
-  `id` int(2) NOT NULL AUTO_INCREMENT,
-  `register` int(2) NOT NULL COMMENT '是否可以注册',
+  `id` int(0) NOT NULL AUTO_INCREMENT,
+  `register` int(0) NOT NULL COMMENT '是否可以注册',
   `checkduplicate` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0',
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
@@ -246,19 +266,19 @@ INSERT INTO `sysconfig` VALUES (1, 1, '0');
 -- ----------------------------
 DROP TABLE IF EXISTS `uploadconfig`;
 CREATE TABLE `uploadconfig`  (
-  `id` int(2) NOT NULL AUTO_INCREMENT,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `filesizetourists` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `filesizeuser` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `imgcounttourists` int(10) NULL DEFAULT NULL COMMENT '游客文件总数量, 超出则不允许加入队列',
-  `imgcountuser` int(10) NULL DEFAULT NULL COMMENT '用户文件总数量, 超出则不允许加入队列',
+  `imgcounttourists` int(0) NULL DEFAULT NULL COMMENT '游客文件总数量, 超出则不允许加入队列',
+  `imgcountuser` int(0) NULL DEFAULT NULL COMMENT '用户文件总数量, 超出则不允许加入队列',
   `suffix` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '支持后缀',
-  `urltype` int(2) NULL DEFAULT NULL COMMENT 'url类型',
-  `isupdate` int(2) NULL DEFAULT NULL COMMENT '禁止游客上传',
-  `api` int(2) NOT NULL COMMENT '开启api',
+  `urltype` int(0) NULL DEFAULT NULL COMMENT 'url类型',
+  `isupdate` int(0) NULL DEFAULT NULL COMMENT '禁止游客上传',
+  `api` int(0) NOT NULL COMMENT '开启api',
   `visitormemory` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `usermemory` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `blacklist` varchar(4000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `userclose` int(4) NULL DEFAULT 0 COMMENT '用户上传开关',
+  `userclose` int(0) NULL DEFAULT 0 COMMENT '用户上传开关',
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
@@ -272,32 +292,33 @@ INSERT INTO `uploadconfig` VALUES (1, '10485760', '20971520', 5, 10, 'gif,jpg,jp
 -- ----------------------------
 DROP TABLE IF EXISTS `user`;
 CREATE TABLE `user`  (
-  `id` int(10) NOT NULL AUTO_INCREMENT COMMENT '主键',
+  `id` int(0) NOT NULL AUTO_INCREMENT,
   `username` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
   `password` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
   `email` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `birthder` date NULL DEFAULT NULL COMMENT '注册时间',
-  `level` int(10) NULL DEFAULT NULL COMMENT '等级',
+  `level` int(0) NULL DEFAULT NULL COMMENT '等级',
   `uid` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户唯一标识',
-  `isok` int(2) NOT NULL,
+  `isok` int(0) NOT NULL,
   `memory` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `groupid` int(255) NULL DEFAULT NULL,
+  `groupid` int(0) NULL DEFAULT NULL,
+  `token` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 
 -- ----------------------------
 -- Records of user
 -- ----------------------------
-INSERT INTO `user` VALUES (1, 'admin', 'YWRtaW4=', 'admin', '2019-01-10', 2, 'e95c0571bfe04ec680c249fb15cc22e9', 1, '2147483648', 1);
+INSERT INTO `user` VALUES (1, 'admin', 'YWRtaW4=', 'admin', '2019-01-10', 2, '05bc9cdc2d454ab59e9cd7eaa9ed296a', 1, '2147483648', 1, '');
 
 -- ----------------------------
 -- Table structure for usergroup
 -- ----------------------------
 DROP TABLE IF EXISTS `usergroup`;
 CREATE TABLE `usergroup`  (
-  `id` int(255) NOT NULL AUTO_INCREMENT,
-  `userid` int(255) NULL DEFAULT NULL,
-  `groupid` int(255) NULL DEFAULT NULL,
+  `id` int(0) NOT NULL AUTO_INCREMENT,
+  `userid` int(0) NULL DEFAULT NULL,
+  `groupid` int(0) NULL DEFAULT NULL,
   PRIMARY KEY (`id`) USING BTREE
 ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
 

src/main/java/cn/hellohao/TbedApplication.java

@@ -1,24 +1,25 @@
 package cn.hellohao;
 
-import javax.servlet.MultipartConfigElement;
-import javax.servlet.http.HttpServletRequest;
-
-import cn.hellohao.utils.Print;
+import cn.hellohao.dao.KeysMapper;
+import cn.hellohao.utils.FirstRun;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.jdbc.DatabaseDriver;
 import org.springframework.boot.web.servlet.MultipartConfigFactory;
 import org.springframework.boot.web.servlet.ServletComponentScan;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.PropertySource;
+import org.springframework.jdbc.support.DatabaseStartupValidator;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 import org.springframework.util.unit.DataSize;
-import org.springframework.web.context.request.RequestContextHolder;
-import org.springframework.web.context.request.ServletRequestAttributes;
 
+import javax.servlet.MultipartConfigElement;
+import javax.sql.DataSource;
 import java.net.InetAddress;
-import java.util.Scanner;
+import java.net.Socket;
+import java.util.stream.Stream;
 
 @SpringBootApplication
 @Configuration
@@ -30,6 +31,31 @@ public class TbedApplication {
 public static void main(String[] args) {
     SpringApplication.run(TbedApplication.class, args);
     }
+
+    //延缓Spring Boot启动时间直到数据库启动的方法
+    @Bean
+    public DatabaseStartupValidator databaseStartupValidator(DataSource dataSource) {
+        DatabaseStartupValidator databaseStartupValidator = new DatabaseStartupValidator();
+        databaseStartupValidator.setDataSource(dataSource);
+        databaseStartupValidator.setValidationQuery(DatabaseDriver.POSTGRESQL.getValidationQuery());
+        return databaseStartupValidator;
+    }
+    @Bean
+    public static BeanFactoryPostProcessor dependsOnPostProcessor() {
+        return bf -> {
+            // Let beans that need the database depend on the DatabaseStartupValidator
+            // like the JPA EntityManagerFactory or Flyway
+            String[] flyway = bf.getBeanNamesForType(FirstRun.class);
+            Stream.of(flyway)
+                    .map(bf::getBeanDefinition)
+                    .forEach(it -> it.setDependsOn("databaseStartupValidator"));
+
+            String[] jpa = bf.getBeanNamesForType(KeysMapper.class);
+            Stream.of(jpa)
+                    .map(bf::getBeanDefinition)
+                    .forEach(it -> it.setDependsOn("databaseStartupValidator"));
+        };
+    }
     /**
      * 文件上传配置
      * @return

src/main/java/cn/hellohao/auth/filter/SubjectFilter.java

@@ -10,10 +10,12 @@ import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.subject.Subject;
 import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
+
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import java.io.PrintWriter;
 
 /**
  * @author Hellohao
@@ -32,9 +34,9 @@ public class SubjectFilter extends BasicHttpAuthenticationFilter {
         HttpServletResponse httpServletResponse =(HttpServletResponse) response;
         String serviceName = httpServletRequest.getServletPath();//获取接口
         String Users_Origin = httpServletRequest.getHeader("usersOrigin");
-
-        //验证前端域名
-        if(httpServletRequest.getMethod().equals("POST") && !serviceName.contains("/api") && !serviceName.contains("/verifyCode")){
+        String token = httpServletRequest.getHeader("Authorization");
+        if(httpServletRequest.getMethod().equals("POST") && !serviceName.contains("/api") && !serviceName.contains("/verifyCode")
+                && !serviceName.contains("/getClientVersion") && !serviceName.contains("/client")){
             try{
                 if(Users_Origin.compareTo(SecureUtil.md5(WEBHOST))!=0){
                     System.out.println("前端域名校验未通过");
@@ -50,10 +52,39 @@ public class SubjectFilter extends BasicHttpAuthenticationFilter {
                 return false;
             }
         }
-        String token = httpServletRequest.getHeader("Authorization");
+
+        if(serviceName.contains("/client")){
+            token = httpServletRequest.getHeader("jwttoken");
+            String userToken = httpServletRequest.getHeader("userToken");
+            User user = new User();
+            user.setToken(userToken);
+            User userData = userService.loginByToken(userToken);
+            if(null==userData){
+                this.CODE = "110404";
+                return false;
+            }else{
+                if(userData.getIsok()<1){
+                    this.CODE = "110403";
+                    return false;
+                }
+                Subject sub = SecurityUtils.getSubject();
+                User u = (User) sub.getPrincipal();
+                if(null==u){
+                    httpServletRequest.getSession().setAttribute("user",userData);
+                    Subject subject = SecurityUtils.getSubject();
+                    UsernamePasswordToken tokenOBJ = new UsernamePasswordToken(userData.getEmail(),userData.getPassword());
+                    tokenOBJ.setRememberMe(true);
+                    subject.login(tokenOBJ);
+                    SecurityUtils.getSubject().getSession().setTimeout(3600000);
+                    User loginUser = (User) SecurityUtils.getSubject().getPrincipal();
+                }
+            }
+        }
+
+//        String token = httpServletRequest.getHeader("Authorization");
         JSONObject jsonObject = JWTUtil.checkToken(token);
         if(!jsonObject.getBoolean("check")){
-            if(!serviceName.contains("admin")){
+            if(!serviceName.contains("admin") || serviceName.contains("admin/client")){
                 return true;
             }else{
                 this.CODE = "403";
@@ -69,7 +100,6 @@ public class SubjectFilter extends BasicHttpAuthenticationFilter {
                     subject.login(tokenOBJ);
                     SecurityUtils.getSubject().getSession().setTimeout(3600000);//一小时
                 } catch (Exception e) {
-//                    System.err.println("拦截器，登录失败，false");
                     this.CODE = "403";
                     return false;
                 }
@@ -102,13 +132,22 @@ public class SubjectFilter extends BasicHttpAuthenticationFilter {
                 info = "当前用户无权访问该请求";
             }else if(this.CODE.equals("402")){
                 info = "当前web请求不合规";
+            }else if(this.CODE.equals("110403")){
+                info = "该账户暂时无法使用";
+            }else if(this.CODE.equals("110404")){
+                info = "用户未找到";
             }
             System.err.println("拦截器False-"+info);
-            response.setContentType("application/json;charset=UTF-8");
-            final JSONObject jsonObject = new JSONObject();
+            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
+            httpServletResponse.setStatus(HttpServletResponse.SC_OK);
+            httpServletResponse.setCharacterEncoding("UTF-8");
+            httpServletResponse.setContentType("application/json");
+            PrintWriter writer = httpServletResponse.getWriter();
+            JSONObject jsonObject = new JSONObject();
             jsonObject.put("code",this.CODE);
             jsonObject.put("info",info);
-            response.getWriter().write(jsonObject.toJSONString());
+            writer.write(jsonObject.toJSONString());
+            writer.flush();
         } catch (Exception e) {
             System.out.println("返回token验证失败403请求，报异常了");
         }

src/main/java/cn/hellohao/auth/filter/xss/XssFilter.java

@@ -24,7 +24,6 @@ public class XssFilter implements Filter {
         //由于我的@WebFilter注解配置的是urlPatterns="/*"(过滤所有请求),所以这里对不需要过滤的静态资源url,作忽略处理(大家可以依照具体需求配置)
         String[] exclusionsUrls = {".js",".gif",".jpg",".png",".bmp",".css",".ico"};//,"/","/index","/admin/root/"
         for (String str : exclusionsUrls) {
-            //System.out.println(path.contains(str));
             if (path.contains(str)) {
                 filterChain.doFilter(servletRequest,servletResponse);
                 return;

src/main/java/cn/hellohao/auth/filter/xss/XssHttpServletRequestWrapper.java

@@ -89,8 +89,6 @@ public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
         String line = "";
         StringBuilder body = new StringBuilder();
         int counter = 0;
-
-        // 读取POST提交的数据内容
         BufferedReader reader = new BufferedReader(new InputStreamReader(stream, Charset.forName("UTF-8")));
         try {
             while ((line = reader.readLine()) != null) {

src/main/java/cn/hellohao/auth/shiro/ShiroConfig.java

@@ -31,7 +31,9 @@ public class ShiroConfig {
         filterMap.put("/verifyCode","anon");
         filterMap.put("/verifyCodeForRegister","anon");
         filterMap.put("/verifyCodeForRetrieve","anon");
+        filterMap.put("/verifyCodeFortowSendEmail","anon");
         filterMap.put("/api/**","anon");
+        filterMap.put("/w/**","anon");
         filterMap.put("/user/**","anon");
         filterMap.put("/ota/**","anon");
         filterMap.put("/admin/root/**","roles[admin]");

src/main/java/cn/hellohao/auth/shiro/UserRealm.java

@@ -2,6 +2,7 @@ package cn.hellohao.auth.shiro;
 
 import cn.hellohao.pojo.User;
 import cn.hellohao.service.UserService;
+import cn.hellohao.utils.SetText;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.authc.*;
 import org.apache.shiro.authz.AuthorizationInfo;
@@ -46,7 +47,11 @@ public class UserRealm extends AuthorizingRealm {
         UsernamePasswordToken userToken = null;
         userToken = (UsernamePasswordToken)tokenOBJ;
         User user = new User();
-        user.setEmail(userToken.getUsername());
+        if(SetText.checkEmail(userToken.getUsername())){
+            user.setEmail(userToken.getUsername());
+        }else{
+            user.setUsername(userToken.getUsername());
+        }
         User u = userService.getUsers(user);
         if(u==null){
             return null;

src/main/java/cn/hellohao/auth/token/JWTUtil.java

@@ -8,7 +8,6 @@ import com.auth0.jwt.algorithms.Algorithm;
 import com.auth0.jwt.exceptions.TokenExpiredException;
 import com.auth0.jwt.interfaces.DecodedJWT;
 
-import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;
 
@@ -24,7 +23,7 @@ public class JWTUtil {
 
     public static String createToken(User user){
         Calendar calendar = Calendar.getInstance();
-        calendar.add(Calendar.SECOND,604800 );//单位秒，604800 为7天
+        calendar.add(Calendar.SECOND,2592000 );//单位秒
         Algorithm algorithm = Algorithm.HMAC256(SECRET);
         String token = JWT.create()
                 .withClaim("email", user.getEmail())

src/main/java/cn/hellohao/config/GlobalConstant.java

@@ -10,4 +10,7 @@ import java.io.File;
 public class GlobalConstant {
     public static String SYSTYPE = "LINUX";
     public static String LOCPATH = File.separator + "HellohaoData";
+
+    public static final String HELLOHAOTEMPIMG_PATH = File.separator + "HellohaoData"+File.separator+"hellohaotempimg";
+
 }

src/main/java/cn/hellohao/config/LogSystemProxy.java

@@ -0,0 +1,44 @@
+package cn.hellohao.config;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Configuration;
+import javax.annotation.PostConstruct;
+import java.io.PrintStream;
+import java.util.function.Consumer;
+
+@Configuration
+public class LogSystemProxy {
+
+    private final static Logger log = LoggerFactory.getLogger("proxy.system.log");
+
+    @PostConstruct
+    public void initProxy(){
+        log.debug("LogSystemProxy init .....");
+        System.setOut(getLoggerProxy(StdType.OUT));
+        System.setErr(getLoggerProxy(StdType.ERR));
+    }
+
+
+    private enum StdType{
+        OUT(System.out, log::info),
+        ERR(System.err, log::error),
+        ;
+        PrintStream stream;
+        Consumer<String> consumer;
+        StdType(PrintStream stream,Consumer<String> consumer){
+            this.stream = stream;
+            this.consumer = consumer;
+        }
+    }
+
+    private PrintStream getLoggerProxy(StdType stdType){
+        return new PrintStream(stdType.stream){
+            @Override
+            public void print(String s) {
+                stdType.stream.print(s);
+                stdType.consumer.accept(s);
+            }
+        };
+    }
+}

src/main/java/cn/hellohao/config/PoolConfig.java

@@ -0,0 +1,52 @@
+package cn.hellohao.config;
+
+import lombok.Data;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+import java.util.concurrent.ThreadPoolExecutor;
+
+//线程池
+@Configuration
+@EnableAsync
+public class PoolConfig {
+    ThreadPoolProperties properties = new ThreadPoolProperties();
+    @Bean(name = "taskExecutor")
+    public ThreadPoolTaskExecutor taskExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(properties.getCorePoolSize()); //设置核心线程数
+        executor.setMaxPoolSize(properties.getMaxPoolSize()); //设置最大线程数
+        executor.setQueueCapacity(properties.getQueueCapacity()); //设置队列容量
+        executor.setThreadNamePrefix(properties.getThreadNamePrefix());
+        executor.setKeepAliveSeconds(properties.getKeepAliveTime());
+        executor.setWaitForTasksToCompleteOnShutdown(properties.isWaitForTasksToCompleteOnShutdown());
+        executor.setAwaitTerminationSeconds(properties.getAwaitTerminationSeconds());
+        // 设置任务拒绝策略
+        /**
+         * 4种
+         * ThreadPoolExecutor类有几个内部实现类来处理这类情况：
+         - AbortPolicy 丢弃任务，抛RejectedExecutionException
+         - CallerRunsPolicy 由该线程调用线程运行。直接调用Runnable的run方法运行。
+         - DiscardPolicy  抛弃策略，直接丢弃这个新提交的任务
+         - DiscardOldestPolicy 抛弃旧任务策略，从队列中踢出最先进入队列（最后一个执行）的任务
+         * 实现RejectedExecutionHandler接口，可自定义处理器
+         */
+        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+        return executor;
+    }
+
+    @Data
+    class ThreadPoolProperties {
+        private int corePoolSize = 5;
+        private int maxPoolSize = 50;
+        private int keepAliveTime = 15;
+        private int queueCapacity = 10;
+        private String threadNamePrefix = "Tbed-Thread";
+        private boolean allowCoreThreadTimeout = false;
+        private boolean waitForTasksToCompleteOnShutdown = false;
+        private int awaitTerminationSeconds;
+
+    }
+}

src/main/java/cn/hellohao/controller/AdminController.java

@@ -4,17 +4,26 @@ import cn.hellohao.config.SysName;
 import cn.hellohao.pojo.*;
 import cn.hellohao.pojo.vo.PageResultBean;
 import cn.hellohao.service.*;
-import cn.hellohao.service.impl.*;
-import cn.hellohao.utils.*;
+import cn.hellohao.service.impl.AlbumServiceImpl;
+import cn.hellohao.service.impl.UserServiceImpl;
+import cn.hellohao.service.impl.deleImages;
+import cn.hellohao.utils.SetFiles;
+import cn.hellohao.utils.SetText;
+import cn.hellohao.utils.progress.MyProgress;
+import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.subject.Subject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.*;
+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.ResponseBody;
 
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
@@ -29,98 +38,78 @@ import java.util.*;
 @RequestMapping("/admin")
 public class AdminController {
 
-    @Autowired
-    private ImgService imgService;
-    @Autowired
-    private KeysService keysService;
-    @Autowired
-    private UserServiceImpl userService;
-    @Autowired
-    private ImgreviewService imgreviewService;
-    @Autowired
-    private ImgTempService imgTempService;
-    @Autowired
-    private UploadConfigService uploadConfigService;
-    @Autowired
-    private CodeService codeService;
-    @Autowired
-    private ImgAndAlbumService imgAndAlbumService;
-    @Autowired
-    private AlbumService albumService;
-    @Autowired
-    AlbumServiceImpl albumServiceI;
+    @Autowired private ImgService imgService;
+    @Autowired private KeysService keysService;
+    @Autowired private UserServiceImpl userService;
+    @Autowired private ImgreviewService imgreviewService;
+    @Autowired private UploadConfigService uploadConfigService;
+    @Autowired private CodeService codeService;
+    @Autowired private AlbumService albumService;
+    @Autowired AlbumServiceImpl albumServiceI;
+    @Autowired private deleImages deleimages;
+    @Autowired private IRedisService iRedisService;
 
-    @Autowired
-    private NOSImageupload nosImageupload;
-    @Autowired
-    private OSSImageupload ossImageupload;
-    @Autowired
-    private COSImageupload cosImageupload;
-    @Autowired
-    private KODOImageupload kodoImageupload;
-    @Autowired
-    private USSImageupload ussImageupload;
-    @Autowired
-    private UFileImageupload uFileImageupload;
-    @Autowired
-    private FTPImageupload ftpImageupload;
-
-
-    @PostMapping(value = "/overviewData") //new
+    @PostMapping(value = "/overviewData")
     @ResponseBody
     public Msg overviewData(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         Subject subject = SecurityUtils.getSubject();
         User user = (User) subject.getPrincipal();
-        user =  userService.getUsers(user);
+        user = userService.getUsers(user);
         JSONObject jsonObject = new JSONObject();
         UploadConfig uploadConfig = uploadConfigService.getUpdateConfig();
-        Imgreview imgreview = imgreviewService.selectByPrimaryKey(1);//查询非法个数
-        Imgreview isImgreviewOK = imgreviewService.selectByusing(1);//查询有没有启动鉴别功能
+        Imgreview imgreview = imgreviewService.selectByPrimaryKey(1);
+        Imgreview isImgreviewOK = imgreviewService.selectByusing(1);
         String ok = "false";
-        jsonObject.put("myImgTotal", imgService.countimg(user.getId())); //我的图片数
-        jsonObject.put("myAlbumTitle", albumService.selectAlbumCount(user.getId()));//我的画廊数量
-        long memory = Long.valueOf(user.getMemory());//分配量
-        Long usermemory = imgService.getusermemory(user.getId())==null?0L:imgService.getusermemory(user.getId());
-        if(memory==0){
-            jsonObject.put("myMemory","无容量");
-        }else{
-            Double aDouble = Double.valueOf(String.format("%.2f", (((double)usermemory/(double)memory)*100)));
-            if(aDouble>=999){
-                jsonObject.put("myMemory",999);
-            }else{
-                jsonObject.put("myMemory",aDouble);
+        jsonObject.put("myToken", user.getToken());
+        jsonObject.put("myImgTotal", imgService.countimg(user.getId()));
+        jsonObject.put("myAlbumTitle", albumService.selectAlbumCount(user.getId()));
+        long memory = Long.valueOf(user.getMemory());
+        Long usermemory =
+                imgService.getusermemory(user.getId()) == null
+                        ? 0L
+                        : imgService.getusermemory(user.getId());
+        if (memory == 0) {
+            jsonObject.put("myMemory", "无容量");
+        } else {
+            Double aDouble =
+                    Double.valueOf(String.format("%.2f", (((double) usermemory / (double) memory) * 100)));
+            if (aDouble >= 999) {
+                jsonObject.put("myMemory", 999);
+            } else {
+                jsonObject.put("myMemory", aDouble);
             }
         }
-        jsonObject.put("myMemorySum",SetFiles.readableFileSize(memory));
-        if(user.getLevel()>1){
+        jsonObject.put("myMemorySum", SetFiles.readableFileSize(memory));
+        if (user.getLevel() > 1) {
             ok = "true";
-            //管理员
-            jsonObject.put("imgTotal", imgService.counts(null) ); //站点图片数
+            jsonObject.put("imgTotal", imgService.counts(null));
             jsonObject.put("userTotal", userService.getUserTotal());
-            jsonObject.put("ViolationImgTotal", imgreview.getCount()); //非法图片
-            jsonObject.put("ViolationSwitch", isImgreviewOK==null?0:isImgreviewOK.getId()); //非法图片开关
-            jsonObject.put("VisitorUpload", uploadConfig.getIsupdate());//是否禁用了游客上传
-            jsonObject.put("VisitorMemory", SetFiles.readableFileSize(Long.valueOf(uploadConfig.getVisitormemory())));//访客共大小
-            if(uploadConfig.getIsupdate()!=1){
-                jsonObject.put("VisitorUpload", 0);//是否禁用了游客上传
-                jsonObject.put("VisitorProportion",100.00);//游客用量%占比
-                jsonObject.put("VisitorMemory", "禁用");//访客共大小
-            }else{
-                Long temp = imgService.getusermemory(0)==null?0:imgService.getusermemory(0);
-                jsonObject.put("UsedMemory", (temp == null ? 0 : SetFiles.readableFileSize(temp)));//访客已用大小
-                if(Long.valueOf(uploadConfig.getVisitormemory())==0){
-                    jsonObject.put("VisitorProportion",100.00);//游客用量%占比
-                }else if(Long.valueOf(uploadConfig.getVisitormemory())==-1){
-                    jsonObject.put("VisitorProportion",0);//游客用量%占比
-                    jsonObject.put("VisitorMemory", "无限");//访客共大小
-                }else{
+            jsonObject.put("ViolationImgTotal", imgreview.getCount());
+            jsonObject.put("ViolationSwitch", isImgreviewOK == null ? 0 : isImgreviewOK.getId());
+            jsonObject.put("VisitorUpload", uploadConfig.getIsupdate());
+            jsonObject.put(
+                    "VisitorMemory",
+                    SetFiles.readableFileSize(Long.valueOf(uploadConfig.getVisitormemory()))); // 访客共大小
+            if (uploadConfig.getIsupdate() != 1) {
+                jsonObject.put("VisitorUpload", 0);
+                jsonObject.put("VisitorProportion", 100.00);
+                jsonObject.put("VisitorMemory", "禁用");
+            } else {
+                Long temp = imgService.getusermemory(0) == null ? 0 : imgService.getusermemory(0);
+                jsonObject.put("UsedMemory", (temp == null ? 0 : SetFiles.readableFileSize(temp)));
+                if (Long.valueOf(uploadConfig.getVisitormemory()) == 0) {
+                    jsonObject.put("VisitorProportion", 100.00);
+                } else if (Long.valueOf(uploadConfig.getVisitormemory()) == -1) {
+                    jsonObject.put("VisitorProportion", 0);
+                    jsonObject.put("VisitorMemory", "无限");
+                } else {
                     double sum = Double.valueOf(uploadConfig.getVisitormemory());
                     Double aDouble = Double.valueOf(String.format("%.2f", ((double) temp / sum) * 100));
-                    if(aDouble>=999){
-                        jsonObject.put("VisitorProportion",999);//游客用量%占比
-                    }else{
-                        jsonObject.put("VisitorProportion",aDouble);//游客用量%占比
+                    if (aDouble >= 999) {
+                        jsonObject.put("VisitorProportion", 999);
+                    } else {
+                        jsonObject.put("VisitorProportion", aDouble);
                     }
                 }
             }
@@ -130,58 +119,77 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping(value = "/SpaceExpansion")//new
+    @PostMapping(value = "/SpaceExpansion")
     @ResponseBody
     public Msg SpaceExpansion(@RequestParam(value = "data", defaultValue = "") String data) {
-        final Msg msg = new Msg();
-        final JSONObject jsonObject = JSONObject.parseObject(data);
+        Msg msg = new Msg();
+        JSONObject jsonObject = JSONObject.parseObject(data);
         Subject subject = SecurityUtils.getSubject();
         User user = (User) subject.getPrincipal();
-        user =  userService.getUsers(user);
-        if(user.getIsok()==0){
+        user = userService.getUsers(user);
+        if (user.getIsok() == 0) {
             msg.setCode("100403");
             msg.setInfo("你暂时无法使用此功能");
             return msg;
         }
-        if(null==user){
+        if (null == user) {
             msg.setCode("100405");
             msg.setInfo("用户信息不存在");
             return msg;
-        }else{
+        } else {
             long sizes = 0;
             Code code = codeService.selectCodekey(jsonObject.getString("code"));
-            if(null==code){
+            if (null == code) {
                 msg.setCode("100404");
                 msg.setInfo("扩容码不存在,请重新填写");
                 return msg;
             }
             Long userMemory = Long.valueOf(user.getMemory());
-            sizes = Long.valueOf(code.getValue())+ userMemory;
+            sizes = Long.valueOf(code.getValue()) + userMemory;
             User newMemoryUser = new User();
             newMemoryUser.setMemory(Long.toString(sizes));
             newMemoryUser.setId(user.getId());
-            userService.usersetmemory(newMemoryUser,jsonObject.getString("code"));
-            msg.setInfo("你已成功扩容"+SetFiles.readableFileSize(sizes));
+            userService.usersetmemory(newMemoryUser, jsonObject.getString("code"));
+            msg.setInfo("你已成功扩容" + SetFiles.readableFileSize(sizes));
             return msg;
         }
     }
 
-    @PostMapping("/getRecently")//new
+    @PostMapping(value = {"/setImgFileName", "/client/setImgFileName"})
     @ResponseBody
-    public Msg getRecently(@RequestParam(value = "data", defaultValue = "") String data) {
+    public Msg setImgFileName(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
-        final JSONObject jsonObject = new JSONObject();
+        try {
+            JSONObject jsonObject = JSONObject.parseObject(data);
+            String name = jsonObject.getString("name");
+            String imgname = jsonObject.getString("imgname");
+            Images images = new Images();
+            images.setIdname(name.replaceAll(" ", ""));
+            images.setImgname(imgname);
+            imgService.setImg(images);
+        } catch (Exception e) {
+            e.printStackTrace();
+            msg.setCode("500");
+        }
+        return msg;
+    }
+
+    @PostMapping("/getRecently")
+    @ResponseBody
+    public Msg getRecently() {
+        Msg msg = new Msg();
+        JSONObject jsonObject = new JSONObject();
         try {
             Subject subject = SecurityUtils.getSubject();
             User user = (User) subject.getPrincipal();
-            user =  userService.getUsers(user);
-            if(user.getLevel()>1){
-                jsonObject.put("RecentlyUser",imgService.RecentlyUser());
-                jsonObject.put("RecentlyUploaded",imgService.RecentlyUploaded(user.getId()));
-            }else{
-                jsonObject.put("RecentlyUploaded",imgService.RecentlyUploaded(user.getId()));
+            user = userService.getUsers(user);
+            if (user.getLevel() > 1) {
+                jsonObject.put("RecentlyUser", imgService.RecentlyUser());
+                jsonObject.put("RecentlyUploaded", imgService.RecentlyUploaded(user.getId()));
+            } else {
+                jsonObject.put("RecentlyUploaded", imgService.RecentlyUploaded(user.getId()));
             }
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
             msg.setInfo("系统内部错误");
             msg.setCode("500");
@@ -191,55 +199,78 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping("/getYyyy")//new
+    @PostMapping("/updateToken")
     @ResponseBody
-    public Msg getYyyy(@RequestParam(value = "data", defaultValue = "") String data){
-        final Msg msg = new Msg();
+    public Msg updateToken() {
+        Msg msg = new Msg();
+        try {
+            Subject subject = SecurityUtils.getSubject();
+            User user = (User) subject.getPrincipal();
+            User u = new User();
+            u.setId(user.getId());
+            u.setToken(UUID.randomUUID().toString().replace("-", ""));
+            userService.changeUser(u);
+            user.setToken(u.getToken());
+            msg.setData(u.getToken());
+            msg.setInfo("Token更新成功,即可生效");
+        } catch (Exception e) {
+            e.printStackTrace();
+            msg.setCode("500");
+            msg.setInfo("Token更新失败");
+        }
+        return msg;
+    }
+
+    @PostMapping("/getYyyy")
+    @ResponseBody
+    public Msg getYyyy() {
+        Msg msg = new Msg();
         Subject subject = SecurityUtils.getSubject();
         User u = (User) subject.getPrincipal();
-        final JSONObject jsonObject = new JSONObject();
-        jsonObject.put("allYyyy",imgService.getyyyy(null));
-        jsonObject.put("userYyyy",imgService.getyyyy(u.getId()));
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("allYyyy", imgService.getyyyy(null));
+        jsonObject.put("userYyyy", imgService.getyyyy(u.getId()));
         msg.setData(jsonObject);
         return msg;
     }
 
-    @PostMapping("/getChart")//new
+    @PostMapping("/getChart")
     @ResponseBody
-    public Msg getChart(@RequestParam(value = "data", defaultValue = "") String data){
+    public Msg getChart(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         JSONObject jsonObject = JSONObject.parseObject(data);
         String yyyy = jsonObject.getString("yyyy");
         Integer type = jsonObject.getInteger("type");
-
         Subject subject = SecurityUtils.getSubject();
         User u = (User) subject.getPrincipal();
-        List<Images> list =null;
-        if(u.getLevel()>1){
-            if(type==2){
+        List<Images> list = null;
+        if (u.getLevel() > 1) {
+            if (type == 2) {
                 Images images = new Images();
                 images.setYyyy(yyyy);
                 list = imgService.countByM(images);
-            }else{
+            } else {
                 Images images = new Images();
                 images.setYyyy(yyyy);
                 images.setUserid(u.getId());
                 list = imgService.countByM(images);
             }
-        }else{
+        } else {
             Images images = new Images();
             images.setYyyy(yyyy);
             images.setUserid(u.getId());
             list = imgService.countByM(images);
         }
-        JSONArray json = JSONArray.parseArray("[{\"id\":1,\"monthNum\":\"一月\",\"countNum\":0},{\"id\":2,\"monthNum\":\"二月\",\"countNum\":0},{\"id\":3,\"monthNum\":\"三月\",\"countNum\":0},{\"id\":4,\"monthNum\":\"四月\",\"countNum\":0},{\"id\":5,\"monthNum\":\"五月\",\"countNum\":0},{\"id\":6,\"monthNum\":\"六月\",\"countNum\":0},{\"id\":7,\"monthNum\":\"七月\",\"countNum\":0},{\"id\":8,\"monthNum\":\"八月\",\"countNum\":0},{\"id\":9,\"monthNum\":\"九月\",\"countNum\":0},{\"id\":10,\"monthNum\":\"十月\",\"countNum\":0},{\"id\":11,\"monthNum\":\"十一月\",\"countNum\":0},{\"id\":12,\"monthNum\":\"十二月\",\"countNum\":0}]");
+        JSONArray json =
+                JSONArray.parseArray(
+                        "[{\"id\":1,\"monthNum\":\"一月\",\"countNum\":0},{\"id\":2,\"monthNum\":\"二月\",\"countNum\":0},{\"id\":3,\"monthNum\":\"三月\",\"countNum\":0},{\"id\":4,\"monthNum\":\"四月\",\"countNum\":0},{\"id\":5,\"monthNum\":\"五月\",\"countNum\":0},{\"id\":6,\"monthNum\":\"六月\",\"countNum\":0},{\"id\":7,\"monthNum\":\"七月\",\"countNum\":0},{\"id\":8,\"monthNum\":\"八月\",\"countNum\":0},{\"id\":9,\"monthNum\":\"九月\",\"countNum\":0},{\"id\":10,\"monthNum\":\"十月\",\"countNum\":0},{\"id\":11,\"monthNum\":\"十一月\",\"countNum\":0},{\"id\":12,\"monthNum\":\"十二月\",\"countNum\":0}]");
         JSONArray jsonArray = new JSONArray();
         for (int j = 0; j < list.size(); j++) {
             for (int i = 0; i < json.size(); i++) {
                 JSONObject jobj = json.getJSONObject(i);
-                if(jobj.getInteger("id")==list.get(j).getMonthNum()){
-                    jobj.put("monthNum",getChinaes(list.get(j).getMonthNum()));
-                    jobj.put("countNum",list.get(j).getCountNum());
+                if (jobj.getInteger("id") == list.get(j).getMonthNum()) {
+                    jobj.put("monthNum", getChinaes(list.get(j).getMonthNum()));
+                    jobj.put("countNum", list.get(j).getCountNum());
                 }
             }
         }
@@ -247,7 +278,7 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping("/getStorage")//new
+    @PostMapping("/getStorage")
     @ResponseBody
     public Msg getStorage() {
         Msg msg = new Msg();
@@ -256,7 +287,7 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping("/getStorageName")//new
+    @PostMapping("/getStorageName")
     @ResponseBody
     public Msg getStorageName() {
         Msg msg = new Msg();
@@ -265,7 +296,7 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping(value = "/selectPhoto")//new
+    @PostMapping(value = {"/selectPhoto", "/client/selectPhoto"})
     @ResponseBody
     public Msg selectPhoto(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -277,18 +308,20 @@ public class AdminController {
         Integer source = jsonObj.getInteger("source");
         String starttime = jsonObj.getString("starttime");
         String stoptime = jsonObj.getString("stoptime");
-        String selectUserType = jsonObj.getString("selectUserType");//me/all
+        String selectUserType = jsonObj.getString("selectUserType"); // me/all
+        String order = jsonObj.getString("order");
         String username = jsonObj.getString("username");
+        String searchname = jsonObj.getString("searchname");
         Integer selecttype = jsonObj.getInteger("selecttype");
         boolean violation = jsonObj.getBoolean("violation");
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-        if(starttime!=null){
+        if (starttime != null) {
             try {
                 Date date1 = format.parse(starttime);
-                Date date2 = format.parse(stoptime==null?format.format(new Date()):stoptime);
+                Date date2 = format.parse(stoptime == null ? format.format(new Date()) : stoptime);
                 int compareTo = date1.compareTo(date2);
                 System.out.println(compareTo);
-                if(compareTo==1){
+                if (compareTo == 1) {
                     msg.setCode("110500");
                     msg.setInfo("起始日期不能大于结束日期");
                     return msg;
@@ -302,46 +335,49 @@ public class AdminController {
         }
         Images img = new Images();
         PageHelper.startPage(pageNum, pageSize);
-        if(violation){
+        if (violation) {
             img.setViolation("true");
         }
         img.setStarttime(starttime);
         img.setStoptime(stoptime);
-        if(subject.hasRole("admin")){
+        if (subject.hasRole("admin")) {
             img.setSource(source);
-            if(selectUserType.equals("me")){
+            if (selectUserType.equals("me")) {
                 img.setUserid(user.getId());
                 img.setUsername(null);
                 img.setSelecttype(null);
-            }else{
+            } else {
                 img.setUsername(username);
                 img.setSelecttype(selecttype);
             }
-        }else{
-            //普通用户
+        } else {
             img.setUserid(user.getId());
         }
+        if(!StringUtils.isBlank(searchname)){
+            img.setSearchname(searchname);
+        }
+        img.setOrder(StringUtils.isBlank(order)?"desc":order);
         List<Images> images = imgService.selectimg(img);
         PageInfo<Images> rolePageInfo = new PageInfo<>(images);
-        PageResultBean<Images> pageResultBean = new PageResultBean<>(rolePageInfo.getTotal(), rolePageInfo.getList());
+        PageResultBean<Images> pageResultBean =
+                new PageResultBean<>(rolePageInfo.getTotal(), rolePageInfo.getList());
         msg.setData(pageResultBean);
         return msg;
     }
 
-
-    @PostMapping(value = "/getUserInfo") //new
+    @PostMapping(value = "/getUserInfo")
     @ResponseBody
     public Msg getUserInfo() {
         Msg msg = new Msg();
         try {
             Subject subject = SecurityUtils.getSubject();
             User user = (User) subject.getPrincipal();
-            final User u = new User();
+            User u = new User();
             u.setId(user.getId());
             User userInfo = userService.getUsers(u);
             JSONObject jsonObject = new JSONObject();
-            jsonObject.put("username",userInfo.getUsername());
-            jsonObject.put("email",userInfo.getEmail());
+            jsonObject.put("username", userInfo.getUsername());
+            jsonObject.put("email", userInfo.getEmail());
             msg.setData(jsonObject);
         } catch (Exception e) {
             e.printStackTrace();
@@ -351,7 +387,7 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping("/setUserInfo") //new
+    @PostMapping("/setUserInfo")
     @ResponseBody
     public Msg setUserInfo(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -363,45 +399,52 @@ public class AdminController {
             Subject subject = SecurityUtils.getSubject();
             User u = (User) subject.getPrincipal();
             User user = new User();
-            if(!SetText.checkEmail(email)){
+            if (!SetText.checkEmail(email)) {
                 msg.setCode("110403");
                 msg.setInfo("邮箱格式不正确");
                 return msg;
             }
             String regex = "^\\w+$";
-            if(username.length()>20 || !username.matches (regex)){
+            if (username.length() > 30) {
                 msg.setCode("110403");
-                msg.setInfo("用户名不得超过20位字符");
+                msg.setInfo("用户名不得超过30位字符");
                 return msg;
             }
-            if(subject.hasRole("admin")){
-                final User userOld = new User();
+            if(!username.matches (regex)){
+                //用户名格式不正确
+                msg.setCode("110403");
+                msg.setInfo("用户名不得含有特殊字符");
+                return msg;
+            }
+            if (subject.hasRole("admin")) {
+                User userOld = new User();
                 userOld.setId(u.getId());
                 User userInfo = userService.getUsers(userOld);
-                if(!userInfo.getUsername().equals(username)){
+                if (!userInfo.getUsername().equals(username)) {
                     Integer countusername = userService.countusername(username);
-                    if(countusername == 1 || !SysName.CheckSysName(username)){
+                    if (countusername == 1 || !SysName.CheckSysName(username)) {
                         msg.setCode("110406");
                         msg.setInfo("此用户名已存在");
                         return msg;
-                    }else {
+                    } else {
                         user.setUsername(username);
                     }
                 }
-                if(!userInfo.getEmail().equals(email)){
+                if (!userInfo.getEmail().equals(email)) {
                     Integer countmail = userService.countmail(email);
-                    if(countmail == 1){
+                    if (countmail == 1) {
                         msg.setCode("110407");
                         msg.setInfo("此邮箱已被注册");
                         return msg;
-                    }else{
+                    } else {
                         user.setEmail(email);
                     }
                 }
-                user.setPassword(Base64Encryption.encryptBASE64(password.getBytes()));
+
+                user.setPassword(Base64.getEncoder().encodeToString(password.getBytes()));
                 user.setUid(u.getUid());
-            }else{
-                user.setPassword(Base64Encryption.encryptBASE64(password.getBytes()));
+            } else {
+                user.setPassword(Base64.getEncoder().encodeToString(password.getBytes()));
                 user.setUid(u.getUid());
             }
             userService.change(user);
@@ -414,129 +457,134 @@ public class AdminController {
         return msg;
     }
 
-    @PostMapping("/deleImages") //new
+    @PostMapping({"/deleImages", "/client/deleImages"})
     @ResponseBody
     public Msg deleImages(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
-        JSONArray images = jsonObj.getJSONArray("images");
-        Subject subject = SecurityUtils.getSubject();
-        User user = (User) subject.getPrincipal();
-
-        if(null == user){
-            msg.setCode("500");
-            msg.setInfo("当前用户信息不存在");
-            return msg;
-        }
-        if(images.size()==0){
+        String images = jsonObj.getString("images");
+        String uuid = jsonObj.getString("uuid");
+        Boolean forceDel = jsonObj.getBoolean("forceDel")==null?false:jsonObj.getBoolean("forceDel");
+        if (images == null) {
             msg.setCode("404");
             msg.setInfo("为获取到图像信息");
             return msg;
         }
-        for (int i = 0; i < images.size(); i++) {
-            Integer imgid = images.getInteger(i);
+        String[] split = images.split(",");
+        Subject subject = SecurityUtils.getSubject();
+        User user = (User) subject.getPrincipal();
+        if (null == user) {
+            msg.setCode("500");
+            msg.setInfo("当前用户信息不存在");
+            return msg;
+        }
+        if (split.length == 0) {
+            msg.setCode("404");
+            msg.setInfo("为获取到图像信息");
+            return msg;
+        }
+        List<Long> imgIds = new ArrayList<Long>();
+        for (int i = 0; i < split.length; i++) {
+            Long imgid = Long.valueOf(split[i]);
             Images image = imgService.selectByPrimaryKey(imgid);
-            Integer keyid = image.getSource();
-            String imgname = image.getImgname();
-            Keys key = keysService.selectKeys(keyid);
-
-            if(!subject.hasRole("admin")){
-                if(image.getUserid()!=user.getId()){
+            if (!subject.hasRole("admin")) {
+                if (!image.getUserid().equals(user.getId())) {
                     break;
                 }
             }
-            boolean isDele = false;
-            try{
-                if (key.getStorageType() == 1) {
-                    isDele = nosImageupload.delNOS(key.getId(), imgname);
-                } else if (key.getStorageType() == 2) {
-                    isDele = ossImageupload.delOSS(key.getId(), imgname);
-                } else if (key.getStorageType() == 3) {
-                    isDele = ussImageupload.delUSS(key.getId(), imgname);
-                } else if (key.getStorageType() == 4) {
-                    isDele = kodoImageupload.delKODO(key.getId(), imgname);
-                } else if (key.getStorageType() == 5) {
-                    isDele = LocUpdateImg.deleteLOCImg(imgname);
-                }else if (key.getStorageType() == 6) {
-                    isDele = cosImageupload.delCOS(key.getId(), imgname);
-                }else if (key.getStorageType() == 7) {
-                    isDele = ftpImageupload.delFTP(key.getId(), imgname);
-                }else if (key.getStorageType() == 8) {
-                    isDele = uFileImageupload.delUFile(key.getId(), imgname);
-                }else {
-                    System.err.println("未获取到对象存储参数，删除失败");
-                }
-            }catch (Exception e){
-                e.printStackTrace();
-            }
-            if(isDele){
-                try {
-                    imgTempService.delImgAndExp(image.getImguid());
-                    imgService.deleimg(imgid);
-                    imgAndAlbumService.deleteImgAndAlbum(imgname);
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    msg.setInfo("图片记录删除失败，请重试");
-                    msg.setCode("500");
-                    return msg;
-                }
-                msg.setInfo("删除成功");
-            }else{
-                imgTempService.delImgAndExp(image.getImguid());
-                imgService.deleimg(imgid);
-                imgAndAlbumService.deleteImgAndAlbum(imgname);
-                msg.setInfo("图片记录已删除，但是图片源删除失败");
-            }
+            imgIds.add(imgid);
+        }
+        if (imgIds.size() == 0) {
+            msg.setCode("110404");
+        } else {
+            deleimages.dele(forceDel,uuid, imgIds.stream().toArray(Long[]::new));
+            msg.setCode("200");
         }
         return msg;
     }
 
-    //工具函数
-    private static String getChinaes(int v){
-        String ch = "";
-        switch(v){
-            case 1 :
-                ch = "一月";
-                break; //可选
-            case 2 :
-                ch = "二月";
-                break; //可选
-            case 3 :
-                ch = "三月";
-                break; //可选
-            case 4 :
-                ch = "四月";
-                break; //可选
-            case 5 :
-                ch = "五月";
-                break; //可选
-            case 6 :
-                ch = "六月";
-                break; //可选
-            case 7 :
-                ch = "七月";
-                break; //可选
-            case 8 :
-                ch = "八月";
-                break; //可选
-            case 9 :
-                ch = "九月";
-                break; //可选
-            case 10 :
-                ch = "十月";
-                break; //可选
-            case 11 :
-                ch = "十一月";
-                break; //可选
-            case 12 :
-                ch = "十二月";
-                break; //可选
-            default : ch = "";//可选
-                //语句
+    @PostMapping({"/GetDelprogress", "/client/GetDelprogress"})
+    @ResponseBody
+    public Msg GetDelprogress(@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
+        try {
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            String uuid = jsonObj.getString("uuid");
+            JSONObject jsonObject = new JSONObject();
+            MyProgress myProgress = null;
+            try{
+                myProgress = JSON.parseObject(iRedisService.getValue(uuid).toString(), MyProgress.class);
+            }catch (Exception e){ }
+            msg.setCode("110666");
+            msg.setInfo("正在执行");
+            if (null == myProgress) {
+                jsonObject.put("succ", 0);
+                jsonObject.put("errorlist", new ArrayList<String>());
+                jsonObject.put("oklist", new ArrayList<Long>());
+                jsonObject.put("delover", false);
+            } else {
+                jsonObject.put("succ", myProgress.getDelSuccessCount());
+                jsonObject.put("errorlist", myProgress.getDelErrorImgListt());
+                jsonObject.put("oklist", myProgress.getDelSuccessImgList());
+                jsonObject.put("delover", myProgress.getDelOCT());
+                if(myProgress.getDelOCT()==1){
+                    System.out.println("循环遍历的值："+myProgress.getDelOCT());
+                    msg.setCode("100");
+                }
+            }
+            msg.setData(jsonObject);
+            return msg;
+        } catch (Exception e) {
+            e.printStackTrace();
+            msg.setCode("110500");
+            msg.setInfo("正在执行过程中发生错误");
+            return msg;
         }
-
-        return ch;
-
     }
 
+    private static String getChinaes(int v) {
+        String ch = "";
+        switch (v) {
+            case 1:
+                ch = "一月";
+                break; // 可选
+            case 2:
+                ch = "二月";
+                break; // 可选
+            case 3:
+                ch = "三月";
+                break; // 可选
+            case 4:
+                ch = "四月";
+                break; // 可选
+            case 5:
+                ch = "五月";
+                break; // 可选
+            case 6:
+                ch = "六月";
+                break; // 可选
+            case 7:
+                ch = "七月";
+                break; // 可选
+            case 8:
+                ch = "八月";
+                break; // 可选
+            case 9:
+                ch = "九月";
+                break; // 可选
+            case 10:
+                ch = "十月";
+                break; // 可选
+            case 11:
+                ch = "十一月";
+                break; // 可选
+            case 12:
+                ch = "十二月";
+                break; // 可选
+            default:
+                ch = ""; // 可选
+                // 语句
+        }
+        return ch;
+    }
 }

src/main/java/cn/hellohao/controller/AdminRootController.java

@@ -3,7 +3,9 @@ package cn.hellohao.controller;
 import cn.hellohao.pojo.*;
 import cn.hellohao.service.*;
 import cn.hellohao.service.impl.*;
-import cn.hellohao.utils.*;
+import cn.hellohao.utils.NewSendEmail;
+import cn.hellohao.utils.Print;
+import cn.hellohao.utils.SetFiles;
 import cn.hutool.http.HttpUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
@@ -13,25 +15,22 @@ import com.github.pagehelper.PageInfo;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.subject.Subject;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Controller;
-import org.springframework.ui.Model;
 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.ResponseBody;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpSession;
+import java.net.HttpURLConnection;
+import java.net.URL;
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 @Controller
 @RequestMapping("/admin/root")
 public class AdminRootController {
     @Autowired
-    private ConfigService configService;
+    private ConfdataService confdataService;
     @Autowired
     private KeysService keysService;
     @Autowired
@@ -46,30 +45,51 @@ public class AdminRootController {
     private ImgService imgService;
     @Autowired
     private ImgreviewService imgreviewService;
+    @Autowired
+    private AppClientService appClientService;
+    @Autowired
+    private NOSImageupload nOSImageupload;
+    @Autowired
+    private OSSImageupload ossImageupload;
+    @Autowired
+    private USSImageupload ussImageupload;
+    @Autowired
+    private KODOImageupload kodoImageupload;
+    @Autowired
+    private COSImageupload cosImageupload;
+    @Autowired
+    private FtpServiceImpl ftpService;
+    @Autowired
+    private S3Imageupload s3Imageupload;
+    @Autowired
+    private WebDAVImageupload webDAVImageupload;
 
 
-    @PostMapping(value = "/getUserList")//new
+    @PostMapping(value = "/getUserList")
     @ResponseBody
-    public Map<String, Object> getUserList(@RequestParam(value = "data", defaultValue = "") String data) {
-        JSONObject jsonObj = JSONObject.parseObject(data);
-        Integer pageNum = jsonObj.getInteger("pageNum");
-        Integer pageSize = jsonObj.getInteger("pageSize");
-        String queryText = jsonObj.getString("queryText");
-        PageHelper.startPage(pageNum, pageSize);
-        List<User> users = userService.getuserlist(queryText);
-        PageInfo<User> rolePageInfo = new PageInfo<>(users);
-        Map<String, Object> map = new HashMap<String, Object>();
-        map.put("count", rolePageInfo.getTotal());
-        map.put("users", rolePageInfo.getList());
-        return map;
+    public Msg getUserList(@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
+        try{
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            Integer pageNum = jsonObj.getInteger("pageNum");
+            Integer pageSize = jsonObj.getInteger("pageSize");
+            String queryText = jsonObj.getString("queryText");
+            PageHelper.startPage(pageNum, pageSize);
+            List<User> users = userService.getuserlist(queryText);
+            PageInfo<User> rolePageInfo = new PageInfo<>(users);
+            msg.setData(rolePageInfo);
+        }catch (Exception e){
+            msg.setCode("500");
+        }
+        return msg;
     }
 
 
-    @PostMapping(value = "/updateUserInfo")//new
+    @PostMapping(value = "/updateUserInfo")
     @ResponseBody
     public Msg updateUserInfo(@RequestParam(value = "data", defaultValue = "") String data) {
         final Msg msg = new Msg();
-        try{
+        try {
             Subject subject = SecurityUtils.getSubject();
             User u = (User) subject.getPrincipal();
             JSONObject jsonObj = JSONObject.parseObject(data);
@@ -78,7 +98,7 @@ public class AdminRootController {
             Long memory = jsonObj.getLong("memory");
             Integer groupid = jsonObj.getInteger("groupid");
             Integer isok = jsonObj.getInteger("isok");
-            if(memory<0 || memory>1048576L){
+            if (memory < 0 || memory > 1048576L) {
                 msg.setCode("500");
                 msg.setInfo("容量不得超过1048576");
                 return msg;
@@ -89,14 +109,14 @@ public class AdminRootController {
             User userInfo = userService.getUsers(user2);
             user.setId(id);
             user.setEmail(email);
-            user.setMemory(Long.toString(memory*1024*1024));
+            user.setMemory(Long.toString(memory * 1024 * 1024));
             user.setGroupid(groupid);
-            if(userInfo.getLevel()==1){
-                user.setIsok(isok==1?1:-1);
+            if (userInfo.getLevel() == 1) {
+                user.setIsok(isok == 1 ? 1 : -1);
             }
             userService.changeUser(user);
             msg.setInfo("修改成功");
-        }catch (Exception e){
+        } catch (Exception e) {
             msg.setCode("500");
             msg.setInfo("修改失败");
             e.printStackTrace();
@@ -105,7 +125,7 @@ public class AdminRootController {
     }
 
 
-    @PostMapping("/disableUser")//new
+    @PostMapping("/disableUser")
     @ResponseBody
     public Msg disableUser(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -116,7 +136,7 @@ public class AdminRootController {
                 User u = new User();
                 u.setId(userIdList.getInteger(i));
                 User u2 = userService.getUsers(u);
-                if(u2.getLevel()==1){
+                if (u2.getLevel() == 1) {
                     User user = new User();
                     user.setId(userIdList.getInteger(i));
                     user.setIsok(-1);
@@ -125,7 +145,7 @@ public class AdminRootController {
 
             }
             msg.setInfo("所选用户已被禁用");
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
             msg.setInfo("系统错误");
             msg.setCode("500");
@@ -133,7 +153,7 @@ public class AdminRootController {
         return msg;
     }
 
-    @PostMapping("/deleUser")//new
+    @PostMapping("/deleUser")
     @ResponseBody
     public Msg deleuser(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -145,18 +165,18 @@ public class AdminRootController {
                 User u = new User();
                 u.setId(userIdList.getInteger(i));
                 User user = userService.getUsers(u);
-                if(user.getLevel()==1){
+                if (user.getLevel() == 1) {
                     userService.deleuser(userIdList.getInteger(i));
-                }else{
+                } else {
                     b = true;
                 }
             }
-            if(b && userIdList.size()==1){
+            if (b && userIdList.size() == 1) {
                 msg.setInfo("管理员账户不可删除");
-            }else {
+            } else {
                 msg.setInfo("用户已删除成功");
             }
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
             msg.setInfo("系统错误");
             msg.setCode("500");
@@ -164,7 +184,7 @@ public class AdminRootController {
         return msg;
     }
 
-    @PostMapping("/getKeysList") //new
+    @PostMapping("/getKeysList")
     @ResponseBody
     public Msg getKeysList() {
         Msg msg = new Msg();
@@ -173,7 +193,7 @@ public class AdminRootController {
         return msg;
     }
 
-    @PostMapping("/LoadInfo")//new
+    @PostMapping("/LoadInfo")
     @ResponseBody
     public Msg LoadInfo(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -181,34 +201,36 @@ public class AdminRootController {
             JSONObject jsonData = JSONObject.parseObject(data);
             Integer keyId = jsonData.getInteger("keyId");
             JSONObject jsonObject = new JSONObject();
-            jsonObject.put("id",keyId);
+            jsonObject.put("id", keyId);
             Keys key = keysService.selectKeys(keyId);
             Integer ret = 0;
-            if(key.getStorageType()==1){
-                ret = NOSImageupload.Initialize(key);
-            }else if (key.getStorageType()==2){
-                ret = OSSImageupload.Initialize(key);
-            }else if(key.getStorageType()==3){
-                ret = USSImageupload.Initialize(key);
-            }else if(key.getStorageType()==4){
-                ret = KODOImageupload.Initialize(key);
-            }else if(key.getStorageType()==6){
-                ret = COSImageupload.Initialize(key);
-            }else if(key.getStorageType()==7){
-                ret = FTPImageupload.Initialize(key);
-            }else if(key.getStorageType()==8){
-                ret = UFileImageupload.Initialize(key);
+            if (key.getStorageType() == 1) {
+                ret = nOSImageupload.Initialize(key);
+            } else if (key.getStorageType() == 2) {
+                ret = ossImageupload.Initialize(key);
+            } else if (key.getStorageType() == 3) {
+                ret = ussImageupload.Initialize(key);
+            } else if (key.getStorageType() == 4) {
+                ret = kodoImageupload.Initialize(key);
+            } else if (key.getStorageType() == 6) {
+                ret = cosImageupload.Initialize(key);
+            } else if (key.getStorageType() == 7) {
+                ret = ftpService.Initialize(key);
+            } else if (key.getStorageType() == 8) {
+                ret = s3Imageupload.Initialize(key);
+            }else if (key.getStorageType() == 9) {
+                ret = webDAVImageupload.Initialize(key);
             }
             Long l = imgService.getsourcememory(keyId);
-            jsonObject.put("isok",ret);
-            jsonObject.put("storagetype",key.getStorageType());
-            if(l==null){
-                jsonObject.put("usedCapacity",0);
-            }else{
+            jsonObject.put("isok", ret);
+            jsonObject.put("storagetype", key.getStorageType());
+            if (l == null) {
+                jsonObject.put("usedCapacity", 0);
+            } else {
                 jsonObject.put("usedCapacity", SetFiles.readableFileSize(l));
             }
             msg.setData(jsonObject);
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
             msg.setCode("500");
         }
@@ -216,32 +238,16 @@ public class AdminRootController {
     }
 
 
-    @PostMapping("/updateStorage") //new
+    @PostMapping("/updateStorage")
     @ResponseBody
     public Msg updateStorage(@RequestParam(value = "data", defaultValue = "") String data) {
         JSONObject jsonObj = JSONObject.parseObject(data);
-        Integer id = jsonObj.getInteger("id");
-        String AccessKey = jsonObj.getString("AccessKey");
-        String AccessSecret = jsonObj.getString("AccessSecret");
-        String Endpoint = jsonObj.getString("Endpoint");
-        String Bucketname = jsonObj.getString("Bucketname");
-        String RequestAddress = jsonObj.getString("RequestAddress");
-        Integer storageType = jsonObj.getInteger("storageType");
-        String keyname = jsonObj.getString("keyname");
-        Keys keys = new Keys();
-        keys.setId(id);
-        keys.setAccessKey(AccessKey);
-        keys.setAccessSecret(AccessSecret);
-        keys.setEndpoint(Endpoint);
-        keys.setBucketname(Bucketname);
-        keys.setRequestAddress(RequestAddress);
-        keys.setStorageType(storageType);
-        keys.setKeyname(keyname);
+        Keys keys = JSON.toJavaObject(jsonObj,Keys.class);
         Msg msg = keysService.updateKey(keys);
         return msg;
     }
 
-    @PostMapping("/getStorageById")//new
+    @PostMapping("/getStorageById")
     @ResponseBody
     public Msg getselectkey(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -252,7 +258,7 @@ public class AdminRootController {
         return msg;
     }
 
-    @PostMapping("/getSettingConfig") //new
+    @PostMapping("/getSettingConfig")
     @ResponseBody
     public Msg getSettingConfig(@RequestParam(value = "data", defaultValue = "") String data) {
         final Msg msg = new Msg();
@@ -261,15 +267,17 @@ public class AdminRootController {
         User u = (User) subject.getPrincipal();
         try {
             UploadConfig uploadConfig = uploadConfigService.getUpdateConfig();
-            Config config = configService.getSourceype();
+            final Confdata confdata = confdataService.selectConfdata("config");
             SysConfig sysConfig = sysConfigService.getstate();
-            uploadConfig.setUsermemory(Long.toString(Long.valueOf(uploadConfig.getUsermemory())/1024/1024));
-            uploadConfig.setVisitormemory(Long.toString(Long.valueOf(uploadConfig.getVisitormemory())/1024/1024));
-            uploadConfig.setFilesizetourists(Long.toString(Long.valueOf(uploadConfig.getFilesizetourists())/1024/1024));
-            uploadConfig.setFilesizeuser(Long.toString(Long.valueOf(uploadConfig.getFilesizeuser())/1024/1024));
-            jsonObject.put("uploadConfig",uploadConfig);
-            jsonObject.put("config",config);
-            jsonObject.put("sysConfig",sysConfig);
+            AppClient appClientData = appClientService.getAppClientData("app");
+            uploadConfig.setUsermemory(Long.toString(Long.valueOf(uploadConfig.getUsermemory()) / 1024 / 1024));
+            uploadConfig.setVisitormemory(Long.toString(Long.valueOf(uploadConfig.getVisitormemory()) / 1024 / 1024));
+            uploadConfig.setFilesizetourists(Long.toString(Long.valueOf(uploadConfig.getFilesizetourists()) / 1024 / 1024));
+            uploadConfig.setFilesizeuser(Long.toString(Long.valueOf(uploadConfig.getFilesizeuser()) / 1024 / 1024));
+            jsonObject.put("uploadConfig", uploadConfig);
+            jsonObject.put("config", JSONObject.parseObject(confdata.getJsondata()));
+            jsonObject.put("sysConfig", sysConfig);
+            jsonObject.put("appClient", appClientData);
             msg.setData(jsonObject);
         } catch (Exception e) {
             e.printStackTrace();
@@ -280,36 +288,44 @@ public class AdminRootController {
     }
 
 
-    @PostMapping("/updateConfig")//new
+    @PostMapping("/updateConfig")
     @ResponseBody
     public Msg updateConfig(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         try {
             JSONObject jsonObject = JSONObject.parseObject(data);
-            UploadConfig uploadConfig = JSON.toJavaObject((JSON) jsonObject.get("uploadConfig"),UploadConfig.class);
-            String vm =  uploadConfig.getVisitormemory();
-            if((Long.valueOf(vm)<-1) || Long.valueOf(vm) > 104857600 || Long.valueOf(uploadConfig.getFilesizetourists())<0 || Long.valueOf(uploadConfig.getFilesizetourists()) > 5120
-                    || Long.valueOf(uploadConfig.getUsermemory())<0 || Long.valueOf(uploadConfig.getUsermemory())>1048576
-                    || Long.valueOf(uploadConfig.getFilesizeuser())<0 || Long.valueOf(uploadConfig.getFilesizeuser())>5120 ){
+            UploadConfig uploadConfig = JSON.toJavaObject((JSON) jsonObject.get("uploadConfig"), UploadConfig.class);
+            String vm = uploadConfig.getVisitormemory();
+            if ((Long.valueOf(vm) < -1) || Long.valueOf(vm) > 104857600 || Long.valueOf(uploadConfig.getFilesizetourists()) < 0 || Long.valueOf(uploadConfig.getFilesizetourists()) > 5120
+                    || Long.valueOf(uploadConfig.getUsermemory()) < 0 || Long.valueOf(uploadConfig.getUsermemory()) > 1048576
+                    || Long.valueOf(uploadConfig.getFilesizeuser()) < 0 || Long.valueOf(uploadConfig.getFilesizeuser()) > 5120) {
                 msg.setInfo("你输入的值不正确");
                 msg.setCode("500");
-                return  msg;
+                return msg;
             }
-            Config config = JSON.toJavaObject((JSON) jsonObject.get("config"),Config.class);
-            SysConfig sysConfig = JSON.toJavaObject((JSON) jsonObject.get("sysConfig"),SysConfig.class);
-            if(Integer.valueOf(vm)==-1){
+//            Config config = JSON.toJavaObject((JSON) jsonObject.get("config"), Config.class);
+            SysConfig sysConfig = JSON.toJavaObject((JSON) jsonObject.get("sysConfig"), SysConfig.class);
+            AppClient appClient = JSON.toJavaObject((JSON) jsonObject.get("appClient"), AppClient.class);
+            if (Integer.valueOf(vm) == -1) {
                 uploadConfig.setVisitormemory("-1");
-            }else{
-                uploadConfig.setVisitormemory(Long.toString(Long.valueOf(uploadConfig.getVisitormemory())*1024*1024));
+            } else {
+                uploadConfig.setVisitormemory(Long.toString(Long.valueOf(uploadConfig.getVisitormemory()) * 1024 * 1024));
             }
-            uploadConfig.setFilesizetourists(Long.toString(Long.valueOf(uploadConfig.getFilesizetourists())*1024*1024));
-            uploadConfig.setUsermemory(Long.toString(Long.valueOf(uploadConfig.getUsermemory())*1024*1024));
-            uploadConfig.setFilesizeuser(Long.toString(Long.valueOf(uploadConfig.getFilesizeuser())*1024*1024));
+            uploadConfig.setFilesizetourists(Long.toString(Long.valueOf(uploadConfig.getFilesizetourists()) * 1024 * 1024));
+            uploadConfig.setUsermemory(Long.toString(Long.valueOf(uploadConfig.getUsermemory()) * 1024 * 1024));
+            uploadConfig.setFilesizeuser(Long.toString(Long.valueOf(uploadConfig.getFilesizeuser()) * 1024 * 1024));
             uploadConfigService.setUpdateConfig(uploadConfig);
-            configService.setSourceype(config);
+            Confdata confdata = new Confdata();
+            confdata.setKey("config");
+            confdata.setJsondata(jsonObject.getJSONObject("config").toJSONString());
+            confdataService.updateConfdata(confdata);
             sysConfigService.setstate(sysConfig);
+            if (!appClient.getIsuse().equals("on")) {
+                appClient.setIsuse("off");
+            }
+            appClientService.editAppClientData(appClient);
             msg.setInfo("配置保存成功");
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
             msg.setInfo("操作出现异常");
             msg.setCode("500");
@@ -318,7 +334,7 @@ public class AdminRootController {
     }
 
 
-    @PostMapping(value = "/getOrderConfig")//new
+    @PostMapping(value = "/getOrderConfig")
     @ResponseBody
     public Msg emailconfig() {
         final Msg msg = new Msg();
@@ -328,8 +344,8 @@ public class AdminRootController {
             final JSONObject jsonObject = new JSONObject();
             emailConfig = emailConfigService.getemail();
             imgreview = imgreviewService.selectByPrimaryKey(1);
-            jsonObject.put("emailConfig",emailConfig);
-            jsonObject.put("imgreview",imgreview);
+            jsonObject.put("emailConfig", emailConfig);
+            jsonObject.put("imgreview", imgreview);
             msg.setData(jsonObject);
         } catch (Exception e) {
             e.printStackTrace();
@@ -340,17 +356,17 @@ public class AdminRootController {
     }
 
 
-    @PostMapping("/updateEmailConfig") //new
+    @PostMapping("/updateEmailConfig")
     @ResponseBody
-    public Msg updateemail(@RequestParam(value = "data", defaultValue = "") String data ) {
+    public Msg updateemail(@RequestParam(value = "data", defaultValue = "") String data) {
         final Msg msg = new Msg();
         try {
             JSONObject jsonObj = JSONObject.parseObject(data);
-            EmailConfig emailConfig = JSON.toJavaObject(jsonObj,EmailConfig.class);
-            if(null==emailConfig.getId() || null==emailConfig.getEmailname()  || null==emailConfig.getEmailurl() || null==emailConfig.getEmails()
-                    || null==emailConfig.getEmailkey()  || null==emailConfig.getPort() || null==emailConfig.getUsing()
-                    || emailConfig.getEmailname().equals("")  || emailConfig.getEmailurl().equals("")  || emailConfig.getEmails().equals("")
-                    || emailConfig.getEmailkey().equals("")   || emailConfig.getPort().equals("")){
+            EmailConfig emailConfig = JSON.toJavaObject(jsonObj, EmailConfig.class);
+            if (null == emailConfig.getId() || null == emailConfig.getEmailname() || null == emailConfig.getEmailurl() || null == emailConfig.getEmails()
+                    || null == emailConfig.getEmailkey() || null == emailConfig.getPort() || null == emailConfig.getUsing()
+                    || emailConfig.getEmailname().equals("") || emailConfig.getEmailurl().equals("") || emailConfig.getEmails().equals("")
+                    || emailConfig.getEmailkey().equals("") || emailConfig.getPort().equals("")) {
                 msg.setCode("110400");
                 msg.setInfo("各参数不能为空");
                 return msg;
@@ -365,22 +381,67 @@ public class AdminRootController {
         return msg;
     }
 
-    @PostMapping("/mailTest") //new
+    @PostMapping("/mailTest")
     @ResponseBody
-    public Msg mailTest(@RequestParam(value = "data", defaultValue = "") String data ) {
+    public Msg mailTest(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
         String tomail = jsonObj.getString("tomail");
-        EmailConfig emailConfig = JSON.toJavaObject(jsonObj,EmailConfig.class);
-        if(null==emailConfig.getEmails() || null==emailConfig.getEmailkey() || null==emailConfig.getEmailurl()
-                || null==emailConfig.getPort()  || null==emailConfig.getEmailname() || null==tomail){
+        EmailConfig emailConfig = JSON.toJavaObject(jsonObj, EmailConfig.class);
+        if (null == emailConfig.getEmails() || null == emailConfig.getEmailkey() || null == emailConfig.getEmailurl()
+                || null == emailConfig.getPort() || null == emailConfig.getEmailname() || null == tomail) {
             msg.setCode("110400");
             msg.setInfo("邮箱配置参数不能为空");
-        }else{
+        } else {
             msg = NewSendEmail.sendTestEmail(emailConfig, tomail);
         }
         return msg;
     }
 
+    @PostMapping("/sysVersion")
+    @ResponseBody
+    public Msg sysupdate(@RequestParam(value = "data", defaultValue = "") String data) {
+        final Msg msg = new Msg();
+        JSONObject jsonObj = JSONObject.parseObject(data);
+        String  dates = jsonObj.getString("dates");
+        HashMap<String, Object> paramMap = new HashMap<>();
+        String urls = "http://check.hellohao.cn:8090/getNoticeText";
+        JSONObject jsonObject =null;
+        try {
+            URL u = new URL(urls);
+            HttpURLConnection uConnection = (HttpURLConnection) u.openConnection();
+            uConnection.connect();
+            if(uConnection.getResponseCode()==200){
+                    jsonObject =JSONObject.parseObject(HttpUtil.get(urls));
+                    String openv = jsonObject.getString("openv");
+                    String opentext = jsonObject.getString("opentext");
+                    JSONObject versionJson = new JSONObject();
+                    if(Double.valueOf(openv)>Double.valueOf(dates)){
+                        versionJson.put("code","110200");
+                        versionJson.put("newVersion",openv);
+                        versionJson.put("versionMsg",opentext);
+                        msg.setCode("110200");
+                        msg.setData(versionJson);
+                    }else{
+                        versionJson.put("code","110300");
+                        versionJson.put("newVersion",openv);
+                        versionJson.put("versionMsg","当前已是最新版本");
+                        msg.setCode("110300");
+                        msg.setData(versionJson);
+                    }
+            }else{
+                msg.setCode("110500");
+                msg.setData("未获取到更新状态");
+            }
+            uConnection.disconnect();
+        } catch (Exception e) {
+            e.printStackTrace();
+            Print.warning("connect failed");
+            msg.setCode("110500");
+            msg.setData("未获取到更新状态");
+        }
+        return msg;
+    }
+
 
 }

src/main/java/cn/hellohao/controller/AlbumController.java

@@ -35,13 +35,13 @@ public class AlbumController {
     @Autowired
     private UserService userService;
 
-    @PostMapping("/admin/getGalleryList") //new
+    @PostMapping("/admin/getGalleryList")  
     @ResponseBody
-    public Map<String, Object> getGalleryList (@RequestParam(value = "data", defaultValue = "") String data){
+    public Msg getGalleryList (@RequestParam(value = "data", defaultValue = "") String data){
+        Msg msg = new Msg();
         Subject subject = SecurityUtils.getSubject();
         User user = (User) subject.getPrincipal();
         user =  userService.getUsers(user);
-        Map<String, Object> map = new HashMap<String, Object>();
         Album album = new Album();
         JSONObject jsonObj = JSONObject.parseObject(data);
         Integer pageNum = jsonObj.getInteger("pageNum");
@@ -56,20 +56,17 @@ public class AlbumController {
         try {
             albums = albumServiceImpl.selectAlbumURLList(album);
             PageInfo<Album> rolePageInfo = new PageInfo<>(albums);
-            map.put("code", 200);
-            map.put("info", "");
-            map.put("count", rolePageInfo.getTotal());
-            map.put("data", rolePageInfo.getList());
+            msg.setData(rolePageInfo);
         } catch (Exception e) {
             e.printStackTrace();
-            map.put("code", 500);
-            map.put("info", "获取数据异常");
+            msg.setInfo("获取数据异常");
+            msg.setCode("500");
         }
-        return map;
+        return msg;
 
     }
 
-    @PostMapping("/admin/deleGallery") //new 删除画廊
+    @PostMapping("/admin/deleGallery")
     @ResponseBody
     public Msg deleGallery (@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -100,7 +97,39 @@ public class AlbumController {
 
     }
 
-    @PostMapping("/getAlbumImgList") //new
+    //后台列表要修改时的查询表单
+    @PostMapping("/admin/getAlbumListForKey")  
+    @ResponseBody
+    public Msg getAlbumListForKey(@RequestParam(value = "data", defaultValue = "") String data){
+        Msg msg = new Msg();
+        try{
+            JSONObject jsonObject = JSONObject.parseObject(data);
+            String key = jsonObject.getString("key");
+            Subject subject = SecurityUtils.getSubject();
+            User user = (User) subject.getPrincipal();
+            Album album = new Album();
+            album.setAlbumkey(key);
+            if(subject.hasRole("admin")){
+                album.setUserid(null);
+            }else{
+                album.setUserid(user.getId());
+            }
+            JSONObject jsonObj = new JSONObject();
+            Album album1 = albumServiceImpl.selectAlbum(album);
+            List<Images> imagesList =  imgAndAlbumService.selectImgForAlbumkey(key);
+            jsonObj.put("album",album1);
+            jsonObj.put("imagesList",imagesList);
+            msg.setData(jsonObj);
+        }catch (Exception e){
+            e.printStackTrace();
+            msg.setCode("500");
+            msg.setInfo("获取画廊数据错误");
+        }
+        return msg;
+
+    }
+
+    @PostMapping("/getAlbumImgList")  
     @ResponseBody
     public Msg getAlbumImgList(@RequestParam("data") String data) {
         Msg msg = new Msg();
@@ -111,7 +140,7 @@ public class AlbumController {
         return msg;
     }
 
-    @PostMapping("/SaveForAlbum")//new
+    @PostMapping("/SaveForAlbum") 
     @ResponseBody
     public Msg SaveForAlbum(@RequestParam(value = "data", defaultValue = "") String data){
         data = StringEscapeUtils.unescapeHtml4(data);
@@ -136,7 +165,7 @@ public class AlbumController {
             }
             Subject subject = SecurityUtils.getSubject();
             User u = (User) subject.getPrincipal();
-            String uuid = "TOALBUM"+ UUID.randomUUID().toString().replace("-", "").toLowerCase().substring(0,5)+"N";
+            String uuid = "TOALBUM"+ UUID.randomUUID().toString().replace("-", "").toLowerCase().substring(0,7)+"N";
             SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             Album album = new Album();
             album.setAlbumtitle(albumtitle);
@@ -173,7 +202,66 @@ public class AlbumController {
     }
 
 
-    @PostMapping("/checkPass")//new
+    @PostMapping("/admin/UpdateForAlbum") 
+    @ResponseBody
+    public Msg UpdateForAlbum(@RequestParam(value = "data", defaultValue = "") String data){
+        data = StringEscapeUtils.unescapeHtml4(data);
+        Msg msg = new Msg();
+        try {
+            JSONObject jsonObject = JSONObject.parseObject(data);
+            String albumkey = jsonObject.getString("albumkey");
+            String albumtitle = jsonObject.getString("albumtitle");
+            String password = jsonObject.getString("password");
+            JSONArray jsonArray = JSONArray.parseArray(jsonObject.getString("albumlist"));
+            if(null!=password){
+//                String regex = "^[a-z0-9A-Z\u4e00-\u9fa5]+$";
+//                return str.matches(regex);
+                password = password.replace(" ", "");
+                if(password.replace(" ", "").equals("") || password.length()<3){
+                    msg.setCode("110403");
+                    msg.setInfo("密码长度不得小于三位有效字符");
+                    return msg;
+                }
+            }
+            if(albumtitle==null || jsonArray.size()==0){
+                msg.setCode("110404");
+                msg.setInfo("标题和图片参数不能为空");
+                return msg;
+            }
+            Subject subject = SecurityUtils.getSubject();
+            User u = (User) subject.getPrincipal();
+            Album album = new Album();
+            album.setAlbumtitle(albumtitle);
+            album.setPassword(password);
+            album.setAlbumkey(albumkey);
+
+            albumServiceImpl.updateAlbum(album);
+            imgAndAlbumService.deleteImgAndAlbumForKey(albumkey);
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject img = jsonArray.getJSONObject(i);
+                ImgAndAlbum imgAndAlbum = new ImgAndAlbum();
+                imgAndAlbum.setImgname(img.getString("imgurl"));
+                imgAndAlbum.setAlbumkey(albumkey);
+                imgAndAlbum.setNotes(img.getString("notes"));
+                albumServiceImpl.addAlbumForImgAndAlbumMapper(imgAndAlbum);
+            }
+            final JSONObject json = new JSONObject();
+            json.put("url",albumkey);
+            json.put("title",albumtitle);
+            json.put("password",password);
+            msg.setCode("200");
+            msg.setInfo("画廊修改成功");
+            msg.setData(json);
+        }catch (Exception e){
+            e.printStackTrace();
+            msg.setCode("500");
+            msg.setInfo("修改画廊失败");
+        }
+        return msg;
+    }
+
+
+    @PostMapping("/checkPass") 
     @ResponseBody
     public Msg checkPass(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
@@ -207,7 +295,7 @@ public class AlbumController {
         return msg;
     }
 
-    @PostMapping("/getAlbumList") //new
+    @PostMapping("/getAlbumList")  
     @ResponseBody
     public Msg getAlbumList(@RequestParam(value = "data", defaultValue = "") String data){
         Msg msg = new Msg();

src/main/java/cn/hellohao/controller/ClientAppController.java

@@ -0,0 +1,135 @@
+package cn.hellohao.controller;
+
+import cn.hellohao.auth.token.JWTUtil;
+import cn.hellohao.pojo.Msg;
+import cn.hellohao.pojo.UploadConfig;
+import cn.hellohao.pojo.User;
+import cn.hellohao.service.AppClientService;
+import cn.hellohao.service.ImgService;
+import cn.hellohao.service.UploadConfigService;
+import cn.hellohao.service.impl.UploadServicel;
+import cn.hellohao.service.impl.UserServiceImpl;
+import cn.hellohao.utils.Base64ToMultipartFile;
+import cn.hellohao.utils.SetFiles;
+import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.SecurityUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletRequest;
+import java.io.File;
+
+/**
+ * @author Hellohao
+ * @version 1.0
+ * @date 2022-05-16 32:45
+ */
+@RestController
+@RequestMapping("/client")
+public class ClientAppController {
+
+    @Autowired
+    private ImgService imgService;
+    @Autowired
+    private AppClientService appClientService;
+    @Autowired
+    private UserServiceImpl userService;
+    @Autowired
+    private UploadConfigService uploadConfigService;
+    @Autowired
+    private UploadServicel uploadServicel;
+
+    @PostMapping("/loginByToken")
+    @ResponseBody
+    public Msg loginByToken(@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
+        try{
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            JSONObject jsonObject = new JSONObject();
+            User newUser = new User();
+            String userToken = jsonObj.getString("userToken");
+            newUser.setToken(userToken);
+            User userData = userService.loginByToken(userToken);
+            if(userData.getIsok()<1){
+                SecurityUtils.getSubject().logout();
+                msg.setInfo("账号暂时无法使用，请咨询管理员");
+                msg.setCode("110403");
+                return msg;
+            }
+            String jwtToken = JWTUtil.createToken(userData);
+            UploadConfig uploadConfig = uploadConfigService.getUpdateConfig();
+            jsonObject.put("username", userData.getUsername());
+            jsonObject.put("jwttoken", jwtToken);
+            jsonObject.put("suffix",uploadConfig.getSuffix().split(","));
+            jsonObject.put("myImgTotal", imgService.countimg(userData.getId()));
+            jsonObject.put("filesize",Integer.valueOf(uploadConfig.getFilesizeuser())/1024);
+            jsonObject.put("imgcount",uploadConfig.getImgcountuser());
+            jsonObject.put("uploadSwitch",uploadConfig.getUserclose());
+            long memory = Long.valueOf(userData.getMemory());
+            Long usermemory = imgService.getusermemory(userData.getId())==null?0L:imgService.getusermemory(userData.getId());
+            if(memory==0){
+                jsonObject.put("myMemory","无容量");
+            }else{
+                Double aDouble = Double.valueOf(String.format("%.2f", (((double)usermemory/(double)memory)*100)));
+                if(aDouble>=999){
+                    jsonObject.put("myMemory",999);
+                }else{
+                    jsonObject.put("myMemory",aDouble);
+                }
+            }
+            msg.setData(jsonObject);
+        }catch (Exception e){
+            e.printStackTrace();
+            msg.setCode("110500");
+            msg.setInfo("未获取到用户，请先在设置中添加Token");
+        }
+        return msg;
+    }
+
+    @PostMapping("/imgUpload")
+    public Msg imgUpload(HttpServletRequest request, @RequestParam(required = true, value = "file") MultipartFile multipartFile,
+                         @RequestParam(required = true, value = "days") String days)  {
+        Msg msg = new Msg();
+        try{
+            if (null != multipartFile) {
+                String originalFilename = multipartFile.getOriginalFilename();
+                if(StringUtils.isBlank(originalFilename)){
+                    originalFilename = "未命名图像";
+                }
+                File file = SetFiles.changeFile_new(multipartFile);
+                msg = uploadServicel.uploadForLoc(request,file,originalFilename,Integer.valueOf(days),null,null);
+            }else{
+                msg.setCode("500");
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+            msg.setCode("500");
+        }
+        return msg;
+    }
+
+    @PostMapping("/imgUploadForCopy")
+    public Msg imgUploadForCopy(@RequestParam(required = true, value = "data") String data, HttpServletRequest request)  {
+        Msg msg = new Msg();
+        try{
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            String imgstr = jsonObj.getString("imgstr");
+            Integer days = jsonObj.getInteger("days");
+            String md5 = jsonObj.getString("md5");
+            if (null != imgstr && !imgstr.isEmpty()) {
+                MultipartFile multipartFile = Base64ToMultipartFile.base64Convert(imgstr);
+                File file = SetFiles.changeFile_new(multipartFile);
+                msg = uploadServicel.uploadForLoc(request, file,"未命名图像", days, null,md5);
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+            msg.setCode("500");
+        }
+        return msg;
+    }
+
+
+
+}

src/main/java/cn/hellohao/controller/ClientController.java

@@ -2,11 +2,9 @@ package cn.hellohao.controller;
 
 import cn.hellohao.pojo.Msg;
 import cn.hellohao.service.impl.ClientService;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.ResponseBody;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
 import javax.servlet.http.HttpServletRequest;
@@ -17,18 +15,30 @@ import javax.servlet.http.HttpServletRequest;
  * @date 2019-07-18 17:22
  */
 @RestController
+@RequestMapping("/api")
 public class ClientController {
 
-    @Autowired
-    private ClientService clientService;
-
+    @Autowired private ClientService clientService;
 
     @PostMapping(value = "/uploadbymail")
     @ResponseBody
-    public Msg uploadbymail(HttpServletRequest request, @RequestParam("file") MultipartFile file, String mail, String pass)  {
-        Msg resultBean = clientService.uploadImg(request, file, mail, pass);
+    public Msg uploadbymail(
+            HttpServletRequest request,
+            @RequestParam(value = "file") MultipartFile file,
+            @RequestParam(value = "mail", defaultValue = "") String mail,
+            @RequestParam(value = "pass", defaultValue = "") String pass,
+            @RequestParam(value = "days", defaultValue = "0") String days) {
+        if (file == null
+                || StringUtils.isBlank(mail)
+                || StringUtils.isBlank(pass)) {
+            Msg msg = new Msg();
+            msg.setCode("400");
+            msg.setInfo("相关参数不能为空");
+            return msg;
+        }
+        Msg resultBean =
+                clientService.uploadImg(
+                        request, file, mail, pass, Integer.valueOf(days.toString()));
         return resultBean;
     }
-
-
 }

src/main/java/cn/hellohao/controller/CodeController.java

@@ -26,10 +26,10 @@ public class CodeController {
     @Autowired
     private CodeService codeService;
 
-    @RequestMapping(value = "/selectCodeList")//new
+    @RequestMapping(value = "/selectCodeList") 
     @ResponseBody
-    public Map<String, Object> selectCodeList(@RequestParam(value = "data", defaultValue = "") String data) {
-        Map<String, Object> map = new HashMap<String, Object>();
+    public Msg selectCodeList(@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
         Integer pageNum = jsonObj.getInteger("pageNum");
         Integer pageSize = jsonObj.getInteger("pageSize");
@@ -38,19 +38,16 @@ public class CodeController {
         try {
             codes = codeService.selectCode(null);
             PageInfo<Code> rolePageInfo = new PageInfo<>(codes);
-            map.put("code", 200);
-            map.put("info", "");
-            map.put("count", rolePageInfo.getTotal());
-            map.put("data", rolePageInfo.getList());
+            msg.setData(rolePageInfo);
         } catch (Exception e) {
             e.printStackTrace();
-            map.put("code", 500);
-            map.put("info", "获取数据异常");
+            msg.setCode("500");
+            msg.setInfo("获取数据异常");
         }
-        return map;
+        return msg;
     }
 
-    @RequestMapping("/deleteCodes")//new
+    @RequestMapping("/deleteCodes") 
     @ResponseBody
     public Msg deletecodes(@RequestParam(value = "data", defaultValue = "") String data){
         final Msg msg = new Msg();
@@ -72,7 +69,7 @@ public class CodeController {
     }
 
 
-    @RequestMapping("/addCode")//new
+    @RequestMapping("/addCode") 
     @ResponseBody
     public Msg addcode(@RequestParam(value = "data", defaultValue = "") String data){
         final Msg msg = new Msg();

src/main/java/cn/hellohao/controller/GroupController.java

@@ -12,9 +12,8 @@ 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.ResponseBody;
-import java.util.HashMap;
+
 import java.util.List;
-import java.util.Map;
 
 /**
  * @author Hellohao
@@ -28,7 +27,7 @@ public class GroupController {
     private GroupService groupService;
 
 
-    @PostMapping("/getGrouplistForUsers") //new
+    @PostMapping("/getGrouplistForUsers")  
     @ResponseBody
     public Msg getGrouplistForUsers() {
         Msg msg = new Msg();
@@ -37,10 +36,10 @@ public class GroupController {
         return msg;
     }
 
-    @PostMapping(value = "/getGroupList")//new
+    @PostMapping(value = "/getGroupList") 
     @ResponseBody
-    public Map<String, Object> getgrouplist(@RequestParam(value = "data", defaultValue = "") String data) {
-        Map<String, Object> map = new HashMap<String, Object>();
+    public Msg getgrouplist(@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
         Integer pageNum = jsonObj.getInteger("pageNum");
         Integer pageSize = jsonObj.getInteger("pageSize");
@@ -49,19 +48,16 @@ public class GroupController {
         try {
             group = groupService.grouplist(null);
             PageInfo<Group> rolePageInfo = new PageInfo<>(group);
-            map.put("code", 200);
-            map.put("info", "");
-            map.put("count", rolePageInfo.getTotal());
-            map.put("data", rolePageInfo.getList());
+            msg.setData(rolePageInfo);
         } catch (Exception e) {
             e.printStackTrace();
-            map.put("code", 500);
-            map.put("info", "获取数据异常");
+            msg.setCode("500");
+            msg.setInfo("获取数据异常");
         }
-        return map;
+        return msg;
     }
 
-    @PostMapping(value = "/addGroup")//new
+    @PostMapping(value = "/addGroup") 
     @ResponseBody
     public Msg addisgroup(@RequestParam(value = "data", defaultValue = "") String data) {
         JSONObject jsonObject = JSONObject.parseObject(data);
@@ -74,7 +70,7 @@ public class GroupController {
         return msg;
     }
 
-    @PostMapping("/updateGroup")//new
+    @PostMapping("/updateGroup") 
     @ResponseBody
     public Msg updategroup(@RequestParam(value = "data", defaultValue = "") String data) {
         JSONObject jsonObject = JSONObject.parseObject(data);
@@ -93,7 +89,7 @@ public class GroupController {
         return msg;
     }
 
-    @PostMapping(value = "/deleGroup")//new
+    @PostMapping(value = "/deleGroup") 
     @ResponseBody
     public Msg delegroup(@RequestParam(value = "data", defaultValue = "") String data) {
         JSONObject jsonObject = JSONObject.parseObject(data);

src/main/java/cn/hellohao/controller/IndexController.java

@@ -1,111 +1,168 @@
 package cn.hellohao.controller;
 
 import cn.hellohao.auth.token.JWTUtil;
+import cn.hellohao.config.GlobalConstant;
 import cn.hellohao.pojo.*;
 import cn.hellohao.service.*;
-import cn.hellohao.service.impl.*;
-import cn.hellohao.utils.*;
-import cn.hellohao.utils.verifyCode.IVerifyCodeGen;
-import cn.hellohao.utils.verifyCode.SimpleCharVerifyCodeGenImpl;
-import cn.hellohao.utils.verifyCode.VerifyCode;
+import cn.hellohao.service.impl.UploadServicel;
+import cn.hellohao.service.impl.WebDAVImageupload;
+import cn.hellohao.service.impl.deleImages;
+import cn.hellohao.utils.GetIPS;
+import cn.hellohao.utils.MyVersion;
+import cn.hellohao.utils.SetFiles;
+import cn.hutool.captcha.CaptchaUtil;
+import cn.hutool.captcha.ShearCaptcha;
+import cn.hutool.captcha.generator.MathGenerator;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.subject.Subject;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
+
 import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
-import java.io.*;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
 
 @Controller
 public class IndexController {
-    @Autowired
-    private ImgService imgService;
-    @Autowired
-    private SysConfigService sysConfigService;
-    @Autowired
-    IRedisService iRedisService;
-    @Autowired
-    private ConfigService configService;
-    @Autowired
-    private UploadConfigService uploadConfigService;
-    @Autowired
-    private  UploadServicel uploadServicel;
-    @Autowired
-    private NOSImageupload nosImageupload;
-    @Autowired
-    private OSSImageupload ossImageupload;
-    @Autowired
-    private COSImageupload cosImageupload;
-    @Autowired
-    private KODOImageupload kodoImageupload;
-    @Autowired
-    private USSImageupload ussImageupload;
-    @Autowired
-    private UFileImageupload uFileImageupload;
-    @Autowired
-    private FTPImageupload ftpImageupload;
-    @Autowired
-    AlbumServiceImpl albumService;
-    @Autowired
-    private KeysService keysService;
-    @Autowired
-    private ImgTempService imgTempService;
-    @Autowired
-    private ImgAndAlbumService imgAndAlbumService;
-
+    @Autowired private ImgService imgService;
+    @Autowired private SysConfigService sysConfigService;
+    @Autowired private ConfdataService confdataService;
+    @Autowired private UploadConfigService uploadConfigService;
+    @Autowired private UploadServicel uploadServicel;
+    @Autowired private deleImages deleimages;
+    @Autowired private IRedisService iRedisService;
+    @Autowired private AppClientService appClientService;
+    @Autowired private WebDAVImageupload webDAVImageupload;
+    public static String version =  "20240319";
+    @RequestMapping(value = "/")
+    public String Welcome(Model model, HttpServletRequest httpServletRequest) {
+        model.addAttribute("name", "服务端程序(开源版)");
+        model.addAttribute("version", version);
+        model.addAttribute("ip", GetIPS.getIpAddr(httpServletRequest));
+        model.addAttribute("links", "https://github.com/Hello-hao/tbed");
+        return "welcome";
+    }
 
     @RequestMapping(value = "/webInfo")
     @ResponseBody
     public Msg webInfo() {
-        final Msg msg = new Msg();
-        Config config = configService.getSourceype();
+        Msg msg = new Msg();
+        final Confdata confdata = confdataService.selectConfdata("config");
+        JSONObject cd = JSONObject.parseObject(confdata.getJsondata());
         UploadConfig updateConfig = uploadConfigService.getUpdateConfig();
         SysConfig sysConfig = sysConfigService.getstate();
         JSONObject jsonObject = new JSONObject();
-        jsonObject.put("webname",config.getWebname());
-        jsonObject.put("websubtitle",config.getWebsubtitle());
-        jsonObject.put("keywords",config.getWebkeywords());
-        jsonObject.put("description",config.getWebms());
-        jsonObject.put("explain",config.getExplain());
-        jsonObject.put("favicon",config.getWebfavicons());
-        jsonObject.put("baidu",config.getBaidu());
-        jsonObject.put("links",config.getLinks());
-        jsonObject.put("aboutinfo",config.getAboutinfo());
-        jsonObject.put("logo",config.getLogo());
-        jsonObject.put("api",updateConfig.getApi());
-        jsonObject.put("register",sysConfig.getRegister());
+        AppClient appClient = appClientService.getAppClientData("app");
+        jsonObject.put("webname", cd.getString("webname"));
+        jsonObject.put("systype","free");
+        jsonObject.put("version",version);
+        jsonObject.put("websubtitle", cd.getString("websubtitle"));
+        jsonObject.put("keywords", cd.getString("keywords"));
+        jsonObject.put("webms", cd.getString("webms"));
+        jsonObject.put("explain", cd.getString("explain"));
+        jsonObject.put("baidu", cd.getString("baidu"));
+        jsonObject.put("links", cd.getString("links"));
+        jsonObject.put("aboutinfo", cd.getString("aboutinfo"));
+        jsonObject.put("logo", cd.getString("logo"));
+        jsonObject.put("webfavicons", cd.getString("webfavicons"));
+        jsonObject.put("api", updateConfig.getApi());
+        jsonObject.put("register", sysConfig.getRegister());
+        jsonObject.put("isuse", appClient.getIsuse());
+        jsonObject.put("clientname", appClient.getAppname());
+        jsonObject.put("clientlogo", appClient.getApplogo());
+        jsonObject.put("appupdate", appClient.getAppupdate());
+        jsonObject.put("serverVersion",version);
         msg.setData(jsonObject);
         return msg;
     }
-
-    @PostMapping(value = "/upload")// new
+    @PostMapping(value = {"/uploadChunkFile","/client/uploadChunkFile"})
     @ResponseBody
-    public Msg upimg(HttpServletRequest request,HttpSession httpSession
-            , @RequestParam(value = "file", required = false) MultipartFile multipartFile,Integer day) {
-        return uploadServicel.uploadForLoc(request,multipartFile,day,null);
+    @CrossOrigin
+    public Msg uploadChunk(HttpServletRequest request,Chunk chunk) {
+        Msg msg = new Msg();
+        MultipartFile file = chunk.getFile();
+        try {
+            byte[] bytes = file.getBytes();
+            Path path = Paths.get(SetFiles.generatePath(GlobalConstant.HELLOHAOTEMPIMG_PATH+ File.separator+chunk.getUuid(), chunk));
+            java.nio.file.Files.write(path, bytes);
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("chunkNumber",chunk.getChunkNumber());
+            jsonObject.put("totalChunks",chunk.getTotalChunks());
+            msg.setData(jsonObject);
+            msg.setCode("200");
+            return msg;
+        } catch (IOException e) {
+            e.printStackTrace();
+            msg.setCode("500");
+            return msg;
+        }
     }
 
-    @PostMapping(value = "/uploadForUrl") //new
+    @PostMapping(value = {"/processFile","/client/processFile"})
     @ResponseBody
-    public Msg upurlimg(HttpServletRequest request,@RequestParam(value = "data", defaultValue = "") String data) {
+    @CrossOrigin
+    public Msg processFile(HttpServletRequest request,@RequestParam(value = "data", defaultValue = "") String data){
+        Msg msg = new Msg();
+        try{
+            Subject subject = SecurityUtils.getSubject();
+            User user = (User) subject.getPrincipal();
+            CompletableFuture<Msg> ret = uploadServicel.mergeFile(request,data,user);
+            msg = ret.get();
+        }catch (Exception e){
+            msg.setCode("500");
+            msg.setInfo("处理文件错误，上传失败");
+        }
+        return msg;
+    }
+
+    @PostMapping(value = {"/upload", "/client/upload"})
+    @ResponseBody
+    public Msg upimg(
+            HttpServletRequest request,
+            @RequestParam(value = "file", required = false) MultipartFile multipartFile,
+            Integer day,@RequestParam(value = "md5",required = false) String md5) {
+        JSONArray jsonArray = new JSONArray();
+        Subject subject = SecurityUtils.getSubject();
+        User user = (User) subject.getPrincipal();
+        String originalFilename = multipartFile.getOriginalFilename();
+        if(StringUtils.isBlank(originalFilename)){
+            originalFilename = "未命名图像";
+        }
+        File file = SetFiles.changeFile_new(multipartFile);
+        return uploadServicel.uploadForLoc(request, file,originalFilename, day, null,md5);
+    }
+
+    @PostMapping(value = {"/uploadForUrl", "/client/uploadForUrl"})
+    @ResponseBody
+    public Msg upurlimg(
+            HttpServletRequest request, @RequestParam(value = "data", defaultValue = "") String data) {
         JSONObject jsonObj = JSONObject.parseObject(data);
         Integer setday = jsonObj.getInteger("day");
         String imgUrl = jsonObj.getString("imgUrl");
+        String referer = jsonObj.getString("referer");
         String[] URLArr = imgUrl.split("\n");
 
         Subject subject = SecurityUtils.getSubject();
         User user = (User) subject.getPrincipal();
         UploadConfig updateConfig = uploadConfigService.getUpdateConfig();
         int syscounts = 0;
-        if(null==user){
+        if (null == user) {
             syscounts = updateConfig.getImgcounttourists();
-        }else{
+        } else {
             syscounts = updateConfig.getImgcountuser();
         }
         Msg retMsg = new Msg();
@@ -114,27 +171,38 @@ public class IndexController {
         int errcounts = 0;
         int excess = 0;
         for (int i = 0; i < URLArr.length; i++) {
-            int temp = i+1;
-            if(syscounts>=temp){
-                Msg msg = uploadServicel.uploadForLoc(request, null, setday, URLArr[i]);
-                if(!msg.getCode().equals("200")){
+            int temp = i + 1;
+            if (syscounts >= temp) {
+                JSONObject imgJson = new JSONObject();
+                imgJson.put("imgUrl",URLArr[i]);
+                imgJson.put("referer",referer);
+                Msg msg = uploadServicel.uploadForLoc(request, null,"URL转存图像", setday, imgJson,null);
+                if (!msg.getCode().equals("200")) {
                     errcounts++;
-                }else{
+                } else {
                     retArray.add(msg);
                 }
-            }else{
+            } else {
                 excess++;
             }
         }
-        jsonObject.put("counts",URLArr.length);
-        jsonObject.put("errcounts",errcounts);
-        jsonObject.put("excess",excess);
-        jsonObject.put("urls",retArray);
+        jsonObject.put("counts", URLArr.length);
+        jsonObject.put("errcounts", errcounts);
+        jsonObject.put("excess", excess);
+        jsonObject.put("urls", retArray);
         retMsg.setData(jsonObject);
         return retMsg;
     }
 
-    @RequestMapping(value = "/getUploadInfo")//new
+    //webdav本地托管
+    @GetMapping("/w/{shortuuid}")
+    public ResponseEntity<InputStreamResource> getNextcloudImage(HttpServletRequest request, @PathVariable("shortuuid") String shortuuid) {
+        ResponseEntity<InputStreamResource> webDAV = webDAVImageupload.getWebDAV(shortuuid);
+        return webDAV;
+
+    }
+
+    @RequestMapping(value = "/getUploadInfo")
     @ResponseBody
     public Msg getUploadInfo() {
         Msg msg = new Msg();
@@ -143,19 +211,19 @@ public class IndexController {
         User user = (User) subject.getPrincipal();
         try {
             UploadConfig updateConfig = uploadConfigService.getUpdateConfig();
-            jsonObject.put("suffix",updateConfig.getSuffix().split(","));
-            if(null==user){
-                jsonObject.put("filesize",Integer.valueOf(updateConfig.getFilesizetourists())/1024);
-                jsonObject.put("imgcount",updateConfig.getImgcounttourists());
-                jsonObject.put("uploadSwitch",updateConfig.getIsupdate());
-                jsonObject.put("uploadInfo","您登陆后才能使用此功能哦");
-            }else{
-                jsonObject.put("filesize",Integer.valueOf(updateConfig.getFilesizeuser())/1024);
-                jsonObject.put("imgcount",updateConfig.getImgcountuser());
-                jsonObject.put("uploadSwitch",updateConfig.getUserclose());
-                jsonObject.put("uploadInfo","系统暂时关闭了用户上传功能");
+            jsonObject.put("suffix", updateConfig.getSuffix().split(","));
+            if (null == user) {
+                jsonObject.put("filesize", Integer.valueOf(updateConfig.getFilesizetourists()) / 1024);
+                jsonObject.put("imgcount", updateConfig.getImgcounttourists());
+                jsonObject.put("uploadSwitch", updateConfig.getIsupdate());
+                jsonObject.put("uploadInfo", "您登陆后才能使用此功能哦");
+            } else {
+                jsonObject.put("filesize", Integer.valueOf(updateConfig.getFilesizeuser()) / 1024);
+                jsonObject.put("imgcount", updateConfig.getImgcountuser());
+                jsonObject.put("uploadSwitch", updateConfig.getUserclose());
+                jsonObject.put("uploadInfo", "系统暂时关闭了用户上传功能");
             }
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
         }
         msg.setData(jsonObject);
@@ -167,19 +235,21 @@ public class IndexController {
     public Msg checkStatus(HttpServletRequest request) {
         Msg msg = new Msg();
         String token = request.getHeader("Authorization");
-        if(token != null) {
+        if (token != null) {
             JSONObject tokenJson = JWTUtil.checkToken(token);
-            if(tokenJson.getBoolean("check")){
+            if (tokenJson.getBoolean("check")) {
                 Subject subject = SecurityUtils.getSubject();
-                UsernamePasswordToken tokenOBJ = new UsernamePasswordToken(tokenJson.getString("email"),tokenJson.getString("password"));
+                UsernamePasswordToken tokenOBJ =
+                        new UsernamePasswordToken(
+                                tokenJson.getString("email"), tokenJson.getString("password"));
                 tokenOBJ.setRememberMe(true);
                 try {
                     subject.login(tokenOBJ);
                     SecurityUtils.getSubject().getSession().setTimeout(3600000);
                     User u = (User) subject.getPrincipal();
-                    final JSONObject jsonObject = new JSONObject();
-                    jsonObject.put("RoleLevel",u.getLevel()==2?"admin":"user");
-                    jsonObject.put("userName",u.getUsername());
+                    JSONObject jsonObject = new JSONObject();
+                    jsonObject.put("RoleLevel", u.getLevel() == 2 ? "admin" : "user");
+                    jsonObject.put("userName", u.getUsername());
                     msg.setCode("200");
                     msg.setData(jsonObject);
                 } catch (Exception e) {
@@ -188,142 +258,183 @@ public class IndexController {
                     System.err.println("登录失效，请重新登录");
                     e.printStackTrace();
                 }
-            }else{
+            } else {
                 msg.setCode("40041");
                 msg.setInfo("登录失效，请重新登录");
             }
-        }else{
+        } else {
             msg.setCode("40040");
             msg.setInfo("当前未登录，请先登录");
         }
         return msg;
     }
 
-    @GetMapping("/verifyCode")
-    public void verifyCode(HttpServletRequest request, HttpServletResponse response,HttpSession httpSession) {
-        IVerifyCodeGen iVerifyCodeGen = new SimpleCharVerifyCodeGenImpl();
+    @PostMapping("/verifyCode")
+    @ResponseBody
+    public Msg verifyCode() {
+        Msg msg = new Msg();
         try {
-            VerifyCode verifyCode = iVerifyCodeGen.generate(80, 38);
-            String code = verifyCode.getCode();
-            String userIP = GetIPS.getIpAddr(request);
-            iRedisService.setValue(userIP+"_hellohao_verifyCode",code);
-            response.setHeader("Pragma", "no-cache");
-            response.setHeader("Cache-Control", "no-cache");
-            response.setDateHeader("Expires", 0);
-            response.setContentType("image/jpeg");
-            response.getOutputStream().write(verifyCode.getImgBytes());
-            response.getOutputStream().flush();
-        } catch (IOException e) {
+            ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(90, 35, 2, 2);
+            captcha.setGenerator(new MathGenerator(1));
+            String code = getVerifyCodeOperator(captcha.getCode());
+            String uid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+            iRedisService.setValue("verifyCode_" + uid, code);
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("codeKey", uid);
+            jsonObject.put("codeImg", captcha.getImageBase64());
+            msg.setData(jsonObject);
+            return msg;
+        } catch (Exception e) {
             e.printStackTrace();
+            msg.setCode("500");
+            return msg;
         }
     }
 
-    @GetMapping("/verifyCodeForRegister")
-    public void verifyCodeForRegister(HttpServletRequest request, HttpServletResponse response,HttpSession httpSession) {
-        IVerifyCodeGen iVerifyCodeGen = new SimpleCharVerifyCodeGenImpl();
+    @PostMapping("/verifyCodeForRegister")
+    @ResponseBody
+    public Msg verifyCodeForRegister() {
+        Msg msg = new Msg();
         try {
-            VerifyCode verifyCode = iVerifyCodeGen.generate(80, 38);
-            String code = verifyCode.getCode();
-            String userIP = GetIPS.getIpAddr(request);
-            iRedisService.setValue(userIP+"_hellohao_verifyCodeForRegister",code);
-            response.setHeader("Pragma", "no-cache");
-            response.setHeader("Cache-Control", "no-cache");
-            response.setDateHeader("Expires", 0);
-            response.setContentType("image/jpeg");
-            response.getOutputStream().write(verifyCode.getImgBytes());
-            response.getOutputStream().flush();
-        } catch (IOException e) {
+            ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(90, 35, 2, 2);
+            captcha.setGenerator(new MathGenerator(1));
+            String code = getVerifyCodeOperator(captcha.getCode());
+            String uid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+            iRedisService.setValue("verifyCodeForRegister_" + uid, code);
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("codeKey", uid);
+            jsonObject.put("codeImg", captcha.getImageBase64());
+            msg.setData(jsonObject);
+            return msg;
+        } catch (Exception e) {
             e.printStackTrace();
+            msg.setCode("500");
+            return msg;
         }
     }
 
-    @GetMapping("/verifyCodeForRetrieve")
-    public void verifyCodeForRetrieve(HttpServletRequest request, HttpServletResponse response,HttpSession httpSession) {
-        IVerifyCodeGen iVerifyCodeGen = new SimpleCharVerifyCodeGenImpl();
+    @PostMapping("/verifyCodeForRetrieve")
+    @ResponseBody
+    public Msg verifyCodeForRetrieve() {
+        Msg msg = new Msg();
         try {
-            VerifyCode verifyCode = iVerifyCodeGen.generate(80, 38);
-            String code = verifyCode.getCode();
-            System.out.println("verifyCodeForRetrieve-zhaoHui httpSession ID==="+httpSession.getId());
-            String userIP = GetIPS.getIpAddr(request);
-            iRedisService.setValue(userIP+"_hellohao_verifyCodeForEmailRetrieve",code);
-            response.setHeader("Pragma", "no-cache");
-            response.setHeader("Cache-Control", "no-cache");
-            response.setDateHeader("Expires", 0);
-            response.setContentType("image/jpeg");
-            response.getOutputStream().write(verifyCode.getImgBytes());
-            response.getOutputStream().flush();
-        } catch (IOException e) {
+            ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(90, 35, 2, 2);
+            captcha.setGenerator(new MathGenerator(1));
+            String code = getVerifyCodeOperator(captcha.getCode());
+            String uid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+            iRedisService.setValue("verifyCodeForRetrieve_" + uid, code);
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("codeKey", uid);
+            jsonObject.put("codeImg", captcha.getImageBase64());
+            msg.setData(jsonObject);
+            return msg;
+        } catch (Exception e) {
             e.printStackTrace();
+            msg.setCode("500");
+            return msg;
         }
     }
 
-    @PostMapping("/deleImagesByUid") //new
+    @PostMapping(value = {"/verifyCodeFortowSendEmail","/wechat/verifyCodeFortowSendEmail"})
+    @ResponseBody
+    public Msg verifyCodeFortowSendEmail() {
+        Msg msg = new Msg();
+        try {
+            ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(90, 35, 2, 2);
+            // 自定义验证码内容为四则运算方式
+            captcha.setGenerator(new MathGenerator(1));
+            String code = getVerifyCodeOperator(captcha.getCode());
+            String uid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+            iRedisService.setValue("verifyCodeFortowSendEmail_"+uid,code);
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("codeKey",uid);
+            jsonObject.put("codeImg",captcha.getImageBase64());
+            msg.setData(jsonObject);
+            return msg;
+        } catch (Exception e) {
+            e.printStackTrace();
+            msg.setCode("500");
+            return msg;
+        }
+    }
+
+    public static String getVerifyCodeOperator(String str) {
+        int a = Integer.valueOf(str.substring(0, 1));
+        String yxf = str.substring(1, 2);
+        int b = Integer.valueOf(str.substring(2, 3));
+        switch (yxf) {
+            case "*":
+                return Integer.toString(a * b);
+            case "+":
+                return Integer.toString(a + b);
+            case ",":
+            default:
+                return Integer.toString(82);
+            case "-":
+                return Integer.toString(a - b);
+        }
+    }
+
+    @PostMapping({"/deleImagesByUid", "/client/deleImagesByUid"})
     @ResponseBody
     public Msg deleImagesByUid(@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
         String imguid = jsonObj.getString("imguid");
         Images image = imgService.selectImgUrlByImgUID(imguid);
+        if (null == image) {
+            msg.setInfo("图像已不存在，删除成功");
+            return msg;
+        }
         Subject subject = SecurityUtils.getSubject();
         User user = (User) subject.getPrincipal();
-        if(null!=user){
-            if(user.getId()!=image.getUserid()){
+        if (null != user) {
+            if (!user.getId().equals(image.getUserid())) {
                 msg.setInfo("删除失败，该图片不允许你执行操作");
                 msg.setCode("100403");
                 return msg;
             }
         }
-        Integer keyid = image.getSource();
-        String imgname = image.getImgname();
-        Keys key = keysService.selectKeys(keyid);
-        //删除图片
-        boolean isDele = false;
-        if (key.getStorageType() == 1) {
-            isDele = nosImageupload.delNOS(key.getId(), imgname);
-        } else if (key.getStorageType() == 2) {
-            isDele = ossImageupload.delOSS(key.getId(), imgname);
-        } else if (key.getStorageType() == 3) {
-            isDele = ussImageupload.delUSS(key.getId(), imgname);
-        } else if (key.getStorageType() == 4) {
-            isDele = kodoImageupload.delKODO(key.getId(), imgname);
-        } else if (key.getStorageType() == 5) {
-            isDele = LocUpdateImg.deleteLOCImg(imgname);
-        }else if (key.getStorageType() == 6) {
-            isDele = cosImageupload.delCOS(key.getId(), imgname);
-        }else if (key.getStorageType() == 7) {
-            isDele = ftpImageupload.delFTP(key.getId(), imgname);
-        }else if (key.getStorageType() == 8) {
-            isDele = uFileImageupload.delUFile(key.getId(), imgname);
-        }else {
-            System.err.println("未获取到对象存储参数，删除失败。");
-        }
-        //删除库
-        if(isDele){
-            try {
-                imgAndAlbumService.deleteImgAndAlbum(imgname);
-                imgTempService.delImgAndExp(image.getImguid());
-                imgService.deleimg(image.getId());
-            } catch (Exception e) {
-                e.printStackTrace();
-                msg.setInfo("图片记录时发生错误");
-                msg.setCode("500");
-                return msg;
-            }
-            msg.setInfo("删除成功");
-        }else{
-            imgAndAlbumService.deleteImgAndAlbum(imgname);
-            imgTempService.delImgAndExp(image.getImguid());
-            imgService.deleimg(image.getId());
-            msg.setInfo("图片记录已删除，但是图片源删除失败");
+        msg = deleimages.dele(false,null, image.getId());
+        List<Long> Delids = (List<Long>) msg.getData();
+        if (!Delids.contains(image.getId())) {
             msg.setCode("500");
+            msg.setInfo("图像删除失败");
+        } else {
+            msg.setCode("200");
+            msg.setInfo("图像已成功删除");
+        }
+        return msg;
+    }
+
+    @PostMapping("/getClientVersion")
+    @ResponseBody
+    public Msg getClientVersion(@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
+        msg.setCode("000");
+        try {
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            String appv = jsonObj.getString("version");
+            AppClient app = appClientService.getAppClientData("app");
+            if (!StringUtils.isBlank(app.getAppupdate())) {
+                String version = app.getAppupdate().replaceAll("\\.", "");
+                if (MyVersion.compareVersion(app.getAppupdate(), appv) == 1) {
+                    JSONObject jsonObject = new JSONObject();
+                    jsonObject.put("winpackurl", app.getWinpackurl());
+                    jsonObject.put("macpackurl", app.getMacpackurl());
+                    msg.setCode("200");
+                    msg.setData(jsonObject);
+                }
+            }
+        } catch (Exception e) {
+            msg.setCode("000");
         }
-        System.out.println("返回的值："+msg.toString());
         return msg;
     }
 
     @RequestMapping("/authError")
     @ResponseBody
-    public Msg authError(HttpServletRequest request){
+    public Msg authError(HttpServletRequest request) {
         Msg msg = new Msg();
         msg.setCode("4031");
         msg.setInfo("You don't have authority");
@@ -332,13 +443,10 @@ public class IndexController {
 
     @RequestMapping("/jurisError")
     @ResponseBody
-    public Msg jurisError(HttpServletRequest request){
+    public Msg jurisError(HttpServletRequest request) {
         Msg msg = new Msg();
         msg.setCode("4031");
         msg.setInfo("Authentication request failed");
         return msg;
     }
-
-
-
 }

src/main/java/cn/hellohao/controller/UserController.java

@@ -1,29 +1,35 @@
 package cn.hellohao.controller;
 
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.UUID;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
 import cn.hellohao.auth.filter.SubjectFilter;
 import cn.hellohao.auth.token.JWTUtil;
 import cn.hellohao.config.SysName;
 import cn.hellohao.pojo.*;
 import cn.hellohao.service.*;
-import cn.hellohao.utils.*;
+import cn.hellohao.utils.NewSendEmail;
+import cn.hellohao.utils.Print;
+import cn.hellohao.utils.SetText;
 import cn.hutool.core.util.HexUtil;
+import com.alibaba.fastjson.JSONObject;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.authc.IncorrectCredentialsException;
 import org.apache.shiro.authc.UnknownAccountException;
 import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.subject.Subject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
-import com.alibaba.fastjson.JSONObject;
 import org.springframework.web.bind.annotation.*;
 
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.text.SimpleDateFormat;
+import java.util.Base64;
+import java.util.Date;
+import java.util.UUID;
+
 
 @Controller
 @RequestMapping("/user")
@@ -33,34 +39,42 @@ public class UserController {
     @Autowired
     private EmailConfigService emailConfigService;
     @Autowired
-    private ConfigService configService;
+    private ConfdataService confdataService;
     @Autowired
     private UploadConfigService uploadConfigService;
     @Autowired
     private SysConfigService sysConfigService;
     @Autowired
     IRedisService iRedisService;
+    private Logger logger = LoggerFactory.getLogger(UserController.class);
 
     @PostMapping("/register")
     @ResponseBody
-    public Msg Register(HttpServletRequest request, @RequestParam(value = "data", defaultValue = "") String data) {//Validated
+    public Msg Register(HttpServletRequest httpServletRequest, @RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
         String username = jsonObj.getString("username");
         String email = jsonObj.getString("email");
-        String password = Base64Encryption.encryptBASE64(jsonObj.getString("password").getBytes());
-        String userIP = GetIPS.getIpAddr(request);
+        String password = Base64.getEncoder().encodeToString(jsonObj.getString("password").getBytes());
         String verifyCodeForRegister = jsonObj.getString("verifyCode");
-        Object redis_verifyCodeForRegister = iRedisService.getValue(userIP+"_hellohao_verifyCodeForRegister");
+        Object redis_verifyCodeForRegister = iRedisService.getValue("verifyCodeForRegister_"+httpServletRequest.getHeader("verifyCodeForRegister"));
         if(!SetText.checkEmail(email)){
+            //邮箱格式不正确
             msg.setCode("110403");
             msg.setInfo("邮箱格式不正确");
             return msg;
         }
         String regex = "^\\w+$";
-        if(username.length()>20 || !username.matches (regex)){
+        if(username.length()>30){
+            //用户名格式不正确
             msg.setCode("110403");
-            msg.setInfo("用户名不得超过20位字符");
+            msg.setInfo("用户名不得超过30位字符");
+            return msg;
+        }
+        if(!username.matches (regex)){
+            //用户名格式不正确
+            msg.setCode("110403");
+            msg.setInfo("用户名不得含有特殊字符");
             return msg;
         }
         if(null==redis_verifyCodeForRegister){
@@ -105,18 +119,22 @@ public class UserController {
             user.setEmail(email);
             user.setUsername(username);
             user.setPassword(password);
-            Config config = configService.getSourceype();
+            user.setToken(UUID.randomUUID().toString().replace("-", ""));
+            final Confdata confdata = confdataService.selectConfdata("config");
+            JSONObject jsonObject = JSONObject.parseObject(confdata.getJsondata());
             Integer type = 0;
             if(emailConfig.getUsing()==1){
                 user.setIsok(0);
+                //注册完发激活链接
                 Thread thread = new Thread() {
                     public void run() {
-                        Integer a = NewSendEmail.sendEmail(emailConfig,user.getUsername(), uid, user.getEmail(),config);
+                        Integer a = NewSendEmail.sendEmail(emailConfig,user.getUsername(), uid, user.getEmail(),jsonObject);
                     }
                 };
                 thread.start();
                 msg.setInfo("注册成功,请注意查收邮箱尽快激活账户");
             }else{
+                //直接注册
                 user.setIsok(1);
                 msg.setInfo("注册成功,快去登陆吧");
             }
@@ -128,16 +146,78 @@ public class UserController {
         return msg;
     }
 
+    @PostMapping(value = {"/validateEmail","/wechat/validateEmail"})
+    @ResponseBody
+    public Msg validateEmail(HttpServletRequest httpServletRequest,@RequestParam(value = "data", defaultValue = "") String data) {
+        Msg msg = new Msg();
+        try {
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            String email = jsonObj.getString("email");
+            String towSendEmailCode = jsonObj.getString("towSendEmailCode");
+            Object verifyCodeFortowSendEmail =iRedisService.getValue("verifyCodeFortowSendEmail_"+httpServletRequest.getHeader("verifyCodeFortowSendEmail"));
+            User u = new User();
+            u.setEmail(email);
+            User user = userService.getUsers(u);
+            if(user.getIsok()!=0){
+                msg.setInfo("不知细叶谁裁出，二月春风似剪刀");
+                return msg;
+            }
+            if(null==verifyCodeFortowSendEmail){
+                msg.setCode("4035");
+                msg.setInfo("验证码已失效，请重新弄获取。");
+                return msg;
+            }else if(null==towSendEmailCode){
+                msg.setCode("4036");
+                msg.setInfo("验证码不能为空。");
+                return msg;
+            }
+            if((verifyCodeFortowSendEmail.toString().toLowerCase()).compareTo((towSendEmailCode.toLowerCase()))==0){
+                //注册完发激活链接
+                final Confdata dataJson = confdataService.selectConfdata("config");
+                JSONObject confdata = JSONObject.parseObject(dataJson.getJsondata());
+                EmailConfig emailConfig = emailConfigService.getemail();
+                Thread thread = new Thread() {
+                    public void run() {
+                        Integer a = NewSendEmail.sendEmail(emailConfig,user.getUsername(), user.getUid(), user.getEmail(),confdata);
+                    }
+                };
+                thread.start();
+                msg.setInfo("邮件已发送,请注意查收邮箱尽快激活账户(如果没收到，请检查垃圾邮件)");
+            }else{
+                msg.setCode("110408");
+                msg.setInfo("验证码不正确");
+                return msg;
+            }
+
+        }catch (Exception e){
+            logger.error("报错位置：/validateEmail",e);
+            msg.setCode("500");
+            msg.setInfo("邮件发送失败");
+        }
+        return msg;
+    }
+
     @PostMapping("/login")//new
     @ResponseBody
-    public Msg login(HttpServletRequest request,@RequestParam(value = "data", defaultValue = "") String data) {
+    public Msg login(HttpServletRequest httpServletRequest,@RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         JSONObject jsonObj = JSONObject.parseObject(data);
         String email = jsonObj.getString("email");
-        String password = Base64Encryption.encryptBASE64(jsonObj.getString("password").getBytes());
+        String password = Base64.getEncoder().encodeToString(jsonObj.getString("password").getBytes());
         String verifyCode = jsonObj.getString("verifyCode");
-        String userIP = GetIPS.getIpAddr(request);
-        Object redis_VerifyCode = iRedisService.getValue(userIP+"_hellohao_verifyCode");
+        if(null == email || null == password || null == verifyCode){
+            msg.setCode("5000");
+            msg.setInfo("登录信息不正确");
+            return msg;
+        }
+        if(email.replace(" ","").equals("") || password.replace(" ","").equals("")
+                || verifyCode.replace(" ","").equals("")){
+            msg.setCode("5000");
+            msg.setInfo("登录信息不正确");
+            return msg;
+        }
+
+        Object redis_VerifyCode = iRedisService.getValue("verifyCode_"+httpServletRequest.getHeader("verifyCode"));
         if(null==redis_VerifyCode){
             msg.setCode("4035");
             msg.setInfo("验证码已失效，请重新弄获取。");
@@ -153,12 +233,13 @@ public class UserController {
             tokenOBJ.setRememberMe(true);
             try {
                 subject.login(tokenOBJ);
-                SecurityUtils.getSubject().getSession().setTimeout(3600000);//一小时
+                SecurityUtils.getSubject().getSession().setTimeout(3600000);
                 JSONObject jsonObject = new JSONObject();
                 User user = (User) SecurityUtils.getSubject().getPrincipal();
                 if(user.getIsok()==0){
                     msg.setInfo("你的账号暂未激活");
-                    msg.setCode("110403");
+                    msg.setData(user.getEmail());
+                    msg.setCode("110402");
                     return msg;
                 }
                 if(user.getIsok()<0){
@@ -178,15 +259,15 @@ public class UserController {
             } catch (UnknownAccountException e) {
                 //此异常说明用户名不存在
                 msg.setCode("4000");
-                msg.setInfo("登录邮箱不存在");
-                System.err.println("邮箱不存在");
-                e.printStackTrace();
+                msg.setInfo("登录账号不存在");
+                System.err.println("邮箱/用户名不存在");
+//                e.printStackTrace();
                 return msg;
             }catch (IncorrectCredentialsException e) {
                 msg.setCode("4000");
                 msg.setInfo("登录密码错误");
                 System.err.println("密码不存在");
-                e.printStackTrace();
+//                e.printStackTrace();
                 return msg;
             }catch (Exception e) {
                 msg.setCode("5000");
@@ -197,7 +278,7 @@ public class UserController {
             }
         }else{
             msg.setCode("40034");
-            msg.setInfo("验证码不正确");//失效也要处理。
+            msg.setInfo("验证码不正确");
         }
         return msg;
     }
@@ -205,7 +286,6 @@ public class UserController {
 
     @RequestMapping(value = "/activation", method = RequestMethod.GET)
     public String activation(Model model, HttpServletRequest request, HttpSession session, String activation, String username) {
-        Config config = configService.getSourceype();
         Integer ret = 0;
         User u2 = new User();
         u2.setUid(activation);
@@ -236,17 +316,15 @@ public class UserController {
         return msg;
     }
 
-    @PostMapping("/retrievePass") //new
+    @PostMapping("/retrievePass")
     @ResponseBody
-    public Msg retrievePass(HttpServletRequest request, @RequestParam(value = "data", defaultValue = "") String data) {
+    public Msg retrievePass(HttpServletRequest httpServletRequest, @RequestParam(value = "data", defaultValue = "") String data) {
         Msg msg = new Msg();
         try {
             JSONObject jsonObj = JSONObject.parseObject(data);
             String email = jsonObj.getString("email");
             String retrieveCode = jsonObj.getString("retrieveCode");
-            String userIP = GetIPS.getIpAddr(request);
-            Object redis_verifyCodeForEmailRetrieve = iRedisService.getValue(userIP+"_hellohao_verifyCodeForEmailRetrieve");
-
+            Object redis_verifyCodeForEmailRetrieve =iRedisService.getValue("verifyCodeForRetrieve_"+httpServletRequest.getHeader("verifyCodeForRetrieve"));
             EmailConfig emailConfig = emailConfigService.getemail();
             if(null==redis_verifyCodeForEmailRetrieve){
                 msg.setCode("4035");
@@ -262,7 +340,6 @@ public class UserController {
                 msg.setInfo("验证码不正确");
                 return msg;
             }
-
             Integer ret = userService.countmail(email);
             if(ret>0){
                 if(emailConfig.getUsing()==1){
@@ -274,10 +351,11 @@ public class UserController {
                         msg.setInfo("当前用户已被冻结，禁止操作");
                         return msg;
                     }
-                    Config config = configService.getSourceype();
+                    final Confdata confdata = confdataService.selectConfdata("config");
+                    JSONObject jsonObject = JSONObject.parseObject(confdata.getJsondata());
                     Thread thread = new Thread() {
                         public void run() {
-                            Integer a = NewSendEmail.sendEmailFindPass(emailConfig,user.getUsername(), user.getUid(), user.getEmail(),config);//SendEmail.sendEmailT(message, user.getUsername(), user.getUid(), user.getEmail(),emailConfig,config);
+                            Integer a = NewSendEmail.sendEmailFindPass(emailConfig,user.getUsername(), user.getUid(), user.getEmail(),jsonObject);
                         }
                     };
                     thread.start();
@@ -298,7 +376,7 @@ public class UserController {
         return msg;
     }
 
-    @RequestMapping(value = "/retrieve", method = RequestMethod.GET) //new
+    @RequestMapping(value = "/retrieve", method = RequestMethod.GET)
     public String retrieve(Model model, String activation,String cip) {
         Integer ret = 0;
         try {
@@ -307,7 +385,7 @@ public class UserController {
             User user = userService.getUsers(u2);
             user.setIsok(1);
             String new_pass = HexUtil.decodeHexStr(cip);//解密密码
-            user.setPassword(Base64Encryption.encryptBASE64(new_pass.getBytes()));
+            user.setPassword(Base64.getEncoder().encodeToString(new_pass.getBytes()));
             String uid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
             user.setUid(uid);
             if (user != null) {

src/main/java/cn/hellohao/dao/AlbumMapper.java

@@ -23,4 +23,6 @@ public interface AlbumMapper {
     List<Album> selectAlbumURLList(Album album);
 
     Integer selectAlbumCount(@Param("userid")  Integer userid);
+
+    Integer updateAlbum(Album album);
 }

src/main/java/cn/hellohao/dao/AppClientMapper.java

@@ -0,0 +1,19 @@
+package cn.hellohao.dao;
+
+import cn.hellohao.pojo.AppClient;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+/**
+ * @author Hellohao
+ * @version 1.0
+ * @date 2022-06-10 18:33
+ */
+
+@Mapper
+public interface AppClientMapper {
+    AppClient getAppClientData(@Param("id") String id);
+
+    Integer editAppClientData(AppClient appClient);
+
+}

src/main/java/cn/hellohao/dao/CodeMapper.java

@@ -9,13 +9,9 @@ import java.util.List;
 
 @Mapper
 public interface CodeMapper {
-    //查询扩容码
     List<Code> selectCode(@Param("code") String code);
     Code selectCodekey(@Param("code") String code);
-    //Integer selectCodekey(@Param("value") String value);
-    //添加
     Integer addCode(Code code);
-    //删除扩容码
     Integer deleteCode(@Param("code") String code);
 
 }

src/main/java/cn/hellohao/dao/ConfdataMapper.java

@@ -0,0 +1,11 @@
+package cn.hellohao.dao;
+
+import cn.hellohao.pojo.Confdata;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+@Mapper
+public interface ConfdataMapper {
+    Confdata selectConfdata(@Param("key") String key);
+    Integer updateConfdata(Confdata confdata);
+}

src/main/java/cn/hellohao/dao/ConfigMapper.java

@@ -1,11 +0,0 @@
-package cn.hellohao.dao;
-
-import cn.hellohao.pojo.Config;
-import org.apache.ibatis.annotations.Mapper;
-import org.springframework.stereotype.Service;
-
-@Mapper
-public interface ConfigMapper {
-    Config getSourceype();
-    Integer setSourceype(Config config);
-}

src/main/java/cn/hellohao/dao/ImgMapper.java

@@ -1,32 +1,37 @@
 package cn.hellohao.dao;
 
-import java.util.List;
-
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.User;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
-import cn.hellohao.pojo.Images;
+import java.util.List;
 
 @Mapper
 public interface ImgMapper {
 
     List<Images> selectimg(Images images);
 
+    Integer insertImgData(Images images);
+
     Integer countimg(@Param("userid") Integer userid);
 
-    Integer deleimg(@Param("id") Integer id);
+    Integer deleimg(@Param("id") Long id);
 
     Integer deleimgForImgUid(@Param("imguid") String imguid);
 
-    Images selectByPrimaryKey(@Param("id") Integer id);
+    Images selectByPrimaryKey(@Param("id") Long id);
+
+    Images selectImgByBrieflink(@Param("brieflink") String brieflink);
+
+    Images selectImgByShortlink(@Param("shortlink") String shortlink);
 
     Integer counts(@Param("userid") Integer userid);
 
     Integer setImg(Images images);
 
     Integer deleimgname(@Param("imgname") String imgname);
-    Integer deleall(@Param("id") Integer id);
+    Integer deleall(@Param("id") Long id);
 
     List<Images> gettimeimg(@Param("time") String time);
 
@@ -36,7 +41,7 @@ public interface ImgMapper {
 
     Integer md5Count(Images images);
 
-    List<Images> selectImgUrlByMD5(@Param("md5key") String md5key);
+    List<Images> selectImgUrlByMD5(Images images);
 
     List<Images> RecentlyUploaded(@Param("userid") Integer userid);
 

src/main/java/cn/hellohao/dao/KeysMapper.java

@@ -9,11 +9,9 @@ import java.util.List;
 
 @Mapper
 public interface KeysMapper {
-    //查询密钥
     Keys selectKeys(@Param("id") Integer id);
     List<Keys> getStorageName();
     List<Keys> getStorage();
-    //修改key
     Integer updateKey(Keys key);
     List<Keys> getKeys();
 

src/main/java/cn/hellohao/dao/UserMapper.java

@@ -1,54 +1,30 @@
 package cn.hellohao.dao;
 
+import cn.hellohao.pojo.User;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
-import cn.hellohao.pojo.Images;
-import cn.hellohao.pojo.User;
-
 import java.util.List;
 
 @Mapper
 public interface UserMapper {
-    //注册
     Integer register(User user);
-
-    //登录
     Integer login(@Param("email") String email, @Param("password") String password,@Param("uid") String uid);
-
-    //获取用户信息
     User getUsers(User user);
-
-    //插入图片
-    Integer insertimg(Images img);
-
-    //修改资料
+    User loginByToken (@Param("token") String token);
     Integer change(User user);
-
     Integer changeUser(User user);
-    //检查用户名是否重复
     Integer checkUsername(@Param("username") String username);
-
     Integer getUserTotal();
-
     List<User> getuserlist(String username);
-
-    //刪除用戶
     Integer deleuser(@Param("id") Integer id);
-
-    //查询用户名或者邮箱是否存在
     Integer countusername(@Param("username") String username);
-
     Integer countmail(@Param("email") String email);
-
     Integer uiduser(@Param("uid") String uid);
-
     User getUsersMail(@Param("uid") String uid);
     Integer setisok (User user);
-
     Integer setmemory(User user);
     User getUsersid(@Param("id") Integer id);
-
     List<User> getuserlistforgroupid(@Param("groupid") Integer groupid);
 
 }

src/main/java/cn/hellohao/pojo/AppClient.java

@@ -0,0 +1,81 @@
+package cn.hellohao.pojo;
+
+public class AppClient {
+
+    private String id;
+    private String isuse;
+    private String winpackurl;
+    private String macpackurl;
+    private String appname;
+    private String applogo;
+    private String appupdate;
+
+
+    public AppClient(){}
+
+    public AppClient(String id, String isuse, String winpackurl, String macpackurl, String appname, String applogo, String appupdate) {
+        this.id = id;
+        this.isuse = isuse;
+        this.winpackurl = winpackurl;
+        this.macpackurl = macpackurl;
+        this.appname = appname;
+        this.applogo = applogo;
+        this.appupdate = appupdate;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getIsuse() {
+        return isuse;
+    }
+
+    public void setIsuse(String isuse) {
+        this.isuse = isuse;
+    }
+
+    public String getWinpackurl() {
+        return winpackurl;
+    }
+
+    public void setWinpackurl(String winpackurl) {
+        this.winpackurl = winpackurl;
+    }
+
+    public String getMacpackurl() {
+        return macpackurl;
+    }
+
+    public void setMacpackurl(String macpackurl) {
+        this.macpackurl = macpackurl;
+    }
+
+    public String getAppname() {
+        return appname;
+    }
+
+    public void setAppname(String appname) {
+        this.appname = appname;
+    }
+
+    public String getApplogo() {
+        return applogo;
+    }
+
+    public void setApplogo(String applogo) {
+        this.applogo = applogo;
+    }
+
+    public String getAppupdate() {
+        return appupdate;
+    }
+
+    public void setAppupdate(String isupdate) {
+        this.appupdate = isupdate;
+    }
+}

src/main/java/cn/hellohao/pojo/Chunk.java

@@ -0,0 +1,70 @@
+package cn.hellohao.pojo;
+
+import lombok.Data;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.Transient;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.Serializable;
+
+@Data
+public class Chunk implements Serializable {
+    @Id
+    private String uid;
+    /**
+     * 当前文件块，从1开始
+     */
+    private Integer chunkNumber;
+    /**
+     * 分块大小
+     */
+    private Long chunkSize;
+    /**
+     * 当前分块大小
+     */
+    private Long currentChunkSize;
+    /**
+     * 总大小
+     */
+    private Long totalSize;
+    /**
+     * 文件标识
+     */
+    private String identifier;
+    /**
+     * 文件名
+     */
+    private String filename;
+    /**
+     * 相对路径
+     */
+    private String relativePath;
+    /**
+     * 总块数
+     */
+    private Integer totalChunks;
+    /**
+     * 文件类型
+     */
+    private String type;
+
+    /**
+     * 前台创建的随机UID,用作创建合并文件的唯一标识目录名
+     */
+    private String uuid;
+
+    /**
+     * 归类
+     */
+    private String classifications;
+
+    /**
+     * 天数
+     */
+    private Integer day;
+
+
+    @Transient
+    private MultipartFile file;
+
+}

src/main/java/cn/hellohao/pojo/Confdata.java

@@ -0,0 +1,16 @@
+package cn.hellohao.pojo;
+
+import lombok.Data;
+
+/**
+ * @author Hellohao
+ * @version 1.0
+ * @date 2023/3/2 10:21
+ */
+@Data
+public class Confdata {
+
+    private String key;
+    private String jsondata;
+
+}

src/main/java/cn/hellohao/pojo/Config.java

@@ -1,223 +0,0 @@
-package cn.hellohao.pojo;
-
-public class Config {
-    private Integer id;
-    private Integer sourcekey;
-    private Integer emails;
-    private String webname;
-    private String explain;
-    private String video;
-    private Integer backtype;
-    private String links;
-    private String notice;
-    private String baidu;
-    private String domain;
-    private String background1;
-    private String background2;
-    private String sett;
-    private String webms;
-    private String webkeywords;
-    private String webfavicons;
-    private Integer theme;
-    private String websubtitle;
-    private String logo;
-    private String aboutinfo;
-
-    public Config() {
-    }
-
-    public Config(Integer id, Integer sourcekey, Integer emails, String webname, String explain, String video, Integer backtype,
-                  String links, String notice, String baidu, String domain, String background1, String background2, String sett,
-                  String webms, String webkeywords, String webfavicons, Integer theme,String websubtitle,String logo,String aboutinfo) {
-        this.id = id;
-        this.sourcekey = sourcekey;
-        this.emails = emails;
-        this.webname = webname;
-        this.explain = explain;
-        this.video = video;
-        this.backtype = backtype;
-        this.links = links;
-        this.notice = notice;
-        this.baidu = baidu;
-        this.domain = domain;
-        this.background1 = background1;
-        this.background2 = background2;
-        this.sett = sett;
-        this.webms = webms;
-        this.webkeywords = webkeywords;
-        this.webfavicons = webfavicons;
-        this.theme = theme;
-        this.websubtitle = websubtitle;
-        this.logo = logo;
-        this.aboutinfo = aboutinfo;
-
-    }
-
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
-    public Integer getSourcekey() {
-        return sourcekey;
-    }
-
-    public void setSourcekey(Integer sourcekey) {
-        this.sourcekey = sourcekey;
-    }
-
-    public Integer getEmails() {
-        return emails;
-    }
-
-    public void setEmails(Integer emails) {
-        this.emails = emails;
-    }
-
-    public String getWebname() {
-        return webname;
-    }
-
-    public void setWebname(String webname) {
-        this.webname = webname;
-    }
-
-    public String getExplain() {
-        return explain;
-    }
-
-    public void setExplain(String explain) {
-        this.explain = explain;
-    }
-
-    public String getVideo() {
-        return video;
-    }
-
-    public void setVideo(String video) {
-        this.video = video;
-    }
-
-    public Integer getBacktype() {
-        return backtype;
-    }
-
-    public void setBacktype(Integer backtype) {
-        this.backtype = backtype;
-    }
-
-    public String getLinks() {
-        return links;
-    }
-
-    public void setLinks(String links) {
-        this.links = links;
-    }
-
-    public String getNotice() {
-        return notice;
-    }
-
-    public void setNotice(String notice) {
-        this.notice = notice;
-    }
-
-    public String getBaidu() {
-        return baidu;
-    }
-
-    public void setBaidu(String baidu) {
-        this.baidu = baidu;
-    }
-
-    public String getDomain() {
-        return domain;
-    }
-
-    public void setDomain(String domain) {
-        this.domain = domain;
-    }
-
-    public String getBackground1() {
-        return background1;
-    }
-
-    public void setBackground1(String background1) {
-        this.background1 = background1;
-    }
-
-    public String getBackground2() {
-        return background2;
-    }
-
-    public void setBackground2(String background2) {
-        this.background2 = background2;
-    }
-
-    public String getSett() {
-        return sett;
-    }
-
-    public void setSett(String sett) {
-        this.sett = sett;
-    }
-
-    public String getWebms() {
-        return webms;
-    }
-
-    public void setWebms(String webms) {
-        this.webms = webms;
-    }
-
-    public String getWebkeywords() {
-        return webkeywords;
-    }
-
-    public void setWebkeywords(String webkeywords) {
-        this.webkeywords = webkeywords;
-    }
-
-    public String getWebfavicons() {
-        return webfavicons;
-    }
-
-    public void setWebfavicons(String webfavicons) {
-        this.webfavicons = webfavicons;
-    }
-
-    public Integer getTheme() {
-        return theme;
-    }
-
-    public void setTheme(Integer theme) {
-        this.theme = theme;
-    }
-
-    public String getWebsubtitle() {
-        return websubtitle;
-    }
-
-    public void setWebsubtitle(String websubtitle) {
-        this.websubtitle = websubtitle;
-    }
-
-    public String getLogo() {
-        return logo;
-    }
-
-    public void setLogo(String logo) {
-        this.logo = logo;
-    }
-
-    public String getAboutinfo() {
-        return aboutinfo;
-    }
-
-    public void setAboutinfo(String aboutinfo) {
-        this.aboutinfo = aboutinfo;
-    }
-}

src/main/java/cn/hellohao/pojo/Images.java

@@ -1,10 +1,11 @@
 package cn.hellohao.pojo;
 
-public class Images {
-    // 默认的时间字符串格式
+import lombok.Data;
 
+@Data
+public class Images {
     //id, imgname, imgurl, userid
-    private Integer id;
+    private Long id;
     private String imgname;
     private String imgurl;
     private Integer userid;
@@ -35,299 +36,12 @@ public class Images {
     private String yyyy;
     private String[] classifuidlist; //类别uid集合
     private String classificationuid; //类别uid集合
-
-    public Images() {
-        super();
-    }
-
-    public Images(String imgurl, String sizes, String abnormal, String updatetime, String username, String md5key, String imguid) {
-        this.imgurl = imgurl;
-        this.sizes = sizes;
-        this.abnormal = abnormal;
-        this.updatetime = updatetime;
-        this.username = username;
-        this.md5key = md5key;
-        this.imguid = imguid;
-    }
-
-    public Images(Integer id, String imgname, String imgurl, Integer userid, String sizes, String abnormal, Integer source,
-                  Integer imgtype, String updatetime, String username, Integer storageType, String starttime, String stoptime,
-                  String explains, String md5key, String notes, String useridlist, String imguid, String albumtitle,
-                  String password, Integer selecttype,Long countNum,Integer monthNum,String yyyy,
-                  String format,String about,Integer great,String[] classifuidlist,String classificationuid,String violation) {
-        this.id = id;
-        this.imgname = imgname;
-        this.imgurl = imgurl;
-        this.userid = userid;
-        this.sizes = sizes;
-        this.abnormal = abnormal;
-        this.source = source;
-        this.imgtype = imgtype;
-        this.updatetime = updatetime;
-        this.username = username;
-        this.storageType = storageType;
-        this.starttime = starttime;
-        this.stoptime = stoptime;
-        this.explains = explains;
-        this.md5key = md5key;
-        this.notes = notes;
-        this.useridlist = useridlist;
-        this.imguid = imguid;
-        this.albumtitle = albumtitle;
-        this.password = password;
-        this.selecttype = selecttype;
-        this.countNum = countNum;
-        this.monthNum = monthNum;
-        this.yyyy = yyyy;
-        this.format = format;
-        this.about = about;
-        this.great = great;
-        this.classifuidlist = classifuidlist;
-        this.classificationuid = classificationuid;
-        this.violation = violation;
-
-    }
-
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
-    public String getImgname() {
-        return imgname;
-    }
-
-    public void setImgname(String imgname) {
-        this.imgname = imgname;
-    }
-
-    public String getImgurl() {
-        return imgurl;
-    }
-
-    public void setImgurl(String imgurl) {
-        this.imgurl = imgurl;
-    }
-
-    public Integer getUserid() {
-        return userid;
-    }
-
-    public void setUserid(Integer userid) {
-        this.userid = userid;
-    }
-
-    public String getSizes() {
-        return sizes;
-    }
-
-    public void setSizes(String sizes) {
-        this.sizes = sizes;
-    }
-
-    public String getAbnormal() {
-        return abnormal;
-    }
-
-    public void setAbnormal(String abnormal) {
-        this.abnormal = abnormal;
-    }
-
-    public Integer getSource() {
-        return source;
-    }
-
-    public void setSource(Integer source) {
-        this.source = source;
-    }
-
-    public Integer getImgtype() {
-        return imgtype;
-    }
-
-    public void setImgtype(Integer imgtype) {
-        this.imgtype = imgtype;
-    }
-
-    public String getUpdatetime() {
-        return updatetime;
-    }
-
-    public void setUpdatetime(String updatetime) {
-        this.updatetime = updatetime;
-    }
-
-    public String getUsername() {
-        return username;
-    }
-
-    public void setUsername(String username) {
-        this.username = username;
-    }
-
-    public Integer getStorageType() {
-        return storageType;
-    }
-
-    public void setStorageType(Integer storageType) {
-        this.storageType = storageType;
-    }
-
-    public String getStarttime() {
-        return starttime;
-    }
-
-    public void setStarttime(String starttime) {
-        this.starttime = starttime;
-    }
-
-    public String getStoptime() {
-        return stoptime;
-    }
-
-    public void setStoptime(String stoptime) {
-        this.stoptime = stoptime;
-    }
-
-    public String getExplains() {
-        return explains;
-    }
-
-    public void setExplains(String explains) {
-        this.explains = explains;
-    }
-
-    public String getMd5key() {
-        return md5key;
-    }
-
-    public void setMd5key(String md5key) {
-        this.md5key = md5key;
-    }
-
-    public String getNotes() {
-        return notes;
-    }
-
-    public void setNotes(String notes) {
-        this.notes = notes;
-    }
-
-    public String getUseridlist() {
-        return useridlist;
-    }
-
-    public void setUseridlist(String useridlist) {
-        this.useridlist = useridlist;
-    }
-
-    public String getImguid() {
-        return imguid;
-    }
-
-    public void setImguid(String imguid) {
-        this.imguid = imguid;
-    }
-
-
-    public String getAlbumtitle() {
-        return albumtitle;
-    }
-
-    public void setAlbumtitle(String albumtitle) {
-        this.albumtitle = albumtitle;
-    }
-
-    public String getPassword() {
-        return password;
-    }
-
-    public void setPassword(String password) {
-        this.password = password;
-    }
-
-    public Integer getSelecttype() {
-        return selecttype;
-    }
-
-    public void setSelecttype(Integer selecttype) {
-        this.selecttype = selecttype;
-    }
-
-    public Long getCountNum() {
-        return countNum;
-    }
-
-    public void setCountNum(Long countNum) {
-        this.countNum = countNum;
-    }
-
-    public Integer getMonthNum() {
-        return monthNum;
-    }
-
-    public void setMonthNum(Integer monthNum) {
-        this.monthNum = monthNum;
-    }
-
-    public String getYyyy() {
-        return yyyy;
-    }
-
-    public void setYyyy(String yyyy) {
-        this.yyyy = yyyy;
-    }
-
-    public String getFormat() {
-        return format;
-    }
-
-    public void setFormat(String format) {
-        this.format = format;
-    }
-
-    public String getAbout() {
-        return about;
-    }
-
-    public void setAbout(String about) {
-        this.about = about;
-    }
-
-    public Integer getGreat() {
-        return great;
-    }
-
-    public void setGreat(Integer great) {
-        this.great = great;
-    }
-
-    public String[] getClassifuidlist() {
-        return classifuidlist;
-    }
-
-    public void setClassifuidlist(String[] classifuidlist ) {
-        this.classifuidlist = classifuidlist;
-    }
-
-    public String getClassificationuid() {
-        return classificationuid;
-    }
-
-    public void setClassificationuid(String classificationuid) {
-        this.classificationuid = classificationuid;
-    }
-
-    public String getViolation() {
-        return violation;
-    }
-
-    public void setViolation(String violation) {
-        this.violation = violation;
-    }
+    private String idname;
+    private Integer isRepeat;//如果没有开启查重的时候他是0，开启为1
+    private String searchname;
+    private String brieflink;
+    private String shortlink;
+    private String order;
 }
 	
 		

src/main/java/cn/hellohao/pojo/Keys.java

@@ -1,94 +1,22 @@
 package cn.hellohao.pojo;
 
+import lombok.Data;
+
+@Data
 public class Keys {
     private Integer id;
     private String AccessKey;
     private String AccessSecret;
     private String Endpoint;
+    private String Region;
     private String Bucketname;
     private String RequestAddress;
     private Integer storageType;
     private String keyname;
+    private String RootPath;//存入的目录
+    private Boolean SysTransmit;
 
-    public Keys() {
-        super();
-    }
-
-    public Keys(Integer id, String accessKey, String accessSecret, String endpoint, String bucketname,
-                String requestAddress, Integer storageType,String keyname) {
-        super();
-        this.id = id;
-        this.AccessKey = accessKey;
-        this.AccessSecret = accessSecret;
-        this.Endpoint = endpoint;
-        this.Bucketname = bucketname;
-        this.RequestAddress = requestAddress;
-        this.storageType = storageType;
-        this.keyname = keyname;
-
-    }
-
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
-    public String getAccessKey() {
-        return AccessKey;
-    }
-
-    public void setAccessKey(String accessKey) {
-        AccessKey = accessKey;
-    }
-
-    public String getAccessSecret() {
-        return AccessSecret;
-    }
-
-    public void setAccessSecret(String accessSecret) {
-        AccessSecret = accessSecret;
-    }
-
-    public String getEndpoint() {
-        return Endpoint;
-    }
-
-    public void setEndpoint(String endpoint) {
-        Endpoint = endpoint;
-    }
-
-    public String getBucketname() {
-        return Bucketname;
-    }
-
-    public void setBucketname(String bucketname) {
-        Bucketname = bucketname;
-    }
-
-    public String getRequestAddress() {
-        return RequestAddress;
-    }
-
-    public void setRequestAddress(String requestAddress) {
-        RequestAddress = requestAddress;
-    }
-
-    public Integer getStorageType() {
-        return storageType;
-    }
-
-    public void setStorageType(Integer storageType) {
-        this.storageType = storageType;
-    }
-
-    public String getKeyname() {
-        return keyname;
-    }
-
-    public void setKeyname(String keyname) {
-        this.keyname = keyname;
+    public Boolean getSysTransmit() {
+        return SysTransmit==null?false:SysTransmit;
     }
 }

src/main/java/cn/hellohao/pojo/Msg.java

@@ -11,16 +11,12 @@ public class Msg implements Serializable {
 
 	private static final long serialVersionUID = 5196249482551119279L;
 
-	//返回码
 	private String code ="200";
 	
-	//提示信息
 	private String info="操作成功";
 	
-	//返回数据
 	private Object data;
 	
-	//异常
 	private String exceptions;
 
 	

src/main/java/cn/hellohao/pojo/User.java

@@ -16,6 +16,7 @@ public class User {
     private  String memory;
     private Integer groupid;
     private String groupname;
+    private String token;
 
     private Long counts;//用户img counts
 
@@ -25,7 +26,7 @@ public class User {
     }
 
     public User(Integer id, String username, String password, String email, String birthder, Integer level, String uid,
-                Integer isok, String memory, Integer groupid,String groupname,Long counts) {
+                Integer isok, String memory, Integer groupid,String groupname,Long counts,String token) {
         this.id = id;
         this.username = username;
         this.password = password;
@@ -38,6 +39,7 @@ public class User {
         this.groupid = groupid;
         this.groupname = groupname;
         this.counts = counts;
+        this.token = token;
     }
 
     public Integer getId() {
@@ -135,4 +137,12 @@ public class User {
     public void setCounts(Long counts) {
         this.counts = counts;
     }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
 }

src/main/java/cn/hellohao/quartz/job/FirstJob.java

@@ -32,9 +32,11 @@ public class FirstJob {
 	@Autowired
 	private USSImageupload ussImageupload;
 	@Autowired
-	private UFileImageupload uFileImageupload;
+	private S3Imageupload s3Imageupload;
 	@Autowired
-	private FTPImageupload ftpImageupload;
+	private WebDAVImageupload webDAVImageupload;
+	@Autowired
+	private FtpServiceImpl ftpService;
 	@Autowired
 	ImgTempService imgTempService;
 	@Autowired
@@ -63,21 +65,23 @@ public class FirstJob {
 				imgService.deleimgForImgUid(images.getImguid());
 				Keys keys = keysService.selectKeys(images.getSource());
 				if(keys.getStorageType()==1){
-					firstJob.nosImageupload.delNOS(keys.getId(),images.getImgname());
+					firstJob.nosImageupload.delNOS(keys.getId(),images);
 				}else if (keys.getStorageType()==2){
-					firstJob.ossImageupload.delOSS(keys.getId(), images.getImgname());
+					firstJob.ossImageupload.delOSS(keys.getId(), images);
 				}else if(keys.getStorageType()==3){
-					firstJob.ussImageupload.delUSS(keys.getId(), images.getImgname());
+					firstJob.ussImageupload.delUSS(keys.getId(), images);
 				}else if(keys.getStorageType()==4){
-					firstJob.kodoImageupload.delKODO(keys.getId(), images.getImgname());
+					firstJob.kodoImageupload.delKODO(keys.getId(), images);
 				}else if(keys.getStorageType()==5){
-					LocUpdateImg.deleteLOCImg(images.getImgname());
+					LocUpdateImg.deleteLOCImg(images);
 				}else if(keys.getStorageType()==6){
-					firstJob.cosImageupload.delCOS(keys.getId(),images.getImgname());
+					firstJob.cosImageupload.delCOS(keys.getId(),images);
 				}else if(keys.getStorageType()==7){
-					firstJob.ftpImageupload.delFTP(keys.getId(), images.getImgname());
+					firstJob.ftpService.delFTP(keys.getId(), images);
 				}else if(keys.getStorageType()==8){
-					firstJob.uFileImageupload.delUFile(keys.getId(), images.getImgname());
+					firstJob.s3Imageupload.deleS3(keys.getId(), images);
+				}else if(keys.getStorageType()==9){
+					firstJob.webDAVImageupload.delWebDAV(keys.getId(), images);
 				}else{
 					System.err.println("未获取到对象存储参数，上传失败。");
 				}

src/main/java/cn/hellohao/service/AlbumService.java

@@ -26,4 +26,6 @@ public interface AlbumService {
     List<Album> selectAlbumURLList(Album album);
 
     Integer selectAlbumCount(Integer userid);
+
+    Integer updateAlbum(Album album);
 }

src/main/java/cn/hellohao/service/AppClientService.java

@@ -0,0 +1,12 @@
+package cn.hellohao.service;
+
+import cn.hellohao.pojo.AppClient;
+import org.springframework.stereotype.Service;
+
+@Service
+public interface AppClientService {
+
+    AppClient getAppClientData( String id);
+
+    Integer editAppClientData(AppClient appClient);
+}

src/main/java/cn/hellohao/service/CodeService.java

@@ -13,12 +13,9 @@ import java.util.List;
  */
 @Service
 public interface CodeService {
-    //查询扩容码
     List<Code> selectCode(String value);
     Code selectCodekey(String code);
-    //添加
     Integer addCode(Code code);
-    //删除扩容码
     Integer deleteCode(String code);
 
 }

src/main/java/cn/hellohao/service/ConfdataService.java

@@ -0,0 +1,10 @@
+package cn.hellohao.service;
+
+import cn.hellohao.pojo.Confdata;
+import org.springframework.stereotype.Service;
+
+@Service
+public interface ConfdataService {
+    Confdata selectConfdata(String key);
+    Integer updateConfdata(Confdata confdata);
+}

src/main/java/cn/hellohao/service/ConfigService.java

@@ -1,10 +0,0 @@
-package cn.hellohao.service;
-
-import cn.hellohao.pojo.Config;
-import org.springframework.stereotype.Service;
-
-@Service
-public interface ConfigService {
-    Config getSourceype();
-    Integer setSourceype(Config config);
-}

src/main/java/cn/hellohao/service/IRedisService.java

@@ -4,14 +4,16 @@ import java.util.Map;
 
 public interface IRedisService {
 
-    // 加入元素
-    void setValue(String key, Map<String, Object> value);
-    // 加入元素
-    void setValue(String key, String value);
-    // 加入元素
-    void setValue(String key, Object value);
-    // 获取元素
-    Object getMapValue(String key);
-    // 获取元素
-    Object getValue(String key);
-}
+  // 加入元素
+  void setValue(String key, Map<String, Object> value);
+  // 加入元素
+  void setValue(String key, String value);
+  // 加入元素
+  void setTimeValue(String key, Object value,Long time);
+  // 获取元素
+  Object getMapValue(String key);
+  // 获取元素
+  Object getValue(String key);
+    // 删除某个值
+  Boolean removeValue(String key);
+}

src/main/java/cn/hellohao/service/ImgService.java

@@ -1,25 +1,30 @@
 package cn.hellohao.service;
 
 
-import java.util.List;
-
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.User;
 import org.apache.ibatis.annotations.Param;
-
-import cn.hellohao.pojo.Images;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
+
 @Service
 public interface ImgService {
     List<Images> selectimg(Images images);
 
-    Integer deleimg(Integer id);
+    Integer insertImgData(Images images);
+
+    Integer deleimg(Long id);
 
     Integer deleimgForImgUid(String imguid);
 
     Integer countimg(Integer userid);
 
-    Images selectByPrimaryKey(Integer id);
+    Images selectByPrimaryKey(Long id);
+
+    Images selectImgByBrieflink(String brieflink);
+
+    Images selectImgByShortlink(String shortlink);
 
     Integer counts(Integer userid);
 
@@ -27,7 +32,7 @@ public interface ImgService {
 
     Integer deleimgname(String imgname);
 
-    Integer deleall(Integer id);
+    Integer deleall(Long id);
 
     List<Images> gettimeimg(String time);
 
@@ -37,7 +42,7 @@ public interface ImgService {
 
     Integer md5Count(Images images);
 
-    List<Images> selectImgUrlByMD5(String md5key);
+    List<Images> selectImgUrlByMD5(Images images);
 
     List<Images> RecentlyUploaded(Integer userid);
 

src/main/java/cn/hellohao/service/ImgTempService.java

@@ -12,6 +12,8 @@ import java.util.List;
 @Service
 public interface ImgTempService {
     List<Images> selectDelImgUidList(String datatime);
+
     Integer delImgAndExp(String imguid);
+
     Integer insertImgExp(ImgTemp imgDataExp);
 }

src/main/java/cn/hellohao/service/KeysService.java

@@ -9,11 +9,13 @@ import java.util.List;
 
 @Service
 public interface KeysService {
-    //查询密钥
     Keys selectKeys(Integer id);
+
     List<Keys> getStorageName();
+
     List<Keys> getStorage();
-    //修改key
+
     Msg updateKey(Keys key);
+
     List<Keys> getKeys();
 }

src/main/java/cn/hellohao/service/SysConfigService.java

@@ -11,5 +11,6 @@ import org.springframework.stereotype.Service;
 @Service
 public interface SysConfigService {
     SysConfig getstate();
+
     Integer setstate(SysConfig sysConfig);
 }

src/main/java/cn/hellohao/service/UploadConfigService.java

@@ -5,6 +5,8 @@ import org.springframework.stereotype.Service;
 
 @Service
 public interface UploadConfigService {
+
     UploadConfig getUpdateConfig();
+
     Integer setUpdateConfig(UploadConfig updateConfig);
 }

src/main/java/cn/hellohao/service/UserGroupService.java

@@ -10,10 +10,17 @@ import org.springframework.stereotype.Service;
  */
 @Service
 public interface UserGroupService {
+
     UserGroup useridgetusergroup(Integer userid);
+
     UserGroup idgetusergroup(Integer id);
+
     Integer addusergroup(UserGroup userGroup);
+
     Integer updateusergroup(UserGroup userGroup);
+
     Integer updateusergroupdefault(Integer groupid);
+
     Integer deleusergroup(Integer userid);
+
 }

src/main/java/cn/hellohao/service/UserService.java

@@ -1,32 +1,24 @@
 package cn.hellohao.service;
 
-import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.User;
-import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
 
 @Service
 public interface UserService {
-    //注册
     Integer register(User user);
 
-    //登录
     Integer login(String email, String password,String uid);
 
-    //获取用户信息
+    User loginByToken (String token);
+
     User getUsers(User user);
 
-    //插入图片
-    Integer insertimg(Images img);
-
-    //修改资料
     Integer change(User user);
 
     Integer changeUser(User user);
 
-    //检查用户名是否重复
     Integer checkUsername(String username);
 
     Integer getUserTotal();
@@ -35,7 +27,6 @@ public interface UserService {
 
     Integer deleuser(Integer id);
 
-    //查询用户名或者邮箱是否存在
     Integer countusername(String username);
 
     Integer countmail(String email);
@@ -43,8 +34,12 @@ public interface UserService {
     Integer uiduser(String uid);
 
     User getUsersMail(String uid);
+
     Integer setisok (User user);
+
     Integer setmemory(User user);
+
     User getUsersid(Integer id);
+
     List<User> getuserlistforgroupid(Integer groupid);
 }

src/main/java/cn/hellohao/service/impl/AlbumServiceImpl.java

@@ -1,23 +1,19 @@
 package cn.hellohao.service.impl;
 
 import cn.hellohao.dao.AlbumMapper;
-import cn.hellohao.dao.ConfigMapper;
 import cn.hellohao.dao.ImgAndAlbumMapper;
 import cn.hellohao.dao.ImgMapper;
 import cn.hellohao.exception.CodeException;
 import cn.hellohao.pojo.Album;
 import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.ImgAndAlbum;
-import cn.hellohao.pojo.Msg;
 import cn.hellohao.service.AlbumService;
 import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
-import java.util.UUID;
 
 /**
  * @author Hellohao
@@ -26,86 +22,85 @@ import java.util.UUID;
  */
 @Service
 public class AlbumServiceImpl implements AlbumService {
-    @Autowired
-    AlbumMapper albumMapper;
-    @Autowired
-    ImgAndAlbumMapper andAlbumMapper;
-    @Autowired
-    ConfigMapper configMapper;
-    @Autowired
-    ImgMapper imgMapper;
+  @Autowired AlbumMapper albumMapper;
+  @Autowired ImgAndAlbumMapper andAlbumMapper;
+  @Autowired ImgMapper imgMapper;
 
-
-    @Override
-    public JSONArray getAlbumList(JSONArray array) {
-        JSONArray jsonArray = new JSONArray();
-        for (int i = 0; i < array.size(); i++) {
-            Images images = new Images();
-            images.setImguid(array.getString(i));
-            jsonArray.add(imgMapper.selectimg(images).get(0));
-        }
-        return jsonArray;
+  @Override
+  public JSONArray getAlbumList(JSONArray array) {
+    JSONArray jsonArray = new JSONArray();
+    for (int i = 0; i < array.size(); i++) {
+      Images images = new Images();
+      images.setImguid(array.getString(i));
+      jsonArray.add(imgMapper.selectimg(images).get(0));
     }
+    return jsonArray;
+  }
 
-    @Override
-    public Album selectAlbum(Album album) {
-        return albumMapper.selectAlbum(album);
-    }
+  @Override
+  public Album selectAlbum(Album album) {
+    return albumMapper.selectAlbum(album);
+  }
 
-    @Override
-    public Integer addAlbum(Album album) {
-        return albumMapper.addAlbum(album);
-    }
+  @Override
+  public Integer addAlbum(Album album) {
+    return albumMapper.addAlbum(album);
+  }
 
-    @Transactional
-    public Integer addAlbumForImgAndAlbumMapper(ImgAndAlbum imgAndAlbum) {
-        Integer tem = 0;
-        Integer r2 = andAlbumMapper.addImgAndAlbum(imgAndAlbum);
-        if(r2>0){
-            tem = 1;
-        }else{
-            throw new CodeException("插入画廊数据失败，回滚");
-        }
-        return tem;
+  @Transactional
+  public Integer addAlbumForImgAndAlbumMapper(ImgAndAlbum imgAndAlbum) {
+    Integer tem = 0;
+    Integer r2 = andAlbumMapper.addImgAndAlbum(imgAndAlbum);
+    if (r2 > 0) {
+      tem = 1;
+    } else {
+      throw new CodeException("插入画廊数据失败，回滚");
     }
+    return tem;
+  }
 
-    @Override
-    public Integer deleteAlbum(String albumkey) {
-        return albumMapper.deleteAlbum(albumkey);
-    }
+  @Override
+  public Integer deleteAlbum(String albumkey) {
+    return albumMapper.deleteAlbum(albumkey);
+  }
 
-    @Override
-    public List<Album> selectAlbumURLList(Album album) {
-        return albumMapper.selectAlbumURLList(album);
-    }
+  @Override
+  public List<Album> selectAlbumURLList(Album album) {
+    return albumMapper.selectAlbumURLList(album);
+  }
 
-    @Override
-    public Integer selectAlbumCount(Integer userid) {
-        return albumMapper.selectAlbumCount(userid);
-    }
+  @Override
+  public Integer selectAlbumCount(Integer userid) {
+    return albumMapper.selectAlbumCount(userid);
+  }
 
-    @Transactional
-    public Integer delete(String albumkey) {
-        Integer ret1 = albumMapper.deleteAlbum(albumkey);
-        if(ret1>0){
-            ret1 = andAlbumMapper.deleteImgAndAlbumForKey(albumkey);
-        }else{
-            throw new CodeException("删除画廊失败。");
-        }
-        return ret1;
-    }
+  @Override
+  public Integer updateAlbum(Album album) {
+    return albumMapper.updateAlbum(album);
+  }
 
-    @Transactional
-    public Integer deleteAll(String[] albumkeyArr) {
-        Integer ret1 = 0 ;
-        for (String s : albumkeyArr) {
-            ret1 = albumMapper.deleteAlbum(s);
-            if(ret1>0){
-                ret1 = andAlbumMapper.deleteImgAndAlbumForKey(s);
-            }else{
-                throw new CodeException("删除画廊失败。");
-            }
-        }
-        return ret1;
+  @Transactional
+  public Integer delete(String albumkey) {
+    Integer ret1 = albumMapper.deleteAlbum(albumkey);
+    if (ret1 > 0) {
+      ret1 = andAlbumMapper.deleteImgAndAlbumForKey(albumkey);
+    } else {
+      throw new CodeException("删除画廊失败。");
     }
+    return ret1;
+  }
+
+  @Transactional
+  public Integer deleteAll(String[] albumkeyArr) {
+    Integer ret1 = 0;
+    for (String s : albumkeyArr) {
+      ret1 = albumMapper.deleteAlbum(s);
+      if (ret1 > 0) {
+        ret1 = andAlbumMapper.deleteImgAndAlbumForKey(s);
+      } else {
+        throw new CodeException("删除画廊失败。");
+      }
+    }
+    return ret1;
+  }
 }

src/main/java/cn/hellohao/service/impl/AppClientServiceImpl.java

@@ -0,0 +1,25 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.dao.AppClientMapper;
+import cn.hellohao.pojo.AppClient;
+import cn.hellohao.service.AppClientService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AppClientServiceImpl implements AppClientService {
+
+    @Autowired
+    AppClientMapper appClientMapper;
+
+
+    @Override
+    public AppClient getAppClientData(String id) {
+        return appClientMapper.getAppClientData(id);
+    }
+
+    @Override
+    public Integer editAppClientData(AppClient appClient) {
+        return appClientMapper.editAppClientData(appClient);
+    }
+}

src/main/java/cn/hellohao/service/impl/COSImageupload.java

@@ -1,51 +1,51 @@
 package cn.hellohao.service.impl;
 
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.Keys;
 import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
-import cn.hellohao.utils.*;
-import com.netease.cloud.auth.BasicCredentials;
-import com.netease.cloud.auth.Credentials;
-import com.netease.cloud.services.nos.NosClient;
-import com.netease.cloud.services.nos.model.ObjectMetadata;
-import com.netease.cloud.services.nos.transfer.TransferManager;
 import com.qcloud.cos.COSClient;
 import com.qcloud.cos.ClientConfig;
 import com.qcloud.cos.auth.BasicCOSCredentials;
 import com.qcloud.cos.auth.COSCredentials;
 import com.qcloud.cos.exception.CosClientException;
 import com.qcloud.cos.exception.CosServiceException;
-import com.qcloud.cos.model.*;
+import com.qcloud.cos.model.ListObjectsRequest;
+import com.qcloud.cos.model.ObjectListing;
+import com.qcloud.cos.model.PutObjectRequest;
+import com.qcloud.cos.model.PutObjectResult;
 import com.qcloud.cos.region.Region;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
 import java.io.FileInputStream;
-import java.util.*;
+import java.util.Map;
 
 @Service
 public class COSImageupload {
+    private static Logger logger = LoggerFactory.getLogger(COSImageupload.class);
     static COSClient cosClient;
     static Keys key;
 
-    public ReturnImage ImageuploadCOS(Map<String, File> fileMap, String username,Integer keyID) {
+    public ReturnImage ImageuploadCOS(
+            Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
         ReturnImage returnImage = new ReturnImage();
         File file = null;
-        Map<ReturnImage, Integer> ImgUrl = new HashMap<>();
+        FileInputStream stream = null;
         try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
                 file = entry.getValue();
+                stream = new FileInputStream(file);
                 try {
                     String bucketName = key.getBucketname();
-                    String userkey =username + "/" + ShortUID + "." + entry.getKey();
-                    PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, userkey, file);
+                    String userkey = username + "/" + ShortUIDName + "." + prefix;
+                    PutObjectRequest putObjectRequest =
+                            new PutObjectRequest(bucketName, userkey, stream,null);
                     PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest);
-                    returnImage.setImgname(userkey);
-                    returnImage.setImgurl(key.getRequestAddress() + "/" + userkey);
-                    returnImage.setImgSize(entry.getValue().length());
-                    returnImage.setCode("200");
                 } catch (CosServiceException serverException) {
                     returnImage.setCode("400");
                     serverException.printStackTrace();
@@ -53,58 +53,57 @@ public class COSImageupload {
                     returnImage.setCode("400");
                     clientException.printStackTrace();
                 }
+                try {if(stream!=null){stream.close();}} catch (Exception ex) { }
             }
-        }catch(Exception e){
-            e.printStackTrace();
+            returnImage.setCode("200");
+        } catch (Exception e) {
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+            logger.error("COS协议上传时发生异常：",e);
             returnImage.setCode("500");
         }
         return returnImage;
     }
 
-
     public static Integer Initialize(Keys k) {
         int ret = -1;
-        if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null
-                && k.getBucketname()!=null && k.getRequestAddress()!=null ) {
-            if (!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("")
-                    && !k.getBucketname().equals("") && !k.getRequestAddress().equals("")) {
-                String secretId = k.getAccessKey();
-                String secretKey = k.getAccessSecret();
-                COSCredentials cred = new BasicCOSCredentials(secretId, secretKey);
-                Region region = new Region(k.getEndpoint());
-                ClientConfig clientConfig = new ClientConfig(region);
-                COSClient cos = new COSClient(cred, clientConfig);
-                ListObjectsRequest listObjectsRequest = new ListObjectsRequest();
-                listObjectsRequest.setBucketName(k.getBucketname());
-                listObjectsRequest.setDelimiter("/");
-                listObjectsRequest.setMaxKeys(1);
-                ObjectListing objectListing = null;
-                try {
-                    objectListing = cos.listObjects(listObjectsRequest);
-                    ret = 1;
-                    cosClient = cos;
-                    key = k;
-                } catch (Exception e) {
-                    System.out.println("COS Object Is null");
-                    ret = -1;
-                }
-            }
+        if (StringUtils.isBlank(k.getAccessKey())
+                || StringUtils.isBlank(k.getAccessSecret())
+                || StringUtils.isBlank(k.getEndpoint())
+                || StringUtils.isBlank(k.getBucketname())
+                || StringUtils.isBlank(k.getRequestAddress())) {
+            return -1;
+        }
+        String secretId = k.getAccessKey();
+        String secretKey = k.getAccessSecret();
+        COSCredentials cred = new BasicCOSCredentials(secretId, secretKey);
+        Region region = new Region(k.getEndpoint());
+        ClientConfig clientConfig = new ClientConfig(region);
+        COSClient cos = new COSClient(cred, clientConfig);
+        ListObjectsRequest listObjectsRequest = new ListObjectsRequest();
+        listObjectsRequest.setBucketName(k.getBucketname());
+        listObjectsRequest.setDelimiter("/");
+        listObjectsRequest.setMaxKeys(1);
+        ObjectListing objectListing = null;
+        try {
+            objectListing = cos.listObjects(listObjectsRequest);
+            ret = 1;
+            cosClient = cos;
+            key = k;
+        } catch (Exception e) {
+            System.out.println("COS Object Is null");
+            ret = -1;
         }
         return ret;
     }
 
-    public Boolean delCOS(Integer keyID, String fileName) {
+    public Boolean delCOS(Integer keyID, Images images) {
         boolean b = true;
         try {
-            cosClient.deleteObject(key.getBucketname(), fileName);
+            cosClient.deleteObject(key.getBucketname(), images.getImgname());
         } catch (Exception e) {
             e.printStackTrace();
             b = false;
         }
-        return b ;
+        return b;
     }
-
-
-
-
 }

src/main/java/cn/hellohao/service/impl/ClientService.java

@@ -2,21 +2,17 @@ package cn.hellohao.service.impl;
 
 import cn.hellohao.dao.*;
 import cn.hellohao.pojo.*;
-import cn.hellohao.pojo.vo.PageResultBean;
-import cn.hellohao.service.ImgAndAlbumService;
+import cn.hellohao.service.ConfdataService;
+import cn.hellohao.service.ImgTempService;
 import cn.hellohao.service.SysConfigService;
 import cn.hellohao.utils.*;
-import cn.hutool.core.util.CharsetUtil;
-import cn.hutool.http.HttpUtil;
-import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
-import com.baidu.aip.contentcensor.AipContentCensor;
-import com.baidu.aip.contentcensor.EImgType;
-import com.github.pagehelper.PageHelper;
-import com.github.pagehelper.PageInfo;
-import net.coobird.thumbnailator.filters.Watermark;
 import org.apache.commons.codec.digest.DigestUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -33,48 +29,28 @@ import java.util.*;
  */
 @Service
 public class ClientService {
+    private static Logger logger = LoggerFactory.getLogger(ClientService.class);
+    @Autowired private ConfdataService confdataService;
+    @Autowired private SysConfigService sysConfigService;
+    @Autowired private UserMapper userMapper;
+    @Autowired private KeysMapper keysMapper;
+    @Autowired private UploadConfigMapper uploadConfigMapper;
+    @Autowired private ImgServiceImpl imgServiceImpl;
+    @Autowired private ImgTempService imgTempService;
+    @Autowired private GetSource getSource;
+    @Autowired private ImgViolationJudgeServiceImpl imgViolationJudgeService;
 
-    @Autowired
-    private ImgAndAlbumService imgAndAlbumService;
-    @Autowired
-    private NOSImageupload nOSImageupload;
-    @Autowired
-    private OSSImageupload ossImageupload;
-    @Autowired
-    private USSImageupload ussImageupload;
-    @Autowired
-    private KODOImageupload kodoImageupload;
-    @Autowired
-    private COSImageupload cosImageupload;
-    @Autowired
-    private SysConfigService sysConfigService;
-    @Autowired
-    private FTPImageupload ftpImageupload;
-    @Autowired
-    private UFileImageupload uFileImageupload;
-    @Autowired
-    private UserMapper userMapper;
-    @Autowired
-    private KeysMapper keysMapper;
-    @Autowired
-    private ConfigMapper configMapper;
-    @Autowired
-    private UploadConfigMapper uploadConfigMapper;
-    @Autowired
-    private ImgMapper imgMapper;
-    @Autowired
-    ImgreviewMapper imgreviewMapper;
-
-
-    public Msg uploadImg(HttpServletRequest request, MultipartFile multipartFile, String email, String pass ){
+    public Msg uploadImg(
+            HttpServletRequest request, MultipartFile multipartFile, String email, String pass,Integer setday) {
         Msg msg = new Msg();
         try {
+            Confdata dataJson = confdataService.selectConfdata("config");
+            JSONObject confdata = JSONObject.parseObject(dataJson.getJsondata());
+            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            String imageFileName = "未命名图像";
             Integer sourceKeyId = 0;
-            FileInputStream fis = null;
             String md5key = null;
-            Integer setday = 0;
             JSONObject jsonObject = new JSONObject();
-            Config config = configMapper.getSourceype();
             String userip = GetIPS.getIpAddr(request);
             UploadConfig uploadConfig = uploadConfigMapper.getUpdateConfig();
             if (uploadConfig.getApi() != 1) {
@@ -82,34 +58,72 @@ public class ClientService {
                 msg.setInfo("管理员关闭了API接口");
                 return msg;
             }
+            imageFileName = multipartFile.getOriginalFilename();
             File file = SetFiles.changeFile_new(multipartFile);
+            FileInputStream stream = new FileInputStream(file);
             User u2 = new User();
             if (!file.exists() || email == null || pass == null) {
                 msg.setCode("4005");
                 msg.setInfo("必要参数不能为空");
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg;
             }
+            if (uploadConfig.getBlacklist() != null) {
+                String[] iparr = uploadConfig.getBlacklist().split(";");
+                for (String s : iparr) {
+                    if (s.equals(userip)) {
+                        msg.setCode("4010");
+                        msg.setInfo("你暂时不能上传");
+                        try {
+                            if(stream!=null){stream.close();}
+                            file.delete();
+                        } catch (Exception e) { }
+                        return msg;
+                    }
+                }
+            }
             u2.setEmail(email);
-            u2.setPassword(Base64Encryption.encryptBASE64(pass.getBytes()));
+            u2.setPassword(Base64.getEncoder().encodeToString(pass.getBytes()));
             User u = userMapper.getUsers(u2);
-            //判断用户的账号密码是否存在（正确）
             if (null == u || u.getIsok() != 1) {
                 msg.setCode("4006");
                 msg.setInfo("用户信息不正确,账号异常");
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg;
             }
             String imguid = UUID.randomUUID().toString().replace("-", "");
-            //判断上传前的一些用户限制信息
             Msg msg1 = updateImgCheck(u, uploadConfig);
             if (!msg1.getCode().equals("300")) {
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg1;
             }
+            JSONObject updateJson = JSONObject.parseObject(msg1.getData().toString());
+            final JSONObject groupJson = updateJson.getJSONObject("group");
+            final Group group = groupJson.toJavaObject(Group.class);
+            Long memory = updateJson.getLong("memory");
+            Long UsedTotleMemory = updateJson.getLong("UsedTotleMemory");
+            Long TotleMemory = updateJson.getLong("TotleMemory");
+            String updatePath = updateJson.getString("updatePath");
+
             sourceKeyId = group.getKeyid();
             Keys key = keysMapper.selectKeys(sourceKeyId);
             Long tmp = (memory == -1 ? -2 : UsedTotleMemory);
             if (tmp >= memory) {
                 msg.setCode("4007");
                 msg.setInfo(u == null ? "游客空间已用尽" : "您的可用空间不足");
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg;
             }
             if (file.length() > TotleMemory) {
@@ -117,213 +131,177 @@ public class ClientService {
                 System.err.println("最大限制：" + TotleMemory);
                 msg.setCode("4008");
                 msg.setInfo("图像超出系统限制大小");
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg;
             }
-            try {
-                fis = new FileInputStream(file);
-                md5key = DigestUtils.md5Hex(fis);
-            } catch (Exception e) {
-                e.printStackTrace();
-                System.out.println("未获取到图片的MD5,成成UUID");
-            }
-            Msg fileMiME = TypeDict.FileMiME(file);
+            md5key = DigestUtils.md5Hex(stream);
+//            FileInputStream fis = null;
+//            try {
+//                fis = new FileInputStream(file);
+//                md5key = DigestUtils.md5Hex(fis);
+//            } catch (Exception e) {
+//                logger.error("未获取到图片的MD5,成成UUID异常：",e);
+//            }finally{
+//                try {
+//                    if (null != fis)
+//                        fis.close();
+//                } catch (Exception e) {
+//                    logger.error("ClientService-110异常",e);
+//                }
+//            }
+            Msg fileMiME = TypeDict.FileMiME(stream);
             if (!fileMiME.getCode().equals("200")) {
-                //非图像文本
                 msg.setCode("4009");
                 msg.setInfo(fileMiME.getInfo());
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg;
             }
             if (md5key == null || md5key.equals("")) {
                 md5key = UUID.randomUUID().toString().replace("-", "");
             }
             String prefix = file.getName().substring(file.getName().lastIndexOf(".") + 1);
-            if (uploadConfig.getBlacklist() != null) {
-                String[] iparr = uploadConfig.getBlacklist().split(";");
-                for (String s : iparr) {
-                    if (s.equals(userip)) {
-                        msg.setCode("4010");
-                        msg.setInfo("你暂时不能上传");
-                        return msg;
-                    }
-                }
-            }
-            //判断图片是否存在
-            if(Integer.valueOf(sysConfigService.getstate().getCheckduplicate())==1) {
-                Images imaOBJ = new Images();
-                imaOBJ.setMd5key(md5key);
-                imaOBJ.setUserid(u.getId());
-                if (imgMapper.md5Count(imaOBJ) > 0) {
-                    List<Images> images = imgMapper.selectImgUrlByMD5(md5key);
-                    jsonObject.put("url", images.get(0).getImgurl());
-                    jsonObject.put("name", file.getName());
-                    jsonObject.put("size", images.get(0).getSizes());
-                    msg.setData(jsonObject);
-                    return msg;
-                }
-            }
-            Map<String, File> map = new HashMap<>();
-            String fileName = file.getName();
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+
+            Images imgObj = new Images();
+            String imgnameEd = null;
+            Map<Map<String, String>, File> map = new HashMap<>();
+            String shortUuid_y = SetText.getShortUuid();
+            String shortUuid_s = SetText.getShortUuid();
             if (file.exists()) {
-                map.put(prefix, file);
+                Map<String, String> m1 = new HashMap<>();
+                m1.put("prefix", prefix);
+                m1.put("name", shortUuid_y);
+                map.put(m1, file);
+                imgnameEd = updatePath + "/" + shortUuid_y + "." + prefix;
+                imgObj.setImgname(imgnameEd);
+                if (key.getStorageType().equals(5)) {
+                    imgObj.setImgurl(confdata.getString("domain") + "/ota/" + imgnameEd);
+                } else if(key.getStorageType().equals(9) && key.getSysTransmit()){
+                    imgObj.setImgurl(confdata.getString("domain") + "/w/" + shortUuid_y);
+                }else {
+                    imgObj.setImgurl(key.getRequestAddress() + "/" + imgnameEd);
+                }
+                imgObj.setSizes(Long.toString(file.length()));
+            }else{
+                msg.setInfo("未获取到指定图像:110503");
+                msg.setCode("110503");
+                file.delete();
+                return msg;
+            }
+            imgObj.setUpdatetime(df.format(new Date()));
+            imgObj.setSource(key.getId());
+            imgObj.setUserid(u == null ? 0 : u.getId());
+            if (setday == 1 || setday == 3 || setday == 7 || setday == 30) {
+                imgObj.setImgtype(1);
+                ImgTemp imgDataExp = new ImgTemp();
+                imgDataExp.setDeltime(UploadServicel.plusDay(setday));
+                imgDataExp.setImguid(imguid);
+                imgTempService.insertImgExp(imgDataExp);
+            } else {
+                imgObj.setImgtype(0);
+            }
+            imgObj.setAbnormal(userip);
+            imgObj.setMd5key(md5key);
+            imgObj.setImguid(imguid);
+            imgObj.setFormat(fileMiME.getData().toString());
+            imgObj.setShortlink(shortUuid_y);
+            imgObj.setBrieflink(shortUuid_s);
+            imgObj.setIdname(imageFileName);
+            Msg insertRet = imgServiceImpl.insertImgDataForCheck(imgObj,u,confdata,file.getName());
+            if (insertRet.getCode().equals("000")) {
+                file.delete();
+                return insertRet;
             }
             long stime = System.currentTimeMillis();
-            Map<ReturnImage, Integer> m = null;
-            ReturnImage returnImage = GetSource.storageSource(key.getStorageType(), map, updatePath,  key.getId());
-            Images img = new Images();
-            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            ReturnImage returnImage = getSource.storageSource(key.getStorageType(), map, updatePath, key.getId());
             if (returnImage.getCode().equals("200")) {
-                String imgurl = returnImage.getImgurl();
-                Long imgsize = returnImage.getImgSize();
-                String imgname = returnImage.getImgname();
-                img.setImgurl(imgurl);
-                img.setUpdatetime(df.format(new Date()));
-                img.setSource(key.getId());
-                img.setUserid(u == null ? 0 : u.getId());
-                img.setSizes(imgsize.toString());
-                if (uploadConfig.getUrltype() == 2) {
-                    img.setImgname(imgname);
-                } else {
-                    img.setImgname(SetText.getSubString(imgname, key.getRequestAddress() + "/", ""));
-                }
-                img.setImgtype(setday > 0 ? 1 : 0);
-                img.setAbnormal(userip);
-                img.setMd5key(md5key);
-                img.setImguid(imguid);
-                img.setFormat(fileMiME.getData().toString());
-                userMapper.insertimg(img);
                 long etime = System.currentTimeMillis();
-                Print.Normal("上传图片所用总时长：" + String.valueOf(etime - stime) + "ms");
-                jsonObject.put("url", img.getImgurl());
-                jsonObject.put("name", imgname);
-                jsonObject.put("size", img.getSizes());
-                //启动鉴黄线程
-                new Thread(() -> {
-                    LegalImageCheck(img);
-                }).start();
+                logger.info("上传图片所用总时长：" + String.valueOf(etime - stime) + "ms");
+                jsonObject.put("url", imgObj.getImgurl());
+                jsonObject.put("name", imgObj.getImgname());
+                jsonObject.put("size", imgObj.getSizes());
+                imgViolationJudgeService.LegalImageCheck(imgObj,key);
             } else {
+                imgServiceImpl.deleimgForImgUid(imgObj.getImguid());
                 msg.setCode("5001");
                 msg.setInfo("上传服务内部错误");
+                file.delete();
                 return msg;
             }
             file.delete();
             msg.setData(jsonObject);
-//            新代码结束=========
             return msg;
-        }catch (Exception e){
-            e.printStackTrace();
+        } catch (Exception e) {
             msg.setCode("5001");
             msg.setInfo("Error for server:500");
+            logger.error("ClientService：Error for server-202行异常",e);
             return msg;
         }
-
     }
 
+//    public static Group group;
+//    public static Long memory;
+//    public static Long TotleMemory;
+//    public static Long UsedTotleMemory;
+//    public static String updatePath = "tourist";
 
-    public static Group group; //上传用户或游客的所属分组
-    public static Long memory;//上传用户或者游客的分配容量 memory
-    public static Long TotleMemory;//用户或者游客下可使用的总容量 //maxsize
-    public static Long UsedTotleMemory;//用户或者游客已经用掉的总容量 //usermemory
-    public static String updatePath="tourist";
-
-    //判断用户 或 游客 当前上传图片的一系列校验
-    private Msg updateImgCheck(User user, UploadConfig uploadConfig){
-        final Msg msg = new Msg();
-        java.text.DateFormat dateFormat = null;
+    private Msg updateImgCheck(User user, UploadConfig uploadConfig) {
+        Msg msg = new Msg();
+        JSONObject jsonObject = new JSONObject();
+        String updatePath = "tourist";
         try {
-            dateFormat = new SimpleDateFormat("yyyy/MM/dd");
+            Group group = GetCurrentSource.GetSource(user == null ? null : user.getId());
+            jsonObject.put("group",group);
             if (user == null) {
-                //用户没有登陆，值判断游客能不能上传即可
-                if(uploadConfig.getIsupdate()!=1){
+                if (uploadConfig.getIsupdate() != 1) {
                     msg.setCode("1000");
                     msg.setInfo("系统已禁用游客上传");
                     return msg;
                 }
-                group = GetCurrentSource.GetSource(null);
-                memory = Long.valueOf(uploadConfig.getVisitormemory());//单位 B 游客设置总量
-                TotleMemory = Long.valueOf(uploadConfig.getFilesizetourists());//单位 B  游客单文件大小
-                UsedTotleMemory = imgMapper.getusermemory(0)==null?0L : imgMapper.getusermemory(0);//单位 B
+                Long memory = Long.valueOf(uploadConfig.getVisitormemory()); // 单位 B 游客设置总量
+                Long TotleMemory = Long.valueOf(uploadConfig.getFilesizetourists()); // 单位 B  游客单文件大小
+                Long UsedTotleMemory =
+                        imgServiceImpl.getusermemory(0) == null
+                                ? 0L
+                                : imgServiceImpl.getusermemory(0); // 单位 B
+                jsonObject.put("memory",memory);
+                jsonObject.put("TotleMemory",TotleMemory);
+                jsonObject.put("UsedTotleMemory",UsedTotleMemory);
             } else {
-                //判断用户能不能上传
-                if(uploadConfig.getUserclose()!=1){
+                // 判断用户能不能上传
+                if (uploadConfig.getUserclose() != 1) {
                     msg.setCode("1001");
                     msg.setInfo("系统已禁用上传功能");
                     return msg;
                 }
                 updatePath = user.getUsername();
-                group= GetCurrentSource.GetSource(user.getId());
-                memory = Long.valueOf(user.getMemory())*1024*1024;//单位 B
-                TotleMemory = Long.valueOf(uploadConfig.getFilesizeuser());//单位 B
-                UsedTotleMemory = imgMapper.getusermemory(user.getId())==null?0L:imgMapper.getusermemory(user.getId());//单位 B
+                Long memory = Long.valueOf(user.getMemory()); // 单位 B
+                Long TotleMemory = Long.valueOf(uploadConfig.getFilesizeuser()); // 单位 B
+                Long UsedTotleMemory =
+                        imgServiceImpl.getusermemory(user.getId()) == null
+                                ? 0L
+                                : imgServiceImpl.getusermemory(user.getId()); // 单位 B
+                jsonObject.put("memory",memory);
+                jsonObject.put("TotleMemory",TotleMemory);
+                jsonObject.put("UsedTotleMemory",UsedTotleMemory);
             }
-            //判断上传的图片目录结构类型
+            // 判断上传的图片目录结构类型
             if (uploadConfig.getUrltype() == 2) {
-                updatePath = dateFormat.format(new Date());
+                jsonObject.put("updatePath",updatePath);
+                msg.setData(jsonObject);
             }
             msg.setCode("300");
         } catch (Exception e) {
-            e.printStackTrace();
+            logger.error("ClientService-异常",e);
             msg.setCode("500");
         }
         return msg;
     }
 
-    //图片鉴黄
-
-    private synchronized void LegalImageCheck(Images images){
-        System.out.println("非法图像鉴别进程启动");
-        Imgreview imgreview = null;
-        try {
-            imgreview = imgreviewMapper.selectByusing(1);
-        } catch (Exception e) {
-            Print.warning("获取鉴别程序的时候发生错误");
-            e.printStackTrace();
-        }
-        LegalImageCheckForBaiDu(imgreview,images);
-    }
-
-    private void LegalImageCheckForBaiDu(Imgreview imgreview,Images images){
-        if(imgreview.getUsing()==1){
-            try {
-                AipContentCensor client = new AipContentCensor(imgreview.getAppId(), imgreview.getApiKey(), imgreview.getSecretKey());
-                client.setConnectionTimeoutInMillis(5000);
-                client.setSocketTimeoutInMillis(30000);
-                org.json.JSONObject res = client.antiPorn(images.getImgurl());
-                res = client.imageCensorUserDefined(images.getImgurl(), EImgType.URL, null);
-                com.alibaba.fastjson.JSONArray jsonArray = JSON.parseArray("[" + res.toString() + "]");
-                for (Object o : jsonArray) {
-                    JSONObject jsonObject = (JSONObject) o;
-                    com.alibaba.fastjson.JSONArray data = jsonObject.getJSONArray("data");
-                    Integer conclusionType = jsonObject.getInteger("conclusionType");
-                    if(conclusionType!=null){
-                        if (conclusionType == 2) {
-                            for (Object datum : data) {
-                                JSONObject imgdata = (JSONObject) datum;
-                                if (imgdata.getInteger("type") == 1) {
-                                    Images img = new Images();
-                                    img.setImgname(images.getImgname());
-                                    img.setViolation("1[1]");//数字是鉴别平台的主键ID，括号是非法的类型，参考上面的注释
-                                    imgMapper.setImg(img);
-                                    Imgreview imgv = new Imgreview();
-                                    imgv.setId(1);
-                                    Integer count = imgreview.getCount();
-                                    System.out.println("违法图片总数：" + count);
-                                    imgv.setCount(count + 1);
-                                    imgreviewMapper.updateByPrimaryKeySelective(imgv);
-                                    System.err.println("存在非法图片，进行处理操作");
-                                }
-                            }
-                        }
-                    }
-                }
-
-            }catch (Exception e){
-                System.out.println("图像鉴黄线程执行过程中出现异常");
-                e.printStackTrace();
-
-            }
-
-        }
-    }
-
-
 }

src/main/java/cn/hellohao/service/impl/CodeServiceImpl.java

@@ -19,7 +19,6 @@ public class CodeServiceImpl implements CodeService {
     @Autowired
     private CodeMapper codeMapper;
 
-
     @Override
     public List<Code> selectCode(String value) {
         return codeMapper.selectCode(value);

src/main/java/cn/hellohao/service/impl/ConfdataServiceImpl.java

@@ -0,0 +1,23 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.dao.ConfdataMapper;
+import cn.hellohao.pojo.Confdata;
+import cn.hellohao.service.ConfdataService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class ConfdataServiceImpl implements ConfdataService {
+    @Autowired
+    private ConfdataMapper confdataMapper;
+
+    @Override
+    public Confdata selectConfdata(String key) {
+        return confdataMapper.selectConfdata(key);
+    }
+
+    @Override
+    public Integer updateConfdata(Confdata confdata) {
+        return confdataMapper.updateConfdata(confdata);
+    }
+}

src/main/java/cn/hellohao/service/impl/ConfigServiceImpl.java

@@ -1,23 +0,0 @@
-package cn.hellohao.service.impl;
-
-import cn.hellohao.dao.ConfigMapper;
-import cn.hellohao.pojo.Config;
-import cn.hellohao.pojo.Images;
-import cn.hellohao.service.ConfigService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-@Service
-public class ConfigServiceImpl implements ConfigService {
-    @Autowired
-    private ConfigMapper configMapper;
-    @Override
-    public Config getSourceype() {
-        return configMapper.getSourceype();
-    }
-
-    @Override
-    public Integer setSourceype(Config config) {
-        return configMapper.setSourceype(config);
-    }
-}

src/main/java/cn/hellohao/service/impl/EmailServiceImpl.java

@@ -10,6 +10,7 @@ import org.springframework.stereotype.Service;
 public class EmailServiceImpl implements EmailConfigService {
     @Autowired
     EmailConfigMapper emailConfigMapper;
+
     @Override
     public EmailConfig getemail() {
         return emailConfigMapper.getemail();

src/main/java/cn/hellohao/service/impl/FTPImageupload.java

@@ -1,135 +0,0 @@
-package cn.hellohao.service.impl;
-
-import cn.hellohao.pojo.Keys;
-import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
-import cn.hellohao.utils.*;
-import org.apache.commons.net.ftp.FTPClient;
-import org.apache.commons.net.ftp.FTPReply;
-import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.*;
-
-@Service
-public class FTPImageupload {
-    static FTPClient ftpClient1 ;
-    static Keys key;
-
-    public ReturnImage ImageuploadFTP(Map<String, File> fileMap, String username,Integer keyID)  {
-        ReturnImage returnImage = new ReturnImage();
-        String[] host = key.getEndpoint().split("\\:");
-        String h = host[0];
-        Integer p = Integer.parseInt(host[1]);
-        FTPUtils ftps = new FTPUtils(h, p, key.getAccessKey(), key.getAccessSecret());
-        boolean flag = ftps.open();
-        File file = null;
-        Map<ReturnImage, Integer> ImgUrl = new HashMap<>();
-        ftps.mkDir(File.separator+username);
-        try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
-                file = entry.getValue();
-                String userkey =username + "/"+ ShortUID + "." + entry.getKey();
-                if (flag) {
-                    boolean isUpload = ftps.upload(file, "/" + userkey, "");
-                    if(isUpload){
-                        returnImage.setImgname(userkey);
-                        returnImage.setImgurl(key.getRequestAddress() + "/"+ userkey);
-                        returnImage.setImgSize(entry.getValue().length());
-                        returnImage.setCode("200");
-                    }else{
-                        returnImage.setCode("500");
-                    }
-                }
-                Print.Normal("要上传的文件路径：/"+userkey);
-            }
-        }catch (Exception e){
-            e.printStackTrace();
-            returnImage.setCode("500");
-//                ImgUrl.put(null, 500);
-        }
-        return returnImage;
-
-    }
-
-    //初始化FTP对象存储
-    public static Integer Initialize(Keys k) {
-        int ret = -1;
-        if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null && k.getRequestAddress()!=null ) {
-            if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("") && !k.getRequestAddress().equals("") ) {
-                FTPClient ftp = new FTPClient();
-                ftp.setConnectTimeout(0);
-                int flag = k.getEndpoint().indexOf(":");
-                if(flag>0){
-                    String[] host = k.getEndpoint().split("\\:");
-                    String h = host[0];
-                    Integer p = Integer.parseInt(host[1]);
-                    try {
-                        if(!ftp.isConnected()){
-                            ftp.connect(h,p);
-                        }
-                        ftp.login(k.getAccessKey(), k.getAccessSecret());
-                        int reply = ftp.getReplyCode();
-                        if (!FTPReply.isPositiveCompletion(reply)) {
-                            System.out.println("FTP Object Is null");
-                            ftp.disconnect();
-                            return -1;
-                        }
-                        ret = 1;
-                        key = k;
-//                        KeyObjectMap objectMap = new KeyObjectMap(ftp,k);
-                    } catch (IOException e) {
-                        System.out.println("FTP Object Is null");
-                        return -1;
-                    }
-                }
-            }
-        }
-        return ret;
-    }
-
-    public static void fuzhi(String p1,String p2){
-        String a=p1;
-        try{
-            File afile=new File(a);
-            File bfile=new File(p2);//定义一个复制后的文件路径
-            bfile.createNewFile();//新建文件
-            FileInputStream c=new FileInputStream(afile);//定义FileInputStream对象
-            FileOutputStream d=new FileOutputStream(bfile);//定义FileOutputStream对象
-            byte[] date=new byte[512];//定义一个byte数组
-            int i=0;
-            while((i=c.read(date))>0){//判断有没有读取到文件末尾
-                d.write(date);
-            }
-            c.close();
-            d.close();
-            System.out.println("文件复制成功");}
-        catch(IOException e){
-            e.printStackTrace();
-        }
-    }
-
-    public Boolean delFTP(Integer keyID, String fileName) {
-        boolean b = true;
-        try {
-            String[] host = key.getEndpoint().split("\\:");
-            String h = host[0];
-            Integer p = Integer.parseInt(host[1]);
-            //创建FTP客户端，所有的操作都基于FTPClinet
-            FTPUtils ftps = new FTPUtils(h, p, key.getAccessKey(), key.getAccessSecret());
-            ftps.open();
-            b = ftps.deleteFile(fileName);
-        } catch (Exception e) {
-            e.printStackTrace();
-            b = false;
-        }
-        return b;
-    }
-
-
-}

src/main/java/cn/hellohao/service/impl/FtpServiceImpl.java

@@ -0,0 +1,115 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Keys;
+import cn.hellohao.pojo.ReturnImage;
+import cn.hutool.extra.ftp.Ftp;
+import cn.hutool.extra.ftp.FtpMode;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.net.ftp.FTP;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+@Service
+public class FtpServiceImpl {
+    private static Logger logger = LoggerFactory.getLogger(FtpServiceImpl.class);
+    private Keys key;
+
+    public static int Initialize(Keys k) {
+        int ret = -1;
+        try{
+            if (StringUtils.isBlank(k.getAccessKey())
+                    || StringUtils.isBlank(k.getAccessSecret())
+                    || StringUtils.isBlank(k.getEndpoint())
+                    || StringUtils.isBlank(k.getRequestAddress())){
+                return -1;
+            }
+            Charset charset = StandardCharsets.UTF_8;//Charset.forName("UTF-8");
+            String[] hostArr = k.getEndpoint().split("\\:");
+            String host = hostArr[0];
+            Integer port = Integer.parseInt(hostArr[1]);
+            Ftp ftp = new Ftp(host, port, k.getAccessKey(), k.getAccessSecret(), charset);
+            ftp.getClient().type(FTP.BINARY_FILE_TYPE);
+            ftp.setMode(FtpMode.Passive);
+            return 1;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return -1;
+        }
+    }
+
+    public ReturnImage FtpUploadFile(
+            Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
+        ReturnImage returnImage = new ReturnImage();
+        Ftp ftp = null;
+        try {
+            if (null == key) {
+                System.out.println("FTP = 存储源对象为空");
+                returnImage.setCode("500");
+                return returnImage;
+            }
+            Charset charset = StandardCharsets.UTF_8;//Charset.forName("UTF-8");
+            String[] hostArr = key.getEndpoint().split("\\:");
+            String host = hostArr[0];
+            Integer port = Integer.parseInt(hostArr[1]);
+            ftp = new Ftp(host, port, key.getAccessKey(), key.getAccessSecret(), charset);
+            ftp.getClient().type(FTP.BINARY_FILE_TYPE);
+            ftp.setMode(FtpMode.Passive);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.out.println("FTP = 存储源对象为空");
+            returnImage.setCode("500");
+            return returnImage;
+        }
+        File file = null;
+        FileInputStream stream = null;
+        try {
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
+                file = entry.getValue();
+                stream = new FileInputStream(file);
+                boolean isUpload = ftp.upload(
+                        "/" + username,
+                        ShortUIDName + "." + prefix,
+                        stream);
+                if (!isUpload) {
+                    returnImage.setCode("400");
+                }
+                try {if(stream!=null){stream.close();}} catch (Exception e) { }
+            }
+            returnImage.setCode("200");
+        } catch (Exception e) {
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+            logger.error("FTP发生异常：",e);
+            returnImage.setCode("500");
+        }
+        return returnImage;
+    }
+
+    public Boolean delFTP(Integer keyID, Images images) {
+        boolean b = true;
+        Ftp ftp = null;
+        try {
+            Charset charset = StandardCharsets.UTF_8;//Charset.forName("UTF-8");
+            String[] hostArr = key.getEndpoint().split("\\:");
+            String host = hostArr[0];
+            Integer port = Integer.parseInt(hostArr[1]);
+            ftp = new Ftp(host, port, key.getAccessKey(), key.getAccessSecret(), charset);
+            b = ftp.delFile(images.getImgname());
+        } catch (Exception e) {
+            e.printStackTrace();
+            b = false;
+        }
+        return b;
+    }
+
+}

src/main/java/cn/hellohao/service/impl/GroupServiceImpl.java

@@ -88,8 +88,8 @@ public class GroupServiceImpl implements GroupService {
         if(group.getUsertype()!=0){
             Group groupFroUserType = groupMapper.getGroupFroUserType(group.getUsertype());
             if(groupFroUserType!=null){
-                if(groupFroUserType.getUsertype()==group.getUsertype()){
-                    if(groupFroUserType.getId()==group.getId()){
+                if(groupFroUserType.getUsertype().equals(group.getUsertype())){
+                    if(groupFroUserType.getId().equals(group.getId())){
                         groupMapper.setgroup(group);
                         msg.setInfo("修改成功");
                     }else{

src/main/java/cn/hellohao/service/impl/ImgServiceImpl.java

@@ -1,50 +1,25 @@
 package cn.hellohao.service.impl;
 
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
+import cn.hellohao.dao.ImgMapper;
+import cn.hellohao.dao.SysConfigMapper;
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Msg;
+import cn.hellohao.pojo.SysConfig;
 import cn.hellohao.pojo.User;
-import cn.hellohao.utils.Print;
-import com.UpYun;
-import com.aliyun.oss.OSSClient;
-import com.qcloud.cos.COSClient;
-import com.qcloud.cos.ClientConfig;
-import com.qcloud.cos.auth.BasicCOSCredentials;
-import com.qcloud.cos.auth.COSCredentials;
-import com.qcloud.cos.exception.CosClientException;
-import com.qcloud.cos.exception.CosServiceException;
-import com.qcloud.cos.region.Region;
-import com.qiniu.common.QiniuException;
-import com.qiniu.common.Zone;
-import com.qiniu.storage.BucketManager;
-import com.qiniu.storage.Configuration;
-import com.qiniu.util.Auth;
-import com.upyun.UpException;
-import org.apache.commons.net.ftp.FTPClient;
+import cn.hellohao.service.ImgService;
+import com.alibaba.fastjson.JSONObject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
-import com.netease.cloud.auth.BasicCredentials;
-import com.netease.cloud.auth.Credentials;
-import com.netease.cloud.services.nos.NosClient;
-import com.netease.cloud.services.nos.model.Bucket;
-import com.netease.cloud.services.nos.model.CannedAccessControlList;
-import com.netease.cloud.services.nos.transfer.TransferManager;
-
-import cn.hellohao.dao.ImgMapper;
-import cn.hellohao.pojo.Images;
-import cn.hellohao.pojo.Keys;
-import cn.hellohao.service.ImgService;
-
-import javax.annotation.Resource;
+import java.util.List;
 
 @Service
 public class ImgServiceImpl implements ImgService {
     @Autowired
-    //@Resource
     private ImgMapper imgMapper;
-
+    @Autowired
+    SysConfigMapper sysConfigMapper;
     @Override
     public List<Images> selectimg(Images images) {
         // TODO Auto-generated method stub
@@ -52,7 +27,12 @@ public class ImgServiceImpl implements ImgService {
     }
 
     @Override
-    public Integer deleimg(Integer id) {
+    public Integer insertImgData(Images images) {
+        return imgMapper.insertImgData(images);
+    }
+
+    @Override
+    public Integer deleimg(Long id) {
         // TODO Auto-generated method stub
         return imgMapper.deleimg(id);
     }
@@ -62,116 +42,20 @@ public class ImgServiceImpl implements ImgService {
         return imgMapper.deleimgForImgUid(imguid);
     }
 
-    public Images selectByPrimaryKey(Integer id) {
+    public Images selectByPrimaryKey(Long id) {
         return imgMapper.selectByPrimaryKey(id);
     }
-    //删除对象存储的图片文件
-    public void delect(Keys key, String fileName) {
-        // 初始化
-        Credentials credentials = new BasicCredentials(key.getAccessKey(), key.getAccessSecret());
-        NosClient nosClient = new NosClient(credentials);
-        nosClient.setEndpoint(key.getEndpoint());
-        // 初始化TransferManager
-        TransferManager transferManager = new TransferManager(nosClient);
-        //列举桶
-        ArrayList bucketList = new ArrayList();
-        String tname = "";
-        for (Bucket bucket : nosClient.listBuckets()) {
-            bucketList.add(bucket.getName());
-        }
-        for (Object object : bucketList) {
-            tname = object.toString();
-            //查看桶的ACL
-            CannedAccessControlList acl = nosClient.getBucketAcl(object.toString());
-        }
-        //这种方法不能删除指定文件夹下的文件
-        boolean isExist = nosClient.doesObjectExist(tname, fileName, null);
-        System.out.println("文件是否存在：" + isExist);
-        if (isExist) {
-            nosClient.deleteObject(tname, fileName);
-        }
-    }
-    public void delectOSS(Keys key, String fileName) {
-        String endpoint = key.getEndpoint();
-        String accessKeyId = key.getAccessKey();
-        String accessKeySecret = key.getAccessSecret();
-        String bucketName = key.getBucketname();
-        String objectName = fileName;
-        OSSClient ossClient = new OSSClient(endpoint, accessKeyId, accessKeySecret);
-        ossClient.deleteObject(bucketName, objectName);
-        ossClient.shutdown();
-    }
-    //删除USS对象存储的图片文件
-    public void delectUSS(Keys key, String fileName) {
-        UpYun upyun = new UpYun(key.getBucketname(), key.getAccessKey(), key.getAccessSecret());
-        try {
-            boolean result = upyun.deleteFile(fileName, null);
-        } catch (IOException e) {
-            e.printStackTrace();
-        } catch (UpException e) {
-            e.printStackTrace();
-        }
+
+    @Override
+    public Images selectImgByBrieflink(String brieflink) {
+        return imgMapper.selectImgByBrieflink(brieflink);
     }
 
-    public void delectUFile(Keys key, String fileName) {
-        UpYun upyun = new UpYun(key.getBucketname(), key.getAccessKey(), key.getAccessSecret());
-        try {
-            boolean result = upyun.deleteFile(fileName, null);
-        } catch (IOException e) {
-            e.printStackTrace();
-        } catch (UpException e) {
-            e.printStackTrace();
-        }
-    }
-    public void delectKODO(Keys key, String fileName) {
-        Configuration cfg;
-        if(key.getEndpoint().equals("1")){cfg = new Configuration(Zone.zone0());}
-        else if(key.getEndpoint().equals("2")){cfg = new Configuration(Zone.zone1());}
-        else if(key.getEndpoint().equals("3")){cfg = new Configuration(Zone.zone2());}
-        else if(key.getEndpoint().equals("4")){cfg = new Configuration(Zone.zoneNa0());}
-        else{cfg = new Configuration(Zone.zoneAs0());}
-        Auth auth = Auth.create(key.getAccessKey(), key.getAccessSecret());
-        BucketManager bucketManager = new BucketManager(auth, cfg);
-        try {
-            bucketManager.delete(key.getBucketname(), fileName);
-        } catch (QiniuException ex) {
-            //如果遇到异常，说明删除失败
-            System.err.println(ex.code());
-            System.err.println(ex.response.toString());
-        }
-    }
-    //删除COS对象存储的图片文件
-    public void delectCOS(Keys key, String fileName) {
-        COSCredentials cred = new BasicCOSCredentials(key.getAccessKey(), key.getAccessSecret());
-        Region region = new Region(key.getEndpoint());
-        ClientConfig clientConfig = new ClientConfig(region);
-        COSClient cosClient= new COSClient(cred, clientConfig);
-        try {
-            String bucketName = key.getBucketname();
-            String userkey = fileName;
-             cosClient.deleteObject(key.getBucketname(), userkey);
-        } catch (CosServiceException serverException) {
-            serverException.printStackTrace();
-        } catch (CosClientException clientException) {
-            clientException.printStackTrace();
-        }
-    }
-    public void delectFTP(Keys key, String fileName) {
-        FTPClient ftp = new FTPClient();
-        String[] host = key.getEndpoint().split("\\:");
-        String h = host[0];
-        Integer p = Integer.parseInt(host[1]);
-        try {
-            if(!ftp.isConnected()){
-                ftp.connect(h,p);
-            }
-            ftp.login(key.getAccessKey(), key.getAccessSecret());
-            ftp.deleteFile(fileName);
-        } catch (IOException e) {
-            e.printStackTrace();
-            Print.warning("删除FTP存储的图片失败");
-        }
+    @Override
+    public Images selectImgByShortlink(String shortlink) {
+        return imgMapper.selectImgByShortlink(shortlink);
     }
+
     @Override
     public Integer counts(Integer userid) {
         // TODO Auto-generated method stub
@@ -195,7 +79,7 @@ public class ImgServiceImpl implements ImgService {
     }
 
     @Override
-    public Integer deleall(Integer id) {
+    public Integer deleall(Long id) {
         return imgMapper.deleall(id);
     }
 
@@ -220,8 +104,8 @@ public class ImgServiceImpl implements ImgService {
     }
 
     @Override
-    public List<Images> selectImgUrlByMD5(String md5key) {
-        return imgMapper.selectImgUrlByMD5(md5key);
+    public List<Images> selectImgUrlByMD5(Images images) {
+        return imgMapper.selectImgUrlByMD5(images);
     }
 
     @Override
@@ -249,4 +133,37 @@ public class ImgServiceImpl implements ImgService {
         return imgMapper.selectImgUrlByImgUID(imguid);
     }
 
+    @Transactional
+    public Msg insertImgDataForCheck(Images images, User user, JSONObject confdata, String flilename)throws Exception {
+        Msg msg = new Msg();
+        JSONObject jsonObject = new JSONObject();
+        SysConfig sysConfig = sysConfigMapper.getstate();
+        if(sysConfig.getCheckduplicate().equals("1")){
+            //查重
+            Images img = new Images();
+            img.setUserid(user==null?0:user.getId());
+            img.setMd5key(images.getMd5key());
+            List<Images> list = imgMapper.selectImgUrlByMD5(img);
+            if (list.size() > 0) {
+                jsonObject.put("url", list.get(0).getImgurl());
+                jsonObject.put("name", flilename);
+                jsonObject.put("imguid", list.get(0).getImguid());
+                System.err.println(jsonObject.toJSONString());
+                msg.setData(jsonObject);
+                msg.setCode("000");
+                return msg;
+            }else{
+                imgMapper.insertImgData(images);
+                msg.setCode("200");
+                return msg;
+            }
+        }else{
+            //不查重
+            imgMapper.insertImgData(images);
+            msg.setCode("200");
+        }
+        return msg;
+    }
+
+
 }

src/main/java/cn/hellohao/service/impl/ImgViolationJudgeServiceImpl.java

@@ -0,0 +1,116 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.dao.ImgMapper;
+import cn.hellohao.dao.ImgreviewMapper;
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Imgreview;
+import cn.hellohao.pojo.Keys;
+import cn.hellohao.pojo.Msg;
+import cn.hellohao.utils.FirstRun;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baidu.aip.contentcensor.AipContentCensor;
+import com.baidu.aip.contentcensor.EImgType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class ImgViolationJudgeServiceImpl {
+
+    private static Logger logger = LoggerFactory.getLogger(FirstRun.class);
+    @Autowired
+    ImgreviewServiceImpl imgreviewService;
+    @Autowired ImgMapper imgMapper;
+    @Autowired deleImages deleimages;
+    @Autowired private ImgreviewMapper imgreviewMapper;
+
+
+    //synchronized
+    @Async("taskExecutor")
+    public void LegalImageCheck(Images images, Keys keys) {
+        Imgreview imgreview = null;
+        try {
+            imgreview = imgreviewService.selectByusing(1);
+        } catch (Exception e) {
+            logger.error("获取鉴别程序的时候发生错误");
+            e.printStackTrace();
+        }
+        // 判断哪个鉴别平台
+        if (null != imgreview) {
+            LegalImageCheckForBaiDu(imgreview, images, keys);
+        }
+    }
+
+    private void LegalImageCheckForBaiDu(Imgreview imgreview, Images images, Keys keys) {
+        //        Imgreview imgreview = imgreviewService.selectByPrimaryKey(1);
+        if (imgreview.getUsing() == 1) {
+            logger.info("非法图像鉴别进程启动-BaiDu");
+            try {
+                AipContentCensor client =
+                        new AipContentCensor(
+                                imgreview.getAppId(),
+                                imgreview.getApiKey(),
+                                imgreview.getSecretKey());
+                client.setConnectionTimeoutInMillis(5000);
+                client.setSocketTimeoutInMillis(30000);
+//                 res = client.antiPorn(images.getImgurl());
+                org.json.JSONObject res = client.imageCensorUserDefined(images.getImgurl(), EImgType.URL, null);
+                logger.info("返回的鉴黄json:" + res.toString());
+                com.alibaba.fastjson.JSONArray jsonArray =
+                        JSON.parseArray("[" + res.toString() + "]");
+
+                for (Object o : jsonArray) {
+                    JSONObject jsonObject =
+                            (JSONObject) o;
+                    com.alibaba.fastjson.JSONArray data = jsonObject.getJSONArray("data");
+                    Integer conclusionType = jsonObject.getInteger("conclusionType");
+                    if (conclusionType != null) {
+                        if (conclusionType == 2) {
+                            // 1：合规，2：不合规，3：疑似，4：审核失败
+                            for (Object datum : data) {
+                                JSONObject imgdata =
+                                        (JSONObject) datum;
+                                if (imgdata.getInteger("type") == 1) {
+                                    logger.info("存在非法图片，进行处理操作");
+                                    // type参数
+                                    // 0:百度官方违禁图库、1：色情识别、2：暴恐识别、3：恶心图识别、4:广告检测、5：政治敏感识别、6：图像质量检测、7：用户图像黑名单、8：用户图像白名单、10：用户头像审核、11：百度官方违禁词库、12：图文审核、13:自定义文本黑名单、14:自定义文本白名单、15:EasyDL自定义模型、16：敏感旗帜标志识别、21：不良场景识别、24：直播场景审核
+                                    // 存在非法图片，进行处理操作
+                                    Images img = new Images();
+                                    img.setImgname(images.getImgname());
+                                    img.setViolation("1[1]"); // 数字是鉴别平台的主键ID，括号是非法的类型，参考上面的注释
+                                    imgMapper.setImg(img);
+                                    // 计入总数
+                                    Imgreview imgv = new Imgreview();
+                                    imgv.setId(1);
+                                    Integer count = imgreview.getCount();
+                                    imgv.setCount(count + 1);
+                                    imgreviewMapper.updateByPrimaryKeySelective(imgv);
+                                    Images imgObj =
+                                            imgMapper.selectImgUrlByImgUID(images.getImguid());
+                                    Msg dele = deleimages.dele2(Long.toString(imgObj.getId()));
+                                    List<Long> ids = (List<Long>) dele.getData();
+                                    if (!ids.contains(imgObj.getId())) {
+                                        logger.error("检测到违规图像，但是数据库删除失败");
+                                    }
+
+                                }
+                            }
+                        }
+                    }
+                }
+
+            } catch (Exception e) {
+                logger.error("图像鉴黄线程执行过程中出现异常");
+                e.printStackTrace();
+            }
+        }
+    }
+
+
+
+}

src/main/java/cn/hellohao/service/impl/InitializationStorage.java

@@ -4,6 +4,8 @@ import cn.hellohao.auth.filter.SubjectFilter;
 import cn.hellohao.dao.KeysMapper;
 import cn.hellohao.pojo.Keys;
 import cn.hellohao.utils.Print;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.CommandLineRunner;
@@ -23,6 +25,7 @@ import java.util.List;
 @Order(2)
 public class InitializationStorage implements CommandLineRunner {
 
+    private static Logger logger = LoggerFactory.getLogger(InitializationStorage.class);
     @Value("${CROS_ALLOWED_ORIGINS}")
     private String allowedOrigins;
 
@@ -30,7 +33,7 @@ public class InitializationStorage implements CommandLineRunner {
     private KeysMapper keysMapper;
 
     @Override
-    public void run(String... args) throws Exception {
+    public void run(String... args) {
         SubjectFilter.WEBHOST = allowedOrigins;
         String name = ManagementFactory.getRuntimeMXBean().getName();
         String pid = name.split("@")[0];
@@ -41,21 +44,22 @@ public class InitializationStorage implements CommandLineRunner {
         List<Keys> keylist = keysMapper.getKeys();
         for (Keys key : keylist) {
             if(key.getStorageType()!=0 && key.getStorageType()!=null){
-                int ret =0;
                 if(key.getStorageType()==1){
-                    ret =NOSImageupload.Initialize(key);
+                    NOSImageupload.Initialize(key);
                 }else if (key.getStorageType()==2){
-                    ret =OSSImageupload.Initialize(key);
+                    OSSImageupload.Initialize(key);
                 }else if(key.getStorageType()==3){
-                    ret = USSImageupload.Initialize(key);
+                    USSImageupload.Initialize(key);
                 }else if(key.getStorageType()==4){
-                    ret = KODOImageupload.Initialize(key);
+                    KODOImageupload.Initialize(key);
                 }else if(key.getStorageType()==6){
-                    ret = COSImageupload.Initialize(key);
+                    COSImageupload.Initialize(key);
                 }else if(key.getStorageType()==7){
-                    ret = FTPImageupload.Initialize(key);
+                    FtpServiceImpl.Initialize(key);
                 }else if(key.getStorageType()==8){
-                    ret = UFileImageupload.Initialize(key);
+                    S3Imageupload.Initialize(key);
+                }else if(key.getStorageType()==9){
+                    WebDAVImageupload.Initialize(key);
                 }
             }
         }

src/main/java/cn/hellohao/service/impl/KODOImageupload.java

@@ -1,65 +1,54 @@
 package cn.hellohao.service.impl;
 
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.Keys;
 import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
-import cn.hellohao.utils.*;
-import com.aliyun.oss.OSSClient;
-import com.aliyun.oss.model.ObjectMetadata;
 import com.google.gson.Gson;
 import com.qiniu.common.QiniuException;
-import com.qiniu.common.Zone;
 import com.qiniu.http.Response;
 import com.qiniu.storage.BucketManager;
 import com.qiniu.storage.Configuration;
+import com.qiniu.storage.Region;
 import com.qiniu.storage.UploadManager;
 import com.qiniu.storage.model.DefaultPutRet;
 import com.qiniu.storage.model.FileInfo;
 import com.qiniu.util.Auth;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
-import java.util.Date;
-import java.util.HashMap;
+import java.io.FileInputStream;
 import java.util.Map;
-import java.util.UUID;
 
 @Service
 public class KODOImageupload {
+    private static Logger logger = LoggerFactory.getLogger(KODOImageupload.class);
     static String upToken;
     static BucketManager bucketManager;
     static Keys key;
 
-    public ReturnImage ImageuploadKODO(Map<String, File> fileMap, String username, Integer keyID){
+    public ReturnImage ImageuploadKODO(
+            Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
         ReturnImage returnImage = new ReturnImage();
-        Configuration cfg;
-        if (key.getEndpoint().equals("1")) {
-            cfg = new Configuration(Zone.zone0());
-        } else if (key.getEndpoint().equals("2")) {
-            cfg = new Configuration(Zone.zone1());
-        } else if (key.getEndpoint().equals("3")) {
-            cfg = new Configuration(Zone.zone2());
-        } else if (key.getEndpoint().equals("4")) {
-            cfg = new Configuration(Zone.zoneNa0());
-        } else {
-            cfg = new Configuration(Zone.zoneAs0());
-        }
+        Configuration cfg = new Configuration(Region.autoRegion());
         UploadManager uploadManager = new UploadManager(cfg);
         Auth auth = Auth.create(key.getAccessKey(), key.getAccessSecret());
-        String upToken = auth.uploadToken(key.getBucketname(),null,7200,null);
+        String upToken = auth.uploadToken(key.getBucketname(), null, 7200, null);
         File file = null;
+        FileInputStream stream = null;
         try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
                 file = entry.getValue();
+                stream = new FileInputStream(file);
                 try {
-                    Response response = uploadManager.put(file,username + "/" + ShortUID + "." + entry.getKey(),upToken);
-                    DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
-                    returnImage.setImgname(username + "/" + ShortUID + "." + entry.getKey());
-                    returnImage.setImgurl(key.getRequestAddress() + "/" + username + "/" + ShortUID + "." + entry.getKey());
-                    returnImage.setImgSize(entry.getValue().length());
-                    returnImage.setCode("200");
+                    Response response = uploadManager.put(stream,username + "/" + ShortUIDName + "." + prefix, upToken, null, null);
+                    DefaultPutRet putRet =
+                            new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
+
                 } catch (QiniuException ex) {
                     returnImage.setCode("400");
                     Response r = ex.response;
@@ -69,9 +58,12 @@ public class KODOImageupload {
                     } catch (QiniuException ex2) {
                     }
                 }
+                try {if(stream!=null){stream.close();}} catch (Exception ex) { }
             }
-        }catch (Exception e){
-            e.printStackTrace();
+            returnImage.setCode("200");
+        } catch (Exception e) {
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+            logger.error("KODO发生异常：",e);
             returnImage.setCode("500");
         }
         return returnImage;
@@ -79,53 +71,41 @@ public class KODOImageupload {
 
     public static Integer Initialize(Keys k) {
         int ret = -1;
-        if (k.getEndpoint() != null && k.getAccessSecret() != null && k.getEndpoint() != null
-                && k.getBucketname() != null && k.getRequestAddress() != null) {
-            if (!k.getEndpoint().equals("") && !k.getAccessSecret() .equals("") && !k.getEndpoint() .equals("")
-                    && !k.getBucketname().equals("") && !k.getRequestAddress() .equals("")) {
-                Configuration cfg;
-                if (k.getEndpoint().equals("1")) {
-                    cfg = new Configuration(Zone.zone0());
-                } else if (k.getEndpoint().equals("2")) {
-                    cfg = new Configuration(Zone.zone1());
-                } else if (k.getEndpoint().equals("3")) {
-                    cfg = new Configuration(Zone.zone2());
-                } else if (k.getEndpoint().equals("4")) {
-                    cfg = new Configuration(Zone.zoneNa0());
-                } else {
-                    cfg = new Configuration(Zone.zoneAs0());
-                }
-                UploadManager uploadManager = new UploadManager(cfg);
-                Auth auth = Auth.create(k.getAccessKey(), k.getAccessSecret());
-                String upToken = auth.uploadToken(k.getBucketname(),null,7200,null);//auth.uploadToken(k.getBucketname());
-                BucketManager bmObj = new BucketManager(auth, cfg);
-                BucketManager.FileListIterator fileListIterator = null;
-                try {
-                    fileListIterator = bmObj.createFileListIterator(k.getBucketname(), "", 1, "/");
-                    FileInfo[] items = fileListIterator.next();
-                    if(items!=null){
-                        ret = 1;
-                        bucketManager = bmObj;
-                        key = k;
-                    }
-                }catch (Exception e){
-                    System.out.println("KODO Object Is null");
-                    ret = -1;
-                }
+        if (StringUtils.isBlank(k.getAccessKey())
+                || StringUtils.isBlank(k.getAccessSecret())
+                || StringUtils.isBlank(k.getEndpoint())
+                || StringUtils.isBlank(k.getBucketname())
+                || StringUtils.isBlank(k.getRequestAddress())) {
+            return -1;
+        }
+        Configuration cfg = new Configuration(Region.autoRegion());
+        UploadManager uploadManager = new UploadManager(cfg);
+        Auth auth = Auth.create(k.getAccessKey(), k.getAccessSecret());
+        String upToken = auth.uploadToken(k.getBucketname(), null, 7200, null);
+        BucketManager BM = new BucketManager(auth, cfg);
+        BucketManager.FileListIterator fileListIterator = null;
+        try {
+            fileListIterator = BM.createFileListIterator(k.getBucketname(), "", 1, "/");
+            FileInfo[] items = fileListIterator.next();
+            if (items != null) {
+                ret = 1;
+                bucketManager = BM;
+                key = k;
             }
+        } catch (Exception e) {
+            System.out.println("KODO Object Is null");
+            ret = -1;
         }
         return ret;
     }
 
-    public Boolean delKODO(Integer keyID, String fileName) {
+    public Boolean delKODO(Integer keyID, Images images) {
         boolean b = true;
         try {
-            bucketManager.delete(key.getBucketname(), fileName);
+            bucketManager.delete(key.getBucketname(), images.getImgname());
         } catch (Exception ex) {
             b = false;
         }
         return b;
     }
-
-
 }

src/main/java/cn/hellohao/service/impl/KeysServiceImpl.java

@@ -2,6 +2,7 @@ package cn.hellohao.service.impl;
 
 import cn.hellohao.pojo.Msg;
 import cn.hellohao.utils.Print;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -16,7 +17,6 @@ public class KeysServiceImpl implements KeysService {
 
     @Autowired
     private KeysMapper keysMapper;
-
     @Autowired
     private NOSImageupload nOSImageupload;
     @Autowired
@@ -28,9 +28,11 @@ public class KeysServiceImpl implements KeysService {
     @Autowired
     private COSImageupload cosImageupload;
     @Autowired
-    private FTPImageupload ftpImageupload;
+    private FtpServiceImpl ftpService;
     @Autowired
-    private UFileImageupload uFileImageupload;
+    private S3Imageupload s3Imageupload;
+    @Autowired
+    private WebDAVImageupload webDAVImageupload;
 
 
     @Override
@@ -52,9 +54,31 @@ public class KeysServiceImpl implements KeysService {
     public Msg updateKey(Keys key) {
         Msg msg = new Msg();
         Integer ret = -2;
-        //修改完初始化
+        //修正一边数据格式，去除末尾的斜杠
+        if(key.getStorageType()==9 || key.getStorageType()==8){
+            //s3或者webdav
+            if(!StringUtils.isBlank(key.getRootPath()) && !key.getRootPath().equals("/")){
+                if (key.getRootPath().endsWith("/")) {
+                    String rootpath = key.getRootPath();
+                    key.setRootPath(rootpath.substring(0, rootpath.length() - 1));
+                }
+            }
+        }
+        if(!StringUtils.isBlank(key.getEndpoint())){
+            final String endpoint = key.getEndpoint();
+            if (endpoint.endsWith("/")) {
+                key.setEndpoint(endpoint.substring(0, endpoint.length() - 1));
+            }
+        }
+        if(!StringUtils.isBlank(key.getRequestAddress())){
+            final String requestAddress = key.getRequestAddress();
+            if (requestAddress.endsWith("/")) {
+                key.setRequestAddress(requestAddress.substring(0, requestAddress.length() - 1));
+            }
+        }
+
         if(key.getStorageType()==1){
-            ret =nOSImageupload.Initialize(key);//实例化网易
+            ret =nOSImageupload.Initialize(key);
         }else if (key.getStorageType()==2){
             ret = ossImageupload.Initialize(key);
         }else if(key.getStorageType()==3 ){
@@ -66,9 +90,11 @@ public class KeysServiceImpl implements KeysService {
         }else if(key.getStorageType()==6){
             ret = cosImageupload.Initialize(key);
         }else if(key.getStorageType()==7){
-            ret = ftpImageupload.Initialize(key);
+            ret = ftpService.Initialize(key);
         }else if(key.getStorageType()==8){
-            ret = uFileImageupload.Initialize(key);
+            ret = s3Imageupload.Initialize(key);
+        }else if(key.getStorageType()==9){
+            ret = webDAVImageupload.Initialize(key);
         }else{
             Print.Normal("为获取到存储参数，或者使用存储源是本地的。");
         }

src/main/java/cn/hellohao/service/impl/NOSImageupload.java

@@ -1,46 +1,39 @@
 package cn.hellohao.service.impl;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.util.*;
-
-import cn.hellohao.exception.StorageSourceInitException;
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Keys;
 import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
-import cn.hellohao.utils.*;
-import com.netease.cloud.services.nos.model.NOSObjectSummary;
-import com.netease.cloud.services.nos.model.ObjectListing;
-import com.netease.cloud.services.nos.model.ObjectMetadata;
-import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
-
+import cn.hellohao.utils.SetText;
 import com.netease.cloud.auth.BasicCredentials;
 import com.netease.cloud.auth.Credentials;
 import com.netease.cloud.services.nos.NosClient;
-import com.netease.cloud.services.nos.model.Bucket;
-import com.netease.cloud.services.nos.transfer.TransferManager;
+import com.netease.cloud.services.nos.model.ObjectListing;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
 
-import cn.hellohao.pojo.Keys;
+import java.io.File;
+import java.util.Map;
 
 @Service
 public class NOSImageupload {
     static NosClient nosClient;
     static Keys key;
 
-    public ReturnImage Imageupload(Map<String, File> fileMap, String username,Integer keyID){
+    public ReturnImage Imageupload(Map<Map<String, String>, File> fileMap, String username,Integer keyID){
         ReturnImage returnImage = new ReturnImage();
         File file = null;
         try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
                 file = entry.getValue();
-                nosClient.putObject(key.getBucketname(), username + "/" + ShortUID+ "." + entry.getKey(), file);
-                returnImage.setImgname(username + "/" + ShortUID+ "." + entry.getKey());
-                returnImage.setImgurl(key.getRequestAddress() + "/" + username + "/" + ShortUID + "." + entry.getKey());
-                returnImage.setImgSize(entry.getValue().length());
-                returnImage.setCode("200");
+                nosClient.putObject(
+                        key.getBucketname(), username + "/" + ShortUIDName + "." + prefix, file);
             }
-        }catch (Exception e){
+            returnImage.setCode("200");
+        } catch (Exception e) {
             e.printStackTrace();
             returnImage.setCode("500");
         }
@@ -49,42 +42,35 @@ public class NOSImageupload {
     }
 
 
-    //初始化网易NOS对象存储
     public static Integer Initialize(Keys k) {
         int ret = -1;
-        if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null
-                && k.getBucketname()!=null && k.getRequestAddress()!=null ){
-            if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("")
-                    && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ){
-                // 初始化
-                Credentials credentials = new BasicCredentials(k.getAccessKey(), k.getAccessSecret());
-                NosClient nosObj = new NosClient(credentials);
-                nosObj.setEndpoint(k.getEndpoint());
-                ObjectListing objectListing = null;
-                try {
-                    objectListing = nosObj.listObjects(k.getBucketname());
-                    ret = 1;
-                    nosClient = nosObj;
-                    key = k;
-                }catch (Exception e){
-                    System.out.println("NOS Object Is null");
-                    ret = -1;
-                }
-            }
+        if (StringUtils.isBlank(k.getAccessKey())
+                || StringUtils.isBlank(k.getAccessSecret())
+                || StringUtils.isBlank(k.getEndpoint())
+                || StringUtils.isBlank(k.getBucketname())
+                || StringUtils.isBlank(k.getRequestAddress())) {
+            return -1;
+        }
+        Credentials credentials = new BasicCredentials(k.getAccessKey(), k.getAccessSecret());
+        NosClient nosObj = new NosClient(credentials);
+        nosObj.setEndpoint(k.getEndpoint());
+        ObjectListing objectListing = null;
+        try {
+            objectListing = nosObj.listObjects(k.getBucketname());
+            ret = 1;
+            nosClient = nosObj;
+            key = k;
+        }catch (Exception e){
+            System.out.println("NOS Object Is null");
+            ret = -1;
         }
-        //throw new StorageSourceInitException("当前数据源配置不完整，请管理员前往后台配置。");
         return ret;
     }
 
-
-    public Boolean delNOS(Integer keyID, String fileName) {
+    public Boolean delNOS(Integer keyID, Images images) {
         boolean b =true;
         try {
-            //这种方法不能删除指定文件夹下的文件
-            boolean isExist = nosClient.doesObjectExist(key.getBucketname(), fileName, null);
-            if (isExist) {
-                nosClient.deleteObject(key.getBucketname(), fileName);
-            }
+            nosClient.deleteObject(key.getBucketname(), images.getImgname());
         } catch (Exception e) {
             e.printStackTrace();
             b =false;

src/main/java/cn/hellohao/service/impl/OSSImageupload.java

@@ -1,82 +1,97 @@
 package cn.hellohao.service.impl;
 
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.Keys;
 import cn.hellohao.pojo.Msg;
 import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.utils.*;
+import cn.hellohao.utils.TypeDict;
 import com.aliyun.oss.OSS;
-import com.aliyun.oss.OSSClient;
 import com.aliyun.oss.OSSClientBuilder;
 import com.aliyun.oss.model.ObjectListing;
 import com.aliyun.oss.model.ObjectMetadata;
+import com.aliyun.oss.model.PutObjectRequest;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
+
 import java.io.File;
-import java.util.*;
+import java.io.FileInputStream;
+import java.util.Map;
 
 @Service
 public class OSSImageupload {
+    private static Logger logger = LoggerFactory.getLogger(OSSImageupload.class);
     static OSS ossClient;
     static Keys key;
 
-    public ReturnImage ImageuploadOSS(Map<String, File> fileMap, String username,Integer keyID){
+    public ReturnImage ImageuploadOSS(
+            Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
         ReturnImage returnImage = new ReturnImage();
         File file = null;
+        FileInputStream stream = null;
         ObjectMetadata meta = new ObjectMetadata();
         meta.setHeader("Content-Disposition", "inline");
         try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
-                java.text.DateFormat format1 = new java.text.SimpleDateFormat("MMddhhmmss");
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
                 file = entry.getValue();
-                Msg fileMiME = TypeDict.FileMiME(file);
+                stream = new FileInputStream(file);
+                Msg fileMiME = TypeDict.FileMiME(stream);
                 meta.setHeader("content-type", fileMiME.getData().toString());
-                System.out.println("待上传的图片："+username + "/" + ShortUID + "." + entry.getKey());
-                ossClient.putObject(key.getBucketname(), username + "/" + ShortUID + "." + entry.getKey(),file);
-                returnImage.setImgname(username + "/" + ShortUID + "." + entry.getKey());//entry.getValue().getOriginalFilename()
-                returnImage.setImgurl(key.getRequestAddress() + "/" + username + "/" + ShortUID + "." + entry.getKey());
-                returnImage.setImgSize(file.length());
-                returnImage.setCode("200");
+                PutObjectRequest putObjectRequest =
+                        new PutObjectRequest(
+                                key.getBucketname(),
+                                username + "/" + ShortUIDName + "." + prefix,
+                                stream,
+                                meta);
+                ossClient.putObject(putObjectRequest);
+                try {if(stream!=null){stream.close();}} catch (Exception e) { }
             }
-        }catch (Exception e){
-            e.printStackTrace();
+            returnImage.setCode("200");
+        } catch (Exception e) {
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+            logger.error("OSS上传发生异常：",e);
             returnImage.setCode("500");
         }
         return returnImage;
-
     }
 
     public static Integer Initialize(Keys k) {
         int ret = -1;
         ObjectListing objectListing = null;
-        if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getAccessKey()!=null && k.getEndpoint()!=null
-                && k.getBucketname()!=null && k.getRequestAddress()!=null ) {
-            if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getAccessKey().equals("") && !k.getEndpoint().equals("")
-                    && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ) {
-                OSS ossObj = new OSSClientBuilder().build(k.getEndpoint(), k.getAccessKey(), k.getAccessSecret());
-                try {
-                    objectListing = ossObj.listObjects(k.getBucketname());
-                    ret=1;
-                    ossClient = ossObj;
-                    key = k;
-                } catch (Exception e) {
-                    System.out.println("OSS Object Is null");
-                    ret = -1;
-                }
-            }
+        if (StringUtils.isBlank(k.getAccessKey())
+                || StringUtils.isBlank(k.getAccessSecret())
+                || StringUtils.isBlank(k.getEndpoint())
+                || StringUtils.isBlank(k.getBucketname())
+                || StringUtils.isBlank(k.getRequestAddress())) {
+            return -1;
         }
+        OSS ossObj =
+                new OSSClientBuilder()
+                        .build(k.getEndpoint(), k.getAccessKey(), k.getAccessSecret());
+        try {
+            objectListing = ossObj.listObjects(k.getBucketname());
+            ret = 1;
+            ossClient = ossObj;
+            key = k;
+        } catch (Exception e) {
+            System.out.println("OSS Object Is null");
+            ret = -1;
+        }
+
         return ret;
     }
 
-    public boolean delOSS(Integer keyID, String fileName){
-        boolean b =true;
+    public boolean delOSS(Integer keyID, Images images) {
+        boolean b = true;
         try {
-            ossClient.deleteObject(key.getBucketname(), fileName);
+            ossClient.deleteObject(key.getBucketname(), images.getImgname());
         } catch (Exception e) {
             e.printStackTrace();
             b = false;
         }
         return b;
     }
-
-
 }

src/main/java/cn/hellohao/service/impl/RedisServiceImpl.java

@@ -12,42 +12,44 @@ import java.util.concurrent.TimeUnit;
 
 @Service
 public class RedisServiceImpl implements IRedisService {
-    @Autowired
-    private StringRedisTemplate stringRedisTemplate;
-    @Autowired
-    private RedisTemplate redisTemplate;
+  @Autowired private StringRedisTemplate stringRedisTemplate;
+  @Autowired private RedisTemplate redisTemplate;
 
+  @Override
+  public void setValue(String key, Map<String, Object> value) {
+    ValueOperations<String, Object> vo = redisTemplate.opsForValue();
+    vo.set(key, value);
+    redisTemplate.expire(key, 1, TimeUnit.HOURS); // 这里指的是1小时后失效
+  }
 
-    @Override
-    public void setValue(String key, Map<String, Object> value) {
-        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
-        vo.set(key, value);
-        redisTemplate.expire(key, 1, TimeUnit.HOURS); // 这里指的是1小时后失效
-    }
+  @Override
+  public Object getValue(String key) {
+    ValueOperations<String, String> vo = redisTemplate.opsForValue();
+    return vo.get(key);
+  }
 
-    @Override
-    public Object getValue(String key) {
-        ValueOperations<String, String> vo = redisTemplate.opsForValue();
-        return vo.get(key);
-    }
+  @Override
+  public void setValue(String key, String value) {
+    ValueOperations<String, Object> vo = redisTemplate.opsForValue();
+    vo.set(key, value);
+    redisTemplate.expire(key, 3, TimeUnit.MINUTES); // 这里指的是1小时后失效 时HOURS  分 MINUTES
+  }
 
-    @Override
-    public void setValue(String key, String value) {
-        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
-        vo.set(key, value);
-        redisTemplate.expire(key, 3, TimeUnit.MINUTES); // 这里指的是1小时后失效 时HOURS  分 MINUTES
-    }
+  @Override
+  public void setTimeValue(String key, Object value, Long time) {
+    ValueOperations<String, Object> vo = redisTemplate.opsForValue();
+    vo.set(key, value);
+    redisTemplate.expire(key, time, TimeUnit.HOURS);
+  }
 
-    @Override
-    public void setValue(String key, Object value) {
-        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
-        vo.set(key, value);
-        redisTemplate.expire(key, 1, TimeUnit.HOURS); // 这里指的是1小时后失效
-    }
+  @Override
+  public Object getMapValue(String key) {
+    ValueOperations<String, String> vo = redisTemplate.opsForValue();
+    return vo.get(key);
+  }
 
-    @Override
-    public Object getMapValue(String key) {
-        ValueOperations<String, String> vo = redisTemplate.opsForValue();
-        return vo.get(key);
-    }
-}
+  @Override
+  public Boolean removeValue(String key) {
+    return redisTemplate.delete(key);
+  }
+}

src/main/java/cn/hellohao/service/impl/S3Imageupload.java

@@ -0,0 +1,171 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Keys;
+import cn.hellohao.pojo.ReturnImage;
+import com.amazonaws.ClientConfiguration;
+import com.amazonaws.auth.AWSCredentials;
+import com.amazonaws.auth.AWSCredentialsProvider;
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.client.builder.AwsClientBuilder;
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3Client;
+import com.amazonaws.services.s3.AmazonS3ClientBuilder;
+import com.amazonaws.services.s3.model.*;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Hellohao
+ * @version 1.0
+ * @date 2023/3/15 14:04
+ */
+@Service
+public class S3Imageupload {
+    private static Logger logger = LoggerFactory.getLogger(S3Imageupload.class);
+
+    static AmazonS3 AS3;
+    static Keys KEY;
+    public ReturnImage ImageuploadS3(
+            Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
+        ReturnImage returnImage = new ReturnImage();
+        try {
+            if (null == AS3 || null == AS3) {
+                logger.error("S3 = 存储源对象为空");
+                returnImage.setCode("500");
+                return returnImage;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            returnImage.setCode("500");
+            return returnImage;
+        }
+        File file = null;
+        FileInputStream stream = null;
+        try {
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
+                file = entry.getValue();
+                stream = new FileInputStream(file);
+                //解决存储源不能浏览图片的问题
+//                ObjectMetadata objectMetadata = new ObjectMetadata();
+//                objectMetadata.addUserMetadata();
+                AS3.putObject(
+                        new PutObjectRequest(
+                                KEY.getBucketname(),
+                                username + "/" + ShortUIDName + "." + prefix,
+                                stream,null));
+                //        S3Object object = s3.getObject( new GetObjectRequest( key.getBucketname(),
+                try {if(stream!=null){stream.close();}} catch (Exception e) { }
+            }
+            returnImage.setCode("200");
+        } catch (Exception e) {
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+            logger.error("S3协议上传发生异常：",e);
+            returnImage.setCode("500");
+        }
+        return returnImage;
+    }
+
+
+    public static Integer Initialize(Keys k) {
+        int ret = -1;
+        if (StringUtils.isBlank(k.getAccessKey())
+                || StringUtils.isBlank(k.getAccessSecret())
+                || StringUtils.isBlank(k.getRootPath())
+                || StringUtils.isBlank(k.getEndpoint())
+                || StringUtils.isBlank(k.getBucketname())
+                || StringUtils.isBlank(k.getRequestAddress())) {
+            return -1;
+        }
+        try {
+            String regionStr = k.getRegion() == null ? "" : k.getRegion();
+            ClientConfiguration config = new ClientConfiguration();
+            config.setMaxConnections(500);
+            config.setConnectionTimeout(30);
+            // cn-north-1 us-east-1
+            BasicAWSCredentials credentials =
+                    new BasicAWSCredentials(k.getAccessKey(), k.getAccessSecret());
+            AmazonS3 s3 =
+                    AmazonS3ClientBuilder.standard()
+                            .withClientConfiguration(config)
+                            .withPathStyleAccessEnabled(false)
+                            .withCredentials(new AWSStaticCredentialsProvider(credentials))
+                            .withEndpointConfiguration(
+                                    new AwsClientBuilder.EndpointConfiguration(
+                                            k.getEndpoint(), regionStr))
+                            .build();
+            ObjectListing objectListing = s3.listObjects(k.getBucketname());
+            ret = 1;
+            AS3 = s3;
+            KEY = k;
+        } catch (Exception e) {
+            logger.warn("S3 Object  " + k.getKeyname() + "  Is null");
+            ret = -1;
+        }
+        if(ret==-1){
+            ret = Initialize_Tow(k);
+            if(ret>-1){
+                //OK
+            }
+        }
+        return ret;
+    }
+
+    public static Integer Initialize_Tow(Keys k) {
+        int ret = -1;
+        try {
+            ClientConfiguration config = new ClientConfiguration();
+            AwsClientBuilder.EndpointConfiguration endpointConfig =
+                    new AwsClientBuilder.EndpointConfiguration(k.getEndpoint(), k.getRegion());//cn-north-1
+            AWSCredentials awsCredentials = new BasicAWSCredentials(k.getAccessKey(),k.getAccessSecret());
+            AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);
+            AmazonS3 s3  = AmazonS3Client.builder()
+                    .withEndpointConfiguration(endpointConfig)
+                    .withClientConfiguration(config)
+                    .withCredentials(awsCredentialsProvider)
+                    .disableChunkedEncoding()
+                    .withPathStyleAccessEnabled(true)
+                    .build();
+            List<Bucket> buckets = s3.listBuckets();
+            boolean b = false;
+            for (Bucket bucket : buckets) {
+                if(k.getBucketname().equals(bucket.getName())){
+                    b = true;
+                }
+            }
+            if(b==false){
+                throw new NullPointerException();
+            }
+            ret=1;
+            AS3 = s3;
+            KEY = k;
+        } catch (Exception e) {
+            ret = -1;
+        }
+        return ret;
+    }
+
+    public boolean deleS3(Integer keyID, Images images) {
+        boolean b = true;
+        try {
+            DeleteObjectRequest deleteObjectRequest =
+                    new DeleteObjectRequest(KEY.getBucketname(), images.getImgname());
+            AS3.deleteObject(deleteObjectRequest);
+        } catch (Exception e) {
+            e.printStackTrace();
+            b = false;
+        }
+        return b;
+    }
+
+}

src/main/java/cn/hellohao/service/impl/UFileImageupload.java

@@ -1,87 +0,0 @@
-package cn.hellohao.service.impl;
-
-import cn.hellohao.pojo.Keys;
-import cn.hellohao.pojo.Msg;
-import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
-import cn.hellohao.utils.*;
-import com.UpYun;
-import com.aliyun.oss.model.ObjectMetadata;
-import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.io.File;
-import java.util.*;
-
-@Service
-public class UFileImageupload {
-    static UpYun uFile;
-    static Keys key;
-
-    public ReturnImage ImageuploadUFile(Map<String, File> fileMap, String username,Integer keyID) {
-        ReturnImage returnImage = new ReturnImage();
-        File file = null;
-        ObjectMetadata meta = new ObjectMetadata();
-        meta.setHeader("Content-Disposition", "inline");
-        try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
-                file = entry.getValue();
-                Msg fileMiME = TypeDict.FileMiME(file);
-                meta.setHeader("content-type", fileMiME.getData().toString());
-                uFile.setContentMD5(UpYun.md5(file));
-                boolean result = uFile.writeFile(username + "/" + ShortUID + "." + entry.getKey(), file, true);
-                if(result){
-                    returnImage.setImgname(username + "/" + ShortUID + "." + entry.getKey());
-                    returnImage.setImgurl(key.getRequestAddress() + "/" +username + "/" + ShortUID + "." + entry.getKey());
-                    returnImage.setImgSize(entry.getValue().length());
-                    returnImage.setCode("200");
-                }else{
-                    returnImage.setCode("400");
-                    System.err.println("上传失败");
-                }
-            }
-        }catch(Exception e){
-            returnImage.setCode("500");
-        }
-        return returnImage;
-
-
-    }
-
-    //ufile初始化
-    public static Integer Initialize(Keys k) {
-        int ret = -1;
-        if(k.getAccessSecret()!=null && k.getAccessKey()!=null
-                && k.getBucketname()!=null && k.getRequestAddress()!=null ) {
-            if(!k.getAccessSecret().equals("") && !k.getAccessKey().equals("")
-                    && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ) {
-                // 创建UpYun实例。
-                UpYun ufObj = new UpYun(k.getBucketname(), k.getAccessKey(), k.getAccessSecret());
-                List<UpYun.FolderItem> items = null;
-                try {
-                    items = ufObj.readDir("/",null);
-                    ret = 1;
-                    uFile = ufObj;
-                    key = k;
-                } catch (Exception e) {
-                    System.out.println("UFile Object Is null");
-                    ret = -1;
-                }
-            }
-        }
-        return ret;
-    }
-
-    public Boolean delUFile(Integer keyID, String fileName) {
-        boolean b = true;
-        try {
-            boolean result = uFile.deleteFile(fileName, null);
-        } catch (Exception e) {
-            e.printStackTrace();
-            b = false;
-        }
-        return b;
-    }
-
-}

src/main/java/cn/hellohao/service/impl/USSImageupload.java

@@ -1,92 +1,97 @@
 package cn.hellohao.service.impl;
 
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.Keys;
 import cn.hellohao.pojo.Msg;
 import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
-import cn.hellohao.utils.*;
+import cn.hellohao.utils.TypeDict;
 import com.UpYun;
-import com.aliyun.oss.OSSClient;
 import com.aliyun.oss.model.ObjectMetadata;
-import com.upyun.UpException;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
-import java.io.IOException;
-import java.util.*;
+import java.io.FileInputStream;
+import java.util.List;
+import java.util.Map;
 
 @Service
 public class USSImageupload {
+    private static Logger logger = LoggerFactory.getLogger(USSImageupload.class);
     static UpYun upyun;
     static Keys key;
 
-    public ReturnImage ImageuploadUSS(Map<String, File> fileMap, String username,Integer keyID) {
+    public ReturnImage ImageuploadUSS(
+            Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
         ReturnImage returnImage = new ReturnImage();
         File file = null;
+        FileInputStream stream = null;
         ObjectMetadata meta = new ObjectMetadata();
         meta.setHeader("Content-Disposition", "inline");
         try {
-            for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-                String ShortUID = SetText.getShortUuid();
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
                 file = entry.getValue();
-                Msg fileMiME = TypeDict.FileMiME(file);
+                stream = new FileInputStream(file);
+                Msg fileMiME = TypeDict.FileMiME(stream);
                 meta.setHeader("content-type", fileMiME.getData().toString());
                 upyun.setContentMD5(UpYun.md5(file));
-                boolean result = upyun.writeFile(username + "/" + ShortUID + "." + entry.getKey(), file, true);
-                if(result){
-                    returnImage.setImgname(username + "/" + ShortUID + "." + entry.getKey());
-                    returnImage.setImgurl(key.getRequestAddress() + "/" +username + "/" + ShortUID + "." + entry.getKey());
-                    returnImage.setImgSize(entry.getValue().length());
-                    returnImage.setCode("200");
-                }else{
-                    returnImage.setCode("400");
+                boolean result =
+                        upyun.writeFile(username + "/" + ShortUIDName + "." + prefix, stream, true, null);
+                if (result) {
+
+                } else {
                     System.err.println("上传失败");
+                    returnImage.setCode("400");
                 }
+                try {if(stream!=null){stream.close();}} catch (Exception e) { }
             }
-        }catch (Exception e){
-            e.printStackTrace();
+            returnImage.setCode("200");
+        } catch (Exception e) {
+            try {if(stream!=null){stream.close();}} catch (Exception ex) { }
+            logger.error("OSS上传发生异常：",e);
             returnImage.setCode("500");
         }
         return returnImage;
-
     }
 
-    //初始化
+    // 初始化
     public static Integer Initialize(Keys k) {
         int ret = -1;
-        if(k.getStorageType()!=null && k.getAccessKey() != null && k.getAccessSecret() != null && k.getBucketname() != null
-                && k.getRequestAddress() !=null ) {
-            if(!k.getStorageType().equals("") && !k.getAccessKey().equals("") && !k.getAccessSecret().equals("") && !k.getBucketname().equals("")
-                    && !k.getRequestAddress().equals("") ) {
-                // 初始化
-                // 创建UpYun实例。
-                UpYun upObj= new UpYun(k.getBucketname(), k.getAccessKey(), k.getAccessSecret());
-                List<UpYun.FolderItem> items = null;
-                try {
-                    items = upObj.readDir("/",null);
-                    ret = 1;
-                    upyun = upObj;
-                    key = k;
-                } catch (Exception e) {
-                    System.out.println("USS Object Is null");
-                    ret = -1;
-                }
-            }
+        if (StringUtils.isBlank(k.getAccessKey())
+                || StringUtils.isBlank(k.getKeyname())
+                || StringUtils.isBlank(k.getAccessSecret())
+                || StringUtils.isBlank(k.getEndpoint())
+                || StringUtils.isBlank(k.getBucketname())
+                || StringUtils.isBlank(k.getRequestAddress())
+                || k.getStorageType() == null) {
+            return -1;
+        }
+        UpYun upObj = new UpYun(k.getBucketname(), k.getAccessKey(), k.getAccessSecret());
+        List<UpYun.FolderItem> items = null;
+        try {
+            items = upObj.readDir("/", null);
+            ret = 1;
+            upyun = upObj;
+            key = k;
+        } catch (Exception e) {
+            System.out.println("USS Object Is null");
+            ret = -1;
         }
         return ret;
     }
 
-    public Boolean delUSS(Integer keyID, String fileName) {
+    public Boolean delUSS(Integer keyID, Images images) {
         boolean b = true;
         try {
-            boolean result = upyun.deleteFile(fileName, null);
+            boolean result = upyun.deleteFile(images.getImgname(), null);
         } catch (Exception e) {
             e.printStackTrace();
-            b=false;
+            b = false;
         }
         return b;
     }
-
-
 }

src/main/java/cn/hellohao/service/impl/UploadServicel.java

@@ -1,145 +1,104 @@
 package cn.hellohao.service.impl;
 
-import cn.hellohao.dao.*;
+import cn.hellohao.config.GlobalConstant;
+import cn.hellohao.dao.KeysMapper;
+import cn.hellohao.dao.UploadConfigMapper;
+import cn.hellohao.dao.UserMapper;
 import cn.hellohao.pojo.*;
+import cn.hellohao.service.ConfdataService;
 import cn.hellohao.service.ImgTempService;
 import cn.hellohao.service.SysConfigService;
 import cn.hellohao.utils.*;
-import cn.hutool.core.util.CharsetUtil;
-import cn.hutool.http.HttpUtil;
-import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
-import com.baidu.aip.contentcensor.AipContentCensor;
-import com.baidu.aip.contentcensor.EImgType;
 import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.subject.Subject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
 
 import javax.servlet.http.HttpServletRequest;
-import java.io.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
 import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
 
 /**
  * @author Hellohao
  * @version 1.0
  * @date 2020/1/9 15:46
  */
-
 @Service
 public class UploadServicel {
+    private static Logger logger = LoggerFactory.getLogger(UploadServicel.class);
     @Autowired
-    ConfigMapper configMapper;
+    ConfdataService confdataService;
     @Autowired
     SysConfigService sysConfigService;
-    @Autowired
-    UploadConfigMapper uploadConfigMapper;
-    @Autowired
-    KeysMapper keysMapper;
-    @Autowired
-    ImgMapper imgMapper;
-    @Autowired
-    UserMapper userMapper;
-    @Autowired
-    ImgreviewMapper imgreviewMapper;
-    @Autowired
-    ImgTempService imgTempService;
+    @Autowired private UploadConfigMapper uploadConfigMapper;
+    @Autowired private KeysMapper keysMapper;
+    @Autowired private ImgServiceImpl imgServiceImpl;
+    @Autowired private UserMapper userMapper;
+    @Autowired private ImgTempService imgTempService;
+    @Autowired private GetSource getSource;
+    @Autowired deleImages deleimages;
+    @Autowired ImgViolationJudgeServiceImpl imgViolationJudgeService;
 
-
-
-    public Msg uploadForLoc(HttpServletRequest request,
-                            MultipartFile multipartFile, Integer setday, String imgUrl) {
+    public Msg uploadForLoc(
+            HttpServletRequest request,
+            File file,
+            String imgName,
+            Integer setday,
+            JSONObject imgJson,
+            String md5key) {
         Msg msg = new Msg();
-        try{
+        try {
+            Confdata dataJson = confdataService.selectConfdata("config");
+            JSONObject confdata = JSONObject.parseObject(dataJson.getJsondata());
+            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             JSONObject jsonObject = new JSONObject();
             UploadConfig uploadConfig = uploadConfigMapper.getUpdateConfig();
             String userip = GetIPS.getIpAddr(request);
             Subject subject = SecurityUtils.getSubject();
             User u = (User) subject.getPrincipal();
-            if(null!=u){
-                u =  userMapper.getUsers(u);
+            if (null != u) {
+                u = userMapper.getUsers(u);
             }
             Integer sourceKeyId = 0;
-            String md5key = null;
-            FileInputStream fis = null;
-            File file =null;
-            if(imgUrl==null){
-                file = SetFiles.changeFile_new(multipartFile);
-            }else{
-                //说明是URL上传
-                Msg imgData = uploadForURL(request, imgUrl);
-                if(imgData.getCode().equals("200")){
+            if (imgJson != null) {
+                Msg imgData = uploadForURL(request, imgJson.getString("imgUrl"),imgJson.getString("referer"));
+                if (imgData.getCode().equals("200")) {
                     file = new File((String) imgData.getData());
-                }else{
+                } else {
                     return imgData;
                 }
             }
+            FileInputStream stream = new FileInputStream(file);
             String imguid = UUID.randomUUID().toString().replace("-", "");
-            //判断上传前的一些用户限制信息
-            Msg msg1 = updateImgCheck(u,uploadConfig);
-            if(!msg1.getCode().equals("300")){
+            Msg msg1 = updateImgCheck(u, uploadConfig);
+            if (!msg1.getCode().equals("300")) {
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
                 return msg1;
             }
-
-            //判断可用容量
-            sourceKeyId = group.getKeyid();
-            Keys key = keysMapper.selectKeys(sourceKeyId);
-            Long tmp = (memory == -1 ? -2 : UsedTotleMemory);
-            if (tmp >= memory) {
-                msg.setCode("4005");
-                msg.setInfo(u==null?"游客空间已用尽":"您的可用空间不足");
-                return msg;
-            }
-
-            //判断图片有没有超出设定大小
-            if (file.length() > TotleMemory) {
-                System.err.println("文件大小："+file.length());
-                System.err.println("最大限制："+TotleMemory);
-                msg.setCode("4006");
-                msg.setInfo("图像超出系统限制大小");
-                return msg;
-            }
-            try {
-                fis = new FileInputStream(file);
-                md5key = DigestUtils.md5Hex(fis);
-            } catch (Exception e) {
-                e.printStackTrace();
-                System.out.println("未获取到图片的MD5,成成UUID");
-            }
-            Msg fileMiME = TypeDict.FileMiME(file);
-            if(!fileMiME.getCode().equals("200")) {
-                //非图像文本
-                msg.setCode("4000");
-                msg.setInfo(fileMiME.getInfo());
-                return msg;
-            }
-            if(md5key==null || md5key.equals("")){
-                md5key = UUID.randomUUID().toString().replace("-", "");
-            }
-
-            //判断图片是否存在
-            if(Integer.valueOf(sysConfigService.getstate().getCheckduplicate())==1){
-                Images imaOBJ = new Images();
-                imaOBJ.setMd5key(md5key);
-                imaOBJ.setUserid(u==null?0:u.getId());
-                if(imgMapper.md5Count(imaOBJ)>0){
-                    List<Images>  images = imgMapper.selectImgUrlByMD5(md5key);
-                    jsonObject.put("url", images.get(0).getImgurl());
-                    jsonObject.put("name",file.getName());
-                    jsonObject.put("imguid",images.get(0).getImguid());
-//                    jsonObject.put("shortLink",images.getShortlink());
-                    msg.setData(jsonObject);
-                    return msg;
-                }
-            }
-
-
-            String prefix = file.getName().substring(file.getName().lastIndexOf(".")+1);
-            //判断黑名单
+            JSONObject updateJson = JSONObject.parseObject(msg1.getData().toString());
+            final JSONObject groupJson = updateJson.getJSONObject("group");
+            final Group group = groupJson.toJavaObject(Group.class);
+            Long memory = updateJson.getLong("memory");
+            Long UsedTotleMemory = updateJson.getLong("UsedTotleMemory");
+            Long TotleMemory = updateJson.getLong("TotleMemory");
+            String updatePath = updateJson.getString("updatePath");
             if (uploadConfig.getBlacklist() != null) {
                 String[] iparr = uploadConfig.getBlacklist().split(";");
                 for (String s : iparr) {
@@ -147,239 +106,321 @@ public class UploadServicel {
                         file.delete();
                         msg.setCode("4003");
                         msg.setInfo("你暂时不能上传");
+                        try {
+                            if(stream!=null){stream.close();}
+                            file.delete();
+                        } catch (Exception e) { }
                         return msg;
                     }
                 }
             }
-
-            Map<String, File> map = new HashMap<>();
+            sourceKeyId = group.getKeyid();
+            Keys key = keysMapper.selectKeys(sourceKeyId);
+            Long tmp = (memory == -1 ? -2 : UsedTotleMemory);
+            if (tmp >= memory) {
+                msg.setCode("4005");
+                msg.setInfo(u == null ? "游客空间已用尽" : "您的可用空间不足");
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
+                return msg;
+            }
+            if (file.length() > TotleMemory) {
+                msg.setCode("4006");
+                msg.setInfo("图像超出系统限制大小");
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
+                return msg;
+            }
+            Msg fileMiME = TypeDict.FileMiME(stream);
+            if (!fileMiME.getCode().equals("200")) {
+                msg.setCode("4000");
+                msg.setInfo(fileMiME.getInfo());
+                try {
+                    if(stream!=null){stream.close();}
+                    file.delete();
+                } catch (Exception e) { }
+                return msg;
+            }
+            if (md5key == null || md5key.equals("")) {
+                md5key = DigestUtils.md5Hex(stream);
+//                FileInputStream fis = null;
+//                try {
+//                    fis = new FileInputStream(file);
+//                    md5key = DigestUtils.md5Hex(fis);
+//                } catch (Exception e) {
+//                    logger.error("获取MD5错误",e);
+//                }finally{
+//                    try {
+//                        if (null != fis)
+//                            fis.close();
+//                    } catch (Exception e) {
+//                        e.printStackTrace();
+//                    }
+//                }
+            }
+            String prefix = file.getName().substring(file.getName().lastIndexOf(".") + 1);
+            try {
+                if(stream!=null){stream.close();}
+            } catch (Exception e) { }
+            // 判断路径格式 处理一下，去掉最前面的/
+            String RootPath = key.getRootPath().replace(" ", "");
+            if (!RootPath.equals("/")) {
+                updatePath = RootPath.substring(1) + "/" + updatePath;
+            }
+            // 先存数据库
+            Images imgObj = new Images();
+            String imgnameEd = null;
+            Map<Map<String, String>, File> map = new HashMap<>();
+            String shortUuid_y = SetText.getShortUuid();
+            String shortUuid_s = SetText.getShortUuid();
             if (file.exists()) {
-                map.put(prefix, file);//prefix
+                Map<String, String> m1 = new HashMap<>();
+                m1.put("prefix", prefix);
+                m1.put("name", shortUuid_y);
+                map.put(m1, file);
+                imgnameEd = updatePath + "/" + shortUuid_y + "." + prefix;
+                imgObj.setImgname(imgnameEd);
+                if (key.getStorageType().equals(5)) {
+                    imgObj.setImgurl(confdata.getString("domain") + "/ota/" + imgnameEd);
+                } else if(key.getStorageType().equals(9) && key.getSysTransmit()){
+                    imgObj.setImgurl(confdata.getString("domain") + "/w/" + shortUuid_y);
+                }else {
+                    imgObj.setImgurl(key.getRequestAddress() + "/" + imgnameEd);
+                }
+                imgObj.setSizes(Long.toString(file.length()));
+            }else{
+                msg.setInfo("未获取到指定图像:110503");
+                msg.setCode("110503");
+                try { file.delete(); } catch (Exception e) { }
+                return msg;
+            }
+            imgObj.setUpdatetime(df.format(new Date()));
+            imgObj.setSource(key.getId());
+            imgObj.setUserid(u == null ? 0 : u.getId());
+            if (setday == 1 || setday == 3 || setday == 7 || setday == 30) {
+                imgObj.setImgtype(1);
+                ImgTemp imgDataExp = new ImgTemp();
+                imgDataExp.setDeltime(plusDay(setday));
+                imgDataExp.setImguid(imguid);
+                imgTempService.insertImgExp(imgDataExp);
+            } else {
+                imgObj.setImgtype(0);
             }
+            imgObj.setAbnormal(userip);
+            imgObj.setMd5key(md5key);
+            imgObj.setImguid(imguid);
+            imgObj.setFormat(fileMiME.getData().toString());
+            imgObj.setShortlink(shortUuid_y);
+            imgObj.setBrieflink(shortUuid_s);
+            imgObj.setIdname(imgName);
+//            Integer insertRet = imgMapper.insertImgData(imgObj);
+            Msg insertRet = imgServiceImpl.insertImgDataForCheck(imgObj,u,confdata,file.getName());
+            if (insertRet.getCode().equals("000")) {
+                try { file.delete(); } catch (Exception e) { }
+                return insertRet;
+            }
+
             long stime = System.currentTimeMillis();
-            Map<ReturnImage, Integer> m = null;
-            ReturnImage returnImage = GetSource.storageSource(key.getStorageType(), map, updatePath, key.getId());
-            Images img = new Images();
-            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-            if(returnImage.getCode().equals("200")){
-                String imgurl = returnImage.getImgurl();
-                Long imgsize = returnImage.getImgSize();
-                String imgname = returnImage.getImgname();
-                img.setImgurl(imgurl);
-                img.setUpdatetime(df.format(new Date()));
-                img.setSource(key.getId());
-                img.setUserid(u == null ? 0 : u.getId());
-                img.setSizes(imgsize.toString());
-                if(uploadConfig.getUrltype()==2){
-                    img.setImgname(imgname);
-                }else{
-                    img.setImgname(SetText.getSubString(imgname, key.getRequestAddress() + "/", ""));
-                }
-                if(setday == 1 || setday == 3 || setday == 7 || setday == 30){
-                    img.setImgtype(1);
-                    ImgTemp imgDataExp = new ImgTemp();
-                    imgDataExp.setDeltime(plusDay(setday));
-                    imgDataExp.setImguid(imguid);
-                    imgTempService.insertImgExp(imgDataExp);
-                }else{
-                    img.setImgtype(0);
-                }
-                img.setAbnormal(userip);
-                img.setMd5key(md5key);
-                img.setImguid(imguid);
-                img.setFormat(fileMiME.getData().toString());
-                userMapper.insertimg(img);
+            System.out.println("上传前地址："+updatePath);
+            ReturnImage returnImage = getSource.storageSource(key.getStorageType(), map, updatePath, key.getId());
+            if (returnImage.getCode().equals("200")) {
                 long etime = System.currentTimeMillis();
                 Print.Normal("上传图片所用总时长：" + String.valueOf(etime - stime) + "ms");
-                jsonObject.put("url", img.getImgurl());
-                jsonObject.put("name", imgname);
-                jsonObject.put("imguid",img.getImguid());
-//                jsonObject.put("shortLink", img.getShortlink());
-                new Thread(()->{LegalImageCheck(img);}).start();
-            }else{
+                jsonObject.put("url", imgObj.getImgurl());
+                jsonObject.put("name", imgObj.getImgname());
+                jsonObject.put("imguid", imgObj.getImguid());
+                imgViolationJudgeService.LegalImageCheck(imgObj,key);
+            } else {
+                imgServiceImpl.deleimgForImgUid(imgObj.getImguid());
                 msg.setCode("5001");
                 msg.setInfo("上传服务内部错误");
+                try { file.delete(); } catch (Exception e) { }
                 return msg;
             }
-            file.delete();
             msg.setData(jsonObject);
+            file.delete();
             return msg;
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
             msg.setInfo("上传时发生了一些错误");
             msg.setCode("110500");
+            file.delete();
             return msg;
         }
+    }
 
+    public CompletableFuture<Msg> mergeFile(HttpServletRequest request, String data, User user){
+        Msg msg = new Msg();
+        try{
+            JSONObject jsonObj = JSONObject.parseObject(data);
+            String filename = jsonObj.getString("filename");
+            String uuid = jsonObj.getString("uuid");
+            String md5 = jsonObj.getString("md5");
+            String classifications = jsonObj.getString("classifications");
+            Integer day = jsonObj.getInteger("day");
+            String imgIdentifier = jsonObj.getString("imgIdentifier");
+            JSONArray jsonArray = new JSONArray();
+            classifications = classifications==null?"":classifications;
+            if(!org.apache.commons.lang3.StringUtils.isBlank(classifications)){
+                String[] calssif = classifications.split(",");
+                for (int i = 0; i < calssif.length; i++) {
+                    jsonArray.add(calssif[i]);
+                }
+            }
+            String path = GlobalConstant.HELLOHAOTEMPIMG_PATH+File.separator+uuid+File.separator+imgIdentifier+File.separator+filename;
+//            if(new File(path).exists()){
+//                path = GlobalConstant.HELLOHAOTEMPIMG_PATH+File.separator+UUID.randomUUID().toString().replace("-", "").toLowerCase()+filename;
+//            }
+            String folder = GlobalConstant.HELLOHAOTEMPIMG_PATH+File.separator+uuid+File.separator+imgIdentifier;
+            String delFolder = GlobalConstant.HELLOHAOTEMPIMG_PATH+File.separator+uuid;
+            String originalFilename = filename;
+            if(StringUtils.isBlank(originalFilename)){
+                originalFilename = "未命名图像";
+            }
+            Msg merge = SetFiles.merge(path, folder, filename);
+            if(merge.getCode().equals("200")){
+                File file = new File(path);
+//                CompletableFuture<Msg> ret =
+                msg = uploadForLoc(request, file,originalFilename, day, null,md5);
+//                msg = ret.get();
+            }else{
+                msg = merge;
+            }
+            SetFiles.delFileFolder(new File(delFolder));
+        }catch (Exception e){
+            e.printStackTrace();
+            msg.setCode("500");
+            msg.setInfo("文件上传时发生错误");
+        }
+        return CompletableFuture.completedFuture(msg);
     }
 
 
-    //通过图片Url上传图片
-    public static Msg uploadForURL(HttpServletRequest request, String imgurl){
+    public static Msg uploadForURL(HttpServletRequest request, String imgurls,String referer) {
         final Msg msg = new Msg();
-        //先判断是不是有效链接
-//        final boolean valid = ImgUrlUtil.isValid(imgurl);
-        if(true){
-            Long imgsize = 0L;
-            try {
-//                imgsize = ImgUrlUtil.getFileLength(imgurl);
-                if(imgsize==0){
-//                    String uuid= UUID.randomUUID().toString().replace("-", "");
-                    String ShortUID = SetText.getShortUuid();
-                    String savePath = request.getSession().getServletContext().getRealPath("/")+File.separator+"hellohaotmp"+File.separator;
-                    Map<String ,Object> bl =ImgUrlUtil.downLoadFromUrl (imgurl, ShortUID, savePath);
-                    if((Boolean) bl.get("res")==true){
-//                        File file = new File();
-                        msg.setCode("200");
-                        msg.setData(bl.get("imgPath"));//savePath + File.separator + ShortUID
-                        return msg;
-                    }else{
-                        if(bl.get("StatusCode").equals("110403")){
-                            msg.setInfo("该链接非图像文件，无法上传");
-                        }else{
-                            msg.setInfo("该链接暂时无法上传");
-                        }
-                        msg.setCode("500");
+        String url = imgurls;
+        // 先判断是不是有效链接  并且自动判断协议头http(s)://
+        GetProtocol getProtocol = new GetProtocol();
+        String protocol = getProtocol.getProtocol(url,referer);
+        if (protocol == null) {
+            msg.setInfo("服务器解析该链接失败");
+            msg.setCode("500");
+            return msg;
+        } else {
+            url = protocol;
+        }
+        Long imgsize = 0L;
+        try {
+            if (imgsize == 0) {
+                String ShortUID = SetText.getShortUuid();
+                String savePath =
+                        request.getSession().getServletContext().getRealPath("/")
+                                + File.separator
+                                + "hellohaotmp"
+                                + File.separator;
+                Map<String, Object> bl = ImgUrlUtil.downLoadFromUrl(url,referer, ShortUID, savePath);
+                if ((Boolean) bl.get("res") == true) {
+                    //                        File file = new File();
+                    msg.setCode("200");
+                    msg.setData(bl.get("imgPath")); // savePath + File.separator + ShortUID
+                    return msg;
+                } else {
+                    if (bl.get("StatusCode").equals("110403")) {
+                        msg.setInfo("该链接非图像文件，无法上传");
+                    } else {
+                        msg.setInfo("该链接暂时无法上传");
                     }
-                }else{
                     msg.setCode("500");
-                    msg.setInfo("获取资源失败");
                 }
-            } catch (Exception e) {
+            } else {
                 msg.setCode("500");
                 msg.setInfo("获取资源失败");
             }
-        }else{
+        } catch (Exception e) {
             msg.setCode("500");
-            msg.setInfo("该链接无效");
+            msg.setInfo("获取资源失败");
         }
 
         return msg;
     }
 
-    public static Group group; //上传用户或游客的所属分组
-    public static Long memory;//上传用户或者游客的分配容量 memory
-    public static Long TotleMemory;//用户或者游客下可使用的总容量 //maxsize
-    public static Long UsedTotleMemory;//用户或者游客已经用掉的总容量 //usermemory
-    public static String updatePath="tourist";
+//    private static Group group; // 上传用户或游客的所属分组
+//    private static Long memory; // 上传用户或者游客的分配容量 memory
+//    private static Long TotleMemory; // 用户或者游客下可使用的总容量 //maxsize
+//    private static Long UsedTotleMemory; // 用户或者游客已经用掉的总容量 //usermemory
+//    private static String updatePath = "tourist";
 
-    //判断用户 或 游客 当前上传图片的一系列校验
-    private Msg updateImgCheck(User user, UploadConfig uploadConfig){
-        final Msg msg = new Msg();
-        java.text.DateFormat dateFormat = null;
+    // 判断用户 或 游客 当前上传图片的一系列校验
+    private Msg updateImgCheck(User user, UploadConfig uploadConfig) {
+        Msg msg = new Msg();
+        JSONObject jsonObject = new JSONObject();
+        String updatePath = "tourist";
         try {
-            dateFormat = new SimpleDateFormat("yyyy/MM/dd");
+            Group group = GetCurrentSource.GetSource(user == null ? null : user.getId());
+            jsonObject.put("group",group);
             if (user == null) {
-                //用户没有登陆，值判断游客能不能上传即可
-                if(uploadConfig.getIsupdate()!=1){
+                if (uploadConfig.getIsupdate() != 1) {
                     msg.setCode("1000");
                     msg.setInfo("系统已禁用游客上传");
                     return msg;
                 }
-                group = GetCurrentSource.GetSource(null);
-                memory = Long.valueOf(uploadConfig.getVisitormemory());//单位 B 游客设置总量
-                TotleMemory = Long.valueOf(uploadConfig.getFilesizetourists());//单位 B  游客单文件大小
-                UsedTotleMemory = imgMapper.getusermemory(0)==null?0L : imgMapper.getusermemory(0);//单位 B
+                updatePath = "tourist";
+                Long memory = Long.valueOf(uploadConfig.getVisitormemory()); // 单位 B 游客设置总量
+                Long TotleMemory = Long.valueOf(uploadConfig.getFilesizetourists()); // 单位 B  游客单文件大小
+                Long UsedTotleMemory =
+                        imgServiceImpl.getusermemory(0) == null
+                                ? 0L
+                                : imgServiceImpl.getusermemory(0); // 单位 B
+                jsonObject.put("memory",memory);
+                jsonObject.put("TotleMemory",TotleMemory);
+                jsonObject.put("UsedTotleMemory",UsedTotleMemory);
             } else {
-                //判断用户能不能上传
-                if(uploadConfig.getUserclose()!=1){
+                if (uploadConfig.getUserclose() != 1) {
                     msg.setCode("1001");
                     msg.setInfo("系统已禁用上传功能");
                     return msg;
                 }
                 updatePath = user.getUsername();
-                group= GetCurrentSource.GetSource(user.getId());
-                memory = Long.valueOf(user.getMemory())*1024*1024;//单位 B
-                TotleMemory = Long.valueOf(uploadConfig.getFilesizeuser());//单位 B
-                UsedTotleMemory = imgMapper.getusermemory(user.getId())==null?0L:imgMapper.getusermemory(user.getId());//单位 B
+                Long memory = Long.valueOf(user.getMemory()); // 单位 B  *1024*1024
+                Long TotleMemory = Long.valueOf(uploadConfig.getFilesizeuser()); // 单位 B
+                Long UsedTotleMemory =
+                        imgServiceImpl.getusermemory(user.getId()) == null
+                                ? 0L
+                                : imgServiceImpl.getusermemory(user.getId()); // 单位 B
+                jsonObject.put("memory",memory);
+                jsonObject.put("TotleMemory",TotleMemory);
+                jsonObject.put("UsedTotleMemory",UsedTotleMemory);
             }
             if (uploadConfig.getUrltype() == 2) {
-                updatePath = dateFormat.format(new Date());
+                LocalDate currentDate = LocalDate.now();
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
+                updatePath = currentDate.format(formatter);
             }
+            jsonObject.put("updatePath",updatePath);
+            msg.setData(jsonObject);
             msg.setCode("300");
         } catch (Exception e) {
-            e.printStackTrace();
+            logger.error("updateImgCheck异常：",e);
             msg.setCode("500");
         }
         return msg;
     }
 
-    private synchronized void LegalImageCheck(Images images){
-        System.out.println("非法图像鉴别进程启动");
-        Imgreview imgreview = null;
-        try {
-            imgreview = imgreviewMapper.selectByusing(1);
-        } catch (Exception e) {
-            Print.warning("获取鉴别程序的时候发生错误");
-            e.printStackTrace();
-        }
-        if(null != imgreview){
-            LegalImageCheckForBaiDu(imgreview,images);
-        }
 
-    }
-
-    private void LegalImageCheckForBaiDu(Imgreview imgreview,Images images){
-        System.out.println("非法图像鉴别进程启动-BaiDu");
-        if(imgreview.getUsing()==1){
-            try {
-                AipContentCensor client = new AipContentCensor(imgreview.getAppId(), imgreview.getApiKey(), imgreview.getSecretKey());
-                client.setConnectionTimeoutInMillis(5000);
-                client.setSocketTimeoutInMillis(30000);
-                org.json.JSONObject res = client.antiPorn(images.getImgurl());
-                res = client.imageCensorUserDefined(images.getImgurl(), EImgType.URL, null);
-                System.err.println("返回的鉴黄json:"+res.toString());
-                com.alibaba.fastjson.JSONArray jsonArray = JSON.parseArray("[" + res.toString() + "]");
-                for (Object o : jsonArray) {
-                    com.alibaba.fastjson.JSONObject jsonObject = (com.alibaba.fastjson.JSONObject) o;
-                    com.alibaba.fastjson.JSONArray data = jsonObject.getJSONArray("data");
-                    Integer conclusionType = jsonObject.getInteger("conclusionType");
-                    if(conclusionType!=null){
-                        if (conclusionType == 2) {
-                            for (Object datum : data) {
-                                com.alibaba.fastjson.JSONObject imgdata = (com.alibaba.fastjson.JSONObject) datum;
-                                if (imgdata.getInteger("type") == 1) {
-                                    Images img = new Images();
-                                    img.setImgname(images.getImgname());
-                                    img.setViolation("1[1]");
-                                    imgMapper.setImg(img);
-                                    Imgreview imgv = new Imgreview();
-                                    imgv.setId(1);
-                                    Integer count = imgreview.getCount();
-                                    System.out.println("违法图片总数：" + count);
-                                    imgv.setCount(count + 1);
-                                    imgreviewMapper.updateByPrimaryKeySelective(imgv);
-                                    System.err.println("存在非法图片，进行处理操作");
-                                }
-                            }
-                        }
-                    }
-                }
-
-            }catch (Exception e){
-                System.out.println("图像鉴黄线程执行过程中出现异常");
-                e.printStackTrace();
-
-            }
-
-        }
-    }
-
-
-    //计算时间
-    public static String plusDay(int setday){
+    // 计算时间
+    public static String plusDay(int setday) {
         Date d = new Date();
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-        String currdate = format.format(d);
-        System.out.println("现在的日期是：" + currdate);
         Calendar ca = Calendar.getInstance();
         ca.setTime(d);
-        ca.add(Calendar.DATE, setday);// num为增加的天数，可以改变的
+        ca.add(Calendar.DATE, setday); // num为增加的天数，可以改变的
         d = ca.getTime();
         String enddate = format.format(d);
         System.out.println("到期的日期：" + enddate);
         return enddate;
     }
-
-
 }

src/main/java/cn/hellohao/service/impl/UserServiceImpl.java

@@ -3,7 +3,6 @@ package cn.hellohao.service.impl;
 import cn.hellohao.dao.CodeMapper;
 import cn.hellohao.dao.UserMapper;
 import cn.hellohao.exception.CodeException;
-import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.User;
 import cn.hellohao.service.UserService;
 import cn.hellohao.utils.Print;
@@ -31,17 +30,17 @@ public class UserServiceImpl implements UserService {
         return userMapper.login(email, password,uid);
     }
 
+    @Override
+    public User loginByToken(String token) {
+        return userMapper.loginByToken(token);
+    }
+
     @Override
     public User getUsers(User user) {
         // TODO Auto-generated method stub
         return userMapper.getUsers(user);
     }
 
-    @Override
-    public Integer insertimg(Images img) {
-        // TODO Auto-generated method stub
-        return userMapper.insertimg(img);
-    }
 
     @Override
     public Integer change(User user) {

src/main/java/cn/hellohao/service/impl/WebDAVImageupload.java

@@ -0,0 +1,210 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.config.GlobalConstant;
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Keys;
+import cn.hellohao.pojo.Msg;
+import cn.hellohao.pojo.ReturnImage;
+import cn.hellohao.service.ImgService;
+import cn.hellohao.service.KeysService;
+import cn.hellohao.utils.TypeDict;
+import com.github.sardine.impl.methods.HttpMkCol;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.HttpResponse;
+import org.apache.http.auth.AuthScope;
+import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.client.CredentialsProvider;
+import org.apache.http.client.methods.*;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.FileEntity;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.BasicCredentialsProvider;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+@Service
+public class WebDAVImageupload {
+
+    static CloseableHttpClient httpClient;
+    static Keys key;
+
+    @Autowired
+    private ImgService imgService;
+    @Autowired
+    private KeysService keysService;
+    private static Logger logger = LoggerFactory.getLogger(WebDAVImageupload.class);
+    public ReturnImage ImageuploadWebDAV(Map<Map<String, String>, File> fileMap, String username,Integer keyID) {
+        ReturnImage returnImage = new ReturnImage();
+        try {
+            if(null==httpClient || null==key){
+                System.out.println("WebDAV = 存储源对象为空");
+                returnImage.setCode("500");
+                return returnImage;
+            }
+        } catch (Exception e) {
+            logger.error("ImageuploadWebDAV:61异常",e);
+            System.out.println("WebDAV = 存储源对象为空");
+            returnImage.setCode("500");
+            return returnImage;
+        }
+        File file = null;
+        try {
+            for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+                String prefix = entry.getKey().get("prefix");
+                String ShortUIDName = entry.getKey().get("name");
+                file = entry.getValue();
+                createDirectories(httpClient, key.getEndpoint(),  "/" + username);
+                HttpPut httpPut = new HttpPut(key.getEndpoint() + "/" + username + "/" + ShortUIDName + "." + prefix);
+                FileEntity fileEntity = new FileEntity(file, ContentType.DEFAULT_BINARY);
+                httpPut.setEntity(fileEntity);
+                HttpResponse response = httpClient.execute(httpPut);
+                final int statusCode = response.getStatusLine().getStatusCode();
+                logger.info("WebDav上传响应代码："+statusCode);
+                EntityUtils.consume(response.getEntity());
+                if(statusCode >= 200 && statusCode < 300){
+                    returnImage.setCode("200");
+                }else{
+                    returnImage.setCode(Integer.toString(statusCode));
+                }
+            }
+
+        } catch (Exception e) {
+            logger.error("ImageuploadWebDAV:87异常",e);
+            returnImage.setCode("500");
+        }
+        return returnImage;
+    }
+
+    //webdav初始化
+    public static Integer Initialize(Keys k) {
+        int ret = -1;
+        try {
+            if(k.getSysTransmit()==false){
+                if (StringUtils.isBlank(k.getAccessKey())
+                        || StringUtils.isBlank(k.getAccessSecret())
+                        || StringUtils.isBlank(k.getEndpoint())
+                        || StringUtils.isBlank(k.getRequestAddress())) {
+                    return -1;
+                }
+            }else{
+                if (StringUtils.isBlank(k.getAccessKey())
+                        || StringUtils.isBlank(k.getAccessSecret())
+                        || StringUtils.isBlank(k.getEndpoint())) {
+                    return -1;
+                }
+            }
+            String endpoint = k.getEndpoint();
+            CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
+            credentialsProvider.setCredentials(
+                    new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT),
+                    new UsernamePasswordCredentials(k.getAccessKey(), k.getAccessSecret()));
+            CloseableHttpClient httpClientObj = HttpClients.custom()
+                    .setDefaultCredentialsProvider(credentialsProvider)
+                    .build();
+            HttpUriRequest request = RequestBuilder.create("PROPFIND")
+                    .setUri(endpoint +"/"+ k.getRootPath())
+                    .addHeader("Depth", "1")
+                    .setEntity(new StringEntity(
+                            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" +
+                                    "<D:propfind xmlns:D=\"DAV:\">\n" +
+                                    "  <D:allprop/>\n" +
+                                    "</D:propfind>",
+                            ContentType.create("text/xml", "UTF-8")))
+                    .build();
+            HttpResponse response = httpClientObj.execute(request);
+            System.out.println("=====>"+response.getStatusLine().getStatusCode());
+            if(response.getStatusLine().getStatusCode()==207 || response.getStatusLine().getStatusCode()==404){
+                ret = 1;
+                httpClient = httpClientObj;
+                key = k;
+            }else {
+                return -1;
+            }
+            EntityUtils.consume(response.getEntity());
+        } catch (Exception e) {
+            logger.error("WebDAV初始化失败", e);
+            return -1;
+        }
+        return ret;
+    }
+
+    public Boolean delWebDAV(Integer keyID, Images images) {
+        boolean b = true;
+        try {
+            Keys keys = keysService.selectKeys(images.getSource());
+            String rootPath = keys.getRootPath().equals("/")?"":keys.getRootPath();
+            String fileUrl = keys.getEndpoint()+"/"+images.getImgname();
+            System.err.println("删除缩yuan图："+fileUrl);
+            HttpDelete httpDelete = new HttpDelete(fileUrl);
+            HttpResponse response = httpClient.execute(httpDelete);
+            int statusCode = response.getStatusLine().getStatusCode();
+            if (statusCode == 204) {
+                logger.info("File deleted: " + fileUrl);
+//            checkAndDeleteEmptyParentDirectories(httpClient,fileUrl);
+            } else {
+                logger.error("Failed to delete file: " + fileUrl);
+            }
+            EntityUtils.consume(response.getEntity());
+        } catch (Exception e) {
+            logger.error("WebDav删除异常：",e);
+            b = false;
+        }
+        return b;
+    }
+
+
+    public ResponseEntity<InputStreamResource> getWebDAV(String shortUuid) {
+        boolean b = true;
+        try {
+            Images images = null;
+            images = imgService.selectImgByShortlink(shortUuid);
+            Keys keys = keysService.selectKeys(images.getSource());
+            String rootPath = keys.getRootPath().equals("/")?"":keys.getRootPath();
+            String fileUrl = keys.getEndpoint()+"/"+images.getImgname();
+            HttpGet httpGet = new HttpGet(fileUrl);
+            HttpResponse response = httpClient.execute(httpGet);
+                HttpHeaders headers = new HttpHeaders();
+                headers.add("Content-Type", "image/jpeg");
+                return ResponseEntity.ok()
+                        .headers(headers)
+                        .body(new InputStreamResource(response.getEntity().getContent()));
+        } catch (IOException e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
+        }
+    }
+
+    private static void createDirectories(CloseableHttpClient httpClient, String baseUrl, String directoryPath) throws Exception {
+        String[] directories = directoryPath.split("/");
+        String currentPath = baseUrl;
+        for (String directory : directories) {
+            currentPath += directory + "/";
+            HttpMkCol httpMkCol = new HttpMkCol(currentPath);
+            HttpResponse response = httpClient.execute(httpMkCol);
+            int statusCode = response.getStatusLine().getStatusCode();
+            if (statusCode == 201) {
+                System.out.println("Directory created: " + currentPath);
+            } else if (statusCode == 405) {
+                System.out.println("Directory already exists: " + currentPath);
+            } else {
+                System.err.println("Failed to create directory: " + currentPath);
+            }
+            EntityUtils.consume(response.getEntity());
+        }
+    }
+
+
+}

src/main/java/cn/hellohao/service/impl/deleImages.java

@@ -0,0 +1,180 @@
+package cn.hellohao.service.impl;
+
+import cn.hellohao.pojo.Images;
+import cn.hellohao.pojo.Keys;
+import cn.hellohao.pojo.Msg;
+import cn.hellohao.service.IRedisService;
+import cn.hellohao.service.ImgAndAlbumService;
+import cn.hellohao.service.ImgService;
+import cn.hellohao.service.ImgTempService;
+import cn.hellohao.utils.LocUpdateImg;
+import cn.hellohao.utils.progress.MyProgress;
+import com.alibaba.fastjson.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class deleImages {
+
+  @Autowired private NOSImageupload nosImageupload;
+  @Autowired private OSSImageupload ossImageupload;
+  @Autowired private COSImageupload cosImageupload;
+  @Autowired private KODOImageupload kodoImageupload;
+  @Autowired private USSImageupload ussImageupload;
+  @Autowired private S3Imageupload s3Imageupload;
+  @Autowired private FtpServiceImpl ftpService;
+  @Autowired private WebDAVImageupload webDAVImageupload;
+  @Autowired private ImgAndAlbumService imgAndAlbumService;
+  @Autowired private ImgTempService imgTempService;
+  @Autowired private ImgService imgService;
+  @Autowired private KeysServiceImpl keysService;
+  @Autowired private IRedisService iRedisService;
+
+  public Msg dele(boolean forceDel,String uuid, Long... imgIds) {
+    Msg msg = new Msg();
+    MyProgress myProgress = new MyProgress();
+    myProgress.InitializeDelImg();
+    List<Long> ids = new ArrayList<>();
+    int successCount = 0;
+    List<String> errorIds = new ArrayList<>();
+    for (int i = 0; i < imgIds.length; i++) {
+      // 删除图片
+      boolean isDele = false;
+      try {
+        Images image = imgService.selectByPrimaryKey(imgIds[i]);
+        if (forceDel) {
+          try {
+            imgAndAlbumService.deleteImgAndAlbum(image.getImgurl());
+            imgTempService.delImgAndExp(image.getImguid());
+            imgService.deleimg(image.getId());
+            ids.add(image.getId());
+            successCount++;
+            System.out.println("删除成功加一个" + image.getId());
+          } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println(image.getImgname() + ":图片数据库记录时发生错误");
+            errorIds.add(image.getImgurl());
+          }
+        }
+        Keys key = keysService.selectKeys(image.getSource());
+        if (key.getStorageType() == 1) {
+          isDele = nosImageupload.delNOS(key.getId(), image);
+        } else if (key.getStorageType() == 2) {
+          isDele = ossImageupload.delOSS(key.getId(), image);
+        } else if (key.getStorageType() == 3) {
+          isDele = ussImageupload.delUSS(key.getId(), image);
+        } else if (key.getStorageType() == 4) {
+          isDele = kodoImageupload.delKODO(key.getId(), image);
+        } else if (key.getStorageType() == 5) {
+          isDele = LocUpdateImg.deleteLOCImg(image);
+        } else if (key.getStorageType() == 6) {
+          isDele = cosImageupload.delCOS(key.getId(), image);
+        } else if (key.getStorageType() == 7) {
+          isDele = ftpService.delFTP(key.getId(), image);
+        } else if (key.getStorageType() == 8) {
+          isDele = s3Imageupload.deleS3(key.getId(), image);
+        }else if (key.getStorageType() == 9) {
+          isDele = webDAVImageupload.delWebDAV(key.getId(), image);
+        } else {
+          System.err.println("未获取到对象存储参数，删除失败。");
+        }
+        if (!forceDel) {
+          try {
+            imgAndAlbumService.deleteImgAndAlbum(image.getImgurl());
+            imgTempService.delImgAndExp(image.getImguid());
+            imgService.deleimg(image.getId());
+            ids.add(image.getId());
+            successCount++;
+            System.out.println("删除成功加一个" + image.getId());
+          } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println(image.getImgname() + ":图片数据库记录时发生错误");
+            errorIds.add(image.getImgurl());
+          }
+        }
+
+        if(uuid!=null){
+          myProgress.setDelSuccessCount(successCount);
+          myProgress.setDelSuccessImgList(ids);
+          myProgress.setDelErrorImgListt(errorIds);
+          if (imgIds.length == (i + 1)) {
+            myProgress.setDelOCT(1);
+          } else {
+            myProgress.setDelOCT(0);
+          }
+          iRedisService.setTimeValue(uuid, JSONObject.toJSONString(myProgress), 24L);
+        }
+      } catch (Exception e) {
+        System.err.println("删除的时候发生了一些异常");
+        ids.add(imgIds[i]);
+        successCount++;
+        if(uuid!=null){
+          myProgress.setDelSuccessCount(successCount);
+          myProgress.setDelSuccessImgList(ids);
+          myProgress.setDelErrorImgListt(errorIds);
+          if (imgIds.length == (i + 1)) {
+            myProgress.setDelOCT(1);
+          } else {
+            myProgress.setDelOCT(0);
+          }
+          iRedisService.setTimeValue(uuid, JSONObject.toJSONString(myProgress), 24L);
+        }
+        e.printStackTrace();
+      }
+    }
+    msg.setData(ids);
+    return msg;
+  }
+
+  public Msg dele2(String... imgIds) {
+    Msg msg = new Msg();
+    List<Long> ids = new ArrayList<>();
+    for (int i = 0; i < imgIds.length; i++) {
+      try {
+        Images image = imgService.selectByPrimaryKey(Long.valueOf(imgIds[i]));
+        Keys key = keysService.selectKeys(image.getSource());
+        if (key.getStorageType() == 1) {
+          nosImageupload.delNOS(key.getId(), image);
+        } else if (key.getStorageType() == 2) {
+          ossImageupload.delOSS(key.getId(), image);
+        } else if (key.getStorageType() == 3) {
+          ussImageupload.delUSS(key.getId(), image);
+        } else if (key.getStorageType() == 4) {
+          kodoImageupload.delKODO(key.getId(), image);
+        } else if (key.getStorageType() == 5) {
+          LocUpdateImg.deleteLOCImg(image);
+        } else if (key.getStorageType() == 6) {
+          cosImageupload.delCOS(key.getId(), image);
+        } else if (key.getStorageType() == 7) {
+          ftpService.delFTP(key.getId(), image);
+        } else if (key.getStorageType() == 8) {
+          s3Imageupload.deleS3(key.getId(), image);
+        }else if (key.getStorageType() == 9) {
+          webDAVImageupload.delWebDAV(key.getId(), image);
+        } else {
+          System.err.println("未获取到对象存储参数，删除失败。");
+        }
+        try {
+          imgAndAlbumService.deleteImgAndAlbum(image.getImgurl());
+          imgTempService.delImgAndExp(image.getImguid());
+          imgService.deleimg(image.getId());
+          ids.add(image.getId());
+        } catch (Exception e) {
+          e.printStackTrace();
+          System.err.println(image.getImgname() + ":图片数据库记录时发生错误");
+        }
+      } catch (Exception e) {
+        System.err.println("删除的时候发生了一些异常");
+//        ids.add(Long.valueOf(imgIds[i]));
+        e.printStackTrace();
+      }
+    }
+    msg.setData(ids);
+    return msg;
+  }
+
+
+}

src/main/java/cn/hellohao/utils/Base64Encryption.java

@@ -1,29 +1,51 @@
-package cn.hellohao.utils;
-
-import sun.misc.BASE64Decoder;
-import sun.misc.BASE64Encoder;
-
-import java.io.IOException;
-import java.util.Base64;
- 
-/**
- * Created by Hellohao on 2019-08-27.
- */
-public class Base64Encryption {
-    public static void toBaseCode(String str) {
-        String data = encryptBASE64(str.getBytes());
-    }
-    public static String decryptBASE64(String key)  {
-        byte[] b =null;
-        try {
-            b = (new BASE64Decoder()).decodeBuffer(key);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return  new String(b);
-    }
-    public static String encryptBASE64(byte[] key)  {
-        String string = "SGVsbG9oYW8K";
-        return (new BASE64Encoder()).encodeBuffer(key).replaceAll("\r|\n", "");
-    }
-}
+//package cn.hellohao.utils;
+//
+//import java.io.IOException;
+//import java.util.Base64;
+//
+///**
+// * Created by Hellohao on 2019-08-27.
+// */
+//public class Base64Encryption {
+////    public static void toBaseCode(String str) {
+////        String data = encryptBASE64(str.getBytes());
+////    }
+////    public static String decryptBASE64(String key)  {
+////        byte[] b =null;
+////        try {
+////            b = (new BASE64Decoder()).decodeBuffer(key);
+////        } catch (IOException e) {
+////            e.printStackTrace();
+////        }
+////        return  new String(b);
+////    }
+////    public static String encryptBASE64(byte[] key)  {
+////        String string = "SGVsbG9oYW8K";
+////        return (new BASE64Encoder()).encodeBuffer(key).replaceAll("\r|\n", "");
+////    }
+//
+//
+//    public static void toBaseCode(String str) {
+//        String data = encryptBASE64(str.getBytes());
+//    }
+//
+//    public static String decryptBASE64(String key) {
+//        byte[] b = null;
+//        try {
+//            b = Base64.getDecoder().decode(key);
+//        } catch (IllegalArgumentException e) {
+//            e.printStackTrace();
+//        }
+//        return new String(b);
+//    }
+//
+//    public static String encryptBASE64(byte[] key) {
+//        String string = "SGVsbG9oYW8K";
+//        return Base64.getEncoder().encodeToString(key);
+//    }
+//
+//
+//
+//
+//
+//}

src/main/java/cn/hellohao/utils/Base64ToMultipartFile.java

@@ -0,0 +1,107 @@
+package cn.hellohao.utils;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.*;
+import java.util.Base64;
+
+/**
+ * base64转为multipartFile工具类
+ * base64Convert
+ */
+
+public class Base64ToMultipartFile implements MultipartFile {
+    private final byte[] imgContent;
+    private final String header;
+
+
+
+    public Base64ToMultipartFile (byte[] imgContent, String header) {
+        this.imgContent = imgContent;
+        this.header = header.split(";")[0];
+    }
+
+    @Override
+    public String getName() {
+        return System.currentTimeMillis() + Math.random() + "." + header.split("/")[1];
+    }
+
+    @Override
+    public String getOriginalFilename() {
+        return System.currentTimeMillis() + (int) Math.random() * 10000 + "." + header.split("/")[1];
+    }
+
+    @Override
+    public String getContentType() {
+        return header.split(":")[1];
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return imgContent == null || imgContent.length == 0;
+    }
+
+    @Override
+    public long getSize() {
+        return imgContent.length;
+    }
+
+    @Override
+    public byte[] getBytes() throws IOException {
+        return imgContent;
+    }
+
+    @Override
+    public InputStream getInputStream() throws IOException {
+       ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(imgContent);
+		// 关闭流，不然文件会一直占用资源，无法对其操作
+		byteArrayInputStream.close();
+		return byteArrayInputStream;
+    }
+
+    @Override
+    public void transferTo(File dest) throws IOException, IllegalStateException {
+      	FileOutputStream fileOutputStream = new FileOutputStream(dest);
+		fileOutputStream.write(imgContent);
+		// 关闭流，不然文件会一直占用资源，无法对其操作
+		fileOutputStream.close();
+    }
+
+    /**
+     * base64转multipartFile
+     *
+     * @param base64
+     * @return
+     */
+    public static MultipartFile base64Convert(String base64) {
+//        String[] baseStrs = base64.split(",");
+//        BASE64Decoder decoder = new BASE64Decoder();
+//        byte[] b = new byte[0];
+//        try {
+//            b = decoder.decodeBuffer(baseStrs[1]);
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//        for (int i = 0; i < b.length; ++i) {
+//            if (b[i] < 0) {
+//                b[i] += 256;
+//            }
+//        }
+//        return new Base64ToMultipartFile (b, baseStrs[0]);
+
+        String[] baseStrs = base64.split(",");
+        byte[] b = Base64.getDecoder().decode(baseStrs[1]);
+        for (int i = 0; i < b.length; ++i) {
+            if (b[i] < 0) {
+                b[i] += 256;
+            }
+        }
+        return new Base64ToMultipartFile(b, baseStrs[0]);
+
+    }
+
+
+
+
+}
+

src/main/java/cn/hellohao/utils/FTPUtils.java

@@ -1,324 +0,0 @@
-package cn.hellohao.utils;
-
-import org.apache.commons.net.ftp.FTP;
-import org.apache.commons.net.ftp.FTPClient;
-import org.apache.commons.net.ftp.FTPFile;
-import org.apache.commons.net.ftp.FTPReply;
-import org.apache.log4j.LogManager;
-import org.apache.log4j.Logger;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-/**
- * <p>Title: </p>
- * <p>Description: </p>
- * 
- * @author Hellohao
- * @date 2019年11月10日
- */
-public class FTPUtils {
-	private final Logger LOGGER = LogManager.getLogger(getClass());
-	private FTPClient ftpClient = null;
-	private String server;
-	private int port;
-	private String userName;
-	private String userPassword;
-	public FTPUtils(String server, int port, String userName, String userPassword) {
-		this.server = server;
-		this.port = port;
-		this.userName = userName;
-		this.userPassword = userPassword;
-	}
-
-	public boolean open() {
-		// 判断是否已连接
-		if (ftpClient != null && ftpClient.isConnected()) {
-			return true;
-		}
-		try {
-			ftpClient = new FTPClient();
-			// 连接FTP服务器
-			ftpClient.connect(this.server, this.port);
-			ftpClient.login(this.userName, this.userPassword);
-			int reply = ftpClient.getReplyCode();
-			if (!FTPReply.isPositiveCompletion(reply)) {
-				Print.warning("FTP服务器拒绝连接.");
-				this.close();
-				System.exit(1);
-			}
-			ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
-			ftpClient.enterLocalPassiveMode();
-			return true;
-		} catch (Exception e) {
-			this.close();
-			e.printStackTrace();
-			return false;
-		}
-
-	}
-
-	/**
-	 * <p>Title: 切换到父目录</p>
-	 * <p>Description: </p>
-	 *
-	 * @author Hellohao
-	 * @date 2018年10月11日
-	 *
-	 * @return 切换结果 true：成功， false：失败
-	 */
-	private boolean changeToParentDir() {
-		try {
-			return ftpClient.changeToParentDirectory();
-		} catch (IOException e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * 
-	 * @param dir 目的目录
-	 * @return 切换结果 true：成功，false：失败
-	 */
-	private boolean cd(String dir) {
-		try {
-			return ftpClient.changeWorkingDirectory(dir);
-		} catch (IOException e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * 
-	 * @param filePath 指定的目录
-	 * @return 文件列表,或者null
-	 */
-	private FTPFile[] getFileList(String filePath) {
-		try {
-			return ftpClient.listFiles(filePath);
-		} catch (IOException e) {
-			e.printStackTrace();
-			return null;
-		}
-	}
-
-	/**
-	 * 
-	 * @param ftpPath 目的目录
-	 * @return 切换结果
-	 */
-	public boolean changeDir(String ftpPath) {
-		if (!ftpClient.isConnected()) {
-			return false;
-		}
-		try {
-			char[] chars = ftpPath.toCharArray();
-			StringBuffer sbStr = new StringBuffer(256);
-			for (int i = 0; i < chars.length; i++) {
-				if ('\\' == chars[i]) {
-					sbStr.append('/');
-				} else {
-					sbStr.append(chars[i]);
-				}
-			}
-			ftpPath = sbStr.toString();
-			if (ftpPath.indexOf('/') == -1) {
-				// 只有一层目录
-				ftpClient.changeWorkingDirectory(new String(ftpPath.getBytes(), "UTF-8"));
-			} else {
-				// 多层目录循环创建
-				String[] paths = ftpPath.split("/");
-				for (int i = 0; i < paths.length; i++) {
-					ftpClient.changeWorkingDirectory(new String(paths[i].getBytes(), "UTF-8"));
-				}
-			}
-			return true;
-		} catch (Exception e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * @param ftpPath 需要创建的目录
-	 * @return
-	 */
-	public boolean mkDir(String ftpPath) {
-		if (!ftpClient.isConnected()) {
-			return false;
-		}
-		try {
-			// 将路径中的斜杠统一
-			char[] chars = ftpPath.toCharArray();
-			StringBuffer sbStr = new StringBuffer(256);
-			for (int i = 0; i < chars.length; i++) {
-				if ('\\' == chars[i]) {
-					sbStr.append('/');
-				} else {
-					sbStr.append(chars[i]);
-				}
-			}
-			ftpPath = sbStr.toString();
-			if (ftpPath.indexOf('/') == -1) {
-				// 只有一层目录
-				ftpClient.makeDirectory(new String(ftpPath.getBytes(), "UTF-8"));
-				ftpClient.changeWorkingDirectory(new String(ftpPath.getBytes(), "UTF-8"));
-			} else {
-				// 多层目录循环创建
-				String[] paths = ftpPath.split("/");
-				for (int i = 0; i < paths.length; i++) {
-					ftpClient.makeDirectory(new String(paths[i].getBytes(), "UTF-8"));
-					ftpClient.changeWorkingDirectory(new String(paths[i].getBytes(), "UTF-8"));
-				}
-			}
-			return true;
-		} catch (Exception e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * 
-	 * @param //localDirectoryAndFileName 本地文件目录和文件名
-	 * @param ftpFileName 上传到服务器的文件名()
-	 * @param ftpDirectory FTP目录如:/path1/pathb2/,如果目录不存在会自动创建目录(目录可以省略)
-	 * @return
-	 */
-	public boolean upload(File srcFile, String ftpFileName, String ftpDirectory) {
-		if (!ftpClient.isConnected()) {
-			return false;
-		}
-		boolean flag = false;
-		if (ftpClient != null) {
-			FileInputStream fis = null;
-			try {
-				fis = new FileInputStream(srcFile);
-				// 创建目录
-				this.mkDir(ftpDirectory);
-				ftpClient.setBufferSize(100000);
-				ftpClient.setControlEncoding("UTF-8");
-				// 设置文件类型（二进制）
-				ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
-
-				if (ftpFileName == null || ftpFileName == "") {
-					ftpFileName = srcFile.getName();
-				}
-				// 上传
-				flag = ftpClient.storeFile(new String(ftpFileName.getBytes(), "UTF-8"), fis);
-			} catch (Exception e) {
-				this.close();
-				e.printStackTrace();
-				return false;
-			} finally {
-				try {
-					fis.close();
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
-			}
-		}
-		return flag;
-	}
-
-	/**
-	 * @param ftpDirectoryAndFileName ftp服务器文件路径，以/dir形式开始
-	 * @param localDirectoryAndFileName 保存到本地的目录
-	 * @return
-	 */
-	public boolean get(String ftpDirectoryAndFileName, String localDirectoryAndFileName) {
-		if (!ftpClient.isConnected()) {
-			return false;
-		}
-		ftpClient.enterLocalPassiveMode();
-		try {
-			// 将路径中的斜杠统一
-			char[] chars = ftpDirectoryAndFileName.toCharArray();
-			StringBuffer sbStr = new StringBuffer(256);
-			for (int i = 0; i < chars.length; i++) {
-				if ('\\' == chars[i]) {
-					sbStr.append('/');
-				} else {
-					sbStr.append(chars[i]);
-				}
-			}
-			ftpDirectoryAndFileName = sbStr.toString();
-			String filePath = ftpDirectoryAndFileName.substring(0, ftpDirectoryAndFileName.lastIndexOf("/"));
-			String fileName = ftpDirectoryAndFileName.substring(ftpDirectoryAndFileName.lastIndexOf("/") + 1);
-			this.changeDir(filePath);
-			ftpClient.retrieveFile(new String(fileName.getBytes(), "UTF-8"), new FileOutputStream(localDirectoryAndFileName)); // download
-			return true;
-		} catch (IOException e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * 
-	 * @param pathName
-	 * @return
-	 */
-	public String[] getFileNameList(String pathName) {
-		try {
-			return ftpClient.listNames(pathName);
-		} catch (IOException e) {
-			e.printStackTrace();
-			return null;
-		}
-	}
-
-	/**
-	 * <p>Title: 删除FTP上的文件</p>
-	 * <p>Description: </p>
-	 * @param ftpDirAndFileName 路径开头不能加/，比如应该是test/filename1
-	 * @return
-	 */
-	public boolean deleteFile(String ftpDirAndFileName) {
-		if (!ftpClient.isConnected()) {
-			return false;
-		}
-		try {
-			return ftpClient.deleteFile(ftpDirAndFileName);
-		} catch (IOException e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * @param ftpDirectory
-	 * @return
-	 */
-	public boolean deleteDirectory(String ftpDirectory) {
-		if (!ftpClient.isConnected()) {
-			return false;
-		}
-		try {
-			return ftpClient.removeDirectory(ftpDirectory);
-		} catch (IOException e) {
-			e.printStackTrace();
-			return false;
-		}
-	}
-
-	/**
-	 * <p>Title: 关闭链接</p>
-	 * <p>Description: </p>
-	 */
-	public void close() {
-		try {
-			if (ftpClient != null && ftpClient.isConnected()) {
-				ftpClient.disconnect();
-			}
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-	}
-
-
-}

src/main/java/cn/hellohao/utils/FirstRun.java

@@ -1,14 +1,15 @@
 package cn.hellohao.utils;
 
 import cn.hellohao.config.GlobalConstant;
-import org.omg.CORBA.Environment;
+import cn.hutool.core.io.FileUtil;import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.InitializingBean;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Configuration;
 
+import java.io.BufferedWriter;
 import java.io.File;
-import java.sql.SQLException;
+import java.io.FileWriter;
 import java.util.Properties;
 import java.util.UUID;
 
@@ -19,7 +20,7 @@ import java.util.UUID;
  */
 @Configuration
 public class FirstRun implements InitializingBean {
-
+    private static Logger logger = LoggerFactory.getLogger(FirstRun.class);
     @Value("${spring.datasource.username}")
     private String jdbcusername;
 
@@ -29,25 +30,37 @@ public class FirstRun implements InitializingBean {
     @Value("${spring.datasource.url}")
     private String jdbcurl;
 
+    @Value("${DockerWebHost}")
+    private String DockerWebHost;
+
+
     @Override
     public void afterPropertiesSet() {
+        if(!DockerWebHost.contains("null")){
+            contentToTxt("/hellohaotbed/webapps/hellohao/config.json", "{\"serverHost\": \""+DockerWebHost+"\"}");
+        }
         isWindows();
         RunSqlScript.USERNAME = jdbcusername;
         RunSqlScript.PASSWORD = jdbcpass;
         RunSqlScript.DBURL = jdbcurl;
-        Print.Normal("正在校验数据库参数...");
+        logger.info("正在校验数据库参数...");
         RunSqlScript.RunInsert(dynamic);
         RunSqlScript.RunInsert(compressed);
 
         String uid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
         RunSqlScript.RunInsert("update user set uid='"+uid+"' where id = 1");
 
+        Integer ret0 =
+                RunSqlScript.RunSelectCount(judgeTable + "'keys' and column_name = 'Region'");
+        if (ret0 == 0) {
+            RunSqlScript.RunInsert(sql0);
+            Print.Normal("Add keys.Region||RootPath");
+        }
+
         Integer ret1 = RunSqlScript.RunSelectCount(sql1);
         if(ret1==0){
             Print.Normal("In execution...");
             RunSqlScript.RunInsert(sql2);
-            ;
-
         }else{
             if(ret1>0){
                 Print.Normal("Stage 1");
@@ -80,50 +93,83 @@ public class FirstRun implements InitializingBean {
             RunSqlScript.RunInsert(sql8);
             Print.Normal("Stage 6");
         }
-        Integer ret5 = RunSqlScript.RunSelectCount(judgeTable+"'config' and column_name = 'theme'");
-        if(ret5==0){
-            RunSqlScript.RunInsert(sql9);
-            Print.Normal("Stage 7");
+
+        Integer ret6 = RunSqlScript.RunSelectCount(judgeTable+" 'user' and column_name = 'token'");
+        if(ret6==0){
+            RunSqlScript.RunInsert(sql12);
+            Print.Normal("Add user.token");
         }
-
-//        Integer ret6 = RunSqlScript.RunSelectCount(judgeTable+"'imgandalbum' and column_name = 'notes' and TABLE_SCHEMA='picturebed'");
-//        if(ret6==0){
-//            RunSqlScript.RunInsert(sql11);
-//            Print.Normal("Stage 8");
-//        }
-
-        RunSqlScript.RunInsert(sql10);
-
-        //RunSqlScript.RunInsert("alter table imgdata drop index index_md5key_url");
-        RunSqlScript.RunInsert(inddx_md5key);
-        RunSqlScript.RunInsert("UPDATE `keys` SET `Endpoint` = '0' WHERE `id` = 8");
+        Integer isappclient = RunSqlScript.RunSelectCount(isTableName+"'appclient'");
+        if(isappclient==0){
+            Integer integer = RunSqlScript.RunInsert(createAppclient);
+            RunSqlScript.RunInsert(instartAppclient);
+            Print.Normal("Add table.appclient");
+        }
+        Integer isconfdata = RunSqlScript.RunSelectCount(isTableName+"'confdata'");
+        if(isconfdata==0){
+            RunSqlScript.RunInsert(createConfdata);
+            RunSqlScript.RunInsert(instartConfdata);
+            Print.Normal("Add table.confdata");
+        }
+        Integer ret7 =
+                RunSqlScript.RunSelectCount(judgeTable + " 'keys' and column_name = 'SysTransmit'");
+        if (ret7 == 0) {
+            RunSqlScript.RunInsert(sql7);
+            Print.Normal("Add keys.SysTransmit");
+        }
+        Integer ret8 =
+                RunSqlScript.RunSelectCount(judgeTable + " 'imgdata' and column_name = 'brieflink'");
+        if (ret8 == 0) {
+            RunSqlScript.RunInsert(sql8);
+            Print.Normal("Add imgdata.brieflink");
+        }
+        Integer ret9 =
+                RunSqlScript.RunSelectCount(judgeTable + " 'imgdata' and column_name = 'shortlink'");
+        if (ret9 == 0) {
+            RunSqlScript.RunInsert(sql9);
+            Print.Normal("Add imgdata.shortlink");
+        }
+        Integer ret10 =
+                RunSqlScript.RunSelectCount(" select count(*) from tbed.keys where storageType='9'");
+        if (ret10 == 0) {
+            RunSqlScript.RunInsert(sql10);
+            Print.Normal("Add Webdav Config");
+        }
+        RunSqlScript.RunInsert(index_imgdata);
+        RunSqlScript.RunInsert("ALTER TABLE tbed.`user` MODIFY id int auto_increment;");
         Print.Normal("Stage success");
 
         clears();
     }
 
     //检查表是否存在，后边加'imgdata' and column_name = 'explains'  检查字段是否存在
-    private String judgeTable = "select count(*) from information_schema.columns where table_name = ";
-    //创建blacklist  2019-11-29
+    private String isTableName = "SELECT count(table_name) FROM information_schema.TABLES WHERE TABLE_SCHEMA='tbed' and table_name =";
+    private String judgeTable = "select count(*) from information_schema.columns where TABLE_SCHEMA='tbed' and table_name = ";
+    private String sql0 =
+            "alter table `keys` add (Region varchar(255) DEFAULT null,RootPath varchar(255) DEFAULT '/');";
     private String sql1 = "select count(*) from information_schema.columns where table_name = 'uploadconfig' and column_name = 'blacklist'";
     private String sql2 = "alter table uploadconfig add blacklist varchar(500);";
-    //创建imgandalbum和album  添加imgdata表字段explain 2019-12-20
+    //创建imgandalbum和album 添加imgdata表字段explain 2019-12-20
     private String sql3 ="CREATE TABLE `imgandalbum`  (`imgname` varchar(5000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,`albumkey` varchar(5000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic";
     private String sql4 ="CREATE TABLE `album`  (`albumkey` varchar(5000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,`albumtitle` varchar(5000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,`createdate` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, `password` varchar(5000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic";
     private String sql6 = "alter table imgdata add explains varchar(5000)";
-    //添加album表字段userid
-    private String sql7 = "alter table album add userid int(10)";
-    //添加imgdata表字段md5key
-    private String sql8 = "alter table imgdata add md5key varchar(5000)";
-    private String sql9 = "ALTER TABLE config ADD theme int(4) DEFAULT '1' COMMENT '主题'  ";
-//修改字段长度
-    private String sql10 = "alter table config modify column `explain` varchar(1000),modify column links varchar(1000),modify column notice varchar(1000),modify column baidu varchar(1000)";
+    private String sql7 =
+            "alter table `keys` add SysTransmit varchar(50) DEFAULT NULL ;";
+    private String sql8 = "alter table `imgdata` add brieflink varchar(100) DEFAULT null ;";
+    private String sql9 = "alter table `imgdata` add shortlink varchar(100) DEFAULT null ;";
+    //  图片标识名字段
+    private String sql10 = "INSERT INTO `tbed`.`keys`(`id`, `AccessKey`, `AccessSecret`, `Endpoint`, `Bucketname`, `RequestAddress`, `storageType`, `keyname`, `Region`, `RootPath`, `SysTransmit`) VALUES (null, '账号', '密码', '连接', '', '存储源请求域名', 9, 'WebDAV', NULL, '/', NULL);";
 
-    //添加imgandalbum字段notes(添加画廊图片说明)
-//    private String sql11 = "alter table imgandalbum add notes varchar(1000) DEFAULT ' '";
+    private String sql12 = "alter table tbed.user add `token` varchar(255)";
+    //创建客户端程序相关表
+    private String createAppclient = "CREATE TABLE `appclient`  (`id` varchar(10) NOT NULL,`isuse` varchar(10) NOT NULL,`winpackurl` varchar(255) NULL DEFAULT NULL,`macpackurl` varchar(255) NULL DEFAULT NULL,`appname` varchar(20) NULL,`applogo` varchar(255) NULL,`appupdate` varchar(10) NOT NULL) ";
+    private String instartAppclient = "INSERT INTO `appclient` VALUES ('app', 'on', NULL, NULL, 'Hellohao图像托管', 'https://hellohao.nos-eastchina1.126.net/TbedClient/app.png', '1.0.1');";
+    //创建confdata表
+    private String createConfdata = "CREATE TABLE tbed.confdata ( `key` varchar(100) NULL, jsondata LONGTEXT NULL )";
+    private String instartConfdata =
+      "INSERT INTO tbed.confdata VALUES ('config', '{\\\"sourcekey\\\":7,\\\"emails\\\":1,\\\"webname\\\":\\\"Hellohao图床\\\",\\\"explain\\\":\\\"Hellohao图像托管，是一家免费开源的图像托管，即时分享你的美好瞬间。\\\",\\\"links\\\":\\\"<p style=\\\\\\\"color:#7c7c88;\\\\\\\">© 2019 <a href=\\\\\\\"http://www.Hellohao.cn/\\\\\\\" target=\\\\\\\"_blank\\\\\\\" title=\\\\\\\"Hellohao\\\\\\\">Hellohao</a><span>  - All Rights Reserved</span> </p>\\\",\\\"notice\\\":\\\"也许...|这将是最好用的图床|为了更好的用户体验，建议您注册本站继续免费使用Hellohao图床。本站不得上传任何形式的非法图片，一旦发现，永久删除并禁封账户。情节严重者将相关资料交于相关部门处理。\\\",\\\"domain\\\":\\\"http://127.0.0.1:10088\\\",\\\"background1\\\":\\\"\\\",\\\"sett\\\":\\\"1\\\",\\\"webms\\\":\\\"Hellohao图像托管，是一家免费开源的图像托管，即时分享你的美好瞬间。\\\",\\\"webkeywords\\\":\\\"hellohao图床,图床,图片上传,开源图床,hellohao,图像托管，图片分享\\\",\\\"theme\\\":2,\\\"websubtitle\\\":\\\"这将是你用过最优秀的图像托管程序\\\",\\\"logo\\\":null,\\\"aboutinfo\\\":\\\"<img width=\\\\\\\"300px\\\\\\\" src=\\\\\\\"http://img.wwery.com/hellohao/rPscRYwz.png\\\\\\\">            <br />            <br />            <p>也许,这将是你用到最优秀的图像托管程序</p>            <p>本程序为Hellohao图象托管程序</p>            <br/>            <p style=\\\\\\\"color: #656565;\\\\\\\">作者：hellohao独立开发</p>            <p style=\\\\\\\"color: #656565;\\\\\\\">www.hellohao.cn</p>\\\"}');";
 
-    private String inddx_md5key = "ALTER TABLE imgdata ADD INDEX index_md5key_url ( md5key,imgurl)";
-    //                             create index yarn_app_result_i4 on yarn_app_result (flow_exec_id(100), another_column(50));
+    private String index_imgdata = "ALTER TABLE imgdata ADD INDEX index_md5key_url ( id,md5key,imgname,imgurl,idname,imguid)";
 
     private String dynamic = "alter table imgdata row_format=dynamic";
     private String compressed = "alter table imgdata row_format=compressed";
@@ -135,14 +181,15 @@ public class FirstRun implements InitializingBean {
         //判断目录有没有创建
         File file = new File(GlobalConstant.LOCPATH);
         if(!file.exists()){
-            file.mkdirs();
-            file1.mkdirs();
-            file2.mkdirs();
+            FileUtil.mkdir(file);
+            FileUtil.mkdir(file1);
+            FileUtil.mkdir(file2);
+
         }else{
             if(!file1.exists()){
-                file1.mkdirs();
+                FileUtil.mkdir(file1);
             }else if(!file2.exists()){
-                file2.mkdirs();
+                FileUtil.mkdir(file2);
             }
         }
     }
@@ -158,4 +205,31 @@ public class FirstRun implements InitializingBean {
         return System.getProperties().getProperty("os.name").toUpperCase().indexOf("WINDOWS") != -1;
     }
 
+    public static void contentToTxt(String filePath, String content) {
+//        String str = new String(); //原有txt内容
+        String s1 = new String();//内容更新
+        try {
+            File f = new File(filePath);
+            if (f.exists()) {
+                logger.info("文件存在");
+            } else {
+                logger.info("文件不存在,准备创建");
+//                f.createNewFile();// 不存在则创建
+                FileUtil.createTempFile(f);
+            }
+//            BufferedReader input = new BufferedReader(new FileReader(f));
+//            while ((str = input.readLine()) != null) {
+//                s1 += str + "\n";
+//            }
+//            input.close();
+            s1 += content + "\n";
+            BufferedWriter output = new BufferedWriter(new FileWriter(f));
+            output.write(s1);
+            output.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+
+        }
+    }
+
 }

src/main/java/cn/hellohao/utils/GetCurrentSource.java

@@ -39,8 +39,6 @@ public class GetCurrentSource {
         userService = userServiceImpl;
     }
 
-
-
     public static Group GetSource(Integer userid) {
         //UserType 0-未分配 1-游客 2-用户 3-管理员
         User user =null;

src/main/java/cn/hellohao/utils/GetProtocol.java

@@ -0,0 +1,89 @@
+package cn.hellohao.utils;
+
+import java.net.HttpURLConnection;
+import java.net.URL;
+import org.apache.commons.lang3.StringUtils;
+
+public class  GetProtocol {
+    private final  static String HTTP= "http://";
+    private final  static  String HTTPS =  "https://";
+    private String newurl;
+
+    //判断协议 能连接上则协议正确
+    public  String getProtocol(String url,String referer) {
+        newurl = clearUrl(url);
+        url = HTTP + newurl;
+        if (exists(url,referer)) {
+            return url;
+        } else {
+            url = HTTPS + newurl;
+            if (exists(url,referer)) {
+                return url;
+            } else {
+                return null;
+            }
+        }
+ 
+    }
+    //清除URL里多余的符号
+    private  String clearUrl(String url) {
+        if (url.contains(HTTP)) {
+            url = url.substring(url.lastIndexOf(HTTP) + HTTP.length());
+            for (int i = 0; i < url.length(); i++) {
+                if (url.charAt(i) == '/' || url.charAt(i) == '.'
+                        || url.charAt(i) == '\\') {
+                } else {
+                    url = url.substring(i);
+                    return url;
+                }
+            }
+        } else if (url.contains(HTTPS)) {
+            url = url.substring(url.lastIndexOf(HTTPS) + HTTPS.length());
+            for (int i = 0; i < url.length(); i++) {
+                if (url.charAt(i) == '/' || url.charAt(i) == '.'
+                        || url.charAt(i) == '\\') {
+                } else {
+                    url = url.substring(i);
+                    return url;
+                }
+            }
+        }else{
+            for (int i = 0; i < url.length(); i++) {
+                if (url.charAt(i) == '/' || url.charAt(i) == '.'
+                        || url.charAt(i) == '\\') {
+                } else {
+                    url = url.substring(i);
+                    return url;
+                }
+            }
+        }
+        return url;
+    }
+    //是否能连接上
+   private boolean exists(String url,String referer) {
+        try {
+            HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
+            con.setConnectTimeout(3000);
+            con.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36");
+            con.setRequestProperty("referer", StringUtils.isBlank(referer)?"no-referrer":referer);
+            System.out.println(con.getResponseCode() );
+            return (con.getResponseCode() == 200);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    public static void main(String[] args){
+
+        try {
+            String url = "https://img-blog.csdnimg.cn/cbf3201a3cfe4fc38a7cef006487158c.png";
+            URL obj = new URL(url);
+            HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+            String referer = con.getRequestProperty("Referer");
+            System.out.println("Referer: " + referer);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/cn/hellohao/utils/GetSource.java

@@ -3,7 +3,8 @@ package cn.hellohao.utils;
 import cn.hellohao.exception.StorageSourceInitException;
 import cn.hellohao.pojo.ReturnImage;
 import cn.hellohao.service.impl.*;
-import org.springframework.web.multipart.MultipartFile;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
 
 import java.io.File;
 import java.util.Map;
@@ -13,15 +14,26 @@ import java.util.Map;
  * @version 1.0
  * @date 2019/11/7 17:12
  */
+@Service
 public class GetSource {
-    public static ReturnImage  storageSource(Integer type, Map<String, File> fileMap, String userpath,Integer keyID){
-        NOSImageupload nosImageupload = SpringContextHolder.getBean(NOSImageupload.class);
-        OSSImageupload ossImageupload = SpringContextHolder.getBean(OSSImageupload.class);
-        USSImageupload ussImageupload = SpringContextHolder.getBean(USSImageupload.class);
-        KODOImageupload kodoImageupload = SpringContextHolder.getBean(KODOImageupload.class);
-        COSImageupload cosImageupload = SpringContextHolder.getBean(COSImageupload.class);
-        FTPImageupload ftpImageupload = SpringContextHolder.getBean(FTPImageupload.class);
-        UFileImageupload uFileImageupload = SpringContextHolder.getBean(UFileImageupload.class);
+
+    @Autowired
+    NOSImageupload nosImageupload;
+    @Autowired
+    OSSImageupload ossImageupload;
+    @Autowired
+    USSImageupload ussImageupload;
+    @Autowired
+    KODOImageupload kodoImageupload;
+    @Autowired
+    COSImageupload cosImageupload;
+    @Autowired
+    FtpServiceImpl ftpService;
+    @Autowired
+    S3Imageupload s3Imageupload;
+    @Autowired
+    WebDAVImageupload webDAVImageupload;
+    public ReturnImage storageSource(Integer type, Map<Map<String, String>, File> fileMap, String userpath,Integer keyID){
         ReturnImage returnImage = null;
         try {
             if(type==1){
@@ -37,9 +49,11 @@ public class GetSource {
             }else if(type==6){
                 returnImage = cosImageupload.ImageuploadCOS(fileMap, userpath,keyID);;
             }else if(type==7){
-                returnImage =  ftpImageupload.ImageuploadFTP(fileMap, userpath,keyID);
+                returnImage =  ftpService.FtpUploadFile(fileMap, userpath,keyID);
             }else if(type==8){
-                returnImage =  uFileImageupload.ImageuploadUFile(fileMap, userpath,keyID);
+                returnImage =  s3Imageupload.ImageuploadS3(fileMap, userpath,keyID);
+            }else if(type==9){
+                returnImage =  webDAVImageupload.ImageuploadWebDAV(fileMap, userpath,keyID);
             }
             else{
                 new StorageSourceInitException("GetSource类捕捉异常：未找到存储源");

src/main/java/cn/hellohao/utils/ImgUrlUtil.java

@@ -2,6 +2,7 @@ package cn.hellohao.utils;
 
 import cn.hellohao.TbedApplication;
 import cn.hellohao.pojo.Msg;
+import org.apache.commons.lang3.StringUtils;
 
 import java.io.*;
 import java.net.HttpURLConnection;
@@ -64,7 +65,7 @@ public class ImgUrlUtil {
             httpUrlConnection.setConnectTimeout(300000);
             httpUrlConnection.setReadTimeout(300000);
             httpUrlConnection.connect();
-            String code = new Integer(httpUrlConnection.getResponseCode()).toString();
+            String code = Integer.toString(httpUrlConnection.getResponseCode());
             String message = httpUrlConnection.getResponseMessage();
             System.out.println("getResponseCode code ="+ code);
             System.out.println("getResponseMessage message ="+ message);
@@ -74,7 +75,7 @@ public class ImgUrlUtil {
                 throw new Exception("ResponseCode is not begin with 2,code="+code);
             }
             map.put("Check","true");
-            System.out.println("连接正常");
+//            System.out.println("连接正常");
         }catch(Exception ex){
             System.out.println(ex.getMessage());
         }
@@ -83,15 +84,8 @@ public class ImgUrlUtil {
     }
 
 
-    /**
-     * 从网络Url中下载文件
-     * @param urlStr
-     * @param fileName
-     * @param savePath
-     * @throws IOException
-     */
-    public static Map<String ,Object>  downLoadFromUrl(String urlStr,String fileName,String savePath){
-
+    public static Map<String ,Object>  downLoadFromUrl(String urlStr,String referer,String fileName,String savePath){
+        FileInputStream fileInputStream = null;
         Map<String ,Object> resmap = new HashMap<>();
         Map<String ,String> map = checkURLStatusCode(urlStr);
         if(map.size()==0 || map.get("Check").equals("false")){
@@ -102,11 +96,11 @@ public class ImgUrlUtil {
         try {
             URL url = new URL(urlStr);
             HttpURLConnection conn = (HttpURLConnection)url.openConnection();
+            conn.setRequestProperty("referer", StringUtils.isBlank(referer) ? "no-referrer" : referer);
             //设置超时间为3秒
             conn.setConnectTimeout(5*1000);
             //防止屏蔽程序抓取而返回403错误
-            conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
-
+            conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36");
             //得到输入流
             InputStream inputStream = conn.getInputStream();
             //获取自己数组
@@ -125,9 +119,9 @@ public class ImgUrlUtil {
                 inputStream.close();
             }
             //下载并且保存成功后 判断格式 如果不是图像格式 就删除
-//
             if(new File(saveDir+File.separator+fileName).exists()){
-                Msg msg = TypeDict.FileMiME(file);
+                fileInputStream = new FileInputStream(file);
+                Msg msg = TypeDict.FileMiME(fileInputStream);
                 if(msg.getCode().equals("200")){
                     File f = new File(saveDir+File.separator+fileName);
                     String imgPath = saveDir+File.separator+fileName+"."+(msg.getData().toString().replace("image/",""));
@@ -144,18 +138,22 @@ public class ImgUrlUtil {
                 resmap.put("res",false);
                 resmap.put("StatusCode","500");
             }
-
-
+            if(fileInputStream!=null){
+                fileInputStream.close();
+            }
             return resmap;
         }catch (Exception e){
-            e.printStackTrace();
+            try{
+                if(fileInputStream!=null){
+                    fileInputStream.close();
+                }
+            }catch (Exception e2){ }
             resmap.put("res",false);
             resmap.put("StatusCode","500");
             return resmap;
         }
     }
 
-
     /**
      * 从输入流中获取字节数组
      * @param inputStream

src/main/java/cn/hellohao/utils/LocUpdateImg.java

@@ -1,25 +1,25 @@
 package cn.hellohao.utils;
 
 import cn.hellohao.config.GlobalConstant;
+import cn.hellohao.pojo.Images;
 import cn.hellohao.pojo.Keys;
 import cn.hellohao.pojo.ReturnImage;
-import cn.hellohao.pojo.UploadConfig;
 import cn.hellohao.service.impl.KeysServiceImpl;
-import org.springframework.web.multipart.MultipartFile;
 
 import java.io.*;
-import java.util.Date;
-import java.util.HashMap;
 import java.util.Map;
-import java.util.UUID;
 
 public class LocUpdateImg {
-    public static boolean deleteLOCImg(String imagename){
+    public static boolean deleteLOCImg(Images images){
         boolean isDele = false;
         try {
-            String filePath = GlobalConstant.LOCPATH + File.separator+imagename;
+            String filePath = GlobalConstant.LOCPATH + File.separator+images.getImgname();
             File file = new File(filePath);
-            isDele = file.delete();
+            if(file.exists()){
+                isDele = file.delete();
+            }else{
+                isDele = true;
+            }
         }catch (Exception e){
             e.printStackTrace();
             isDele = false;
@@ -27,43 +27,35 @@ public class LocUpdateImg {
         return isDele;
     }
 
-    public static ReturnImage ImageuploadLOC(Map<String, File> fileMap, String username,Integer keyID) throws Exception {
-        KeysServiceImpl keysService = SpringContextHolder.getBean(KeysServiceImpl.class);
-        final Keys key = keysService.selectKeys(keyID);
+  public static ReturnImage ImageuploadLOC(
+      Map<Map<String, String>, File> fileMap, String username, Integer keyID) {
         ReturnImage returnImage = new ReturnImage();
-        String filePath =GlobalConstant.LOCPATH + File.separator;
-        File file = null;
-        for (Map.Entry<String, File> entry : fileMap.entrySet()) {
-            String ShortUID = SetText.getShortUuid();
-            System.out.println("待上传的图片："+username + File.separator + ShortUID + "." + entry.getKey());
-            File dest = new File(filePath + username + File.separator+ ShortUID + "." + entry.getKey());
-            File temppath = new File(filePath + username+ File.separator );
+        String filePath = GlobalConstant.LOCPATH + File.separator;
+        try {
+          for (Map.Entry<Map<String, String>, File> entry : fileMap.entrySet()) {
+            String prefix = entry.getKey().get("prefix");
+            String ShortUIDName = entry.getKey().get("name");
+            File dest = new File(filePath + username + File.separator + ShortUIDName + "." + prefix);
             if (!dest.getParentFile().exists()) {
-                dest.getParentFile().mkdirs();
+              dest.getParentFile().mkdirs();
             }
-            try {
-                InputStream fileInputStream = new FileInputStream(entry.getValue());
-                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
-                byte[] bs = new byte[1024];
-                int len;
-                while ((len = fileInputStream.read(bs)) != -1) {
-                    bos.write(bs, 0, len);
-                }
-                bos.flush();
-                bos.close();
-                returnImage.setImgname(username + "/" +ShortUID + "." + entry.getKey());//entry.getValue().getOriginalFilename()
-                returnImage.setImgurl(key.getRequestAddress() +"/ota/"+username + "/" + ShortUID + "." + entry.getKey());
-                returnImage.setImgSize(entry.getValue().length());
-                returnImage.setCode("200");
-
-            } catch (IOException e) {
-                e.printStackTrace();
-                returnImage.setCode("500");
-                System.err.println("上传失败");
+            InputStream fileInputStream = new FileInputStream(entry.getValue());
+            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
+            byte[] bs = new byte[1024];
+            int len;
+            while ((len = fileInputStream.read(bs)) != -1) {
+              bos.write(bs, 0, len);
             }
+            bos.flush();
+            bos.close();
+          }
+          returnImage.setCode("200");
+        } catch (Exception e) {
+          e.printStackTrace();
+          returnImage.setCode("500");
+          System.err.println("上传失败");
         }
         return returnImage;
     }
 
-
 }

src/main/java/cn/hellohao/utils/MyVersion.java

@@ -0,0 +1,50 @@
+package cn.hellohao.utils;
+
+/**
+ * @author Hellohao
+ * @version 1.0
+ * @date 2022/7/18 9:49
+ */
+public class MyVersion {
+    /**
+     * 版本号比较
+     *
+     * @param v1
+     * @param v2
+     * @return 0代表相等，1代表左边大，-1代表右边大
+     * Utils.compareVersion("1.0.358_20180820090554","1.0.358_20180820090553")=1
+     */
+    public static int compareVersion(String v1, String v2) {
+        if (v1.equals(v2)) {
+            return 0;
+        }
+        String[] version1Array = v1.split("[._]");
+        String[] version2Array = v2.split("[._]");
+        int index = 0;
+        int minLen = Math.min(version1Array.length, version2Array.length);
+        long diff = 0;
+
+        while (index < minLen
+                && (diff = Long.parseLong(version1Array[index])
+                - Long.parseLong(version2Array[index])) == 0) {
+            index++;
+        }
+        if (diff == 0) {
+            for (int i = index; i < version1Array.length; i++) {
+                if (Long.parseLong(version1Array[i]) > 0) {
+                    return 1;
+                }
+            }
+
+            for (int i = index; i < version2Array.length; i++) {
+                if (Long.parseLong(version2Array[i]) > 0) {
+                    return -1;
+                }
+            }
+            return 0;
+        } else {
+            return diff > 0 ? 1 : -1;
+        }
+    }
+
+}

src/main/java/cn/hellohao/utils/NewSendEmail.java

@@ -1,14 +1,15 @@
 package cn.hellohao.utils;
 
-import cn.hellohao.pojo.Config;
 import cn.hellohao.pojo.EmailConfig;
 import cn.hellohao.pojo.Msg;
 import cn.hutool.core.util.CharsetUtil;
 import cn.hutool.core.util.HexUtil;
+import com.alibaba.fastjson.JSONObject;
 import com.mitchellbosecke.pebble.PebbleEngine;
 import com.mitchellbosecke.pebble.template.PebbleTemplate;
 import io.github.biezhi.ome.OhMyEmail;
 import org.springframework.core.io.ClassPathResource;
+
 import java.io.StringWriter;
 import java.io.Writer;
 import java.util.HashMap;
@@ -18,7 +19,7 @@ import java.util.UUID;
 
 public class NewSendEmail {
 
-    public static Integer sendEmail(EmailConfig emailConfig, String username, String uid, String toEmail,  Config config) {
+    public static Integer sendEmail(EmailConfig emailConfig, String username, String uid, String toEmail,  JSONObject jsonObject) {
 
         Properties props = new Properties();
         props.put("mail.smtp.auth", "true");
@@ -33,8 +34,8 @@ public class NewSendEmail {
 //        OhMyEmail.config(OhMyEmail.SMTP_QQ(false), "xxxx@qq.com", "your@password");
         OhMyEmail.config(props, emailConfig.getEmails(), emailConfig.getEmailkey());
 
-        String webname=config.getWebname();
-        String domain = config.getDomain();
+        String webname=jsonObject.getString("webname");
+        String domain = jsonObject.getString("domain");
         try {
             //生成模板
             PebbleEngine engine = new PebbleEngine.Builder().build();
@@ -90,7 +91,7 @@ public class NewSendEmail {
     }
 
 
-    public static Integer sendEmailFindPass(EmailConfig emailConfig,String username, String uid, String toEmail,  Config config) {
+    public static Integer sendEmailFindPass(EmailConfig emailConfig,String username, String uid, String toEmail,  JSONObject jsonObject) {
         Properties props = new Properties();
         props.put("mail.smtp.auth", "true");
         props.put("mail.smtp.ssl.enable", "true");
@@ -103,8 +104,8 @@ public class NewSendEmail {
         // 配置一次即可，可以配置为静态方法
 //        OhMyEmail.config(OhMyEmail.SMTP_QQ(false), "xxxx@qq.com", "your@password");
         OhMyEmail.config(props, emailConfig.getEmails(), emailConfig.getEmailkey());
-        String webname=config.getWebname();
-        String domain = config.getDomain();
+        String webname=jsonObject.getString("webname");
+        String domain = jsonObject.getString("domain");
         String new_pass = UUID.randomUUID().toString().replace("-", "").toLowerCase().substring(0,10);
         try {
             //生成模板

src/main/java/cn/hellohao/utils/RunSqlScript.java

@@ -1,15 +1,14 @@
 package cn.hellohao.utils;
 
-import org.apache.ibatis.io.Resources;
-import org.apache.ibatis.jdbc.ScriptRunner;
+import cn.hellohao.service.impl.S3Imageupload;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
 import java.sql.*;
-import java.util.Properties;
 
 
 final class RunSqlScript {
-
+    private static Logger logger = LoggerFactory.getLogger(RunSqlScript.class);
     public static  String DBDRIVER = "com.mysql.cj.jdbc.Driver";
     public static  String DBURL ;
     //现在使用的是mysql数据库，是直接连接的，所以此处必须有用户名和密码
@@ -26,7 +25,7 @@ final class RunSqlScript {
         try {
             Class.forName(DBDRIVER);
         } catch (ClassNotFoundException e) {
-            e.printStackTrace();
+            logger.error("RunSqlScript[29]", e);
         }
         //2、连接数据库
         //通过连接管理器连接数据库
@@ -34,14 +33,14 @@ final class RunSqlScript {
             //在连接的时候直接输入用户名和密码才可以连接
             conn = DriverManager.getConnection(DBURL,USERNAME,PASSWORD);
         } catch (SQLException e) {
-            e.printStackTrace();
+            logger.error("RunSqlScript[36]", e);
         }
         //3、向数据库中插入一条数据
         //String sql = "select count(*) from information_schema.columns where table_name = 'config' and column_name = 'id'";
         try {
             stmt = conn.createStatement();
         } catch (SQLException e) {
-            e.printStackTrace();
+            logger.error("RunSqlScript[43]", e);
         }
         //4、执行语句
         try {
@@ -51,7 +50,7 @@ final class RunSqlScript {
                 count = resultSet.getInt(1);
             }
         } catch (SQLException e) {
-            e.printStackTrace();
+            logger.error("RunSqlScript[53]", e);
             return -1;
         }
         //5、关闭操作
@@ -59,7 +58,7 @@ final class RunSqlScript {
             stmt.close();
             conn.close();
         } catch (SQLException e) {
-            e.printStackTrace();
+            logger.error("RunSqlScript[61]", e);
         }
         return count;
     }
@@ -76,8 +75,7 @@ final class RunSqlScript {
         try {
             Class.forName(DBDRIVER);
         } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-            Print.Normal("SqlHelper.java - ClassNotFoundException");
+            logger.error("RunSqlScript[78]", e);
         }
         //2、连接数据库
         //通过连接管理器连接数据库
@@ -85,23 +83,21 @@ final class RunSqlScript {
             //在连接的时候直接输入用户名和密码才可以连接
             conn = DriverManager.getConnection(DBURL,USERNAME,PASSWORD);
         } catch (SQLException e) {
-            e.printStackTrace();
-            Print.Normal("SqlHelper.java - SQLException1");
+            logger.error("RunSqlScript[86]", e);
         }
         try {
             stmt = conn.createStatement();
         } catch (SQLException e) {
-            e.printStackTrace();
-            Print.Normal("SqlHelper.java - SQLException2");
+            logger.error("RunSqlScript[91]", e);
         }
         //4、执行语句
         try {
             count = stmt.executeUpdate(sql);
         } catch (SQLException e) {
             if(e.getMessage().contains("Duplicate key name") && e.getMessage().contains("index_md5key_url")){
-                Print.Normal("Database index already exists, skip this step.");
+                logger.info("Database index already exists, skip this step.");
             }else{
-                e.printStackTrace();
+                logger.error("RunSqlScript[100]", e);
             }
         }
         //5、关闭操作
@@ -109,7 +105,7 @@ final class RunSqlScript {
             stmt.close();
             conn.close();
         } catch (SQLException e) {
-            Print.Normal("SqlHelper.java - SQLException4");
+            logger.error("RunSqlScript[108]", e);
         }
         return count;
     }

src/main/java/cn/hellohao/utils/SetFiles.java

@@ -1,11 +1,22 @@
 package cn.hellohao.utils;
 
+import cn.hellohao.pojo.Chunk;
+import cn.hellohao.pojo.Msg;
+import org.apache.commons.io.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
 import java.text.DecimalFormat;
+import java.util.stream.Stream;
 
 public class SetFiles {
+    private static Logger logger = LoggerFactory.getLogger(SetFiles.class);
     // 转换文件方法
     public static File changeFile(MultipartFile multipartFile) {
         // 获取文件名
@@ -40,17 +51,16 @@ public class SetFiles {
 
     // 转换文件方法
     public static File changeFile_new(MultipartFile multipartFile) {
-        // 获取文件名
         String fileName = multipartFile.getOriginalFilename();//getOriginalFilename
-        // 获取文件后缀
         String prefix = fileName.substring(fileName.lastIndexOf("."));
         // todo 修改临时文件文件名
         File file = null;
         try {
-            file = File.createTempFile(fileName, prefix);
-            multipartFile.transferTo(file);
+            String new_FileName = System.getProperty("java.io.tmpdir")+"hellohao_tmp_upload"+File.separator+fileName;
+            file = new File(new_FileName);
+            FileUtils.copyInputStreamToFile(multipartFile.getInputStream(), file);
         } catch (IOException e) {
-            e.printStackTrace();
+            logger.error("SetFiles.changeFile_new", e);
         }
         return file;
     }
@@ -78,7 +88,73 @@ public class SetFiles {
         return fileSizeString;
     }
 
+    public static String generatePath(String uploadFolder, Chunk chunk) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(uploadFolder+File.separator).append("/").append(chunk.getIdentifier());
+        if (!Files.isWritable(Paths.get(sb.toString()))) {
+            System.err.println("path not exist,create path");
+            System.err.println(sb.toString());
+            try {
+                Files.createDirectories(Paths.get(sb.toString()));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return sb.append("/")
+                .append(chunk.getFilename())
+                .append("-")
+                .append(chunk.getChunkNumber()).toString();
+    }
 
+    public static Msg merge(String targetFile, String folder, String filename) {
+        Msg msg = new Msg();
+        try {
+            final File file = new File(targetFile);
+            if (file.exists()){
+                file.delete();
+            }
+            Files.createFile(Paths.get(targetFile));
+        } catch (IOException e) {
+            System.out.println("这是一个无伤大雅的错:IOException");
+            e.printStackTrace();
+        }
+        try (Stream<Path> stream = Files.list(Paths.get(folder))) {
+            stream.filter(path -> !path.getFileName().toString().equals(filename))
+                    .sorted((o1, o2) -> {
+                        String p1 = o1.getFileName().toString();
+                        String p2 = o2.getFileName().toString();
+                        int i1 = p1.lastIndexOf("-");
+                        int i2 = p2.lastIndexOf("-");
+                        return Integer.valueOf(p2.substring(i2)).compareTo(Integer.valueOf(p1.substring(i1)));
+                    })
+                    .forEach(path -> {
+                        try {
+                            //以追加的形式写入文件
+                            Files.write(Paths.get(targetFile), Files.readAllBytes(path), StandardOpenOption.APPEND);
+                            //合并后删除该块
+                            Files.delete(path);
+                        } catch (IOException e) {
+                            msg.setCode("500");
+                            msg.setInfo("合并文件时发生了错误");
+                            e.printStackTrace();
+                        }
+                    });
+        } catch (IOException e) {
+            msg.setCode("500");
+            msg.setInfo("合并文件时发生了错误");
+            e.printStackTrace();
+        }
+        return msg;
+    }
 
+    public static void delFileFolder(File file){
+        if (file.isDirectory()){
+            File[] files = file.listFiles();
+            for (File in: files) {
+                delFileFolder(in);
+            }
+        }
+        file.delete();
+    }
 
 }

src/main/java/cn/hellohao/utils/SetText.java

@@ -57,6 +57,7 @@ public class SetText {
         boolean flag = false;
         try {
             String check = "^\\w+@[a-zA-Z0-9]{2,10}(?:\\.[a-z]{2,4}){1,3}$";
+//            String regex = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*"; //这个也可以用
             Pattern regex = Pattern.compile(check);
             Matcher matcher = regex.matcher(email);
             flag = matcher.matches();
@@ -66,6 +67,5 @@ public class SetText {
         return flag;
     }
 
-
 }
 

src/main/java/cn/hellohao/utils/StringUtils.java

@@ -1,64 +1,6 @@
 package cn.hellohao.utils;
 
-import cn.hellohao.pojo.Keys;
-
-import java.lang.reflect.Field;
-import java.util.Collection;
-import java.util.Map;
-
 public class StringUtils {
-    //此方法目前未使用2020-04-06
-    public static Boolean doNull(Integer sourcekey,Keys k) {
-        if(sourcekey==1){
-            if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null
-                    && k.getBucketname()!=null && k.getRequestAddress()!=null ){
-                if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("")
-                        && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ){
-                    return true;
-                }
-            }
-        }else if(sourcekey==2){
-            if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null
-                    && k.getBucketname()!=null && k.getRequestAddress()!=null ) {
-                if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("")
-                        && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ) {
-                    return true;
-                }
-            }
-        }else if(sourcekey==3){
-            if(k.getEndpoint()!=null && k.getAccessSecret()!=null
-                    && k.getBucketname()!=null && k.getRequestAddress()!=null ) {
-                if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("")
-                        && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ) {
-                    return true;
-                }
-            }
-        }else if(sourcekey==4){
-            if (k.getEndpoint() != null && k.getAccessSecret() != null && k.getEndpoint() != null
-                    && k.getBucketname() != null && k.getRequestAddress() != null) {
-                if (!k.getEndpoint().equals("") && !k.getAccessSecret() .equals("") && !k.getEndpoint() .equals("")
-                        && !k.getBucketname() .equals("") && !k.getRequestAddress().equals("")) {
-                    return true;
-                }
-            }
-        }else if(sourcekey==6){
-            if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null
-                    && k.getBucketname()!=null && k.getRequestAddress()!=null ) {
-                if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("")
-                        && !k.getBucketname().equals("") && !k.getRequestAddress().equals("") ) {
-                    return true;
-                }
-            }
-        }else if(sourcekey==7){
-            if(k.getEndpoint()!=null && k.getAccessSecret()!=null && k.getEndpoint()!=null && k.getRequestAddress()!=null ) {
-                if(!k.getEndpoint().equals("") && !k.getAccessSecret().equals("") && !k.getEndpoint().equals("") && !k.getRequestAddress().equals("") ) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
     /**
      * 移除 URL 中的第一个 '/'
      * @return 如 path = '/folder1/file1', 返回 'folder1/file1'

src/main/java/cn/hellohao/utils/TypeDict.java

@@ -7,73 +7,16 @@ import javax.imageio.ImageIO;
 import java.awt.*;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 
 public class TypeDict {
-/**
- 常用文件的文件头如下：(以前六位为准)
-JPEG (jpg)，文件头：FFD8FF 
-PNG (png)，文件头：89504E47 
-GIF (gif)，文件头：47494638 
-TIFF (tif)，文件头：49492A00 
-Windows Bitmap (bmp)，文件头：424D 
-CAD (dwg)，文件头：41433130 
-Adobe Photoshop (psd)，文件头：38425053 
-Rich Text Format (rtf)，文件头：7B5C727466 
-XML (xml)，文件头：3C3F786D6C 
-HTML (html)，文件头：68746D6C3E 
-Email [thorough only] (eml)，文件头：44656C69766572792D646174653A 
-Outlook Express (dbx)，文件头：CFAD12FEC5FD746F 
-Outlook (pst)，文件头：2142444E 
-MS Word/Excel (xls.or.doc)，文件头：D0CF11E0 
-MS Access (mdb)，文件头：5374616E64617264204A 
-WordPerfect (wpd)，文件头：FF575043 
-Postscript (eps.or.ps)，文件头：252150532D41646F6265 
-Adobe Acrobat (pdf)，文件头：255044462D312E 
-Quicken (qdf)，文件头：AC9EBD8F 
-Windows Password (pwl)，文件头：E3828596 
-ZIP Archive (zip)，文件头：504B0304 
-RAR Archive (rar)，文件头：52617221 
-Wave (wav)，文件头：57415645 
-AVI (avi)，文件头：41564920 
-Real Audio (ram)，文件头：2E7261FD 
-Real Media (rm)，文件头：2E524D46 
-MPEG (mpg)，文件头：000001BA 
-MPEG (mpg)，文件头：000001B3 
-Quicktime (mov)，文件头：6D6F6F76 
-Windows Media (asf)，文件头：3026B2758E66CF11 
-MIDI (mid)，文件头：4D546864 
-*/
-    public static String checkType(String xxxx) {
-        
-        switch (xxxx) {
-        case "FFD8FF": return "jpg";
-        case "89504E": return "png";
-        case "474946": return "jif";
-        case "47494638": return "gif";
-        case "424D": return "bmp";
-        case "424D36": return "bmp";
-        default: return "0000";
-        }
-    }
-
-    public static Boolean checkImgType(File file) {
-        try {
-            // 通过ImageReader来解码这个file并返回一个BufferedImage对象
-            // 如果找不到合适的ImageReader则会返回null，我们可以认为这不是图片文件
-            // 或者在解析过程中报错，也返回false
-            Image image = ImageIO.read(file);
-            return image != null;
-        } catch(IOException ex) {
-            return false;
-        }
-    }
 
     //apache大法
-    public static Msg FileMiME(File file ){
+    public static Msg FileMiME(InputStream stream){
         final Msg msg = new Msg();
         try {
             Tika tika = new Tika();
-            String fileType = tika.detect(file);
+            String fileType = tika.detect(stream);
             if (fileType != null && fileType.contains("/")) {
                 if(fileType.contains("image/")){
                     msg.setData(fileType);

src/main/java/cn/hellohao/utils/progress/MyProgress.java

@@ -0,0 +1,62 @@
+package cn.hellohao.utils.progress;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MyProgress {
+    private int delSuccessCount=0;//已经成功的个数
+    private List<String> delErrorImgListt =  new ArrayList<>();//已经失败的图片
+    private int delOCT=0; //控制开关
+    private List<Long> delSuccessImgList =  new ArrayList<>(); //删除成功的图片
+
+    public void InitializeDelImg(){
+        this.delSuccessCount=0;//已经成功的个数
+        this.delErrorImgListt =  new ArrayList<>();//已经失败的图片
+        this.delOCT=0; //控制开关 0代表false 1代表true
+        this.delSuccessImgList =  new ArrayList<>(); //删除成功的图片
+    }
+
+    public MyProgress() {
+    }
+
+    public MyProgress(int delSuccessCount, List<String> delErrorImgListt, int delOCT, List<Long> delSuccessImgList) {
+        this.delSuccessCount = delSuccessCount;
+        this.delErrorImgListt = delErrorImgListt;
+        this.delOCT = delOCT;
+        this.delSuccessImgList = delSuccessImgList;
+    }
+
+    public int getDelSuccessCount() {
+        return delSuccessCount;
+    }
+
+    public void setDelSuccessCount(int delSuccessCount) {
+        this.delSuccessCount = delSuccessCount;
+    }
+
+    public List<String> getDelErrorImgListt() {
+        return delErrorImgListt;
+    }
+
+    public void setDelErrorImgListt(List<String> delErrorImgListt) {
+        this.delErrorImgListt = delErrorImgListt;
+    }
+
+    public int getDelOCT() {
+        return delOCT;
+    }
+
+    public void setDelOCT(int delOCT) {
+        this.delOCT = delOCT;
+    }
+
+    public List<Long> getDelSuccessImgList() {
+        return delSuccessImgList;
+    }
+
+    public void setDelSuccessImgList(List<Long> delSuccessImgList) {
+        this.delSuccessImgList = delSuccessImgList;
+    }
+
+
+}

src/main/java/cn/hellohao/utils/test/Demo.java

@@ -0,0 +1,66 @@
+package cn.hellohao.utils.test;
+
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSONObject;
+
+import java.util.HashMap;
+import java.util.UUID;
+
+class counts {
+    public static Long i = 5000L;
+}
+//1.创建一个实现了Runnable接口的类
+class Demo implements Runnable {
+    //2.实现类去实现(重写)Runnable中的抽象方法：run()
+    @Override
+    public void run() {
+
+        while (true){
+            try{
+                String uuid = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+                HashMap<String, Object> paramMap = new HashMap<>();
+                paramMap.put("email", uuid.substring(0,10)+"@163.com");
+                paramMap.put("pwd", uuid+uuid+uuid);
+                String result1 = HttpUtil.post("http://39.107.115.48/og/v1/user/login/email", paramMap);
+                JSONObject jsonObject = JSONObject.parseObject(result1);
+                System.out.println("执行第"+counts.i+"次：响应代码："+jsonObject.getInteger("c")+"，"+jsonObject.getString("m"));
+                System.out.println("用户UUID："+jsonObject.getJSONObject("d").getJSONObject("user").getString("object_id"));
+                if(jsonObject.getInteger("c")==200){
+                    String uuid2 = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+                    HashMap<String, Object> paramMap2 = new HashMap<>();
+                    paramMap2.put("order_id", uuid2);
+                    paramMap2.put("email", uuid.substring(0,10)+"@163.com");
+                    paramMap2.put("info", "pay&money=永久会员 ¥12 (随功能增多会涨价)");
+                    paramMap2.put("product_id", "beetodo");
+                    paramMap2.put("pay_channel", "unkown");
+                    paramMap2.put("click_pay_time", "unkown");
+                    paramMap2.put("version", "21/1.2.6");
+                    String result2 = HttpUtil.post("http://39.107.115.48/og/v1/user/login/email", paramMap);
+                    JSONObject jsonObject2 = JSONObject.parseObject(result2);
+                    System.out.println("提交订单的："+jsonObject2.getInteger("c"));
+                }
+                counts.i++;
+            }catch (Exception e){
+                e.printStackTrace();
+                System.err.println("报错了");
+            }
+        }
+
+    }
+}
+
+//测试类:
+class ThreadTest {
+    public static void main(String[] args) {
+
+        //同样为了展示多线程效果,我们在main主线程中也遍历输出一下作为对比
+        for (int i = 0; i < 10; i++) {
+            //3.创建实现类的对象
+            Demo d1 = new Demo();
+//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
+            Thread thread = new Thread(d1);
+            //5.通过Thread类的对象调用start()
+            thread.start();
+        }
+    }
+}

src/main/java/cn/hellohao/utils/verifyCode/SimpleCharVerifyCodeGenImpl.java

@@ -30,22 +30,22 @@ private static final int VALICATE_CODE_LENGTH = 4;
 * @param height
 */
 private static void fillBackground(Graphics graphics, int width, int height) {
-// 填充背景
-graphics.setColor(Color.WHITE);
-//设置矩形坐标x y 为0
-graphics.fillRect(0, 0, width, height);
+    // 填充背景
+    graphics.setColor(Color.WHITE);
+    //设置矩形坐标x y 为0
+    graphics.fillRect(0, 0, width, height);
 
-// 加入干扰线条
-for (int i = 0; i < 8; i++) {
-//设置随机颜色算法参数
-graphics.setColor(RandomUtils.randomColor(40, 150));
-Random random = new Random();
-int x = random.nextInt(width);
-int y = random.nextInt(height);
-int x1 = random.nextInt(width);
-int y1 = random.nextInt(height);
-graphics.drawLine(x, y, x1, y1);
-}
+    // 加入干扰线条
+    for (int i = 0; i < 8; i++) {
+    //设置随机颜色算法参数
+    graphics.setColor(RandomUtils.randomColor(40, 150));
+    Random random = new Random();
+    int x = random.nextInt(width);
+    int y = random.nextInt(height);
+    int x1 = random.nextInt(width);
+    int y1 = random.nextInt(height);
+    graphics.drawLine(x, y, x1, y1);
+    }
 }
 
 /**
@@ -59,15 +59,15 @@ graphics.drawLine(x, y, x1, y1);
 */
 @Override
 public String generate(int width, int height, OutputStream os) throws IOException {
-BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
-Graphics graphics = image.getGraphics();
-fillBackground(graphics, width, height);
-String randomStr = RandomUtils.randomString(VALICATE_CODE_LENGTH);
-createCharacter(graphics, randomStr);
-graphics.dispose();
-//设置JPEG格式
-ImageIO.write(image, "JPEG", os);
-return randomStr;
+    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+    Graphics graphics = image.getGraphics();
+    fillBackground(graphics, width, height);
+    String randomStr = RandomUtils.randomString(VALICATE_CODE_LENGTH);
+    createCharacter(graphics, randomStr);
+    graphics.dispose();
+    //设置JPEG格式
+    ImageIO.write(image, "JPEG", os);
+    return randomStr;
 }
 
 /**
@@ -79,20 +79,20 @@ return randomStr;
 */
 @Override
 public VerifyCode generate(int width, int height) {
-VerifyCode verifyCode = null;
-try (
-//将流的初始化放到这里就不需要手动关闭流
-ByteArrayOutputStream baos = new ByteArrayOutputStream();
-) {
-String code = generate(width, height, baos);
-verifyCode = new VerifyCode();
-verifyCode.setCode(code);
-verifyCode.setImgBytes(baos.toByteArray());
-} catch (IOException e) {
-logger.error(e.getMessage(), e);
-verifyCode = null;
-}
-return verifyCode;
+    VerifyCode verifyCode = null;
+    try (
+    //将流的初始化放到这里就不需要手动关闭流
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    ) {
+    String code = generate(width, height, baos);
+    verifyCode = new VerifyCode();
+    verifyCode.setCode(code);
+    verifyCode.setImgBytes(baos.toByteArray());
+    } catch (IOException e) {
+    logger.error(e.getMessage(), e);
+    verifyCode = null;
+    }
+    return verifyCode;
 }
 
 /**
@@ -102,15 +102,15 @@ return verifyCode;
 * @param randomStr
 */
 private void createCharacter(Graphics g, String randomStr) {
-char[] charArray = randomStr.toCharArray();
-for (int i = 0; i < charArray.length; i++) {
-//设置RGB颜色算法参数
-g.setColor(new Color(50 + RandomUtils.nextInt(100),
-50 + RandomUtils.nextInt(100), 50 + RandomUtils.nextInt(100)));
-//设置字体大小，类型
-g.setFont(new Font(FONT_TYPES[RandomUtils.nextInt(FONT_TYPES.length)], Font.BOLD, 26));
-//设置x y 坐标
-g.drawString(String.valueOf(charArray[i]), 15 * i + 5, 19 + RandomUtils.nextInt(8));
-}
-}
+    char[] charArray = randomStr.toCharArray();
+        for (int i = 0; i < charArray.length; i++) {
+        //设置RGB颜色算法参数
+        g.setColor(new Color(50 + RandomUtils.nextInt(100),
+        50 + RandomUtils.nextInt(100), 50 + RandomUtils.nextInt(100)));
+        //设置字体大小，类型
+        g.setFont(new Font(FONT_TYPES[RandomUtils.nextInt(FONT_TYPES.length)], Font.BOLD, 26));
+        //设置x y 坐标
+        g.drawString(String.valueOf(charArray[i]), 15 * i + 5, 19 + RandomUtils.nextInt(8));
+        }
+    }
 }

src/main/resources/application.properties

@@ -1,38 +1,42 @@
-#数据库账号
-spring.datasource.username=root
-#数据库密码test
-spring.datasource.password=root
-#数据库链接地址
-spring.datasource.url=jdbc:mysql://localhost:3306/tbed?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
+DockerWebHost=${HELLOHAO_SERVER_HOST:null}
 #端口
-server.port=8089
+server.port=10088
 #前端域名需要带协议头http(s)://
-CROS_ALLOWED_ORIGINS=http://127.0.0.1:8080
+CROS_ALLOWED_ORIGINS=${HELLOHAO_WEB_HOST:http://127.0.0.1:8080}
+#数据库账号
+spring.datasource.username=${MYSQL_USERNAME:root}
+#数据库密码test
+spring.datasource.password=${MYSQL_PASS:root}
+#数据库链接地址
+spring.datasource.url=${MYSQL_URL:jdbc:mysql://localhost:3306/tbed?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8}
+#MySQL Driver 无需修改
+spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
+spring.redis.host= 127.0.0.1
+spring.redis.port=6379
+## 设置最大连接数，0为无限
+spring.redis.pool.max-active=8
+# 连接超时时间（毫秒）
+spring.redis.timeout=5000
+spring.redis.password=
 
 #下边的配置项不需要修改。
-#logging.config=classpath:logback-spring.xml
-#logging.file.path=/HellohaoData/tbedlog
 spring.thymeleaf.suffix=.html
 mybatis.configuration.map-underscore-to-camel-case=true
 mybatis.mapper-locations=classpath:mapper/*.xml
-logging.level.cn.hellohao.dao=debug
 spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
 spring.jackson.time-zone=GMT+8
-spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
 spring.thymeleaf.cache=false
 multipart.maxFileSize=10240KB
 multipart.maxRequestSize=10240KB
 spring.thymeleaf.mode = LEGACYHTML5
-spring.http.multipart.location=/data/upload_tmp
 systemupdate=2020-05-26
 
 spring.datasource.druid.filter.config.enabled=false
 spring.datasource.druid.web-stat-filter.enabled=false
 spring.datasource.druid.web-stat-filter.session-stat-enable=false
 spring.datasource.druid.stat-view-servlet.reset-enable=false
-
 spring.datasource.druid.filter.stat.enabled=false
 spring.datasource.druid.filter.wall.enabled=false
 spring.datasource.druid.filter.slf4j.enabled=false
@@ -44,4 +48,11 @@ spring.datasource.druid.stat-view-servlet.login-username=hellohao@dealer
 spring.datasource.druid.stat-view-servlet.login-password=52BNmXPJL0rQQ3CU
 spring.datasource.druid.stat-view-servlet.allow=127.0.0.1
 spring.datasource.druid.web-stat-filter.exclusions=false
-log4j2.formatMsgNoLookups=True
+#log4j.logger.cn.hellohao.dao=DEBUG
+log4j2.formatMsgNoLookups=True
+logging.level.cn.hellohao=DEBUG
+logging.file.name=/HellohaoData/tbedlog/tbed.log
+logging.pattern.console=%blue(%d{yyyy-MM-dd HH:mm:ss,SSS}) [%cyan(%t)] [%yellow(%c)]-[%highlight(%p)] %msg%n
+logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
+logging.logback.rollingpolicy.clean-history-on-start=true
+logging.logback.rollingpolicy.max-history=7