Merge branch 'dev/ez-security210625' into dev/ez-analyze210917

# Conflicts:
#	dblayer-mbg/src/main/java/com/lantone/dblayermbg/facade/HospitalSetFacade.java
#	gateway-service/src/main/resources/bootstrap.yml
#	pom.xml
#	security-center/src/main/java/com/lantone/security/facade/HospitalManagementFacade.java

bus-interceptor/pom.xml

@@ -0,0 +1,26 @@
+<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.lantone</groupId>
+        <artifactId>emrais</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>bus-interceptor</artifactId>
+    <name>bus-interceptor</name>
+    <packaging>jar</packaging>
+
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>com.lantone</groupId>
+            <artifactId>common</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>

bus-interceptor/src/main/java/com/lantone/interceptor/config/HttpInterceptorConfig.java

@@ -0,0 +1,36 @@
+package com.lantone.interceptor.config;
+
+import com.lantone.interceptor.interceptor.HttpInterceptor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.EnvironmentAware;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author songxl
+ * @Date 2021/9/26
+ */
+@PropertySource("classpath:application.properties")
+@Configuration
+public class HttpInterceptorConfig implements WebMvcConfigurer, EnvironmentAware {
+    @Autowired
+    private HttpInterceptor httpInterceptor;
+    private Environment env;
+
+    @Override
+    public void setEnvironment(Environment environment) {
+        this.env=environment;
+    }
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(httpInterceptor).addPathPatterns("/**")
+                .excludePathPatterns(env.getProperty("url",List.class));
+
+    }
+}

bus-interceptor/src/main/java/com/lantone/interceptor/interceptor/HttpInterceptor.java

@@ -0,0 +1,52 @@
+package com.lantone.interceptor.interceptor;
+
+import com.lantone.common.constant.AuthConstant;
+import com.lantone.common.service.RedisService;
+import com.lantone.common.util.StringUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.PrintWriter;
+
+/**
+ * @Description:
+ * @Author songxl
+ * @Date 2021/9/26
+ */
+@Component
+public class HttpInterceptor implements HandlerInterceptor {
+    @Autowired
+    private RedisService redisService;
+
+    @Override
+    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
+        String uuid = httpServletRequest.getHeader(AuthConstant.UUID);
+        String sessionId = httpServletRequest.getHeader(AuthConstant.SESSION_ID);
+        if (StringUtil.isNotBlank(uuid)) {
+            if (uuid.equals(redisService.get(AuthConstant.UUID+":"+sessionId))) {
+                return true;
+            }
+        }
+        httpServletResponse.setCharacterEncoding("UTF-8");
+        httpServletResponse.setHeader("content-type", "text/html;charset=UTF-8");
+        httpServletResponse.setStatus(403);
+        PrintWriter out = httpServletResponse.getWriter();
+        out.println("该请求无效被拦截");
+        return false;
+    }
+
+    @Override
+    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
+
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
+
+    }
+}
+

bus-interceptor/src/main/resources/application.properties

@@ -0,0 +1 @@
+url =/userManage/loadByUsername,/redisRefresh,/loginLogHandle

common/pom.xml

@@ -93,6 +93,16 @@
             <groupId>com.nimbusds</groupId>
             <artifactId>nimbus-jose-jwt</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt</artifactId>
+            <version>0.9.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.auth0</groupId>
+            <artifactId>java-jwt</artifactId>
+            <version>3.4.0</version>
+        </dependency>
         <dependency>
             <groupId>com.baomidou</groupId>
             <artifactId>mybatis-plus-extension</artifactId>

common/src/main/java/com/lantone/common/config/BaseRedisConfig.java

@@ -25,6 +25,10 @@ import java.time.Duration;
  * @time: 2021/1/5 18:27
  */
 public class BaseRedisConfig {
+    @Bean(name = "redisTemplateForToken")
+    public RedisTemplate<String, Object> redisTemplateForToken(RedisConnectionFactory redisConnectionFactory) {
+        return redisTemplate(redisConnectionFactory);
+    }
 
     @Bean
     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

common/src/main/java/com/lantone/common/config/BaseSwaggerConfig.java

@@ -33,12 +33,15 @@ public class BaseSwaggerConfig {
     private String swagger_des;
     @Value("${swagger.version}")
     private String swagger_version;
+    @Value("${swagger.show}")
+    private boolean swagger_show;
 
     @Bean
     @Order(value = 1)
     public Docket groupRestApi() {
         SwaggerProperties swaggerProperties = swaggerProperties();
         Docket docket = new Docket(DocumentationType.SWAGGER_2)
+                .enable(swagger_show)
                 .apiInfo(apiInfo(swaggerProperties))
                 .select()
                 .apis(RequestHandlerSelectors.basePackage(swaggerProperties.getApiBasePackage()))

common/src/main/java/com/lantone/common/constant/AuthConstant.java

@@ -69,4 +69,17 @@ public interface AuthConstant {
      * 数据权限过滤sql key
      */
     String DATAAUTH_FILTER_SQL = "dataAuthFilter";
+    /**
+     * 网关UUID
+     */
+    String UUID = "UUID";
+    String SESSION_ID = "SESSIONID";
+    /**
+     * Token
+     */
+    String ASSESS_TOKEN = "token";
+    /**
+     * Token
+     */
+    String REFRESH_TOKEN = "refreshToken";
 }

common/src/main/java/com/lantone/common/dto/AbnormalLogDTO.java

@@ -14,6 +14,10 @@ public class AbnormalLogDTO implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 主键
+     */
+    private Long id;
 
     /**
      * 操作人用户ID

common/src/main/java/com/lantone/common/dto/JwtStore.java

@@ -0,0 +1,17 @@
+package com.lantone.common.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2018/10/29 14:38
+ */
+@Getter
+@Setter
+public class JwtStore {
+    private String accessToken;
+    private String refreshToken;
+    private String ip;
+}

common/src/main/java/com/lantone/common/dto/LoginLogDTO.java

@@ -16,6 +16,11 @@ public class LoginLogDTO implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 主键
+     */
+    private Long id;
+
     /**
      * 登录用户ID
      */

common/src/main/java/com/lantone/common/dto/OperationLogDTO.java

@@ -14,6 +14,11 @@ public class OperationLogDTO implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 主键
+     */
+    private Long id;
+
     /**
      * 操作人用户ID
      */

common/src/main/java/com/lantone/common/dto/SendToTopicDTO.java

@@ -13,6 +13,8 @@ public class SendToTopicDTO implements Serializable {
     private static final long serialVersionUID = 1L;
     @ApiModelProperty(value = "信息")
     private String message;
+    @ApiModelProperty(value = "类型")
+    private String type;
     @ApiModelProperty(value = "topic")
     private String topic;
 }

common/src/main/java/com/lantone/common/service/SysTokenService.java

@@ -0,0 +1,56 @@
+package com.lantone.common.service;
+
+import com.lantone.common.dto.JwtStore;
+
+import java.util.List;
+
+/**
+ * @Description: Token验证类
+ * @author: gaodm
+ * @time: 2018/10/29 13:35
+ */
+public interface SysTokenService {
+
+    /**
+     * 创建token
+     *
+     * @param token 用户token
+     * @return
+     */
+    Boolean createToken(JwtStore token);
+
+    /**
+     * 验证token是否有效
+     *
+     * @param token 待验证的token
+     * @param type  1:accessToken,2:refreshToken
+     * @return
+     */
+    Boolean verifyToken(String token, Integer type);
+
+    /**
+     * 删除用户token
+     *
+     * @param userId 用户ID
+     * @return 删除是否成功
+     */
+    Boolean deleteToken(String userId);
+
+    /**
+     * 批量删除用户token
+     *
+     * @param userIds 用户列表
+     * @return 删除是否成功
+     */
+    Boolean deleteBatchToken(List<Long> userIds);
+
+    /**
+     * 获取用户jwt
+     *
+     * @param userId 用户ID
+     * @return jwt信息
+     */
+    JwtStore getToken(String userId);
+
+    String getUserIDByToken(String token);
+}

common/src/main/java/com/lantone/common/service/impl/SysTokenServiceImpl.java

@@ -0,0 +1,217 @@
+package com.lantone.common.service.impl;
+
+import com.auth0.jwt.JWT;
+import com.auth0.jwt.exceptions.JWTDecodeException;
+import com.auth0.jwt.interfaces.Claim;
+import com.auth0.jwt.interfaces.DecodedJWT;
+import com.lantone.common.dto.JwtStore;
+import com.lantone.common.exception.Asserts;
+import com.lantone.common.service.SysTokenService;
+import com.lantone.common.util.DateUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description: Token验证类 实现
+ * @author: gaodm
+ * @time: 2018/10/29 13:34
+ */
+@Service
+public class SysTokenServiceImpl implements SysTokenService {
+
+    @Autowired
+    @Qualifier("redisTemplateForToken")
+    RedisTemplate redisForToken;
+
+    private byte[] serializeKey(Object o) {
+        return redisForToken.getKeySerializer().serialize(o);
+    }
+
+    private byte[] serializeValue(Object o) {
+        return redisForToken.getValueSerializer().serialize(o);
+    }
+
+    private Object deserializeValue(byte[] b) {
+        return redisForToken.getValueSerializer().deserialize(b);
+    }
+
+    private byte[] getUserTokenKey(String userId) {
+        String userTokensFormat = "user_tokens_%s";
+        return serializeKey(String.format(userTokensFormat, userId));
+    }
+
+    /**
+     * 创建token
+     *
+     * @param token 用户token
+     * @return
+     */
+    @Override
+    public Boolean createToken(JwtStore token) {
+        DecodedJWT jwt = decodedJWT(token.getRefreshToken());
+        Map<String, Claim> claims = jwt.getClaims();
+        String userId = claims.get("id").asInt().toString();
+        Date expDate = claims.get("exp").asDate();
+        final byte[] redis_key = getUserTokenKey(userId);
+        redisForToken.execute(new RedisCallback<Object>() {
+            @Override
+            public Object doInRedis(RedisConnection connection) throws DataAccessException {
+                //获取旧的
+                byte[] bytes = connection.get(redis_key);
+                //删除旧的
+                if (bytes != null) {
+                    connection.del(bytes);
+                }
+                //设置新的
+                connection.setEx(
+                        redis_key,
+                        (expDate.getTime() - DateUtil.now().getTime()) / 1000,
+                        serializeValue(token)
+                );
+                return true;
+            }
+        });
+        return true;
+    }
+    private DecodedJWT decodedJWT(String token) {
+        try {
+            DecodedJWT jwt = JWT.decode(token);
+            return jwt;
+        } catch (JWTDecodeException var2) {
+            var2.printStackTrace();
+            Asserts.fail("token解析失败！");
+        }
+        return null;
+    }
+
+    /**
+     * 验证token是否有效
+     *
+     * @param token 待验证的token
+     * @param type  1:accessToken,2:refreshToken
+     * @return
+     */
+    @Override
+    public Boolean verifyToken(String token, Integer type) {
+        Boolean res = false;
+        if (null == token) {
+            return false;
+        }
+        DecodedJWT jwt = decodedJWT(token);
+        Map<String, Claim> claims = jwt.getClaims();
+        Claim claim = (Claim)claims.get("id");
+        String userId = claim.asInt().toString();
+        //从redis中取出
+        final byte[] redis_key = getUserTokenKey(userId);
+        JwtStore tokenStore = (JwtStore) redisForToken.execute(new RedisCallback<JwtStore>() {
+            @Override
+            public JwtStore doInRedis(RedisConnection connection) throws DataAccessException {
+                byte[] bytes = connection.get(redis_key);
+                if (bytes == null) {
+                    return null;
+                }
+                return (JwtStore) deserializeValue(bytes);
+            }
+        });
+
+        if (null != tokenStore) {
+            if (type == 1) {
+                if (null != tokenStore.getAccessToken() && tokenStore.getAccessToken().equals(token)) {
+                    res = true;
+                }
+            }
+
+            if (type == 2) {
+                if (null != tokenStore.getRefreshToken() && tokenStore.getRefreshToken().equals(token)) {
+                    res = true;
+                }
+            }
+        }
+
+        return res;
+    }
+
+    /**
+     * 删除用户token
+     *
+     * @param userId 用户ID
+     * @return 删除是否成功
+     */
+    @Override
+    public Boolean deleteToken(String userId) {
+        final byte[] redis_key = getUserTokenKey(userId);
+        Long l = (Long) redisForToken.execute(new RedisCallback<Long>() {
+            @Override
+            public Long doInRedis(RedisConnection connection) throws DataAccessException {
+                return connection.del(redis_key);
+            }
+        });
+        return l > 0;
+    }
+
+    /**
+     * 批量删除用户token
+     *
+     * @param userIds 用户列表
+     * @return 删除是否成功
+     */
+    @Override
+    public Boolean deleteBatchToken(List<Long> userIds) {
+        Long l = (Long) redisForToken.execute(new RedisCallback<Long>() {
+            @Override
+            public Long doInRedis(RedisConnection connection) throws DataAccessException {
+                connection.openPipeline();
+                Long cnt = 0L;
+                for (Long userId : userIds) {
+                    byte[] redis_key = getUserTokenKey(userId.toString());
+                    connection.del(redis_key);
+                    cnt++;
+                }
+                connection.closePipeline();
+                return cnt;
+            }
+        });
+        return l > 0;
+    }
+
+    /**
+     * 获取用户jwt
+     *
+     * @param userId 用户ID
+     * @return jwt信息
+     */
+    @Override
+    public JwtStore getToken(String userId) {
+        JwtStore tokenStore = null;
+        //从redis中取出
+        final byte[] redis_key = getUserTokenKey(userId);
+        tokenStore = (JwtStore) redisForToken.execute(new RedisCallback<JwtStore>() {
+            @Override
+            public JwtStore doInRedis(RedisConnection connection) throws DataAccessException {
+                byte[] bytes = connection.get(redis_key);
+                if (bytes == null) {
+                    return null;
+                }
+                return (JwtStore) deserializeValue(bytes);
+            }
+        });
+        return tokenStore;
+    }
+
+    @Override
+    public String getUserIDByToken(String token) {
+        DecodedJWT jwt = decodedJWT(token);
+        Map<String, Claim> claims = jwt.getClaims();
+        return claims.get("id").asInt().toString();
+    }
+}

config-center/src/main/resources/shared/gateway-service-debug.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: true

config-center/src/main/resources/shared/gateway-service-inner.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: false

config-center/src/main/resources/shared/gateway-service-local.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: true

config-center/src/main/resources/shared/gateway-service-outer.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: false

config-center/src/main/resources/shared/gateway-service-test.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: true

config-center/src/main/resources/shared/message-service-debug.yml

@@ -0,0 +1,54 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+  rabbitmq:
+    host: 192.168.2.237
+    port: 5672
+    username: emrais
+    password: emrais
+    virtual-host: /emrais # 虚拟host
+    publisher-confirm-type: correlated # 确认消息已发送到交换机(Exchange)  发送确认
+    publisher-returns: true # 确认消息已发送到队列(Queue)  发送回调
+    connection-timeout: 4000
+    template:
+      mandatory: true # 当exchange无法找到任何一个合适的queue时，将消息return给生产者
+      receive-timeout: 30000 # 消费端接收的响应时间
+      reply-timeout: 30000 # 发送端等待接收消费端给出return msg的时间，相当于在message同步时，发送并消费成功的时间
+      retry:
+        enabled: true
+        max-attempts: 6 # 最大重试次数
+        initial-interval: 2000 # 重试初始间隔时间
+        multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间
+        max-interval: 64000 # 最大重试时间间隔
+    listener:
+      simple:
+        acknowledge-mode: auto # 自动确认
+        auto-startup: true # 是否启动时自动启动容器
+        concurrency: 1 # 最小的消费者数量
+        max-concurrency: 5 # 最大的消费者数量
+        default-requeue-rejected: true # 投递失败时是否重新排队；默认是true（与参数acknowledge-mode有关系）
+        retry:
+          enabled: true
+          max-attempts: 6
+          initial-interval: 2000
+          multiplier: 2
+          max-interval: 64000
+          stateless: true # 不论重试是有状态的还是无状态的
+
+rabbitmq:
+  mqtt:
+    url: tcp://192.168.2.237:1883
+    front-url: ws://192.168.2.237:15675/ws
+    defaultTopic: defaultSampleTopic
+
+swagger.show: true

config-center/src/main/resources/shared/message-service-inner.yml

@@ -0,0 +1,54 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+  rabbitmq:
+    host: 192.168.2.237
+    port: 5672
+    username: emrais
+    password: emrais
+    virtual-host: /emrais # 虚拟host
+    publisher-confirm-type: correlated # 确认消息已发送到交换机(Exchange)  发送确认
+    publisher-returns: true # 确认消息已发送到队列(Queue)  发送回调
+    connection-timeout: 4000
+    template:
+      mandatory: true # 当exchange无法找到任何一个合适的queue时，将消息return给生产者
+      receive-timeout: 30000 # 消费端接收的响应时间
+      reply-timeout: 30000 # 发送端等待接收消费端给出return msg的时间，相当于在message同步时，发送并消费成功的时间
+      retry:
+        enabled: true
+        max-attempts: 6 # 最大重试次数
+        initial-interval: 2000 # 重试初始间隔时间
+        multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间
+        max-interval: 64000 # 最大重试时间间隔
+    listener:
+      simple:
+        acknowledge-mode: auto # 自动确认
+        auto-startup: true # 是否启动时自动启动容器
+        concurrency: 1 # 最小的消费者数量
+        max-concurrency: 5 # 最大的消费者数量
+        default-requeue-rejected: true # 投递失败时是否重新排队；默认是true（与参数acknowledge-mode有关系）
+        retry:
+          enabled: true
+          max-attempts: 6
+          initial-interval: 2000
+          multiplier: 2
+          max-interval: 64000
+          stateless: true # 不论重试是有状态的还是无状态的
+
+rabbitmq:
+  mqtt:
+    url: tcp://192.168.2.237:1883
+    front-url: ws://192.168.2.237:15675/ws
+    defaultTopic: defaultSampleTopic
+
+swagger.show: false

config-center/src/main/resources/shared/message-service-local.yml

@@ -0,0 +1,54 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+  rabbitmq:
+    host: 192.168.2.237
+    port: 5672
+    username: emrais
+    password: emrais
+    virtual-host: /emrais # 虚拟host
+    publisher-confirm-type: correlated # 确认消息已发送到交换机(Exchange)  发送确认
+    publisher-returns: true # 确认消息已发送到队列(Queue)  发送回调
+    connection-timeout: 4000
+    template:
+      mandatory: true # 当exchange无法找到任何一个合适的queue时，将消息return给生产者
+      receive-timeout: 30000 # 消费端接收的响应时间
+      reply-timeout: 30000 # 发送端等待接收消费端给出return msg的时间，相当于在message同步时，发送并消费成功的时间
+      retry:
+        enabled: true
+        max-attempts: 6 # 最大重试次数
+        initial-interval: 2000 # 重试初始间隔时间
+        multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间
+        max-interval: 64000 # 最大重试时间间隔
+    listener:
+      simple:
+        acknowledge-mode: auto # 自动确认
+        auto-startup: true # 是否启动时自动启动容器
+        concurrency: 1 # 最小的消费者数量
+        max-concurrency: 5 # 最大的消费者数量
+        default-requeue-rejected: true # 投递失败时是否重新排队；默认是true（与参数acknowledge-mode有关系）
+        retry:
+          enabled: true
+          max-attempts: 6
+          initial-interval: 2000
+          multiplier: 2
+          max-interval: 64000
+          stateless: true # 不论重试是有状态的还是无状态的
+
+rabbitmq:
+  mqtt:
+    url: tcp://192.168.2.237:1883
+    front-url: ws://192.168.2.237:15675/ws
+    defaultTopic: defaultSampleTopic
+
+swagger.show: true

config-center/src/main/resources/shared/message-service-outer.yml

@@ -0,0 +1,54 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+  rabbitmq:
+    host: 192.168.2.237
+    port: 5672
+    username: emrais
+    password: emrais
+    virtual-host: /emrais # 虚拟host
+    publisher-confirm-type: correlated # 确认消息已发送到交换机(Exchange)  发送确认
+    publisher-returns: true # 确认消息已发送到队列(Queue)  发送回调
+    connection-timeout: 4000
+    template:
+      mandatory: true # 当exchange无法找到任何一个合适的queue时，将消息return给生产者
+      receive-timeout: 30000 # 消费端接收的响应时间
+      reply-timeout: 30000 # 发送端等待接收消费端给出return msg的时间，相当于在message同步时，发送并消费成功的时间
+      retry:
+        enabled: true
+        max-attempts: 6 # 最大重试次数
+        initial-interval: 2000 # 重试初始间隔时间
+        multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间
+        max-interval: 64000 # 最大重试时间间隔
+    listener:
+      simple:
+        acknowledge-mode: auto # 自动确认
+        auto-startup: true # 是否启动时自动启动容器
+        concurrency: 1 # 最小的消费者数量
+        max-concurrency: 5 # 最大的消费者数量
+        default-requeue-rejected: true # 投递失败时是否重新排队；默认是true（与参数acknowledge-mode有关系）
+        retry:
+          enabled: true
+          max-attempts: 6
+          initial-interval: 2000
+          multiplier: 2
+          max-interval: 64000
+          stateless: true # 不论重试是有状态的还是无状态的
+
+rabbitmq:
+  mqtt:
+    url: tcp://192.168.2.237:1883
+    front-url: ws://192.168.2.237:15675/ws
+    defaultTopic: defaultSampleTopic
+
+swagger.show: false

config-center/src/main/resources/shared/message-service-test.yml

@@ -0,0 +1,54 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+  rabbitmq:
+    host: 192.168.2.237
+    port: 5672
+    username: emrais
+    password: emrais
+    virtual-host: /emrais # 虚拟host
+    publisher-confirm-type: correlated # 确认消息已发送到交换机(Exchange)  发送确认
+    publisher-returns: true # 确认消息已发送到队列(Queue)  发送回调
+    connection-timeout: 4000
+    template:
+      mandatory: true # 当exchange无法找到任何一个合适的queue时，将消息return给生产者
+      receive-timeout: 30000 # 消费端接收的响应时间
+      reply-timeout: 30000 # 发送端等待接收消费端给出return msg的时间，相当于在message同步时，发送并消费成功的时间
+      retry:
+        enabled: true
+        max-attempts: 6 # 最大重试次数
+        initial-interval: 2000 # 重试初始间隔时间
+        multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间
+        max-interval: 64000 # 最大重试时间间隔
+    listener:
+      simple:
+        acknowledge-mode: auto # 自动确认
+        auto-startup: true # 是否启动时自动启动容器
+        concurrency: 1 # 最小的消费者数量
+        max-concurrency: 5 # 最大的消费者数量
+        default-requeue-rejected: true # 投递失败时是否重新排队；默认是true（与参数acknowledge-mode有关系）
+        retry:
+          enabled: true
+          max-attempts: 6
+          initial-interval: 2000
+          multiplier: 2
+          max-interval: 64000
+          stateless: true # 不论重试是有状态的还是无状态的
+
+rabbitmq:
+  mqtt:
+    url: tcp://192.168.2.237:1883
+    front-url: ws://192.168.2.237:15675/ws
+    defaultTopic: defaultSampleTopic
+
+swagger.show: true

config-center/src/main/resources/shared/security-center-debug.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: true

config-center/src/main/resources/shared/security-center-inner.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: false

config-center/src/main/resources/shared/security-center-local.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: true

config-center/src/main/resources/shared/security-center-outer.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: false

config-center/src/main/resources/shared/security-center-test.yml

@@ -0,0 +1,15 @@
+spring:
+  redis:
+    database: 12
+    host: 192.168.2.237 # Redis服务器地址
+    port: 63791 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: emrais # Redis服务器连接密码（默认为空）
+    jedis:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
+swagger.show: true

dblayer-mbg/src/main/java/com/lantone/dblayermbg/facade/AbnormalLogFacade.java

@@ -1,15 +1,7 @@
 package com.lantone.dblayermbg.facade;
-
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.lantone.common.dto.AbnormalLogDTO;
-import com.lantone.common.vo.GetAbnormalLogVO;
-import com.lantone.common.vo.GetAbnormalWayAndIpVO;
-import com.lantone.dblayermbg.mapper.AbnormalLogMapper;
 import com.lantone.dblayermbg.service.impl.AbnormalLogServiceImpl;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
 
-import java.util.List;
+import org.springframework.stereotype.Component;
 
 /**
  * <p>
@@ -18,39 +10,5 @@ import java.util.List;
  */
 @Component
 public class AbnormalLogFacade extends AbnormalLogServiceImpl {
-    @Autowired
-    private AbnormalLogMapper abnormalLogMapper;
-
-    /**
-     * @Description: 新增异常日志
-     * @Param: [abnormalLogDTO]
-     * @return: void
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public void addOperErrorLog(AbnormalLogDTO abnormalLogDTO) {
-        abnormalLogMapper.addOperErrorLog(abnormalLogDTO);
-    }
-
-    /**
-     * @Description:  查看异常日志
-     * @Param: [getAbnormalLogVO]
-     * @return: com.baomidou.mybatisplus.core.metadata.IPage<com.lantone.common.dto.AbnormalLogDTO>
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public IPage<AbnormalLogDTO> getAbnormalLog(GetAbnormalLogVO getAbnormalLogVO) {
-        return  abnormalLogMapper.getAbnormalLog(getAbnormalLogVO);
-    }
 
-    /**
-     * @Description:  查看异常日志请求方式|ip地址
-     * @Param: [getAbnormalWayAndIpVO]
-     * @return: java.util.List<java.lang.String>
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public List<String> getAbnormalLogWayAndIp(GetAbnormalWayAndIpVO getAbnormalWayAndIpVO) {
-        return  abnormalLogMapper.getAbnormalLogWayAndIp(getAbnormalWayAndIpVO);
-    }
 }

dblayer-mbg/src/main/java/com/lantone/dblayermbg/facade/HospitalSetFacade.java

@@ -7,7 +7,7 @@ import com.lantone.common.service.RedisService;
 import com.lantone.common.util.StringUtil;
 import com.lantone.dblayermbg.entity.HospitalSet;
 import com.lantone.dblayermbg.service.impl.HospitalSetServiceImpl;
-import org.apache.commons.collections.MapUtils;
+import org.apache.commons.collections4.MapUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -48,7 +48,6 @@ public class HospitalSetFacade extends HospitalSetServiceImpl {
         redisService.set(AuthConstant.HOSPITAL_SET_MAP_KEY, hospitalSetMap);
         return hospitalSetMap;
     }
-
     /**
      * @param hospitalId 医院id
      * @param code  分组集合
@@ -63,5 +62,4 @@ public class HospitalSetFacade extends HospitalSetServiceImpl {
         }
         return null;
     }
-
 }

dblayer-mbg/src/main/java/com/lantone/dblayermbg/facade/LoginLogFacade.java

@@ -1,14 +1,7 @@
 package com.lantone.dblayermbg.facade;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.lantone.common.dto.LoginLogDTO;
-import com.lantone.common.vo.GetLoginLogVO;
-import com.lantone.common.vo.GetLoginNameAndIpVO;
-import com.lantone.dblayermbg.mapper.LoginLogMapper;
 import com.lantone.dblayermbg.service.impl.LoginLogServiceImpl;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.List;
 
 
 /**
@@ -18,39 +11,5 @@ import java.util.List;
  */
 @Component
 public class LoginLogFacade extends LoginLogServiceImpl {
-    @Autowired
-    private LoginLogMapper loginLogMapper;
 
-    /**
-     * @Description: 新增登录日志
-     * @Param: [loginLogDTO]
-     * @return: void
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public void addLoginLog(LoginLogDTO loginLogDTO) {
-        loginLogMapper.addLoginLog(loginLogDTO);
-    }
-
-    /**
-     * @Description: 查看登录日志
-     * @Param: [getLoginLogVO]
-     * @return: com.baomidou.mybatisplus.core.metadata.IPage<com.lantone.common.dto.LoginLogDTO>
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public IPage<LoginLogDTO> getLoginLog(GetLoginLogVO getLoginLogVO) {
-        return loginLogMapper.getLoginLog(getLoginLogVO);
-    }
-
-    /**查看登录日志登录用户|登录ip地址
-     * @Description:
-     * @Param: [getLoginNameAndIpVO]
-     * @return: java.util.List<java.lang.String>
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public List<String> getLoginLogNameAndIp(GetLoginNameAndIpVO getLoginNameAndIpVO) {
-        return loginLogMapper.getLoginLogNameAndIp(getLoginNameAndIpVO);
-    }
 }

dblayer-mbg/src/main/java/com/lantone/dblayermbg/facade/OperationLogFacade.java

@@ -1,18 +1,7 @@
 package com.lantone.dblayermbg.facade;
-
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.lantone.common.dto.OperationLogDTO;
-import com.lantone.common.vo.GetOperationLogVO;
-import com.lantone.dblayermbg.entity.OperationLog;
-import com.lantone.dblayermbg.mapper.OperationLogMapper;
 import com.lantone.dblayermbg.service.impl.OperationLogServiceImpl;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.List;
-import java.util.stream.Collectors;
-
 /**
  * <p>
  * 表名：sys_operation_log 业务类
@@ -20,42 +9,5 @@ import java.util.stream.Collectors;
  */
 @Component
 public class OperationLogFacade extends OperationLogServiceImpl {
-    @Autowired
-    private OperationLogMapper operationLogMapper;
-
-    /**
-     * @Description: 新增操作日志
-     * @Param: [operationLog]
-     * @return: void
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public void addOperLog(OperationLogDTO operationLog) {
-        operationLogMapper.addOperLog(operationLog);
-    }
-
-    /**
-     * @Description:  查看操作日志
-     * @Param: [getOperationLogVO]
-     * @return: com.baomidou.mybatisplus.core.metadata.IPage<com.lantone.common.dto.OperationLogDTO>
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public IPage<OperationLogDTO> getOperationLog(GetOperationLogVO getOperationLogVO) {
-        return operationLogMapper.getOperationLog(getOperationLogVO);
-    }
 
-    /**
-     * @Description:  查看操作日志操作用户
-     * @Param: [operationName]
-     * @return: java.util.List<java.lang.String>
-     * @Author: cy
-     * @Date: 2021/9/8
-     */
-    public List<String> getOperationLogName(String operationName) {
-        return this.lambdaQuery()
-                .like(StringUtils.isNotBlank(operationName), OperationLog::getOperationName, operationName)
-                .select(OperationLog::getOperationName)
-                .list().stream().map(OperationLog::getOperationName).collect(Collectors.toList());
-    }
 }

dblayer-mbg/src/main/java/com/lantone/dblayermbg/facade/RegionFacade.java

@@ -1,8 +1,5 @@
 package com.lantone.dblayermbg.facade;
 
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.lantone.common.dto.ViewRegionDTO;
-import com.lantone.common.vo.GetRegionVO;
 import com.lantone.dblayermbg.service.impl.RegionServiceImpl;
 import org.springframework.stereotype.Component;
 
@@ -14,8 +11,4 @@ import org.springframework.stereotype.Component;
 @Component
 public class RegionFacade extends RegionServiceImpl {
 
-    public IPage<ViewRegionDTO> getWard(GetRegionVO getRegionVO) {
-        return this.baseMapper.getWard(getRegionVO);
-    }
-
 }

dblayer-mbg/src/main/resources/application-debug.yml

@@ -0,0 +1,46 @@
+spring:
+  datasource:
+    druid:
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      platform: mysql
+      url: jdbc:mysql://192.168.2.236:3306/emrais?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&allowMultiQueries=true
+      username: root
+      password: lantone
+      # 连接池的配置信息
+      # 初始化大小，最小，最大
+      initialSize: 5
+      minIdle: 5
+      maxActive: 20
+      # 配置获取连接等待超时的时间
+      maxWait: 60000
+      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+      timeBetweenEvictionRunsMillis: 60000
+      # 配置一个连接在池中最小生存的时间，单位是毫秒
+      minEvictableIdleTimeMillis: 300000
+      validationQuery: SELECT 1 FROM DUAL
+      testWhileIdle: true
+      testOnBorrow: false
+      testOnReturn: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      poolPreparedStatements: true
+      maxPoolPreparedStatementPerConnectionSize: 20
+      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+      filters.commons-log.connection-logger-name: wall,log4j
+      filter:
+        stat:
+          enabled: true
+          mergeSql: true
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      #监控配置
+      web-stat-filter:
+        enabled: true
+        url-pattern: /*
+        exclusions: '*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*'
+      # StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
+      stat-view-servlet:
+        enabled: true
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: root
+        login-password: root

dblayer-mbg/src/main/resources/application-inner.yml

@@ -0,0 +1,46 @@
+spring:
+  datasource:
+    druid:
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      platform: mysql
+      url: jdbc:mysql://192.168.2.236:3306/emrais?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&allowMultiQueries=true
+      username: root
+      password: lantone
+      # 连接池的配置信息
+      # 初始化大小，最小，最大
+      initialSize: 5
+      minIdle: 5
+      maxActive: 20
+      # 配置获取连接等待超时的时间
+      maxWait: 60000
+      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+      timeBetweenEvictionRunsMillis: 60000
+      # 配置一个连接在池中最小生存的时间，单位是毫秒
+      minEvictableIdleTimeMillis: 300000
+      validationQuery: SELECT 1 FROM DUAL
+      testWhileIdle: true
+      testOnBorrow: false
+      testOnReturn: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      poolPreparedStatements: true
+      maxPoolPreparedStatementPerConnectionSize: 20
+      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+      filters.commons-log.connection-logger-name: wall,log4j
+      filter:
+        stat:
+          enabled: true
+          mergeSql: true
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      #监控配置
+      web-stat-filter:
+        enabled: true
+        url-pattern: /*
+        exclusions: '*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*'
+      # StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
+      stat-view-servlet:
+        enabled: true
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: root
+        login-password: root

dblayer-mbg/src/main/resources/application-local.yml

@@ -0,0 +1,46 @@
+spring:
+  datasource:
+    druid:
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      platform: mysql
+      url: jdbc:mysql://192.168.2.237:3306/emrais?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&allowMultiQueries=true
+      username: root
+      password: lantone
+      # 连接池的配置信息
+      # 初始化大小，最小，最大
+      initialSize: 5
+      minIdle: 5
+      maxActive: 20
+      # 配置获取连接等待超时的时间
+      maxWait: 60000
+      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+      timeBetweenEvictionRunsMillis: 60000
+      # 配置一个连接在池中最小生存的时间，单位是毫秒
+      minEvictableIdleTimeMillis: 300000
+      validationQuery: SELECT 1 FROM DUAL
+      testWhileIdle: true
+      testOnBorrow: false
+      testOnReturn: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      poolPreparedStatements: true
+      maxPoolPreparedStatementPerConnectionSize: 20
+      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+      filters.commons-log.connection-logger-name: wall,log4j
+      filter:
+        stat:
+          enabled: true
+          mergeSql: true
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      #监控配置
+      web-stat-filter:
+        enabled: true
+        url-pattern: /*
+        exclusions: '*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*'
+      # StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
+      stat-view-servlet:
+        enabled: true
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: root
+        login-password: root

dblayer-mbg/src/main/resources/application-outer.yml

@@ -0,0 +1,46 @@
+spring:
+  datasource:
+    druid:
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      platform: mysql
+      url: jdbc:mysql://192.168.2.236:3306/emrais?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&allowMultiQueries=true
+      username: root
+      password: lantone
+      # 连接池的配置信息
+      # 初始化大小，最小，最大
+      initialSize: 5
+      minIdle: 5
+      maxActive: 20
+      # 配置获取连接等待超时的时间
+      maxWait: 60000
+      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+      timeBetweenEvictionRunsMillis: 60000
+      # 配置一个连接在池中最小生存的时间，单位是毫秒
+      minEvictableIdleTimeMillis: 300000
+      validationQuery: SELECT 1 FROM DUAL
+      testWhileIdle: true
+      testOnBorrow: false
+      testOnReturn: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      poolPreparedStatements: true
+      maxPoolPreparedStatementPerConnectionSize: 20
+      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+      filters.commons-log.connection-logger-name: wall,log4j
+      filter:
+        stat:
+          enabled: true
+          mergeSql: true
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      #监控配置
+      web-stat-filter:
+        enabled: true
+        url-pattern: /*
+        exclusions: '*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*'
+      # StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
+      stat-view-servlet:
+        enabled: true
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: root
+        login-password: root

dblayer-mbg/src/main/resources/application-test.yml

@@ -0,0 +1,46 @@
+spring:
+  datasource:
+    druid:
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      platform: mysql
+      url: jdbc:mysql://192.168.2.236:3306/emrais?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&allowMultiQueries=true
+      username: root
+      password: lantone
+      # 连接池的配置信息
+      # 初始化大小，最小，最大
+      initialSize: 5
+      minIdle: 5
+      maxActive: 20
+      # 配置获取连接等待超时的时间
+      maxWait: 60000
+      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+      timeBetweenEvictionRunsMillis: 60000
+      # 配置一个连接在池中最小生存的时间，单位是毫秒
+      minEvictableIdleTimeMillis: 300000
+      validationQuery: SELECT 1 FROM DUAL
+      testWhileIdle: true
+      testOnBorrow: false
+      testOnReturn: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      poolPreparedStatements: true
+      maxPoolPreparedStatementPerConnectionSize: 20
+      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
+      filters.commons-log.connection-logger-name: wall,log4j
+      filter:
+        stat:
+          enabled: true
+          mergeSql: true
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      #监控配置
+      web-stat-filter:
+        enabled: true
+        url-pattern: /*
+        exclusions: '*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*'
+      # StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
+      stat-view-servlet:
+        enabled: true
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: root
+        login-password: root

dblayer-mbg/src/main/resources/application.yml

@@ -1,50 +1,4 @@
 spring:
-  datasource:
-    druid:
-      driver-class-name: com.mysql.cj.jdbc.Driver
-      platform: mysql
-      url: jdbc:mysql://192.168.2.236:3306/emrais?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&allowMultiQueries=true
-      username: root
-      password: lantone
-      # 连接池的配置信息
-      # 初始化大小，最小，最大
-      initialSize: 5
-      minIdle: 5
-      maxActive: 20
-      # 配置获取连接等待超时的时间
-      maxWait: 60000
-      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
-      timeBetweenEvictionRunsMillis: 60000
-      # 配置一个连接在池中最小生存的时间，单位是毫秒
-      minEvictableIdleTimeMillis: 300000
-      validationQuery: SELECT 1 FROM DUAL
-      testWhileIdle: true
-      testOnBorrow: false
-      testOnReturn: false
-      # 打开PSCache，并且指定每个连接上PSCache的大小
-      poolPreparedStatements: true
-      maxPoolPreparedStatementPerConnectionSize: 20
-      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
-      filters.commons-log.connection-logger-name: wall,log4j
-      filter:
-        stat:
-          enabled: true
-          mergeSql: true
-          log-slow-sql: true
-          slow-sql-millis: 2000
-      #监控配置
-      web-stat-filter:
-        enabled: true
-        url-pattern: /*
-        exclusions: '*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*'
-      # StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
-      stat-view-servlet:
-        enabled: true
-        url-pattern: /druid/*
-        reset-enable: false
-        login-username: root
-        login-password: root
-
   jackson:
     date-format: yyyy-MM-dd HH:mm:ss
     time-zone: GMT+8

dblayer-mbg/src/main/resources/mapper/AbnormalLogMapper.xml

@@ -8,6 +8,7 @@
 
     <select id="getAbnormalLog" resultType="com.lantone.common.dto.AbnormalLogDTO">
         SELECT
+        id,
         a.operation_id AS operationId,
         a.operation_name AS operationName,
         a.gmt_create AS gmtCreate,

dblayer-mbg/src/main/resources/mapper/LoginLogMapper.xml

@@ -7,7 +7,8 @@
     </insert>
 
     <select id="getLoginLog" resultType="com.lantone.common.dto.LoginLogDTO">
-        select a.login_id as loginId,
+        select id,
+        a.login_id as loginId,
         a.login_name as loginName,
         a.login_date as loginDate,
         INET_NTOA(a.login_ip) as loginIp,

dblayer-mbg/src/main/resources/mapper/OperationLogMapper.xml

@@ -8,6 +8,7 @@
 
     <select id="getOperationLog" resultType="com.lantone.common.dto.OperationLogDTO">
         SELECT
+        id,
         a.operation_id AS operationId,
         a.operation_name AS operationName,
         a.operation_date AS operationDate,

gateway-service/pom.xml

@@ -36,6 +36,10 @@
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-config</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.github.xiaoymin</groupId>
             <artifactId>knife4j-spring-boot-starter</artifactId>

gateway-service/src/main/java/com/lantone/authorization/AuthorizationManager.java

@@ -5,6 +5,7 @@ import cn.hutool.core.util.StrUtil;
 import com.lantone.common.constant.AuthConstant;
 import com.lantone.common.domain.UserDto;
 import com.lantone.common.service.RedisService;
+import com.lantone.common.service.SysTokenService;
 import com.lantone.common.util.SysUserUtils;
 import com.lantone.config.IgnoreUrlsConfig;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -35,6 +36,8 @@ import java.util.stream.Collectors;
 @Component
 public class AuthorizationManager implements ReactiveAuthorizationManager<AuthorizationContext> {
 
+    @Autowired
+    private SysTokenService sysTokenService;
     @Autowired
     private RedisService redisService;
     @Autowired
@@ -61,6 +64,9 @@ public class AuthorizationManager implements ReactiveAuthorizationManager<Author
         if (StrUtil.isEmpty(token)) {
             return Mono.just(new AuthorizationDecision(false));
         }
+        if(!sysTokenService.verifyToken(token.replaceFirst("Bearer ", ""),1)){
+            return Mono.just(new AuthorizationDecision(false));
+        }
         UserDto userDto = SysUserUtils.getUserByToken(token);
         if (userDto == null || (AuthConstant.SECURITY_CENTER_CLIENT_ID.equals(userDto.getClientId())
                 && !pathMatcher.match(AuthConstant.SECURITY_CENTER_URL_PATTERN, uri.getPath()))) {

gateway-service/src/main/java/com/lantone/config/ResourceServerConfig.java

@@ -5,6 +5,7 @@ import com.lantone.authorization.AuthorizationManager;
 import com.lantone.common.constant.AuthConstant;
 import com.lantone.component.RestAuthenticationEntryPoint;
 import com.lantone.component.RestfulAccessDeniedHandler;
+import com.lantone.filter.GateWayFilter;
 import com.lantone.filter.IgnoreUrlsRemoveJwtFilter;
 import lombok.AllArgsConstructor;
 import org.springframework.context.annotation.Bean;
@@ -33,6 +34,7 @@ public class ResourceServerConfig {
 
     private final AuthorizationManager authorizationManager;
     private final IgnoreUrlsConfig ignoreUrlsConfig;
+    private final GateWayFilter gateWayFilter;
     private final RestfulAccessDeniedHandler restfulAccessDeniedHandler;
     private final RestAuthenticationEntryPoint restAuthenticationEntryPoint;
     private final IgnoreUrlsRemoveJwtFilter ignoreUrlsRemoveJwtFilter;
@@ -45,6 +47,8 @@ public class ResourceServerConfig {
         http.oauth2ResourceServer().authenticationEntryPoint(restAuthenticationEntryPoint);
         //对白名单路径，直接移除JWT请求头
         http.addFilterBefore(ignoreUrlsRemoveJwtFilter, SecurityWebFiltersOrder.AUTHENTICATION);
+        //请求头添加uuid防止直接访问服务
+        http.addFilterBefore(gateWayFilter,SecurityWebFiltersOrder.LAST);
         http.authorizeExchange()
                 .pathMatchers(ArrayUtil.toArray(ignoreUrlsConfig.getUrls(), String.class)).permitAll()//白名单配置
                 .anyExchange().access(authorizationManager)//鉴权管理器配置

gateway-service/src/main/java/com/lantone/filter/GateWayFilter.java

@@ -0,0 +1,36 @@
+package com.lantone.filter;
+
+
+import com.lantone.common.constant.AuthConstant;
+import com.lantone.common.service.RedisService;
+import com.lantone.common.util.UUidUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.stereotype.Component;
+import org.springframework.web.server.ServerWebExchange;
+import org.springframework.web.server.WebFilter;
+import org.springframework.web.server.WebFilterChain;
+import org.springframework.web.server.WebSession;
+import reactor.core.publisher.Mono;
+
+/**
+ * @Description:
+ * @Author songxl
+ * @Date 2021/9/26
+ */
+@Component
+public class GateWayFilter implements WebFilter {
+    @Autowired
+    private RedisService redisService;
+    @Override
+    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
+        //请求头添加uuid
+        String uuid = UUidUtil.getUUid();
+        String sessionId = exchange.getSession().block().getId();
+        ServerHttpRequest request = exchange.getRequest().mutate().header(AuthConstant.UUID,uuid)
+                .header(AuthConstant.SESSION_ID,sessionId).build();
+        exchange = exchange.mutate().request(request).build();
+        redisService.set(AuthConstant.UUID+":"+sessionId,uuid,5);
+        return chain.filter(exchange);
+    }
+}

gateway-service/src/main/resources/bootstrap.yml

@@ -39,24 +39,12 @@ spring:
             - Path=/message-service/**
           filters:
             - StripPrefix=1
-        - id: report-service
-          uri: lb://report-service
-          predicates:
-            - Path=/report-service/**
-          filters:
-            - StripPrefix=1
-  redis:
-    database: 12
-    host: 192.168.2.236 # Redis服务器地址
-    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
-    password: lantone # Redis服务器连接密码（默认为空）
-    jedis:
-      pool:
-        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
-        max-idle: 5 # 连接池中的最大空闲连接
-        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
-        min-idle: 0 # 连接池中的最小空闲连接
-    timeout: 20000 # 连接超时时间（毫秒）
+    config:
+      discovery:
+        enabled: true
+        service-id: config-center
+  profiles:
+    active: local
 
 eureka:
   client:
@@ -78,7 +66,7 @@ management:
 
 secure:
   ignore:
-    urls: #配置白名单路径
+    urls: # 配置白名单路径
       - "/doc.html"
       - "/swagger-resources/**"
       - "/swagger/**"
@@ -92,6 +80,7 @@ secure:
       - "/user-auth/oauth/token"
       - "/user-auth/rsa/publicKey"
       - "/security-center/userManage/login"
+      - "/security-center/userManage/close"
       - "/message-service/pageSample/sample"
       - "/message-service/backSample/sendToDefaultTopic"
       - "/message-service/backSample/sendToTopic"

message-service/pom.xml

@@ -22,6 +22,10 @@
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-config</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-amqp</artifactId>

message-service/src/main/java/com/lantone/message/component/MessageReceiver.java

@@ -60,20 +60,20 @@ public class MessageReceiver {
     @RabbitListener(queues = "emrais.login.success.record.queue", ackMode = "MANUAL")
     public void sendLogSuccessMessageHandle(LoginLogDTO loginLog, Message message, Channel channel) throws Exception {
         loginLog.setLoginAddress(AddressUtils.getRealAddressByIP(loginLog.getLoginIp()));
-        loginLogFacade.addLoginLog(loginLog);
+        loginLogFacade.getBaseMapper().addLoginLog(loginLog);
         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
     }
 
     @RabbitListener(queues = "emrais.oper.log.record.queue", ackMode = "MANUAL")
     public void sendOperLogRecordMessage(OperationLogDTO operationLog, Message message, Channel channel) throws Exception {
         operationLog.setOperationAddress(AddressUtils.getRealAddressByIP(operationLog.getOperationIp()));
-        operationLogFacade.addOperLog(operationLog);
+        operationLogFacade.getBaseMapper().addOperLog(operationLog);
         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
     }
 
     @RabbitListener(queues = "emrais.oper.error.record.queue", ackMode = "MANUAL")
     public void sendOperErrorRecordMessage(AbnormalLogDTO abnormalLogDTO, Message message, Channel channel) throws Exception {
-        abnormalLogFacade.addOperErrorLog(abnormalLogDTO);
+        abnormalLogFacade.getBaseMapper().addOperErrorLog(abnormalLogDTO);
         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
     }
 

message-service/src/main/resources/bootstrap.yml

@@ -1,55 +1,18 @@
 server:
   port: 8879
+
 spring:
   application:
     name: message-service
   thymeleaf:
     cache: false
-  redis:
-    database: 12
-    host: 192.168.2.236 # Redis服务器地址
-    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
-    password: lantone # Redis服务器连接密码（默认为空）
-    jedis:
-      pool:
-        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
-        max-idle: 5 # 连接池中的最大空闲连接
-        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
-        min-idle: 0 # 连接池中的最小空闲连接
-    timeout: 20000 # 连接超时时间（毫秒）
-  rabbitmq:
-    host: 192.168.2.237
-    port: 5672
-    username: emrais
-    password: emrais
-    virtual-host: /emrais # 虚拟host
-    publisher-confirm-type: correlated # 确认消息已发送到交换机(Exchange)  发送确认
-    publisher-returns: true # 确认消息已发送到队列(Queue)  发送回调
-    connection-timeout: 4000
-    template:
-      mandatory: true # 当exchange无法找到任何一个合适的queue时，将消息return给生产者
-      receive-timeout: 30000 # 消费端接收的响应时间
-      reply-timeout: 30000 # 发送端等待接收消费端给出return msg的时间，相当于在message同步时，发送并消费成功的时间
-      retry:
+  cloud:
+    config:
+      discovery:
         enabled: true
-        max-attempts: 6 # 最大重试次数
-        initial-interval: 2000 # 重试初始间隔时间
-        multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间
-        max-interval: 64000 # 最大重试时间间隔
-    listener:
-      simple:
-        acknowledge-mode: auto # 自动确认
-        auto-startup: true # 是否启动时自动启动容器
-        concurrency: 1 # 最小的消费者数量
-        max-concurrency: 5 # 最大的消费者数量
-        default-requeue-rejected: true # 投递失败时是否重新排队；默认是true（与参数acknowledge-mode有关系）
-        retry:
-          enabled: true
-          max-attempts: 6
-          initial-interval: 2000
-          multiplier: 2
-          max-interval: 64000
-          stateless: true # 不论重试是有状态的还是无状态的
+        service-id: config-center
+  profiles:
+    active: local
 
 eureka:
   client:
@@ -69,12 +32,6 @@ management:
     health:
       show-details: always
 
-rabbitmq:
-  mqtt:
-    url: tcp://192.168.2.237:1883
-    front-url: ws://192.168.2.237:15675/ws
-    defaultTopic: defaultSampleTopic
-
 swagger.title: 消息管理服务
 swagger.des: 消息管理服务
 swagger.version: 0.0.1-SNAPSHOT

pom.xml

@@ -28,7 +28,7 @@
         <module>dblayer-mbg</module>
         <module>user-auth</module>
         <module>message-service</module>
-        <module>report-service</module>
+        <module>bus-interceptor</module>
     </modules>
 
     <properties>
@@ -58,7 +58,6 @@
         <jackson-databind.version>2.12.3</jackson-databind.version>
         <validation-api.version>2.0.1.Final</validation-api.version>
         <common.version>0.0.1-SNAPSHOT</common.version>
-        <aggregator.version>1.1.0</aggregator.version>
         <dblayer-mbg.version>0.0.1-SNAPSHOT</dblayer-mbg.version>
         <txlcn-tc.version>5.0.2.RELEASE</txlcn-tc.version>
         <txlcn-txmsg-netty.version>5.0.2.RELEASE</txlcn-txmsg-netty.version>
@@ -163,12 +162,6 @@
                 <version>${txlcn-txmsg-netty.version}</version>
             </dependency>
 
-            <dependency>
-                <groupId>io.github.lvyahui8</groupId>
-                <artifactId>spring-boot-data-aggregator-starter</artifactId>
-                <version>${aggregator.version}</version>
-            </dependency>
-
             <!--guava Java工具包-->
             <dependency>
                 <groupId>com.google.guava</groupId>

security-center/pom.xml

@@ -14,6 +14,11 @@
     <packaging>jar</packaging>
 
     <dependencies>
+        <dependency>
+            <groupId>com.lantone</groupId>
+            <artifactId>bus-interceptor</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>com.lantone</groupId>
             <artifactId>dblayer-mbg</artifactId>
@@ -27,6 +32,10 @@
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-config</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-openfeign</artifactId>

security-center/src/main/java/com/lantone/security/facade/FuncManagementFacade.java

@@ -18,6 +18,7 @@ import com.lantone.dblayermbg.entity.Menu;
 import com.lantone.dblayermbg.entity.MenuResource;
 import com.lantone.dblayermbg.entity.Resource;
 import com.lantone.dblayermbg.entity.RoleSoftwareMenu;
+import com.lantone.dblayermbg.entity.RoleSoftwareResource;
 import com.lantone.dblayermbg.entity.SoftwareMenu;
 import com.lantone.dblayermbg.entity.SoftwareResource;
 import com.lantone.dblayermbg.entity.User;
@@ -26,6 +27,7 @@ import com.lantone.dblayermbg.facade.MenuFacade;
 import com.lantone.dblayermbg.facade.MenuResourceFacade;
 import com.lantone.dblayermbg.facade.ResourceFacade;
 import com.lantone.dblayermbg.facade.RoleSoftwareMenuFacade;
+import com.lantone.dblayermbg.facade.RoleSoftwareResourceFacade;
 import com.lantone.dblayermbg.facade.SoftwareMenuFacade;
 import com.lantone.dblayermbg.facade.SoftwareResourceFacade;
 import com.lantone.common.enums.IsDeleteEnum;
@@ -62,6 +64,8 @@ public class FuncManagementFacade {
     @Autowired
     private SoftwareResourceFacade softwareResourceFacade;
     @Autowired
+    private RoleSoftwareResourceFacade roleSoftwareResourceFacade;
+    @Autowired
     private UserRoleFacade userRoleFacade;
 
     /**
@@ -136,7 +140,7 @@ public class FuncManagementFacade {
             //2.插入功能菜单对应系统对应系统 sys_software_menu和sys_role_software_menu
             if (savaRoleSoftwareMenu(menu.getId(), addMenuVO.getSoftwares(), 1l)) {
                 //插入sys_resource、sys_menu_resource、sys_software_resource
-                return saveMenuResource(addMenuVO.getPermissions(), addMenuVO.getSoftwares(), menu.getId());
+                return saveMenuResource(addMenuVO.getPermissions(), addMenuVO.getSoftwares(), menu.getId(), 1l);
             }
         } else {
             Asserts.fail("菜单详情插入失败");
@@ -169,7 +173,7 @@ public class FuncManagementFacade {
      * @Description插入sys_resource、sys_menu_resource
      * @Return boolean
      */
-    private boolean saveMenuResource(List<String> permissions, List<Long> softwares, Long menuID) {
+    private boolean saveMenuResource(List<String> permissions, List<Long> softwares, Long menuID, Long roleID) {
         //2.3 判断该功能菜单是否有对应权限
         if (ListUtil.isNotEmpty(permissions)) {
             permissions.stream().forEach(permission -> {
@@ -203,6 +207,11 @@ public class FuncManagementFacade {
                                 softwareResource.setSoftwareId(softwareId);
                                 softwareResource.setResourceId(resource.getId());
                                 softwareResourceFacade.save(softwareResource);
+                                //插入超级管理员与SoftwareResource关系 sys_role_software_resource
+                                RoleSoftwareResource roleSoftwareResource = new RoleSoftwareResource();
+                                roleSoftwareResource.setRoleId(roleID);
+                                roleSoftwareResource.setSoftwareResourceId(softwareResource.getId());
+                                roleSoftwareResourceFacade.save(roleSoftwareResource);
                             });
                         } else {
                             Asserts.fail("菜单与资源权限插入失败");
@@ -215,7 +224,7 @@ public class FuncManagementFacade {
             });
             return true;
         }
-        return false;
+        return true;
     }
 
     /**
@@ -309,7 +318,7 @@ public class FuncManagementFacade {
                 //3.1插入功能菜单对应系统对应系统 sys_software_menu和sys_role_software_menu
                 if (savaRoleSoftwareMenu(updateMenuVO.getId(), updateMenuVO.getSoftwares(), 1l)) {
                     //3.2插入sys_resource、sys_menu_resource、sys_software_resource
-                    return saveMenuResource(updateMenuVO.getPermissions(), updateMenuVO.getSoftwares(), updateMenuVO.getId());
+                    return saveMenuResource(updateMenuVO.getPermissions(), updateMenuVO.getSoftwares(), updateMenuVO.getId(), 1l);
                 }
             }
         }

security-center/src/main/java/com/lantone/security/facade/HospitalManagementFacade.java

@@ -513,13 +513,9 @@ public class HospitalManagementFacade {
      */
     public Map<String, Object> getManagerBoxInfo() {
         Map<String, Object> outMap = new HashMap<>();
+        String boxId = dictionaryInfoFacade.getOneDicMap(ReturnTypeEnum.INTERFACE.getKey(),DictionaryEnum.MANAGE_HIDE_MENU.getKey()+"").get("box");
         Map<String, List<GetDictionaryInfoByTypeDTO>> dicMapObj = dictionaryInfoFacade.getDicMapObj(ReturnTypeEnum.INTERFACE.getKey(),
-                Lists.newArrayList(DictionaryEnum.TITLE.getKey() + "",
-                        DictionaryEnum.STATUS.getKey() + "",
-                        DictionaryEnum.NOTICE_TYPE.getKey() + "",
-                        DictionaryEnum.NOTICE_STATUS.getKey() + "",
-                        DictionaryEnum.HOSPITAL_TYPE.getKey() + "",
-                        DictionaryEnum.DATA_AUTH.getKey() + ""));
+                Lists.newArrayList(boxId.split(",")));
         outMap.putAll(dicMapObj);
         outMap.remove(DictionaryEnum.HOSPITAL_TYPE.getKey() + "");
         //1.获取当前用户的组织类型

security-center/src/main/java/com/lantone/security/facade/LogManagementFacade.java

@@ -9,12 +9,15 @@ import com.lantone.common.vo.GetAbnormalWayAndIpVO;
 import com.lantone.common.vo.GetLoginLogVO;
 import com.lantone.common.vo.GetLoginNameAndIpVO;
 import com.lantone.common.vo.GetOperationLogVO;
+import com.lantone.dblayermbg.entity.OperationLog;
 import com.lantone.dblayermbg.facade.AbnormalLogFacade;
 import com.lantone.dblayermbg.facade.LoginLogFacade;
 import com.lantone.dblayermbg.facade.OperationLogFacade;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @Description:日志管理
@@ -38,7 +41,7 @@ public class LogManagementFacade {
      * @Date: 2021/9/8
      */
     public IPage<LoginLogDTO> getLoginLog(GetLoginLogVO getLoginLogVO) {
-        return loginLogFacade.getLoginLog(getLoginLogVO);
+        return loginLogFacade.getBaseMapper().getLoginLog(getLoginLogVO);
     }
 
     /**查看登录日志登录用户|登录ip地址
@@ -49,7 +52,7 @@ public class LogManagementFacade {
      * @Date: 2021/9/8
      */
     public List<String> getLoginLogNameAndIp(GetLoginNameAndIpVO getLoginNameAndIpVO) {
-        return loginLogFacade.getLoginLogNameAndIp(getLoginNameAndIpVO);
+        return loginLogFacade.getBaseMapper().getLoginLogNameAndIp(getLoginNameAndIpVO);
     }
 
     /**
@@ -60,7 +63,7 @@ public class LogManagementFacade {
      * @Date: 2021/9/8
      */
     public IPage<OperationLogDTO> getOperationLog(GetOperationLogVO getOperationLogVO) {
-        return operationLogFacade.getOperationLog(getOperationLogVO);
+        return operationLogFacade.getBaseMapper().getOperationLog(getOperationLogVO);
     }
 
     /**
@@ -71,7 +74,10 @@ public class LogManagementFacade {
      * @Date: 2021/9/8
      */
     public List<String> getOperationLogName(String operationName) {
-        return operationLogFacade.getOperationLogName(operationName);
+        return operationLogFacade.lambdaQuery()
+                .like(StringUtils.isNotBlank(operationName), OperationLog::getOperationName, operationName)
+                .select(OperationLog::getOperationName)
+                .list().stream().map(OperationLog::getOperationName).collect(Collectors.toList());
     }
 
     /**
@@ -82,7 +88,7 @@ public class LogManagementFacade {
      * @Date: 2021/9/8
      */
     public IPage<AbnormalLogDTO> getAbnormalLog(GetAbnormalLogVO getAbnormalLogVO) {
-        return  abnormalLogFacade.getAbnormalLog(getAbnormalLogVO);
+        return  abnormalLogFacade.getBaseMapper().getAbnormalLog(getAbnormalLogVO);
     }
 
     /**
@@ -93,6 +99,6 @@ public class LogManagementFacade {
      * @Date: 2021/9/8
      */
     public List<String> getAbnormalLogWayAndIp(GetAbnormalWayAndIpVO getAbnormalWayAndIpVO) {
-        return  abnormalLogFacade.getAbnormalLogWayAndIp(getAbnormalWayAndIpVO);
+        return  abnormalLogFacade.getBaseMapper().getAbnormalLogWayAndIp(getAbnormalWayAndIpVO);
     }
 }

security-center/src/main/java/com/lantone/security/facade/NoticeManagementFacade.java

@@ -167,6 +167,7 @@ public class NoticeManagementFacade {
             noticeUsers.add(noticeUser);
             SendToTopicDTO sendToTopicDTO = new SendToTopicDTO();
             sendToTopicDTO.setMessage("+1");
+            sendToTopicDTO.setType("count");
             sendToTopicDTO.setTopic(userId+"");
             sendToTopics.add(sendToTopicDTO);
         });

security-center/src/main/java/com/lantone/security/facade/RegionManagementFacade.java

@@ -64,7 +64,7 @@ public class RegionManagementFacade {
         if (1 == updateRegionVO.getMark()) {
             GetRegionVO getRegionVO = new GetRegionVO();
             BeanUtils.copyProperties(updateRegionVO, getRegionVO);
-            return regionFacade.getWard(getRegionVO);
+            return regionFacade.getBaseMapper().getWard(getRegionVO);
         }
         Region sysRegion = new Region();
         BeanUtils.copyProperties(updateRegionVO, sysRegion);
@@ -83,7 +83,7 @@ public class RegionManagementFacade {
     public IPage<ViewRegionDTO> getRegion(GetRegionVO getRegionVO) {
         getRegionVO.setHospitalId(SysUserUtils.getCurrentHospitalId());
         getRegionVO.setUserId(SysUserUtils.getCurrentPrincipleId());
-        return regionFacade.getWard(getRegionVO);
+        return regionFacade.getBaseMapper().getWard(getRegionVO);
     }
 
     /**

security-center/src/main/java/com/lantone/security/facade/UserManagementFacade.java

@@ -1,8 +1,10 @@
 package com.lantone.security.facade;
 
+import cn.hutool.core.util.StrUtil;
 import cn.hutool.crypto.digest.BCrypt;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
+import com.auth0.jwt.interfaces.Claim;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -16,7 +18,9 @@ import com.lantone.common.dto.GetUserDTO;
 import com.lantone.common.dto.GetUserHospitalDeptDTO;
 import com.lantone.common.dto.GetUserHospitalsDTO;
 import com.lantone.common.dto.GetUserPageDTO;
+import com.lantone.common.dto.JwtStore;
 import com.lantone.common.dto.LoginLogDTO;
+import com.lantone.common.dto.SendToTopicDTO;
 import com.lantone.common.dto.SoftwareDTO;
 import com.lantone.common.dto.UserInfoDTO;
 import com.lantone.common.dto.UserRoleDTO;
@@ -25,6 +29,8 @@ import com.lantone.common.enums.DataAuthDataTypeEnum;
 import com.lantone.common.enums.IsDeleteEnum;
 import com.lantone.common.enums.StatusEnum;
 import com.lantone.common.exception.Asserts;
+import com.lantone.common.service.RedisService;
+import com.lantone.common.service.SysTokenService;
 import com.lantone.common.util.DateUtil;
 import com.lantone.common.util.EntityUtil;
 import com.lantone.common.util.HttpUtils;
@@ -110,6 +116,10 @@ public class UserManagementFacade {
     private DictionaryInfoFacade dictionaryInfoFacade;
     @Autowired
     private MessageService messageService;
+    @Autowired
+    private RedisService redisService;
+    @Autowired
+    private SysTokenService sysTokenService;
 
     public CommonResult login(LoginVO loginVO) {
         Map<String, String> params = new HashMap<>();
@@ -119,10 +129,40 @@ public class UserManagementFacade {
         params.put("username", loginVO.getUsername());
         params.put("password", loginVO.getPassword());
         CommonResult restResult = authService.getAccessToken(params);
+        userLoginCheck(restResult);
         sendLogRecordMessage(restResult);
         return restResult;
     }
 
+    private void userLoginCheck(CommonResult restResult) {
+        if (restResult.getData() != null) {
+            Map<String, Object> map = JSONObject.parseObject(JSON.toJSONString(restResult.getData()));
+            if (map.containsKey(AuthConstant.ASSESS_TOKEN) && null != map.get(AuthConstant.ASSESS_TOKEN)) {
+                String userId = sysTokenService.getUserIDByToken(map.get(AuthConstant.ASSESS_TOKEN).toString());
+                JwtStore oldJwt = sysTokenService.getToken(userId);
+                String ip = HttpUtils.getIpAddress();
+                //异地登录
+                if (StringUtil.isNotBlank(ip)
+                        && oldJwt != null
+                        && !ip.equals(oldJwt.getIp())) {
+                    //推送消息
+                    List<SendToTopicDTO> sendToTopics = new ArrayList<>();
+                    SendToTopicDTO sendToTopicDTO = new SendToTopicDTO();
+                    sendToTopicDTO.setMessage("温誓提示，您的账号在其它地方已登录您将被迫下线!");
+                    sendToTopicDTO.setType("login");
+                    sendToTopicDTO.setTopic(userId);
+                    sendToTopics.add(sendToTopicDTO);
+                    messageService.sendToTopic(sendToTopics);
+                }
+                JwtStore jwtStore = new JwtStore();
+                jwtStore.setAccessToken(map.get(AuthConstant.ASSESS_TOKEN).toString());
+                jwtStore.setRefreshToken(map.get(AuthConstant.REFRESH_TOKEN).toString());
+                jwtStore.setIp(HttpUtils.getIpAddress());
+                sysTokenService.createToken(jwtStore);
+            }
+        }
+    }
+
     public UserDto loadUserByUsername(String username) {
         QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
         userQueryWrapper.eq("username", username);
@@ -211,7 +251,7 @@ public class UserManagementFacade {
         } else {
             if (ListUtil.isNotEmpty(users)) {
                 users.stream().forEach(user1 -> {
-                    if(!user.getId().equals(user1.getId())){
+                    if (!user.getId().equals(user1.getId())) {
                         Asserts.fail("该用户已存在,请更换用户名");
                     }
                 });
@@ -823,4 +863,13 @@ public class UserManagementFacade {
         }
     }
 
+    /**
+     *@Description用户登出
+     *
+     * @param userId
+     * @Return com.lantone.common.api.CommonResult<java.lang.Boolean>
+     */
+    public CommonResult<Boolean> close(String userId) {
+        return CommonResult.success(sysTokenService.deleteToken(userId));
+    }
 }

security-center/src/main/java/com/lantone/security/web/UserManagementController.java

@@ -47,6 +47,11 @@ public class UserManagementController {
     public CommonResult login(@Valid @RequestBody LoginVO loginVO) {
         return userManagementFacade.login(loginVO);
     }
+    @ApiOperation(value = "登出")
+    @PostMapping(value = "/close")
+    public CommonResult<Boolean> close(@RequestParam @Valid @NotNull(message = "用户编号为空") String userId) {
+        return userManagementFacade.close(userId);
+    }
 
     @ApiOperation("根据用户名获取通用用户信息")
     @PostMapping(value = "/loadByUsername")

security-center/src/main/resources/bootstrap.yml

@@ -4,18 +4,13 @@ server:
 spring:
   application:
     name: security-center
-  redis:
-    database: 12
-    host: 192.168.2.236 # Redis服务器地址
-    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
-    password: lantone # Redis服务器连接密码（默认为空）
-    jedis:
-      pool:
-        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
-        max-idle: 5 # 连接池中的最大空闲连接
-        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
-        min-idle: 0 # 连接池中的最小空闲连接
-    timeout: 20000 # 连接超时时间（毫秒）
+  cloud:
+    config:
+      discovery:
+        enabled: true
+        service-id: config-center
+  profiles:
+    active: local
 
 eureka:
   client:
@@ -41,6 +36,7 @@ encrypt:
 feign:
   okhttp:
     enabled: true
+
 ribbon:
   ConnectTimeout: 3000 # 服务请求连接超时时间（毫秒）
   ReadTimeout: 3000 # 服务请求处理超时时间（毫秒）

user-auth/src/main/java/com/lantone/UserAuthApplication.java

@@ -1,13 +1,19 @@
 package com.lantone;
 
+import com.lantone.common.service.SysTokenService;
+import com.lantone.common.service.impl.SysTokenServiceImpl;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
 import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.FilterType;
 
 @EnableFeignClients
 @EnableEurekaClient
 @SpringBootApplication
+@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
+        classes = {SysTokenService.class, SysTokenServiceImpl.class})})
 public class UserAuthApplication {
 
     public static void main(String[] args) {

user-auth/src/main/resources/bootstrap.yml

@@ -26,10 +26,12 @@ management:
 feign:
   okhttp:
     enabled: true
+
 ribbon:
   ConnectTimeout: 3000 #服务请求连接超时时间（毫秒）
   ReadTimeout: 3000 #服务请求处理超时时间（毫秒）
 
 swagger.title: 认证中心
 swagger.des: 认证中心相关接口文档
-swagger.version: 0.0.1-SNAPSHOT
+swagger.version: 0.0.1-SNAPSHOT
+swagger.show: true