消息发送

Dockerfile

@@ -54,7 +54,7 @@ EXPOSE  80  8090 81
 ENTRYPOINT /bin/sh -c   /etc/init.d/start.sh
 
 #启动脚本
-#docker rmi $(docker images | grep "^<none>" | awk "{print $3}") 删除<none>
+#docker rmi `docker images|grep none| awk '{print $3}'`
 
 #docker build -t docker.xt.wenhq.top:8083/docker_r/yjzh_test:1.0 .
 #docker run --privileged=true  -itd --name yjzh_test -v /sys/fs/cgroup:/sys/fs/cgroup:ro  -p 81:81 -p 8080:8080 -p 82:80  959e5d6a26e7

pom.xml

@@ -27,7 +27,7 @@
         <mybatis-plus.version>3.4.3.3</mybatis-plus.version>
         <p6spy.version>3.9.1</p6spy.version>
         <hutool.version>5.7.11</hutool.version>
-        <feign.version>3.0.3</feign.version>
+        <feign.version>2.2.5.RELEASE</feign.version>
         <feign-okhttp.version>11.6</feign-okhttp.version>
         <okhttp.version>4.9.1</okhttp.version>
         <spring-boot-admin.version>2.5.1</spring-boot-admin.version>
@@ -47,7 +47,7 @@
         <docker.namespace>ruoyi</docker.namespace>
         <docker.plugin.version>1.2.2</docker.plugin.version>
 
-        <alicloud.version>2.2.3.RELEASE</alicloud.version>
+        <alicloud.version>2.2.1.RELEASE</alicloud.version>
         <spring.cloud-version>2020.0.4</spring.cloud-version>
     </properties>
 
@@ -254,14 +254,6 @@
                 <version>${ruoyi-vue-plus.version}</version>
             </dependency>
 
-            <!-- demo模块 -->
-            <dependency>
-                <groupId>com.ruoyi</groupId>
-                <artifactId>ruoyi-demo</artifactId>
-                <version>${ruoyi-vue-plus.version}</version>
-            </dependency>
-
-
         </dependencies>
     </dependencyManagement>
 
@@ -272,7 +264,6 @@
         <module>ruoyi-quartz</module>
         <module>ruoyi-generator</module>
         <module>ruoyi-common</module>
-        <module>ruoyi-demo</module>
         <module>ruoyi-oss</module>
         <module>ruoyi-zhdd</module>
     </modules>

ruoyi-admin/nacos/yjzh-sq-dev.yaml

@@ -1,95 +1,95 @@
 # 数据源配置
 spring:
-  datasource:
-    type: com.alibaba.druid.pool.DruidDataSource
-    # 动态数据源文档 https://www.kancloud.cn/tracy5546/dynamic-datasource/content
-    dynamic:
-      # 性能分析插件(有性能损耗 不建议生产环境使用)
-      p6spy: true
-      # 设置默认的数据源或者数据源组,默认值即为 master
-      primary: master
-      datasource:
-        # 主库数据源
-#        master:
-#          driverClassName: com.mysql.cj.jdbc.Driver
-#          url: jdbc:mysql://cd-cdb-mrgi4hig.sql.tencentcdb.com:63225/tocc-sq?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
-#          username: tocc_sq
-#          password: tocc_sq1
-        master:
-          driverClassName: org.postgresql.Driver
-          url: jdbc:postgresql://xt.wenhq.top:8284/tocc-sq?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
-          username: postgres
-          password: postgres
-        # 从库数据源
-#        slave:
-#          lazy: true
-#          driverClassName: com.mysql.cj.jdbc.Driver
-#          url:
-#          username:
-#          password:
-      druid:
-        # 初始连接数
-        initialSize: 5
-        # 最小连接池数量
-        minIdle: 10
-        # 最大连接池数量
-        maxActive: 20
-        # 配置获取连接等待超时的时间
-        maxWait: 60000
-        # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
-        timeBetweenEvictionRunsMillis: 60000
-        # 配置一个连接在池中最小生存的时间，单位是毫秒
-        minEvictableIdleTimeMillis: 300000
-        # 配置一个连接在池中最大生存的时间，单位是毫秒
-        maxEvictableIdleTimeMillis: 900000
-        # 配置检测连接是否有效
-        validationQuery: SELECT 1
-        testWhileIdle: true
-        testOnBorrow: false
-        testOnReturn: false
-        # 注意这个值和druid原生不一致，默认启动了stat
-        filters: stat
+    datasource:
+        type: com.alibaba.druid.pool.DruidDataSource
+        # 动态数据源文档 https://www.kancloud.cn/tracy5546/dynamic-datasource/content
+        dynamic:
+            # 性能分析插件(有性能损耗 不建议生产环境使用)
+            p6spy: true
+            # 设置默认的数据源或者数据源组,默认值即为 master
+            primary: master
+            datasource:
+                # 主库数据源
+                #        master:
+                #          driverClassName: com.mysql.cj.jdbc.Driver
+                #          url: jdbc:mysql://cd-cdb-mrgi4hig.sql.tencentcdb.com:63225/tocc-sq?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
+                #          username: tocc_sq
+                #          password: tocc_sq1
+                master:
+                    driverClassName: org.postgresql.Driver
+                    url: jdbc:postgresql://xt.wenhq.top:8284/tocc-sq?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
+                    username: postgres
+                    password: postgres
+                # 从库数据源
+            #        slave:
+            #          lazy: true
+            #          driverClassName: com.mysql.cj.jdbc.Driver
+            #          url:
+            #          username:
+            #          password:
+            druid:
+                # 初始连接数
+                initialSize: 5
+                # 最小连接池数量
+                minIdle: 10
+                # 最大连接池数量
+                maxActive: 20
+                # 配置获取连接等待超时的时间
+                maxWait: 60000
+                # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+                timeBetweenEvictionRunsMillis: 60000
+                # 配置一个连接在池中最小生存的时间，单位是毫秒
+                minEvictableIdleTimeMillis: 300000
+                # 配置一个连接在池中最大生存的时间，单位是毫秒
+                maxEvictableIdleTimeMillis: 900000
+                # 配置检测连接是否有效
+                validationQuery: SELECT 1
+                testWhileIdle: true
+                testOnBorrow: false
+                testOnReturn: false
+                # 注意这个值和druid原生不一致，默认启动了stat
+                filters: stat
 
 --- # druid 配置
 spring:
-  datasource:
-    druid:
-      webStatFilter:
-        enabled: true
-      statViewServlet:
-        enabled: true
-        # 设置白名单，不填则允许所有访问
-        allow:
-        url-pattern: /druid/*
-        # 控制台管理用户名和密码
-        login-username: ruoyi
-        login-password: 123456
-      filter:
-        stat:
-          enabled: true
-          # 慢SQL记录
-          log-slow-sql: true
-          slow-sql-millis: 1000
-          merge-sql: true
-        wall:
-          config:
-            multi-statement-allow: true
+    datasource:
+        druid:
+            webStatFilter:
+                enabled: true
+            statViewServlet:
+                enabled: true
+                # 设置白名单，不填则允许所有访问
+                allow:
+                url-pattern: /druid/*
+                # 控制台管理用户名和密码
+                login-username: ruoyi
+                login-password: 123456
+            filter:
+                stat:
+                    enabled: true
+                    # 慢SQL记录
+                    log-slow-sql: true
+                    slow-sql-millis: 1000
+                    merge-sql: true
+                wall:
+                    config:
+                        multi-statement-allow: true
 
 --- # redis 配置
 spring:
-  redis:
-    # 地址
-    host: 127.0.0.1
-    # 端口，默认为6379
-    port: 6379
-    # 数据库索引
-    database: 10
-    # 密码
-    password: ficot!redis!
-    # 连接超时时间
-    timeout: 10s
-    # 是否开启ssl
-    ssl: false
+    redis:
+        # 地址
+        host: 127.0.0.1
+        # 端口，默认为6379
+        port: 6379
+        # 数据库索引
+        database: 10
+        # 密码
+        password: ficot!redis!
+        # 连接超时时间
+        timeout: 10s
+        # 是否开启ssl
+        ssl: false
 
 --- # kafaka 配置
 spring:
@@ -122,36 +122,36 @@ spring:
             value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
             auto-commit-interval: 1000
 redisson:
-  # 线程池数量
-  threads: 16
-  # Netty线程池数量
-  nettyThreads: 32
-  # 传输模式
-  transportMode: "NIO"
-  # 单节点配置
-  singleServerConfig:
-    # 客户端名称
-    clientName: ${ruoyi.name}
-    # 最小空闲连接数
-    connectionMinimumIdleSize: 32
-    # 连接池大小
-    connectionPoolSize: 64
-    # 连接空闲超时，单位：毫秒
-    idleConnectionTimeout: 10000
-    # 命令等待超时，单位：毫秒
-    timeout: 3000
-    # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
-    retryAttempts: 3
-    # 命令重试发送时间间隔，单位：毫秒
-    retryInterval: 1500
-    # 发布和订阅连接的最小空闲连接数
-    subscriptionConnectionMinimumIdleSize: 1
-    # 发布和订阅连接池大小
-    subscriptionConnectionPoolSize: 50
-    # 单个连接最大订阅数量
-    subscriptionsPerConnection: 5
-    # DNS监测时间间隔，单位：毫秒
-    dnsMonitoringInterval: 5000
+    # 线程池数量
+    threads: 16
+    # Netty线程池数量
+    nettyThreads: 32
+    # 传输模式
+    transportMode: "NIO"
+    # 单节点配置
+    singleServerConfig:
+        # 客户端名称
+        clientName: ${ruoyi.name}
+        # 最小空闲连接数
+        connectionMinimumIdleSize: 32
+        # 连接池大小
+        connectionPoolSize: 64
+        # 连接空闲超时，单位：毫秒
+        idleConnectionTimeout: 10000
+        # 命令等待超时，单位：毫秒
+        timeout: 3000
+        # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
+        retryAttempts: 3
+        # 命令重试发送时间间隔，单位：毫秒
+        retryInterval: 1500
+        # 发布和订阅连接的最小空闲连接数
+        subscriptionConnectionMinimumIdleSize: 1
+        # 发布和订阅连接池大小
+        subscriptionConnectionPoolSize: 50
+        # 单个连接最大订阅数量
+        subscriptionsPerConnection: 5
+        # DNS监测时间间隔，单位：毫秒
+        dnsMonitoringInterval: 5000
 
 ruoyi:
     # 文件路径 示例（ Windows配置D:/tocc/uploadPath，Linux配置 /xintong/server/uploadPath）

ruoyi-admin/nacos/yjzh-sq-prod.yaml

@@ -1,137 +1,137 @@
 # 数据源配置
 spring:
-  datasource:
-    type: com.alibaba.druid.pool.DruidDataSource
-    # 动态数据源文档 https://www.kancloud.cn/tracy5546/dynamic-datasource/content
-    dynamic:
-      # 性能分析插件(有性能损耗 不建议生产环境使用)
-      p6spy: false
-      # 设置默认的数据源或者数据源组,默认值即为 master
-      primary: master
-      datasource:
-        # 主库数据源
-        master:
-          driverClassName: com.mysql.cj.jdbc.Driver
-          url: jdbc:mysql://172.30.0.36:3306/ry-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
-          username: root
-          password: root
-        # 从库数据源
-        slave:
-          lazy: true
-          driverClassName: com.mysql.cj.jdbc.Driver
-          url:
-          username:
-          password:
-      druid:
-        # 初始连接数
-        initialSize: 5
-        # 最小连接池数量
-        minIdle: 10
-        # 最大连接池数量
-        maxActive: 20
-        # 配置获取连接等待超时的时间
-        maxWait: 60000
-        # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
-        timeBetweenEvictionRunsMillis: 60000
-        # 配置一个连接在池中最小生存的时间，单位是毫秒
-        minEvictableIdleTimeMillis: 300000
-        # 配置一个连接在池中最大生存的时间，单位是毫秒
-        maxEvictableIdleTimeMillis: 900000
-        # 配置检测连接是否有效
-        validationQuery: SELECT 1 FROM DUAL
-        testWhileIdle: true
-        testOnBorrow: false
-        testOnReturn: false
-        # 注意这个值和druid原生不一致，默认启动了stat
-        filters: stat
+    datasource:
+        type: com.alibaba.druid.pool.DruidDataSource
+        # 动态数据源文档 https://www.kancloud.cn/tracy5546/dynamic-datasource/content
+        dynamic:
+            # 性能分析插件(有性能损耗 不建议生产环境使用)
+            p6spy: false
+            # 设置默认的数据源或者数据源组,默认值即为 master
+            primary: master
+            datasource:
+                # 主库数据源
+                master:
+                    driverClassName: com.mysql.cj.jdbc.Driver
+                    url: jdbc:mysql://172.30.0.36:3306/ry-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
+                    username: root
+                    password: root
+                # 从库数据源
+                slave:
+                    lazy: true
+                    driverClassName: com.mysql.cj.jdbc.Driver
+                    url:
+                    username:
+                    password:
+            druid:
+                # 初始连接数
+                initialSize: 5
+                # 最小连接池数量
+                minIdle: 10
+                # 最大连接池数量
+                maxActive: 20
+                # 配置获取连接等待超时的时间
+                maxWait: 60000
+                # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+                timeBetweenEvictionRunsMillis: 60000
+                # 配置一个连接在池中最小生存的时间，单位是毫秒
+                minEvictableIdleTimeMillis: 300000
+                # 配置一个连接在池中最大生存的时间，单位是毫秒
+                maxEvictableIdleTimeMillis: 900000
+                # 配置检测连接是否有效
+                validationQuery: SELECT 1 FROM DUAL
+                testWhileIdle: true
+                testOnBorrow: false
+                testOnReturn: false
+                # 注意这个值和druid原生不一致，默认启动了stat
+                filters: stat
 
 --- # druid 配置
 spring:
-  datasource:
-    druid:
-      webStatFilter:
-        enabled: true
-      statViewServlet:
-        enabled: true
-        # 设置白名单，不填则允许所有访问
-        allow:
-        url-pattern: /druid/*
-        # 控制台管理用户名和密码
-        login-username: ruoyi
-        login-password: 123456
-      filter:
-        stat:
-          enabled: true
-          # 慢SQL记录
-          log-slow-sql: true
-          slow-sql-millis: 1000
-          merge-sql: true
-        wall:
-          config:
-            multi-statement-allow: true
+    datasource:
+        druid:
+            webStatFilter:
+                enabled: true
+            statViewServlet:
+                enabled: true
+                # 设置白名单，不填则允许所有访问
+                allow:
+                url-pattern: /druid/*
+                # 控制台管理用户名和密码
+                login-username: ruoyi
+                login-password: 123456
+            filter:
+                stat:
+                    enabled: true
+                    # 慢SQL记录
+                    log-slow-sql: true
+                    slow-sql-millis: 1000
+                    merge-sql: true
+                wall:
+                    config:
+                        multi-statement-allow: true
 
 --- # redis 配置
 spring:
-  redis:
-    # 地址
-    host: 172.30.0.48
-    # 端口，默认为6379
-    port: 6379
-    # 数据库索引
-    database: 0
-    # 密码
-    password:
-    # 连接超时时间
-    timeout: 10s
-    # 是否开启ssl
-    ssl: false
+    redis:
+        # 地址
+        host: 172.30.0.48
+        # 端口，默认为6379
+        port: 6379
+        # 数据库索引
+        database: 0
+        # 密码
+        password:
+        # 连接超时时间
+        timeout: 10s
+        # 是否开启ssl
+        ssl: false
 
 redisson:
-  # 线程池数量
-  threads: 16
-  # Netty线程池数量
-  nettyThreads: 32
-  # 传输模式
-  transportMode: "NIO"
-  # 单节点配置
-  singleServerConfig:
-    # 客户端名称
-    clientName: ${ruoyi.name}
-    # 最小空闲连接数
-    connectionMinimumIdleSize: 32
-    # 连接池大小
-    connectionPoolSize: 64
-    # 连接空闲超时，单位：毫秒
-    idleConnectionTimeout: 10000
-    # 命令等待超时，单位：毫秒
-    timeout: 3000
-    # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
-    retryAttempts: 3
-    # 命令重试发送时间间隔，单位：毫秒
-    retryInterval: 1500
-    # 发布和订阅连接的最小空闲连接数
-    subscriptionConnectionMinimumIdleSize: 1
-    # 发布和订阅连接池大小
-    subscriptionConnectionPoolSize: 50
-    # 单个连接最大订阅数量
-    subscriptionsPerConnection: 5
-    # DNS监测时间间隔，单位：毫秒
-    dnsMonitoringInterval: 5000
+    # 线程池数量
+    threads: 16
+    # Netty线程池数量
+    nettyThreads: 32
+    # 传输模式
+    transportMode: "NIO"
+    # 单节点配置
+    singleServerConfig:
+        # 客户端名称
+        clientName: ${ruoyi.name}
+        # 最小空闲连接数
+        connectionMinimumIdleSize: 32
+        # 连接池大小
+        connectionPoolSize: 64
+        # 连接空闲超时，单位：毫秒
+        idleConnectionTimeout: 10000
+        # 命令等待超时，单位：毫秒
+        timeout: 3000
+        # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
+        retryAttempts: 3
+        # 命令重试发送时间间隔，单位：毫秒
+        retryInterval: 1500
+        # 发布和订阅连接的最小空闲连接数
+        subscriptionConnectionMinimumIdleSize: 1
+        # 发布和订阅连接池大小
+        subscriptionConnectionPoolSize: 50
+        # 单个连接最大订阅数量
+        subscriptionsPerConnection: 5
+        # DNS监测时间间隔，单位：毫秒
+        dnsMonitoringInterval: 5000
 
 --- # 监控配置
 spring:
-  boot:
-    admin:
-      # Spring Boot Admin Client 客户端的相关配置
-      client:
-        # 增加客户端开关
-        enabled: true
-        # 设置 Spring Boot Admin Server 地址
-        url: http://172.30.0.90:9090/admin
-        instance:
-          prefer-ip: true # 注册实例时，优先使用 IP
-        username: ruoyi
-        password: 123456
+    boot:
+        admin:
+            # Spring Boot Admin Client 客户端的相关配置
+            client:
+                # 增加客户端开关
+                enabled: true
+                # 设置 Spring Boot Admin Server 地址
+                url: http://172.30.0.90:9090/admin
+                instance:
+                    prefer-ip: true # 注册实例时，优先使用 IP
+                username: ruoyi
+                password: 123456
 
 --- # kafaka 配置
 spring:

ruoyi-admin/nacos/yjzh-sq-test.yaml

@@ -1,90 +1,90 @@
 # 数据源配置
 spring:
-  datasource:
-    type: com.alibaba.druid.pool.DruidDataSource
-    # 动态数据源文档 https://www.kancloud.cn/tracy5546/dynamic-datasource/content
-    dynamic:
-      # 性能分析插件(有性能损耗 不建议生产环境使用)
-      p6spy: true
-      # 设置默认的数据源或者数据源组,默认值即为 master
-      primary: master
-      datasource:
-        # 主库数据源
-        master:
-          driverClassName: org.postgresql.Driver
-          url: jdbc:postgresql://10.11.208.18:16430/yjzh?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
-          username: postgres
-          password: Superman@2021
-        # 从库数据源
-#        slave:
-#          lazy: true
-#          driverClassName: com.mysql.cj.jdbc.Driver
-#          url:
-#          username:
-#          password:
-      druid:
-        # 初始连接数
-        initialSize: 5
-        # 最小连接池数量
-        minIdle: 10
-        # 最大连接池数量
-        maxActive: 20
-        # 配置获取连接等待超时的时间
-        maxWait: 60000
-        # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
-        timeBetweenEvictionRunsMillis: 60000
-        # 配置一个连接在池中最小生存的时间，单位是毫秒
-        minEvictableIdleTimeMillis: 300000
-        # 配置一个连接在池中最大生存的时间，单位是毫秒
-        maxEvictableIdleTimeMillis: 900000
-        # 配置检测连接是否有效
-        validationQuery: SELECT 1
-        testWhileIdle: true
-        testOnBorrow: false
-        testOnReturn: false
-        # 注意这个值和druid原生不一致，默认启动了stat
-        filters: stat
+    datasource:
+        type: com.alibaba.druid.pool.DruidDataSource
+        # 动态数据源文档 https://www.kancloud.cn/tracy5546/dynamic-datasource/content
+        dynamic:
+            # 性能分析插件(有性能损耗 不建议生产环境使用)
+            p6spy: true
+            # 设置默认的数据源或者数据源组,默认值即为 master
+            primary: master
+            datasource:
+                # 主库数据源
+                master:
+                    driverClassName: org.postgresql.Driver
+                    url: jdbc:postgresql://10.11.208.18:16430/yjzh?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true
+                    username: postgres
+                    password: Superman@2021
+                # 从库数据源
+            #        slave:
+            #          lazy: true
+            #          driverClassName: com.mysql.cj.jdbc.Driver
+            #          url:
+            #          username:
+            #          password:
+            druid:
+                # 初始连接数
+                initialSize: 5
+                # 最小连接池数量
+                minIdle: 10
+                # 最大连接池数量
+                maxActive: 20
+                # 配置获取连接等待超时的时间
+                maxWait: 60000
+                # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+                timeBetweenEvictionRunsMillis: 60000
+                # 配置一个连接在池中最小生存的时间，单位是毫秒
+                minEvictableIdleTimeMillis: 300000
+                # 配置一个连接在池中最大生存的时间，单位是毫秒
+                maxEvictableIdleTimeMillis: 900000
+                # 配置检测连接是否有效
+                validationQuery: SELECT 1
+                testWhileIdle: true
+                testOnBorrow: false
+                testOnReturn: false
+                # 注意这个值和druid原生不一致，默认启动了stat
+                filters: stat
 
 --- # druid 配置
 spring:
-  datasource:
-    druid:
-      webStatFilter:
-        enabled: true
-      statViewServlet:
-        enabled: true
-        # 设置白名单，不填则允许所有访问
-        allow:
-        url-pattern: /druid/*
-        # 控制台管理用户名和密码
-        login-username: ruoyi
-        login-password: 123456
-      filter:
-        stat:
-          enabled: true
-          # 慢SQL记录
-          log-slow-sql: true
-          slow-sql-millis: 1000
-          merge-sql: true
-        wall:
-          config:
-            multi-statement-allow: true
+    datasource:
+        druid:
+            webStatFilter:
+                enabled: true
+            statViewServlet:
+                enabled: true
+                # 设置白名单，不填则允许所有访问
+                allow:
+                url-pattern: /druid/*
+                # 控制台管理用户名和密码
+                login-username: ruoyi
+                login-password: 123456
+            filter:
+                stat:
+                    enabled: true
+                    # 慢SQL记录
+                    log-slow-sql: true
+                    slow-sql-millis: 1000
+                    merge-sql: true
+                wall:
+                    config:
+                        multi-statement-allow: true
 
 --- # redis 配置
 spring:
-  redis:
-    # 地址
-    host: 10.11.208.16
-    # 端口，默认为6379
-    port: 6379
-    # 数据库索引
-    database: 10
-    # 密码
-    password: superman
-    # 连接超时时间
-    timeout: 10s
-    # 是否开启ssl
-    ssl: false
+    redis:
+        # 地址
+        host: 10.11.208.16
+        # 端口，默认为6379
+        port: 6379
+        # 数据库索引
+        database: 10
+        # 密码
+        password: superman
+        # 连接超时时间
+        timeout: 10s
+        # 是否开启ssl
+        ssl: false
 
 --- # kafaka 配置
 spring:
@@ -117,36 +117,36 @@ spring:
             value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
             auto-commit-interval: 1000
 redisson:
-  # 线程池数量
-  threads: 16
-  # Netty线程池数量
-  nettyThreads: 32
-  # 传输模式
-  transportMode: "NIO"
-  # 单节点配置
-  singleServerConfig:
-    # 客户端名称
-    clientName: ${ruoyi.name}
-    # 最小空闲连接数
-    connectionMinimumIdleSize: 32
-    # 连接池大小
-    connectionPoolSize: 64
-    # 连接空闲超时，单位：毫秒
-    idleConnectionTimeout: 10000
-    # 命令等待超时，单位：毫秒
-    timeout: 3000
-    # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
-    retryAttempts: 3
-    # 命令重试发送时间间隔，单位：毫秒
-    retryInterval: 1500
-    # 发布和订阅连接的最小空闲连接数
-    subscriptionConnectionMinimumIdleSize: 1
-    # 发布和订阅连接池大小
-    subscriptionConnectionPoolSize: 50
-    # 单个连接最大订阅数量
-    subscriptionsPerConnection: 5
-    # DNS监测时间间隔，单位：毫秒
-    dnsMonitoringInterval: 5000
+    # 线程池数量
+    threads: 16
+    # Netty线程池数量
+    nettyThreads: 32
+    # 传输模式
+    transportMode: "NIO"
+    # 单节点配置
+    singleServerConfig:
+        # 客户端名称
+        clientName: ${ruoyi.name}
+        # 最小空闲连接数
+        connectionMinimumIdleSize: 32
+        # 连接池大小
+        connectionPoolSize: 64
+        # 连接空闲超时，单位：毫秒
+        idleConnectionTimeout: 10000
+        # 命令等待超时，单位：毫秒
+        timeout: 3000
+        # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
+        retryAttempts: 3
+        # 命令重试发送时间间隔，单位：毫秒
+        retryInterval: 1500
+        # 发布和订阅连接的最小空闲连接数
+        subscriptionConnectionMinimumIdleSize: 1
+        # 发布和订阅连接池大小
+        subscriptionConnectionPoolSize: 50
+        # 单个连接最大订阅数量
+        subscriptionsPerConnection: 5
+        # DNS监测时间间隔，单位：毫秒
+        dnsMonitoringInterval: 5000
 
 ruoyi:
     # 文件路径 示例（ Windows配置D:/tocc/uploadPath，Linux配置 /xintong/server/uploadPath）

ruoyi-admin/pom.xml

@@ -65,13 +65,6 @@
             <artifactId>ruoyi-zhdd</artifactId>
         </dependency>
 
-        <!--  demo模块  -->
-        <dependency>
-            <groupId>com.ruoyi</groupId>
-            <artifactId>ruoyi-demo</artifactId>
-        </dependency>
-
-
         <dependency>
             <groupId>org.springframework.kafka</groupId>
             <artifactId>spring-kafka</artifactId>
@@ -83,11 +76,11 @@
             <scope>test</scope>
         </dependency>
 
-        <!--<dependency>
+        <dependency>
             <groupId>org.springframework.cloud</groupId>
-            <artifactId>spring-cloud-loadbalancer</artifactId>
-            <version>3.0.3</version>
-        </dependency>-->
+            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
+            <version>2.2.0.RELEASE</version>
+        </dependency>
 
     </dependencies>
 

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

@@ -4,9 +4,6 @@ import cn.hutool.captcha.AbstractCaptcha;
 import cn.hutool.captcha.generator.CodeGenerator;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.util.IdUtil;
-import com.alibaba.nacos.api.annotation.NacosInjected;
-import com.alibaba.nacos.api.config.annotation.NacosValue;
-import com.alibaba.nacos.api.naming.NamingService;
 import com.ruoyi.common.constant.Constants;
 import com.ruoyi.common.core.domain.AjaxResult;
 import com.ruoyi.common.enums.CaptchaType;
@@ -17,10 +14,7 @@ import com.ruoyi.common.utils.spring.SpringUtils;
 import com.ruoyi.framework.config.properties.CaptchaProperties;
 import com.ruoyi.system.service.ISysConfigService;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.boot.CommandLineRunner;
 import org.springframework.cloud.context.config.annotation.RefreshScope;
-import org.springframework.context.ApplicationContext;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -37,56 +31,56 @@ import java.util.concurrent.TimeUnit;
 @RefreshScope
 public class CaptchaController {
 
-	@Autowired
-	private CaptchaProperties captchaProperties;
+    @Autowired
+    private CaptchaProperties captchaProperties;
 
-	@Autowired
-	private ISysConfigService configService;
+    @Autowired
+    private ISysConfigService configService;
 
-	/**
-	 * 生成验证码
-	 */
-	@GetMapping("/captchaImage")
-	public AjaxResult getCode() {
-		Map<String, Object> ajax = new HashMap<>();
-		boolean captchaOnOff = configService.selectCaptchaOnOff();
-		ajax.put("captchaOnOff", captchaOnOff);
-		if (!captchaOnOff) {
-			return AjaxResult.success(ajax);
-		}
-		// 保存验证码信息
-		String uuid = IdUtil.simpleUUID();
-		String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;
-		// 生成验证码
-		CaptchaType captchaType = captchaProperties.getType();
-		boolean isMath = CaptchaType.MATH == captchaType;
-		Integer length = isMath ? captchaProperties.getNumberLength() : captchaProperties.getCharLength();
-		CodeGenerator codeGenerator = ReflectUtils.newInstance(captchaType.getClazz(), length);
-		AbstractCaptcha captcha = SpringUtils.getBean(captchaProperties.getCategory().getClazz());
-		captcha.setGenerator(codeGenerator);
-		captcha.createCode();
-		String code = isMath ? getCodeResult(captcha.getCode()) : captcha.getCode();
-		RedisUtils.setCacheObject(verifyKey, code, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);
-		ajax.put("uuid", uuid);
-		ajax.put("img", captcha.getImageBase64());
-		return AjaxResult.success(ajax);
-	}
+    /**
+     * 生成验证码
+     */
+    @GetMapping("/captchaImage")
+    public AjaxResult getCode() {
+        Map<String, Object> ajax = new HashMap<>();
+        boolean captchaOnOff = configService.selectCaptchaOnOff();
+        ajax.put("captchaOnOff", captchaOnOff);
+        if (!captchaOnOff) {
+            return AjaxResult.success(ajax);
+        }
+        // 保存验证码信息
+        String uuid = IdUtil.simpleUUID();
+        String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;
+        // 生成验证码
+        CaptchaType captchaType = captchaProperties.getType();
+        boolean isMath = CaptchaType.MATH == captchaType;
+        Integer length = isMath ? captchaProperties.getNumberLength() : captchaProperties.getCharLength();
+        CodeGenerator codeGenerator = ReflectUtils.newInstance(captchaType.getClazz(), length);
+        AbstractCaptcha captcha = SpringUtils.getBean(captchaProperties.getCategory().getClazz());
+        captcha.setGenerator(codeGenerator);
+        captcha.createCode();
+        String code = isMath ? getCodeResult(captcha.getCode()) : captcha.getCode();
+        RedisUtils.setCacheObject(verifyKey, code, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);
+        ajax.put("uuid", uuid);
+        ajax.put("img", captcha.getImageBase64());
+        return AjaxResult.success(ajax);
+    }
 
-	private String getCodeResult(String capStr) {
-		int numberLength = captchaProperties.getNumberLength();
-		int a = Convert.toInt(StringUtils.substring(capStr, 0, numberLength).trim());
-		char operator = capStr.charAt(numberLength);
-		int b = Convert.toInt(StringUtils.substring(capStr, numberLength + 1, numberLength + 1 + numberLength).trim());
-		switch (operator) {
-			case '*':
-				return Convert.toStr(a * b);
-			case '+':
-				return Convert.toStr(a + b);
-			case '-':
-				return Convert.toStr(a - b);
-			default:
-				return StringUtils.EMPTY;
-		}
-	}
+    private String getCodeResult(String capStr) {
+        int numberLength = captchaProperties.getNumberLength();
+        int a = Convert.toInt(StringUtils.substring(capStr, 0, numberLength).trim());
+        char operator = capStr.charAt(numberLength);
+        int b = Convert.toInt(StringUtils.substring(capStr, numberLength + 1, numberLength + 1 + numberLength).trim());
+        switch (operator) {
+            case '*':
+                return Convert.toStr(a * b);
+            case '+':
+                return Convert.toStr(a + b);
+            case '-':
+                return Convert.toStr(a - b);
+            default:
+                return StringUtils.EMPTY;
+        }
+    }
 
 }

ruoyi-admin/src/main/java/com/ruoyi/web/controller/task/NoticeInfoListiner.java

@@ -0,0 +1,91 @@
+package com.ruoyi.web.controller.task;
+
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
+import com.ruoyi.common.constant.Constants;
+import com.ruoyi.common.utils.RedisUtils;
+import com.ruoyi.zhdd.domain.IncidentProcess;
+import com.ruoyi.zhdd.domain.bo.MessagePushBo;
+import com.ruoyi.zhdd.domain.bo.MessagePushUser;
+import com.ruoyi.zhdd.domain.vo.IncidentTaskVo;
+import com.ruoyi.zhdd.domain.vo.IncidentVo;
+import com.ruoyi.zhdd.feign.FeignNoticeInfoService;
+import com.ruoyi.zhdd.service.IIncidentProcessService;
+import com.ruoyi.zhdd.service.IIncidentService;
+import com.ruoyi.zhdd.service.IIncidentTaskService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * @Description: TODO
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+@Component
+@Slf4j
+@RequiredArgsConstructor(onConstructor_ = @Autowired)
+public class NoticeInfoListiner {
+
+    private final FeignNoticeInfoService feignNoticeInfoService;
+    private final IIncidentService incidentService;
+    private final IIncidentTaskService incidentTaskService;
+    private final IIncidentProcessService incidentProcessService;
+
+    /**
+     * 消息发送
+     * A:事件接报。B:处置方案
+     */
+    @Bean
+    public void sendNotice() {
+        RedisUtils.subscribe(Constants.NOTICE_PUSH, String.class, msg -> {
+            // 查询事件信息并发送消息
+            MessagePushBo messagePushBo = new MessagePushBo();
+            String type = msg.substring(0, 1);
+            String title = "未知";
+            String synopsis = "未知";
+            String text = "未知";
+            String messageUser = "";
+            IncidentProcess incidentProcess = new IncidentProcess();
+            if ("A".equals(type)) {
+                IncidentVo incidentVo = incidentService.queryById(msg.substring(1));
+                title = StrUtil.concat(true, "应急事件:", incidentVo.getName());
+                synopsis = "请查看应急事件";
+                text = StrUtil.concat(true, incidentVo.getAddr(), "发生应急事件，请关注消息，做好应急准备");
+                incidentProcess.setDes("事件接报");
+                incidentProcess.setIncidentId(msg.substring(1));
+                messageUser = incidentVo.getExprJson();
+            } else if ("B".equals(type)) {
+                // 查询处置方案
+                IncidentTaskVo incidentTaskVo = incidentTaskService.queryById(msg.substring(1));
+                IncidentVo incidentVo = incidentService.queryById(incidentTaskVo.getIncidentId());
+                title = "应急处置";
+                synopsis = "请查看应急处置方案";
+                text = StrUtil.concat(true, "请查看", incidentVo.getName(), "事件的", incidentTaskVo.getTaskName(), "方案");
+                incidentProcess.setDes("发送处置方案");
+                incidentProcess.setIncidentId(incidentTaskVo.getIncidentId());
+                messageUser = incidentVo.getExprJson();
+            }
+            if (StrUtil.isBlank(messageUser)) {
+                return;
+            }
+            List<MessagePushUser> messagePushUsers = JSONUtil.toList(messageUser, MessagePushUser.class);
+            incidentProcess.setStatus(1);
+            incidentProcessService.save(incidentProcess);
+            messagePushBo.setMsTitle(title);
+            messagePushBo.setMsSynopsis(synopsis);
+            messagePushBo.setMsText(text);
+            messagePushBo.setMsNo(incidentProcess.getId());
+            messagePushBo.setMessageReadInfoList(messagePushUsers);
+            feignNoticeInfoService.messagePush(messagePushBo);
+            log.info("发送消息体 => {}", messagePushBo);
+            log.info("订阅事件消息 => {}", msg);
+        });
+    }
+
+}

ruoyi-admin/src/main/java/com/ruoyi/web/controller/zhdd/IncidentController.java

@@ -103,7 +103,7 @@ public class IncidentController extends BaseController {
      */
     @ApiOperation("导出事件基础列表")
 //    @PreAuthorize("@ss.hasPermi('zhdd:incident:export')")
-    @Log(title = "事件基础", businessType = BusinessType.EXPORT)
+//    @Log(title = "事件基础", businessType = BusinessType.EXPORT)
     @GetMapping("/export")
     public void export(@Validated IncidentBo bo, HttpServletResponse response) {
         List<IncidentVo> list = iIncidentService.queryList(bo);
@@ -140,7 +140,7 @@ public class IncidentController extends BaseController {
      */
     @ApiOperation("新增事件基础")
 //    @PreAuthorize("@ss.hasPermi('zhdd:incident:add')")
-    @Log(title = "事件基础", businessType = BusinessType.INSERT)
+//    @Log(title = "事件基础", businessType = BusinessType.INSERT)
     @RepeatSubmit()
     @PostMapping()
     public AjaxResult<Void> add(@Validated(AddGroup.class) @RequestBody IncidentBo bo) {
@@ -154,7 +154,7 @@ public class IncidentController extends BaseController {
      */
     @ApiOperation("修改事件基础")
 //    @PreAuthorize("@ss.hasPermi('zhdd:incident:edit')")
-    @Log(title = "事件基础", businessType = BusinessType.UPDATE)
+//    @Log(title = "事件基础", businessType = BusinessType.UPDATE)
     @RepeatSubmit()
     @PutMapping()
     public AjaxResult<Void> edit(@Validated(EditGroup.class) @RequestBody IncidentBo bo) {

ruoyi-common/src/main/java/com/ruoyi/common/constant/Constants.java

@@ -7,8 +7,7 @@ import io.jsonwebtoken.Claims;
  *
  * @author ruoyi
  */
-public class Constants
-{
+public class Constants {
     /**
      * UTF-8 字符集
      */
@@ -139,13 +138,15 @@ public class Constants
      */
     public static final String RESOURCE_PREFIX = "/profile";
 
-	/**
-	 * RMI 远程方法调用
-	 */
-	public static final String LOOKUP_RMI = "rmi://";
+    /**
+     * RMI 远程方法调用
+     */
+    public static final String LOOKUP_RMI = "rmi://";
+
+    /**
+     * LDAP 远程方法调用
+     */
+    public static final String LOOKUP_LDAP = "ldap://";
 
-	/**
-	 * LDAP 远程方法调用
-	 */
-	public static final String LOOKUP_LDAP = "ldap://";
+    public static final String NOTICE_PUSH = "notice_push";
 }

ruoyi-demo/pom.xml

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>ruoyi-vue-plus</artifactId>
-        <groupId>com.ruoyi</groupId>
-        <version>3.1.0</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>ruoyi-demo</artifactId>
-
-    <description>
-        demo模块
-    </description>
-
-    <dependencies>
-
-        <!-- 通用工具-->
-        <dependency>
-            <groupId>com.ruoyi</groupId>
-            <artifactId>ruoyi-common</artifactId>
-        </dependency>
-
-    </dependencies>
-
-</project>

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

@@ -1,36 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.ruoyi.common.core.domain.AjaxResult;
-import com.ruoyi.demo.feign.FeignTestService;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-/**
- * feign测试controller
- *
- * @author Lion Li
- */
-@Api(value = "feign测试", tags = {"feign测试"})
-@RequiredArgsConstructor(onConstructor_ = @Autowired)
-@RestController
-@RequestMapping("/feign/test")
-public class FeignTestController {
-
-    private final FeignTestService feignTestService;
-
-    /**
-     * 搜索数据
-     */
-    @ApiOperation("测试使用feign请求数据")
-    @GetMapping("/search/{wd}")
-    public AjaxResult search(@PathVariable String wd) {
-        String search = feignTestService.search(wd);
-        return AjaxResult.success("操作成功",search);
-    }
-}

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

@@ -1,76 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.ruoyi.common.core.domain.AjaxResult;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.cache.annotation.CacheEvict;
-import org.springframework.cache.annotation.CachePut;
-import org.springframework.cache.annotation.Cacheable;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-/**
- * spring-cache 演示案例
- *
- * @author Lion Li
- */
-// 类级别 缓存统一配置
-//@CacheConfig(cacheNames = "redissonCacheMap")
-@Api(value = "spring-cache 演示案例", tags = {"spring-cache 演示案例"})
-@RequiredArgsConstructor(onConstructor_ = @Autowired)
-@RestController
-@RequestMapping("/demo/cache")
-public class RedisCacheController {
-
-	/**
-	 * 测试 @Cacheable
-	 *
-	 * 表示这个方法有了缓存的功能,方法的返回值会被缓存下来
-	 * 下一次调用该方法前,会去检查是否缓存中已经有值
-	 * 如果有就直接返回,不调用方法
-	 * 如果没有,就调用方法,然后把结果缓存起来
-	 * 这个注解「一般用在查询方法上」
-	 *
-	 * cacheNames 为配置文件内 groupId
-	 */
-	@ApiOperation("测试 @Cacheable")
-	@Cacheable(cacheNames = "redissonCacheMap", key = "#key", condition = "#key != null")
-	@GetMapping("/test1")
-	public AjaxResult<String> test1(String key, String value){
-		return AjaxResult.success("操作成功", value);
-	}
-
-	/**
-	 * 测试 @CachePut
-	 *
-	 * 加了@CachePut注解的方法,会把方法的返回值put到缓存里面缓存起来,供其它地方使用
-	 * 它「通常用在新增方法上」
-	 *
-	 * cacheNames 为 配置文件内 groupId
-	 */
-	@ApiOperation("测试 @CachePut")
-	@CachePut(cacheNames = "redissonCacheMap", key = "#key", condition = "#key != null")
-	@GetMapping("/test2")
-	public AjaxResult<String> test2(String key, String value){
-		return AjaxResult.success("操作成功", value);
-	}
-
-	/**
-	 * 测试 @CacheEvict
-	 *
-	 * 使用了CacheEvict注解的方法,会清空指定缓存
-	 * 「一般用在更新或者删除的方法上」
-	 *
-	 * cacheNames 为 配置文件内 groupId
-	 */
-	@ApiOperation("测试 @CacheEvict")
-	@CacheEvict(cacheNames = "redissonCacheMap", key = "#key", condition = "#key != null")
-	@GetMapping("/test3")
-	public AjaxResult<String> test3(String key, String value){
-		return AjaxResult.success("操作成功", value);
-	}
-
-}

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

@@ -1,86 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.baomidou.lock.LockInfo;
-import com.baomidou.lock.LockTemplate;
-import com.baomidou.lock.annotation.Lock4j;
-import com.baomidou.lock.executor.RedissonLockExecutor;
-import com.ruoyi.common.core.domain.AjaxResult;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.cache.annotation.Cacheable;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.time.LocalTime;
-
-
-/**
- * 测试分布式锁的样例
- *
- * @author shenxinquan
- */
-@Api(value = "测试分布式锁的样例", tags = {"测试分布式锁的样例"})
-@Slf4j
-@RestController
-@RequestMapping("/demo/redisLock")
-public class RedisLockController {
-
-	@Autowired
-	private LockTemplate lockTemplate;
-
-	/**
-	 * 测试lock4j 注解
-	 */
-	@ApiOperation("测试lock4j 注解")
-	@Lock4j(keys = {"#key"})
-	@GetMapping("/testLock4j")
-	public  AjaxResult<String> testLock4j(String key,String value){
-		System.out.println("start:"+key+",time:"+ LocalTime.now().toString());
-		try {
-			Thread.sleep(10000);
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
-		System.out.println("end :"+key+",time:"+LocalTime.now().toString());
-		return AjaxResult.success("操作成功",value);
-	}
-
-	/**
-	 * 测试lock4j 工具
-	 */
-	@ApiOperation("测试lock4j 工具")
-	@GetMapping("/testLock4jLockTemaplate")
-	public  AjaxResult<String> testLock4jLockTemaplate(String key,String value){
-		final LockInfo lockInfo = lockTemplate.lock(key, 30000L, 5000L, RedissonLockExecutor.class);
-		if (null == lockInfo) {
-			throw new RuntimeException("业务处理中,请稍后再试");
-		}
-		// 获取锁成功，处理业务
-		try {
-			try {
-				Thread.sleep(8000);
-			} catch (InterruptedException e) {
-				//
-			}
-			System.out.println("执行简单方法1 , 当前线程:" + Thread.currentThread().getName());
-		} finally {
-			//释放锁
-			lockTemplate.releaseLock(lockInfo);
-		}
-		//结束
-		return AjaxResult.success("操作成功",value);
-	}
-
-	/**
-	 * 测试spring-cache注解
-	 */
-	@ApiOperation("测试spring-cache注解")
-	@Cacheable(value = "test", key = "#key")
-	@GetMapping("/testCache")
-	public AjaxResult<String> testCache(String key) {
-		return AjaxResult.success("操作成功", key);
-	}
-}

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

@@ -1,42 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.ruoyi.common.core.domain.AjaxResult;
-import com.ruoyi.common.utils.RedisUtils;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-/**
- * Redis 发布订阅 演示案例
- *
- * @author Lion Li
- */
-@Api(value = "Redis发布订阅 演示案例", tags = {"Redis发布订阅"})
-@RequiredArgsConstructor(onConstructor_ = @Autowired)
-@RestController
-@RequestMapping("/demo/redis/pubsub")
-public class RedisPubSubController {
-
-	@ApiOperation("发布消息")
-	@GetMapping("/pub")
-	public AjaxResult<Void> pub(String key, String value){
-		RedisUtils.publish(key, value, consumer -> {
-			System.out.println("发布通道 => " + key + ", 发送值 => " + value);
-		});
-		return AjaxResult.success("操作成功");
-	}
-
-	@ApiOperation("订阅消息")
-	@GetMapping("/sub")
-	public AjaxResult<Void> sub(String key){
-		RedisUtils.subscribe(key, String.class, msg -> {
-			System.out.println("订阅通道 => " + key + ", 接收值 => " + msg);
-		});
-		return AjaxResult.success("操作成功");
-	}
-
-}

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

@@ -1,38 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.ruoyi.common.core.domain.AjaxResult;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiImplicitParam;
-import io.swagger.annotations.ApiImplicitParams;
-import io.swagger.annotations.ApiOperation;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestPart;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.multipart.MultipartFile;
-
-/**
- * swagger3 用法示例
- *
- * @author Lion Li
- */
-@Api(value = "演示swagger3控制器", tags = {"演示swagger3接口"})
-@RestController
-@RequestMapping("/swagger/demo")
-public class Swagger3DemoController {
-
-	/**
-	 * 上传请求
-	 * 必须使用 @RequestPart 注解标注为文件
-	 * dataType 必须为 "java.io.File"
-	 */
-	@ApiOperation(value = "通用上传请求")
-	@ApiImplicitParams({
-		@ApiImplicitParam(name = "file", value = "文件", dataType = "java.io.File", required = true),
-	})
-	@PostMapping(value = "/upload")
-	public AjaxResult<String> upload(@RequestPart("file") MultipartFile file) {
-		return AjaxResult.success("操作成功", file.getOriginalFilename());
-	}
-
-}

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

@@ -1,81 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.ruoyi.common.core.controller.BaseController;
-import com.ruoyi.common.core.domain.AjaxResult;
-import com.ruoyi.demo.domain.TestDemo;
-import com.ruoyi.demo.service.ITestDemoService;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.DeleteMapping;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * 测试批量方法
- *
- * @author Lion Li
- * @date 2021-05-30
- */
-@Api(value = "测试批量方法", tags = {"测试批量方法"})
-@RequiredArgsConstructor(onConstructor_ = @Autowired)
-@RestController
-@RequestMapping("/demo/batch")
-public class TestBatchController extends BaseController {
-
-    private final ITestDemoService iTestDemoService;
-
-    /**
-     * 新增批量方法 可完美替代 saveBatch 秒级插入上万数据 (对mysql负荷较大)
-     */
-	@ApiOperation(value = "新增批量方法")
-    @PostMapping("/add")
-//	@DataSource(DataSourceType.SLAVE)
-    public AjaxResult<Void> add() {
-		List<TestDemo> list = new ArrayList<>();
-		for (int i = 0; i < 1000; i++) {
-			list.add(new TestDemo().setOrderNum(-1L).setTestKey("批量新增").setValue("测试新增"));
-		}
-        return toAjax(iTestDemoService.saveAll(list) ? 1 : 0);
-    }
-
-	/**
-	 * 新增或更新 可完美替代 saveOrUpdateBatch 高性能
-	 */
-	@ApiOperation(value = "新增或更新批量方法")
-	@PostMapping("/addOrUpdate")
-//	@DataSource(DataSourceType.SLAVE)
-	public AjaxResult<Void> addOrUpdate() {
-		List<TestDemo> list = new ArrayList<>();
-		for (int i = 0; i < 1000; i++) {
-			list.add(new TestDemo().setOrderNum(-1L).setTestKey("批量新增").setValue("测试新增"));
-		}
-		iTestDemoService.saveAll(list);
-		for (int i = 0; i < list.size(); i++) {
-			TestDemo testDemo = list.get(i);
-			testDemo.setTestKey("批量新增或修改").setValue("批量新增或修改");
-			if (i % 2 == 0) {
-				testDemo.setId(null);
-			}
-		}
-		return toAjax(iTestDemoService.saveOrUpdateAll(list) ? 1 : 0);
-	}
-
-    /**
-     * 删除批量方法
-     */
-	@ApiOperation(value = "删除批量方法")
-    @DeleteMapping()
-//	@DataSource(DataSourceType.SLAVE)
-    public AjaxResult<Void> remove() {
-        return toAjax(iTestDemoService.remove(new LambdaQueryWrapper<TestDemo>()
-			.eq(TestDemo::getOrderNum, -1L)) ? 1 : 0);
-    }
-
-}

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

@@ -1,33 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.ruoyi.common.core.domain.AjaxResult;
-import com.ruoyi.common.utils.MessageUtils;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-
-/**
- * 测试国际化
- *
- * @author Lion Li
- */
-@Api(value = "测试国际化控制器", tags = {"测试国际化管理"})
-@RestController
-@RequestMapping("/demo/i18n")
-public class TestI18nController {
-
-	/**
-	 * 通过code获取国际化内容
-	 * code为 messages.properties 中的 key
-	 *
-	 * 测试使用 user.register.success
-	 */
-	@ApiOperation("通过code获取国际化内容")
-	@GetMapping()
-	public AjaxResult<Void> get(String code) {
-		return AjaxResult.success(MessageUtils.message(code));
-	}
-}

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

@@ -1,113 +0,0 @@
-package com.ruoyi.demo.controller;
-
-import com.ruoyi.common.annotation.Log;
-import com.ruoyi.common.annotation.RepeatSubmit;
-import com.ruoyi.common.core.controller.BaseController;
-import com.ruoyi.common.core.domain.AjaxResult;
-import com.ruoyi.common.core.validate.AddGroup;
-import com.ruoyi.common.core.validate.EditGroup;
-import com.ruoyi.common.core.validate.QueryGroup;
-import com.ruoyi.common.enums.BusinessType;
-import com.ruoyi.common.utils.poi.ExcelUtil;
-import com.ruoyi.demo.domain.bo.TestTreeBo;
-import com.ruoyi.demo.domain.vo.TestTreeVo;
-import com.ruoyi.demo.service.ITestTreeService;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-
-import javax.servlet.http.HttpServletResponse;
-import javax.validation.constraints.NotEmpty;
-import javax.validation.constraints.NotNull;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * 测试树表Controller
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Validated
-@Api(value = "测试树表控制器", tags = {"测试树表管理"})
-@RequiredArgsConstructor(onConstructor_ = @Autowired)
-@RestController
-@RequestMapping("/demo/tree")
-public class TestTreeController extends BaseController {
-
-    private final ITestTreeService iTestTreeService;
-
-    /**
-     * 查询测试树表列表
-     */
-    @ApiOperation("查询测试树表列表")
-    @PreAuthorize("@ss.hasPermi('demo:tree:list')")
-    @GetMapping("/list")
-    public AjaxResult<List<TestTreeVo>> list(@Validated(QueryGroup.class) TestTreeBo bo) {
-        List<TestTreeVo> list = iTestTreeService.queryList(bo);
-        return AjaxResult.success(list);
-    }
-
-    /**
-     * 导出测试树表列表
-     */
-    @ApiOperation("导出测试树表列表")
-    @PreAuthorize("@ss.hasPermi('demo:tree:export')")
-    @Log(title = "测试树表", businessType = BusinessType.EXPORT)
-    @GetMapping("/export")
-    public void export(@Validated TestTreeBo bo, HttpServletResponse response) {
-        List<TestTreeVo> list = iTestTreeService.queryList(bo);
-		ExcelUtil.exportExcel(list, "测试树表", TestTreeVo.class, response);
-    }
-
-    /**
-     * 获取测试树表详细信息
-     */
-    @ApiOperation("获取测试树表详细信息")
-    @PreAuthorize("@ss.hasPermi('demo:tree:query')")
-    @GetMapping("/{id}")
-    public AjaxResult<TestTreeVo> getInfo(@NotNull(message = "主键不能为空")
-                                                  @PathVariable("id") Long id) {
-        return AjaxResult.success(iTestTreeService.queryById(id));
-    }
-
-    /**
-     * 新增测试树表
-     */
-    @ApiOperation("新增测试树表")
-    @PreAuthorize("@ss.hasPermi('demo:tree:add')")
-    @Log(title = "测试树表", businessType = BusinessType.INSERT)
-    @RepeatSubmit
-    @PostMapping()
-    public AjaxResult<Void> add(@Validated(AddGroup.class) @RequestBody TestTreeBo bo) {
-        return toAjax(iTestTreeService.insertByBo(bo) ? 1 : 0);
-    }
-
-    /**
-     * 修改测试树表
-     */
-    @ApiOperation("修改测试树表")
-    @PreAuthorize("@ss.hasPermi('demo:tree:edit')")
-    @Log(title = "测试树表", businessType = BusinessType.UPDATE)
-    @RepeatSubmit
-    @PutMapping()
-    public AjaxResult<Void> edit(@Validated(EditGroup.class) @RequestBody TestTreeBo bo) {
-        return toAjax(iTestTreeService.updateByBo(bo) ? 1 : 0);
-    }
-
-    /**
-     * 删除测试树表
-     */
-    @ApiOperation("删除测试树表")
-    @PreAuthorize("@ss.hasPermi('demo:tree:remove')")
-    @Log(title = "测试树表" , businessType = BusinessType.DELETE)
-    @DeleteMapping("/{ids}")
-    public AjaxResult<Void> remove(@NotEmpty(message = "主键不能为空")
-                                       @PathVariable Long[] ids) {
-        return toAjax(iTestTreeService.deleteWithValidByIds(Arrays.asList(ids), true) ? 1 : 0);
-    }
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestDemo.java

@@ -1,94 +0,0 @@
-package com.ruoyi.demo.domain;
-
-import com.baomidou.mybatisplus.annotation.*;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.experimental.Accessors;
-
-import java.io.Serializable;
-import java.util.Date;
-
-/**
- * 测试单表对象 test_demo
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Data
-@NoArgsConstructor
-@Accessors(chain = true)
-@TableName("test_demo")
-public class TestDemo implements Serializable {
-
-    private static final long serialVersionUID=1L;
-
-
-	/**
-	 * 主键
-	 */
-    @TableId(value = "id")
-    private Long id;
-
-    /**
-     * 部门id
-     */
-    private Long deptId;
-
-    /**
-     * 用户id
-     */
-    private Long userId;
-
-    /**
-     * 排序号
-     */
-	@OrderBy(isDesc = false, sort = 1)
-    private Long orderNum;
-
-    /**
-     * key键
-     */
-    private String testKey;
-
-    /**
-     * 值
-     */
-    private String value;
-
-    /**
-     * 版本
-     */
-    @Version
-    private Long version;
-
-    /**
-     * 创建时间
-     */
-    @TableField(fill = FieldFill.INSERT)
-    private Date createTime;
-
-    /**
-     * 创建人
-     */
-    @TableField(fill = FieldFill.INSERT)
-    private String createBy;
-
-    /**
-     * 更新时间
-     */
-    @TableField(fill = FieldFill.INSERT_UPDATE)
-    private Date updateTime;
-
-    /**
-     * 更新人
-     */
-    @TableField(fill = FieldFill.INSERT_UPDATE)
-    private String updateBy;
-
-    /**
-     * 删除标志
-     */
-    @TableLogic
-    private Long delFlag;
-
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/domain/TestTree.java

@@ -1,88 +0,0 @@
-package com.ruoyi.demo.domain;
-
-import com.baomidou.mybatisplus.annotation.*;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.experimental.Accessors;
-
-import java.io.Serializable;
-import java.util.Date;
-
-/**
- * 测试树表对象 test_tree
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Data
-@NoArgsConstructor
-@Accessors(chain = true)
-@TableName("test_tree")
-public class TestTree implements Serializable {
-
-    private static final long serialVersionUID=1L;
-
-
-    /**
-     * 主键
-     */
-    @TableId(value = "id")
-    private Long id;
-
-    /**
-     * 父id
-     */
-    private Long parentId;
-
-    /**
-     * 部门id
-     */
-    private Long deptId;
-
-    /**
-     * 用户id
-     */
-    private Long userId;
-
-    /**
-     * 树节点名
-     */
-    private String treeName;
-
-    /**
-     * 版本
-     */
-    @Version
-    private Long version;
-
-    /**
-     * 创建时间
-     */
-    @TableField(fill = FieldFill.INSERT)
-    private Date createTime;
-
-    /**
-     * 创建人
-     */
-    @TableField(fill = FieldFill.INSERT)
-    private String createBy;
-
-    /**
-     * 更新时间
-     */
-    @TableField(fill = FieldFill.INSERT_UPDATE)
-    private Date updateTime;
-
-    /**
-     * 更新人
-     */
-    @TableField(fill = FieldFill.INSERT_UPDATE)
-    private String updateBy;
-
-    /**
-     * 删除标志
-     */
-    @TableLogic
-    private Long delFlag;
-
-}

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

@@ -1,94 +0,0 @@
-package com.ruoyi.demo.domain.bo;
-
-import com.ruoyi.common.core.validate.AddGroup;
-import com.ruoyi.common.core.validate.EditGroup;
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import javax.validation.constraints.*;
-
-import java.util.Date;
-
-import com.ruoyi.common.core.domain.BaseEntity;
-
-/**
- * 测试单表业务对象 test_demo
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-
-@Data
-@EqualsAndHashCode(callSuper = true)
-@ApiModel("测试单表业务对象")
-public class TestDemoBo extends BaseEntity {
-
-    /**
-     * 主键
-     */
-	@ApiModelProperty("主键")
-    @NotNull(message = "主键不能为空", groups = { EditGroup.class })
-    private Long id;
-
-    /**
-     * 部门id
-     */
-	@ApiModelProperty("部门id")
-    @NotNull(message = "部门id不能为空", groups = { AddGroup.class, EditGroup.class })
-    private Long deptId;
-
-    /**
-     * 用户id
-     */
-	@ApiModelProperty("用户id")
-    @NotNull(message = "用户id不能为空", groups = { AddGroup.class, EditGroup.class })
-    private Long userId;
-
-    /**
-     * 排序号
-     */
-	@ApiModelProperty("排序号")
-    @NotNull(message = "排序号不能为空", groups = { AddGroup.class, EditGroup.class })
-    private Long orderNum;
-
-    /**
-     * key键
-     */
-	@ApiModelProperty("key键")
-    @NotBlank(message = "key键不能为空", groups = { AddGroup.class, EditGroup.class })
-    private String testKey;
-
-    /**
-     * 值
-     */
-	@ApiModelProperty("值")
-    @NotBlank(message = "值不能为空", groups = { AddGroup.class, EditGroup.class })
-    private String value;
-
-
-    /**
-     * 分页大小
-     */
-    @ApiModelProperty("分页大小")
-    private Integer pageSize;
-
-    /**
-     * 当前页数
-     */
-    @ApiModelProperty("当前页数")
-    private Integer pageNum;
-
-    /**
-     * 排序列
-     */
-    @ApiModelProperty("排序列")
-    private String orderByColumn;
-
-    /**
-     * 排序的方向desc或者asc
-     */
-    @ApiModelProperty(value = "排序的方向", example = "asc,desc")
-    private String isAsc;
-
-}

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

@@ -1,79 +0,0 @@
-package com.ruoyi.demo.domain.bo;
-
-import com.ruoyi.common.core.domain.TreeEntity;
-import com.ruoyi.common.core.validate.AddGroup;
-import com.ruoyi.common.core.validate.EditGroup;
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-
-/**
- * 测试树表业务对象 test_tree
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-
-@Data
-@EqualsAndHashCode(callSuper = true)
-@ApiModel("测试树表业务对象")
-public class TestTreeBo extends TreeEntity {
-
-    /**
-     * 主键
-     */
-	@ApiModelProperty("主键")
-    @NotNull(message = "主键不能为空", groups = { EditGroup.class })
-    private Long id;
-
-    /**
-     * 部门id
-     */
-	@ApiModelProperty("部门id")
-    @NotNull(message = "部门id不能为空", groups = { AddGroup.class, EditGroup.class })
-    private Long deptId;
-
-    /**
-     * 用户id
-     */
-	@ApiModelProperty("用户id")
-    @NotNull(message = "用户id不能为空", groups = { AddGroup.class, EditGroup.class })
-    private Long userId;
-
-    /**
-     * 树节点名
-     */
-	@ApiModelProperty("树节点名")
-    @NotBlank(message = "树节点名不能为空", groups = { AddGroup.class, EditGroup.class })
-    private String treeName;
-
-
-    /**
-     * 分页大小
-     */
-    @ApiModelProperty("分页大小")
-    private Integer pageSize;
-
-    /**
-     * 当前页数
-     */
-    @ApiModelProperty("当前页数")
-    private Integer pageNum;
-
-    /**
-     * 排序列
-     */
-    @ApiModelProperty("排序列")
-    private String orderByColumn;
-
-    /**
-     * 排序的方向desc或者asc
-     */
-    @ApiModelProperty(value = "排序的方向", example = "asc,desc")
-    private String isAsc;
-
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/domain/package-info.java

@@ -1 +0,0 @@
-package com.ruoyi.demo.domain;

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

@@ -1,94 +0,0 @@
-package com.ruoyi.demo.domain.vo;
-
-import cn.afterturn.easypoi.excel.annotation.Excel;
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
-
-import java.util.Date;
-
-
-/**
- * 测试单表视图对象 test_demo
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Data
-@ApiModel("测试单表视图对象")
-public class TestDemoVo {
-
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * 主键
-     */
-    @Excel(name = "主键")
-    @ApiModelProperty("主键")
-    private Long id;
-
-    /**
-     * 部门id
-     */
-    @Excel(name = "部门id")
-    @ApiModelProperty("部门id")
-    private Long deptId;
-
-    /**
-     * 用户id
-     */
-    @Excel(name = "用户id")
-    @ApiModelProperty("用户id")
-    private Long userId;
-
-    /**
-     * 排序号
-     */
-    @Excel(name = "排序号")
-    @ApiModelProperty("排序号")
-    private Long orderNum;
-
-    /**
-     * key键
-     */
-    @Excel(name = "key键")
-    @ApiModelProperty("key键")
-    private String testKey;
-
-    /**
-     * 值
-     */
-    @Excel(name = "值")
-    @ApiModelProperty("值")
-    private String value;
-
-    /**
-     * 创建时间
-     */
-    @Excel(name = "创建时间")
-    @ApiModelProperty("创建时间")
-    private Date createTime;
-
-    /**
-     * 创建人
-     */
-    @Excel(name = "创建人")
-    @ApiModelProperty("创建人")
-    private String createBy;
-
-    /**
-     * 更新时间
-     */
-    @Excel(name = "更新时间")
-    @ApiModelProperty("更新时间")
-    private Date updateTime;
-
-    /**
-     * 更新人
-     */
-    @Excel(name = "更新人")
-    @ApiModelProperty("更新人")
-    private String updateBy;
-
-
-}

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

@@ -1,65 +0,0 @@
-package com.ruoyi.demo.domain.vo;
-
-import cn.afterturn.easypoi.excel.annotation.Excel;
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
-
-import java.util.Date;
-
-
-/**
- * 测试树表视图对象 test_tree
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Data
-@ApiModel("测试树表视图对象")
-public class TestTreeVo {
-
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * 主键
-     */
-    @ApiModelProperty("主键")
-    private Long id;
-
-    /**
-     * 父id
-     */
-    @Excel(name = "父id")
-    @ApiModelProperty("父id")
-    private Long parentId;
-
-    /**
-     * 部门id
-     */
-    @Excel(name = "部门id")
-    @ApiModelProperty("部门id")
-    private Long deptId;
-
-    /**
-     * 用户id
-     */
-    @Excel(name = "用户id")
-    @ApiModelProperty("用户id")
-    private Long userId;
-
-    /**
-     * 树节点名
-     */
-    @Excel(name = "树节点名")
-    @ApiModelProperty("树节点名")
-    private String treeName;
-
-    /**
-     * 创建时间
-     */
-    @Excel(name = "创建时间")
-    @ApiModelProperty("创建时间")
-    private Date createTime;
-
-
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/feign/FeignTestService.java

@@ -1,26 +0,0 @@
-package com.ruoyi.demo.feign;
-
-import com.ruoyi.demo.feign.constant.FeignTestConstant;
-import com.ruoyi.demo.feign.fallback.FeignTestFallback;
-import org.springframework.cloud.openfeign.FeignClient;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-
-/**
- * feign测试service
- * 规范接口 Service 无感调用
- * 常量管理请求路径 更加规范
- * 自定义容错处理 安全可靠 (需自行配置熔断器)
- * 增加 feign 的目的为使 http 请求接口化
- *
- * @author Lion Li
- */
-@FeignClient(
-	name = FeignTestConstant.BAIDU_NAME,
-	url = FeignTestConstant.BAIDU_URL,
-	fallback = FeignTestFallback.class)
-public interface FeignTestService {
-
-    @GetMapping("/s")
-    String search(@RequestParam("wd") String wd);
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/feign/constant/FeignTestConstant.java

@@ -1,9 +0,0 @@
-package com.ruoyi.demo.feign.constant;
-
-public class FeignTestConstant {
-
-	public static final String BAIDU_NAME = "baidu";
-
-	public static final String BAIDU_URL = "http://www.baidu.com";
-
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/feign/fallback/FeignTestFallback.java

@@ -1,27 +0,0 @@
-package com.ruoyi.demo.feign.fallback;
-
-
-import com.ruoyi.demo.feign.FeignTestService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-
-/**
- * feign测试fallback
- * 自定义封装结构体熔断
- * 需重写解码器 根据自定义实体 自行解析熔断
- *
- * 熔断器需要自行添加配置
- *
- * @see {com.ruoyi.framework.config.FeignConfig#errorDecoder()}
- * @author Lion Li
- */
-@Slf4j
-@Component
-public class FeignTestFallback implements FeignTestService {
-
-    @Override
-    public String search(String wd) {
-        log.error("fallback");
-        return "报错啦";
-    }
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/feign/fallback/package-info.java

@@ -1 +0,0 @@
-package com.ruoyi.demo.feign.fallback;

ruoyi-demo/src/main/java/com/ruoyi/demo/feign/package-info.java

@@ -1 +0,0 @@
-package com.ruoyi.demo.feign;

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

@@ -1,24 +0,0 @@
-package com.ruoyi.demo.mapper;
-
-import com.baomidou.mybatisplus.core.conditions.Wrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.ruoyi.common.core.mybatisplus.cache.MybatisPlusRedisCache;
-import com.ruoyi.common.core.mybatisplus.core.BaseMapperPlus;
-import com.ruoyi.demo.domain.TestDemo;
-import com.ruoyi.demo.domain.vo.TestDemoVo;
-import org.apache.ibatis.annotations.CacheNamespace;
-import org.apache.ibatis.annotations.Param;
-
-/**
- * 测试单表Mapper接口
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-// 如使需切换数据源 请勿使用缓存 会造成数据不一致现象
-@CacheNamespace(implementation = MybatisPlusRedisCache.class, eviction = MybatisPlusRedisCache.class)
-public interface TestDemoMapper extends BaseMapperPlus<TestDemo> {
-
-    Page<TestDemoVo> customPageList(@Param("page") Page<TestDemo> page, @Param("ew") Wrapper<TestDemo> wrapper);
-
-}

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

@@ -1,14 +0,0 @@
-package com.ruoyi.demo.mapper;
-
-import com.ruoyi.common.core.mybatisplus.core.BaseMapperPlus;
-import com.ruoyi.demo.domain.TestTree;
-
-/**
- * 测试树表Mapper接口
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-public interface TestTreeMapper extends BaseMapperPlus<TestTree> {
-
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/mapper/package-info.java

@@ -1 +0,0 @@
-package com.ruoyi.demo.mapper;

ruoyi-demo/src/main/java/com/ruoyi/demo/service/ITestDemoService.java

@@ -1,62 +0,0 @@
-package com.ruoyi.demo.service;
-
-import com.ruoyi.demo.domain.TestDemo;
-import com.ruoyi.demo.domain.vo.TestDemoVo;
-import com.ruoyi.demo.domain.bo.TestDemoBo;
-import com.ruoyi.common.core.mybatisplus.core.IServicePlus;
-import com.ruoyi.common.core.page.TableDataInfo;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * 测试单表Service接口
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-public interface ITestDemoService extends IServicePlus<TestDemo, TestDemoVo> {
-
-	/**
-	 * 查询单个
-	 * @return
-	 */
-	TestDemoVo queryById(Long id);
-
-	/**
-	 * 查询列表
-	 */
-    TableDataInfo<TestDemoVo> queryPageList(TestDemoBo bo);
-
-	/**
-	 * 自定义分页查询
-	 */
-	TableDataInfo<TestDemoVo> customPageList(TestDemoBo bo);
-
-    /**
-	 * 查询列表
-	 */
-	List<TestDemoVo> queryList(TestDemoBo bo);
-
-	/**
-	 * 根据新增业务对象插入测试单表
-	 * @param bo 测试单表新增业务对象
-	 * @return
-	 */
-	Boolean insertByBo(TestDemoBo bo);
-
-	/**
-	 * 根据编辑业务对象修改测试单表
-	 * @param bo 测试单表编辑业务对象
-	 * @return
-	 */
-	Boolean updateByBo(TestDemoBo bo);
-
-	/**
-	 * 校验并删除数据
-	 * @param ids 主键集合
-	 * @param isValid 是否校验,true-删除前校验,false-不校验
-	 * @return
-	 */
-	Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/service/ITestTreeService.java

@@ -1,50 +0,0 @@
-package com.ruoyi.demo.service;
-
-import com.ruoyi.demo.domain.TestTree;
-import com.ruoyi.demo.domain.vo.TestTreeVo;
-import com.ruoyi.demo.domain.bo.TestTreeBo;
-import com.ruoyi.common.core.mybatisplus.core.IServicePlus;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * 测试树表Service接口
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-public interface ITestTreeService extends IServicePlus<TestTree, TestTreeVo> {
-	/**
-	 * 查询单个
-	 * @return
-	 */
-	TestTreeVo queryById(Long id);
-
-	/**
-	 * 查询列表
-	 */
-	List<TestTreeVo> queryList(TestTreeBo bo);
-
-	/**
-	 * 根据新增业务对象插入测试树表
-	 * @param bo 测试树表新增业务对象
-	 * @return
-	 */
-	Boolean insertByBo(TestTreeBo bo);
-
-	/**
-	 * 根据编辑业务对象修改测试树表
-	 * @param bo 测试树表编辑业务对象
-	 * @return
-	 */
-	Boolean updateByBo(TestTreeBo bo);
-
-	/**
-	 * 校验并删除数据
-	 * @param ids 主键集合
-	 * @param isValid 是否校验,true-删除前校验,false-不校验
-	 * @return
-	 */
-	Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/service/impl/TestDemoServiceImpl.java

@@ -1,104 +0,0 @@
-package com.ruoyi.demo.service.impl;
-
-import cn.hutool.core.bean.BeanUtil;
-import com.ruoyi.common.utils.StringUtils;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.ruoyi.common.annotation.DataScope;
-import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
-import com.ruoyi.common.core.page.PagePlus;
-import com.ruoyi.common.core.page.TableDataInfo;
-import com.ruoyi.common.utils.PageUtils;
-import com.ruoyi.demo.domain.TestDemo;
-import com.ruoyi.demo.domain.bo.TestDemoBo;
-import com.ruoyi.demo.domain.vo.TestDemoVo;
-import com.ruoyi.demo.mapper.TestDemoMapper;
-import com.ruoyi.demo.service.ITestDemoService;
-import org.springframework.stereotype.Service;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 测试单表Service业务层处理
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Service
-public class TestDemoServiceImpl extends ServicePlusImpl<TestDemoMapper, TestDemo, TestDemoVo> implements ITestDemoService {
-
-	@Override
-	public TestDemoVo queryById(Long id) {
-		return getVoById(id);
-	}
-
-	@DataScope(isUser = true)
-	@Override
-	public TableDataInfo<TestDemoVo> queryPageList(TestDemoBo bo) {
-		PagePlus<TestDemo, TestDemoVo> result = pageVo(PageUtils.buildPagePlus(), buildQueryWrapper(bo));
-		return PageUtils.buildDataInfo(result);
-	}
-
-	/**
-	 * 自定义分页查询
-	 */
-	@DataScope(isUser = true)
-	@Override
-	public TableDataInfo<TestDemoVo> customPageList(TestDemoBo bo) {
-		Page<TestDemoVo> result = baseMapper.customPageList(PageUtils.buildPage(), buildQueryWrapper(bo));
-		return PageUtils.buildDataInfo(result);
-	}
-
-	@DataScope(isUser = true)
-	@Override
-	public List<TestDemoVo> queryList(TestDemoBo bo) {
-		return listVo(buildQueryWrapper(bo));
-	}
-
-	private LambdaQueryWrapper<TestDemo> buildQueryWrapper(TestDemoBo bo) {
-		Map<String, Object> params = bo.getParams();
-		Object dataScope = params.get("dataScope");
-		LambdaQueryWrapper<TestDemo> lqw = Wrappers.lambdaQuery();
-		lqw.like(StringUtils.isNotBlank(bo.getTestKey()), TestDemo::getTestKey, bo.getTestKey());
-		lqw.eq(StringUtils.isNotBlank(bo.getValue()), TestDemo::getValue, bo.getValue());
-		lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
-			TestDemo::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
-		lqw.apply(dataScope != null && StringUtils.isNotBlank(dataScope.toString()),
-			dataScope != null ? dataScope.toString() : null);
-		return lqw;
-	}
-
-	@Override
-	public Boolean insertByBo(TestDemoBo bo) {
-		TestDemo add = BeanUtil.toBean(bo, TestDemo.class);
-		validEntityBeforeSave(add);
-		return save(add);
-	}
-
-	@Override
-	public Boolean updateByBo(TestDemoBo bo) {
-		TestDemo update = BeanUtil.toBean(bo, TestDemo.class);
-		validEntityBeforeSave(update);
-		return updateById(update);
-	}
-
-	/**
-	 * 保存前的数据校验
-	 *
-	 * @param entity 实体类数据
-	 */
-	private void validEntityBeforeSave(TestDemo entity) {
-		//TODO 做一些数据校验,如唯一约束
-	}
-
-	@Override
-	public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
-		if (isValid) {
-			//TODO 做一些业务上的校验,判断是否需要校验
-		}
-		return removeByIds(ids);
-	}
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/service/impl/TestTreeServiceImpl.java

@@ -1,83 +0,0 @@
-package com.ruoyi.demo.service.impl;
-
-import cn.hutool.core.bean.BeanUtil;
-import com.ruoyi.common.utils.StringUtils;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.ruoyi.common.annotation.DataScope;
-import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
-import com.ruoyi.demo.domain.TestTree;
-import com.ruoyi.demo.domain.bo.TestTreeBo;
-import com.ruoyi.demo.domain.vo.TestTreeVo;
-import com.ruoyi.demo.mapper.TestTreeMapper;
-import com.ruoyi.demo.service.ITestTreeService;
-import org.springframework.stereotype.Service;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 测试树表Service业务层处理
- *
- * @author Lion Li
- * @date 2021-07-26
- */
-@Service
-public class TestTreeServiceImpl extends ServicePlusImpl<TestTreeMapper, TestTree, TestTreeVo> implements ITestTreeService {
-
-	@Override
-	public TestTreeVo queryById(Long id) {
-		return getVoById(id);
-	}
-
-//	@DataSource(DataSourceType.SLAVE) // 切换从库查询
-	@DataScope(isUser = true)
-	@Override
-	public List<TestTreeVo> queryList(TestTreeBo bo) {
-		return listVo(buildQueryWrapper(bo));
-	}
-
-	private LambdaQueryWrapper<TestTree> buildQueryWrapper(TestTreeBo bo) {
-		Map<String, Object> params = bo.getParams();
-		Object dataScope = params.get("dataScope");
-		LambdaQueryWrapper<TestTree> lqw = Wrappers.lambdaQuery();
-		lqw.like(StringUtils.isNotBlank(bo.getTreeName()), TestTree::getTreeName, bo.getTreeName());
-		lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
-			TestTree::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
-		lqw.apply(dataScope != null && StringUtils.isNotBlank(dataScope.toString()),
-			dataScope != null ? dataScope.toString() : null);
-		return lqw;
-	}
-
-	@Override
-	public Boolean insertByBo(TestTreeBo bo) {
-		TestTree add = BeanUtil.toBean(bo, TestTree.class);
-		validEntityBeforeSave(add);
-		return save(add);
-	}
-
-	@Override
-	public Boolean updateByBo(TestTreeBo bo) {
-		TestTree update = BeanUtil.toBean(bo, TestTree.class);
-		validEntityBeforeSave(update);
-		return updateById(update);
-	}
-
-	/**
-	 * 保存前的数据校验
-	 *
-	 * @param entity 实体类数据
-	 */
-	private void validEntityBeforeSave(TestTree entity) {
-		//TODO 做一些数据校验,如唯一约束
-	}
-
-	@Override
-	public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
-		if (isValid) {
-			//TODO 做一些业务上的校验,判断是否需要校验
-		}
-		return removeByIds(ids);
-	}
-}

ruoyi-demo/src/main/java/com/ruoyi/demo/service/impl/package-info.java

@@ -1 +0,0 @@
-package com.ruoyi.demo.service.impl;

ruoyi-demo/src/main/java/com/ruoyi/demo/service/package-info.java

@@ -1 +0,0 @@
-package com.ruoyi.demo.service;

ruoyi-demo/src/main/resources/mapper/demo/TestDemoMapper.xml

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper
-PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.ruoyi.demo.mapper.TestDemoMapper">
-
-    <resultMap type="com.ruoyi.demo.domain.TestDemo" id="TestDemoResult">
-        <result property="id" column="id"/>
-        <result property="deptId" column="dept_id"/>
-        <result property="userId" column="user_id"/>
-        <result property="orderNum" column="order_num"/>
-        <result property="testKey" column="test_key"/>
-        <result property="value" column="value"/>
-        <result property="version" column="version"/>
-        <result property="createTime" column="create_time"/>
-        <result property="createBy" column="create_by"/>
-        <result property="updateTime" column="update_time"/>
-        <result property="updateBy" column="update_by"/>
-        <result property="delFlag" column="del_flag"/>
-    </resultMap>
-    <select id="customPageList" resultType="com.ruoyi.demo.domain.vo.TestDemoVo">
-        SELECT * FROM test_demo ${ew.customSqlSegment}
-    </select>
-
-
-</mapper>

ruoyi-demo/src/main/resources/mapper/demo/TestTreeMapper.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper
-PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.ruoyi.demo.mapper.TestTreeMapper">
-
-    <resultMap type="com.ruoyi.demo.domain.TestTree" id="TestTreeResult">
-        <result property="id" column="id"/>
-        <result property="parentId" column="parent_id"/>
-        <result property="deptId" column="dept_id"/>
-        <result property="userId" column="user_id"/>
-        <result property="treeName" column="tree_name"/>
-        <result property="version" column="version"/>
-        <result property="createTime" column="create_time"/>
-        <result property="createBy" column="create_by"/>
-        <result property="updateTime" column="update_time"/>
-        <result property="updateBy" column="update_by"/>
-        <result property="delFlag" column="del_flag"/>
-    </resultMap>
-
-
-</mapper>

ruoyi-framework/pom.xml

@@ -67,19 +67,19 @@
             <artifactId>ruoyi-system</artifactId>
         </dependency>
 
-        <!--        <dependency>-->
-        <!--            <groupId>com.alibaba.cloud</groupId>-->
-        <!--            <artifactId>spring-cloud-alibaba-dependencies</artifactId>-->
-        <!--            <version>${alicloud.version}</version>-->
-        <!--            <type>pom</type>-->
-        <!--            <scope>import</scope>-->
-        <!--            <exclusions>-->
-        <!--                <exclusion>-->
-        <!--                    <groupId>org.springframework.cloud</groupId>-->
-        <!--                    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>-->
-        <!--                </exclusion>-->
-        <!--            </exclusions>-->
-        <!--        </dependency>-->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
+            <version>${alicloud.version}</version>
+            <type>pom</type>
+            <scope>import</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.springframework.cloud</groupId>
+                    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
 
         <dependency>
             <groupId>com.alibaba.cloud</groupId>

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

@@ -1,8 +1,12 @@
 package com.ruoyi.framework.config;
 
-import com.alibaba.nacos.client.naming.utils.SignUtil;
 import com.ruoyi.framework.config.properties.TokenProperties;
-import feign.*;
+import feign.Contract;
+import feign.Feign;
+import feign.Logger;
+import feign.Request;
+import feign.RequestInterceptor;
+import feign.Retryer;
 import lombok.extern.slf4j.Slf4j;
 import okhttp3.ConnectionPool;
 import okhttp3.OkHttpClient;
@@ -18,9 +22,6 @@ import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 
 import javax.servlet.http.HttpServletRequest;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.SortedMap;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -47,7 +48,7 @@ public class FeignConfig {
                 log.info("Feign request: {}", request.getRequestURI());
                 // 将token信息放入header中
                 String token = request.getHeader(tokenProperties.getHeader());
-                if(token==null || "".equals(token)){
+                if (token == null || "".equals(token)) {
                     token = request.getParameter("token");
                 }
                 requestTemplate.header(tokenProperties.getHeader(), token);
@@ -56,13 +57,13 @@ public class FeignConfig {
     }
 
     @Bean
-    public OkHttpClient okHttpClient(){
+    public OkHttpClient okHttpClient() {
         return new OkHttpClient.Builder()
-                .readTimeout(60, TimeUnit.SECONDS)
-                .connectTimeout(60, TimeUnit.SECONDS)
-                .writeTimeout(120, TimeUnit.SECONDS)
-                .connectionPool(new ConnectionPool())
-                .build();
+            .readTimeout(60, TimeUnit.SECONDS)
+            .connectTimeout(60, TimeUnit.SECONDS)
+            .writeTimeout(120, TimeUnit.SECONDS)
+            .connectionPool(new ConnectionPool())
+            .build();
     }
 
     @Bean
@@ -77,7 +78,7 @@ public class FeignConfig {
 
     @Bean
     public Request.Options feignRequestOptions() {
-        return new Request.Options(10, TimeUnit.SECONDS, 60,TimeUnit.SECONDS,true);
+        return new Request.Options(10, TimeUnit.SECONDS, 60, TimeUnit.SECONDS, true);
     }
 
     @Bean

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/domain/bo/IncidentBo.java

@@ -1,18 +1,16 @@
 package com.ruoyi.zhdd.domain.bo;
 
+import com.ruoyi.common.core.domain.BaseEntity;
 import com.ruoyi.common.core.validate.AddGroup;
-import com.ruoyi.common.core.validate.EditGroup;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
-import javax.validation.constraints.*;
 
-import java.util.Date;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
 import java.util.List;
 
-import com.ruoyi.common.core.domain.BaseEntity;
-
 /**
  * 事件基础业务对象 b_incident
  *
@@ -35,14 +33,14 @@ public class IncidentBo extends BaseEntity {
      * 事件类型
      */
     @ApiModelProperty(value = "事件类型")
-    @NotNull(message = "type不能为空", groups = { AddGroup.class })
+    @NotNull(message = "type不能为空", groups = {AddGroup.class})
     private Integer type;
 
     /**
      * 事件等级
      */
     @ApiModelProperty(value = "事件等级")
-    @NotNull(message = "level不能为空", groups = { AddGroup.class })
+    @NotNull(message = "level不能为空", groups = {AddGroup.class})
     private Integer level;
 
     private List<Integer> levels;
@@ -123,7 +121,7 @@ public class IncidentBo extends BaseEntity {
      * 事件标题
      */
     @ApiModelProperty(value = "事件标题")
-    @NotBlank(message = "name不能为空", groups = { AddGroup.class })
+    @NotBlank(message = "name不能为空", groups = {AddGroup.class})
     private String name;
 
     /**
@@ -169,4 +167,9 @@ public class IncidentBo extends BaseEntity {
     @ApiModelProperty(value = "排序的方向", example = "asc,desc")
     private String isAsc;
 
+    @ApiModelProperty("消息是否发送")
+    private boolean sendFlag = false;
+
+    @ApiModelProperty("消息发送的人")
+    private List<MessagePushUser> messagePushUsers;
 }

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/domain/bo/MessagePushBo.java

@@ -0,0 +1,33 @@
+package com.ruoyi.zhdd.domain.bo;
+
+import cn.hutool.core.date.DateUtil;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Description: TODO
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+@Data
+public class MessagePushBo {
+    // 标题（必填）
+    private String msTitle;
+    // 简介（必填）
+    private String msSynopsis;
+    // 内容（必填）
+    private String msText;
+    private String msSource = "1";
+    // 消息类型1：综合执法，2：应急指挥，3：运行监测
+    private String msType = "2";
+    // 是否定制化推送，0：否，1：是
+    private String msCustom = "1";
+    // 时间。格式yyyy-MM-dd
+    private String msTime = DateUtil.today();
+    // 消息id
+    private String msNo;
+    // 发送的用户
+    private List<MessagePushUser> messageReadInfoList;
+}

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/domain/bo/MessagePushUser.java

@@ -0,0 +1,16 @@
+package com.ruoyi.zhdd.domain.bo;
+
+import lombok.Data;
+
+/**
+ * @Description: TODO
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+@Data
+public class MessagePushUser {
+    private String userId;
+    private String readState = "0";
+    private String nickName;
+}

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/feign/FeignNoticeInfoService.java

@@ -0,0 +1,21 @@
+package com.ruoyi.zhdd.feign;
+
+import com.ruoyi.zhdd.domain.bo.MessagePushBo;
+import com.ruoyi.zhdd.feign.fallback.FeignNoticeInfoFallback;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+/**
+ * @Description: 联旺消息接口
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+@FeignClient(value = "notice-info", fallback = FeignNoticeInfoFallback.class)
+public interface FeignNoticeInfoService {
+
+    @PostMapping("/messagepushinfo")
+    void messagePush(@RequestBody MessagePushBo messagePushBo);
+
+}

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/feign/fallback/FeignNoticeInfoFallback.java

@@ -0,0 +1,22 @@
+package com.ruoyi.zhdd.feign.fallback;
+
+import com.ruoyi.zhdd.domain.bo.MessagePushBo;
+import com.ruoyi.zhdd.feign.FeignNoticeInfoService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description: TODO
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+@Slf4j
+@Component
+public class FeignNoticeInfoFallback implements FeignNoticeInfoService {
+
+    @Override
+    public void messagePush(MessagePushBo messagePushBo) {
+        log.error("APP发送消息失败");
+    }
+}

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/service/IThirdInterfaceService.java

@@ -0,0 +1,11 @@
+package com.ruoyi.zhdd.service;
+
+/**
+ * @Description: TODO
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+public interface IThirdInterfaceService {
+
+}

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/service/impl/IncidentServiceImpl.java

@@ -3,37 +3,36 @@ package com.ruoyi.zhdd.service.impl;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.util.StrUtil;
-import com.ruoyi.common.exception.ServiceException;
-import com.ruoyi.common.utils.StringUtils;
-import com.ruoyi.common.utils.PageUtils;
+import cn.hutool.json.JSONUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.ruoyi.common.constant.Constants;
+import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
 import com.ruoyi.common.core.page.PagePlus;
 import com.ruoyi.common.core.page.TableDataInfo;
-import com.ruoyi.zhdd.domain.IncidentProcess;
-import com.ruoyi.zhdd.domain.IncidentTask;
-import com.ruoyi.zhdd.domain.PlanTask;
+import com.ruoyi.common.exception.ServiceException;
+import com.ruoyi.common.utils.PageUtils;
+import com.ruoyi.common.utils.RedisUtils;
+import com.ruoyi.common.utils.StringUtils;
+import com.ruoyi.zhdd.domain.Incident;
+import com.ruoyi.zhdd.domain.bo.IncidentBo;
 import com.ruoyi.zhdd.domain.bo.IncidentProcessBo;
 import com.ruoyi.zhdd.domain.vo.IncidentProcessVo;
+import com.ruoyi.zhdd.domain.vo.IncidentVo;
+import com.ruoyi.zhdd.mapper.IncidentMapper;
 import com.ruoyi.zhdd.service.IIncidentProcessService;
+import com.ruoyi.zhdd.service.IIncidentService;
 import com.ruoyi.zhdd.service.IIncidentTaskService;
 import com.ruoyi.zhdd.service.IPlanService;
-import com.ruoyi.zhdd.service.IPlanTaskService;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.ruoyi.zhdd.domain.bo.IncidentBo;
-import com.ruoyi.zhdd.domain.vo.IncidentVo;
-import com.ruoyi.zhdd.domain.Incident;
-import com.ruoyi.zhdd.mapper.IncidentMapper;
-import com.ruoyi.zhdd.service.IIncidentService;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.sql.Timestamp;
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-import java.util.Collection;
 
 /**
  * 事件基础Service业务层处理
@@ -42,6 +41,7 @@ import java.util.Collection;
  * @date 2021-09-28
  */
 @Service
+@Slf4j
 public class IncidentServiceImpl extends ServicePlusImpl<IncidentMapper, Incident, IncidentVo> implements IIncidentService {
 
     @Autowired
@@ -52,7 +52,7 @@ public class IncidentServiceImpl extends ServicePlusImpl<IncidentMapper, Inciden
     private IIncidentTaskService incidentTaskService;
 
     @Override
-    public IncidentVo queryById(String id){
+    public IncidentVo queryById(String id) {
         return getVoById(id);
     }
 
@@ -87,7 +87,7 @@ public class IncidentServiceImpl extends ServicePlusImpl<IncidentMapper, Inciden
         lqw.eq(bo.getMadinDept() != null, Incident::getMadinDept, bo.getMadinDept());
         lqw.eq(StringUtils.isNotBlank(bo.getAssistDept()), Incident::getAssistDept, bo.getAssistDept());
         if (params.get("beginTime") != null && params.get("endTime") != null) {
-            lqw.between(Incident::getCreateTime, Timestamp.valueOf(Convert.toStr(params.get("beginTime"))+ " 00:00:00"), Timestamp.valueOf(Convert.toStr(params.get("endTime")) + " 23:59:59"));
+            lqw.between(Incident::getCreateTime, Timestamp.valueOf(Convert.toStr(params.get("beginTime")) + " 00:00:00"), Timestamp.valueOf(Convert.toStr(params.get("endTime")) + " 23:59:59"));
         }
         lqw.in(bo.getLevels() != null && bo.getLevels().size() > 0, Incident::getLevel, bo.getLevels());
         return lqw;
@@ -97,7 +97,15 @@ public class IncidentServiceImpl extends ServicePlusImpl<IncidentMapper, Inciden
     public Boolean insertByBo(IncidentBo bo) {
         Incident add = BeanUtil.toBean(bo, Incident.class);
         validEntityBeforeSave(add);
-        return save(add);
+        add.setExprJson(JSONUtil.toJsonStr(bo.getMessagePushUsers()));
+        boolean save = save(add);
+        if (bo.isSendFlag()) {
+            // A:事件接报。B:处置方案
+            RedisUtils.publish(Constants.NOTICE_PUSH, "A" + add.getId(), msg -> {
+                log.info("发布事件接报消息 => " + msg);
+            });
+        }
+        return save;
     }
 
     @Override
@@ -141,7 +149,13 @@ public class IncidentServiceImpl extends ServicePlusImpl<IncidentMapper, Inciden
                 throw new ServiceException("请填写归档总结！");
             }
         }
-        return updateById(update);
+        boolean b = updateById(update);
+        /*if (bo.isSendFlag()) {
+            RedisUtils.publish(Constants.NOTICE_PUSH, update.getId(), msg -> {
+                log.info("发布事件接报消息 => " + msg);
+            });
+        }*/
+        return b;
     }
 
     /**
@@ -149,13 +163,13 @@ public class IncidentServiceImpl extends ServicePlusImpl<IncidentMapper, Inciden
      *
      * @param entity 实体类数据
      */
-    private void validEntityBeforeSave(Incident entity){
+    private void validEntityBeforeSave(Incident entity) {
         //TODO 做一些数据校验,如唯一约束
     }
 
     @Override
     public Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid) {
-        if(isValid){
+        if (isValid) {
             //TODO 做一些业务上的校验,判断是否需要校验
         }
         return removeByIds(ids);

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/service/impl/SingleDeviceServiceImpl.java

@@ -1,23 +1,23 @@
 package com.ruoyi.zhdd.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
-import com.ruoyi.common.utils.StringUtils;
-import com.ruoyi.common.utils.PageUtils;
-import com.ruoyi.common.core.page.PagePlus;
-import com.ruoyi.common.core.page.TableDataInfo;
-import org.springframework.stereotype.Service;
-import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
+import com.ruoyi.common.core.page.PagePlus;
+import com.ruoyi.common.core.page.TableDataInfo;
+import com.ruoyi.common.utils.PageUtils;
+import com.ruoyi.common.utils.StringUtils;
+import com.ruoyi.zhdd.domain.SingleDevice;
 import com.ruoyi.zhdd.domain.bo.SingleDeviceBo;
 import com.ruoyi.zhdd.domain.vo.SingleDeviceVo;
-import com.ruoyi.zhdd.domain.SingleDevice;
 import com.ruoyi.zhdd.mapper.SingleDeviceMapper;
 import com.ruoyi.zhdd.service.ISingleDeviceService;
+import org.springframework.stereotype.Service;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-import java.util.Collection;
 
 /**
  * 单兵数据信息Service业务层处理
@@ -29,7 +29,7 @@ import java.util.Collection;
 public class SingleDeviceServiceImpl extends ServicePlusImpl<SingleDeviceMapper, SingleDevice, SingleDeviceVo> implements ISingleDeviceService {
 
     @Override
-    public SingleDeviceVo queryById(String userId){
+    public SingleDeviceVo queryById(String userId) {
         return getVoById(userId);
     }
 
@@ -41,6 +41,9 @@ public class SingleDeviceServiceImpl extends ServicePlusImpl<SingleDeviceMapper,
 
     @Override
     public List<SingleDeviceVo> queryList(SingleDeviceBo bo) {
+        // 单兵设备查询一分钟之内的
+//        bo.getParams().put("beginCreateTime", DateUtil.formatDateTime(DateUtil.offsetMinute(new Date(), -1)));
+//        bo.getParams().put("endCreateTime", DateUtil.now());
         return listVo(buildQueryWrapper(bo));
     }
 
@@ -59,6 +62,8 @@ public class SingleDeviceServiceImpl extends ServicePlusImpl<SingleDeviceMapper,
         lqw.eq(bo.getStartCount() != null, SingleDevice::getStartCount, bo.getStartCount());
         lqw.eq(bo.getDataSource() != null, SingleDevice::getDataSource, bo.getDataSource());
         lqw.eq(StringUtils.isNotBlank(bo.getTime()), SingleDevice::getTime, bo.getTime());
+        lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
+            SingleDevice::getTime, params.get("beginCreateTime"), params.get("endCreateTime"));
         return lqw;
     }
 
@@ -81,13 +86,13 @@ public class SingleDeviceServiceImpl extends ServicePlusImpl<SingleDeviceMapper,
      *
      * @param entity 实体类数据
      */
-    private void validEntityBeforeSave(SingleDevice entity){
+    private void validEntityBeforeSave(SingleDevice entity) {
         //TODO 做一些数据校验,如唯一约束
     }
 
     @Override
     public Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid) {
-        if(isValid){
+        if (isValid) {
             //TODO 做一些业务上的校验,判断是否需要校验
         }
         return removeByIds(ids);

ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/service/impl/ThirdInterfaceServiceImpl.java

@@ -0,0 +1,15 @@
+package com.ruoyi.zhdd.service.impl;
+
+import com.ruoyi.zhdd.service.IThirdInterfaceService;
+import org.springframework.stereotype.Service;
+
+/**
+ * @Description: TODO
+ * @Author: huangcheng
+ * @Date: 2022/1/12
+ * @Version V1.0
+ */
+@Service
+public class ThirdInterfaceServiceImpl implements IThirdInterfaceService {
+
+}

sql/20211209修改.sql

@@ -101,9 +101,27 @@ on column sys_user.id_number is '身份证';
 
 alter table sys_user alter column phonenumber type varchar(20) using phonenumber::varchar(20);
 
-
-
-
+-- 2022-1-5新增
+INSERT INTO public.sys_dict_type (dict_id, dict_name, dict_type, status, create_by, create_time, update_by, update_time)
+VALUES (23, '语音指令', 'zhdd_voice', '0', 'admin', '2021-09-28 15:55:09', 'admin', '2021-09-28 15:55:09');
+
+INSERT INTO public.sys_dict_data (dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, update_by, update_time, remark)
+VALUES (146, 0, '应急专家', '4', 'zhdd_resource', null, 'default', 'N', '0', 'admin', '2021-09-28 15:57:23', 'admin', '2021-09-28 15:57:23', null);
+INSERT INTO public.sys_dict_data (dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, update_by, update_time, remark)
+VALUES (147, 0, '地图放大', 'mapZoomIn', 'zhdd_voice', null, 'default', 'N', '0', 'admin', '2021-09-28 15:57:23', 'admin', '2021-09-28 15:57:23', null);
+INSERT INTO public.sys_dict_data (dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, update_by, update_time, remark)
+VALUES (148, 0, '地图缩写', 'mapZoomOut', 'zhdd_voice', null, 'default', 'N', '0', 'admin', '2021-09-28 15:57:23', 'admin', '2021-09-28 15:57:23', null);
+INSERT INTO public.sys_dict_data (dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, update_by, update_time, remark)
+VALUES (149, 0, '打开单兵设备图层', 'singleDeviceLayer', 'zhdd_voice', null, 'default', 'N', '0', 'admin', '2021-09-28 15:57:23', 'admin', '2021-09-28 15:57:23', null);
+INSERT INTO public.sys_dict_data (dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, update_by, update_time, remark)
+VALUES (150, 0, '打开视频设备图层', 'videoDeviceLayer', 'zhdd_voice', null, 'default', 'N', '0', 'admin', '2021-09-28 15:57:23', 'admin', '2021-09-28 15:57:23', null);
+INSERT INTO public.sys_dict_data (dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, update_by, update_time, remark)
+VALUES (151, 0, '打开应急事件图层', 'incidentLayer', 'zhdd_voice', null, 'default', 'N', '0', 'admin', '2021-09-28 15:57:23', 'admin', '2021-09-28 15:57:23', null);
+
+alter table b_incident_process
+    alter column status set default 0;
+
+-- 以上已同步