one-YI
/
cloud-server
5
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

merge into: one-YI:master
Branches Tags
one-YI:dev
one-YI:dev.car.gateway
one-YI:dev.saas.platform
one-YI:dev.saas.RedisCar
one-YI:dev.vehicle.gateway
one-YI:dev.saas.customer
one-YI:dev.data.processing
one-YI:dev.protocol.parsing
one-YI:dev.data.processing.dataTreating
one-YI:master
...
pull from: one-YI:dev.data.processing.dataTreating
Branches Tags
one-YI:dev
one-YI:dev.car.gateway
one-YI:dev.saas.platform
one-YI:dev.saas.RedisCar
one-YI:dev.vehicle.gateway
one-YI:dev.saas.customer
one-YI:dev.data.processing
one-YI:dev.protocol.parsing
one-YI:dev.data.processing.dataTreating
one-YI:master

No commits in common. "master" and "dev.data.processing.dataTreating" have entirely different histories.
master ... dev.data.p

348 changed files with 13747 additions and 1206 deletions
Show Stats Expand all files Collapse all files

63
cloud-auth/pom.xml
View File

@ -16,23 +16,10 @@
<dependencies>
<!-- SpringCloud Alibaba Nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- SpringCloud Alibaba Nacos Config -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!-- SpringCloud Alibaba Sentinel -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!-- <dependency>-->
<!-- <groupId>com.muyu</groupId>-->
<!-- <artifactId>cloud-common-saas</artifactId>-->
<!-- </dependency>-->
<!-- SpringBoot Web -->
<dependency>
@ -58,6 +45,48 @@
<artifactId>cloud-common-api-doc</artifactId>
</dependency>
<!-- SpringCloud Alibaba Nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- SpringCloud Alibaba Nacos Config -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!-- SpringCloud Alibaba Sentinel -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!-- Mysql Connector -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<!-- MuYu Common DataSource -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-datasource</artifactId>
</dependency>
<!-- MuYu Common DataScope -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-datascope</artifactId>
</dependency>
<!-- MuYu Common Log -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-log</artifactId>
</dependency>
</dependencies>
<build>

13
cloud-auth/src/main/java/com/muyu/auth/CloudAuthApplication.java
View File

@ -1,5 +1,8 @@
package com.muyu.auth;
import com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceAutoConfiguration;
import com.muyu.common.security.annotation.EnableCustomConfig;
import com.muyu.common.security.annotation.EnableMyFeignClients;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@ -10,10 +13,18 @@ import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
*
* @author muyu
*/
@EnableCustomConfig
@EnableMyFeignClients
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@SpringBootApplication(
exclude = {
DataSourceAutoConfiguration.class,
DruidDataSourceAutoConfigure.class,
DynamicDataSourceAutoConfiguration.class
}
)
public class CloudAuthApplication {
public static void main (String[] args) {
SpringApplication.run(CloudAuthApplication.class, args);
System.out.println("CloudAuth 模块启动成功!");
}
}

8
cloud-auth/src/main/java/com/muyu/auth/controller/TokenController.java
View File

@ -10,7 +10,7 @@ import com.muyu.common.security.auth.AuthUtil;
import com.muyu.common.security.service.TokenService;
import com.muyu.common.security.utils.SecurityUtils;
import com.muyu.common.system.domain.LoginUser;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@ -25,16 +25,16 @@ import jakarta.servlet.http.HttpServletRequest;
*/
@RestController
public class TokenController {
@Autowired
@Resource
private TokenService tokenService;
@Autowired
@Resource
private SysLoginService sysLoginService;
@PostMapping("login")
public Result<?> login (@RequestBody LoginBody form) {
// 用户登录
LoginUser userInfo = sysLoginService.login(form.getUsername(), form.getPassword());
LoginUser userInfo = sysLoginService.login(form);
// 获取登录token
return Result.success(tokenService.createToken(userInfo));
}

21
cloud-auth/src/main/java/com/muyu/auth/form/LoginBody.java
View File

@ -1,11 +1,16 @@
package com.muyu.auth.form;
import lombok.Data;
/**
* 用户登录对象
*
* @author muyu
*/
@Data
public class LoginBody {
private String firmCode;
/**
* 用户名
*/
@ -15,20 +20,4 @@ public class LoginBody {
* 用户密码
*/
private String password;
public String getUsername () {
return username;
}
public void setUsername (String username) {
this.username = username;
}
public String getPassword () {
return password;
}
public void setPassword (String password) {
this.password = password;
}
}

35
cloud-auth/src/main/java/com/muyu/auth/service/SysLoginService.java
View File

@ -1,5 +1,6 @@
package com.muyu.auth.service;
import com.muyu.auth.form.LoginBody;
import com.muyu.common.core.constant.CacheConstants;
import com.muyu.common.core.constant.Constants;
import com.muyu.common.core.constant.SecurityConstants;
@ -12,12 +13,16 @@ import com.muyu.common.core.utils.StringUtils;
import com.muyu.common.core.utils.ip.IpUtils;
import com.muyu.common.redis.service.RedisService;
import com.muyu.common.security.utils.SecurityUtils;
import com.muyu.common.system.remote.RemoteSaasService;
import com.muyu.common.system.remote.RemoteUserService;
import com.muyu.common.system.domain.SysUser;
import com.muyu.common.system.domain.LoginUser;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import java.util.Set;
/**
* 登录校验方法
*
@ -25,24 +30,30 @@ import org.springframework.stereotype.Component;
*/
@Component
public class SysLoginService {
@Autowired
@Resource
private RemoteUserService remoteUserService;
@Autowired
@Resource
private SysPasswordService passwordService;
@Autowired
@Resource
private SysRecordLogService recordLogService;
@Autowired
@Resource
private RedisService redisService;
@Resource
private RemoteSaasService remoteSaasService;
/**
* 登录
*/
public LoginUser login (String username, String password) {
public LoginUser login (LoginBody form) {
String firmCode = form.getFirmCode();
String username = form.getUsername();
String password = form.getPassword();
// 用户名或密码为空 错误
if (StringUtils.isAnyBlank(username, password)) {
if (StringUtils.isAnyBlank(firmCode, username, password)) {
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "用户/密码必须填写");
throw new ServiceException("用户/密码必须填写");
}
@ -65,8 +76,7 @@ public class SysLoginService {
throw new ServiceException("很遗憾，访问IP已被列入系统黑名单");
}
// 查询用户信息
Result<LoginUser> userResult = remoteUserService.getUserInfo(username, SecurityConstants.INNER);
Result<LoginUser> userResult = remoteUserService.getUserInfo(firmCode, username, SecurityConstants.INNER);
if (StringUtils.isNull(userResult) || StringUtils.isNull(userResult.getData())) {
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "登录用户不存在");
throw new ServiceException("登录用户：" + username + " 不存在");
@ -76,8 +86,8 @@ public class SysLoginService {
throw new ServiceException(userResult.getMsg());
}
LoginUser userInfo = userResult.getData();
SysUser user = userResult.getData().getSysUser();
LoginUser loginUser = userResult.getData();
SysUser user = loginUser.getSysUser();
if (UserStatus.DELETED.getCode().equals(user.getDelFlag())) {
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "对不起，您的账号已被删除");
throw new ServiceException("对不起，您的账号：" + username + " 已被删除");
@ -88,7 +98,8 @@ public class SysLoginService {
}
passwordService.validate(user, password);
recordLogService.recordLogininfor(username, Constants.LOGIN_SUCCESS, "登录成功");
return userInfo;
return loginUser;
}
public void logout (String loginName) {

6
cloud-auth/src/main/java/com/muyu/auth/service/SysPasswordService.java
View File

@ -6,7 +6,7 @@ import com.muyu.common.core.exception.ServiceException;
import com.muyu.common.redis.service.RedisService;
import com.muyu.common.security.utils.SecurityUtils;
import com.muyu.common.system.domain.SysUser;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@ -18,14 +18,14 @@ import java.util.concurrent.TimeUnit;
*/
@Component
public class SysPasswordService {
@Autowired
@Resource
private RedisService redisService;
private int maxRetryCount = CacheConstants.PASSWORD_MAX_RETRY_COUNT;
private Long lockTime = CacheConstants.PASSWORD_LOCK_TIME;
@Autowired
@Resource
private SysRecordLogService recordLogService;
/**

4
cloud-auth/src/main/java/com/muyu/auth/service/SysRecordLogService.java
View File

@ -6,7 +6,7 @@ import com.muyu.common.core.utils.StringUtils;
import com.muyu.common.core.utils.ip.IpUtils;
import com.muyu.common.system.remote.RemoteLogService;
import com.muyu.common.system.domain.SysLogininfor;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
/**
@ -16,7 +16,7 @@ import org.springframework.stereotype.Component;
*/
@Component
public class SysRecordLogService {
@Autowired
@Resource
private RemoteLogService remoteLogService;
/**

8
cloud-auth/src/main/resources/bootstrap.yml
View File

@ -4,10 +4,10 @@ server:
# nacos线上地址
nacos:
addr: nacos.muyu.icu:8848
addr: 47.116.173.119:8848
user-name: nacos
password: nacos
namespace: muyu-cloud
namespace: one-saas
# Spring
spring:
application:
@ -40,8 +40,8 @@ spring:
file-extension: yml
# 共享配置
shared-configs:
# 系统共享配置
- application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
# 系统环境Config共享配置
- application-config-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
# 系统共享配置
- application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}

35
cloud-common/cloud-common-caffeine/pom.xml 100644
View File

@ -0,0 +1,35 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>cloud-common</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>cloud-common-caffeine</artifactId>
<description>
cloud-common-caffeine caffeine缓存模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-redis</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>
</dependencies>
</project>

51
cloud-common/cloud-common-caffeine/src/main/java/com/muyu/common/caffeine/bean/CaffeineManager.java 100644
View File

@ -0,0 +1,51 @@
package com.muyu.common.caffeine.bean;
import com.muyu.common.caffeine.enums.CacheNameEnums;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Caffeine管理器
* @Author: 胡杨
* @Name: CaffeineCacheConfig
* @Description: Caffeine管理器
* @CreatedDate: 2024/9/26 上午11:52
* @FilePath: com.muyu.common.caffeine.config
*/
@Slf4j
@Component
public class CaffeineManager {
/**
* 创建缓存管理器
* @return 缓存管理器实例
*/
@Bean
public CacheManager cacheManager() {
SimpleCacheManager cacheManager = new SimpleCacheManager();
List<String> cacheNames = CacheNameEnums.getCodes();
cacheManager.setCaches(cacheNames.stream()
.map(name -> new CaffeineCache(
name,
Caffeine.newBuilder()
.recordStats()
.build()))
.toList());
log.info("缓存管理器初始化完成,缓存分区:{}", cacheNames);
return cacheManager;
}
}

17
cloud-common/cloud-common-caffeine/src/main/java/com/muyu/common/caffeine/constents/CaffeineContent.java 100644
View File

@ -0,0 +1,17 @@
package com.muyu.common.caffeine.constents;
/**
* Caffeine常量
* @Author: 胡杨
* @Name: CaffeineContent
* @Description: Caffeine常量
* @CreatedDate: 2024/9/26 下午12:06
* @FilePath: com.muyu.common.caffeine.constents
*/
public class CaffeineContent {
public static final String CAR_VIN_KEY = "car:vin";
public static final String VIN = "vin";
}

66
cloud-common/cloud-common-caffeine/src/main/java/com/muyu/common/caffeine/enums/CacheNameEnums.java 100644
View File

@ -0,0 +1,66 @@
package com.muyu.common.caffeine.enums;
import lombok.Getter;
import java.util.Arrays;
import java.util.List;
/**
* 缓存分区枚举
*
* @Author: 胡杨
* @Name: CacheNameEnums
* @Description: 缓存分区枚举
* @CreatedDate: 2024/10/2 上午9:17
* @FilePath: com.muyu.common.caffeine.enums
*/
@Getter
public enum CacheNameEnums {
FAULT("fault", "故障"),
FENCE("fence", "围栏"),
WARMING("warming", "预警");
private final String code;
private final String info;
CacheNameEnums(String code, String info) {
this.code = code;
this.info = info;
}
/**
* 鉴别参数是否是枚举的值
*
* @param code 需鉴别参数
* @return 如果存在返回结果turn, 否则返回false
*/
public static boolean isCode(String code) {
return Arrays.stream(values())
.map(CacheNameEnums::getCode)
.anyMatch(c -> c.equals(code));
}
/**
* 获取枚举Value
* @param code 编码
* @return Value
*/
public static String getInfo(String code) {
return Arrays.stream(values())
.filter(c -> c.getCode().equals(code))
.map(CacheNameEnums::getInfo)
.findFirst()
.orElse("");
}
/**
* 获取所有code
* @return code集合
*/
public static List<String> getCodes() {
return Arrays.stream(values())
.map(CacheNameEnums::getCode)
.toList();
}
}

97
cloud-common/cloud-common-caffeine/src/main/java/com/muyu/common/caffeine/utils/CaffeineCacheUtils.java 100644
View File

@ -0,0 +1,97 @@
package com.muyu.common.caffeine.utils;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.muyu.common.caffeine.constents.CaffeineContent;
import com.muyu.common.caffeine.enums.CacheNameEnums;
import com.muyu.common.redis.service.RedisService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collection;
/**
* Caffeine缓存工具
* @Author: 胡杨
* @Name: CaffeineUtils
* @Description: 缓存工具类
* @CreatedDate: 2024/9/26 下午2:53
* @FilePath: com.muyu.common.caffeine
*/
@Slf4j
@Component
public class CaffeineCacheUtils {
@Resource
private CacheManager cacheManager;
@Resource
private RedisTemplate<String, String> redisTemplate;
/**
* 车辆上线 - 新增缓存
*/
public void addCarCache(String vin) {
// 从Redis中获取缓存信息
for (String name : CacheNameEnums.getCodes()) {
String value = redisTemplate.opsForValue().get(name+":"+vin);
cacheManager.getCache(name).put(vin, value);
log.info("存储缓存, 缓存分区:[{}], 车辆编码:[{}], 存储值:[{}]", name, vin, value);
}
log.info("车辆编码:{},本地缓存完成...",vin);
}
/**
* 车辆下线 - 删除缓存
*/
public void deleteCarCache(String cacheName) {
if (!hasCarVinCache(cacheName,null)) {
log.warn("车辆编码:{},本地缓存不存在该车辆信息...", cacheName);
return;
}
cacheManager.getCache(cacheName).invalidate();
log.info("车辆编码:{},本地缓存删除完成...", cacheName);
}
/**
* 获取车辆信息缓存
*/
public Object getCarCache(String cacheName, String key) {
if (!hasCarVinCache(cacheName, key)){
log.warn("车辆编码:{},本地缓存不存在该车辆信息...",cacheName);
return null;
}
return cacheManager.getCache(cacheName).get(key).get();
}
/**
* 获取车辆信息缓存
*/
public <T> T getCarCache(String cacheName, String key, Class<T> type) {
if (!hasCarVinCache(cacheName,key)){
log.warn("车辆编码:{},本地缓存不存在该车辆信息...",cacheName);
return null;
}
return cacheManager.getCache(cacheName).get(key, type);
}
/**
* 判断缓存存在与否
*/
public Boolean hasCarVinCache(String cacheName,String key) {
boolean notEmpty = ObjectUtils.isNotEmpty(cacheManager.getCache(cacheName));
if (notEmpty && StringUtils.isNotEmpty(key)){
return ObjectUtils.isNotEmpty(cacheManager.getCache(cacheName).get(key).get());
}
return notEmpty;
}
}

2
cloud-common/cloud-common-caffeine/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 100644
View File

@ -0,0 +1,2 @@
com.muyu.common.caffeine.utils.CaffeineCacheUtils
com.muyu.common.caffeine.bean.CaffeineManager

5
cloud-common/cloud-common-core/pom.xml
View File

@ -16,6 +16,11 @@
</description>
<dependencies>
<dependency>
<groupId>com.github.yulichang</groupId>
<artifactId>mybatis-plus-join-boot-starter</artifactId>
<version>1.4.11</version>
</dependency>
<!-- SpringCloud Openfeign -->
<dependency>

5
cloud-common/cloud-common-core/src/main/java/com/muyu/common/core/constant/SecurityConstants.java
View File

@ -45,4 +45,9 @@ public class SecurityConstants {
* 角色权限
*/
public static final String ROLE_PERMISSION = "role_permission";
/**
* SAAS请求头的key
*/
public static final String SAAS_KEY = "ent-code";
}

9
cloud-common/cloud-common-core/src/main/java/com/muyu/common/core/constant/ServiceNameConstants.java
View File

@ -20,4 +20,13 @@ public class ServiceNameConstants {
* 文件服务的serviceid
*/
public static final String FILE_SERVICE = "cloud-file";
/**
* 智能车联服务
*/
public static final String SMART_SERVICE = "cloud-smart-car";
public static final String ENT_SERVICE = "cloud-ent";
public static final String SAAS_SERVICE = "cloud-system-saas";
}

8
cloud-common/cloud-common-core/src/main/java/com/muyu/common/core/context/SecurityContextHolder.java
View File

@ -80,4 +80,12 @@ public class SecurityContextHolder {
public static void remove () {
THREAD_LOCAL.remove();
}
public static String getSaasKey() {
return get(SecurityConstants.SAAS_KEY);
}
public static void setSaasKey(String saasKey) {
set(SecurityConstants.SAAS_KEY,saasKey);
}
}

63
cloud-common/cloud-common-core/src/main/java/com/muyu/common/core/enums/ClassType.java 100644
View File

@ -0,0 +1,63 @@
package com.muyu.common.core.enums;
import lombok.Getter;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 类型枚举
*
* @Author: 胡杨
* @Name: ClassType
* @Description: 类型枚举
* @CreatedDate: 2024/9/29 上午9:28
* @FilePath: com.muyu.common.core.enums
*/
@Getter
public enum ClassType {
BYTE("byte", byte.class),
SHORT("short", short.class),
INT("int", int.class),
LONG("long", long.class),
FLOAT("float", float.class),
DOUBLE("double", double.class),
BOOLEAN("boolean", boolean.class),
CHAR("char", char.class),
STRING("String", String.class),
SET("Set", Set.class),
MAP("Map", Map.class),
LIST("List", List.class);
private final String code;
private final Class<?> info;
ClassType(String code, Class<?> info) {
this.code = code;
this.info = info;
}
/**
* 鉴别参数是否是枚举的值
*
* @param code 需鉴别参数
* @return 如果存在返回结果turn, 否则返回false
*/
public static boolean isCode(String code) {
return Arrays.stream(values())
.map(ClassType::getCode)
.anyMatch(c -> c.equals(code));
}
public static Class<?> getInfo(String code) {
return Arrays.stream(values())
.filter(c -> c.getCode().equals(code))
.findFirst()
.map(ClassType::getInfo)
.orElse(null);
}
}

4
cloud-common/cloud-common-core/src/main/java/com/muyu/common/core/exception/ServiceException.java
View File

@ -5,7 +5,7 @@ package com.muyu.common.core.exception;
*
* @author muyu
*/
public final class ServiceException extends RuntimeException {
public class ServiceException extends RuntimeException {
private static final long serialVersionUID = 1L;
/**
@ -21,7 +21,7 @@ public final class ServiceException extends RuntimeException {
/**
* 错误明细，内部调试错误
* <p>
* 和 {@link CommonResult#getDetailMessage()} 一致的设计
* 和 {CommonResult#getDetailMessage()} 一致的设计
*/
private String detailMessage;

11
cloud-common/cloud-common-core/src/main/java/com/muyu/common/core/utils/JwtUtils.java
View File

@ -162,4 +162,15 @@ public class JwtUtils {
public static String getValue (Claims claims, String key) {
return Convert.toStr(claims.get(key), "");
}
/**
* 根据身份信息获取SAASKey
*
* @param claims 身份信息
*
* @return saas_key
*/
public static String getSaasKey(Claims claims) {
return getValue(claims, SecurityConstants.SAAS_KEY);
}
}

36
cloud-common/cloud-common-iotdb/pom.xml 100644
View File

@ -0,0 +1,36 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>cloud-common</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>cloud-common-iotdb</artifactId>
<description>
cloud-common-iotdb 时序数据库模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-core</artifactId>
</dependency>
<dependency>
<groupId>org.apache.iotdb</groupId>
<artifactId>iotdb-session</artifactId>
<version>1.3.2</version>
</dependency>
</dependencies>
</project>

48
cloud-common/cloud-common-iotdb/src/main/java/com/muyu/common/iotdb/config/IotDBConfig.java 100644
View File

@ -0,0 +1,48 @@
package com.muyu.common.iotdb.config;
import org.apache.iotdb.rpc.IoTDBConnectionException;
import org.apache.iotdb.session.Session;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 时序数据库配置
*
* @Author: 胡杨
* @Name: IotDBConfig
* @Description: 时序数据库配置
* @CreatedDate: 2024/9/29 下午9:30
* @FilePath: com.muyu.data.processing.config
*/
@Configuration
public class IotDBConfig {
@Value("${spring.iotdb.ip}")
private String ip;
@Value("${spring.iotdb.port}")
private int port;
@Value("${spring.iotdb.user}")
private String user;
@Value("${spring.iotdb.password}")
private String password;
@Value("${spring.iotdb.fetchSize}")
private int fetchSize;
@Bean
public Session iotSession(){
Session session = new Session(ip, port, user, password, fetchSize);
try {
session.open();
} catch (IoTDBConnectionException e) {
throw new RuntimeException(e);
}
return session;
}
}

1
cloud-common/cloud-common-iotdb/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 100644
View File

@ -0,0 +1 @@
com.muyu.common.iotdb.config.IotDBConfig

37
cloud-common/cloud-common-kafka/pom.xml 100644
View File

@ -0,0 +1,37 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>cloud-common</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>cloud-common-kafka</artifactId>
<description>
cloud-common-kafka kafka中间件模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
</project>

54
cloud-common/cloud-common-kafka/src/main/java/com/muyu/common/kafka/config/KafkaConsumerConfig.java 100644
View File

@ -0,0 +1,54 @@
package com.muyu.common.kafka.config;
import com.muyu.common.kafka.constants.KafkaConstants;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.Deserializer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
/**
* kafka 消息的消费者 配置类
*/
@Configuration
public class KafkaConsumerConfig {
@Bean
public KafkaConsumer kafkaConsumer() {
Map<String, Object> configs = new HashMap<>();
//kafka服务端的IP和端口,格式:(ip:port)
configs.put("bootstrap.servers", "47.116.173.119:9092");
//开启consumer的偏移量(offset)自动提交到Kafka
configs.put("enable.auto.commit", true);
//consumer的偏移量(offset) 自动提交的时间间隔,单位毫秒
configs.put("auto.commit.interval", 5000);
//在Kafka中没有初始化偏移量或者当前偏移量不存在情况
//earliest, 在偏移量无效的情况下, 自动重置为最早的偏移量
//latest, 在偏移量无效的情况下, 自动重置为最新的偏移量
//none, 在偏移量无效的情况下, 抛出异常.
configs.put("auto.offset.reset", "latest");
//请求阻塞的最大时间(毫秒)
configs.put("fetch.max.wait", 500);
//请求应答的最小字节数
configs.put("fetch.min.size", 1);
//心跳间隔时间(毫秒)
configs.put("heartbeat-interval", 3000);
//一次调用poll返回的最大记录条数
configs.put("max.poll.records", 500);
//指定消费组
configs.put("group.id", KafkaConstants.KafkaGrop);
//指定key使用的反序列化类
Deserializer keyDeserializer = new StringDeserializer();
//指定value使用的反序列化类
Deserializer valueDeserializer = new StringDeserializer();
//创建Kafka消费者
KafkaConsumer kafkaConsumer = new KafkaConsumer(configs, keyDeserializer, valueDeserializer);
return kafkaConsumer;
}
}

45
cloud-common/cloud-common-kafka/src/main/java/com/muyu/common/kafka/config/KafkaProviderConfig.java 100644
View File

@ -0,0 +1,45 @@
package com.muyu.common.kafka.config;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.common.serialization.Serializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
/**
* kafka 消息的生产者 配置类
*/
@Configuration
public class KafkaProviderConfig {
@Bean
public KafkaProducer kafkaProducer() {
Map<String, Object> configs = new HashMap<>();
//#kafka服务端的IP和端口,格式:(ip:port)
configs.put("bootstrap.servers", "47.116.173.119:9092");
//客户端发送服务端失败的重试次数
configs.put("retries", 2);
//多个记录被发送到同一个分区时,生产者将尝试将记录一起批处理成更少的请求.
//此设置有助于提高客户端和服务器的性能,配置控制默认批量大小(以字节为单位)
configs.put("batch.size", 16384);
//生产者可用于缓冲等待发送到服务器的记录的总内存字节数(以字节为单位)
configs.put("buffer-memory", 33554432);
//生产者producer要求leader节点在考虑完成请求之前收到的确认数,用于控制发送记录在服务端的持久化
//acks=0,设置为0,则生产者producer将不会等待来自服务器的任何确认.该记录将立即添加到套接字(socket)缓冲区并视为已发送.在这种情况下,无法保证服务器已收到记录,并且重试配置(retries)将不会生效(因为客户端通常不会知道任何故障),每条记录返回的偏移量始终设置为-1.
//acks=1,设置为1,leader节点会把记录写入本地日志,不需要等待所有follower节点完全确认就会立即应答producer.在这种情况下,在follower节点复制前,leader节点确认记录后立即失败的话,记录将会丢失.
//acks=all,acks=-1,leader节点将等待所有同步复制副本完成再确认记录,这保证了只要至少有一个同步复制副本存活,记录就不会丢失.
configs.put("acks", "-1");
//指定key使用的序列化类
Serializer keySerializer = new StringSerializer();
//指定value使用的序列化类
Serializer valueSerializer = new StringSerializer();
//创建Kafka生产者
KafkaProducer kafkaProducer = new KafkaProducer(configs, keySerializer, valueSerializer);
return kafkaProducer;
}
}

14
cloud-common/cloud-common-kafka/src/main/java/com/muyu/common/kafka/constants/KafkaConstants.java 100644
View File

@ -0,0 +1,14 @@
package com.muyu.common.kafka.constants;
/**
* @Author: 胡杨
* @date: 2024/7/10
* @Description: kafka常量
* @Version 1.0.0
*/
public class KafkaConstants {
public final static String KafkaTopic = "kafka_topic2";
public final static String KafkaGrop = "kafka_grop2";
}

2
cloud-common/cloud-common-kafka/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 100644
View File

@ -0,0 +1,2 @@
com.muyu.common.kafka.config.KafkaConsumerConfig
com.muyu.common.kafka.config.KafkaProviderConfig

4
cloud-common/cloud-common-log/src/main/java/com/muyu/common/log/aspect/LogAspect.java
View File

@ -18,7 +18,7 @@ import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.core.NamedThreadLocal;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
@ -48,7 +48,7 @@ public class LogAspect {
*/
private static final ThreadLocal<Long> TIME_THREADLOCAL = new NamedThreadLocal<Long>("Cost Time");
@Autowired
@Resource
private AsyncLogService asyncLogService;
/**

4
cloud-common/cloud-common-log/src/main/java/com/muyu/common/log/service/AsyncLogService.java
View File

@ -3,7 +3,7 @@ package com.muyu.common.log.service;
import com.muyu.common.core.constant.SecurityConstants;
import com.muyu.common.system.remote.RemoteLogService;
import com.muyu.common.system.domain.SysOperLog;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@ -14,7 +14,7 @@ import org.springframework.stereotype.Service;
*/
@Service
public class AsyncLogService {
@Autowired
@Resource
private RemoteLogService remoteLogService;
/**

6
cloud-common/cloud-common-rabbit/pom.xml
View File

@ -10,7 +10,9 @@
</parent>
<artifactId>cloud-common-rabbit</artifactId>
<description>
cloud-common-rabbit rabbit中间件模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
@ -32,4 +34,4 @@
</dependency>
</dependencies>
</project>
</project>

48
cloud-common/cloud-common-rabbit/src/main/java/com/muyu/common/rabbit/config/ConfirmCallbackConfig.java 100644
View File

@ -0,0 +1,48 @@
package com.muyu.common.rabbit.config;
import lombok.extern.log4j.Log4j2;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
* 消息发送确认配置
* 消息发送到交换机的回调
*/
@Component
@Log4j2
public class ConfirmCallbackConfig implements RabbitTemplate.ConfirmCallback {
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* @PostContruct是spring框架的注解，在⽅法上加该注解会在项⽬启动的时候执⾏该⽅法，也可以理解为在spring容器初始化的时候执
*/
@PostConstruct
public void init() {
rabbitTemplate.setConfirmCallback(this);
}
/**
* 交换机不管是否收到消息的一个回调方法
*
* @param correlationData 消息相关数据
* @param ack 交换机是否收到消息
* @param cause 失败原因
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
if (!ack) {
String exchange = correlationData.getReturned().getExchange();
String message = correlationData.getReturned().getMessage().getBody().toString();
// 发送异常
log.error("消息：{}，发送到交换机：{}失败，原因是：{}", message, exchange, cause);
// TODO 可以把异常信息 以及 消息的内容直接添加到 MYSQL
}
}
}

6
cloud-common/cloud-common-rabbit/src/main/java/com/muyu/common/rabbit/RabbitListenerConfigurer.java → cloud-common/cloud-common-rabbit/src/main/java/com/muyu/common/rabbit/config/RabbitListenerConfigurer.java
View File

@ -1,8 +1,8 @@
package com.muyu.common.rabbit;
package com.muyu.common.rabbit.config;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
@ -16,7 +16,7 @@ public class RabbitListenerConfigurer implements org.springframework.amqp.rabbit
}
//以下配置RabbitMQ消息服务
@Autowired
@Resource
public ConnectionFactory connectionFactory;

41
cloud-common/cloud-common-rabbit/src/main/java/com/muyu/common/rabbit/config/ReturnCallbackConfig.java 100644
View File

@ -0,0 +1,41 @@
package com.muyu.common.rabbit.config;
import lombok.extern.log4j.Log4j2;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
* 消息发送到队列的确认
*/
@Component
@Log4j2
public class ReturnCallbackConfig implements RabbitTemplate.ReturnsCallback {
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* @PostContruct是spring框架的注解，在⽅法上加该注解会在项⽬启动的时候执⾏该⽅法，也可以理解为在spring容器初始化的时候执
*/
@PostConstruct
public void init() {
rabbitTemplate.setReturnsCallback(this);
}
/**
* 消息发送失败 则会执行这个方法
*
* @param returnedMessage the returned message and metadata.
*/
@Override
public void returnedMessage(ReturnedMessage returnedMessage) {
log.error("消息：{}，被交换机：{} 回退！退回原因为：{}",
returnedMessage.getMessage().toString(), returnedMessage.getExchange(), returnedMessage.getReplyText());
// TODO 回退了所有的信息，可做补偿机制
}
}

15
cloud-common/cloud-common-rabbit/src/main/java/com/muyu/common/rabbit/constants/RabbitConstants.java 100644
View File

@ -0,0 +1,15 @@
package com.muyu.common.rabbit.constants;
/**
* rabbit常量
* @Author: 胡杨
* @date: 2024/7/10
* @Description: rabbit常量
* @Version 1.0.0
*/
public class RabbitConstants {
public final static String GO_ONLINE_QUEUE= "GoOnline";
public final static String DOWNLINE_QUEUE= "Downline";
}

4
cloud-common/cloud-common-rabbit/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
View File

@ -1 +1,3 @@
com.muyu.common.rabbit.RabbitListenerConfigurer
com.muyu.common.rabbit.config.RabbitListenerConfigurer
com.muyu.common.rabbit.config.ConfirmCallbackConfig
com.muyu.common.rabbit.config.ReturnCallbackConfig

4
cloud-common/cloud-common-redis/src/main/java/com/muyu/common/redis/service/RedisService.java
View File

@ -1,6 +1,6 @@
package com.muyu.common.redis.service;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
@ -18,7 +18,7 @@ import java.util.concurrent.TimeUnit;
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisService {
@Autowired
@Resource
public RedisTemplate redisTemplate;
/**

36
cloud-common/cloud-common-saas/pom.xml 100644
View File

@ -0,0 +1,36 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>cloud-common</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>cloud-common-saas</artifactId>
<description>
cloud-common-saas saas数据源切换模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- 多数据源依赖 -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-datasource</artifactId>
</dependency>
<!-- 鉴权依赖 -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-security</artifactId>
</dependency>
</dependencies>
</project>

105
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/many/datasource/ManyDataSource.java 100644
View File

@ -0,0 +1,105 @@
package com.muyu.cloud.common.many.datasource;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.autoconfigure.MybatisPlusAutoConfiguration;
import com.muyu.cloud.common.saas.domain.model.EntInfo;
import com.muyu.cloud.common.many.datasource.factory.DruidDataSourceFactory;
import com.muyu.cloud.common.many.datasource.domain.model.DataSourceInfo;
import com.muyu.cloud.common.many.datasource.role.DynamicDataSource;
import com.muyu.cloud.common.saas.exception.SaaSException;
import com.muyu.common.core.domain.Result;
import com.muyu.common.core.utils.SpringUtils;
import com.muyu.common.system.domain.SysEnt;
import com.muyu.common.system.remote.RemoteUserService;
import lombok.extern.log4j.Log4j2;
import org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import java.util.*;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: 多数据源
* @Version: 1.0
*/
@Log4j2
@AutoConfiguration(before = {MybatisPlusAutoConfiguration.class, MybatisAutoConfiguration.class})
@Component
public class ManyDataSource implements ApplicationRunner{
private List<EntInfo> dataSourceInfoList(){
RemoteUserService remoteUserService = SpringUtils.getBean(RemoteUserService.class);
Result<List<SysEnt>> listResult = remoteUserService.list(new SysEnt());
if (listResult==null){
throw new SaaSException("saas远调数据源错误");
}
List<SysEnt> data = listResult.getData();
System.out.println(data);
if (listResult.getCode() == Result.SUCCESS && data !=null){
List<EntInfo> list = new ArrayList<>();
for (SysEnt row : data) {
list.add(
EntInfo.builder()
.entCode(row.getEntCode())
.dbName(row.getDbName())
.ip(row.getIp())
.port(row.getPort())
.userName(row.getUserName())
.password(row.getPassword())
.build()
);
}
return list;
}else {
log.error("远调数据源错误,远调数据为：{}", JSON.toJSONString(listResult));
return null;
}
}
@Bean
public DynamicDataSource dynamicDataSource(DruidDataSourceFactory druidDataSourceFactory) {
// 企业列表 企业CODE，端口，IP
Map<Object, Object> dataSourceMap = new HashMap<>();
Objects.requireNonNull(dataSourceInfoList())
.stream()
.map(DataSourceInfo::hostAndPortBuild)
.forEach(dataSourceInfo -> {
dataSourceMap.put(dataSourceInfo.getKey(), druidDataSourceFactory.create(dataSourceInfo));
});
//设置动态数据源
DynamicDataSource dynamicDataSource = new DynamicDataSource();
// dynamicDataSource.setDefaultTargetDataSource(masterDataSource());
dynamicDataSource.setTargetDataSources(dataSourceMap);
//将数据源信息备份在defineTargetDataSources中
dynamicDataSource.setDefineTargetDataSources(dataSourceMap);
log.info("动态数据源加载完成,持有key：{}",dynamicDataSource.getKeys());
return dynamicDataSource;
}
@Override
public void run(ApplicationArguments args) {
DruidDataSourceFactory druidDataSourceFactory = SpringUtils.getBean(DruidDataSourceFactory.class);
DynamicDataSource dynamicDataSource = SpringUtils.getBean(DynamicDataSource.class);
for (EntInfo entInfo : dataSourceInfoList()) {
DataSourceInfo dataSourceInfo = DataSourceInfo.hostAndPortBuild(entInfo);
DruidDataSource druidDataSource = druidDataSourceFactory.create(dataSourceInfo);
dynamicDataSource.put(dataSourceInfo.getKey(), druidDataSource);
log.info("存储数据连接池为：key:{}",dataSourceInfo.getKey());
}
}
// @Bean
// public SqlSessionFactory sqlSessionFactory(DynamicDataSource dataSource) throws Exception {
// SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
// sessionFactory.setDataSource(dataSource);
// return sessionFactory.getObject();
// }
}

19
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/many/datasource/constents/DatasourceContent.java 100644
View File

@ -0,0 +1,19 @@
package com.muyu.cloud.common.many.datasource.constents;
/**
* @author DongZl
* @description: 数据源常量
* @Date 2023-8-1 上午 11:02
*/
public class DatasourceContent {
public final static String DATASOURCE_URL = "jdbc:mysql://{}:{}/{}?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8";
public final static String USER_NAME = "root";
public final static String PASSWORD = "bawei2112A";
public final static String IP = "127.0.0.1";
public final static Integer PORT = 3306;
}

60
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/many/datasource/domain/model/DataSourceInfo.java 100644
View File

@ -0,0 +1,60 @@
package com.muyu.cloud.common.many.datasource.domain.model;
import com.muyu.cloud.common.many.datasource.constents.DatasourceContent;
import com.muyu.cloud.common.saas.domain.model.EntInfo;
import com.muyu.common.core.utils.StringUtils;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author DongZl
* @description: 数据源实体类
* @Date 2023-8-1 上午 11:15
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DataSourceInfo {
/**
* 键
*/
private String key;
/**
* 地址
*/
private String url;
/**
* 用户名
*/
private String userName;
/**
* 密码
*/
private String password;
// public static DataSourceInfo hostAndPortBuild(String key, String host, Integer port) {
// return DataSourceInfo.builder()
// .key(key)
// .url(StringUtils.format(DatasourceContent.DATASOURCE_URL, host, port, key))
// .password(DatasourceContent.PASSWORD)
// .userName(DatasourceContent.USER_NAME)
// .build();
// }
public static DataSourceInfo hostAndPortBuild(EntInfo entInfo) {
return DataSourceInfo.builder()
.key(entInfo.getEntCode())
.url(StringUtils.format(DatasourceContent.DATASOURCE_URL, entInfo.getIp(), entInfo.getPort(), entInfo.getDbName()))
.userName(entInfo.getUserName())
.password(entInfo.getPassword())
.build();
}
}

41
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/many/datasource/factory/DruidDataSourceFactory.java 100644
View File

@ -0,0 +1,41 @@
package com.muyu.cloud.common.many.datasource.factory;
import com.alibaba.druid.pool.DruidDataSource;
import com.muyu.cloud.common.many.datasource.domain.model.DataSourceInfo;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Component;
import java.sql.SQLException;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: Druid工厂
* @Version: 1.0
*/
@Log4j2
@Component
public class DruidDataSourceFactory {
/**
* @Description: 根据传递的数据源信息测试数据库连接
* @Author Dongzl
*/
public DruidDataSource create(DataSourceInfo dataSourceInfo) {
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setUrl(dataSourceInfo.getUrl());
druidDataSource.setConnectTimeout(10000);
druidDataSource.setUsername(dataSourceInfo.getUserName());
druidDataSource.setPassword(dataSourceInfo.getPassword());
druidDataSource.setBreakAfterAcquireFailure(true);
druidDataSource.setConnectionErrorRetryAttempts(0);
try {
druidDataSource.getConnection(2000);
log.info("{} -> 数据源连接成功", dataSourceInfo.getKey());
return druidDataSource;
} catch (SQLException throwables) {
log.error("数据源 {} 连接失败,用户名：{}，密码 {}, 原因:{}",dataSourceInfo.getUrl(),dataSourceInfo.getUserName(),dataSourceInfo.getPassword(), throwables);
return null;
}
}
}

42
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/many/datasource/holder/DynamicDataSourceHolder.java 100644
View File

@ -0,0 +1,42 @@
package com.muyu.cloud.common.many.datasource.holder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.Assert;
/**
* 数据源切换处理
*
* @author Dongzl
*/
@Slf4j
public class DynamicDataSourceHolder {
/**
* 保存动态数据源名称
*/
private static final ThreadLocal<String> DYNAMIC_DATASOURCE_KEY = new ThreadLocal<>();
/**
* 设置/切换数据源，决定当前线程使用哪个数据源
*/
public static void setDynamicDataSourceKey(String key){
log.info("数据源切换为：{}",key);
DYNAMIC_DATASOURCE_KEY.set(key);
}
/**
* 获取动态数据源名称，默认使用mater数据源
*/
public static String getDynamicDataSourceKey(){
String key = DYNAMIC_DATASOURCE_KEY.get();
Assert.notNull(key, "请携带数据标识");
return key;
}
/**
* 移除当前数据源
*/
public static void removeDynamicDataSourceKey(){
log.info("移除数据源：{}",DYNAMIC_DATASOURCE_KEY.get());
DYNAMIC_DATASOURCE_KEY.remove();
}
}

66
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/many/datasource/role/DynamicDataSource.java 100644
View File

@ -0,0 +1,66 @@
package com.muyu.cloud.common.many.datasource.role;
import com.alibaba.druid.pool.DruidDataSource;
import com.muyu.cloud.common.many.datasource.holder.DynamicDataSourceHolder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import java.util.List;
import java.util.Map;
/**
* 动态数据源
* 调用AddDefineDataSource组件的addDefineDynamicDataSource（）方法，获取原来targetdatasources的map，并将新的数据源信息添加到map中，并替换targetdatasources中的map
* 切换数据源时可以使用@DataSource(value = "数据源名称")，或者DynamicDataSourceContextHolder.setContextKey("数据源名称")
* @author Dongzl
*/
@EqualsAndHashCode(callSuper = true)
@Data
@Slf4j
@AllArgsConstructor
@NoArgsConstructor
public class DynamicDataSource extends AbstractRoutingDataSource {
/**
* 备份所有数据源信息 备份的是个 指针 ！！！
*/
private Map<Object, Object> defineTargetDataSources;
/**
* 判定键是否出站了
* @param key 键
* @return 存在结果 true存在 false不存在
*/
public boolean hashKey(String key){
return defineTargetDataSources.containsKey(key);
}
/**
* 添加数据库
* @param key 键
* @param value 数据源
*/
public void put(String key, DruidDataSource value) {
if (value!=null) {
defineTargetDataSources.put(key, value);
this.afterPropertiesSet();
}else{
log.warn("Key为 {} 的数据源为空!",key);
}
}
/**
* 决定当前线程使用哪个数据源
*/
@Override
protected Object determineCurrentLookupKey() {
return DynamicDataSourceHolder.getDynamicDataSourceKey();
}
public List<Object> getKeys() {
return defineTargetDataSources.keySet().stream().toList();
}
}

12
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/saas/contents/SaaSConstant.java 100644
View File

@ -0,0 +1,12 @@
package com.muyu.cloud.common.saas.contents;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: SAAS常量
* @Version: 1.0
*/
public class SaaSConstant {
public final static String SAAS_KEY = "ent-code";
}

31
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/saas/domain/model/EntInfo.java 100644
View File

@ -0,0 +1,31 @@
package com.muyu.cloud.common.saas.domain.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: 企业信息
* @Version: 1.0
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class EntInfo {
private String entCode;
private String ip;
private Integer port;
private String dbName;
private String userName;
private String password;
}

28
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/saas/exception/SaaSException.java 100644
View File

@ -0,0 +1,28 @@
package com.muyu.cloud.common.saas.exception;
import com.muyu.common.core.exception.ServiceException;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: SaaS异常类
* @Version: 1.0
*/
public class SaaSException extends ServiceException {
public SaaSException (String message, Integer code) {
super(message, code);
}
public SaaSException (String message) {
super(message);
}
/**
* 空构造方法，避免反序列化问题
*/
public SaaSException () {
super();
}
}

57
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/saas/interceptor/SaaSInterceptor.java 100644
View File

@ -0,0 +1,57 @@
package com.muyu.cloud.common.saas.interceptor;
import com.alibaba.fastjson2.JSONObject;
import com.muyu.cloud.common.saas.contents.SaaSConstant;
import com.muyu.cloud.common.many.datasource.holder.DynamicDataSourceHolder;
import com.muyu.cloud.common.saas.exception.SaaSException;
import com.muyu.cloud.common.many.datasource.role.DynamicDataSource;
import com.muyu.common.core.context.SecurityContextHolder;
import com.muyu.common.core.utils.ServletUtils;
import com.muyu.common.core.utils.SpringUtils;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.AsyncHandlerInterceptor;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: SAAS拦截器
* @Version: 1.0
*/
@Slf4j
public class SaaSInterceptor implements AsyncHandlerInterceptor {
/**
* 之前
*/
@Override
public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (!(handler instanceof HandlerMethod)) {
return true;
}
String saasKey = ServletUtils.getHeader(request, SaaSConstant.SAAS_KEY);
log.info("访问路径：{}，携带SaaSKey：{}",request.getRequestURI(),saasKey);
if (saasKey == null) {
throw new SaaSException("SaaS非法访问");
}else {
DynamicDataSource dynamicDataSource = SpringUtils.getBean(DynamicDataSource.class);
if (!dynamicDataSource.hashKey(saasKey)){
throw new SaaSException("SaaS非法访问");
}
}
DynamicDataSourceHolder.setDynamicDataSourceKey(saasKey);
return true;
}
/**
* 之后
*/
@Override
public void afterConcurrentHandlingStarted (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
DynamicDataSourceHolder.removeDynamicDataSourceKey();
}
}

31
cloud-common/cloud-common-saas/src/main/java/com/muyu/cloud/common/saas/interceptor/WebMvcSaaSConfig.java 100644
View File

@ -0,0 +1,31 @@
package com.muyu.cloud.common.saas.interceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* 拦截器配置
*
* @author muyu
*/
public class WebMvcSaaSConfig implements WebMvcConfigurer {
/**
* 不需要拦截的地址
*/
public static final String[] EXCLUDE_URLS = {"/user/info", "/login", "/logout", "/refresh"};
@Override
public void addInterceptors (InterceptorRegistry registry) {
registry.addInterceptor(getHeaderInterceptor())
.addPathPatterns("/**")
.excludePathPatterns(EXCLUDE_URLS)
.order(-10);
}
/**
* 自定义请求头拦截器
*/
public SaaSInterceptor getHeaderInterceptor () {
return new SaaSInterceptor();
}
}

3
cloud-common/cloud-common-saas/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 100644
View File

@ -0,0 +1,3 @@
com.muyu.cloud.common.saas.interceptor.WebMvcSaaSConfig
com.muyu.cloud.common.many.datasource.ManyDataSource
com.muyu.cloud.common.many.datasource.factory.DruidDataSourceFactory

1
cloud-common/cloud-common-security/src/main/java/com/muyu/common/security/interceptor/HeaderInterceptor.java
View File

@ -28,6 +28,7 @@ public class HeaderInterceptor implements AsyncHandlerInterceptor {
}
SecurityContextHolder.setUserId(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USER_ID));
SecurityContextHolder.setSaasKey(ServletUtils.getHeader(request, SecurityConstants.SAAS_KEY));
SecurityContextHolder.setUserName(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USERNAME));
SecurityContextHolder.setUserKey(ServletUtils.getHeader(request, SecurityConstants.USER_KEY));

7
cloud-common/cloud-common-security/src/main/java/com/muyu/common/security/service/TokenService.java
View File

@ -12,7 +12,7 @@ import com.muyu.common.security.utils.SecurityUtils;
import com.muyu.common.system.domain.LoginUser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import jakarta.servlet.http.HttpServletRequest;
@ -34,7 +34,7 @@ public class TokenService {
private final static long expireTime = CacheConstants.EXPIRATION;
private final static String ACCESS_TOKEN = CacheConstants.LOGIN_TOKEN_KEY;
@Autowired
@Resource
private RedisService redisService;
/**
@ -55,10 +55,11 @@ public class TokenService {
claimsMap.put(SecurityConstants.USER_KEY, token);
claimsMap.put(SecurityConstants.DETAILS_USER_ID, userId);
claimsMap.put(SecurityConstants.DETAILS_USERNAME, userName);
claimsMap.put(SecurityConstants.SAAS_KEY,loginUser.getSysUser().getFirmCode());
// 接口返回信息
Map<String, Object> rspMap = new HashMap<String, Object>();
rspMap.put("access_token", JwtUtils.createToken(claimsMap));
rspMap.put("ent_code", loginUser.getSysUser().getFirmCode());
rspMap.put("expires_in", expireTime);
return rspMap;
}

4
cloud-common/cloud-common-security/src/main/java/com/muyu/common/security/utils/SecurityUtils.java
View File

@ -30,6 +30,10 @@ public class SecurityUtils {
return SecurityContextHolder.getUserName();
}
public static String getSaasKey () {
return SecurityContextHolder.getSaasKey();
}
/**
* 获取用户key
*/

2
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/LoginUser.java
View File

@ -63,4 +63,6 @@ public class LoginUser implements Serializable {
*/
private SysUser sysUser;
}

2
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysDept.java
View File

@ -34,6 +34,8 @@ public class SysDept extends BaseEntity {
*/
private Long parentId;
private String firmCode;
/**
* 祖级列表
*/

37
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysEnt.java 100644
View File

@ -0,0 +1,37 @@
package com.muyu.common.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @Author: DongZeLiang
* @date: 2024/6/3
* @Description: 企业信息
* @Version: 1.0
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@TableName("sys_ent")
public class SysEnt {
@TableId( type = IdType.AUTO)
private Integer id;
private String entCode;
private String ip;
private Integer port;
private String dbName;
private String userName;
private String password;
}

25
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysFirmUser.java 100644
View File

@ -0,0 +1,25 @@
package com.muyu.common.system.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @Author WangXin
* @Data 2024/9/18
* @Description 企业用户
* @Version 1.0.0
*/
@EqualsAndHashCode(callSuper = true)
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class SysFirmUser extends SysUser {
/**
* 用户数据库
*/
private String databaseName;
}

2
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysRole.java
View File

@ -36,6 +36,8 @@ public class SysRole extends BaseEntity {
@Excel(name = "角色名称")
private String roleName;
private String firmCode;
/**
* 角色权限
*/

15
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysUser.java
View File

@ -1,5 +1,8 @@
package com.muyu.common.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.muyu.common.core.annotation.Excel;
import com.muyu.common.core.annotation.Excel.ColumnType;
import com.muyu.common.core.annotation.Excel.Type;
@ -28,6 +31,7 @@ import java.util.List;
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@TableName("sys_user")
public class SysUser extends BaseEntity {
private static final long serialVersionUID = 1L;
@ -35,8 +39,11 @@ public class SysUser extends BaseEntity {
* 用户ID
*/
@Excel(name = "用户序号", cellType = ColumnType.NUMERIC, prompt = "用户编号")
@TableId(type = IdType.AUTO)
private Long userId;
private Integer isAdmin;
/**
* 部门ID
*/
@ -49,6 +56,9 @@ public class SysUser extends BaseEntity {
@Excel(name = "登录名称")
private String userName;
private String firmCode;
/**
* 用户昵称
*/
@ -135,6 +145,8 @@ public class SysUser extends BaseEntity {
*/
private Long roleId;
public SysUser (Long userId) {
this.userId = userId;
}
@ -143,8 +155,9 @@ public class SysUser extends BaseEntity {
return userId != null && 1L == userId;
}
public boolean isAdmin () {
return isAdmin(this.userId);
return isAdmin(this.userId) || (this.isAdmin != null && this.isAdmin == 1);
}
@Xss(message = "用户昵称不能包含脚本字符")

28
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysUserPost.java 100644
View File

@ -0,0 +1,28 @@
package com.muyu.common.system.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 用户和岗位关联 sys_user_post
*
* @author muyu
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SysUserPost {
/**
* 用户ID
*/
private Long userId;
/**
* 岗位ID
*/
private Long postId;
}

27
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysUserRole.java 100644
View File

@ -0,0 +1,27 @@
package com.muyu.common.system.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 用户和角色关联 sys_user_role
*
* @author muyu
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SysUserRole {
/**
* 用户ID
*/
private Long userId;
/**
* 角色ID
*/
private Long roleId;
}

32
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/remote/RemoteSaasService.java 100644
View File

@ -0,0 +1,32 @@
package com.muyu.common.system.remote;
import com.muyu.common.core.constant.SecurityConstants;
import com.muyu.common.core.constant.ServiceNameConstants;
import com.muyu.common.core.domain.Result;
import com.muyu.common.system.domain.SysUser;
import com.muyu.common.system.remote.factory.RemoteSaasFallbackFactory;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
/**
* 文件服务
*
* @author muyu
*/
@FeignClient(contextId = "remoteSaasService", value = ServiceNameConstants.SAAS_SERVICE, fallbackFactory = RemoteSaasFallbackFactory.class)
public interface RemoteSaasService {
/**
* 通过用户名查询用户信息
*
* @param firmCode
* @param userName 用户名
* @param source 请求来源
* @return 结果
*/
@GetMapping("/user/info")
public Result<SysUser> getUserInfo (@RequestParam("firmCode") String firmCode, @RequestParam("userName") String userName, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);
}

85
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/remote/RemoteUserService.java
View File

@ -3,12 +3,14 @@ package com.muyu.common.system.remote;
import com.muyu.common.core.constant.SecurityConstants;
import com.muyu.common.core.constant.ServiceNameConstants;
import com.muyu.common.core.domain.Result;
import com.muyu.common.system.domain.SysUser;
import com.muyu.common.system.domain.*;
import com.muyu.common.system.remote.factory.RemoteUserFallbackFactory;
import com.muyu.common.system.domain.LoginUser;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Set;
/**
* 用户服务
*
@ -16,16 +18,6 @@ import org.springframework.web.bind.annotation.*;
*/
@FeignClient(contextId = "remoteUserService", value = ServiceNameConstants.SYSTEM_SERVICE, fallbackFactory = RemoteUserFallbackFactory.class)
public interface RemoteUserService {
/**
* 通过用户名查询用户信息
*
* @param username 用户名
* @param source 请求来源
*
* @return 结果
*/
@GetMapping("/user/info/{username}")
public Result<LoginUser> getUserInfo (@PathVariable("username") String username, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);
/**
* 注册用户信息
@ -37,4 +29,73 @@ public interface RemoteUserService {
*/
@PostMapping("/user/register")
public Result<Boolean> registerUserInfo (@RequestBody SysUser sysUser, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);
@GetMapping("/user/companyList")
public Result<List<SysUser>> companyList ();
@PostMapping("/ent/list")
public Result<List<SysEnt>> list (@RequestBody SysEnt sysEnt);
/**
* 通过用户名查询用户信息
*
* @param firmCode
* @param userName 用户名
* @param source 请求来源
* @return 结果
*/
@GetMapping("/user/info")
public Result<LoginUser> getUserInfo (@RequestParam("firmCode") String firmCode, @RequestParam("userName") String userName, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);
/**
* 获取角色数据权限
*
* @param user 用户
*
* @return 角色权限信息
*/
@PostMapping("/permission/getRole")
public Set<String> getRolePermission (@RequestBody SysUser user);
/**
* 获取菜单数据权限
*
* @param user 用户
*
* @return 菜单权限信息
*/
@PostMapping("/permission/getMenu")
public Set<String> getMenuPermission (@RequestBody SysUser user);
/**
* 根据部门编号获取详细信息
*/
@GetMapping(value = "/dept/{deptId}")
public Result<SysDept> selectDeptById (@PathVariable("deptId") Long deptId);
/**
* 新增用户角色信息
*
* @param user 用户对象
*/
@PostMapping("/user/insertUserRole")
public void insertUserRole (@RequestBody SysUser user);
/**
* 新增用户岗位信息
*
* @param user 用户对象
*/
@PostMapping("/user/insertUserPost")
public void insertUserPost (@RequestBody SysUser user);
/**
* 注册用户
*/
@PostMapping("/user")
public Result addUser (@RequestBody SysUser user);
}

36
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/remote/factory/RemoteSaasFallbackFactory.java 100644
View File

@ -0,0 +1,36 @@
package com.muyu.common.system.remote.factory;
/**
* @Author: 胡杨
* @Name: RemoteEntFallbackFactory
* @Description:
* @CreatedDate: 2024/9/20 下午3:11
* @FilePath: com.muyu.common.system.remote
*/
import com.muyu.common.core.domain.Result;
import com.muyu.common.system.domain.SysUser;
import com.muyu.common.system.remote.RemoteSaasService;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* @Author: 胡杨
* @Name: RemoteEntFallbackFactory
* @Description:
* @CreatedDate: 2024/9/20 下午3:11
* @FilePath: com.muyu.common.system.remote
*/
@Component
public class RemoteSaasFallbackFactory implements FallbackFactory<RemoteSaasService> {
@Override
public RemoteSaasService create(Throwable cause) {
return new RemoteSaasService() {
@Override
public Result<SysUser> getUserInfo(String firmCode, String username, String source) {
return Result.error("获取用户失败:" + cause.getMessage());
}
};
}
}

57
cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/remote/factory/RemoteUserFallbackFactory.java
View File

@ -1,14 +1,17 @@
package com.muyu.common.system.remote.factory;
import com.muyu.common.core.domain.Result;
import com.muyu.common.core.web.page.TableDataInfo;
import com.muyu.common.system.domain.*;
import com.muyu.common.system.remote.RemoteUserService;
import com.muyu.common.system.domain.SysUser;
import com.muyu.common.system.domain.LoginUser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Set;
/**
* 用户服务降级处理
*
@ -22,15 +25,57 @@ public class RemoteUserFallbackFactory implements FallbackFactory<RemoteUserServ
public RemoteUserService create (Throwable throwable) {
log.error("用户服务调用失败:{}", throwable.getMessage());
return new RemoteUserService() {
@Override
public Result<LoginUser> getUserInfo (String username, String source) {
return Result.error("获取用户失败:" + throwable.getMessage());
}
@Override
public Result<Boolean> registerUserInfo (SysUser sysUser, String source) {
return Result.error("注册用户失败:" + throwable.getMessage());
}
@Override
public Result<List<SysUser>> companyList() {
return Result.error("获取企业列表失败:" + throwable.getMessage());
}
@Override
public Result<List<SysEnt>> list(SysEnt sysEnt) {
return Result.error("获取企业列表失败:" + throwable.getMessage());
}
@Override
public Result<LoginUser> getUserInfo(String firmCode, String userName, String source) {
return Result.error("获取用户信息失败:" + throwable.getMessage());
}
@Override
public Set<String> getRolePermission(SysUser user) {
return Set.of();
}
@Override
public Set<String> getMenuPermission(SysUser user) {
return Set.of();
}
@Override
public Result<SysDept> selectDeptById(Long deptId) {
return Result.error();
}
@Override
public void insertUserRole(SysUser user) {
log.warn("新增用户角色失败!");
}
@Override
public void insertUserPost(SysUser user) {
log.warn("新增用户权限失败!");
}
@Override
public Result addUser(SysUser user) {
return Result.error(throwable);
}
};
}
}

1
cloud-common/cloud-common-system/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
View File

@ -1,3 +1,4 @@
com.muyu.common.system.remote.factory.RemoteUserFallbackFactory
com.muyu.common.system.remote.factory.RemoteLogFallbackFactory
com.muyu.common.system.remote.factory.RemoteFileFallbackFactory
com.muyu.common.system.remote.factory.RemoteSaasFallbackFactory

4
cloud-common/cloud-common-xxl/src/main/java/com/muyu/common/xxl/XXLJobConfig.java
View File

@ -7,9 +7,9 @@ import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
@Log4j2
@Component
//@Component
public class XXLJobConfig {
@Bean
// @Bean
public XxlJobSpringExecutor xxlJobExecutor(XxlJobProperties xxlJobProperties) {
if (StringUtils.isEmpty(xxlJobProperties.getAdminAddresses())){
throw new RuntimeException("请在bootstrap.yml当中配置shared-configs项，xxl-job共享配置[application-xxl-config]");

4
cloud-common/pom.xml
View File

@ -20,6 +20,10 @@
<module>cloud-common-system</module>
<module>cloud-common-xxl</module>
<module>cloud-common-rabbit</module>
<module>cloud-common-saas</module>
<module>cloud-common-caffeine</module>
<module>cloud-common-kafka</module>
<module>cloud-common-iotdb</module>
</modules>
<artifactId>cloud-common</artifactId>

155
cloud-data-processing/pom.xml 100644
View File

@ -0,0 +1,155 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>cloud-server</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>cloud-data-processing</artifactId>
<description>
cloud-data-processing 数据处理模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-kafka</artifactId>
</dependency>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-caffeine</artifactId>
</dependency>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-rabbit</artifactId>
</dependency>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-iotdb</artifactId>
<version>3.6.3</version>
</dependency>
<!-- SpringCloud Alibaba Nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- SpringCloud Alibaba Nacos Config -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!-- SpringCloud Alibaba Sentinel -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!-- SpringBoot Actuator -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!-- Mysql Connector -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<!-- MuYu Common DataScope -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-datascope</artifactId>
</dependency>
<dependency>
<groupId>com.muyu</groupId>
<artifactId>cloud-common-datasource</artifactId>
</dependency>
<!-- <dependency>-->
<!-- <groupId>org.apache.iotdb</groupId>-->
<!-- <artifactId>iotdb-jdbc</artifactId>-->
<!-- <version>0.12.1</version>-->
<!-- </dependency>-->
<!-- <dependency>-->
<!-- <groupId>com.alibaba</groupId>-->
<!-- <artifactId>druid-spring-boot-starter</artifactId>-->
<!-- <version>1.2.20</version>-->
<!-- </dependency>-->
<!-- <dependency>-->
<!-- <groupId>org.mybatis</groupId>-->
<!-- <artifactId>mybatis-spring</artifactId>-->
<!-- <version>3.0.3</version>-->
<!-- </dependency>-->
<!-- <dependency>-->
<!-- <groupId>com.baomidou</groupId>-->
<!-- <artifactId>mybatis-plus-boot-starter</artifactId>-->
<!-- <version>3.5.5</version>-->
<!-- </dependency>-->
<!--&lt;!&ndash; <dependency>&ndash;&gt;-->
<!--&lt;!&ndash; <groupId>org.apache.iotdb</groupId>&ndash;&gt;-->
<!--&lt;!&ndash; <artifactId>iotdb-session</artifactId>&ndash;&gt;-->
<!--&lt;!&ndash; <version>1.3.2</version>&ndash;&gt;-->
<!--&lt;!&ndash; </dependency>&ndash;&gt;-->
<!-- &lt;!&ndash; Druid &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>com.alibaba</groupId>-->
<!-- <artifactId>druid-spring-boot-3-starter</artifactId>-->
<!-- <version>${druid.version}</version>-->
<!-- </dependency>-->
<!-- &lt;!&ndash; Dynamic DataSource &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>com.baomidou</groupId>-->
<!-- <artifactId>dynamic-datasource-spring-boot3-starter</artifactId>-->
<!-- <version>${dynamic-ds.version}</version>-->
<!-- </dependency>-->
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

32
cloud-data-processing/src/main/java/com/muyu/data/processing/MyDataApplication.java 100644
View File

@ -0,0 +1,32 @@
package com.muyu.data.processing;
import com.muyu.common.kafka.constants.KafkaConstants;
import com.muyu.common.security.annotation.EnableCustomConfig;
import com.muyu.common.security.annotation.EnableMyFeignClients;
import jakarta.annotation.PostConstruct;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
/**
* 数据处理模块启动器
* @Author: 胡杨
* @Name: MyData
* @Description: 数据处理模块启动器
* @CreatedDate: 2024/9/26 下午7:31
* @FilePath: com.muyu.data.processing
*/
@EnableRabbit
@EnableCustomConfig
@EnableMyFeignClients
@SpringBootApplication(scanBasePackages = {"com.muyu"})
public class MyDataApplication {
public static void main(String[] args) {
SpringApplication.run(MyDataApplication.class, args);
System.out.println("MyData 模块启动成功!");
}
}

48
cloud-data-processing/src/main/java/com/muyu/data/processing/controller/DataProcessingController.java 100644
View File

@ -0,0 +1,48 @@
package com.muyu.data.processing.controller;
import com.muyu.common.core.domain.Result;
import com.muyu.data.processing.domain.IotDbData;
import com.muyu.data.processing.service.DataProcessingService;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.*;
import lombok.extern.slf4j.Slf4j;
import java.util.Date;
import java.util.List;
/**
* 数据处理控制层
*
* @Author: 胡杨
* @Name: DataProcessing
* @Description: 数据处理控制层
* @CreatedDate: 2024/9/28 下午3:53
* @FilePath: com.muyu.data.processing.controller
*/
@Slf4j
@RestController
@RequestMapping("/DataProcessing")
public class DataProcessingController {
@Resource
private DataProcessingService service;
/**
* 查看数据库有多少组
*
* @return
*/
@RequestMapping(value = "/selectStorageGroup", method = RequestMethod.GET)
public Result selectStorageGroup() {
List<String> v = service.selectStorageGroup();if (v.size() > 0) {v.forEach(x -> {
System.out.println("group------------------" + x.toString());
});
return Result.success(v);
} else {
return Result.error(false);
}
}
}

146
cloud-data-processing/src/main/java/com/muyu/data/processing/controller/TestController.java 100644
View File

@ -0,0 +1,146 @@
package com.muyu.data.processing.controller;
import com.muyu.common.caffeine.enums.CacheNameEnums;
import com.muyu.common.core.utils.uuid.UUID;
import com.muyu.common.iotdb.config.IotDBConfig;
import com.muyu.common.kafka.constants.KafkaConstants;
import com.muyu.common.rabbit.constants.RabbitConstants;
import jakarta.annotation.Resource;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
import lombok.extern.slf4j.Slf4j;
/**
* 测试控制层
* @Author: 胡杨
* @Name: Test
* @Description:
* @CreatedDate: 2024/9/27 上午10:54
* @FilePath: com.muyu.data.processing.controller
*/
@Slf4j
@RestController
@RequestMapping("/Test")
public class TestController {
@Resource
private KafkaProducer<String,String> kafkaProducer;
@Resource
private RabbitTemplate rabbitTemplate;
@Resource
private IotDBConfig iotDBConfig;
@Resource
private RedisTemplate<String,String> redisTemplate;
// @Resource
// private CaffeineCacheUtils cacheUtils;
@Resource
private CacheManager cacheManager;
@GetMapping("/testKafka")
public void sendMsg(@RequestParam("msg") String msg) {
try {
// 测试数据
String jsonString = """
[{
"key": "vin",
"label": "VIN码",
"type": "String",
"value": "vin131413534474"
},{
"key": "timestamp",
"label": "时间戳",
"type": "String",
"value": "1727534036893"
},{
"key": "latitude",
"label": "纬度",
"type": "String",
"value": "66.898"
},{
"key": "longitude",
"label": "经度",
"type": "String",
"value": "99.12"
}]""";
ProducerRecord<String, String> producerRecord = new ProducerRecord<>(KafkaConstants.KafkaTopic, jsonString);
kafkaProducer.send(producerRecord);
System.out.println("同步消息发送成功: " + jsonString);
} catch (Exception e) {
e.printStackTrace();
System.out.println("同步消息发送失败");
}
}
@GetMapping("/testRabbit/GoOnline")
public void testRabbitGoOnline(@RequestParam("msg") String msg) {
rabbitTemplate.convertAndSend(RabbitConstants.GO_ONLINE_QUEUE, msg, message -> {
message.getMessageProperties().setMessageId(UUID.randomUUID().toString().replace("-",""));
return message;
});
}
@GetMapping("/testRabbit/Downline")
public void testRabbitDownline(@RequestParam("msg") String msg) {
rabbitTemplate.convertAndSend(RabbitConstants.DOWNLINE_QUEUE, msg, message -> {
message.getMessageProperties().setMessageId(UUID.randomUUID().toString().replace("-",""));
return message;
});
}
@GetMapping("/insertData")
public void insertData(@RequestParam("deviceId") String deviceId, @RequestParam("time") long time, @RequestParam("value") double value) throws Exception {
String sql = String.format("insert into root.one.%s(timestamp, temperature) values (%d, %f)", deviceId, time, value);
iotDBConfig.iotSession().executeNonQueryStatement(sql);
}
@GetMapping("/testSetRedis")
public void testSetRedis(@RequestParam("key") String key,@RequestParam("value") String value) {
redisTemplate.opsForValue().set(key,value);
}
@GetMapping("/testGetCache")
public void testGetCache(@RequestParam("cacheName") String cacheName,@RequestParam("key") String key) {
Cache cache = cacheManager.getCache(cacheName);
if (cache != null) {
String v = cache.get(key,String.class);
log.info("缓存值为: {}",v);
}else {
log.info("无缓存");
}
}
@GetMapping("/textSetCache")
public void textSetCache(
@RequestParam("cacheName") String cacheName,
@RequestParam("key") String key,
@RequestParam("value") String value) {
Cache cache = cacheManager.getCache(cacheName);
if (cache != null){
cache.put(key, value);
log.info("设置缓存成功");
}else {
log.info("无缓存");
}
}
@GetMapping("/testDelCache")
public void testDelCache(@RequestParam("cacheName") String cacheName) {
if (!CacheNameEnums.isCode(cacheName)){
log.info("缓存分区不存在");
return;
}
Cache cache = cacheManager.getCache(cacheName);
if (cache != null) {
cache.invalidate();
log.info("删除缓存成功");
}else{
log.info("无缓存");
}
}
}

33
cloud-data-processing/src/main/java/com/muyu/data/processing/domain/IotDbData.java 100644
View File

@ -0,0 +1,33 @@
package com.muyu.data.processing.domain;
import com.muyu.common.core.web.domain.BaseEntity;
import lombok.*;
import lombok.experimental.SuperBuilder;
import java.util.Date;
/**
* 报文信息 时序实体类
*
* @Author: 胡杨
* @Name: DataProcessing
* @Description: 报文信息 时序实体类
* @CreatedDate: 2024/9/28 下午3:48
* @FilePath: com.muyu.data.processing.domain
*/
@EqualsAndHashCode(callSuper = true)
@Data
@ToString
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class IotDbData extends BaseEntity {
private long timestamp;
private String vin;
private String latitude;
private String longitude;
}

39
cloud-data-processing/src/main/java/com/muyu/data/processing/domain/KafkaData.java 100644
View File

@ -0,0 +1,39 @@
package com.muyu.data.processing.domain;
import com.muyu.common.core.enums.ClassType;
import lombok.*;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import java.io.Serializable;
/**
* 报文信息 时序实体类
*
* @Author: 胡杨
* @Name: DataProcessing
* @Description: 报文信息 时序实体类
* @CreatedDate: 2024/9/28 下午3:48
* @FilePath: com.muyu.data.processing.domain
*/
@Data
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class KafkaData implements Serializable {
private String key;
private String label;
private String value;
private String type;
// public void setValueClass() {
// Class<?> info = ClassType.getInfo(type);
// if (info.isInstance(value)){
// value = info.cast(value);
// }
// }
}

22
cloud-data-processing/src/main/java/com/muyu/data/processing/domain/Temporary1.java 100644
View File

@ -0,0 +1,22 @@
package com.muyu.data.processing.domain;
import lombok.*;
/**
* 临时类1
*
* @Author: 胡杨
* @Name: Temporary1
* @Description: 临时类1
* @CreatedDate: 2024/9/30 下午7:26
* @FilePath: com.muyu.data.processing.domain
*/
@Data
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Temporary1 {
private String test;
}

22
cloud-data-processing/src/main/java/com/muyu/data/processing/domain/Temporary2.java 100644
View File

@ -0,0 +1,22 @@
package com.muyu.data.processing.domain;
import lombok.*;
/**
* 临时类2
*
* @Author: 胡杨
* @Name: Temporary2
* @Description: 临时类2
* @CreatedDate: 2024/9/30 下午7:27
* @FilePath: com.muyu.data.processing.domain
*/
@Data
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Temporary2 {
private String test;
}

62
cloud-data-processing/src/main/java/com/muyu/data/processing/kafka/KafkaConsumerService.java 100644
View File

@ -0,0 +1,62 @@
package com.muyu.data.processing.kafka;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.nacos.shaded.com.google.common.collect.Lists;
import com.muyu.common.kafka.constants.KafkaConstants;
import com.muyu.data.processing.domain.KafkaData;
import com.muyu.data.processing.service.DataProcessingService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import java.time.Duration;
import java.util.Collection;
import java.util.List;
/**
* kafka消费者
* @Author: 胡杨
* @Name: KafkaConsumerService
* @Description: kafka消费者
* @CreatedDate: 2024/9/27 上午9:27
* @FilePath: com.muyu.data.processing.kafka
*/
@Slf4j
@Component
public class KafkaConsumerService implements InitializingBean {
@Resource
private KafkaConsumer kafkaConsumer;
@Resource
private DataProcessingService service;
@Override
public void afterPropertiesSet() throws Exception {
Thread thread = new Thread(() -> {
log.info("启动线程监听Topic: {}", KafkaConstants.KafkaTopic);
ThreadUtil.sleep(1000);
Collection<String> topics = Lists.newArrayList(KafkaConstants.KafkaTopic);
kafkaConsumer.subscribe(topics);
while (true) {
System.out.println("开始消费数据,等待中...");
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofMillis(1000));
for (ConsumerRecord consumerRecord : consumerRecords) {
//1.从ConsumerRecord中获取消费数据
String originalMsg = (String) consumerRecord.value();
log.info("从Kafka中消费的原始数据: " + originalMsg);
//2.把消费数据转换为DTO对象
List<KafkaData> dataList = JSONUtil.toList(originalMsg, KafkaData.class);
log.info("从Kafka中消费的实体数据: " + dataList);
service.strategyCheck(dataList);
}
}
});
thread.start();
}
}

32
cloud-data-processing/src/main/java/com/muyu/data/processing/mapper/DataProcessingMapper.java 100644
View File

@ -0,0 +1,32 @@
package com.muyu.data.processing.mapper;
import com.muyu.data.processing.domain.IotDbData;
import com.muyu.data.processing.domain.KafkaData;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 数据处理持久层
*
* @Author: 胡杨
* @Name: DataPeocessingMapper
* @Description: 数据处理持久层
* @CreatedDate: 2024/9/28 下午3:47
* @FilePath: com.muyu.data.processing.mapper
*/
@Repository
@Mapper
public interface DataProcessingMapper{
List<String> selectStorageGroup();
Integer insIotDbData(@Param("key") String key, @Param("value") String value);
void strategyCheck(@Param("dataList") List<KafkaData> dataList);
Integer insIotDbDataVo(IotDbData build);
}

73
cloud-data-processing/src/main/java/com/muyu/data/processing/rebbit/DownlineRabbitConsumer.java 100644
View File

@ -0,0 +1,73 @@
package com.muyu.data.processing.rebbit;
import com.muyu.common.rabbit.constants.RabbitConstants;
import com.rabbitmq.client.Channel;
import jakarta.annotation.Resource;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.HashSet;
/**
* 下线事件监听
* @Author: 胡杨
* @Name: DownlineRabbitConsumer
* @Description: 车辆下线监听器
* @CreatedDate: 2024/9/26 下午8:21
* @FilePath: com.muyu.data.processing.rebbit
*/
@Slf4j
@Component
@Setter
public class DownlineRabbitConsumer {
@Resource
private RedisTemplate<String,String> redisTemplate;
@Resource
private CacheManager cacheManager;
@RabbitListener(queuesToDeclare = {@Queue(RabbitConstants.DOWNLINE_QUEUE)})
public void downline(String vin, Message message, Channel channel) {
log.info("车辆 {} 下线, 配置信息准备中。。。",vin);
try {
// 重复性校验
Long add = redisTemplate.opsForSet().add(RabbitConstants.DOWNLINE_QUEUE, message.getMessageProperties().getMessageId());
if (add>0) {
deleteCarCache(vin);
log.info("车辆 {} 下线, 消息已确认。。。",vin);
} else {
log.info("车辆 {} 下线, 消息重复消费，已确认。。。",vin);
}
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
log.info("车辆 {} 下线, 配置信息已准备完毕。。。",vin);
} catch (IOException e) {
try {
log.warn("车辆 {} 下线, 配置信息准备失败，返回队列，原因：{}", vin, e.getMessage());
channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
} catch (IOException ex) {
log.warn("车辆 {} 下线, 消息返回队列失败，原因：{}", vin, ex.getMessage());
}
}
}
/**
* 车辆下线 - 删除缓存
*/
public void deleteCarCache(String vin) {
Cache cache = cacheManager.getCache(vin);
if (ObjectUtils.isNotEmpty(cache)){
cache.invalidate();
}
log.info("车辆编码:{},本地缓存删除完成...", vin);
}
}

76
cloud-data-processing/src/main/java/com/muyu/data/processing/rebbit/GoOnlineRabbitConsumer.java 100644
View File

@ -0,0 +1,76 @@
package com.muyu.data.processing.rebbit;
import com.muyu.common.rabbit.constants.RabbitConstants;
import com.rabbitmq.client.Channel;
import jakarta.annotation.Resource;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.List;
/**
* 上线事件监听
* @Author: 胡杨
* @Name: GoOnlineRabbitConsumer
* @Description: 上线事件
* @CreatedDate: 2024/9/26 下午7:38
* @FilePath: com.muyu.data.processing.rebbit
*/
@Slf4j
@Component
@Setter
public class GoOnlineRabbitConsumer {
@Resource
private RedisTemplate<String,String> redisTemplate;
@Resource
private CacheManager cacheManager;
@Value("#{'${cacheNames}'.split(',')}")
private List<String> cacheNames;
@RabbitListener(queuesToDeclare = {@Queue(RabbitConstants.GO_ONLINE_QUEUE)})
public void goOnline(String vin, Message message, Channel channel){
log.info("车辆 {} 上线, 配置信息准备中。。。",vin);
try {
// 重复性校验
Long add = redisTemplate.opsForSet().add(RabbitConstants.GO_ONLINE_QUEUE, message.getMessageProperties().getMessageId());
if (add>0) {
addCarCache(vin);
log.info("车辆 {} 上线, 消息已确认。。。",vin);
} else {
log.info("车辆 {} 上线, 消息重复消费，已确认。。。",vin);
}
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
log.info("车辆 {} 上线, 配置信息已准备完毕。。。",vin);
} catch (IOException e) {
try {
log.warn("车辆 {} 上线, 配置信息准备失败，返回队列，原因：{}", vin, e.getMessage());
channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
} catch (IOException ex) {
log.warn("车辆 {} 上线, 消息返回队列失败，原因：{}", vin, ex.getMessage());
}
}
}
/**
* 车辆上线 - 新增缓存
*/
public void addCarCache(String vin) {
// 从Redis中获取缓存信息
for (String name : cacheNames) {
String value = redisTemplate.opsForValue().get(name+":"+vin);
cacheManager.getCache(name).put(vin, value);
log.info("存储缓存, 缓存分区:[{}], 车辆编码:[{}], 存储值:[{}]", name, vin, value);
}
log.info("车辆编码:{},本地缓存完成...",vin);
}
}

31
cloud-data-processing/src/main/java/com/muyu/data/processing/service/DataProcessingService.java 100644
View File

@ -0,0 +1,31 @@
package com.muyu.data.processing.service;
import com.muyu.data.processing.domain.IotDbData;
import com.muyu.data.processing.domain.KafkaData;
import java.util.List;
/**
* 数据处理业务层
*
* @Author: 胡杨
* @Name: DataProcessing
* @Description: 数据处理业务层
* @CreatedDate: 2024/9/28 下午3:52
* @FilePath: com.muyu.data.processing.server
*/
public interface DataProcessingService{
/**
* 选择存储组
*
* @return {@link List }<{@link String }>
*/
List<String> selectStorageGroup();
void strategyCheck(List<KafkaData> dataList);
Integer insIotDbData(String key, String value);
}

65
cloud-data-processing/src/main/java/com/muyu/data/processing/service/impl/DataProcessingServiceImpl.java 100644
View File

@ -0,0 +1,65 @@
package com.muyu.data.processing.service.impl;
import javax.annotation.Resource;
import com.muyu.data.processing.domain.IotDbData;
import com.muyu.data.processing.domain.KafkaData;
import com.muyu.data.processing.strategy.core.StartStrategy;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import com.muyu.data.processing.mapper.DataProcessingMapper;
import com.muyu.data.processing.service.DataProcessingService;
import java.util.HashMap;
import java.util.List;
/**
* 数据处理实现层
*
* @Author: 胡杨
* @Name: DataProcessing
* @Description: 数据处理实现层
* @CreatedDate: 2024/9/28 下午3:52
* @FilePath: com.muyu.data.processing.server.impl
*/
@Slf4j
@Service
public class DataProcessingServiceImpl implements DataProcessingService {
@Resource
private DataProcessingMapper mapper;
@Resource
private StartStrategy rootStrategy;
@Override
public List<String> selectStorageGroup() {
return mapper.selectStorageGroup();
}
@Override
public void strategyCheck(List<KafkaData> dataList) {
HashMap<String, KafkaData> kafkaDataHashMap = new HashMap<>();
dataList.forEach(data -> kafkaDataHashMap.put(data.getKey(), data));
// Result<String[]> result = rootStrategy.applyStrategy(kafkaDataHashMap);
// String[] data = result.getData();
// insIotDbData(data[0],data[1]);
IotDbData build = IotDbData.builder()
.vin(kafkaDataHashMap.get("vin").getValue())
.timestamp(Long.parseLong(kafkaDataHashMap.get("timestamp").getValue()))
.latitude(kafkaDataHashMap.get("latitude").getValue())
.longitude(kafkaDataHashMap.get("longitude").getValue())
.build();
mapper.insIotDbDataVo(build);
// dataList.forEach(KafkaData::setValueClass);
// mapper.strategyCheck(dataList);
}
@Override
public Integer insIotDbData(String key, String value) {
return mapper.insIotDbData(key, value);
}
}

24
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/StrategyHandler.java 100644
View File

@ -0,0 +1,24 @@
package com.muyu.data.processing.strategy;
import com.muyu.data.processing.strategy.core.EndStrategy;
/**
* 策略控制者接口
* @Author: 胡杨
* @Name: StrategyHandler
* @Description: 策略控制者接口
* @CreatedDate: 2024/9/28 上午9:35
* @FilePath: com.muyu.data.processing.strategy
*/
public interface StrategyHandler<T,R> {
@SuppressWarnings("rawtypes")
StrategyHandler DEFAULT = param -> new EndStrategy();
/**
* 执行方法
* @param t 入参
* @return 返回结果
*/
R apply(T t);
}

60
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/abstractStrategyRouter.java 100644
View File

@ -0,0 +1,60 @@
package com.muyu.data.processing.strategy;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Objects;
/**
* 抽象策略路由
* @Author: 胡杨
* @Name: abstractStrategyRouter
* @Description: 抽象策略路由
* @CreatedDate: 2024/9/28 上午9:26
* @FilePath: com.muyu.data.processing.strategy
*/
@Slf4j
@Component
public abstract class abstractStrategyRouter<T,R> {
/**
* 策略映射器, 指定入参与出参以决定策略处理者
* @param <T> 策略入参
* @param <R> 策略出参
*/
public interface StrategyMapper<T,R>{
// 通过入参获取对应策略处理方法,使用Map实现
StrategyHandler<T,R> getHandler(T param);
}
/**
* 选择下级策略
* @return
*/
protected abstract StrategyMapper<T,R> registerStrategy();
/**
* 默认策略处理者
*/
@SuppressWarnings("unchecked")
private StrategyHandler<T,R> defaultStrategyHandler = StrategyHandler.DEFAULT;
/**
* 选择策略处理者
* @param param 入参
* @return 策略处理结果
*/
public R applyStrategy(T param) {
StrategyMapper<T, R> trStrategyMapper = registerStrategy();
if (trStrategyMapper == null) {
return defaultStrategyHandler.apply(param);
}
final StrategyHandler<T,R> strategyHandler = trStrategyMapper.getHandler(param);
if (strategyHandler != null) {
return strategyHandler.apply(param);
}
// 使用默认策略处理者
return defaultStrategyHandler.apply(param);
}
}

34
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/DataProcessStrategy.java 100644
View File

@ -0,0 +1,34 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.leaves.DataStorageStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 持久化数据处理
* 数据持久化之前的数据调整
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 数据持久化数据处理
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class DataProcessStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new DataStorageStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

35
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/FaultJudgmentStrategy.java 100644
View File

@ -0,0 +1,35 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.leaves.DataStorageStrategy;
import com.muyu.data.processing.strategy.leaves.FaultAlarmStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 故障数据判断
* 判断是否故障
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 故障数据判断
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class FaultJudgmentStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new FaultAlarmStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

34
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/FaultProcessingStrategy.java 100644
View File

@ -0,0 +1,34 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.leaves.DataStorageStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 故障数据处理
* 调整故障判断规则
* @Author: 胡杨
* @Name: FaultProcessingStrategy
* @Description: 故障参数处理
* @CreatedDate: 2024/9/30 下午7:47
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class FaultProcessingStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new FaultJudgmentStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

35
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/FenceJudgmentStrategy.java 100644
View File

@ -0,0 +1,35 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.leaves.FaultAlarmStrategy;
import com.muyu.data.processing.strategy.leaves.FenceAlarmStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 围栏数据判断
* 判断是否围栏违规
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 围栏数据判断
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class FenceJudgmentStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new FenceAlarmStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

33
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/FenceProcessingStrategy.java 100644
View File

@ -0,0 +1,33 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 围栏数据处理
* 调整围栏判断规则
* @Author: 胡杨
* @Name: FaultProcessingStrategy
* @Description: 围栏参数处理
* @CreatedDate: 2024/9/30 下午7:47
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class FenceProcessingStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new FenceJudgmentStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

35
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/RealTimeJudgmentStrategy.java 100644
View File

@ -0,0 +1,35 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.leaves.RealTimeAlarmStrategy;
import com.muyu.data.processing.strategy.leaves.WarningAlarmStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 实时数据判断
* 判断实时数据情况
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 实时数据判断
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class RealTimeJudgmentStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new RealTimeAlarmStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

33
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/RealTimeProcessingStrategy.java 100644
View File

@ -0,0 +1,33 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 实时数据处理
* 调整实时数据
* @Author: 胡杨
* @Name: FaultProcessingStrategy
* @Description: 实时数据理
* @CreatedDate: 2024/9/30 下午7:47
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class RealTimeProcessingStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new RealTimeJudgmentStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

35
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/WarningJudgmentStrategy.java 100644
View File

@ -0,0 +1,35 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.leaves.FenceAlarmStrategy;
import com.muyu.data.processing.strategy.leaves.WarningAlarmStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 预警数据判断
* 判断预警策略
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 预警数据判断
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class WarningJudgmentStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new WarningAlarmStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

33
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/branch/WarningProcessingStrategy.java 100644
View File

@ -0,0 +1,33 @@
package com.muyu.data.processing.strategy.branch;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 预警数据处理
* 调整预警使用策略
* @Author: 胡杨
* @Name: FaultProcessingStrategy
* @Description: 预警数据处理
* @CreatedDate: 2024/9/30 下午7:47
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class WarningProcessingStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param-> new WarningJudgmentStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

33
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/core/BasicStrategy.java 100644
View File

@ -0,0 +1,33 @@
package com.muyu.data.processing.strategy.core;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 基础校验节点
* 负责基础校验
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 基础校验节点
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class BasicStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param -> new RoutingStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

26
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/core/EndStrategy.java 100644
View File

@ -0,0 +1,26 @@
package com.muyu.data.processing.strategy.core;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 结束节点
*
* @Author: 胡杨
* @Name: EndStrategy
* @Description: 策略树 - 结束节点
* @CreatedDate: 2024/9/30 下午7:13
* @FilePath: com.muyu.data.processing.strategy.leaves
*/
@Slf4j
@Component
public class EndStrategy implements StrategyHandler<Temporary1, Temporary2> {
@Override
public Temporary2 apply(Temporary1 temporary1) {
return null;
}
}

39
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/core/RoutingStrategy.java 100644
View File

@ -0,0 +1,39 @@
package com.muyu.data.processing.strategy.core;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 路由节点
* 根据条件重新导向对应节点
* @Author: 胡杨
* @Name: RoutingStrategy
* @Description: 路由节点
* @CreatedDate: 2024/9/30 下午7:37
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class RoutingStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return new StrategyMapper<Temporary1, Temporary2>() {
@Override
public StrategyHandler<Temporary1, Temporary2> getHandler(Temporary1 param) {
// 编写路由规则
return null;
}
};
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

43
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/core/StartStrategy.java 100644
View File

@ -0,0 +1,43 @@
package com.muyu.data.processing.strategy.core;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 开始节点
*
* @Author: 胡杨
* @Name: StartStrategy
* @Description: 策略路由实现
* @CreatedDate: 2024/9/28 上午10:39
* @FilePath: com.muyu.data.processing.strategy.impl
* 开始节点
* ↓
* 基础校验节点
* ↓
* 路由节点 ← ← ← ← ← ←
* ↙ ↙ ↓ ↘ ↘
* 数据处理节点 预警处理节点 故障处理节点 围栏处理节点 实时数据数据处理节点 ↑
* ↓ ↓ ↓ ↓ ↓
* 数据持久化处理节点 预警处理节点 故障处理节点 围栏处理节点 实时数据数据处理节点 ↑
* ↓ ↓ ↓ ↓ ↓
* ↓ 预警通知节点 故障通知节点 围栏通知节点 实时数据处理节点 ↑
* ↓ ↘ ↓ ↙ ↙
* ↓ ↓ ↑
* → → → 路由节点 → → → → → →
* ↓
* 结束节点
*/
@Slf4j
@Component
public class StartStrategy extends abstractStrategyRouter<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param -> new BasicStrategy();
}
}

34
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/leaves/DataStorageStrategy.java 100644
View File

@ -0,0 +1,34 @@
package com.muyu.data.processing.strategy.leaves;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.core.RoutingStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 数据持久化
* 车辆数据进行持久化
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 数据持久化
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class DataStorageStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param -> new RoutingStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

34
cloud-data-processing/src/main/java/com/muyu/data/processing/strategy/leaves/FaultAlarmStrategy.java 100644
View File

@ -0,0 +1,34 @@
package com.muyu.data.processing.strategy.leaves;
import com.muyu.data.processing.domain.Temporary1;
import com.muyu.data.processing.domain.Temporary2;
import com.muyu.data.processing.strategy.StrategyHandler;
import com.muyu.data.processing.strategy.abstractStrategyRouter;
import com.muyu.data.processing.strategy.core.RoutingStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 故障报警
* 故障数据记录并报警
* @Author: 胡杨
* @Name: BasicStrategy
* @Description: 责任树 - 故障报警
* @CreatedDate: 2024/9/30 下午7:24
* @FilePath: com.muyu.data.processing.strategy.branch
*/
@Slf4j
@Component
public class FaultAlarmStrategy extends abstractStrategyRouter<Temporary1, Temporary2>
implements StrategyHandler<Temporary1, Temporary2> {
@Override
protected StrategyMapper<Temporary1, Temporary2> registerStrategy() {
return param -> new RoutingStrategy();
}
@Override
public Temporary2 apply(Temporary1 temporary1) {
return applyStrategy(temporary1);
}
}

Some files were not shown because too many files have changed in this diff Show More