Merge remote-tracking branch 'origin/dev' into 4.X

.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md

@@ -1,4 +1,4 @@
-### 更改目的 解决了什么问题
+### 更改目的 解决了什么问题(请提交到dev分支)
 
 
 ### 描述 做了哪些改动

README.md

@@ -4,7 +4,7 @@
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://gitee.com/JavaLionLi/RuoYi-Vue-Plus/blob/master/LICENSE)
 [![使用IntelliJ IDEA开发维护](https://img.shields.io/badge/IntelliJ%20IDEA-提供支持-blue.svg)](https://www.jetbrains.com/?from=RuoYi-Vue-Plus)
 <br>
-[![RuoYi-Vue-Plus](https://img.shields.io/badge/RuoYi_Vue_Plus-4.1.0-success.svg)](https://gitee.com/JavaLionLi/RuoYi-Vue-Plus)
+[![RuoYi-Vue-Plus](https://img.shields.io/badge/RuoYi_Vue_Plus-4.2.0_beta1-success.svg)](https://gitee.com/JavaLionLi/RuoYi-Vue-Plus)
 [![Spring Boot](https://img.shields.io/badge/Spring%20Boot-2.6-blue.svg)]()
 [![JDK-8+](https://img.shields.io/badge/JDK-8-green.svg)]()
 [![JDK-11](https://img.shields.io/badge/JDK-11-green.svg)]()
@@ -42,6 +42,7 @@
 | 分布式任务调度  | Xxl-Job             | [Xxl-Job官网](https://www.xuxueli.com/xxl-job/)                                                     | 高性能 高可靠 易扩展                |
 | 文件存储     | Minio               | [Minio文档](https://docs.min.io/)                                                                   | 本地存储                       |
 | 文件存储     | 七牛、阿里、腾讯            | [OSS使用文档](https://gitee.com/JavaLionLi/RuoYi-Vue-Plus/wikis/pages?sort_id=4359146&doc_id=1469725) | 云存储                        |
+| 短信模块     | 阿里、腾讯               | [短信使用文档](https://gitee.com/JavaLionLi/RuoYi-Vue-Plus/wikis/pages?sort_id=5578491&doc_id=1469725)  | 短信发送                       |
 | 监控框架     | SpringBoot-Admin    | [SpringBoot-Admin文档](https://codecentric.github.io/spring-boot-admin/current/)                    | 全方位服务监控                    |
 | 校验框架     | Validation          | [Validation文档](https://docs.jboss.org/hibernate/stable/validator/reference/en-US/html_single/)    | 增强接口安全性、严谨性 支持国际化          |
 | Excel框架  | Alibaba EasyExcel   | [EasyExcel文档](https://www.yuque.com/easyexcel/doc/easyexcel)                                      | 性能优异 扩展性强                  |

pom.xml

@@ -6,49 +6,46 @@
 
     <groupId>com.ruoyi</groupId>
     <artifactId>ruoyi-vue-plus</artifactId>
-    <version>4.1.0</version>
+    <version>4.2.0</version>
 
     <name>RuoYi-Vue-Plus</name>
     <url>https://gitee.com/JavaLionLi/RuoYi-Vue-Plus</url>
     <description>RuoYi-Vue-Plus后台管理系统</description>
 
     <properties>
-        <ruoyi-vue-plus.version>4.1.0</ruoyi-vue-plus.version>
+        <ruoyi-vue-plus.version>4.2.0</ruoyi-vue-plus.version>
-        <spring-boot.version>2.6.7</spring-boot.version>
+        <spring-boot.version>2.6.9</spring-boot.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>
         <maven-jar-plugin.version>3.2.2</maven-jar-plugin.version>
-        <spring-boot.mybatis>2.2.0</spring-boot.mybatis>
+        <spring-boot.mybatis>2.2.2</spring-boot.mybatis>
-        <druid.version>1.2.8</druid.version>
+        <druid.version>1.2.11</druid.version>
         <knife4j.version>3.0.3</knife4j.version>
         <swagger-annotations.version>1.5.22</swagger-annotations.version>
-        <poi.version>4.1.2</poi.version>
+        <poi.version>5.2.2</poi.version>
-        <commons-compress.version>1.21</commons-compress.version>
+        <easyexcel.version>3.1.1</easyexcel.version>
-        <easyexcel.version>3.0.5</easyexcel.version>
         <velocity.version>2.3</velocity.version>
-        <satoken.version>1.29.0</satoken.version>
+        <satoken.version>1.30.0</satoken.version>
-        <mybatis-plus.version>3.5.1</mybatis-plus.version>
+        <mybatis-plus.version>3.5.2</mybatis-plus.version>
         <p6spy.version>3.9.1</p6spy.version>
-        <hutool.version>5.7.22</hutool.version>
+        <hutool.version>5.8.3</hutool.version>
         <okhttp.version>4.9.3</okhttp.version>
-        <spring-boot-admin.version>2.6.6</spring-boot-admin.version>
+        <spring-boot-admin.version>2.6.7</spring-boot-admin.version>
-        <redisson.version>3.17.0</redisson.version>
+        <redisson.version>3.17.4</redisson.version>
         <lock4j.version>2.2.1</lock4j.version>
         <dynamic-ds.version>3.5.1</dynamic-ds.version>
-        <tlog.version>1.3.6</tlog.version>
+        <tlog.version>1.4.3</tlog.version>
-        <xxl-job.version>2.3.0</xxl-job.version>
+        <xxl-job.version>2.3.1</xxl-job.version>
 
-        <!-- jdk11 缺失依赖 jaxb-->
-        <jaxb.version>3.0.1</jaxb.version>
         <!-- 统一 guava 版本 解决隐式漏洞问题 -->
         <guava.version>30.0-jre</guava.version>
 
         <!-- OSS 配置 -->
-        <qiniu.version>7.9.5</qiniu.version>
+        <aws-java-sdk-s3.version>1.12.248</aws-java-sdk-s3.version>
-        <aliyun.oss.version>3.14.0</aliyun.oss.version>
+        <!-- SMS 配置 -->
-        <qcloud.cos.version>5.6.72</qcloud.cos.version>
+        <aliyun.sms.version>2.0.9</aliyun.sms.version>
-        <minio.version>8.3.8</minio.version>
+        <tencent.sms.version>3.1.537</tencent.sms.version>
 
         <!-- docker 配置 -->
         <docker.registry.url>localhost</docker.registry.url>
@@ -105,29 +102,21 @@
                 <version>${swagger-annotations.version}</version>
             </dependency>
 
-            <!-- excel工具 -->
+            <dependency>
+                <groupId>org.apache.poi</groupId>
+                <artifactId>poi</artifactId>
+                <version>${poi.version}</version>
+            </dependency>
             <dependency>
                 <groupId>org.apache.poi</groupId>
                 <artifactId>poi-ooxml</artifactId>
                 <version>${poi.version}</version>
             </dependency>
-
-            <!-- 修复poi漏洞 -->
-            <dependency>
-                <groupId>org.apache.commons</groupId>
-                <artifactId>commons-compress</artifactId>
-                <version>${commons-compress.version}</version>
-            </dependency>
-
             <dependency>
                 <groupId>com.alibaba</groupId>
                 <artifactId>easyexcel</artifactId>
                 <version>${easyexcel.version}</version>
                 <exclusions>
-                    <exclusion>
-                        <groupId>org.apache.poi</groupId>
-                        <artifactId>poi</artifactId>
-                    </exclusion>
                     <exclusion>
                         <groupId>org.apache.poi</groupId>
                         <artifactId>poi-ooxml-schemas</artifactId>
@@ -155,13 +144,6 @@
                 <version>${satoken.version}</version>
             </dependency>
 
-            <!-- jdk11 缺失依赖 jaxb-->
-            <dependency>
-                <groupId>com.sun.xml.bind</groupId>
-                <artifactId>jaxb-impl</artifactId>
-                <version>${jaxb.version}</version>
-            </dependency>
-
             <!-- dynamic-datasource 多数据源-->
             <dependency>
                 <groupId>com.baomidou</groupId>
@@ -192,6 +174,24 @@
                 <version>${okhttp.version}</version>
             </dependency>
 
+            <dependency>
+                <groupId>com.amazonaws</groupId>
+                <artifactId>aws-java-sdk-s3</artifactId>
+                <version>${aws-java-sdk-s3.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>com.aliyun</groupId>
+                <artifactId>dysmsapi20170525</artifactId>
+                <version>${aliyun.sms.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>com.tencentcloudapi</groupId>
+                <artifactId>tencentcloud-sdk-java</artifactId>
+                <version>${tencent.sms.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>de.codecentric</groupId>
                 <artifactId>spring-boot-admin-starter-server</artifactId>
@@ -297,6 +297,13 @@
                 <version>${ruoyi-vue-plus.version}</version>
             </dependency>
 
+            <!-- SMS短信模块 -->
+            <dependency>
+                <groupId>com.ruoyi</groupId>
+                <artifactId>ruoyi-sms</artifactId>
+                <version>${ruoyi-vue-plus.version}</version>
+            </dependency>
+
             <!-- demo模块 -->
             <dependency>
                 <groupId>com.ruoyi</groupId>
@@ -317,6 +324,7 @@
         <module>ruoyi-demo</module>
         <module>ruoyi-extend</module>
         <module>ruoyi-oss</module>
+        <module>ruoyi-sms</module>
     </modules>
     <packaging>pom</packaging>
 

ruoyi-admin/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>ruoyi-vue-plus</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <packaging>jar</packaging>

ruoyi-admin/src/main/java/com/ruoyi/web/controller/common/CaptchaController.java

@@ -4,6 +4,8 @@ import cn.hutool.captcha.AbstractCaptcha;
 import cn.hutool.captcha.generator.CodeGenerator;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.RandomUtil;
+import com.ruoyi.common.annotation.Anonymous;
 import com.ruoyi.common.constant.Constants;
 import com.ruoyi.common.core.domain.R;
 import com.ruoyi.common.enums.CaptchaType;
@@ -12,30 +14,68 @@ import com.ruoyi.common.utils.redis.RedisUtils;
 import com.ruoyi.common.utils.reflect.ReflectUtils;
 import com.ruoyi.common.utils.spring.SpringUtils;
 import com.ruoyi.framework.config.properties.CaptchaProperties;
+import com.ruoyi.sms.config.properties.SmsProperties;
+import com.ruoyi.sms.core.SmsTemplate;
+import com.ruoyi.sms.entity.SmsResult;
 import com.ruoyi.system.service.ISysConfigService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import javax.validation.constraints.NotBlank;
+import java.time.Duration;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
 
 /**
  * 验证码操作处理
  *
  * @author Lion Li
  */
+@Anonymous
+@Slf4j
+@Validated
 @Api(value = "验证码操作处理", tags = {"验证码管理"})
 @RequiredArgsConstructor
 @RestController
 public class CaptchaController {
 
     private final CaptchaProperties captchaProperties;
+    private final SmsProperties smsProperties;
     private final ISysConfigService configService;
 
+    /**
+     * 短信验证码
+     */
+    @ApiOperation("短信验证码")
+    @GetMapping("/captchaSms")
+    public R<Void> smsCaptcha(@ApiParam("用户手机号")
+                              @NotBlank(message = "{user.phonenumber.not.blank}")
+                              String phonenumber) {
+        if (smsProperties.getEnabled()) {
+            R.fail("当前系统没有开启短信功能！");
+        }
+        String key = Constants.CAPTCHA_CODE_KEY + phonenumber;
+        String code = RandomUtil.randomNumbers(4);
+        RedisUtils.setCacheObject(key, code, Duration.ofMinutes(Constants.CAPTCHA_EXPIRATION));
+        // 验证码模板id 自行处理 (查数据库或写死均可)
+        String templateId = "";
+        Map<String, String> map = new HashMap<>(1);
+        map.put("code", code);
+        SmsTemplate smsTemplate = SpringUtils.getBean(SmsTemplate.class);
+        SmsResult result = smsTemplate.send(phonenumber, templateId, map);
+        if (!result.isSuccess()) {
+            log.error("验证码短信发送异常 => {}", result);
+            return R.fail(result.getMessage());
+        }
+        return R.ok();
+    }
+
     /**
      * 生成验证码
      */
@@ -60,7 +100,7 @@ public class CaptchaController {
         captcha.setGenerator(codeGenerator);
         captcha.createCode();
         String code = isMath ? getCodeResult(captcha.getCode()) : captcha.getCode();
-        RedisUtils.setCacheObject(verifyKey, code, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);
+        RedisUtils.setCacheObject(verifyKey, code, Duration.ofMinutes(Constants.CAPTCHA_EXPIRATION));
         ajax.put("uuid", uuid);
         ajax.put("img", captcha.getImageBase64());
         return R.ok(ajax);

ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysLoginController.java

@@ -2,6 +2,7 @@ package com.ruoyi.web.controller.system;
 
 import cn.dev33.satoken.exception.NotLoginException;
 import cn.dev33.satoken.stp.StpUtil;
+import com.ruoyi.common.annotation.Anonymous;
 import com.ruoyi.common.constant.Constants;
 import com.ruoyi.common.core.domain.R;
 import com.ruoyi.common.core.domain.entity.SysMenu;
@@ -51,6 +52,7 @@ public class SysLoginController {
      * @param loginBody 登录信息
      * @return 结果
      */
+    @Anonymous
     @ApiOperation("登录方法")
     @PostMapping("/login")
     public R<Map<String, Object>> login(@Validated @RequestBody LoginBody loginBody) {
@@ -68,6 +70,7 @@ public class SysLoginController {
      * @param smsLoginBody 登录信息
      * @return 结果
      */
+    @Anonymous
     @ApiOperation("短信登录(示例)")
     @PostMapping("/smsLogin")
     public R<Map<String, Object>> smsLogin(@Validated @RequestBody SmsLoginBody smsLoginBody) {
@@ -84,6 +87,7 @@ public class SysLoginController {
      * @param xcxCode 小程序code
      * @return 结果
      */
+    @Anonymous
     @ApiOperation("小程序登录(示例)")
     @PostMapping("/xcxLogin")
     public R<Map<String, Object>> xcxLogin(@NotBlank(message = "{xcx.code.not.blank}") String xcxCode) {
@@ -94,12 +98,14 @@ public class SysLoginController {
         return R.ok(ajax);
     }
 
+    @Anonymous
     @ApiOperation("登出方法")
     @PostMapping("/logout")
     public R<Void> logout() {
         try {
+            String username = LoginHelper.getUsername();
             StpUtil.logout();
-            loginService.logout(LoginHelper.getUsername());
+            loginService.logout(username);
         } catch (NotLoginException e) {
         }
         return R.ok("退出成功");

ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysOssController.java

@@ -32,6 +32,7 @@ import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -58,6 +59,19 @@ public class SysOssController extends BaseController {
         return iSysOssService.queryPageList(bo, pageQuery);
     }
 
+    /**
+     * 查询OSS对象基于id串
+     */
+    @ApiOperation("查询OSS对象基于ID")
+    @SaCheckPermission("system:oss:list")
+    @GetMapping("/listByIds/{ossIds}")
+    public R<List<SysOssVo>> listByIds(@ApiParam("OSS对象ID串")
+                                     @NotEmpty(message = "主键不能为空")
+                                     @PathVariable Long[] ossIds) {
+        List<SysOssVo> list = iSysOssService.listByIds(Arrays.asList(ossIds));
+        return R.ok(list);
+    }
+
     /**
      * 上传OSS对象存储
      */

ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysProfileController.java

@@ -1,6 +1,7 @@
 package com.ruoyi.web.controller.system;
 
 import cn.dev33.satoken.secure.BCrypt;
+import cn.hutool.core.io.FileUtil;
 import com.ruoyi.common.annotation.Log;
 import com.ruoyi.common.constant.UserConstants;
 import com.ruoyi.common.core.controller.BaseController;
@@ -9,6 +10,7 @@ import com.ruoyi.common.core.domain.entity.SysUser;
 import com.ruoyi.common.enums.BusinessType;
 import com.ruoyi.common.helper.LoginHelper;
 import com.ruoyi.common.utils.StringUtils;
+import com.ruoyi.common.utils.file.MimeTypeUtils;
 import com.ruoyi.system.domain.SysOss;
 import com.ruoyi.system.service.ISysOssService;
 import com.ruoyi.system.service.ISysUserService;
@@ -22,6 +24,7 @@ import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -117,6 +120,10 @@ public class SysProfileController extends BaseController {
     public R<Map<String, Object>> avatar(@RequestPart("avatarfile") MultipartFile file) {
         Map<String, Object> ajax = new HashMap<>();
         if (!file.isEmpty()) {
+            String extension = FileUtil.extName(file.getOriginalFilename());
+            if (!StringUtils.equalsAnyIgnoreCase(extension, MimeTypeUtils.IMAGE_EXTENSION)) {
+                return R.fail("文件格式不正确，请上传" + Arrays.toString(MimeTypeUtils.IMAGE_EXTENSION) + "格式");
+            }
             SysOss oss = iSysOssService.upload(file);
             String avatar = oss.getUrl();
             if (userService.updateUserAvatar(getUsername(), avatar)) {

ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysRegisterController.java

@@ -1,5 +1,6 @@
 package com.ruoyi.web.controller.system;
 
+import com.ruoyi.common.annotation.Anonymous;
 import com.ruoyi.common.core.controller.BaseController;
 import com.ruoyi.common.core.domain.R;
 import com.ruoyi.common.core.domain.model.RegisterBody;
@@ -27,6 +28,7 @@ public class SysRegisterController extends BaseController {
     private final SysRegisterService registerService;
     private final ISysConfigService configService;
 
+    @Anonymous
     @ApiOperation("用户注册")
     @PostMapping("/register")
     public R<Void> register(@Validated @RequestBody RegisterBody user) {

ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysRoleController.java

@@ -148,7 +148,7 @@ public class SysRoleController extends BaseController {
     @SaCheckPermission("system:role:remove")
     @Log(title = "角色管理", businessType = BusinessType.DELETE)
     @DeleteMapping("/{roleIds}")
-    public R<Void> remove(@ApiParam("岗位ID串") @PathVariable Long[] roleIds) {
+    public R<Void> remove(@ApiParam("角色ID串") @PathVariable Long[] roleIds) {
         return toAjax(roleService.deleteRoleByIds(roleIds));
     }
 

ruoyi-admin/src/main/resources/application-dev.yml

@@ -130,8 +130,8 @@ spring:
     port: 6379
     # 数据库索引
     database: 0
-    # 密码
+    # 密码(如没有密码请注释掉)
-    password:
+    # password:
     # 连接超时时间
     timeout: 10s
     # 是否开启ssl
@@ -156,3 +156,37 @@ redisson:
     timeout: 3000
     # 发布和订阅连接池大小
     subscriptionConnectionPoolSize: 50
+
+--- # mail 邮件发送
+mail:
+  enabled: false
+  host: smtp.163.com
+  port: 465
+  # 是否需要用户名密码验证
+  auth: true
+  # 发送方，遵循RFC-822标准
+  from: xxx@163.com
+  # 用户名（注意：如果使用foxmail邮箱，此处user为qq号）
+  user: xxx@163.com
+  # 密码（注意，某些邮箱需要为SMTP服务单独设置密码，详情查看相关帮助）
+  pass: xxxxxxxxxx
+  # 使用 STARTTLS安全连接，STARTTLS是对纯文本通信协议的扩展。
+  starttlsEnable: true
+  # 使用SSL安全连接
+  sslEnable: true
+  # SMTP超时时长，单位毫秒，缺省值不超时
+  timeout: 0
+  # Socket连接超时值，单位毫秒，缺省值不超时
+  connectionTimeout: 0
+
+--- # sms 短信
+sms:
+  enabled: false
+  # 阿里云 dysmsapi.aliyuncs.com
+  # 腾讯云 sms.tencentcloudapi.com
+  endpoint: "dysmsapi.aliyuncs.com"
+  accessKeyId: xxxxxxx
+  accessKeySecret: xxxxxx
+  signName: 测试
+  # 腾讯专用
+  sdkAppId:

ruoyi-admin/src/main/resources/application-prod.yml

@@ -133,8 +133,8 @@ spring:
     port: 6379
     # 数据库索引
     database: 0
-    # 密码
+    # 密码(如没有密码请注释掉)
-    password:
+    # password:
     # 连接超时时间
     timeout: 10s
     # 是否开启ssl
@@ -159,3 +159,37 @@ redisson:
     timeout: 3000
     # 发布和订阅连接池大小
     subscriptionConnectionPoolSize: 50
+
+--- # mail 邮件发送
+mail:
+  enabled: false
+  host: smtp.163.com
+  port: 465
+  # 是否需要用户名密码验证
+  auth: true
+  # 发送方，遵循RFC-822标准
+  from: xxx@163.com
+  # 用户名（注意：如果使用foxmail邮箱，此处user为qq号）
+  user: xxx@163.com
+  # 密码（注意，某些邮箱需要为SMTP服务单独设置密码，详情查看相关帮助）
+  pass: xxxxxxxxxx
+  # 使用 STARTTLS安全连接，STARTTLS是对纯文本通信协议的扩展。
+  starttlsEnable: true
+  # 使用SSL安全连接
+  sslEnable: true
+  # SMTP超时时长，单位毫秒，缺省值不超时
+  timeout: 0
+  # Socket连接超时值，单位毫秒，缺省值不超时
+  connectionTimeout: 0
+
+--- # sms 短信
+sms:
+  enabled: false
+  # 阿里云 dysmsapi.aliyuncs.com
+  # 腾讯云 sms.tencentcloudapi.com
+  endpoint: "dysmsapi.aliyuncs.com"
+  accessKeyId: xxxxxxx
+  accessKeySecret: xxxxxx
+  signName: 测试
+  # 腾讯专用
+  sdkAppId:

ruoyi-admin/src/main/resources/application.yml

@@ -118,12 +118,6 @@ sa-token:
 security:
   # 排除路径
   excludes:
-    - /login
-    - /smsLogin
-    - /xcxLogin
-    - /logout
-    - /register
-    - /captchaImage
     # 静态资源
     - /*.html
     - /**/*.html

ruoyi-admin/src/main/resources/logback.xml

@@ -97,17 +97,9 @@
         <appender-ref ref="file_error"/>
     </appender>
 
-    <!-- 系统模块日志级别控制  -->
-    <logger name="com.ruoyi" level="info" />
-    <!-- Spring日志级别控制  -->
-    <logger name="org.springframework" level="warn" />
-
-    <root level="info">
-        <appender-ref ref="console" />
-    </root>
-
     <!--系统操作日志-->
     <root level="info">
+        <appender-ref ref="console" />
         <appender-ref ref="async_info" />
         <appender-ref ref="async_error" />
         <appender-ref ref="file_console" />

ruoyi-common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>ruoyi-vue-plus</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -58,12 +58,6 @@
             <artifactId>jackson-databind</artifactId>
         </dependency>
 
-        <!-- excel工具 -->
-        <dependency>
-            <groupId>org.apache.poi</groupId>
-            <artifactId>poi-ooxml</artifactId>
-        </dependency>
-
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>easyexcel</artifactId>
@@ -75,12 +69,6 @@
             <artifactId>snakeyaml</artifactId>
         </dependency>
 
-        <!-- jdk11 缺失依赖 jaxb-->
-        <dependency>
-            <groupId>com.sun.xml.bind</groupId>
-            <artifactId>jaxb-impl</artifactId>
-        </dependency>
-
         <!-- servlet包 -->
         <dependency>
             <groupId>javax.servlet</groupId>
@@ -127,6 +115,11 @@
             <artifactId>hutool-extra</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>com.sun.mail</groupId>
+            <artifactId>jakarta.mail</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

ruoyi-common/src/main/java/com/ruoyi/common/annotation/Anonymous.java

@@ -0,0 +1,18 @@
+package com.ruoyi.common.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 匿名访问不鉴权注解
+ *
+ * @author ruoyi
+ */
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Anonymous {
+}

ruoyi-common/src/main/java/com/ruoyi/common/annotation/CellMerge.java

@@ -0,0 +1,24 @@
+package com.ruoyi.common.annotation;
+
+import com.ruoyi.common.excel.CellMergeStrategy;
+
+import java.lang.annotation.*;
+
+/**
+ * excel 列单元格合并(合并列相同项)
+ *
+ * 需搭配 {@link CellMergeStrategy} 策略使用
+ *
+ * @author Lion Li
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface CellMerge {
+
+	/**
+	 * col index
+	 */
+	int index() default -1;
+
+}

ruoyi-common/src/main/java/com/ruoyi/common/core/domain/entity/SysUser.java

@@ -108,12 +108,6 @@ public class SysUser extends BaseEntity {
     )
     private String password;
 
-    @JsonIgnore
-    @JsonProperty
-    public String getPassword() {
-        return password;
-    }
-
     /**
      * 帐号状态（0正常 1停用）
      */

ruoyi-common/src/main/java/com/ruoyi/common/excel/CellMergeStrategy.java

@@ -0,0 +1,114 @@
+package com.ruoyi.common.excel;
+
+import com.alibaba.excel.metadata.Head;
+import com.alibaba.excel.write.merge.AbstractMergeStrategy;
+import com.ruoyi.common.annotation.CellMerge;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.util.CellRangeAddress;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 列值重复合并策略
+ *
+ * @author Lion Li
+ */
+@AllArgsConstructor
+@Slf4j
+public class CellMergeStrategy extends AbstractMergeStrategy {
+
+	private List<?> list;
+	private boolean hasTitle;
+
+	@Override
+	protected void merge(Sheet sheet, Cell cell, Head head, Integer relativeRowIndex) {
+		List<CellRangeAddress> cellList = handle(list, hasTitle);
+		// judge the list is not null
+		if (CollectionUtils.isNotEmpty(cellList)) {
+			// the judge is necessary
+			if (cell.getRowIndex() == 1 && cell.getColumnIndex() == 0) {
+				for (CellRangeAddress item : cellList) {
+					sheet.addMergedRegion(item);
+				}
+			}
+		}
+	}
+
+	@SneakyThrows
+	private static List<CellRangeAddress> handle(List<?> list, boolean hasTitle) {
+		List<CellRangeAddress> cellList = new ArrayList<>();
+		if (CollectionUtils.isEmpty(list)) {
+			return cellList;
+		}
+		Class<?> clazz = list.get(0).getClass();
+		Field[] fields = clazz.getDeclaredFields();
+		// 有注解的字段
+		List<Field> mergeFields = new ArrayList<>();
+		List<Integer> mergeFieldsIndex = new ArrayList<>();
+		for (int i = 0; i < fields.length; i++) {
+			Field field = fields[i];
+			if (field.isAnnotationPresent(CellMerge.class)) {
+				CellMerge cm = field.getAnnotation(CellMerge.class);
+				mergeFields.add(field);
+				mergeFieldsIndex.add(cm.index() == -1 ? i : cm.index());
+			}
+		}
+		// 行合并开始下标
+		int rowIndex = hasTitle ? 1 : 0;
+		Map<Field, RepeatCell> map = new HashMap<>();
+		// 生成两两合并单元格
+		for (int i = 0; i < list.size(); i++) {
+			for (int j = 0; j < mergeFields.size(); j++) {
+				Field field = mergeFields.get(j);
+				String name = field.getName();
+				String methodName = "get" + name.substring(0, 1).toUpperCase() + name.substring(1);
+				Method readMethod = clazz.getMethod(methodName);
+				Object val = readMethod.invoke(list.get(i));
+
+				int colNum = mergeFieldsIndex.get(j);
+				if (!map.containsKey(field)) {
+					map.put(field, new RepeatCell(val, i));
+				} else {
+					RepeatCell repeatCell = map.get(field);
+					Object cellValue = repeatCell.getValue();
+					if (cellValue == null || "".equals(cellValue)) {
+						// 空值跳过不合并
+						continue;
+					}
+					if (cellValue != val) {
+						if (i - repeatCell.getCurrent() > 1) {
+							cellList.add(new CellRangeAddress(repeatCell.getCurrent() + rowIndex, i + rowIndex - 1, colNum, colNum));
+						}
+						map.put(field, new RepeatCell(val, i));
+					} else if (i == list.size() - 1) {
+						if (i > repeatCell.getCurrent()) {
+							cellList.add(new CellRangeAddress(repeatCell.getCurrent() + rowIndex, i + rowIndex, colNum, colNum));
+						}
+					}
+				}
+			}
+		}
+		return cellList;
+	}
+
+	@Data
+	@AllArgsConstructor
+	static class RepeatCell {
+
+		private Object value;
+
+		private int current;
+
+	}
+}

ruoyi-common/src/main/java/com/ruoyi/common/helper/DataPermissionHelper.java

@@ -1,11 +1,11 @@
 package com.ruoyi.common.helper;
 
+import cn.dev33.satoken.context.SaHolder;
+import cn.dev33.satoken.context.model.SaStorage;
 import cn.hutool.core.util.ObjectUtil;
-import com.ruoyi.common.utils.ServletUtils;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 
-import javax.servlet.http.HttpServletRequest;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -33,11 +33,11 @@ public class DataPermissionHelper {
     }
 
     public static Map<String, Object> getContext() {
-        HttpServletRequest request = ServletUtils.getRequest();
+        SaStorage saStorage = SaHolder.getStorage();
-        Object attribute = request.getAttribute(DATA_PERMISSION_KEY);
+        Object attribute = saStorage.get(DATA_PERMISSION_KEY);
         if (ObjectUtil.isNull(attribute)) {
-            request.setAttribute(DATA_PERMISSION_KEY, new HashMap<>());
+            saStorage.set(DATA_PERMISSION_KEY, new HashMap<>());
-            attribute = request.getAttribute(DATA_PERMISSION_KEY);
+            attribute = saStorage.get(DATA_PERMISSION_KEY);
         }
         if (attribute instanceof Map) {
             return (Map<String, Object>) attribute;

ruoyi-common/src/main/java/com/ruoyi/common/helper/LoginHelper.java

@@ -1,5 +1,6 @@
 package com.ruoyi.common.helper;
 
+import cn.dev33.satoken.context.SaHolder;
 import cn.dev33.satoken.stp.StpUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.ruoyi.common.constant.UserConstants;
@@ -29,15 +30,13 @@ public class LoginHelper {
     public static final String JOIN_CODE = ":";
     public static final String LOGIN_USER_KEY = "loginUser";
 
-    private static final ThreadLocal<LoginUser> LOGIN_CACHE = new ThreadLocal<>();
-
     /**
      * 登录系统
      *
      * @param loginUser 登录用户信息
      */
     public static void login(LoginUser loginUser) {
-        LOGIN_CACHE.set(loginUser);
+        SaHolder.getStorage().set(LOGIN_USER_KEY, loginUser);
         StpUtil.login(loginUser.getLoginId());
         setLoginUser(loginUser);
     }
@@ -49,7 +48,7 @@ public class LoginHelper {
      * @param loginUser 登录用户信息
      */
     public static void loginByDevice(LoginUser loginUser, DeviceType deviceType) {
-        LOGIN_CACHE.set(loginUser);
+        SaHolder.getStorage().set(LOGIN_USER_KEY, loginUser);
         StpUtil.login(loginUser.getLoginId(), deviceType.getDevice());
         setLoginUser(loginUser);
     }
@@ -65,18 +64,13 @@ public class LoginHelper {
      * 获取用户(多级缓存)
      */
     public static LoginUser getLoginUser() {
-        LoginUser loginUser = LOGIN_CACHE.get();
+        LoginUser loginUser = (LoginUser) SaHolder.getStorage().get(LOGIN_USER_KEY);
         if (loginUser != null) {
             return loginUser;
         }
-        return (LoginUser) StpUtil.getTokenSession().get(LOGIN_USER_KEY);
+        loginUser = (LoginUser) StpUtil.getTokenSession().get(LOGIN_USER_KEY);
-    }
+        SaHolder.getStorage().set(LOGIN_USER_KEY, loginUser);
-
+        return loginUser;
-    /**
-     * 清除一级缓存 防止内存问题
-     */
-    public static void clearCache() {
-        LOGIN_CACHE.remove();
     }
 
     /**

ruoyi-common/src/main/java/com/ruoyi/common/jackson/SensitiveJsonSerializer.java

@@ -27,9 +27,9 @@ public class SensitiveJsonSerializer extends JsonSerializer<String> implements C
     public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
         SensitiveService sensitiveService = SpringUtils.getBean(SensitiveService.class);
         if (sensitiveService.isSensitive()) {
-            gen.writeString(value);
-        } else {
             gen.writeString(strategy.desensitizer().apply(value));
+        } else {
+            gen.writeString(value);
         }
 
     }

ruoyi-common/src/main/java/com/ruoyi/common/utils/email/MailUtils.java

@@ -0,0 +1,468 @@
+package com.ruoyi.common.utils.email;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.CharUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.mail.*;
+import com.ruoyi.common.utils.StringUtils;
+import com.ruoyi.common.utils.spring.SpringUtils;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+import javax.mail.Authenticator;
+import javax.mail.Session;
+import java.io.File;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * 邮件工具类
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class MailUtils {
+
+    private static final MailAccount ACCOUNT = SpringUtils.getBean(MailAccount.class);
+
+    /**
+     * 获取邮件发送实例
+     */
+    public static MailAccount getMailAccount() {
+        return ACCOUNT;
+    }
+
+    /**
+     * 获取邮件发送实例 (自定义发送人以及授权码)
+     *
+     * @param user 发送人
+     * @param pass 授权码
+     */
+    public static MailAccount getMailAccount(String from, String user, String pass) {
+        ACCOUNT.setFrom(StringUtils.blankToDefault(from, ACCOUNT.getFrom()));
+        ACCOUNT.setUser(StringUtils.blankToDefault(user, ACCOUNT.getUser()));
+        ACCOUNT.setPass(StringUtils.blankToDefault(pass, ACCOUNT.getPass()));
+        return ACCOUNT;
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送文本邮件，发送给单个或多个收件人<br>
+     * 多个收件人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to      收件人
+     * @param subject 标题
+     * @param content 正文
+     * @param files   附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String sendText(String to, String subject, String content, File... files) {
+        return send(to, subject, content, false, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送HTML邮件，发送给单个或多个收件人<br>
+     * 多个收件人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to      收件人
+     * @param subject 标题
+     * @param content 正文
+     * @param files   附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String sendHtml(String to, String subject, String content, File... files) {
+        return send(to, subject, content, true, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送单个或多个收件人<br>
+     * 多个收件人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to      收件人
+     * @param subject 标题
+     * @param content 正文
+     * @param isHtml  是否为HTML
+     * @param files   附件列表
+     * @return message-id
+     */
+    public static String send(String to, String subject, String content, boolean isHtml, File... files) {
+        return send(splitAddress(to), subject, content, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送单个或多个收件人<br>
+     * 多个收件人、抄送人、密送人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to      收件人，可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     * @param cc      抄送人，可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     * @param bcc     密送人，可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     * @param subject 标题
+     * @param content 正文
+     * @param isHtml  是否为HTML
+     * @param files   附件列表
+     * @return message-id
+     * @since 4.0.3
+     */
+    public static String send(String to, String cc, String bcc, String subject, String content, boolean isHtml, File... files) {
+        return send(splitAddress(to), splitAddress(cc), splitAddress(bcc), subject, content, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送文本邮件，发送给多人
+     *
+     * @param tos     收件人列表
+     * @param subject 标题
+     * @param content 正文
+     * @param files   附件列表
+     * @return message-id
+     */
+    public static String sendText(Collection<String> tos, String subject, String content, File... files) {
+        return send(tos, subject, content, false, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送HTML邮件，发送给多人
+     *
+     * @param tos     收件人列表
+     * @param subject 标题
+     * @param content 正文
+     * @param files   附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String sendHtml(Collection<String> tos, String subject, String content, File... files) {
+        return send(tos, subject, content, true, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送给多人
+     *
+     * @param tos     收件人列表
+     * @param subject 标题
+     * @param content 正文
+     * @param isHtml  是否为HTML
+     * @param files   附件列表
+     * @return message-id
+     */
+    public static String send(Collection<String> tos, String subject, String content, boolean isHtml, File... files) {
+        return send(tos, null, null, subject, content, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送给多人
+     *
+     * @param tos     收件人列表
+     * @param ccs     抄送人列表，可以为null或空
+     * @param bccs    密送人列表，可以为null或空
+     * @param subject 标题
+     * @param content 正文
+     * @param isHtml  是否为HTML
+     * @param files   附件列表
+     * @return message-id
+     * @since 4.0.3
+     */
+    public static String send(Collection<String> tos, Collection<String> ccs, Collection<String> bccs, String subject, String content, boolean isHtml, File... files) {
+        return send(getMailAccount(), true, tos, ccs, bccs, subject, content, null, isHtml, files);
+    }
+
+    // ------------------------------------------------------------------------------------------------------------------------------- Custom MailAccount
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount 邮件认证对象
+     * @param to          收件人，多个收件人逗号或者分号隔开
+     * @param subject     标题
+     * @param content     正文
+     * @param isHtml      是否为HTML格式
+     * @param files       附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String send(MailAccount mailAccount, String to, String subject, String content, boolean isHtml, File... files) {
+        return send(mailAccount, splitAddress(to), subject, content, isHtml, files);
+    }
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount 邮件帐户信息
+     * @param tos         收件人列表
+     * @param subject     标题
+     * @param content     正文
+     * @param isHtml      是否为HTML格式
+     * @param files       附件列表
+     * @return message-id
+     */
+    public static String send(MailAccount mailAccount, Collection<String> tos, String subject, String content, boolean isHtml, File... files) {
+        return send(mailAccount, tos, null, null, subject, content, isHtml, files);
+    }
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount 邮件帐户信息
+     * @param tos         收件人列表
+     * @param ccs         抄送人列表，可以为null或空
+     * @param bccs        密送人列表，可以为null或空
+     * @param subject     标题
+     * @param content     正文
+     * @param isHtml      是否为HTML格式
+     * @param files       附件列表
+     * @return message-id
+     * @since 4.0.3
+     */
+    public static String send(MailAccount mailAccount, Collection<String> tos, Collection<String> ccs, Collection<String> bccs, String subject, String content, boolean isHtml, File... files) {
+        return send(mailAccount, false, tos, ccs, bccs, subject, content, null, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送HTML邮件，发送给单个或多个收件人<br>
+     * 多个收件人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to       收件人
+     * @param subject  标题
+     * @param content  正文
+     * @param imageMap 图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param files    附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String sendHtml(String to, String subject, String content, Map<String, InputStream> imageMap, File... files) {
+        return send(to, subject, content, imageMap, true, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送单个或多个收件人<br>
+     * 多个收件人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to       收件人
+     * @param subject  标题
+     * @param content  正文
+     * @param imageMap 图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml   是否为HTML
+     * @param files    附件列表
+     * @return message-id
+     */
+    public static String send(String to, String subject, String content, Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        return send(splitAddress(to), subject, content, imageMap, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送单个或多个收件人<br>
+     * 多个收件人、抄送人、密送人可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     *
+     * @param to       收件人，可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     * @param cc       抄送人，可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     * @param bcc      密送人，可以使用逗号“,”分隔，也可以通过分号“;”分隔
+     * @param subject  标题
+     * @param content  正文
+     * @param imageMap 图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml   是否为HTML
+     * @param files    附件列表
+     * @return message-id
+     * @since 4.0.3
+     */
+    public static String send(String to, String cc, String bcc, String subject, String content, Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        return send(splitAddress(to), splitAddress(cc), splitAddress(bcc), subject, content, imageMap, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送HTML邮件，发送给多人
+     *
+     * @param tos      收件人列表
+     * @param subject  标题
+     * @param content  正文
+     * @param imageMap 图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param files    附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String sendHtml(Collection<String> tos, String subject, String content, Map<String, InputStream> imageMap, File... files) {
+        return send(tos, subject, content, imageMap, true, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送给多人
+     *
+     * @param tos      收件人列表
+     * @param subject  标题
+     * @param content  正文
+     * @param imageMap 图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml   是否为HTML
+     * @param files    附件列表
+     * @return message-id
+     */
+    public static String send(Collection<String> tos, String subject, String content, Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        return send(tos, null, null, subject, content, imageMap, isHtml, files);
+    }
+
+    /**
+     * 使用配置文件中设置的账户发送邮件，发送给多人
+     *
+     * @param tos      收件人列表
+     * @param ccs      抄送人列表，可以为null或空
+     * @param bccs     密送人列表，可以为null或空
+     * @param subject  标题
+     * @param content  正文
+     * @param imageMap 图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml   是否为HTML
+     * @param files    附件列表
+     * @return message-id
+     * @since 4.0.3
+     */
+    public static String send(Collection<String> tos, Collection<String> ccs, Collection<String> bccs, String subject, String content, Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        return send(getMailAccount(), true, tos, ccs, bccs, subject, content, imageMap, isHtml, files);
+    }
+
+    // ------------------------------------------------------------------------------------------------------------------------------- Custom MailAccount
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount 邮件认证对象
+     * @param to          收件人，多个收件人逗号或者分号隔开
+     * @param subject     标题
+     * @param content     正文
+     * @param imageMap    图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml      是否为HTML格式
+     * @param files       附件列表
+     * @return message-id
+     * @since 3.2.0
+     */
+    public static String send(MailAccount mailAccount, String to, String subject, String content, Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        return send(mailAccount, splitAddress(to), subject, content, imageMap, isHtml, files);
+    }
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount 邮件帐户信息
+     * @param tos         收件人列表
+     * @param subject     标题
+     * @param content     正文
+     * @param imageMap    图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml      是否为HTML格式
+     * @param files       附件列表
+     * @return message-id
+     * @since 4.6.3
+     */
+    public static String send(MailAccount mailAccount, Collection<String> tos, String subject, String content, Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        return send(mailAccount, tos, null, null, subject, content, imageMap, isHtml, files);
+    }
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount 邮件帐户信息
+     * @param tos         收件人列表
+     * @param ccs         抄送人列表，可以为null或空
+     * @param bccs        密送人列表，可以为null或空
+     * @param subject     标题
+     * @param content     正文
+     * @param imageMap    图片与占位符，占位符格式为cid:$IMAGE_PLACEHOLDER
+     * @param isHtml      是否为HTML格式
+     * @param files       附件列表
+     * @return message-id
+     * @since 4.6.3
+     */
+    public static String send(MailAccount mailAccount, Collection<String> tos, Collection<String> ccs, Collection<String> bccs, String subject, String content, Map<String, InputStream> imageMap,
+                              boolean isHtml, File... files) {
+        return send(mailAccount, false, tos, ccs, bccs, subject, content, imageMap, isHtml, files);
+    }
+
+    /**
+     * 根据配置文件，获取邮件客户端会话
+     *
+     * @param mailAccount 邮件账户配置
+     * @param isSingleton 是否单例（全局共享会话）
+     * @return {@link Session}
+     * @since 5.5.7
+     */
+    public static Session getSession(MailAccount mailAccount, boolean isSingleton) {
+        Authenticator authenticator = null;
+        if (mailAccount.isAuth()) {
+            authenticator = new UserPassAuthenticator(mailAccount.getUser(), mailAccount.getPass());
+        }
+
+        return isSingleton ? Session.getDefaultInstance(mailAccount.getSmtpProps(), authenticator) //
+            : Session.getInstance(mailAccount.getSmtpProps(), authenticator);
+    }
+
+    // ------------------------------------------------------------------------------------------------------------------------ Private method start
+
+    /**
+     * 发送邮件给多人
+     *
+     * @param mailAccount      邮件帐户信息
+     * @param useGlobalSession 是否全局共享Session
+     * @param tos              收件人列表
+     * @param ccs              抄送人列表，可以为null或空
+     * @param bccs             密送人列表，可以为null或空
+     * @param subject          标题
+     * @param content          正文
+     * @param imageMap         图片与占位符，占位符格式为cid:${cid}
+     * @param isHtml           是否为HTML格式
+     * @param files            附件列表
+     * @return message-id
+     * @since 4.6.3
+     */
+    private static String send(MailAccount mailAccount, boolean useGlobalSession, Collection<String> tos, Collection<String> ccs, Collection<String> bccs, String subject, String content,
+                               Map<String, InputStream> imageMap, boolean isHtml, File... files) {
+        final Mail mail = Mail.create(mailAccount).setUseGlobalSession(useGlobalSession);
+
+        // 可选抄送人
+        if (CollUtil.isNotEmpty(ccs)) {
+            mail.setCcs(ccs.toArray(new String[0]));
+        }
+        // 可选密送人
+        if (CollUtil.isNotEmpty(bccs)) {
+            mail.setBccs(bccs.toArray(new String[0]));
+        }
+
+        mail.setTos(tos.toArray(new String[0]));
+        mail.setTitle(subject);
+        mail.setContent(content);
+        mail.setHtml(isHtml);
+        mail.setFiles(files);
+
+        // 图片
+        if (MapUtil.isNotEmpty(imageMap)) {
+            for (Map.Entry<String, InputStream> entry : imageMap.entrySet()) {
+                mail.addImage(entry.getKey(), entry.getValue());
+                // 关闭流
+                IoUtil.close(entry.getValue());
+            }
+        }
+
+        return mail.send();
+    }
+
+    /**
+     * 将多个联系人转为列表，分隔符为逗号或者分号
+     *
+     * @param addresses 多个联系人，如果为空返回null
+     * @return 联系人列表
+     */
+    private static List<String> splitAddress(String addresses) {
+        if (StrUtil.isBlank(addresses)) {
+            return null;
+        }
+
+        List<String> result;
+        if (StrUtil.contains(addresses, CharUtil.COMMA)) {
+            result = StrUtil.splitTrim(addresses, CharUtil.COMMA);
+        } else if (StrUtil.contains(addresses, ';')) {
+            result = StrUtil.splitTrim(addresses, ';');
+        } else {
+            result = CollUtil.newArrayList(addresses);
+        }
+        return result;
+    }
+    // ------------------------------------------------------------------------------------------------------------------------ Private method end
+
+}

ruoyi-common/src/main/java/com/ruoyi/common/utils/file/MimeTypeUtils.java

@@ -0,0 +1,40 @@
+package com.ruoyi.common.utils.file;
+
+/**
+ * 媒体类型工具类
+ *
+ * @author ruoyi
+ */
+public class MimeTypeUtils {
+    public static final String IMAGE_PNG = "image/png";
+
+    public static final String IMAGE_JPG = "image/jpg";
+
+    public static final String IMAGE_JPEG = "image/jpeg";
+
+    public static final String IMAGE_BMP = "image/bmp";
+
+    public static final String IMAGE_GIF = "image/gif";
+
+    public static final String[] IMAGE_EXTENSION = {"bmp", "gif", "jpg", "jpeg", "png"};
+
+    public static final String[] FLASH_EXTENSION = {"swf", "flv"};
+
+    public static final String[] MEDIA_EXTENSION = {"swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
+        "asf", "rm", "rmvb"};
+
+    public static final String[] VIDEO_EXTENSION = {"mp4", "avi", "rmvb"};
+
+    public static final String[] DEFAULT_ALLOWED_EXTENSION = {
+        // 图片
+        "bmp", "gif", "jpg", "jpeg", "png",
+        // word excel powerpoint
+        "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
+        // 压缩文件
+        "rar", "zip", "gz", "bz2",
+        // 视频格式
+        "mp4", "avi", "rmvb",
+        // pdf
+        "pdf"};
+
+}

ruoyi-common/src/main/java/com/ruoyi/common/utils/poi/ExcelUtil.java

@@ -1,9 +1,17 @@
 package com.ruoyi.common.utils.poi;
 
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.io.resource.ClassPathResource;
 import cn.hutool.core.util.IdUtil;
 import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.ExcelWriter;
+import com.alibaba.excel.write.builder.ExcelWriterSheetBuilder;
+import com.alibaba.excel.write.metadata.WriteSheet;
+import com.alibaba.excel.write.metadata.fill.FillConfig;
+import com.alibaba.excel.write.metadata.fill.FillWrapper;
 import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
 import com.ruoyi.common.convert.ExcelBigNumberConvert;
+import com.ruoyi.common.excel.CellMergeStrategy;
 import com.ruoyi.common.excel.DefaultExcelListener;
 import com.ruoyi.common.excel.ExcelListener;
 import com.ruoyi.common.excel.ExcelResult;
@@ -16,7 +24,10 @@ import javax.servlet.ServletOutputStream;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Excel相关处理
@@ -69,27 +80,125 @@ public class ExcelUtil {
      *
      * @param list      导出数据集合
      * @param sheetName 工作表的名称
-     * @return 结果
+     * @param clazz     实体类
+     * @param response  响应体
      */
     public static <T> void exportExcel(List<T> list, String sheetName, Class<T> clazz, HttpServletResponse response) {
+        exportExcel(list, sheetName, clazz, false, response);
+    }
+
+    /**
+     * 导出excel
+     *
+     * @param list      导出数据集合
+     * @param sheetName 工作表的名称
+     * @param clazz     实体类
+     * @param merge     是否合并单元格
+     * @param response  响应体
+     */
+    public static <T> void exportExcel(List<T> list, String sheetName, Class<T> clazz, boolean merge, HttpServletResponse response) {
         try {
-            String filename = encodingFilename(sheetName);
+            resetResponse(sheetName, response);
-            response.reset();
-            FileUtils.setAttachmentResponseHeader(response, filename);
-            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8");
             ServletOutputStream os = response.getOutputStream();
-            EasyExcel.write(os, clazz)
+            ExcelWriterSheetBuilder builder = EasyExcel.write(os, clazz)
                 .autoCloseStream(false)
                 // 自动适配
                 .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
                 // 大数值自动转换 防止失真
                 .registerConverter(new ExcelBigNumberConvert())
-                .sheet(sheetName).doWrite(list);
+                .sheet(sheetName);
+            if (merge) {
+                // 合并处理器
+                builder.registerWriteHandler(new CellMergeStrategy(list, true));
+            }
+            builder.doWrite(list);
         } catch (IOException e) {
             throw new RuntimeException("导出Excel异常");
         }
     }
 
+    /**
+     * 单表多数据模板导出 模板格式为 {.属性}
+     *
+     * @param filename     文件名
+     * @param templatePath 模板路径 resource 目录下的路径包括模板文件名
+     *                     例如: excel/temp.xlsx
+     *                     重点: 模板文件必须放置到启动类对应的 resource 目录下
+     * @param data         模板需要的数据
+     */
+    public static void exportTemplate(List<Object> data, String filename, String templatePath, HttpServletResponse response) {
+        try {
+            resetResponse(filename, response);
+            ClassPathResource templateResource = new ClassPathResource(templatePath);
+            ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
+                .withTemplate(templateResource.getStream())
+                .autoCloseStream(false)
+                // 大数值自动转换 防止失真
+                .registerConverter(new ExcelBigNumberConvert())
+                .build();
+            WriteSheet writeSheet = EasyExcel.writerSheet().build();
+            if (CollUtil.isEmpty(data)) {
+                throw new IllegalArgumentException("数据为空");
+            }
+            // 单表多数据导出 模板格式为 {.属性}
+            for (Object d : data) {
+                excelWriter.fill(d, writeSheet);
+            }
+            excelWriter.finish();
+        } catch (IOException e) {
+            throw new RuntimeException("导出Excel异常");
+        }
+    }
+
+    /**
+     * 多表多数据模板导出 模板格式为 {key.属性}
+     *
+     * @param filename     文件名
+     * @param templatePath 模板路径 resource 目录下的路径包括模板文件名
+     *                     例如: excel/temp.xlsx
+     *                     重点: 模板文件必须放置到启动类对应的 resource 目录下
+     * @param data         模板需要的数据
+     */
+    public static void exportTemplateMultiList(Map<String, Object> data, String filename, String templatePath, HttpServletResponse response) {
+        try {
+            resetResponse(filename, response);
+            ClassPathResource templateResource = new ClassPathResource(templatePath);
+            ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
+                .withTemplate(templateResource.getStream())
+                .autoCloseStream(false)
+                // 大数值自动转换 防止失真
+                .registerConverter(new ExcelBigNumberConvert())
+                .build();
+            WriteSheet writeSheet = EasyExcel.writerSheet().build();
+            if (CollUtil.isEmpty(data)) {
+                throw new IllegalArgumentException("数据为空");
+            }
+            for (Map.Entry<String, Object> map : data.entrySet()) {
+                // 设置列表后续还有数据
+                FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
+                if (map.getValue() instanceof Collection) {
+                    // 多表导出必须使用 FillWrapper
+                    excelWriter.fill(new FillWrapper(map.getKey(), (Collection<?>) map.getValue()), fillConfig, writeSheet);
+                } else {
+                    excelWriter.fill(map.getValue(), writeSheet);
+                }
+            }
+            excelWriter.finish();
+        } catch (IOException e) {
+            throw new RuntimeException("导出Excel异常");
+        }
+    }
+
+    /**
+     * 重置响应体
+     */
+    private static void resetResponse(String sheetName, HttpServletResponse response) throws UnsupportedEncodingException {
+        String filename = encodingFilename(sheetName);
+        response.reset();
+        FileUtils.setAttachmentResponseHeader(response, filename);
+        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8");
+    }
+
     /**
      * 解析导出值 0=男,1=女,2=未知
      *
@@ -103,7 +212,7 @@ public class ExcelUtil {
         String[] convertSource = converterExp.split(",");
         for (String item : convertSource) {
             String[] itemArray = item.split("=");
-            if (StringUtils.containsAny(separator, propertyValue)) {
+            if (StringUtils.containsAny(propertyValue, separator)) {
                 for (String value : propertyValue.split(separator)) {
                     if (itemArray[0].equals(value)) {
                         propertyString.append(itemArray[1] + separator);
@@ -132,7 +241,7 @@ public class ExcelUtil {
         String[] convertSource = converterExp.split(",");
         for (String item : convertSource) {
             String[] itemArray = item.split("=");
-            if (StringUtils.containsAny(separator, propertyValue)) {
+            if (StringUtils.containsAny(propertyValue, separator)) {
                 for (String value : propertyValue.split(separator)) {
                     if (itemArray[1].equals(value)) {
                         propertyString.append(itemArray[0] + separator);

ruoyi-common/src/main/java/com/ruoyi/common/utils/redis/RedisUtils.java

@@ -6,11 +6,11 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.redisson.api.*;
 
+import java.time.Duration;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
 /**
@@ -107,7 +107,7 @@ public class RedisUtils {
             } catch (Exception e) {
                 long timeToLive = bucket.remainTimeToLive();
                 bucket.set(value);
-                bucket.expire(timeToLive, TimeUnit.MILLISECONDS);
+                bucket.expire(Duration.ofMillis(timeToLive));
             }
         } else {
             bucket.set(value);
@@ -119,13 +119,12 @@ public class RedisUtils {
      *
      * @param key      缓存的键值
      * @param value    缓存的值
-     * @param timeout  时间
+     * @param duration 时间
-     * @param timeUnit 时间颗粒度
      */
-    public static <T> void setCacheObject(final String key, final T value, final long timeout, final TimeUnit timeUnit) {
+    public static <T> void setCacheObject(final String key, final T value, final Duration duration) {
         RBucket<T> result = CLIENT.getBucket(key);
         result.set(value);
-        result.expire(timeout, timeUnit);
+        result.expire(duration);
     }
 
     /**
@@ -149,20 +148,19 @@ public class RedisUtils {
      * @return true=设置成功；false=设置失败
      */
     public static boolean expire(final String key, final long timeout) {
-        return expire(key, timeout, TimeUnit.SECONDS);
+        return expire(key, Duration.ofSeconds(timeout));
     }
 
     /**
      * 设置有效时间
      *
      * @param key      Redis键
-     * @param timeout 超时时间
+     * @param duration 超时时间
-     * @param unit    时间单位
      * @return true=设置成功；false=设置失败
      */
-    public static boolean expire(final String key, final long timeout, final TimeUnit unit) {
+    public static boolean expire(final String key, final Duration duration) {
         RBucket rBucket = CLIENT.getBucket(key);
-        return rBucket.expire(timeout, unit);
+        return rBucket.expire(duration);
     }
 
     /**
@@ -366,6 +364,50 @@ public class RedisUtils {
         return rMap.getAll(hKeys);
     }
 
+    /**
+     * 设置原子值
+     *
+     * @param key   Redis键
+     * @param value 值
+     */
+    public static void setAtomicValue(String key, long value) {
+        RAtomicLong atomic = CLIENT.getAtomicLong(key);
+        atomic.set(value);
+    }
+
+    /**
+     * 获取原子值
+     *
+     * @param key Redis键
+     * @return 当前值
+     */
+    public static long getAtomicValue(String key) {
+        RAtomicLong atomic = CLIENT.getAtomicLong(key);
+        return atomic.get();
+    }
+
+    /**
+     * 递增原子值
+     *
+     * @param key Redis键
+     * @return 当前值
+     */
+    public static long incrAtomicValue(String key) {
+        RAtomicLong atomic = CLIENT.getAtomicLong(key);
+        return atomic.incrementAndGet();
+    }
+
+    /**
+     * 递减原子值
+     *
+     * @param key Redis键
+     * @return 当前值
+     */
+    public static long decrAtomicValue(String key) {
+        RAtomicLong atomic = CLIENT.getAtomicLong(key);
+        return atomic.decrementAndGet();
+    }
+
     /**
      * 获得缓存的基本对象列表
      *

ruoyi-demo/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>ruoyi-vue-plus</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -23,6 +23,22 @@
             <artifactId>ruoyi-common</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>ruoyi-sms</artifactId>
+        </dependency>
+
+        <!-- 短信 用哪个导入哪个依赖 -->
+<!--        <dependency>-->
+<!--            <groupId>com.aliyun</groupId>-->
+<!--            <artifactId>dysmsapi20170525</artifactId>-->
+<!--        </dependency>-->
+
+<!--        <dependency>-->
+<!--            <groupId>com.tencentcloudapi</groupId>-->
+<!--            <artifactId>tencentcloud-sdk-java</artifactId>-->
+<!--        </dependency>-->
+
     </dependencies>
 
 </project>

ruoyi-demo/src/main/java/com/ruoyi/demo/controller/MailController.java

@@ -0,0 +1,48 @@
+package com.ruoyi.demo.controller;
+
+import com.ruoyi.common.core.domain.R;
+import com.ruoyi.common.utils.email.MailUtils;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.io.File;
+
+
+/**
+ * 邮件发送案例
+ *
+ * @author Michelle.Chung
+ */
+@Validated
+@Api(value = "邮件发送案例", tags = {"邮件发送案例"})
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/demo/mail")
+public class MailController {
+
+    @ApiOperation("发送邮件")
+    @GetMapping("/sendSimpleMessage")
+    public R<Void> sendSimpleMessage(@ApiParam("接收人") String to,
+                                     @ApiParam("标题") String subject,
+                                     @ApiParam("内容") String text) {
+        MailUtils.sendText(to, subject, text);
+        return R.ok();
+    }
+
+    @ApiOperation("发送邮件（带附件）")
+    @GetMapping("/sendMessageWithAttachment")
+    public R<Void> sendMessageWithAttachment(@ApiParam("接收人") String to,
+                                             @ApiParam("标题") String subject,
+                                             @ApiParam("内容") String text,
+                                             @ApiParam("附件路径") String filePath) {
+        MailUtils.sendText(to, subject, text, new File(filePath));
+        return R.ok();
+    }
+
+}

ruoyi-demo/src/main/java/com/ruoyi/demo/controller/RedisCacheController.java

@@ -12,7 +12,7 @@ import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;
 
 /**
  * spring-cache 演示案例
@@ -87,7 +87,7 @@ public class RedisCacheController {
     @GetMapping("/test6")
     public R<Boolean> test6(String key, String value) {
         RedisUtils.setCacheObject(key, value);
-        boolean flag = RedisUtils.expire(key, 10, TimeUnit.SECONDS);
+        boolean flag = RedisUtils.expire(key, Duration.ofSeconds(10));
         System.out.println("***********" + flag);
         try {
             Thread.sleep(11 * 1000);

ruoyi-demo/src/main/java/com/ruoyi/demo/controller/SmsController.java

@@ -0,0 +1,72 @@
+package com.ruoyi.demo.controller;
+
+import com.ruoyi.common.core.domain.R;
+import com.ruoyi.common.utils.spring.SpringUtils;
+import com.ruoyi.sms.config.properties.SmsProperties;
+import com.ruoyi.sms.core.SmsTemplate;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 短信演示案例
+ * 请先阅读文档 否则无法使用
+ *
+ * @author Lion Li
+ * @version 4.2.0
+ */
+@Validated
+@Api(value = "短信演示案例", tags = {"短信演示案例"})
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/demo/sms")
+public class SmsController {
+
+    private final SmsProperties smsProperties;
+//    private final SmsTemplate smsTemplate; // 可以使用spring注入
+//    private final AliyunSmsTemplate smsTemplate; // 也可以注入某个厂家的模板工具
+
+    @ApiOperation("发送短信Aliyun")
+    @GetMapping("/sendAliyun")
+    public R<Object> sendAliyun(@ApiParam("电话号") String phones,
+                                     @ApiParam("模板ID") String templateId) {
+        if (!smsProperties.getEnabled()) {
+            return R.fail("当前系统没有开启短信功能！");
+        }
+        if (!SpringUtils.containsBean("aliyunSmsTemplate")) {
+            return R.fail("阿里云依赖未引入！");
+        }
+        SmsTemplate smsTemplate = SpringUtils.getBean(SmsTemplate.class);
+        Map<String, String> map = new HashMap<>(1);
+        map.put("code", "1234");
+        Object send = smsTemplate.send(phones, templateId, map);
+        return R.ok(send);
+    }
+
+    @ApiOperation("发送短信Tencent")
+    @GetMapping("/sendTencent")
+    public R<Object> sendTencent(@ApiParam("电话号") String phones,
+                                             @ApiParam("模板ID") String templateId) {
+        if (!smsProperties.getEnabled()) {
+            return R.fail("当前系统没有开启短信功能！");
+        }
+        if (!SpringUtils.containsBean("tencentSmsTemplate")) {
+            return R.fail("腾讯云依赖未引入！");
+        }
+        SmsTemplate smsTemplate = SpringUtils.getBean(SmsTemplate.class);
+        Map<String, String> map = new HashMap<>(1);
+//        map.put("2", "测试测试");
+        map.put("1", "1234");
+        Object send = smsTemplate.send(phones, templateId, map);
+        return R.ok(send);
+    }
+
+}

ruoyi-demo/src/main/java/com/ruoyi/demo/controller/TestDemoController.java

@@ -29,6 +29,7 @@ import org.springframework.web.multipart.MultipartFile;
 import javax.servlet.http.HttpServletResponse;
 import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
+import java.io.File;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
@@ -70,7 +71,7 @@ public class TestDemoController extends BaseController {
 
     @ApiOperation("导入测试-校验")
     @ApiImplicitParams({
-        @ApiImplicitParam(name = "file", value = "导入文件", dataType = "java.io.File", required = true),
+        @ApiImplicitParam(name = "file", value = "导入文件", paramType = "query", dataTypeClass = File.class, required = true),
     })
     @Log(title = "测试单表", businessType = BusinessType.IMPORT)
     @SaCheckPermission("demo:demo:import")

ruoyi-demo/src/main/java/com/ruoyi/demo/controller/TestExcelController.java

@@ -0,0 +1,102 @@
+package com.ruoyi.demo.controller;
+
+import cn.hutool.core.collection.CollUtil;
+import com.ruoyi.common.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletResponse;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 测试Excel功能
+ *
+ * @author Lion Li
+ */
+@Api(value = "测试Excel功能", tags = {"测试Excel功能"})
+@RestController
+@RequestMapping("/demo/excel")
+public class TestExcelController {
+
+    /**
+     * 单列表多数据
+     */
+    @ApiOperation(value = "单列表多数据")
+    @GetMapping("/exportTemplateOne")
+    public void exportTemplateOne(HttpServletResponse response) {
+        Map<String,String> map = new HashMap<>();
+        map.put("title","单列表多数据");
+        map.put("test1","数据测试1");
+        map.put("test2","数据测试2");
+        map.put("test3","数据测试3");
+        map.put("test4","数据测试4");
+        map.put("testTest","666");
+        List<TestObj> list = new ArrayList<>();
+        list.add(new TestObj("单列表测试1", "列表测试1", "列表测试2", "列表测试3", "列表测试4"));
+        list.add(new TestObj("单列表测试2", "列表测试5", "列表测试6", "列表测试7", "列表测试8"));
+        list.add(new TestObj("单列表测试3", "列表测试9", "列表测试10", "列表测试11", "列表测试12"));
+        ExcelUtil.exportTemplate(CollUtil.newArrayList(map,list),"单列表.xlsx", "excel/单列表.xlsx", response);
+    }
+
+    /**
+     * 多列表多数据
+     */
+    @ApiOperation(value = "多列表多数据")
+    @GetMapping("/exportTemplateMuliti")
+    public void exportTemplateMuliti(HttpServletResponse response) {
+        Map<String,String> map = new HashMap<>();
+        map.put("title1","标题1");
+        map.put("title2","标题2");
+        map.put("title3","标题3");
+        map.put("title4","标题4");
+        map.put("author","Lion Li");
+        List<TestObj1> list1 = new ArrayList<>();
+        list1.add(new TestObj1("list1测试1", "list1测试2", "list1测试3"));
+        list1.add(new TestObj1("list1测试4", "list1测试5", "list1测试6"));
+        list1.add(new TestObj1("list1测试7", "list1测试8", "list1测试9"));
+        List<TestObj1> list2 = new ArrayList<>();
+        list2.add(new TestObj1("list2测试1", "list2测试2", "list2测试3"));
+        list2.add(new TestObj1("list2测试4", "list2测试5", "list2测试6"));
+        List<TestObj1> list3 = new ArrayList<>();
+        list3.add(new TestObj1("list3测试1", "list3测试2", "list3测试3"));
+        List<TestObj1> list4 = new ArrayList<>();
+        list4.add(new TestObj1("list4测试1", "list4测试2", "list4测试3"));
+        list4.add(new TestObj1("list4测试4", "list4测试5", "list4测试6"));
+        list4.add(new TestObj1("list4测试7", "list4测试8", "list4测试9"));
+        list4.add(new TestObj1("list4测试10", "list4测试11", "list4测试12"));
+        Map<String,Object> multiListMap = new HashMap<>();
+        multiListMap.put("map",map);
+        multiListMap.put("data1",list1);
+        multiListMap.put("data2",list2);
+        multiListMap.put("data3",list3);
+        multiListMap.put("data4",list4);
+        ExcelUtil.exportTemplateMultiList(multiListMap, "多列表.xlsx", "excel/多列表.xlsx", response);
+    }
+
+    @Data
+    @AllArgsConstructor
+    static class TestObj1 {
+        private String test1;
+        private String test2;
+        private String test3;
+    }
+
+    @Data
+    @AllArgsConstructor
+    static class TestObj {
+        private String name;
+        private String list1;
+        private String list2;
+        private String list3;
+        private String list4;
+    }
+
+}

ruoyi-demo/src/main/java/com/ruoyi/demo/domain/bo/TestDemoBo.java

@@ -49,7 +49,7 @@ public class TestDemoBo extends BaseEntity {
      */
     @ApiModelProperty("排序号")
     @NotNull(message = "排序号不能为空", groups = {AddGroup.class, EditGroup.class})
-    private Long orderNum;
+    private Integer orderNum;
 
     /**
      * key键

ruoyi-demo/src/main/java/com/ruoyi/demo/domain/vo/TestDemoVo.java

@@ -48,7 +48,7 @@ public class TestDemoVo {
      */
     @ExcelProperty(value = "排序号")
     @ApiModelProperty("排序号")
-    private Long orderNum;
+    private Integer orderNum;
 
     /**
      * key键

ruoyi-demo/src/main/java/com/ruoyi/demo/mapper/TestDemoMapper.java

@@ -54,5 +54,5 @@ public interface TestDemoMapper extends BaseMapperPlus<TestDemoMapper, TestDemo,
         @DataColumn(key = "deptName", value = "dept_id"),
         @DataColumn(key = "userName", value = "user_id")
     })
-    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);
+    int deleteBatchIds(@Param(Constants.COLL) Collection<?> idList);
 }

ruoyi-extend/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>ruoyi-vue-plus</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>ruoyi-extend</artifactId>

ruoyi-extend/ruoyi-monitor-admin/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>ruoyi-extend</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <packaging>jar</packaging>

ruoyi-extend/ruoyi-xxl-job-admin/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <artifactId>ruoyi-extend</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <artifactId>ruoyi-xxl-job-admin</artifactId>
     <packaging>jar</packaging>

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/IndexController.java

@@ -56,13 +56,13 @@ public class IndexController {
     @PermissionLimit(limit = false)
     public ModelAndView toLogin(HttpServletRequest request, HttpServletResponse response, ModelAndView modelAndView) {
         if (loginService.ifLogin(request, response) != null) {
-            modelAndView.setView(new RedirectView("/" , true, false));
+            modelAndView.setView(new RedirectView("/", true, false));
             return modelAndView;
         }
         return new ModelAndView("login");
     }
 
-    @RequestMapping(value = "login" , method = RequestMethod.POST)
+    @RequestMapping(value = "login", method = RequestMethod.POST)
     @ResponseBody
     @PermissionLimit(limit = false)
     public ReturnT<String> loginDo(HttpServletRequest request, HttpServletResponse response, String userName, String password, String ifRemember) {
@@ -70,7 +70,7 @@ public class IndexController {
         return loginService.login(request, response, userName, password, ifRem);
     }
 
-    @RequestMapping(value = "logout" , method = RequestMethod.POST)
+    @RequestMapping(value = "logout", method = RequestMethod.POST)
     @ResponseBody
     @PermissionLimit(limit = false)
     public ReturnT<String> logout(HttpServletRequest request, HttpServletResponse response) {

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/JobApiController.java

@@ -37,18 +37,18 @@ public class JobApiController {
      */
     @RequestMapping("/{uri}")
     @ResponseBody
-    @PermissionLimit(limit=false)
+    @PermissionLimit(limit = false)
     public ReturnT<String> api(HttpServletRequest request, @PathVariable("uri") String uri, @RequestBody(required = false) String data) {
 
         // valid
         if (!"POST".equalsIgnoreCase(request.getMethod())) {
             return new ReturnT<String>(ReturnT.FAIL_CODE, "invalid request, HttpMethod not support.");
         }
-        if (uri==null || uri.trim().length()==0) {
+        if (uri == null || uri.trim().length() == 0) {
             return new ReturnT<String>(ReturnT.FAIL_CODE, "invalid request, uri-mapping empty.");
         }
-        if (XxlJobAdminConfig.getAdminConfig().getAccessToken()!=null
+        if (XxlJobAdminConfig.getAdminConfig().getAccessToken() != null
-                && XxlJobAdminConfig.getAdminConfig().getAccessToken().trim().length()>0
+            && XxlJobAdminConfig.getAdminConfig().getAccessToken().trim().length() > 0
             && !XxlJobAdminConfig.getAdminConfig().getAccessToken().equals(request.getHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN))) {
             return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
         }
@@ -64,7 +64,7 @@ public class JobApiController {
             RegistryParam registryParam = GsonTool.fromJson(data, RegistryParam.class);
             return adminBiz.registryRemove(registryParam);
         } else {
-            return new ReturnT<String>(ReturnT.FAIL_CODE, "invalid request, uri-mapping("+ uri +") not found.");
+            return new ReturnT<String>(ReturnT.FAIL_CODE, "invalid request, uri-mapping(" + uri + ") not found.");
         }
 
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/JobCodeController.java

@@ -47,10 +47,10 @@ public class JobCodeController {
         JobInfoController.validPermission(request, jobInfo.getJobGroup());
 
         // Glue类型-字典
-        model.addAttribute("GlueTypeEnum" , GlueTypeEnum.values());
+        model.addAttribute("GlueTypeEnum", GlueTypeEnum.values());
 
-        model.addAttribute("jobInfo" , jobInfo);
+        model.addAttribute("jobInfo", jobInfo);
-        model.addAttribute("jobLogGlues" , jobLogGlues);
+        model.addAttribute("jobLogGlues", jobLogGlues);
         return "jobcode/jobcode.index";
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/JobGroupController.java

@@ -52,9 +52,9 @@ public class JobGroupController {
 
         // package result
         Map<String, Object> maps = new HashMap<String, Object>();
-        maps.put("recordsTotal" , list_count);        // 总记录数
+        maps.put("recordsTotal", list_count);        // 总记录数
-        maps.put("recordsFiltered" , list_count);    // 过滤后的总记录数
+        maps.put("recordsFiltered", list_count);    // 过滤后的总记录数
-        maps.put("data" , list);                    // 分页列表
+        maps.put("data", list);                    // 分页列表
         return maps;
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/JobInfoController.java

@@ -49,11 +49,11 @@ public class JobInfoController {
     public String index(HttpServletRequest request, Model model, @RequestParam(required = false, defaultValue = "-1") int jobGroup) {
 
         // 枚举-字典
-        model.addAttribute("ExecutorRouteStrategyEnum" , ExecutorRouteStrategyEnum.values());        // 路由策略-列表
+        model.addAttribute("ExecutorRouteStrategyEnum", ExecutorRouteStrategyEnum.values());        // 路由策略-列表
-        model.addAttribute("GlueTypeEnum" , GlueTypeEnum.values());                                // Glue类型-字典
+        model.addAttribute("GlueTypeEnum", GlueTypeEnum.values());                                // Glue类型-字典
-        model.addAttribute("ExecutorBlockStrategyEnum" , ExecutorBlockStrategyEnum.values());        // 阻塞处理策略-字典
+        model.addAttribute("ExecutorBlockStrategyEnum", ExecutorBlockStrategyEnum.values());        // 阻塞处理策略-字典
-        model.addAttribute("ScheduleTypeEnum" , ScheduleTypeEnum.values());                        // 调度类型
+        model.addAttribute("ScheduleTypeEnum", ScheduleTypeEnum.values());                        // 调度类型
-        model.addAttribute("MisfireStrategyEnum" , MisfireStrategyEnum.values());                    // 调度过期策略
+        model.addAttribute("MisfireStrategyEnum", MisfireStrategyEnum.values());                    // 调度过期策略
 
         // 执行器列表
         List<XxlJobGroup> jobGroupList_all = xxlJobGroupDao.findAll();
@@ -64,8 +64,8 @@ public class JobInfoController {
             throw new XxlJobException(I18nUtil.getString("jobgroup_empty"));
         }
 
-        model.addAttribute("JobGroupList" , jobGroupList);
+        model.addAttribute("JobGroupList", jobGroupList);
-        model.addAttribute("jobGroup" , jobGroup);
+        model.addAttribute("jobGroup", jobGroup);
 
         return "jobinfo/jobinfo.index";
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/JobLogController.java

@@ -1,7 +1,7 @@
 package com.xxl.job.admin.controller;
 
-import com.xxl.job.admin.core.complete.XxlJobCompleter;
 import com.xxl.job.admin.core.exception.XxlJobException;
+import com.xxl.job.admin.core.complete.XxlJobCompleter;
 import com.xxl.job.admin.core.model.XxlJobGroup;
 import com.xxl.job.admin.core.model.XxlJobInfo;
 import com.xxl.job.admin.core.model.XxlJobLog;
@@ -60,7 +60,7 @@ public class JobLogController {
             throw new XxlJobException(I18nUtil.getString("jobgroup_empty"));
         }
 
-        model.addAttribute("JobGroupList" , jobGroupList);
+        model.addAttribute("JobGroupList", jobGroupList);
 
         // 任务
         if (jobId > 0) {
@@ -69,7 +69,7 @@ public class JobLogController {
                 throw new RuntimeException(I18nUtil.getString("jobinfo_field_id") + I18nUtil.getString("system_unvalid"));
             }
 
-            model.addAttribute("jobInfo" , jobInfo);
+            model.addAttribute("jobInfo", jobInfo);
 
             // valid permission
             JobInfoController.validPermission(request, jobInfo.getJobGroup());
@@ -112,9 +112,9 @@ public class JobLogController {
 
         // package result
         Map<String, Object> maps = new HashMap<String, Object>();
-        maps.put("recordsTotal" , list_count);        // 总记录数
+        maps.put("recordsTotal", list_count);        // 总记录数
-        maps.put("recordsFiltered" , list_count);    // 过滤后的总记录数
+        maps.put("recordsFiltered", list_count);    // 过滤后的总记录数
-        maps.put("data" , list);                    // 分页列表
+        maps.put("data", list);                    // 分页列表
         return maps;
     }
 
@@ -128,11 +128,11 @@ public class JobLogController {
             throw new RuntimeException(I18nUtil.getString("joblog_logid_unvalid"));
         }
 
-        model.addAttribute("triggerCode" , jobLog.getTriggerCode());
+        model.addAttribute("triggerCode", jobLog.getTriggerCode());
-        model.addAttribute("handleCode" , jobLog.getHandleCode());
+        model.addAttribute("handleCode", jobLog.getHandleCode());
-        model.addAttribute("executorAddress" , jobLog.getExecutorAddress());
+        model.addAttribute("executorAddress", jobLog.getExecutorAddress());
-        model.addAttribute("triggerTime" , jobLog.getTriggerTime().getTime());
+        model.addAttribute("triggerTime", jobLog.getTriggerTime().getTime());
-        model.addAttribute("logId" , jobLog.getId());
+        model.addAttribute("logId", jobLog.getId());
         return "joblog/joblog.detail";
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/UserController.java

@@ -40,7 +40,7 @@ public class UserController {
 
         // 执行器列表
         List<XxlJobGroup> groupList = xxlJobGroupDao.findAll();
-        model.addAttribute("groupList" , groupList);
+        model.addAttribute("groupList", groupList);
 
         return "user/user.index";
     }
@@ -65,9 +65,9 @@ public class UserController {
 
         // package result
         Map<String, Object> maps = new HashMap<String, Object>();
-        maps.put("recordsTotal" , list_count);        // 总记录数
+        maps.put("recordsTotal", list_count);        // 总记录数
-        maps.put("recordsFiltered" , list_count);    // 过滤后的总记录数
+        maps.put("recordsFiltered", list_count);    // 过滤后的总记录数
-        maps.put("data" , list);                      // 分页列表
+        maps.put("data", list);                    // 分页列表
         return maps;
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/interceptor/CookieInterceptor.java

@@ -29,15 +29,14 @@ public class CookieInterceptor implements AsyncHandlerInterceptor {
             for (Cookie ck : request.getCookies()) {
                 cookieMap.put(ck.getName(), ck);
             }
-            modelAndView.addObject("cookieMap" , cookieMap);
+            modelAndView.addObject("cookieMap", cookieMap);
         }
 
         // static method
         if (modelAndView != null) {
-            modelAndView.addObject("I18nUtil" , FtlUtil.generateStaticModel(I18nUtil.class.getName()));
+            modelAndView.addObject("I18nUtil", FtlUtil.generateStaticModel(I18nUtil.class.getName()));
         }
 
-        AsyncHandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
     }
 
 }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/interceptor/PermissionInterceptor.java

@@ -27,7 +27,7 @@ public class PermissionInterceptor implements AsyncHandlerInterceptor {
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 
         if (!(handler instanceof HandlerMethod)) {
-            return AsyncHandlerInterceptor.super.preHandle(request, response, handler);
+            return true;    // proceed with the next interceptor
         }
 
         // if need login
@@ -44,7 +44,7 @@ public class PermissionInterceptor implements AsyncHandlerInterceptor {
             XxlJobUser loginUser = loginService.ifLogin(request, response);
             if (loginUser == null) {
                 response.setStatus(302);
-                response.setHeader("location" , request.getContextPath() + "/toLogin");
+                response.setHeader("location", request.getContextPath() + "/toLogin");
                 return false;
             }
             if (needAdminuser && loginUser.getRole() != 1) {
@@ -53,7 +53,7 @@ public class PermissionInterceptor implements AsyncHandlerInterceptor {
             request.setAttribute(LoginService.LOGIN_IDENTITY_KEY, loginUser);
         }
 
-        return AsyncHandlerInterceptor.super.preHandle(request, response, handler);
+        return true;    // proceed with the next interceptor
     }
 
 }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/controller/resolver/WebExceptionResolver.java

@@ -1,8 +1,8 @@
 package com.xxl.job.admin.controller.resolver;
 
 import com.xxl.job.admin.core.exception.XxlJobException;
-import com.xxl.job.admin.core.util.JacksonUtil;
 import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.admin.core.util.JacksonUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
@@ -29,7 +29,7 @@ public class WebExceptionResolver implements HandlerExceptionResolver {
                                          HttpServletResponse response, Object handler, Exception ex) {
 
         if (!(ex instanceof XxlJobException)) {
-            logger.error("WebExceptionResolver:{}" , ex);
+            logger.error("WebExceptionResolver:{}", ex);
         }
 
         // if json
@@ -43,7 +43,7 @@ public class WebExceptionResolver implements HandlerExceptionResolver {
         }
 
         // error result
-        ReturnT<String> errorResult = new ReturnT<String>(ReturnT.FAIL_CODE, ex.toString().replaceAll("\n" , "<br/>"));
+        ReturnT<String> errorResult = new ReturnT<String>(ReturnT.FAIL_CODE, ex.toString().replaceAll("\n", "<br/>"));
 
         // response
         ModelAndView mv = new ModelAndView();
@@ -57,7 +57,7 @@ public class WebExceptionResolver implements HandlerExceptionResolver {
             return mv;
         } else {
 
-            mv.addObject("exceptionMsg" , errorResult.getMsg());
+            mv.addObject("exceptionMsg", errorResult.getMsg());
             mv.setViewName("/common/common.exception");
             return mv;
         }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/alarm/JobAlarmer.java

@@ -44,9 +44,9 @@ public class JobAlarmer implements ApplicationContextAware, InitializingBean {
     public boolean alarm(XxlJobInfo info, XxlJobLog jobLog) {
 
         boolean result = false;
-        if (jobAlarmList!=null && jobAlarmList.size()>0) {
+        if (jobAlarmList != null && jobAlarmList.size() > 0) {
             result = true;  // success means all-success
-            for (JobAlarm alarm: jobAlarmList) {
+            for (JobAlarm alarm : jobAlarmList) {
                 boolean resultItem = false;
                 try {
                     resultItem = alarm.doAlarm(info, jobLog);

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/alarm/impl/EmailJobAlarm.java

@@ -32,18 +32,19 @@ public class EmailJobAlarm implements JobAlarm {
      *
      * @param jobLog
      */
-    public boolean doAlarm(XxlJobInfo info, XxlJobLog jobLog){
+    @Override
+    public boolean doAlarm(XxlJobInfo info, XxlJobLog jobLog) {
         boolean alarmResult = true;
 
         // send monitor email
-        if (info!=null && info.getAlarmEmail()!=null && info.getAlarmEmail().trim().length()>0) {
+        if (info != null && info.getAlarmEmail() != null && info.getAlarmEmail().trim().length() > 0) {
 
             // alarmContent
             String alarmContent = "Alarm Job LogId=" + jobLog.getId();
             if (jobLog.getTriggerCode() != ReturnT.SUCCESS_CODE) {
                 alarmContent += "<br>TriggerMsg=<br>" + jobLog.getTriggerMsg();
             }
-            if (jobLog.getHandleCode()>0 && jobLog.getHandleCode() != ReturnT.SUCCESS_CODE) {
+            if (jobLog.getHandleCode() > 0 && jobLog.getHandleCode() != ReturnT.SUCCESS_CODE) {
                 alarmContent += "<br>HandleCode=" + jobLog.getHandleMsg();
             }
 
@@ -52,13 +53,13 @@ public class EmailJobAlarm implements JobAlarm {
             String personal = I18nUtil.getString("admin_name_full");
             String title = I18nUtil.getString("jobconf_monitor");
             String content = MessageFormat.format(loadEmailJobAlarmTemplate(),
-                    group!=null?group.getTitle():"null",
+                group != null ? group.getTitle() : "null",
                 info.getId(),
                 info.getJobDesc(),
                 alarmContent);
 
             Set<String> emailSet = new HashSet<String>(Arrays.asList(info.getAlarmEmail().split(",")));
-            for (String email: emailSet) {
+            for (String email : emailSet) {
 
                 // make mail
                 try {
@@ -88,16 +89,16 @@ public class EmailJobAlarm implements JobAlarm {
      *
      * @return
      */
-    private static final String loadEmailJobAlarmTemplate(){
+    private static final String loadEmailJobAlarmTemplate() {
         String mailBodyTemplate = "<h5>" + I18nUtil.getString("jobconf_monitor_detail") + "：</span>" +
             "<table border=\"1\" cellpadding=\"3\" style=\"border-collapse:collapse; width:80%;\" >\n" +
             "   <thead style=\"font-weight: bold;color: #ffffff;background-color: #ff8c00;\" >" +
             "      <tr>\n" +
-                "         <td width=\"20%\" >"+ I18nUtil.getString("jobinfo_field_jobgroup") +"</td>\n" +
+            "         <td width=\"20%\" >" + I18nUtil.getString("jobinfo_field_jobgroup") + "</td>\n" +
-                "         <td width=\"10%\" >"+ I18nUtil.getString("jobinfo_field_id") +"</td>\n" +
+            "         <td width=\"10%\" >" + I18nUtil.getString("jobinfo_field_id") + "</td>\n" +
-                "         <td width=\"20%\" >"+ I18nUtil.getString("jobinfo_field_jobdesc") +"</td>\n" +
+            "         <td width=\"20%\" >" + I18nUtil.getString("jobinfo_field_jobdesc") + "</td>\n" +
-                "         <td width=\"10%\" >"+ I18nUtil.getString("jobconf_monitor_alarm_title") +"</td>\n" +
+            "         <td width=\"10%\" >" + I18nUtil.getString("jobconf_monitor_alarm_title") + "</td>\n" +
-                "         <td width=\"40%\" >"+ I18nUtil.getString("jobconf_monitor_alarm_content") +"</td>\n" +
+            "         <td width=\"40%\" >" + I18nUtil.getString("jobconf_monitor_alarm_content") + "</td>\n" +
             "      </tr>\n" +
             "   </thead>\n" +
             "   <tbody>\n" +
@@ -105,7 +106,7 @@ public class EmailJobAlarm implements JobAlarm {
             "         <td>{0}</td>\n" +
             "         <td>{1}</td>\n" +
             "         <td>{2}</td>\n" +
-                "         <td>"+ I18nUtil.getString("jobconf_monitor_alarm_type") +"</td>\n" +
+            "         <td>" + I18nUtil.getString("jobconf_monitor_alarm_type") + "</td>\n" +
             "         <td>{3}</td>\n" +
             "      </tr>\n" +
             "   </tbody>\n" +

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/complete/XxlJobCompleter.java

@@ -32,7 +32,7 @@ public class XxlJobCompleter {
 
         // text最大64kb 避免长度过长
         if (xxlJobLog.getHandleMsg().length() > 15000) {
-            xxlJobLog.setHandleMsg( xxlJobLog.getHandleMsg().substring(0, 15000) );
+            xxlJobLog.setHandleMsg(xxlJobLog.getHandleMsg().substring(0, 15000));
         }
 
         // fresh handle
@@ -43,18 +43,18 @@ public class XxlJobCompleter {
     /**
      * do somethind to finish job
      */
-    private static void finishJob(XxlJobLog xxlJobLog){
+    private static void finishJob(XxlJobLog xxlJobLog) {
 
         // 1、handle success, to trigger child job
         String triggerChildMsg = null;
-        if (XxlJobContext.HANDLE_COCE_SUCCESS == xxlJobLog.getHandleCode()) {
+        if (XxlJobContext.HANDLE_CODE_SUCCESS == xxlJobLog.getHandleCode()) {
             XxlJobInfo xxlJobInfo = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(xxlJobLog.getJobId());
-            if (xxlJobInfo!=null && xxlJobInfo.getChildJobId()!=null && xxlJobInfo.getChildJobId().trim().length()>0) {
+            if (xxlJobInfo != null && xxlJobInfo.getChildJobId() != null && xxlJobInfo.getChildJobId().trim().length() > 0) {
-                triggerChildMsg = "<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>"+ I18nUtil.getString("jobconf_trigger_child_run") +"<<<<<<<<<<< </span><br>";
+                triggerChildMsg = "<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_child_run") + "<<<<<<<<<<< </span><br>";
 
                 String[] childJobIds = xxlJobInfo.getChildJobId().split(",");
                 for (int i = 0; i < childJobIds.length; i++) {
-                    int childJobId = (childJobIds[i]!=null && childJobIds[i].trim().length()>0 && isNumeric(childJobIds[i]))?Integer.valueOf(childJobIds[i]):-1;
+                    int childJobId = (childJobIds[i] != null && childJobIds[i].trim().length() > 0 && isNumeric(childJobIds[i])) ? Integer.valueOf(childJobIds[i]) : -1;
                     if (childJobId > 0) {
 
                         JobTriggerPoolHelper.trigger(childJobId, TriggerTypeEnum.PARENT, -1, null, null, null);
@@ -62,14 +62,14 @@ public class XxlJobCompleter {
 
                         // add msg
                         triggerChildMsg += MessageFormat.format(I18nUtil.getString("jobconf_callback_child_msg1"),
-                                (i+1),
+                            (i + 1),
                             childJobIds.length,
                             childJobIds[i],
-                                (triggerChildResult.getCode()==ReturnT.SUCCESS_CODE?I18nUtil.getString("system_success"):I18nUtil.getString("system_fail")),
+                            (triggerChildResult.getCode() == ReturnT.SUCCESS_CODE ? I18nUtil.getString("system_success") : I18nUtil.getString("system_fail")),
                             triggerChildResult.getMsg());
                     } else {
                         triggerChildMsg += MessageFormat.format(I18nUtil.getString("jobconf_callback_child_msg2"),
-                                (i+1),
+                            (i + 1),
                             childJobIds.length,
                             childJobIds[i]);
                     }
@@ -79,7 +79,7 @@ public class XxlJobCompleter {
         }
 
         if (triggerChildMsg != null) {
-            xxlJobLog.setHandleMsg( xxlJobLog.getHandleMsg() + triggerChildMsg );
+            xxlJobLog.setHandleMsg(xxlJobLog.getHandleMsg() + triggerChildMsg);
         }
 
         // 2、fix_delay trigger next
@@ -87,7 +87,7 @@ public class XxlJobCompleter {
 
     }
 
-    private static boolean isNumeric(String str){
+    private static boolean isNumeric(String str) {
         try {
             int result = Integer.valueOf(str);
             return true;

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/conf/XxlJobAdminConfig.java

@@ -23,6 +23,7 @@ import java.util.Arrays;
 public class XxlJobAdminConfig implements InitializingBean, DisposableBean {
 
     private static XxlJobAdminConfig adminConfig = null;
+
     public static XxlJobAdminConfig getAdminConfig() {
         return adminConfig;
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/cron/CronExpression.java

@@ -191,13 +191,11 @@ import java.util.TreeSet;
  * </ul>
  * </p>
  *
- * 
  * @author Sharada Jambula, James House
  * @author Contributions from Mads Henderson
  * @author Refactoring from CronTrigger to CronExpression by Aaron Craven
- *
+ * <p>
  * Borrowed from quartz v2.3.1
- *
  */
 public final class CronExpression implements Serializable, Cloneable {
 
@@ -217,6 +215,7 @@ public final class CronExpression implements Serializable, Cloneable {
 
     protected static final Map<String, Integer> monthMap = new HashMap<String, Integer>(20);
     protected static final Map<String, Integer> dayMap = new HashMap<String, Integer>(60);
+
     static {
         monthMap.put("JAN", 0);
         monthMap.put("FEB", 1);
@@ -265,8 +264,7 @@ public final class CronExpression implements Serializable, Cloneable {
      *
      * @param cronExpression String representation of the cron expression the
      *                       new object should represent
-     * @throws java.text.ParseException
+     * @throws ParseException if the string expression cannot be parsed into a valid
-     *         if the string expression cannot be parsed into a valid 
      *                        <CODE>CronExpression</CODE>
      */
     public CronExpression(String cronExpression) throws ParseException {
@@ -283,8 +281,7 @@ public final class CronExpression implements Serializable, Cloneable {
      * Constructs a new {@code CronExpression} as a copy of an existing
      * instance.
      *
-     * @param expression
+     * @param expression The existing cron expression to be copied
-     *            The existing cron expression to be copied
      */
     public CronExpression(CronExpression expression) {
         /*
@@ -363,7 +360,7 @@ public final class CronExpression implements Serializable, Cloneable {
         // the second immediately following it.
         while (difference == 1000) {
             newDate = getTimeAfter(lastDate);
-            if(newDate == null)
+            if (newDate == null)
                 break;
 
             difference = newDate.getTime() - lastDate.getTime();
@@ -473,14 +470,14 @@ public final class CronExpression implements Serializable, Cloneable {
                 String expr = exprsTok.nextToken().trim();
 
                 // throw an exception if L is used with other days of the month
-                if(exprOn == DAY_OF_MONTH && expr.indexOf('L') != -1 && expr.length() > 1 && expr.contains(",")) {
+                if (exprOn == DAY_OF_MONTH && expr.indexOf('L') != -1 && expr.length() > 1 && expr.contains(",")) {
                     throw new ParseException("Support for specifying 'L' and 'LW' with other days of the month is not implemented", -1);
                 }
                 // throw an exception if L is used with other days of the week
-                if(exprOn == DAY_OF_WEEK && expr.indexOf('L') != -1 && expr.length() > 1  && expr.contains(",")) {
+                if (exprOn == DAY_OF_WEEK && expr.indexOf('L') != -1 && expr.length() > 1 && expr.contains(",")) {
                     throw new ParseException("Support for specifying 'L' with other days of the week is not implemented", -1);
                 }
-                if(exprOn == DAY_OF_WEEK && expr.indexOf('#') != -1 && expr.indexOf('#', expr.indexOf('#') +1) != -1) {
+                if (exprOn == DAY_OF_WEEK && expr.indexOf('#') != -1 && expr.indexOf('#', expr.indexOf('#') + 1) != -1) {
                     throw new ParseException("Support for specifying multiple \"nth\" days is not implemented.", -1);
                 }
 
@@ -663,18 +660,18 @@ public final class CronExpression implements Serializable, Cloneable {
             if (type == DAY_OF_WEEK) {
                 addToSet(7, 7, 0, type);
             }
-            if(type == DAY_OF_MONTH && s.length() > i) {
+            if (type == DAY_OF_MONTH && s.length() > i) {
                 c = s.charAt(i);
-                if(c == '-') {
+                if (c == '-') {
-                    ValueSet vs = getValue(0, s, i+1);
+                    ValueSet vs = getValue(0, s, i + 1);
                     lastdayOffset = vs.value;
-                    if(lastdayOffset > 30)
+                    if (lastdayOffset > 30)
-                        throw new ParseException("Offset from last day must be <= 30", i+1);
+                        throw new ParseException("Offset from last day must be <= 30", i + 1);
                     i = vs.pos;
                 }
-                if(s.length() > i) {
+                if (s.length() > i) {
                     c = s.charAt(i);
-                    if(c == 'W') {
+                    if (c == 'W') {
                         nearestWeekday = true;
                         i++;
                     }
@@ -732,7 +729,7 @@ public final class CronExpression implements Serializable, Cloneable {
 
         if (c == 'L') {
             if (type == DAY_OF_WEEK) {
-                if(val < 1 || val > 7)
+                if (val < 1 || val > 7)
                     throw new ParseException("Day-of-Week values must be between 1 and 7", -1);
                 lastdayOfWeek = true;
             } else {
@@ -750,7 +747,7 @@ public final class CronExpression implements Serializable, Cloneable {
             } else {
                 throw new ParseException("'W' option is not valid here. (pos=" + i + ")", i);
             }
-            if(val > 31)
+            if (val > 31)
                 throw new ParseException("The 'W' option does not make sense with values larger than 31 (max number of days in a month)", i);
             TreeSet<Integer> set = getSet(type);
             set.add(val);
@@ -1067,14 +1064,28 @@ public final class CronExpression implements Serializable, Cloneable {
         int max = -1;
         if (stopAt < startAt) {
             switch (type) {
-              case       SECOND : max = 60; break;
+                case SECOND:
-              case       MINUTE : max = 60; break;
+                    max = 60;
-              case         HOUR : max = 24; break;
+                    break;
-              case        MONTH : max = 12; break;
+                case MINUTE:
-              case  DAY_OF_WEEK : max = 7;  break;
+                    max = 60;
-              case DAY_OF_MONTH : max = 31; break;
+                    break;
-              case         YEAR : throw new IllegalArgumentException("Start year must be less than stop year");
+                case HOUR:
-              default           : throw new IllegalArgumentException("Unexpected type encountered");
+                    max = 24;
+                    break;
+                case MONTH:
+                    max = 12;
+                    break;
+                case DAY_OF_WEEK:
+                    max = 7;
+                    break;
+                case DAY_OF_MONTH:
+                    max = 31;
+                    break;
+                case YEAR:
+                    throw new IllegalArgumentException("Start year must be less than stop year");
+                default:
+                    throw new IllegalArgumentException("Unexpected type encountered");
             }
             stopAt += max;
         }
@@ -1088,7 +1099,7 @@ public final class CronExpression implements Serializable, Cloneable {
                 int i2 = i % max;
 
                 // 1-indexed ranges should not include 0, and should include their max
-                if (i2 == 0 && (type == MONTH || type == DAY_OF_WEEK || type == DAY_OF_MONTH) ) {
+                if (i2 == 0 && (type == MONTH || type == DAY_OF_WEEK || type == DAY_OF_MONTH)) {
                     i2 = max;
                 }
 
@@ -1185,7 +1196,7 @@ public final class CronExpression implements Serializable, Cloneable {
         while (!gotOne) {
 
             //if (endTime != null && cl.getTime().after(endTime)) return null;
-            if(cl.get(Calendar.YEAR) > 2999) { // prevent endless loop...
+            if (cl.get(Calendar.YEAR) > 2999) { // prevent endless loop...
                 return null;
             }
 
@@ -1262,13 +1273,13 @@ public final class CronExpression implements Serializable, Cloneable {
             if (dayOfMSpec && !dayOfWSpec) { // get day by day of month rule
                 st = daysOfMonth.tailSet(day);
                 if (lastdayOfMonth) {
-                    if(!nearestWeekday) {
+                    if (!nearestWeekday) {
                         t = day;
                         day = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                         day -= lastdayOffset;
-                        if(t > day) {
+                        if (t > day) {
                             mon++;
-                            if(mon > 12) { 
+                            if (mon > 12) {
                                 mon = 1;
                                 tmon = 3333; // ensure test of mon != tmon further below fails
                                 cl.add(Calendar.YEAR, 1);
@@ -1280,7 +1291,7 @@ public final class CronExpression implements Serializable, Cloneable {
                         day = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                         day -= lastdayOffset;
 
-                        java.util.Calendar tcal = java.util.Calendar.getInstance(getTimeZone());
+                        Calendar tcal = Calendar.getInstance(getTimeZone());
                         tcal.set(Calendar.SECOND, 0);
                         tcal.set(Calendar.MINUTE, 0);
                         tcal.set(Calendar.HOUR_OF_DAY, 0);
@@ -1291,13 +1302,13 @@ public final class CronExpression implements Serializable, Cloneable {
                         int ldom = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                         int dow = tcal.get(Calendar.DAY_OF_WEEK);
 
-                        if(dow == Calendar.SATURDAY && day == 1) {
+                        if (dow == Calendar.SATURDAY && day == 1) {
                             day += 2;
-                        } else if(dow == Calendar.SATURDAY) {
+                        } else if (dow == Calendar.SATURDAY) {
                             day -= 1;
-                        } else if(dow == Calendar.SUNDAY && day == ldom) { 
+                        } else if (dow == Calendar.SUNDAY && day == ldom) {
                             day -= 2;
-                        } else if(dow == Calendar.SUNDAY) { 
+                        } else if (dow == Calendar.SUNDAY) {
                             day += 1;
                         }
 
@@ -1307,16 +1318,16 @@ public final class CronExpression implements Serializable, Cloneable {
                         tcal.set(Calendar.DAY_OF_MONTH, day);
                         tcal.set(Calendar.MONTH, mon - 1);
                         Date nTime = tcal.getTime();
-                        if(nTime.before(afterTime)) {
+                        if (nTime.before(afterTime)) {
                             day = 1;
                             mon++;
                         }
                     }
-                } else if(nearestWeekday) {
+                } else if (nearestWeekday) {
                     t = day;
                     day = daysOfMonth.first();
 
-                    java.util.Calendar tcal = java.util.Calendar.getInstance(getTimeZone());
+                    Calendar tcal = Calendar.getInstance(getTimeZone());
                     tcal.set(Calendar.SECOND, 0);
                     tcal.set(Calendar.MINUTE, 0);
                     tcal.set(Calendar.HOUR_OF_DAY, 0);
@@ -1327,13 +1338,13 @@ public final class CronExpression implements Serializable, Cloneable {
                     int ldom = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                     int dow = tcal.get(Calendar.DAY_OF_WEEK);
 
-                    if(dow == Calendar.SATURDAY && day == 1) {
+                    if (dow == Calendar.SATURDAY && day == 1) {
                         day += 2;
-                    } else if(dow == Calendar.SATURDAY) {
+                    } else if (dow == Calendar.SATURDAY) {
                         day -= 1;
-                    } else if(dow == Calendar.SUNDAY && day == ldom) { 
+                    } else if (dow == Calendar.SUNDAY && day == ldom) {
                         day -= 2;
-                    } else if(dow == Calendar.SUNDAY) { 
+                    } else if (dow == Calendar.SUNDAY) {
                         day += 1;
                     }
 
@@ -1344,7 +1355,7 @@ public final class CronExpression implements Serializable, Cloneable {
                     tcal.set(Calendar.DAY_OF_MONTH, day);
                     tcal.set(Calendar.MONTH, mon - 1);
                     Date nTime = tcal.getTime();
-                    if(nTime.before(afterTime)) {
+                    if (nTime.before(afterTime)) {
                         day = daysOfMonth.first();
                         mon++;
                     }
@@ -1580,9 +1591,9 @@ public final class CronExpression implements Serializable, Cloneable {
      * @param hour the hour to set
      */
     protected void setCalendarHour(Calendar cal, int hour) {
-        cal.set(java.util.Calendar.HOUR_OF_DAY, hour);
+        cal.set(Calendar.HOUR_OF_DAY, hour);
-        if (cal.get(java.util.Calendar.HOUR_OF_DAY) != hour && hour != 24) {
+        if (cal.get(Calendar.HOUR_OF_DAY) != hour && hour != 24) {
-            cal.set(java.util.Calendar.HOUR_OF_DAY, hour + 1);
+            cal.set(Calendar.HOUR_OF_DAY, hour + 1);
         }
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/exception/XxlJobException.java

@@ -7,6 +7,7 @@ public class XxlJobException extends RuntimeException {
 
     public XxlJobException() {
     }
+
     public XxlJobException(String message) {
         super(message);
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/model/XxlJobGroup.java

@@ -19,8 +19,9 @@ public class XxlJobGroup {
 
     // registry list
     private List<String> registryList;  // 执行器地址列表(系统注册)
+
     public List<String> getRegistryList() {
-        if (addressList!=null && addressList.trim().length()>0) {
+        if (addressList != null && addressList.trim().length() > 0) {
             registryList = new ArrayList<String>(Arrays.asList(addressList.split(",")));
         }
         return registryList;

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/old/RemoteHttpJobBean.java

@@ -1,4 +1,4 @@
-//package com.xxl.job.admin.core.jobbean;
+package com.xxl.job.admin.core.old;//package com.xxl.job.admin.core.jobbean;
 //
 //import com.xxl.job.admin.core.thread.JobTriggerPoolHelper;
 //import com.xxl.job.admin.core.trigger.TriggerTypeEnum;

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/old/XxlJobDynamicScheduler.java

@@ -1,4 +1,4 @@
-//package com.xxl.job.admin.core.schedule;
+package com.xxl.job.admin.core.old;//package com.xxl.job.admin.core.schedule;
 //
 //import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
 //import com.xxl.job.admin.core.jobbean.RemoteHttpJobBean;

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/old/XxlJobThreadPool.java

@@ -1,4 +1,4 @@
-//package com.xxl.job.admin.core.quartz;
+package com.xxl.job.admin.core.old;//package com.xxl.job.admin.core.quartz;
 //
 //import org.quartz.SchedulerConfigException;
 //import org.quartz.spi.ThreadPool;

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/ExecutorRouteStrategyEnum.java

@@ -30,13 +30,14 @@ public enum ExecutorRouteStrategyEnum {
     public String getTitle() {
         return title;
     }
+
     public ExecutorRouter getRouter() {
         return router;
     }
 
-    public static ExecutorRouteStrategyEnum match(String name, ExecutorRouteStrategyEnum defaultItem){
+    public static ExecutorRouteStrategyEnum match(String name, ExecutorRouteStrategyEnum defaultItem) {
         if (name != null) {
-            for (ExecutorRouteStrategyEnum item: ExecutorRouteStrategyEnum.values()) {
+            for (ExecutorRouteStrategyEnum item : ExecutorRouteStrategyEnum.values()) {
                 if (item.name().equals(name)) {
                     return item;
                 }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteBusyover.java

@@ -26,9 +26,9 @@ public class ExecutorRouteBusyover extends ExecutorRouter {
                 idleBeatResult = executorBiz.idleBeat(new IdleBeatParam(triggerParam.getJobId()));
             } catch (Exception e) {
                 logger.error(e.getMessage(), e);
-                idleBeatResult = new ReturnT<String>(ReturnT.FAIL_CODE, ""+e );
+                idleBeatResult = new ReturnT<String>(ReturnT.FAIL_CODE, "" + e);
             }
-            idleBeatResultSB.append( (idleBeatResultSB.length()>0)?"<br><br>":"")
+            idleBeatResultSB.append((idleBeatResultSB.length() > 0) ? "<br><br>" : "")
                 .append(I18nUtil.getString("jobconf_idleBeat") + "：")
                 .append("<br>address：").append(address)
                 .append("<br>code：").append(idleBeatResult.getCode())

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteConsistentHash.java

@@ -23,6 +23,7 @@ public class ExecutorRouteConsistentHash extends ExecutorRouter {
 
     /**
      * get hash code on 2^32 ring (md5散列的方式计算hash值)
+     *
      * @param key
      * @return
      */
@@ -61,7 +62,7 @@ public class ExecutorRouteConsistentHash extends ExecutorRouter {
         // ------A1------A2-------A3------
         // -----------J1------------------
         TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
-        for (String address: addressList) {
+        for (String address : addressList) {
             for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
                 long addressHash = hash("SHARD-" + address + "-NODE-" + i);
                 addressRing.put(addressHash, address);

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteFailover.java

@@ -26,9 +26,9 @@ public class ExecutorRouteFailover extends ExecutorRouter {
                 beatResult = executorBiz.beat();
             } catch (Exception e) {
                 logger.error(e.getMessage(), e);
-                beatResult = new ReturnT<String>(ReturnT.FAIL_CODE, ""+e );
+                beatResult = new ReturnT<String>(ReturnT.FAIL_CODE, "" + e);
             }
-            beatResultSB.append( (beatResultSB.length()>0)?"<br><br>":"")
+            beatResultSB.append((beatResultSB.length() > 0) ? "<br><br>" : "")
                 .append(I18nUtil.getString("jobconf_beat") + "：")
                 .append("<br>address：").append(address)
                 .append("<br>code：").append(beatResult.getCode())

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteFirst.java

@@ -12,7 +12,7 @@ import java.util.List;
 public class ExecutorRouteFirst extends ExecutorRouter {
 
     @Override
-    public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList){
+    public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
         return new ReturnT<String>(addressList.get(0));
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteLFU.java

@@ -12,7 +12,7 @@ import java.util.concurrent.ConcurrentMap;
  * 单个JOB对应的每个执行器，使用频率最低的优先被选举
  * a(*)、LFU(Least Frequently Used)：最不经常使用，频率/次数
  * b、LRU(Least Recently Used)：最近最久未使用，时间
- *
+ * <p>
  * Created by xuxueli on 17/3/10.
  */
 public class ExecutorRouteLFU extends ExecutorRouter {
@@ -25,7 +25,7 @@ public class ExecutorRouteLFU extends ExecutorRouter {
         // cache clear
         if (System.currentTimeMillis() > CACHE_VALID_TIME) {
             jobLfuMap.clear();
-            CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
+            CACHE_VALID_TIME = System.currentTimeMillis() + 1000 * 60 * 60 * 24;
         }
 
         // lfu item init
@@ -36,20 +36,20 @@ public class ExecutorRouteLFU extends ExecutorRouter {
         }
 
         // put new
-        for (String address: addressList) {
+        for (String address : addressList) {
-            if (!lfuItemMap.containsKey(address) || lfuItemMap.get(address) >1000000 ) {
+            if (!lfuItemMap.containsKey(address) || lfuItemMap.get(address) > 1000000) {
                 lfuItemMap.put(address, new Random().nextInt(addressList.size()));  // 初始化时主动Random一次，缓解首次压力
             }
         }
         // remove old
         List<String> delKeys = new ArrayList<>();
-        for (String existKey: lfuItemMap.keySet()) {
+        for (String existKey : lfuItemMap.keySet()) {
             if (!addressList.contains(existKey)) {
                 delKeys.add(existKey);
             }
         }
         if (delKeys.size() > 0) {
-            for (String delKey: delKeys) {
+            for (String delKey : delKeys) {
                 lfuItemMap.remove(delKey);
             }
         }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteLRU.java

@@ -14,7 +14,7 @@ import java.util.concurrent.ConcurrentMap;
  * 单个JOB对应的每个执行器，最久为使用的优先被选举
  * a、LFU(Least Frequently Used)：最不经常使用，频率/次数
  * b(*)、LRU(Least Recently Used)：最近最久未使用，时间
- *
+ * <p>
  * Created by xuxueli on 17/3/10.
  */
 public class ExecutorRouteLRU extends ExecutorRouter {
@@ -27,7 +27,7 @@ public class ExecutorRouteLRU extends ExecutorRouter {
         // cache clear
         if (System.currentTimeMillis() > CACHE_VALID_TIME) {
             jobLRUMap.clear();
-            CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
+            CACHE_VALID_TIME = System.currentTimeMillis() + 1000 * 60 * 60 * 24;
         }
 
         // init lru
@@ -43,20 +43,20 @@ public class ExecutorRouteLRU extends ExecutorRouter {
         }
 
         // put new
-        for (String address: addressList) {
+        for (String address : addressList) {
             if (!lruItem.containsKey(address)) {
                 lruItem.put(address, address);
             }
         }
         // remove old
         List<String> delKeys = new ArrayList<>();
-        for (String existKey: lruItem.keySet()) {
+        for (String existKey : lruItem.keySet()) {
             if (!addressList.contains(existKey)) {
                 delKeys.add(existKey);
             }
         }
         if (delKeys.size() > 0) {
-            for (String delKey: delKeys) {
+            for (String delKey : delKeys) {
                 lruItem.remove(delKey);
             }
         }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteLast.java

@@ -13,7 +13,7 @@ public class ExecutorRouteLast extends ExecutorRouter {
 
     @Override
     public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
-        return new ReturnT<String>(addressList.get(addressList.size()-1));
+        return new ReturnT<String>(addressList.get(addressList.size() - 1));
     }
 
 }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteRound.java

@@ -22,7 +22,7 @@ public class ExecutorRouteRound extends ExecutorRouter {
         // cache clear
         if (System.currentTimeMillis() > CACHE_VALID_TIME) {
             routeCountEachJob.clear();
-            CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
+            CACHE_VALID_TIME = System.currentTimeMillis() + 1000 * 60 * 60 * 24;
         }
 
         AtomicInteger count = routeCountEachJob.get(jobId);
@@ -39,7 +39,7 @@ public class ExecutorRouteRound extends ExecutorRouter {
 
     @Override
     public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
-        String address = addressList.get(count(triggerParam.getJobId())%addressList.size());
+        String address = addressList.get(count(triggerParam.getJobId()) % addressList.size());
         return new ReturnT<String>(address);
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/scheduler/MisfireStrategyEnum.java

@@ -27,8 +27,8 @@ public enum MisfireStrategyEnum {
         return title;
     }
 
-    public static MisfireStrategyEnum match(String name, MisfireStrategyEnum defaultItem){
+    public static MisfireStrategyEnum match(String name, MisfireStrategyEnum defaultItem) {
-        for (MisfireStrategyEnum item: MisfireStrategyEnum.values()) {
+        for (MisfireStrategyEnum item : MisfireStrategyEnum.values()) {
             if (item.name().equals(name)) {
                 return item;
             }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/scheduler/ScheduleTypeEnum.java

@@ -34,8 +34,8 @@ public enum ScheduleTypeEnum {
         return title;
     }
 
-    public static ScheduleTypeEnum match(String name, ScheduleTypeEnum defaultItem){
+    public static ScheduleTypeEnum match(String name, ScheduleTypeEnum defaultItem) {
-        for (ScheduleTypeEnum item: ScheduleTypeEnum.values()) {
+        for (ScheduleTypeEnum item : ScheduleTypeEnum.values()) {
             if (item.name().equals(name)) {
                 return item;
             }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/scheduler/XxlJobScheduler.java

@@ -70,17 +70,18 @@ public class XxlJobScheduler  {
 
     // ---------------------- I18n ----------------------
 
-    private void initI18n(){
+    private void initI18n() {
-        for (ExecutorBlockStrategyEnum item:ExecutorBlockStrategyEnum.values()) {
+        for (ExecutorBlockStrategyEnum item : ExecutorBlockStrategyEnum.values()) {
             item.setTitle(I18nUtil.getString("jobconf_block_".concat(item.name())));
         }
     }
 
     // ---------------------- executor-client ----------------------
     private static ConcurrentMap<String, ExecutorBiz> executorBizRepository = new ConcurrentHashMap<String, ExecutorBiz>();
+
     public static ExecutorBiz getExecutorBiz(String address) throws Exception {
         // valid
-        if (address==null || address.trim().length()==0) {
+        if (address == null || address.trim().length() == 0) {
             return null;
         }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/thread/JobCompleteHelper.java

@@ -96,7 +96,7 @@ public class JobCompleteHelper {
                         }
                     } catch (Exception e) {
                         if (!toStop) {
-                            logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}" , e);
+                            logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}", e);
                         }
                     }
 
@@ -144,7 +144,7 @@ public class JobCompleteHelper {
             public void run() {
                 for (HandleCallbackParam handleCallbackParam : callbackParamList) {
                     ReturnT<String> callbackResult = callback(handleCallbackParam);
-                    logger.debug(">>>>>>>>> JobApiController.callback {}, handleCallbackParam={}, callbackResult={}" ,
+                    logger.debug(">>>>>>>>> JobApiController.callback {}, handleCallbackParam={}, callbackResult={}",
                         (callbackResult.getCode() == ReturnT.SUCCESS_CODE ? "success" : "fail"), handleCallbackParam, callbackResult);
                 }
             }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/thread/JobFailMonitorHelper.java

@@ -62,7 +62,7 @@ public class JobFailMonitorHelper {
 
                                 // 2、fail alarm monitor
                                 int newAlarmStatus = 0;        // 告警状态：0-默认、-1=锁定状态、1-无需告警、2-告警成功、3-告警失败
-                                if (info != null && info.getAlarmEmail() != null && info.getAlarmEmail().trim().length() > 0) {
+                                if (info != null) {
                                     boolean alarmResult = XxlJobAdminConfig.getAdminConfig().getJobAlarmer().alarm(info, log);
                                     newAlarmStatus = alarmResult ? 2 : 3;
                                 } else {
@@ -75,7 +75,7 @@ public class JobFailMonitorHelper {
 
                     } catch (Exception e) {
                         if (!toStop) {
-                            logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}" , e);
+                            logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}", e);
                         }
                     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/thread/JobLogReportHelper.java

@@ -20,14 +20,16 @@ public class JobLogReportHelper {
     private static Logger logger = LoggerFactory.getLogger(JobLogReportHelper.class);
 
     private static JobLogReportHelper instance = new JobLogReportHelper();
-    public static JobLogReportHelper getInstance(){
+
+    public static JobLogReportHelper getInstance() {
         return instance;
     }
 
 
     private Thread logrThread;
     private volatile boolean toStop = false;
-    public void start(){
+
+    public void start() {
         logrThread = new Thread(new Runnable() {
 
             @Override
@@ -69,10 +71,10 @@ public class JobLogReportHelper {
                             xxlJobLogReport.setFailCount(0);
 
                             Map<String, Object> triggerCountMap = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findLogReport(todayFrom, todayTo);
-                            if (triggerCountMap!=null && triggerCountMap.size()>0) {
+                            if (triggerCountMap != null && triggerCountMap.size() > 0) {
-                                int triggerDayCount = triggerCountMap.containsKey("triggerDayCount")?Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCount"))):0;
+                                int triggerDayCount = triggerCountMap.containsKey("triggerDayCount") ? Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCount"))) : 0;
-                                int triggerDayCountRunning = triggerCountMap.containsKey("triggerDayCountRunning")?Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCountRunning"))):0;
+                                int triggerDayCountRunning = triggerCountMap.containsKey("triggerDayCountRunning") ? Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCountRunning"))) : 0;
-                                int triggerDayCountSuc = triggerCountMap.containsKey("triggerDayCountSuc")?Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCountSuc"))):0;
+                                int triggerDayCountSuc = triggerCountMap.containsKey("triggerDayCountSuc") ? Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCountSuc"))) : 0;
                                 int triggerDayCountFail = triggerDayCount - triggerDayCountRunning - triggerDayCountSuc;
 
                                 xxlJobLogReport.setRunningCount(triggerDayCountRunning);
@@ -94,8 +96,8 @@ public class JobLogReportHelper {
                     }
 
                     // 2、log-clean: switch open & once each day
-                    if (XxlJobAdminConfig.getAdminConfig().getLogretentiondays()>0
+                    if (XxlJobAdminConfig.getAdminConfig().getLogretentiondays() > 0
-                            && System.currentTimeMillis() - lastCleanLogTime > 24*60*60*1000) {
+                        && System.currentTimeMillis() - lastCleanLogTime > 24 * 60 * 60 * 1000) {
 
                         // expire-time
                         Calendar expiredDay = Calendar.getInstance();
@@ -110,10 +112,10 @@ public class JobLogReportHelper {
                         List<Long> logIds = null;
                         do {
                             logIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findClearLogIds(0, 0, clearBeforeTime, 0, 1000);
-                            if (logIds!=null && logIds.size()>0) {
+                            if (logIds != null && logIds.size() > 0) {
                                 XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().clearLog(logIds);
                             }
-                        } while (logIds!=null && logIds.size()>0);
+                        } while (logIds != null && logIds.size() > 0);
 
                         // update clean time
                         lastCleanLogTime = System.currentTimeMillis();
@@ -138,7 +140,7 @@ public class JobLogReportHelper {
         logrThread.start();
     }
 
-    public void toStop(){
+    public void toStop() {
         toStop = true;
         // interrupt and wait
         logrThread.interrupt();

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/thread/JobRegistryHelper.java

@@ -111,14 +111,14 @@ public class JobRegistryHelper {
                         }
                     } catch (Exception e) {
                         if (!toStop) {
-                            logger.error(">>>>>>>>>>> xxl-job, job registry monitor thread error:{}" , e);
+                            logger.error(">>>>>>>>>>> xxl-job, job registry monitor thread error:{}", e);
                         }
                     }
                     try {
                         TimeUnit.SECONDS.sleep(RegistryConfig.BEAT_TIMEOUT);
                     } catch (InterruptedException e) {
                         if (!toStop) {
-                            logger.error(">>>>>>>>>>> xxl-job, job registry monitor thread error:{}" , e);
+                            logger.error(">>>>>>>>>>> xxl-job, job registry monitor thread error:{}", e);
                         }
                     }
                 }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/thread/JobScheduleHelper.java

@@ -23,7 +23,8 @@ public class JobScheduleHelper {
     private static Logger logger = LoggerFactory.getLogger(JobScheduleHelper.class);
 
     private static JobScheduleHelper instance = new JobScheduleHelper();
-    public static JobScheduleHelper getInstance(){
+
+    public static JobScheduleHelper getInstance() {
         return instance;
     }
 
@@ -35,7 +36,7 @@ public class JobScheduleHelper {
     private volatile boolean ringThreadToStop = false;
     private volatile static Map<Integer, List<Integer>> ringData = new ConcurrentHashMap<>();
 
-    public void start(){
+    public void start() {
 
         // schedule thread
         scheduleThread = new Thread(new Runnable() {
@@ -43,7 +44,7 @@ public class JobScheduleHelper {
             public void run() {
 
                 try {
-                    TimeUnit.MILLISECONDS.sleep(5000 - System.currentTimeMillis()%1000 );
+                    TimeUnit.MILLISECONDS.sleep(5000 - System.currentTimeMillis() % 1000);
                 } catch (InterruptedException e) {
                     if (!scheduleThreadToStop) {
                         logger.error(e.getMessage(), e);
@@ -70,7 +71,7 @@ public class JobScheduleHelper {
                         connAutoCommit = conn.getAutoCommit();
                         conn.setAutoCommit(false);
 
-                        preparedStatement = conn.prepareStatement(  "select * from xxl_job_lock where lock_name = 'schedule_lock' for update" );
+                        preparedStatement = conn.prepareStatement("select * from xxl_job_lock where lock_name = 'schedule_lock' for update");
                         preparedStatement.execute();
 
                         // tx start
@@ -78,9 +79,9 @@ public class JobScheduleHelper {
                         // 1、pre read
                         long nowTime = System.currentTimeMillis();
                         List<XxlJobInfo> scheduleList = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().scheduleJobQuery(nowTime + PRE_READ_MS, preReadCount);
-                        if (scheduleList!=null && scheduleList.size()>0) {
+                        if (scheduleList != null && scheduleList.size() > 0) {
                             // 2、push time-ring
-                            for (XxlJobInfo jobInfo: scheduleList) {
+                            for (XxlJobInfo jobInfo : scheduleList) {
 
                                 // time-ring jump
                                 if (nowTime > jobInfo.getTriggerNextTime() + PRE_READ_MS) {
@@ -92,7 +93,7 @@ public class JobScheduleHelper {
                                     if (MisfireStrategyEnum.FIRE_ONCE_NOW == misfireStrategyEnum) {
                                         // FIRE_ONCE_NOW 》 trigger
                                         JobTriggerPoolHelper.trigger(jobInfo.getId(), TriggerTypeEnum.MISFIRE, -1, null, null, null);
-                                        logger.debug(">>>>>>>>>>> xxl-job, schedule push trigger : jobId = " + jobInfo.getId() );
+                                        logger.debug(">>>>>>>>>>> xxl-job, schedule push trigger : jobId = " + jobInfo.getId());
                                     }
 
                                     // 2、fresh next
@@ -103,16 +104,16 @@ public class JobScheduleHelper {
 
                                     // 1、trigger
                                     JobTriggerPoolHelper.trigger(jobInfo.getId(), TriggerTypeEnum.CRON, -1, null, null, null);
-                                    logger.debug(">>>>>>>>>>> xxl-job, schedule push trigger : jobId = " + jobInfo.getId() );
+                                    logger.debug(">>>>>>>>>>> xxl-job, schedule push trigger : jobId = " + jobInfo.getId());
 
                                     // 2、fresh next
                                     refreshNextValidTime(jobInfo, new Date());
 
                                     // next-trigger-time in 5s, pre-read again
-                                    if (jobInfo.getTriggerStatus()==1 && nowTime + PRE_READ_MS > jobInfo.getTriggerNextTime()) {
+                                    if (jobInfo.getTriggerStatus() == 1 && nowTime + PRE_READ_MS > jobInfo.getTriggerNextTime()) {
 
                                         // 1、make ring second
-                                        int ringSecond = (int)((jobInfo.getTriggerNextTime()/1000)%60);
+                                        int ringSecond = (int) ((jobInfo.getTriggerNextTime() / 1000) % 60);
 
                                         // 2、push time ring
                                         pushTimeRing(ringSecond, jobInfo.getId());
@@ -126,7 +127,7 @@ public class JobScheduleHelper {
                                     // 2.3、trigger-pre-read：time-ring trigger && make next-trigger-time
 
                                     // 1、make ring second
-                                    int ringSecond = (int)((jobInfo.getTriggerNextTime()/1000)%60);
+                                    int ringSecond = (int) ((jobInfo.getTriggerNextTime() / 1000) % 60);
 
                                     // 2、push time ring
                                     pushTimeRing(ringSecond, jobInfo.getId());
@@ -139,7 +140,7 @@ public class JobScheduleHelper {
                             }
 
                             // 3、update trigger info
-                            for (XxlJobInfo jobInfo: scheduleList) {
+                            for (XxlJobInfo jobInfo : scheduleList) {
                                 XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().scheduleUpdate(jobInfo);
                             }
 
@@ -192,14 +193,14 @@ public class JobScheduleHelper {
                             }
                         }
                     }
-                    long cost = System.currentTimeMillis()-start;
+                    long cost = System.currentTimeMillis() - start;
 
 
                     // Wait seconds, align second
                     if (cost < 1000) {  // scan-overtime, not wait
                         try {
                             // pre-read period: success > scan each second; fail > skip this period;
-                            TimeUnit.MILLISECONDS.sleep((preReadSuc?1000:PRE_READ_MS) - System.currentTimeMillis()%1000);
+                            TimeUnit.MILLISECONDS.sleep((preReadSuc ? 1000 : PRE_READ_MS) - System.currentTimeMillis() % 1000);
                         } catch (InterruptedException e) {
                             if (!scheduleThreadToStop) {
                                 logger.error(e.getMessage(), e);
@@ -238,17 +239,17 @@ public class JobScheduleHelper {
                         List<Integer> ringItemData = new ArrayList<>();
                         int nowSecond = Calendar.getInstance().get(Calendar.SECOND);   // 避免处理耗时太长，跨过刻度，向前校验一个刻度；
                         for (int i = 0; i < 2; i++) {
-                            List<Integer> tmpData = ringData.remove( (nowSecond+60-i)%60 );
+                            List<Integer> tmpData = ringData.remove((nowSecond + 60 - i) % 60);
                             if (tmpData != null) {
                                 ringItemData.addAll(tmpData);
                             }
                         }
 
                         // ring trigger
-                        logger.debug(">>>>>>>>>>> xxl-job, time-ring beat : " + nowSecond + " = " + Arrays.asList(ringItemData) );
+                        logger.debug(">>>>>>>>>>> xxl-job, time-ring beat : " + nowSecond + " = " + Arrays.asList(ringItemData));
                         if (ringItemData.size() > 0) {
                             // do trigger
-                            for (int jobId: ringItemData) {
+                            for (int jobId : ringItemData) {
                                 // do trigger
                                 JobTriggerPoolHelper.trigger(jobId, TriggerTypeEnum.CRON, -1, null, null, null);
                             }
@@ -283,7 +284,7 @@ public class JobScheduleHelper {
         }
     }
 
-    private void pushTimeRing(int ringSecond, int jobId){
+    private void pushTimeRing(int ringSecond, int jobId) {
         // push async ring
         List<Integer> ringItemData = ringData.get(ringSecond);
         if (ringItemData == null) {
@@ -292,10 +293,10 @@ public class JobScheduleHelper {
         }
         ringItemData.add(jobId);
 
-        logger.debug(">>>>>>>>>>> xxl-job, schedule push time-ring : " + ringSecond + " = " + Arrays.asList(ringItemData) );
+        logger.debug(">>>>>>>>>>> xxl-job, schedule push time-ring : " + ringSecond + " = " + Arrays.asList(ringItemData));
     }
 
-    public void toStop(){
+    public void toStop() {
 
         // 1、stop schedule
         scheduleThreadToStop = true;
@@ -304,7 +305,7 @@ public class JobScheduleHelper {
         } catch (InterruptedException e) {
             logger.error(e.getMessage(), e);
         }
-        if (scheduleThread.getState() != Thread.State.TERMINATED){
+        if (scheduleThread.getState() != Thread.State.TERMINATED) {
             // interrupt and wait
             scheduleThread.interrupt();
             try {
@@ -319,7 +320,7 @@ public class JobScheduleHelper {
         if (!ringData.isEmpty()) {
             for (int second : ringData.keySet()) {
                 List<Integer> tmpData = ringData.get(second);
-                if (tmpData!=null && tmpData.size()>0) {
+                if (tmpData != null && tmpData.size() > 0) {
                     hasRingData = true;
                     break;
                 }
@@ -340,7 +341,7 @@ public class JobScheduleHelper {
         } catch (InterruptedException e) {
             logger.error(e.getMessage(), e);
         }
-        if (ringThread.getState() != Thread.State.TERMINATED){
+        if (ringThread.getState() != Thread.State.TERMINATED) {
             // interrupt and wait
             ringThread.interrupt();
             try {
@@ -361,7 +362,7 @@ public class JobScheduleHelper {
             Date nextValidTime = new CronExpression(jobInfo.getScheduleConf()).getNextValidTimeAfter(fromTime);
             return nextValidTime;
         } else if (ScheduleTypeEnum.FIX_RATE == scheduleTypeEnum /*|| ScheduleTypeEnum.FIX_DELAY == scheduleTypeEnum*/) {
-            return new Date(fromTime.getTime() + Integer.valueOf(jobInfo.getScheduleConf())*1000 );
+            return new Date(fromTime.getTime() + Integer.valueOf(jobInfo.getScheduleConf()) * 1000);
         }
         return null;
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/trigger/TriggerTypeEnum.java

@@ -16,10 +16,12 @@ public enum TriggerTypeEnum {
     API(I18nUtil.getString("jobconf_trigger_type_api")),
     MISFIRE(I18nUtil.getString("jobconf_trigger_type_misfire"));
 
-    private TriggerTypeEnum(String title){
+    private TriggerTypeEnum(String title) {
         this.title = title;
     }
+
     private String title;
+
     public String getTitle() {
         return title;
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/trigger/XxlJobTrigger.java

@@ -30,15 +30,12 @@ public class XxlJobTrigger {
      *
      * @param jobId
      * @param triggerType
-     * @param failRetryCount
+     * @param failRetryCount        >=0: use this param
-     * 			>=0: use this param
      *                              <0: use param from job info config
      * @param executorShardingParam
-     * @param executorParam
+     * @param executorParam         null: use job param
-     *          null: use job param
      *                              not null: cover job param
-     * @param addressList
+     * @param addressList           null: use executor addressList
-     *          null: use executor addressList
      *                              not null: cover
      */
     public static void trigger(int jobId,
@@ -57,28 +54,28 @@ public class XxlJobTrigger {
         if (executorParam != null) {
             jobInfo.setExecutorParam(executorParam);
         }
-        int finalFailRetryCount = failRetryCount>=0?failRetryCount:jobInfo.getExecutorFailRetryCount();
+        int finalFailRetryCount = failRetryCount >= 0 ? failRetryCount : jobInfo.getExecutorFailRetryCount();
         XxlJobGroup group = XxlJobAdminConfig.getAdminConfig().getXxlJobGroupDao().load(jobInfo.getJobGroup());
 
         // cover addressList
-        if (addressList!=null && addressList.trim().length()>0) {
+        if (addressList != null && addressList.trim().length() > 0) {
             group.setAddressType(1);
             group.setAddressList(addressList.trim());
         }
 
         // sharding param
         int[] shardingParam = null;
-        if (executorShardingParam!=null){
+        if (executorShardingParam != null) {
             String[] shardingArr = executorShardingParam.split("/");
-            if (shardingArr.length==2 && isNumeric(shardingArr[0]) && isNumeric(shardingArr[1])) {
+            if (shardingArr.length == 2 && isNumeric(shardingArr[0]) && isNumeric(shardingArr[1])) {
                 shardingParam = new int[2];
                 shardingParam[0] = Integer.valueOf(shardingArr[0]);
                 shardingParam[1] = Integer.valueOf(shardingArr[1]);
             }
         }
-        if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST==ExecutorRouteStrategyEnum.match(jobInfo.getExecutorRouteStrategy(), null)
+        if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == ExecutorRouteStrategyEnum.match(jobInfo.getExecutorRouteStrategy(), null)
-                && group.getRegistryList()!=null && !group.getRegistryList().isEmpty()
+            && group.getRegistryList() != null && !group.getRegistryList().isEmpty()
-                && shardingParam==null) {
+            && shardingParam == null) {
             for (int i = 0; i < group.getRegistryList().size(); i++) {
                 processTrigger(group, jobInfo, finalFailRetryCount, triggerType, i, group.getRegistryList().size());
             }
@@ -91,7 +88,7 @@ public class XxlJobTrigger {
 
     }
 
-    private static boolean isNumeric(String str){
+    private static boolean isNumeric(String str) {
         try {
             int result = Integer.valueOf(str);
             return true;
@@ -108,12 +105,12 @@ public class XxlJobTrigger {
      * @param index               sharding index
      * @param total               sharding index
      */
-    private static void processTrigger(XxlJobGroup group, XxlJobInfo jobInfo, int finalFailRetryCount, TriggerTypeEnum triggerType, int index, int total){
+    private static void processTrigger(XxlJobGroup group, XxlJobInfo jobInfo, int finalFailRetryCount, TriggerTypeEnum triggerType, int index, int total) {
 
         // param
         ExecutorBlockStrategyEnum blockStrategy = ExecutorBlockStrategyEnum.match(jobInfo.getExecutorBlockStrategy(), ExecutorBlockStrategyEnum.SERIAL_EXECUTION);  // block strategy
         ExecutorRouteStrategyEnum executorRouteStrategyEnum = ExecutorRouteStrategyEnum.match(jobInfo.getExecutorRouteStrategy(), null);    // route strategy
-        String shardingParam = (ExecutorRouteStrategyEnum.SHARDING_BROADCAST==executorRouteStrategyEnum)?String.valueOf(index).concat("/").concat(String.valueOf(total)):null;
+        String shardingParam = (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == executorRouteStrategyEnum) ? String.valueOf(index).concat("/").concat(String.valueOf(total)) : null;
 
         // 1、save log-id
         XxlJobLog jobLog = new XxlJobLog();
@@ -141,7 +138,7 @@ public class XxlJobTrigger {
         // 3、init address
         String address = null;
         ReturnT<String> routeAddressResult = null;
-        if (group.getRegistryList()!=null && !group.getRegistryList().isEmpty()) {
+        if (group.getRegistryList() != null && !group.getRegistryList().isEmpty()) {
             if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == executorRouteStrategyEnum) {
                 if (index < group.getRegistryList().size()) {
                     address = group.getRegistryList().get(index);
@@ -171,18 +168,18 @@ public class XxlJobTrigger {
         triggerMsgSb.append(I18nUtil.getString("jobconf_trigger_type")).append("：").append(triggerType.getTitle());
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_admin_adress")).append("：").append(IpUtil.getIp());
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_exe_regtype")).append("：")
-                .append( (group.getAddressType() == 0)?I18nUtil.getString("jobgroup_field_addressType_0"):I18nUtil.getString("jobgroup_field_addressType_1") );
+            .append((group.getAddressType() == 0) ? I18nUtil.getString("jobgroup_field_addressType_0") : I18nUtil.getString("jobgroup_field_addressType_1"));
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_exe_regaddress")).append("：").append(group.getRegistryList());
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorRouteStrategy")).append("：").append(executorRouteStrategyEnum.getTitle());
         if (shardingParam != null) {
-            triggerMsgSb.append("("+shardingParam+")");
+            triggerMsgSb.append("(" + shardingParam + ")");
         }
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorBlockStrategy")).append("：").append(blockStrategy.getTitle());
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_timeout")).append("：").append(jobInfo.getExecutorTimeout());
         triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorFailRetryCount")).append("：").append(finalFailRetryCount);
 
-        triggerMsgSb.append("<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>"+ I18nUtil.getString("jobconf_trigger_run") +"<<<<<<<<<<< </span><br>")
+        triggerMsgSb.append("<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_run") + "<<<<<<<<<<< </span><br>")
-                .append((routeAddressResult!=null&&routeAddressResult.getMsg()!=null)?routeAddressResult.getMsg()+"<br><br>":"").append(triggerResult.getMsg()!=null?triggerResult.getMsg():"");
+            .append((routeAddressResult != null && routeAddressResult.getMsg() != null) ? routeAddressResult.getMsg() + "<br><br>" : "").append(triggerResult.getMsg() != null ? triggerResult.getMsg() : "");
 
         // 6、save log trigger-info
         jobLog.setExecutorAddress(address);
@@ -200,11 +197,12 @@ public class XxlJobTrigger {
 
     /**
      * run executor
+     *
      * @param triggerParam
      * @param address
      * @return
      */
-    public static ReturnT<String> runExecutor(TriggerParam triggerParam, String address){
+    public static ReturnT<String> runExecutor(TriggerParam triggerParam, String address) {
         ReturnT<String> runResult = null;
         try {
             ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/util/CookieUtil.java

@@ -91,7 +91,7 @@ public class CookieUtil {
     public static void remove(HttpServletRequest request, HttpServletResponse response, String key) {
         Cookie cookie = get(request, key);
         if (cookie != null) {
-            set(response, key, "" , null, COOKIE_PATH, 0, true);
+            set(response, key, "", null, COOKIE_PATH, 0, true);
         }
     }
 

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/util/I18nUtil.java

@@ -23,7 +23,8 @@ public class I18nUtil {
     private static Logger logger = LoggerFactory.getLogger(I18nUtil.class);
 
     private static Properties prop = null;
-    public static Properties loadI18nProp(){
+
+    public static Properties loadI18nProp() {
         if (prop != null) {
             return prop;
         }
@@ -34,7 +35,7 @@ public class I18nUtil {
 
             // load prop
             Resource resource = new ClassPathResource(i18nFile);
-            EncodedResource encodedResource = new EncodedResource(resource,"UTF-8");
+            EncodedResource encodedResource = new EncodedResource(resource, "UTF-8");
             prop = PropertiesLoaderUtils.loadProperties(encodedResource);
         } catch (IOException e) {
             logger.error(e.getMessage(), e);
@@ -62,12 +63,12 @@ public class I18nUtil {
         Map<String, String> map = new HashMap<String, String>();
 
         Properties prop = loadI18nProp();
-        if (keys!=null && keys.length>0) {
+        if (keys != null && keys.length > 0) {
-            for (String key: keys) {
+            for (String key : keys) {
                 map.put(key, prop.getProperty(key));
             }
         } else {
-            for (String key: prop.stringPropertyNames()) {
+            for (String key : prop.stringPropertyNames()) {
                 map.put(key, prop.getProperty(key));
             }
         }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/core/util/LocalCacheUtil.java

@@ -11,7 +11,8 @@ import java.util.concurrent.ConcurrentMap;
 public class LocalCacheUtil {
 
     private static ConcurrentMap<String, LocalCacheData> cacheRepository = new ConcurrentHashMap<String, LocalCacheData>();   // 类型建议用抽象父类，兼容性更好；
-    private static class LocalCacheData{
+
+    private static class LocalCacheData {
         private String key;
         private Object val;
         private long timeoutTime;
@@ -59,13 +60,13 @@ public class LocalCacheUtil {
      * @param cacheTime
      * @return
      */
-    public static boolean set(String key, Object val, long cacheTime){
+    public static boolean set(String key, Object val, long cacheTime) {
 
         // clean timeout cache, before set new cache (avoid cache too much)
         cleanTimeoutCache();
 
         // set new cache
-        if (key==null || key.trim().length()==0) {
+        if (key == null || key.trim().length() == 0) {
             return false;
         }
         if (val == null) {
@@ -86,8 +87,8 @@ public class LocalCacheUtil {
      * @param key
      * @return
      */
-    public static boolean remove(String key){
+    public static boolean remove(String key) {
-        if (key==null || key.trim().length()==0) {
+        if (key == null || key.trim().length() == 0) {
             return false;
         }
         cacheRepository.remove(key);
@@ -100,12 +101,12 @@ public class LocalCacheUtil {
      * @param key
      * @return
      */
-    public static Object get(String key){
+    public static Object get(String key) {
-        if (key==null || key.trim().length()==0) {
+        if (key == null || key.trim().length() == 0) {
             return null;
         }
         LocalCacheData localCacheData = cacheRepository.get(key);
-        if (localCacheData!=null && System.currentTimeMillis()<localCacheData.getTimeoutTime()) {
+        if (localCacheData != null && System.currentTimeMillis() < localCacheData.getTimeoutTime()) {
             return localCacheData.getVal();
         } else {
             remove(key);
@@ -118,11 +119,11 @@ public class LocalCacheUtil {
      *
      * @return
      */
-    public static boolean cleanTimeoutCache(){
+    public static boolean cleanTimeoutCache() {
         if (!cacheRepository.keySet().isEmpty()) {
-            for (String key: cacheRepository.keySet()) {
+            for (String key : cacheRepository.keySet()) {
                 LocalCacheData localCacheData = cacheRepository.get(key);
-                if (localCacheData!=null && System.currentTimeMillis()>=localCacheData.getTimeoutTime()) {
+                if (localCacheData != null && System.currentTimeMillis() >= localCacheData.getTimeoutTime()) {
                     cacheRepository.remove(key);
                 }
             }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/service/LoginService.java

@@ -26,12 +26,13 @@ public class LoginService {
     private XxlJobUserDao xxlJobUserDao;
 
 
-    private String makeToken(XxlJobUser xxlJobUser){
+    private String makeToken(XxlJobUser xxlJobUser) {
         String tokenJson = JacksonUtil.writeValueAsString(xxlJobUser);
         String tokenHex = new BigInteger(tokenJson.getBytes()).toString(16);
         return tokenHex;
     }
-    private XxlJobUser parseToken(String tokenHex){
+
+    private XxlJobUser parseToken(String tokenHex) {
         XxlJobUser xxlJobUser = null;
         if (tokenHex != null) {
             String tokenJson = new String(new BigInteger(tokenHex, 16).toByteArray());      // username_password(md5)
@@ -41,10 +42,10 @@ public class LoginService {
     }
 
 
-    public ReturnT<String> login(HttpServletRequest request, HttpServletResponse response, String username, String password, boolean ifRemember){
+    public ReturnT<String> login(HttpServletRequest request, HttpServletResponse response, String username, String password, boolean ifRemember) {
 
         // param
-        if (username==null || username.trim().length()==0 || password==null || password.trim().length()==0){
+        if (username == null || username.trim().length() == 0 || password == null || password.trim().length() == 0) {
             return new ReturnT<String>(500, I18nUtil.getString("login_param_empty"));
         }
 
@@ -71,7 +72,7 @@ public class LoginService {
      * @param request
      * @param response
      */
-    public ReturnT<String> logout(HttpServletRequest request, HttpServletResponse response){
+    public ReturnT<String> logout(HttpServletRequest request, HttpServletResponse response) {
         CookieUtil.remove(request, response, LOGIN_IDENTITY_KEY);
         return ReturnT.SUCCESS;
     }
@@ -82,7 +83,7 @@ public class LoginService {
      * @param request
      * @return
      */
-    public XxlJobUser ifLogin(HttpServletRequest request, HttpServletResponse response){
+    public XxlJobUser ifLogin(HttpServletRequest request, HttpServletResponse response) {
         String cookieToken = CookieUtil.getValue(request, LOGIN_IDENTITY_KEY);
         if (cookieToken != null) {
             XxlJobUser cookieUser = null;
@@ -103,8 +104,5 @@ public class LoginService {
         return null;
     }
 
-    public static void main(String[] args) {
-        System.out.println("121312");
-    }
 
 }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/java/com/xxl/job/admin/service/impl/XxlJobServiceImpl.java

@@ -52,9 +52,9 @@ public class XxlJobServiceImpl implements XxlJobService {
 
         // package result
         Map<String, Object> maps = new HashMap<String, Object>();
-        maps.put("recordsTotal" , list_count);        // 总记录数
+        maps.put("recordsTotal", list_count);        // 总记录数
-        maps.put("recordsFiltered" , list_count);    // 过滤后的总记录数
+        maps.put("recordsFiltered", list_count);    // 过滤后的总记录数
-        maps.put("data" , list);                    // 分页列表
+        maps.put("data", list);                    // 分页列表
         return maps;
     }
 
@@ -105,7 +105,7 @@ public class XxlJobServiceImpl implements XxlJobService {
         }
         // 》fix "\r" in shell
         if (GlueTypeEnum.GLUE_SHELL == GlueTypeEnum.match(jobInfo.getGlueType()) && jobInfo.getGlueSource() != null) {
-            jobInfo.setGlueSource(jobInfo.getGlueSource().replaceAll("\r" , ""));
+            jobInfo.setGlueSource(jobInfo.getGlueSource().replaceAll("\r", ""));
         }
 
         // valid advanced
@@ -373,10 +373,10 @@ public class XxlJobServiceImpl implements XxlJobService {
         int executorCount = executorAddressSet.size();
 
         Map<String, Object> dashboardMap = new HashMap<String, Object>();
-        dashboardMap.put("jobInfoCount" , jobInfoCount);
+        dashboardMap.put("jobInfoCount", jobInfoCount);
-        dashboardMap.put("jobLogCount" , jobLogCount);
+        dashboardMap.put("jobLogCount", jobLogCount);
-        dashboardMap.put("jobLogSuccessCount" , jobLogSuccessCount);
+        dashboardMap.put("jobLogSuccessCount", jobLogSuccessCount);
-        dashboardMap.put("executorCount" , executorCount);
+        dashboardMap.put("executorCount", executorCount);
         return dashboardMap;
     }
 
@@ -420,14 +420,14 @@ public class XxlJobServiceImpl implements XxlJobService {
         }
 
         Map<String, Object> result = new HashMap<String, Object>();
-        result.put("triggerDayList" , triggerDayList);
+        result.put("triggerDayList", triggerDayList);
-        result.put("triggerDayCountRunningList" , triggerDayCountRunningList);
+        result.put("triggerDayCountRunningList", triggerDayCountRunningList);
-        result.put("triggerDayCountSucList" , triggerDayCountSucList);
+        result.put("triggerDayCountSucList", triggerDayCountSucList);
-        result.put("triggerDayCountFailList" , triggerDayCountFailList);
+        result.put("triggerDayCountFailList", triggerDayCountFailList);
 
-        result.put("triggerCountRunningTotal" , triggerCountRunningTotal);
+        result.put("triggerCountRunningTotal", triggerCountRunningTotal);
-        result.put("triggerCountSucTotal" , triggerCountSucTotal);
+        result.put("triggerCountSucTotal", triggerCountSucTotal);
-        result.put("triggerCountFailTotal" , triggerCountFailTotal);
+        result.put("triggerCountFailTotal", triggerCountFailTotal);
 
         return new ReturnT<Map<String, Object>>(result);
     }

ruoyi-extend/ruoyi-xxl-job-admin/src/main/resources/i18n/message_en.properties

@@ -1,6 +1,6 @@
 admin_name=Scheduling Center
 admin_name_full=Distributed Task Scheduling Platform XXL-JOB
-admin_version=2.3.0
+admin_version=2.3.1
 admin_i18n=en
 
 ## system

ruoyi-extend/ruoyi-xxl-job-admin/src/main/resources/i18n/message_zh_CN.properties

@@ -1,6 +1,6 @@
 admin_name=任务调度中心
 admin_name_full=分布式任务调度平台XXL-JOB
-admin_version=2.3.0
+admin_version=2.3.1
 admin_i18n=
 
 ## system

ruoyi-extend/ruoyi-xxl-job-admin/src/main/resources/i18n/message_zh_TC.properties

@@ -1,6 +1,6 @@
 admin_name=任務調度中心
 admin_name_full=分布式任務調度平臺XXL-JOB
-admin_version=2.3.0
+admin_version=2.3.1
 admin_i18n=
 
 ## system

ruoyi-framework/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>ruoyi-vue-plus</artifactId>
         <groupId>com.ruoyi</groupId>
-        <version>4.1.0</version>
+        <version>4.2.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

ruoyi-framework/src/main/java/com/ruoyi/framework/aspectj/RepeatSubmitAspect.java

@@ -25,9 +25,9 @@ import org.springframework.web.multipart.MultipartFile;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import java.time.Duration;
 import java.util.Collection;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
 
 /**
  * 防止重复提交(参考美团GTIS防重系统)
@@ -66,7 +66,7 @@ public class RepeatSubmitAspect {
         String cacheRepeatKey = Constants.REPEAT_SUBMIT_KEY + url + submitKey;
         String key = RedisUtils.getCacheObject(cacheRepeatKey);
         if (key == null) {
-            RedisUtils.setCacheObject(cacheRepeatKey, "", interval, TimeUnit.MILLISECONDS);
+            RedisUtils.setCacheObject(cacheRepeatKey, "", Duration.ofMillis(interval));
             KEY_CACHE.set(cacheRepeatKey);
         } else {
             String message = repeatSubmit.message();

ruoyi-framework/src/main/java/com/ruoyi/framework/config/JacksonConfig.java

@@ -1,17 +1,14 @@
 package com.ruoyi.framework.config;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import com.ruoyi.framework.jackson.BigNumberSerializer;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.boot.autoconfigure.jackson.JacksonProperties;
+import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
-import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -28,23 +25,22 @@ import java.util.TimeZone;
 @Configuration
 public class JacksonConfig {
 
-    @Primary
     @Bean
-    public ObjectMapper getObjectMapper(Jackson2ObjectMapperBuilder builder, JacksonProperties jacksonProperties) {
+    public Jackson2ObjectMapperBuilderCustomizer customizer() {
-        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
+        return builder -> {
             // 全局配置序列化返回 JSON 处理
-        SimpleModule simpleModule = new SimpleModule();
+            JavaTimeModule javaTimeModule = new JavaTimeModule();
-        simpleModule.addSerializer(Long.class, BigNumberSerializer.INSTANCE);
+            javaTimeModule.addSerializer(Long.class, BigNumberSerializer.INSTANCE);
-        simpleModule.addSerializer(Long.TYPE, BigNumberSerializer.INSTANCE);
+            javaTimeModule.addSerializer(Long.TYPE, BigNumberSerializer.INSTANCE);
-        simpleModule.addSerializer(BigInteger.class, BigNumberSerializer.INSTANCE);
+            javaTimeModule.addSerializer(BigInteger.class, BigNumberSerializer.INSTANCE);
-        simpleModule.addSerializer(BigDecimal.class, ToStringSerializer.instance);
+            javaTimeModule.addSerializer(BigDecimal.class, ToStringSerializer.instance);
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(jacksonProperties.getDateFormat());
+            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-        simpleModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(formatter));
+            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(formatter));
-        simpleModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(formatter));
+            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(formatter));
-        objectMapper.registerModule(simpleModule);
+            builder.modules(javaTimeModule);
-        objectMapper.setTimeZone(TimeZone.getDefault());
+            builder.timeZone(TimeZone.getDefault());
             log.info("初始化 jackson 配置");
-        return objectMapper;
+        };
     }
 
 }

ruoyi-framework/src/main/java/com/ruoyi/framework/config/MailConfig.java

@@ -0,0 +1,35 @@
+package com.ruoyi.framework.config;
+
+import cn.hutool.extra.mail.MailAccount;
+import com.ruoyi.framework.config.properties.MailProperties;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * JavaMail 配置
+ *
+ * @author Michelle.Chung
+ */
+@Configuration
+public class MailConfig {
+
+    @Bean
+    @ConditionalOnProperty(value = "mail.enabled", havingValue = "true")
+    public MailAccount mailAccount(MailProperties mailProperties) {
+        MailAccount account = new MailAccount();
+        account.setHost(mailProperties.getHost());
+        account.setPort(mailProperties.getPort());
+        account.setAuth(mailProperties.getAuth());
+        account.setFrom(mailProperties.getFrom());
+        account.setUser(mailProperties.getUser());
+        account.setPass(mailProperties.getPass());
+        account.setSocketFactoryPort(mailProperties.getPort());
+        account.setStarttlsEnable(mailProperties.getStarttlsEnable());
+        account.setSslEnable(mailProperties.getSslEnable());
+        account.setTimeout(mailProperties.getTimeout());
+        account.setConnectionTimeout(mailProperties.getConnectionTimeout());
+        return account;
+    }
+
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/RedisConfig.java

@@ -1,28 +1,25 @@
 package com.ruoyi.framework.config;
 
 import cn.hutool.core.util.ObjectUtil;
-import com.ruoyi.common.utils.StringUtils;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.ruoyi.framework.config.properties.RedissonProperties;
 import lombok.extern.slf4j.Slf4j;
-import org.redisson.Redisson;
 import org.redisson.api.RedissonClient;
 import org.redisson.codec.JsonJacksonCodec;
-import org.redisson.config.Config;
 import org.redisson.spring.cache.CacheConfig;
 import org.redisson.spring.cache.RedissonSpringCacheManager;
+import org.redisson.spring.starter.RedissonAutoConfigurationCustomizer;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CachingConfigurerSupport;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 /**
  * redis配置
@@ -32,37 +29,25 @@ import java.util.stream.Collectors;
 @Slf4j
 @Configuration
 @EnableCaching
+@EnableConfigurationProperties(RedissonProperties.class)
 public class RedisConfig extends CachingConfigurerSupport {
 
-    private static final String REDIS_PROTOCOL_PREFIX = "redis://";
-    private static final String REDISS_PROTOCOL_PREFIX = "rediss://";
-
-    @Autowired
-    private RedisProperties redisProperties;
-
     @Autowired
     private RedissonProperties redissonProperties;
 
-    @Primary
+    @Autowired
-    @Bean(destroyMethod = "shutdown")
+    private ObjectMapper objectMapper;
-    public RedissonClient redisson() {
+
-        String prefix = REDIS_PROTOCOL_PREFIX;
+    @Bean
-        if (redisProperties.isSsl()) {
+    public RedissonAutoConfigurationCustomizer redissonCustomizer() {
-            prefix = REDISS_PROTOCOL_PREFIX;
+        return config -> {
-        }
-        Config config = new Config();
             config.setThreads(redissonProperties.getThreads())
                 .setNettyThreads(redissonProperties.getNettyThreads())
-            .setCodec(JsonJacksonCodec.INSTANCE);
+                .setCodec(new JsonJacksonCodec(objectMapper));
-
             RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
             if (ObjectUtil.isNotNull(singleServerConfig)) {
                 // 使用单机模式
                 config.useSingleServer()
-                .setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort())
-                .setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue())
-                .setDatabase(redisProperties.getDatabase())
-                .setPassword(StringUtils.isNotBlank(redisProperties.getPassword()) ? redisProperties.getPassword() : null)
                     .setTimeout(singleServerConfig.getTimeout())
                     .setClientName(singleServerConfig.getClientName())
                     .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
@@ -73,16 +58,7 @@ public class RedisConfig extends CachingConfigurerSupport {
             // 集群配置方式 参考下方注释
             RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig();
             if (ObjectUtil.isNotNull(clusterServersConfig)) {
-            // 使用集群模式
-            String finalPrefix = prefix;
-            List<String> nodes = redisProperties.getCluster().getNodes()
-                .stream()
-                .map(node -> finalPrefix + node)
-                .collect(Collectors.toList());
-
                 config.useClusterServers()
-                .setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue())
-                .setPassword(StringUtils.isNotBlank(redisProperties.getPassword()) ? redisProperties.getPassword() : null)
                     .setTimeout(clusterServersConfig.getTimeout())
                     .setClientName(clusterServersConfig.getClientName())
                     .setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
@@ -92,12 +68,10 @@ public class RedisConfig extends CachingConfigurerSupport {
                     .setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
                     .setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
                     .setReadMode(clusterServersConfig.getReadMode())
-                .setSubscriptionMode(clusterServersConfig.getSubscriptionMode())
+                    .setSubscriptionMode(clusterServersConfig.getSubscriptionMode());
-                .setNodeAddresses(nodes);
             }
-        RedissonClient redissonClient = Redisson.create(config);
             log.info("初始化 redis 配置");
-        return redissonClient;
+        };
     }
 
     /**
@@ -112,7 +86,7 @@ public class RedisConfig extends CachingConfigurerSupport {
             cacheConfig.setMaxSize(group.getMaxSize());
             config.put(group.getGroupId(), cacheConfig);
         }
-        return new RedissonSpringCacheManager(redissonClient, config, JsonJacksonCodec.INSTANCE);
+        return new RedissonSpringCacheManager(redissonClient, config, new JsonJacksonCodec(objectMapper));
     }
 
     /**

ruoyi-framework/src/main/java/com/ruoyi/framework/config/SaTokenConfig.java

@@ -2,11 +2,12 @@ package com.ruoyi.framework.config;
 
 import cn.dev33.satoken.interceptor.SaAnnotationInterceptor;
 import cn.dev33.satoken.interceptor.SaRouteInterceptor;
-import cn.dev33.satoken.jwt.StpLogicJwtForStyle;
+import cn.dev33.satoken.jwt.StpLogicJwtForSimple;
 import cn.dev33.satoken.router.SaRouter;
 import cn.dev33.satoken.stp.StpLogic;
 import cn.dev33.satoken.stp.StpUtil;
-import com.ruoyi.common.helper.LoginHelper;
+import com.ruoyi.common.utils.spring.SpringUtils;
+import com.ruoyi.framework.config.properties.ExcludeUrlProperties;
 import com.ruoyi.framework.config.properties.SecurityProperties;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -15,9 +16,6 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
 /**
  * sa-token 配置
  *
@@ -37,12 +35,14 @@ public class SaTokenConfig implements WebMvcConfigurer {
     public void addInterceptors(InterceptorRegistry registry) {
         // 注册路由拦截器，自定义验证规则
         registry.addInterceptor(new SaRouteInterceptor((request, response, handler) -> {
+            ExcludeUrlProperties excludeUrlProperties = SpringUtils.getBean(ExcludeUrlProperties.class);
             // 登录验证 -- 排除多个路径
             SaRouter
                 // 获取所有的
                 .match("/**")
                 // 排除下不需要拦截的
                 .notMatch(securityProperties.getExcludes())
+                .notMatch(excludeUrlProperties.getExcludes())
                 // 对未排除的路径进行检查
                 .check(() -> {
                     // 检查是否登录 是否有token
@@ -55,20 +55,14 @@ public class SaTokenConfig implements WebMvcConfigurer {
                     // }
 
                 });
-        }) {
+        })).addPathPatterns("/**");
-            @SuppressWarnings("all")
-            @Override
-            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
-                LoginHelper.clearCache();
-            }
-        }).addPathPatterns("/**");
         registry.addInterceptor(new SaAnnotationInterceptor()).addPathPatterns("/**");
     }
 
     @Bean
     public StpLogic getStpLogicJwt() {
-        // Sa-Token 整合 jwt (Style模式)
+        // Sa-Token 整合 jwt (简单模式)
-        return new StpLogicJwtForStyle();
+        return new StpLogicJwtForSimple();
     }
 
 }

ruoyi-framework/src/main/java/com/ruoyi/framework/config/SwaggerConfig.java

@@ -109,7 +109,7 @@ public class SwaggerConfig {
      * 安全模式，这里指定token通过Authorization头请求头传递
      */
     private List<SecurityScheme> securitySchemes() {
-        List<SecurityScheme> apiKeyList = new ArrayList<SecurityScheme>();
+        List<SecurityScheme> apiKeyList = new ArrayList<>();
         String header = saTokenConfig.getTokenName();
         apiKeyList.add(new ApiKey(header, header, In.HEADER.toValue()));
         return apiKeyList;

ruoyi-framework/src/main/java/com/ruoyi/framework/config/ThreadPoolConfig.java

@@ -33,8 +33,8 @@ public class ThreadPoolConfig {
     @ConditionalOnProperty(prefix = "thread-pool", name = "enabled", havingValue = "true")
     public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
-        executor.setMaxPoolSize(core);
+        executor.setCorePoolSize(core);
-        executor.setCorePoolSize(core * 2);
+        executor.setMaxPoolSize(core * 2);
         executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
         executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

ruoyi-framework/src/main/java/com/ruoyi/framework/config/UndertowConfig.java

@@ -0,0 +1,30 @@
+package com.ruoyi.framework.config;
+
+import io.undertow.server.DefaultByteBufferPool;
+import io.undertow.websockets.jsr.WebSocketDeploymentInfo;
+import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory;
+import org.springframework.boot.web.server.WebServerFactoryCustomizer;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Undertow 自定义配置
+ *
+ * @author Lion Li
+ */
+@Configuration
+public class UndertowConfig implements WebServerFactoryCustomizer<UndertowServletWebServerFactory> {
+
+    /**
+     * 设置 Undertow 的 websocket 缓冲池
+     */
+    @Override
+    public void customize(UndertowServletWebServerFactory factory) {
+        // 默认不直接分配内存 如果项目中使用了 websocket 建议直接分配
+        factory.addDeploymentInfoCustomizers(deploymentInfo -> {
+            WebSocketDeploymentInfo webSocketDeploymentInfo = new WebSocketDeploymentInfo();
+            webSocketDeploymentInfo.setBuffers(new DefaultByteBufferPool(false, 512));
+            deploymentInfo.addServletContextAttribute("io.undertow.websockets.jsr.WebSocketDeploymentInfo", webSocketDeploymentInfo);
+        });
+    }
+
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/ExcludeUrlProperties.java

@@ -0,0 +1,61 @@
+package com.ruoyi.framework.config.properties;
+
+import cn.hutool.core.util.ReUtil;
+import com.ruoyi.common.annotation.Anonymous;
+import com.ruoyi.common.utils.spring.SpringUtils;
+import lombok.Getter;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.stereotype.Component;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
+import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
+
+import java.util.*;
+import java.util.regex.Pattern;
+
+/**
+ * 设置注解允许匿名访问的url
+ *
+ * @author Lion Li
+ */
+@Lazy
+@Component
+public class ExcludeUrlProperties implements InitializingBean {
+
+    private static final Pattern PATTERN = Pattern.compile("\\{(.*?)\\}");
+
+    @Getter
+    private final List<String> excludes = new ArrayList<>();
+
+    @Override
+    public void afterPropertiesSet() {
+        String asterisk = "*";
+        RequestMappingHandlerMapping mapping = SpringUtils.getBean(RequestMappingHandlerMapping.class);
+        Map<RequestMappingInfo, HandlerMethod> map = mapping.getHandlerMethods();
+
+        map.keySet().forEach(info -> {
+            HandlerMethod handlerMethod = map.get(info);
+
+            // 获取方法上边的注解 替代path variable 为 *
+            Anonymous method = AnnotationUtils.findAnnotation(handlerMethod.getMethod(), Anonymous.class);
+            Optional.ofNullable(method).ifPresent(anonymous -> {
+                Set<String> patterns = info.getPatternsCondition().getPatterns();
+                patterns.forEach(url -> {
+                    excludes.add(ReUtil.replaceAll(url, PATTERN, asterisk));
+                });
+            });
+
+            // 获取类上边的注解, 替代path variable 为 *
+            Anonymous controller = AnnotationUtils.findAnnotation(handlerMethod.getBeanType(), Anonymous.class);
+            Optional.ofNullable(controller).ifPresent(anonymous -> {
+                Set<String> patterns = info.getPatternsCondition().getPatterns();
+                patterns.forEach(url -> {
+                    excludes.add(ReUtil.replaceAll(url, PATTERN, asterisk));
+                });
+            });
+        });
+    }
+
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/MailProperties.java

@@ -0,0 +1,71 @@
+package com.ruoyi.framework.config.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * JavaMail 配置属性
+ *
+ * @author Michelle.Chung
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "mail")
+public class MailProperties {
+
+    /**
+     * 过滤开关
+     */
+    private Boolean enabled;
+
+    /**
+     * SMTP服务器域名
+     */
+    private String host;
+
+    /**
+     * SMTP服务端口
+     */
+    private Integer port;
+
+    /**
+     * 是否需要用户名密码验证
+     */
+    private Boolean auth;
+
+    /**
+     * 用户名
+     */
+    private String user;
+
+    /**
+     * 密码
+     */
+    private String pass;
+
+    /**
+     * 发送方，遵循RFC-822标准
+     */
+    private String from;
+
+    /**
+     * 使用 STARTTLS安全连接，STARTTLS是对纯文本通信协议的扩展。它将纯文本连接升级为加密连接（TLS或SSL）， 而不是使用一个单独的加密通信端口。
+     */
+    private Boolean starttlsEnable;
+
+    /**
+     * 使用 SSL安全连接
+     */
+    private Boolean sslEnable;
+
+    /**
+     * SMTP超时时长，单位毫秒，缺省值不超时
+     */
+    private Long timeout;
+
+    /**
+     * Socket连接超时值，单位毫秒，缺省值不超时
+     */
+    private Long connectionTimeout;
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/listener/UserActionListener.java

@@ -3,7 +3,6 @@ package com.ruoyi.framework.listener;
 import cn.dev33.satoken.config.SaTokenConfig;
 import cn.dev33.satoken.listener.SaTokenListener;
 import cn.dev33.satoken.stp.SaLoginModel;
-import cn.dev33.satoken.stp.StpUtil;
 import cn.hutool.http.useragent.UserAgent;
 import cn.hutool.http.useragent.UserAgentUtil;
 import com.ruoyi.common.constant.Constants;
@@ -18,7 +17,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;
 
 /**
  * 用户行为 侦听器的实现
@@ -36,13 +35,12 @@ public class UserActionListener implements SaTokenListener {
      * 每次登录时触发
      */
     @Override
-    public void doLogin(String loginType, Object loginId, SaLoginModel loginModel) {
+    public void doLogin(String loginType, Object loginId, String tokenValue, SaLoginModel loginModel) {
         UserType userType = UserType.getUserType(loginId.toString());
         if (userType == UserType.SYS_USER) {
             UserAgent userAgent = UserAgentUtil.parse(ServletUtils.getRequest().getHeader("User-Agent"));
             String ip = ServletUtils.getClientIP();
             LoginUser user = LoginHelper.getLoginUser();
-            String tokenValue = StpUtil.getTokenValueByLoginId(loginId);
             UserOnlineDTO dto = new UserOnlineDTO();
             dto.setIpaddr(ip);
             dto.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
@@ -52,7 +50,7 @@ public class UserActionListener implements SaTokenListener {
             dto.setTokenId(tokenValue);
             dto.setUserName(user.getUsername());
             dto.setDeptName(user.getDeptName());
-            RedisUtils.setCacheObject(Constants.ONLINE_TOKEN_KEY + tokenValue, dto, tokenConfig.getTimeout(), TimeUnit.SECONDS);
+            RedisUtils.setCacheObject(Constants.ONLINE_TOKEN_KEY + tokenValue, dto, Duration.ofSeconds(tokenConfig.getTimeout()));
             log.info("user doLogin, userId:{}, token:{}", loginId, tokenValue);
         } else if (userType == UserType.APP_USER) {
             // app端 自行根据业务编写

ruoyi-framework/src/main/java/com/ruoyi/framework/satoken/dao/PlusSaTokenDao.java

@@ -5,10 +5,10 @@ import cn.dev33.satoken.util.SaFoxUtil;
 import com.ruoyi.common.utils.redis.RedisUtils;
 import org.springframework.stereotype.Component;
 
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.TimeUnit;
 
 /**
  * Sa-Token持久层接口(使用框架自带RedisUtils实现 协议统一)
@@ -38,7 +38,7 @@ public class PlusSaTokenDao implements SaTokenDao {
         if (timeout == SaTokenDao.NEVER_EXPIRE) {
             RedisUtils.setCacheObject(key, value);
         } else {
-            RedisUtils.setCacheObject(key, value, timeout, TimeUnit.SECONDS);
+            RedisUtils.setCacheObject(key, value, Duration.ofSeconds(timeout));
         }
     }
 
@@ -68,7 +68,8 @@ public class PlusSaTokenDao implements SaTokenDao {
      */
     @Override
     public long getTimeout(String key) {
-        return RedisUtils.getTimeToLive(key) / 1000;
+        long timeout = RedisUtils.getTimeToLive(key);
+        return timeout < 0 ? timeout : timeout / 1000;
     }
 
     /**
@@ -87,7 +88,7 @@ public class PlusSaTokenDao implements SaTokenDao {
             }
             return;
         }
-        RedisUtils.expire(key, timeout, TimeUnit.SECONDS);
+        RedisUtils.expire(key, Duration.ofSeconds(timeout));
     }
 
 
@@ -111,7 +112,7 @@ public class PlusSaTokenDao implements SaTokenDao {
         if (timeout == SaTokenDao.NEVER_EXPIRE) {
             RedisUtils.setCacheObject(key, object);
         } else {
-            RedisUtils.setCacheObject(key, object, timeout, TimeUnit.SECONDS);
+            RedisUtils.setCacheObject(key, object, Duration.ofSeconds(timeout));
         }
     }
 
@@ -141,7 +142,8 @@ public class PlusSaTokenDao implements SaTokenDao {
      */
     @Override
     public long getObjectTimeout(String key) {
-        return RedisUtils.getTimeToLive(key) / 1000;
+        long timeout = RedisUtils.getTimeToLive(key);
+        return timeout < 0 ? timeout : timeout / 1000;
     }
 
     /**
@@ -160,7 +162,7 @@ public class PlusSaTokenDao implements SaTokenDao {
             }
             return;
         }
-        RedisUtils.expire(key, timeout, TimeUnit.SECONDS);
+        RedisUtils.expire(key, Duration.ofSeconds(timeout));
     }