five-groups
/
five-groups-couplet
4
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/server_five' into server_five_dongxiaodong 

# Conflicts:
#	couplet-modules/couplet-modules-onLine/src/main/resources/bootstrap.yml
server_five_liuyunhu
dongxiaodong 2024-04-08 09:21:25 +08:00
parent 0eba9f5cfe 1c6cebb2cc
commit f104a50c27
30 changed files with 728 additions and 698 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
couplet-auth/src/main/resources/bootstrap.yml
View File

@ -17,9 +17,11 @@ spring:
discovery: discovery:
# 服务注册地址 # 服务注册地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
config: config:
# 配置中心地址 # 配置中心地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
# 配置文件格式 # 配置文件格式
file-extension: yml file-extension: yml
# 共享配置 # 共享配置

5
couplet-common/couplet-common-business/src/main/java/com/couplet/remote/RemoteVehicleService.java
View File

@ -4,7 +4,9 @@ import com.couplet.common.core.constant.ServiceNameConstants;
import com.couplet.common.core.domain.Result; import com.couplet.common.core.domain.Result;
import com.couplet.common.domain.Vehicle; import com.couplet.common.domain.Vehicle;
import com.couplet.common.domain.VehicleMiddle; import com.couplet.common.domain.VehicleMiddle;
import com.couplet.common.domain.request.VehicleListParams;
import com.couplet.remote.factory.RemoteVehicleFallbackFactory; import com.couplet.remote.factory.RemoteVehicleFallbackFactory;
import lombok.extern.java.Log;
import org.springframework.cloud.openfeign.FeignClient; import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
@ -62,4 +64,7 @@ public interface RemoteVehicleService {
@PostMapping("/vehicleAndLogo/queryByLogoIds/{vehicleId}") @PostMapping("/vehicleAndLogo/queryByLogoIds/{vehicleId}")
public Result<List<Long>> queryByLogoIds(@PathVariable("vehicleId") Long vehicleId); public Result<List<Long>> queryByLogoIds(@PathVariable("vehicleId") Long vehicleId);
@PostMapping("/list")
public Result list(@RequestBody VehicleListParams listParams);
} }

6
couplet-common/couplet-common-business/src/main/java/com/couplet/remote/factory/RemoteVehicleFallbackFactory.java
View File

@ -3,6 +3,7 @@ package com.couplet.remote.factory;
import com.couplet.common.core.domain.Result; import com.couplet.common.core.domain.Result;
import com.couplet.common.domain.Vehicle; import com.couplet.common.domain.Vehicle;
import com.couplet.common.domain.VehicleMiddle; import com.couplet.common.domain.VehicleMiddle;
import com.couplet.common.domain.request.VehicleListParams;
import com.couplet.remote.RemoteVehicleService; import com.couplet.remote.RemoteVehicleService;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -61,6 +62,11 @@ public class RemoteVehicleFallbackFactory implements FallbackFactory<RemoteVehic
public Result<List<Long>> queryByLogoIds(Long vehicleId) { public Result<List<Long>> queryByLogoIds(Long vehicleId) {
return Result.error("车辆服务调用失败:"+cause.getMessage()); return Result.error("车辆服务调用失败:"+cause.getMessage());
} }
@Override
public Result list(VehicleListParams listParams) {
return Result.error("车辆服务调用失败:"+cause.getMessage());
}
}; };
} }
} }

38
couplet-common/couplet-common-event/.gitignore vendored 100644
View File

@ -0,0 +1,38 @@
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### IntelliJ IDEA ###
.idea/modules.xml
.idea/jarRepositories.xml
.idea/compiler.xml
.idea/libraries/
*.iws
*.iml
*.ipr
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store

28
couplet-common/couplet-common-event/pom.xml 100644
View File

@ -0,0 +1,28 @@
<?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.couplet</groupId>
<artifactId>couplet-common</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>couplet-common-event</artifactId>
<description>事件系统</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.couplet</groupId>
<artifactId>couplet-common-redis</artifactId>
</dependency>
</dependencies>
</project>

27
couplet-common/couplet-common-event/src/main/java/com/couplet/analyze/common/contents/AnalyzeEventContents.java 100644
View File

@ -0,0 +1,27 @@
package com.couplet.analyze.common.contents;
/**
* @Author: LiJiaYao
* @Date: 2024/4/7
* @Description: 事件内容
*/
public class AnalyzeEventContents {
/**
* 故障
*/
String BREAKDOWN = "breakdown";
/**
* 电子围栏
*/
String ELECTRONIC_FENCE = "electronic-fence";
/**
* 实时数据
*/
String REAL_TIME_DATA = "real-time-data";
/**
* 存储
*/
String STORED_EVENT = "stored-event";
}

51
couplet-common/couplet-common-event/src/main/java/com/couplet/analyze/common/event/AnalyzeEventCache.java 100644
View File

@ -0,0 +1,51 @@
package com.couplet.analyze.common.event;
import com.couplet.common.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.Set;
/**
* @Author: LiJiaYao
* @Date: 2024/4/7
* @Description:
*/
public class AnalyzeEventCache {
@Autowired
private RedisService redisService;
public String encode(String vin){
return "event:arr"+vin;
}
/**
* 添加事件
*/
public void addEvent(String vin, String eventValue) {
redisService.setCacheSet(encode(vin), eventValue);
}
/**
* 修改事件
*/
public void updateEvent(String vin,String eventValue){
redisService.setCacheSet(encode(vin), eventValue);
}
/**
* 删除事件
*/
public void removeEvent(String vin,String eventName){
redisService.deleteSet(encode(vin), eventName);
}
/**
* 获取事件集合
*
* @return
*/
public Set<Object> getEventList(String vin){
return redisService.getCacheSet(encode(vin));
}
}

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

@ -0,0 +1 @@
com.couplet.analyze.common.event.AnalyzeEventCache

27
couplet-common/couplet-common-redis/src/main/java/com/couplet/common/redis/service/RedisService.java
View File

@ -1,6 +1,7 @@
package com.couplet.common.redis.service; package com.couplet.common.redis.service;
import com.couplet.common.domain.CoupletVehicleData; import com.couplet.common.domain.CoupletVehicleData;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*; import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
@ -179,8 +180,31 @@ public class RedisService {
setOperation.add(it.next()); setOperation.add(it.next());
} }
return setOperation; return setOperation;
} /**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
*
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet (final String key, final T dataSet) {
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
setOperation.add(dataSet);
return setOperation;
} }
/**
* 删除set
* @param key
* @param setValue
*/
public <T> void deleteSet(String key, String setValue) {
//缓存的键值
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
setOperation.remove(setValue); //缓存的数据
}
/** /**
* 获得缓存的set * 获得缓存的set
* *
@ -192,6 +216,7 @@ public class RedisService {
return redisTemplate.opsForSet().members(key); return redisTemplate.opsForSet().members(key);
} }
/** /**
* 缓存Map * 缓存Map
* *
@ -273,4 +298,6 @@ public class RedisService {
public Collection<String> keys (final String pattern) { public Collection<String> keys (final String pattern) {
return redisTemplate.keys(pattern); return redisTemplate.keys(pattern);
} }
} }

1
couplet-common/pom.xml
View File

@ -19,6 +19,7 @@
<module>couplet-common-datasource</module> <module>couplet-common-datasource</module>
<module>couplet-common-system</module> <module>couplet-common-system</module>
<module>couplet-common-business</module> <module>couplet-common-business</module>
<module>couplet-common-event</module>
</modules> </modules>

2
couplet-gateway/src/main/resources/bootstrap.yml
View File

@ -15,9 +15,11 @@ spring:
discovery: discovery:
# 服务注册地址 # 服务注册地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
config: config:
# 配置中心地址 # 配置中心地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
# 配置文件格式 # 配置文件格式
file-extension: yml file-extension: yml
# 共享配置 # 共享配置

8
couplet-modules/couplet-analyze/couplet-analyze-msg/pom.xml
View File

@ -11,6 +11,7 @@
<artifactId>couplet-analyze-msg</artifactId> <artifactId>couplet-analyze-msg</artifactId>
<description>解析系统</description>
<properties> <properties>
<maven.compiler.source>17</maven.compiler.source> <maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target> <maven.compiler.target>17</maven.compiler.target>
@ -86,13 +87,14 @@
<artifactId>org.eclipse.paho.client.mqttv3</artifactId> <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
<version>1.2.5</version> <version>1.2.5</version>
</dependency> </dependency>
<!-- 事件核心配置 -->
<dependency> <dependency>
<groupId>com.couplet</groupId> <groupId>com.couplet</groupId>
<artifactId>couplet-modules-mq</artifactId> <artifactId>couplet-common-event</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.couplet</groupId> <groupId>org.springframework.kafka</groupId>
<artifactId>couplet-common-business</artifactId> <artifactId>spring-kafka</artifactId>
</dependency> </dependency>
</dependencies> </dependencies>

166
couplet-modules/couplet-analyze/couplet-analyze-msg/src/main/java/com/couplet/analyze/msg/consumer/FenceConsumer.java
View File

@ -1,84 +1,84 @@
package com.couplet.analyze.msg.consumer; //package com.couplet.analyze.msg.consumer;
//
import com.couplet.common.core.text.Convert; //import com.couplet.common.core.text.Convert;
import com.couplet.common.domain.request.FenceUpdateRequest; //import com.couplet.common.domain.request.FenceUpdateRequest;
import com.couplet.common.redis.service.RedisService; //import com.couplet.common.redis.service.RedisService;
import com.rabbitmq.client.Channel; //import com.rabbitmq.client.Channel;
import lombok.extern.log4j.Log4j2; //import lombok.extern.log4j.Log4j2;
import org.springframework.amqp.core.Message; //import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler; //import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; //import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired; //import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations; //import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.stereotype.Component; //import org.springframework.stereotype.Component;
//
import java.io.IOException; //import java.io.IOException;
import java.util.HashMap; //import java.util.HashMap;
import java.util.HashSet; //import java.util.HashSet;
import java.util.Set; //import java.util.Set;
import java.util.concurrent.TimeUnit; //import java.util.concurrent.TimeUnit;
//
/** ///**
* @Author: LiJiaYao // * @Author: LiJiaYao
* @Date: 2024/4/4 // * @Date: 2024/4/4
* @Description: // * @Description:
*/ // */
@Log4j2 //@Log4j2
@Component //@Component
@RabbitListener(queues = "fenceQueue") //@RabbitListener(queues = "fenceQueue")
public class FenceConsumer { //public class FenceConsumer {
@Autowired // @Autowired
private RedisService redisService; // private RedisService redisService;
//
@RabbitHandler // @RabbitHandler
public void fenceConsumer(FenceUpdateRequest fenceUpdateRequest, Channel channel, Message message) throws IOException { // public void fenceConsumer(FenceUpdateRequest fenceUpdateRequest, Channel channel, Message message) throws IOException {
//
log.info("电子围栏消息进入队列，传入的数据是:[{}]", fenceUpdateRequest); // log.info("电子围栏消息进入队列，传入的数据是:[{}]", fenceUpdateRequest);
//
String messageId = message.getMessageProperties().getMessageId(); // String messageId = message.getMessageProperties().getMessageId();
long deliveryTag = message.getMessageProperties().getDeliveryTag(); // long deliveryTag = message.getMessageProperties().getDeliveryTag();
if (!redisService.hasKey("电子围栏消息不丢失:" + messageId)) { // if (!redisService.hasKey("电子围栏消息不丢失:" + messageId)) {
redisService.setCacheObject("电子围栏消息不丢失:" + messageId, "" + deliveryTag); // redisService.setCacheObject("电子围栏消息不丢失:" + messageId, "" + deliveryTag);
}
// if (redisService.hasKey("fence")){
// redisService.deleteObject("fence");
// } // }
//// if (redisService.hasKey("fence")){
HashSet<String> objects = new HashSet<>(); //// redisService.deleteObject("fence");
objects.add(messageId); //// }
//
BoundSetOperations<String, String> set = redisService.setCacheSet("电子围栏消息不重复:" + messageId, objects); // HashSet<String> objects = new HashSet<>();
redisService.expire("电子围栏消息不重复:" + messageId, 5, TimeUnit.MINUTES); // objects.add(messageId);
try { //
if (set != null) { // BoundSetOperations<String, String> set = redisService.setCacheSet("电子围栏消息不重复:" + messageId, objects);
HashMap<String, Object> hashMap = new HashMap<>(); // redisService.expire("电子围栏消息不重复:" + messageId, 5, TimeUnit.MINUTES);
HashSet<FenceUpdateRequest> hashSet = new HashSet<>(); // try {
hashSet.add(fenceUpdateRequest); // if (set != null) {
hashMap.put(fenceUpdateRequest.getFenceId()+"",fenceUpdateRequest); // HashMap<String, Object> hashMap = new HashMap<>();
// redisTemplate.opsForH("fence", JSON.toJSONString(hashMap),10,TimeUnit.MINUTES); // HashSet<FenceUpdateRequest> hashSet = new HashSet<>();
// redisTemplate.opsForHash().put("fence", fenceUpdateRequest.getFenceId()+"", JSON.toJSONString(hashMap)); // hashSet.add(fenceUpdateRequest);
// hashMap.put(fenceUpdateRequest.getFenceId()+"",fenceUpdateRequest);
String key = Convert.toStr(fenceUpdateRequest.getFenceId()); //// redisTemplate.opsForH("fence", JSON.toJSONString(hashMap),10,TimeUnit.MINUTES);
redisService.setCacheObject(key,fenceUpdateRequest); //// redisTemplate.opsForHash().put("fence", fenceUpdateRequest.getFenceId()+"", JSON.toJSONString(hashMap));
redisService.expire(key, 10, TimeUnit.MINUTES); //
//判断车辆是否有实时数据,如果没有则删除数据 // String key = Convert.toStr(fenceUpdateRequest.getFenceId());
channel.basicAck(deliveryTag, false); // redisService.setCacheObject(key,fenceUpdateRequest);
} else { // redisService.expire(key, 10, TimeUnit.MINUTES);
log.error("电子围栏消息不能重复消费:[{}]", fenceUpdateRequest); // //判断车辆是否有实时数据,如果没有则删除数据
channel.basicReject(deliveryTag, false); // channel.basicAck(deliveryTag, false);
} // } else {
} catch (IOException e) { // log.error("电子围栏消息不能重复消费:[{}]", fenceUpdateRequest);
log.error("电子围栏消息未进入队列,传入的信息是:【{}】", fenceUpdateRequest); // channel.basicReject(deliveryTag, false);
String s = redisService.getCacheObject("电子围栏消息不丢失:" + messageId); // }
// } catch (IOException e) {
Long o = Long.valueOf(s); // log.error("电子围栏消息未进入队列,传入的信息是:【{}】", fenceUpdateRequest);
if (deliveryTag == o + 2) { // String s = redisService.getCacheObject("电子围栏消息不丢失:" + messageId);
log.error("电子围栏消息已丢失,无法传入的信息是:【{}】", fenceUpdateRequest); //
channel.basicNack(deliveryTag, false, false); // Long o = Long.valueOf(s);
} else { // if (deliveryTag == o + 2) {
log.error("电子围栏消息已丢失,已再次传入的信息是:【{}】", fenceUpdateRequest); // log.error("电子围栏消息已丢失,无法传入的信息是:【{}】", fenceUpdateRequest);
channel.basicNack(deliveryTag, true, false); // channel.basicNack(deliveryTag, false, false);
} // } else {
} // log.error("电子围栏消息已丢失,已再次传入的信息是:【{}】", fenceUpdateRequest);
} // channel.basicNack(deliveryTag, true, false);
} // }
// }
// }
//}

182
couplet-modules/couplet-analyze/couplet-analyze-msg/src/main/java/com/couplet/analyze/msg/consumer/MsgConsumer.java
View File

@ -1,91 +1,91 @@
package com.couplet.analyze.msg.consumer; //package com.couplet.analyze.msg.consumer;
//
import com.alibaba.fastjson.JSON; //import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject; //import com.alibaba.fastjson.JSONObject;
import com.couplet.analyze.msg.domain.CoupletMsgData; //import com.couplet.analyze.msg.domain.CoupletMsgData;
import com.couplet.analyze.msg.mapper.IncidentMapper; //import com.couplet.analyze.msg.mapper.IncidentMapper;
import com.couplet.analyze.msg.service.impl.realTimeData.RealTimeJudge; //import com.couplet.analyze.msg.service.impl.realTimeData.RealTimeJudge;
import com.couplet.common.domain.request.RealTimeDataRequest; //import com.couplet.common.domain.request.RealTimeDataRequest;
import com.rabbitmq.client.Channel; //import com.rabbitmq.client.Channel;
import lombok.extern.log4j.Log4j2; //import lombok.extern.log4j.Log4j2;
import org.springframework.amqp.core.Message; //import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler; //import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; //import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired; //import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate; //import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component; //import org.springframework.stereotype.Component;
//
import java.io.IOException; //import java.io.IOException;
import java.util.concurrent.TimeUnit; //import java.util.concurrent.TimeUnit;
//
/** ///**
* @Author: LiJiaYao // * @Author: LiJiaYao
* @Date: 2024/4/4 // * @Date: 2024/4/4
* @Description: // * @Description:
*/ // */
@Log4j2 //@Log4j2
@Component //@Component
@RabbitListener(queues = "finByVinQueueName") //@RabbitListener(queues = "finByVinQueueName")
public class MsgConsumer { //public class MsgConsumer {
@Autowired // @Autowired
private StringRedisTemplate redisTemplate; // private StringRedisTemplate redisTemplate;
@Autowired // @Autowired
private IncidentMapper incidentMapper; // private IncidentMapper incidentMapper;
//
@RabbitHandler // @RabbitHandler
public void realTimeDataConsumer(RealTimeDataRequest realTimeDataRequest, Channel channel, Message message) throws IOException { // public void realTimeDataConsumer(RealTimeDataRequest realTimeDataRequest, Channel channel, Message message) throws IOException {
//
log.info("消息进入队列，传入的数据是:[{}]", realTimeDataRequest); // log.info("消息进入队列，传入的数据是:[{}]", realTimeDataRequest);
//
String messageId = message.getMessageProperties().getMessageId(); // String messageId = message.getMessageProperties().getMessageId();
long deliveryTag = message.getMessageProperties().getDeliveryTag(); // long deliveryTag = message.getMessageProperties().getDeliveryTag();
if (!redisTemplate.hasKey("消息不丢失:" + messageId)) { // if (!redisTemplate.hasKey("消息不丢失:" + messageId)) {
redisTemplate.opsForValue().set("消息不丢失:" + messageId, "" + deliveryTag, 1, TimeUnit.MINUTES); // redisTemplate.opsForValue().set("消息不丢失:" + messageId, "" + deliveryTag, 1, TimeUnit.MINUTES);
} // }
//
Long add = redisTemplate.opsForSet().add("消息不重复:" + messageId, messageId); // Long add = redisTemplate.opsForSet().add("消息不重复:" + messageId, messageId);
redisTemplate.expire("消息不重复:" + messageId, 5, TimeUnit.MINUTES); // redisTemplate.expire("消息不重复:" + messageId, 5, TimeUnit.MINUTES);
try { // try {
if (0 < add) { // if (0 < add) {
JSONObject jsonObject = JSONObject.parseObject(String.valueOf(realTimeDataRequest)); // JSONObject jsonObject = JSONObject.parseObject(String.valueOf(realTimeDataRequest));
Long userId = jsonObject.getLong("userId"); // Long userId = jsonObject.getLong("userId");
String vin = jsonObject.getString("vin"); // String vin = jsonObject.getString("vin");
RealTimeDataRequest request = new RealTimeDataRequest(); // RealTimeDataRequest request = new RealTimeDataRequest();
request.setVin(vin); // request.setVin(vin);
request.setUserId(userId); // request.setUserId(userId);
RealTimeJudge.addRealTime(request); // RealTimeJudge.addRealTime(request);
//判断车辆是否有实时数据,如果没有则删除数据 // //判断车辆是否有实时数据,如果没有则删除数据
if (RealTimeJudge.isJudge(realTimeDataRequest.getVin())){ // if (RealTimeJudge.isJudge(realTimeDataRequest.getVin())){
log.info("开始实时数据传输:[{}]",realTimeDataRequest.getVin()); // log.info("开始实时数据传输:[{}]",realTimeDataRequest.getVin());
} // }
CoupletMsgData incident = incidentMapper.queryByIncident(realTimeDataRequest.getVin()); // CoupletMsgData incident = incidentMapper.queryByIncident(realTimeDataRequest.getVin());
if (incident == null){ // if (incident == null){
log.error("没有数据......"); // log.error("没有数据......");
} // }
redisTemplate.opsForList().rightPush("coupletMsgData", JSON.toJSONString(incident)); // redisTemplate.opsForList().rightPush("coupletMsgData", JSON.toJSONString(incident));
//
channel.basicAck(deliveryTag, false); // channel.basicAck(deliveryTag, false);
} else { // } else {
log.error("消息不能重复消费:[{}]", realTimeDataRequest); // log.error("消息不能重复消费:[{}]", realTimeDataRequest);
channel.basicReject(deliveryTag, false); // channel.basicReject(deliveryTag, false);
} // }
} catch (IOException e) { // } catch (IOException e) {
//
log.error("消息未进入队列,传入的信息是:【{}】", realTimeDataRequest); // log.error("消息未进入队列,传入的信息是:【{}】", realTimeDataRequest);
String s = redisTemplate.opsForValue().get("消息不丢失:" + messageId); // String s = redisTemplate.opsForValue().get("消息不丢失:" + messageId);
//
Long o = Long.valueOf(s); // Long o = Long.valueOf(s);
if (deliveryTag == o + 2) { // if (deliveryTag == o + 2) {
log.error("消息已丢失,无法传入的信息是:【{}】", realTimeDataRequest); // log.error("消息已丢失,无法传入的信息是:【{}】", realTimeDataRequest);
channel.basicNack(deliveryTag, false, false); // channel.basicNack(deliveryTag, false, false);
} else { // } else {
log.error("消息已丢失,已再次传入的信息是:【{}】", realTimeDataRequest); // log.error("消息已丢失,已再次传入的信息是:【{}】", realTimeDataRequest);
channel.basicNack(deliveryTag, true, false); // channel.basicNack(deliveryTag, true, false);
} // }
//
} // }
//
//
} // }
//
} //}

136
couplet-modules/couplet-analyze/couplet-analyze-msg/src/main/java/com/couplet/analyze/msg/consumer/VehicleConsumer.java
View File

@ -1,68 +1,68 @@
package com.couplet.analyze.msg.consumer; //package com.couplet.analyze.msg.consumer;
//
import com.couplet.common.core.text.Convert; //import com.couplet.common.core.text.Convert;
import com.couplet.common.redis.service.RedisService; //import com.couplet.common.redis.service.RedisService;
import com.rabbitmq.client.Channel; //import com.rabbitmq.client.Channel;
import lombok.extern.log4j.Log4j2; //import lombok.extern.log4j.Log4j2;
import org.springframework.amqp.core.Message; //import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler; //import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; //import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired; //import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations; //import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.stereotype.Component; //import org.springframework.stereotype.Component;
//
import java.io.IOException; //import java.io.IOException;
import java.util.HashSet; //import java.util.HashSet;
import java.util.List; //import java.util.List;
import java.util.concurrent.TimeUnit; //import java.util.concurrent.TimeUnit;
//
/** ///**
* @Author: LiJiaYao // * @Author: LiJiaYao
* @Date: 2024/4/4 // * @Date: 2024/4/4
* @Description: // * @Description:
*/ // */
@Log4j2 //@Log4j2
@Component //@Component
@RabbitListener(queues = "vehicleQueue") //@RabbitListener(queues = "vehicleQueue")
public class VehicleConsumer { //public class VehicleConsumer {
@Autowired // @Autowired
private RedisService redisService; // private RedisService redisService;
@RabbitHandler // @RabbitHandler
public void vehicleConsumer(String vehicleAndLogo, Channel channel, Message message) throws IOException { // public void vehicleConsumer(String vehicleAndLogo, Channel channel, Message message) throws IOException {
log.info("车辆消息进入队列，传入的数据是:[{}]", vehicleAndLogo); // log.info("车辆消息进入队列，传入的数据是:[{}]", vehicleAndLogo);
String messageId = message.getMessageProperties().getMessageId(); // String messageId = message.getMessageProperties().getMessageId();
long deliveryTag = message.getMessageProperties().getDeliveryTag(); // long deliveryTag = message.getMessageProperties().getDeliveryTag();
if (!redisService.hasKey("车辆消息不丢失:" + messageId)) { // if (!redisService.hasKey("车辆消息不丢失:" + messageId)) {
redisService.setCacheObject("车辆消息不丢失:" + messageId, "" + deliveryTag); // redisService.setCacheObject("车辆消息不丢失:" + messageId, "" + deliveryTag);
} // }
HashSet<String> objects = new HashSet<>(); // HashSet<String> objects = new HashSet<>();
objects.add(messageId); // objects.add(messageId);
BoundSetOperations<String, String> set = redisService.setCacheSet("车辆信息消息不重复:" + messageId, objects); // BoundSetOperations<String, String> set = redisService.setCacheSet("车辆信息消息不重复:" + messageId, objects);
redisService.expire("车辆信息消息不重复:" + messageId, 5, TimeUnit.MINUTES); // redisService.expire("车辆信息消息不重复:" + messageId, 5, TimeUnit.MINUTES);
try { // try {
if (set != null) { // if (set != null) {
// String key = Convert.toStr(id); //// String key = Convert.toStr(id);
//
String key = "id"; // String key = "id";
redisService.setCacheObject(key, vehicleAndLogo); // redisService.setCacheObject(key, vehicleAndLogo);
redisService.expire(key, 10, TimeUnit.MINUTES); // redisService.expire(key, 10, TimeUnit.MINUTES);
//判断车辆是否有实时数据,如果没有则删除数据 // //判断车辆是否有实时数据,如果没有则删除数据
channel.basicAck(deliveryTag, false); // channel.basicAck(deliveryTag, false);
} else { // } else {
log.error("车辆消息不能重复消费:[{}]", vehicleAndLogo); // log.error("车辆消息不能重复消费:[{}]", vehicleAndLogo);
channel.basicReject(deliveryTag, false); // channel.basicReject(deliveryTag, false);
} // }
} catch (IOException e) { // } catch (IOException e) {
log.error("车辆消息未进入队列,传入的信息是:【{}】", vehicleAndLogo); // log.error("车辆消息未进入队列,传入的信息是:【{}】", vehicleAndLogo);
String s = redisService.getCacheObject("车辆消息不丢失:" + messageId); // String s = redisService.getCacheObject("车辆消息不丢失:" + messageId);
Long o = Long.valueOf(s); // Long o = Long.valueOf(s);
if (deliveryTag == o + 2) { // if (deliveryTag == o + 2) {
log.error("车辆消息已丢失,无法传入的信息是:【{}】", vehicleAndLogo); // log.error("车辆消息已丢失,无法传入的信息是:【{}】", vehicleAndLogo);
channel.basicNack(deliveryTag, false, false); // channel.basicNack(deliveryTag, false, false);
} else { // } else {
log.error("车辆消息已丢失,已再次传入的信息是:【{}】", vehicleAndLogo); // log.error("车辆消息已丢失,已再次传入的信息是:【{}】", vehicleAndLogo);
channel.basicNack(deliveryTag, true, false); // channel.basicNack(deliveryTag, true, false);
} // }
} // }
} // }
} //}

58
couplet-modules/couplet-analyze/couplet-analyze-msg/src/main/java/com/couplet/analyze/msg/service/impl/BreakdownServiceImpl.java
View File

@ -74,9 +74,7 @@ public class BreakdownServiceImpl extends KeyExpirationEventMessageListener impl
//获取过期的key //获取过期的key
String key = "breakdown"; String key = "breakdown";
log.debug("失效+key is:"+ key); log.debug("失效+key is:"+ key);
HashSet<CoupletMsgData> objects = new HashSet<>(); redisService.setCacheSet(key, coupletMsgData);
objects.add(coupletMsgData);
redisService.setCacheSet(key, objects);
long expireTime = 30; long expireTime = 30;
redisService.expire(key, expireTime, TimeUnit.MINUTES); redisService.expire(key, expireTime, TimeUnit.MINUTES);
scheduledRedis(); scheduledRedis();
@ -98,112 +96,108 @@ public class BreakdownServiceImpl extends KeyExpirationEventMessageListener impl
} }
public void scheduledRedis() { public void scheduledRedis() {
// Get all members of the set // Get all members of the set
Set<String> members = redisService.getCacheSet("breakdown"); String key = "breakdown";
if (members.size()!=0){ Set<CoupletMsgData> members = redisService.getCacheSet(key);
for (String member : members){ if (members.size()>0){
CoupletMsgData code = JSON.parseObject(member, CoupletMsgData.class); for (CoupletMsgData member : members) {
String vin = code.getVin(); Set<String> breakdownIds = redisService.getCacheSet(member.getVin()+":"+key);
Set<String> breakdownIds = redisService.getCacheSet(vin+":"+"breakdown");
if (breakdownIds.size()==0){ if (breakdownIds.size()==0){
CoupletTroubleCode troubleCode = new CoupletTroubleCode(); CoupletTroubleCode troubleCode = new CoupletTroubleCode();
troubleCode.setTroubleStartTime(new Date()); troubleCode.setTroubleStartTime(new Date());
troubleCode.setTroubleVin(code.getVin()); troubleCode.setTroubleVin(member.getVin());
// 随机生成故障码 // 随机生成故障码
String faultCode = MsgUtils.generateGTA(); String faultCode = MsgUtils.generateGTA();
troubleCode.setTroubleCode(faultCode); troubleCode.setTroubleCode(faultCode);
// 检查车辆状态，若为0，则设置故障位置为"190" // 检查车辆状态，若为0，则设置故障位置为"190"
if(code.getVehicleStatus() == 0) { if(member.getVehicleStatus() == 0) {
troubleCode.setTroublePosition("190"); troubleCode.setTroublePosition("190");
} }
// 检查充电状态，若为0，则设置故障位置为"191" // 检查充电状态，若为0，则设置故障位置为"191"
if (code.getChargingStatus() == 0) { if (member.getChargingStatus() == 0) {
troubleCode.setTroublePosition("191"); troubleCode.setTroublePosition("191");
} }
// 检查运行状态，若为0，则设置故障位置为"192" // 检查运行状态，若为0，则设置故障位置为"192"
if (code.getOperatingStatus() == 0) { if (member.getOperatingStatus() == 0) {
troubleCode.setTroublePosition("192"); troubleCode.setTroublePosition("192");
} }
// 检查电池荷电状态（SOC）, 若为0，则设置故障位置为"193" // 检查电池荷电状态（SOC）, 若为0，则设置故障位置为"193"
if (code.getSocStatus() == 0) { if (member.getSocStatus() == 0) {
troubleCode.setTroublePosition("193"); troubleCode.setTroublePosition("193");
} }
// 检查充电能源存储状态，若为0，则设置故障位置为"194" // 检查充电能源存储状态，若为0，则设置故障位置为"194"
if (code.getChargingEnergyStorageStatus() == 0) { if (member.getChargingEnergyStorageStatus() == 0) {
troubleCode.setTroublePosition("194"); troubleCode.setTroublePosition("194");
} }
// 检查驱动电机状态，若为0，则设置故障位置为"195" // 检查驱动电机状态，若为0，则设置故障位置为"195"
if (code.getDriveMotorStatus() == 0) { if (member.getDriveMotorStatus() == 0) {
troubleCode.setTroublePosition("195"); troubleCode.setTroublePosition("195");
} }
// 检查定位状态，若为0，则设置故障位置为"196" // 检查定位状态，若为0，则设置故障位置为"196"
if (code.getPositionStatus() == 0) { if (member.getPositionStatus() == 0) {
troubleCode.setTroublePosition("196"); troubleCode.setTroublePosition("196");
} }
// 检查电子驻车系统（EAS）状态，若为0，则设置故障位置为"197" // 检查电子驻车系统（EAS）状态，若为0，则设置故障位置为"197"
if (code.getEasStatus() == 0) { if (member.getEasStatus() == 0) {
troubleCode.setTroublePosition("197"); troubleCode.setTroublePosition("197");
} }
// 检查PTC（正温度系数热敏电阻）状态，若为0，则设置故障位置为"198" // 检查PTC（正温度系数热敏电阻）状态，若为0，则设置故障位置为"198"
if (code.getPtcStatus() == 0) { if (member.getPtcStatus() == 0) {
troubleCode.setTroublePosition("198"); troubleCode.setTroublePosition("198");
} }
// 检查电动助力转向系统（EPS）状态，若为0，则设置故障位置为"199" // 检查电动助力转向系统（EPS）状态，若为0，则设置故障位置为"199"
if (code.getEpsStatus() == 0) { if (member.getEpsStatus() == 0) {
troubleCode.setTroublePosition("199"); troubleCode.setTroublePosition("199");
} }
// 检查防抱死制动系统（ABS）状态，若为0，则设置故障位置为"200" // 检查防抱死制动系统（ABS）状态，若为0，则设置故障位置为"200"
if (code.getAbsStatus() == 0) { if (member.getAbsStatus() == 0) {
troubleCode.setTroublePosition("200"); troubleCode.setTroublePosition("200");
} }
// 检查主控制器（MCU）状态，若为0，则设置故障位置为"201" // 检查主控制器（MCU）状态，若为0，则设置故障位置为"201"
if (code.getMcuStatus() == 0) { if (member.getMcuStatus() == 0) {
troubleCode.setTroublePosition("201"); troubleCode.setTroublePosition("201");
} }
// 检查加热状态，若为0，则设置故障位置为"202" // 检查加热状态，若为0，则设置故障位置为"202"
if (code.getHeatingStatus() == 0) { if (member.getHeatingStatus() == 0) {
troubleCode.setTroublePosition("202"); troubleCode.setTroublePosition("202");
} }
// 检查电池状态，若为0，则设置故障位置为"203" // 检查电池状态，若为0，则设置故障位置为"203"
if (code.getBatteryStatus() == 0) { if (member.getBatteryStatus() == 0) {
troubleCode.setTroublePosition("203"); troubleCode.setTroublePosition("203");
} }
// 检查电池绝缘状态，若为0，则设置故障位置为"204" // 检查电池绝缘状态，若为0，则设置故障位置为"204"
if (code.getBatteryInsulationStatus() == 0) { if (member.getBatteryInsulationStatus() == 0) {
troubleCode.setTroublePosition("204"); troubleCode.setTroublePosition("204");
} }
// 检查直流-直流转换器（DC/DC）状态，若为0，则设置故障位置为"205" // 检查直流-直流转换器（DC/DC）状态，若为0，则设置故障位置为"205"
if (code.getDcdcStatus() == 0) { if (member.getDcdcStatus() == 0) {
troubleCode.setTroublePosition("205"); troubleCode.setTroublePosition("205");
} }
// 检查充电机（CHG）状态，若为0，则设置故障位置为"206" // 检查充电机（CHG）状态，若为0，则设置故障位置为"206"
if (code.getChgStatus() == 0) { if (member.getChgStatus() == 0) {
troubleCode.setTroublePosition("206"); troubleCode.setTroublePosition("206");
} }
remoteTroubleService.newFaultData(troubleCode); remoteTroubleService.newFaultData(troubleCode);
HashSet<Object> objects = new HashSet<>(); redisService.setCacheSet(member.getVin()+":"+key, member.getVin()+":"+member);
objects.add(code.getVin()+":"+code);
redisService.setCacheSet(vin+":"+"breakdown", objects);
long expireTime = 30; long expireTime = 30;
redisService.expire(vin+":"+"breakdown", expireTime, TimeUnit.MINUTES); redisService.expire(member.getVin()+":"+key, expireTime, TimeUnit.MINUTES);
} }
} }

9
couplet-modules/couplet-analyze/couplet-analyze-msg/src/main/java/com/couplet/analyze/msg/service/impl/ElectronicFenceServiceImpl.java
View File

@ -64,10 +64,12 @@ public class ElectronicFenceServiceImpl implements IncidentService {
String[] strings = s.split(","); String[] strings = s.split(",");
if (strings.length == 2){ if (strings.length == 2){
// 经度
Double trim = Double.valueOf(strings[0].trim()); Double trim = Double.valueOf(strings[0].trim());
// 纬度
Double trim1 = Double.valueOf(strings[1].trim()); Double trim1 = Double.valueOf(strings[1].trim());
boolean a = trim<= Double.valueOf(coupletMsgData.getLongitude()); boolean a = trim <= Double.valueOf(coupletMsgData.getLongitude());
boolean b = trim1 < Double.valueOf(coupletMsgData.getLatitude()); boolean b = trim1 <= Double.valueOf(coupletMsgData.getLatitude());
if (a && b){ if (a && b){
log.info("电子围栏报警啦!!!!您的车驶出范围啦!!!"); log.info("电子围栏报警啦!!!!您的车驶出范围啦!!!");
}else { }else {
@ -78,10 +80,7 @@ public class ElectronicFenceServiceImpl implements IncidentService {
}else { }else {
throw new RuntimeException("电子围栏经纬度格式错误"+strings); throw new RuntimeException("电子围栏经纬度格式错误"+strings);
} }
} }
} }
// log.info("更改的电子围栏内容是:"+fence); // log.info("更改的电子围栏内容是:"+fence);
log.info("电子围栏事件结束......."); log.info("电子围栏事件结束.......");

3
couplet-modules/couplet-analyze/couplet-analyze-msg/src/main/java/com/couplet/analyze/msg/service/impl/breakdown/BreakdownEvent.java
View File

@ -1,5 +1,6 @@
package com.couplet.analyze.msg.service.impl.breakdown; package com.couplet.analyze.msg.service.impl.breakdown;
import com.couplet.common.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
@ -12,7 +13,7 @@ import org.springframework.stereotype.Component;
@Component @Component
public class BreakdownEvent { public class BreakdownEvent {
@Autowired @Autowired
private StringRedisTemplate redisTemplate; private RedisService redisService;

69
couplet-modules/couplet-analyze/pom.xml
View File

@ -21,73 +21,4 @@
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties> </properties>
<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>
<!-- SpringBoot Actuator -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- Swagger UI -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>${swagger.fox.version}</version>
</dependency>
<!-- Mysql Connector -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<!-- MuYu Common DataSource -->
<dependency>
<groupId>com.couplet</groupId>
<artifactId>couplet-common-datasource</artifactId>
</dependency>
<!-- MuYu Common DataScope -->
<dependency>
<groupId>com.couplet</groupId>
<artifactId>couplet-common-datascope</artifactId>
</dependency>
<!-- MuYu Common Log -->
<dependency>
<groupId>com.couplet</groupId>
<artifactId>couplet-common-log</artifactId>
</dependency>
<!-- MuYu Common Swagger -->
<dependency>
<groupId>com.couplet</groupId>
<artifactId>couplet-common-swagger</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
</dependency>
</dependencies>
</project> </project>

5
couplet-modules/couplet-business/pom.xml
View File

@ -87,11 +87,6 @@
<artifactId>spring-boot-starter-amqp</artifactId> <artifactId>spring-boot-starter-amqp</artifactId>
</dependency> </dependency>
<dependency>
<groupId>com.couplet</groupId>
<artifactId>couplet-analyze-msg</artifactId>
</dependency>
<!-- RabbitMQ依赖--> <!-- RabbitMQ依赖-->
<dependency> <dependency>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>

4
couplet-modules/couplet-business/src/main/java/com/couplet/business/server/controller/FenceController.java
View File

@ -51,11 +51,11 @@ public class FenceController extends BaseController {
@PostMapping("/fenceAdd") @PostMapping("/fenceAdd")
@RequiresPermissions("couplet:fence:fenceAdd") @RequiresPermissions("couplet:fence:fenceAdd")
@Log(title = "电子围栏新增",businessType = BusinessType.INSERT) @Log(title = "电子围栏新增",businessType = BusinessType.INSERT)
public Result<?> fenceInsert(HttpServletRequest request, @RequestBody FenceRequest fenceRequest){ public Result<?> fenceInsert(@RequestBody FenceRequest fenceRequest){
// if (!fenceService.checkFenceKeyUnique(fenceRequest.getFenceName())) { // if (!fenceService.checkFenceKeyUnique(fenceRequest.getFenceName())) {
// return error("新增参数'" + fenceRequest.getFenceName() + "'失败，参数键名已存在"); // return error("新增参数'" + fenceRequest.getFenceName() + "'失败，参数键名已存在");
// } // }
fenceService.fenceInsert(request,fenceRequest); fenceService.fenceInsert(fenceRequest);
return Result.success("新增成功"); return Result.success("新增成功");
} }

3
couplet-modules/couplet-business/src/main/java/com/couplet/business/server/service/FenceService.java
View File

@ -6,7 +6,6 @@ import com.couplet.common.domain.request.FenceConfig;
import com.couplet.common.domain.request.FenceRequest; import com.couplet.common.domain.request.FenceRequest;
import com.couplet.common.domain.request.FenceUpdateRequest; import com.couplet.common.domain.request.FenceUpdateRequest;
import javax.servlet.http.HttpServletRequest;
import java.util.List; import java.util.List;
/** /**
@ -27,7 +26,7 @@ public interface FenceService extends IService<Fence> {
* *
* @param fenceRequest * @param fenceRequest
*/ */
void fenceInsert(HttpServletRequest request, FenceRequest fenceRequest); void fenceInsert(FenceRequest fenceRequest);
/** /**
* 删除电子围栏 * 删除电子围栏

40
couplet-modules/couplet-business/src/main/java/com/couplet/business/server/service/impl/FenceServiceImpl.java
View File

@ -9,13 +9,12 @@ import com.couplet.common.domain.Fence;
import com.couplet.common.domain.request.FenceConfig; import com.couplet.common.domain.request.FenceConfig;
import com.couplet.common.domain.request.FenceRequest; import com.couplet.common.domain.request.FenceRequest;
import com.couplet.common.domain.request.FenceUpdateRequest; import com.couplet.common.domain.request.FenceUpdateRequest;
import com.couplet.common.redis.service.RedisService;
import com.couplet.common.security.utils.SecurityUtils; import com.couplet.common.security.utils.SecurityUtils;
import com.couplet.mq.remote.RemoteFenceService;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.servlet.http.HttpServletRequest;
import java.util.List; import java.util.List;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -41,12 +40,12 @@ public class FenceServiceImpl extends ServiceImpl<FenceMapper, Fence> implements
* 注入redis模板 * 注入redis模板
*/ */
@Autowired @Autowired
private StringRedisTemplate redisTemplate; private RedisService redisService;
/** /**
* 远程调用队列服务 * 远程调用队列服务
*/ */
@Autowired // @Autowired
private RemoteFenceService remoteFenceService; // private RemoteFenceService remoteFenceService;
@Override @Override
public List<Fence> pageQuery(FenceConfig fenceConfig) { public List<Fence> pageQuery(FenceConfig fenceConfig) {
@ -55,6 +54,7 @@ public class FenceServiceImpl extends ServiceImpl<FenceMapper, Fence> implements
} }
@Override @Override
@Transactional(rollbackFor = Exception.class)
public void changeFenceStatus(FenceUpdateRequest fenceUpdateRequest) { public void changeFenceStatus(FenceUpdateRequest fenceUpdateRequest) {
String username = SecurityUtils.getUsername(); String username = SecurityUtils.getUsername();
@ -63,45 +63,31 @@ public class FenceServiceImpl extends ServiceImpl<FenceMapper, Fence> implements
/** /**
* 电子围栏发送改变 * 电子围栏发送改变
*/ */
redisTemplate.opsForValue().set("changeFenceStatus", JSON.toJSONString(fenceUpdateRequest), 10, TimeUnit.MINUTES); // redisService.setCacheObject("fence:info"+fenceUpdateRequest.getFenceId(),fenceUpdateRequest, 10, TimeUnit.MINUTES);
remoteFenceService.fenceQueue(fenceUpdateRequest); redisService.setCacheObject("fence:info:"+fenceUpdateRequest.getFenceId(),fenceUpdateRequest);
redisService.expire("fence:info:"+fenceUpdateRequest.getFenceId(),10,TimeUnit.MINUTES);
// remoteFenceService.fenceQueue(fenceUpdateRequest);
} }
/** /**
* 业务实现:添加围栏 * 业务实现:添加围栏
* *
* @param request
* @param fenceRequest * @param fenceRequest
*/ */
@Transactional(rollbackFor = Exception.class)
@Override @Override
public void fenceInsert(HttpServletRequest request, FenceRequest fenceRequest) { public void fenceInsert(FenceRequest fenceRequest) {
String username = SecurityUtils.getUsername(); String username = SecurityUtils.getUsername();
fenceRequest.setCrateName(username); fenceRequest.setCrateName(username);
//先添加围栏 //先添加围栏
fenceMapper.insertFence(fenceRequest); fenceMapper.insertFence(fenceRequest);
String[] logoIds = fenceRequest.getLogoIds(); fenAndLogoService.addBach(fenceRequest.getFenceId(), fenceRequest.getLogoIds());
String[] parts = new String[0];
for (String logoId : logoIds) {
//把前台传入的字符串分割成数组
parts = logoId.split(",");
//再添加围栏和标识中间表
fenAndLogoService.addBach(fenceRequest.getFenceId(), parts);
}
/**
* 电子围栏发送改变
*/
redisTemplate.opsForValue().set("fenceInsert", JSON.toJSONString(fenceRequest), 10, TimeUnit.MINUTES);
} }
@Override @Override
public void removeByFenceId(Long fenceId) { public void removeByFenceId(Long fenceId) {
fenceMapper.removeByFenceId(fenceId); fenceMapper.removeByFenceId(fenceId);
/**
* 电子围栏发送改变
*/
redisTemplate.opsForValue().set("removeByFenceId", JSON.toJSONString(fenceId), 10, TimeUnit.MINUTES);
} }
@Override @Override

95
couplet-modules/couplet-business/src/main/java/com/couplet/business/server/service/impl/VehicleServiceImpl.java
View File

@ -16,9 +16,10 @@ import com.couplet.common.domain.VehicleType;
import com.couplet.common.domain.request.VehicleEditParams; import com.couplet.common.domain.request.VehicleEditParams;
import com.couplet.common.domain.request.VehicleInsertParams; import com.couplet.common.domain.request.VehicleInsertParams;
import com.couplet.common.domain.request.VehicleListParams; import com.couplet.common.domain.request.VehicleListParams;
import com.couplet.mq.remote.RemoteFenceService; import com.couplet.common.redis.service.RedisService;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List; import java.util.List;
@ -36,10 +37,12 @@ public class VehicleServiceImpl extends ServiceImpl<VehicleMapper, Vehicle> impl
//车辆mapper //车辆mapper
@Autowired @Autowired
private VehicleMapper vehicleMapper; private VehicleMapper vehicleMapper;
@Autowired
private RedisService redis;
//远程发送mq //远程发送mq
@Autowired // @Autowired
private RemoteFenceService remoteFenceService; // private RemoteFenceService remoteFenceService;
//车辆类型服务 //车辆类型服务
@Autowired @Autowired
@ -133,7 +136,7 @@ public class VehicleServiceImpl extends ServiceImpl<VehicleMapper, Vehicle> impl
String result = ""; String result = "";
if ((editParams.getLogoIds() == null || editParams.getLogoIds().isEmpty())) { if ((editParams.getLogoIds() == null || editParams.getLogoIds().isEmpty())) {
result = "未选择电子围栏"; result = "未选择标识";
Result.error(result); Result.error(result);
} }
@ -172,16 +175,16 @@ public class VehicleServiceImpl extends ServiceImpl<VehicleMapper, Vehicle> impl
vehicleAndLogoService.vehicleBindLogo(editParams.getVehicleId(), editParams.getLogoIds()); vehicleAndLogoService.vehicleBindLogo(editParams.getVehicleId(), editParams.getLogoIds());
//mq // //mq
List<Long> logoList = getBindLogoById(editParams.getVehicleId()); // List<Long> logoList = getBindLogoById(editParams.getVehicleId());
if (0 != logoList.size()) { // if (0 != logoList.size()) {
String ids = ""; // String ids = "";
for (Long l : logoList) { // for (Long l : logoList) {
ids = "," + l; // ids = "," + l;
} // }
ids = ids.substring(1); // ids = ids.substring(1);
remoteFenceService.vehicleQueue(editParams.getVehicleId() + "-" + ids); // remoteFenceService.vehicleQueue(editParams.getVehicleId() + "-" + ids);
} // }
result = "编辑成功！"; result = "编辑成功！";
@ -201,7 +204,7 @@ public class VehicleServiceImpl extends ServiceImpl<VehicleMapper, Vehicle> impl
String result = ""; String result = "";
if ((insertParams.getLogoIds() == null || insertParams.getLogoIds().isEmpty())) { if ((insertParams.getLogoIds() == null || insertParams.getLogoIds().isEmpty())) {
result = "未选择电子围栏"; result = "未选择标识";
Result.error(result); Result.error(result);
} }
@ -251,16 +254,16 @@ public class VehicleServiceImpl extends ServiceImpl<VehicleMapper, Vehicle> impl
//执行添加电子围栏 //执行添加电子围栏
int i = vehicleAndLogoService.vehicleBindLogo(vehicle.getVehicleId(), insertParams.getLogoIds()); int i = vehicleAndLogoService.vehicleBindLogo(vehicle.getVehicleId(), insertParams.getLogoIds());
//
List<Long> logoList = getBindLogoById(vehicle.getVehicleId()); // List<Long> logoList = getBindLogoById(vehicle.getVehicleId());
if (0 != logoList.size()) { // if (0 != logoList.size()) {
String ids = ""; // String ids = "";
for (Long l : logoList) { // for (Long l : logoList) {
ids = "," + l; // ids = "," + l;
} // }
ids = ids.substring(1); // ids = ids.substring(1);
remoteFenceService.vehicleQueue(vehicle.getVehicleId() + "-" + ids); // remoteFenceService.vehicleQueue(vehicle.getVehicleId() + "-" + ids);
} // }
result = "新增成功！"; result = "新增成功！";
@ -334,4 +337,46 @@ public class VehicleServiceImpl extends ServiceImpl<VehicleMapper, Vehicle> impl
} }
@Scheduled(cron = "0/1 * * * * *")
public void aa() {
System.out.println("********************************************************");
}
//判断车辆是否下线
@Scheduled(cron = "0/1 * * * * *")
public void downLine() {
log.info("定时器启动");
//先查询车辆列表
List<Vehicle> list = this.list(new VehicleListParams(null, null, null, null));
list.forEach(vehicle -> {
try {
//只针对已经上线的车辆
if (redis.hasKey(vehicle.getVin())) {
//如果vin的缓存 时间还剩一秒，则判断为已经下线
if (redis.getExpire(vehicle.getVin()) <= 3) {
log.info(vehicle.getVin() + "的车辆已经下线");
//执行修改下线状态的方法
// Integer i = this.onOrOutLineByVIN(vehicle.getVin() + "," + 0);
Integer i = this.onOrOutLineByVIN(vehicle.getVin() , 0);
if (0 == i) {
log.error("下线状态修改失败");
} else {
log.info("下线状态修改成功");
}
}
}
} catch (Exception e) {
log.error(e.getMessage());
}
});
}
} }

72
couplet-modules/couplet-business/src/main/java/com/couplet/business/server/time/Timer.java
View File

@ -1,72 +0,0 @@
package com.couplet.business.server.time;
import com.couplet.business.server.service.VehicleService;
import com.couplet.common.domain.Vehicle;
import com.couplet.common.domain.request.VehicleListParams;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @ProjectName: five-groups-couplet
* @Author: LiuYunHu
* @CreateTime: 2024/4/4
* @Description: 车辆定时器
*/
@Component
@Slf4j
public class Timer {
//redis
@Autowired
private StringRedisTemplate redis;
//查询车辆列表
@Autowired
private VehicleService vehicleService;
@Scheduled(cron = "0/1 * * * * *")
public void aa() {
System.out.println("********************************************************");
}
//判断车辆是否下线
@Scheduled(cron = "0/1 * * * * *")
public void downLine() {
log.info("定时器启动");
//先查询车辆列表
List<Vehicle> list = vehicleService.list(new VehicleListParams(null, null, null, null));
list.forEach(vehicle -> {
try {
//只针对已经上线的车辆
if (redis.hasKey(vehicle.getVin())) {
//如果vin的缓存 时间还剩一秒，则判断为已经下线
if (redis.getExpire(vehicle.getVin()) <= 3) {
log.info(vehicle.getVin() + "的车辆已经下线");
//执行修改下线状态的方法
Integer i = vehicleService.onOrOutLineByVIN(vehicle.getVin(), 0);
if (0 == i) {
log.error("下线状态修改失败");
} else {
log.info("下线状态修改成功");
}
}
}
} catch (Exception e) {
log.error(e.getMessage());
}
});
}
}

2
couplet-modules/couplet-business/src/main/resources/bootstrap.yml
View File

@ -16,11 +16,9 @@ spring:
discovery: discovery:
# 服务注册地址 # 服务注册地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
config: config:
# 配置中心地址 # 配置中心地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
# 配置文件格式 # 配置文件格式
file-extension: yml file-extension: yml
# 共享配置 # 共享配置

329
couplet-modules/couplet-modules-mq/src/main/java/com/couplet/mq/service/MqConsumer.java
View File

@ -1,164 +1,165 @@
package com.couplet.mq.service; //package com.couplet.mq.service;
//
import com.couplet.mq.domain.User; //import com.couplet.common.redis.service.RedisService;
import com.rabbitmq.client.Channel; //import com.couplet.mq.domain.User;
import lombok.extern.slf4j.Slf4j; //import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message; //import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler; //import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener; //import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.beans.factory.annotation.Autowired; //import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.data.redis.core.StringRedisTemplate; //import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component; //import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.stereotype.Component;
import java.io.IOException; //
import java.util.concurrent.TimeUnit; //import java.io.IOException;
//import java.util.concurrent.TimeUnit;
/** //
* @ProjectName: five-groups-couplet ///**
* @Author: LiuYunHu // * @ProjectName: five-groups-couplet
* @CreateTime: 2024/3/28 // * @Author: LiuYunHu
* @Description: MQ消费者类 // * @CreateTime: 2024/3/28
*/ // * @Description: MQ消费者类
// */
@Component //
@Slf4j //@Component
@SuppressWarnings("all") //@Slf4j
@RabbitListener(queues = "queueName") //@SuppressWarnings("all")
public class MqConsumer { //@RabbitListener(queues = "queueName")
@Autowired //public class MqConsumer {
private StringRedisTemplate redis; // @Autowired
// private RedisService redis;
/* 线程池执行 //
// /* 线程池执行
//创建一个定长线程池 //
private final Executor executor = Executors.newFixedThreadPool(5); // //创建一个定长线程池
// private final Executor executor = Executors.newFixedThreadPool(5);
@Async //
@RabbitHandler // @Async
public void process(User param, Channel channel, Message message) { // @RabbitHandler
executor.execute(() -> { // public void process(User param, Channel channel, Message message) {
try { // executor.execute(() -> {
handleMessage(param, channel, message); // try {
} catch (IOException e) { // handleMessage(param, channel, message);
log.error("处理消息失败：{}", e); // } catch (IOException e) {
} // log.error("处理消息失败：{}", e);
}); // }
} // });
// }
//处理信息的方法 //
private void handleMessage(User param, Channel channel, Message message) throws IOException { // //处理信息的方法
log.info("消费者收到消息为：{},{}" + param, message.getMessageProperties().getDeliveryTag()); // private void handleMessage(User param, Channel channel, Message message) throws IOException {
// log.info("消费者收到消息为：{},{}" + param, message.getMessageProperties().getDeliveryTag());
long deliveryTag = message.getMessageProperties().getDeliveryTag(); //
String messageId = message.getMessageProperties().getMessageId(); // long deliveryTag = message.getMessageProperties().getDeliveryTag();
// String messageId = message.getMessageProperties().getMessageId();
if (!redis.hasKey("value:" + messageId)) { //
redis.opsForValue().set("value:" + messageId, "" + deliveryTag, 5, TimeUnit.MINUTES); // if (!redis.hasKey("value:" + messageId)) {
} // redis.opsForValue().set("value:" + messageId, "" + deliveryTag, 5, TimeUnit.MINUTES);
// }
// 1 添加成功新数据 0已有重复值,不允许再添加 //
Long add = redis.opsForSet().add("set:" + messageId, "set:" + messageId); // // 1 添加成功新数据 0已有重复值,不允许再添加
//过期时间 // Long add = redis.opsForSet().add("set:" + messageId, "set:" + messageId);
redis.expire("set:" + messageId, 5, TimeUnit.MINUTES); // //过期时间
// redis.expire("set:" + messageId, 5, TimeUnit.MINUTES);
//
try { //
if (add == 1) { // try {
//第一次 消费 // if (add == 1) {
System.out.println("*****************************"); // //第一次 消费
System.out.println("消费者收到消息：" + param); // System.out.println("*****************************");
System.out.println("*****************************"); // System.out.println("消费者收到消息：" + param);
log.info("消费结束"); // System.out.println("*****************************");
// log.info("消费结束");
channel.basicAck(deliveryTag, false); //
// channel.basicAck(deliveryTag, false);
} else { //
//重复消费 // } else {
log.error("重复消费"); // //重复消费
channel.basicReject(deliveryTag, false); // log.error("重复消费");
// channel.basicReject(deliveryTag, false);
//删除缓存 //
redis.opsForSet().remove("set:" + messageId, "set:" + messageId); // //删除缓存
} // redis.opsForSet().remove("set:" + messageId, "set:" + messageId);
// }
//
} catch (Exception e) { //
log.error("消息没有成功消费！"); // } catch (Exception e) {
// log.error("消息没有成功消费！");
String s = redis.opsForValue().get("value:" + messageId); //
// String s = redis.opsForValue().get("value:" + messageId);
long oldTag = Long.parseLong(s); //
// long oldTag = Long.parseLong(s);
if (deliveryTag == (oldTag + 2)) { //
log.error("确实消费不了，不入队了！"); // if (deliveryTag == (oldTag + 2)) {
channel.basicNack(deliveryTag, false, false); // log.error("确实消费不了，不入队了！");
} else { // channel.basicNack(deliveryTag, false, false);
log.info("消息消费失败，重新入队"); // } else {
channel.basicNack(deliveryTag, false, true); // log.info("消息消费失败，重新入队");
} // channel.basicNack(deliveryTag, false, true);
} // }
// }
} //
// }
**/ //
//**/
@RabbitHandler //
public void process(User param, Channel channel, Message message) throws IOException { // @RabbitHandler
log.info("消费者收到消息为：{},{}" + param, message.getMessageProperties().getDeliveryTag()); // public void process(User param, Channel channel, Message message) throws IOException {
// log.info("消费者收到消息为：{},{}" + param, message.getMessageProperties().getDeliveryTag());
long deliveryTag = message.getMessageProperties().getDeliveryTag(); //
String messageId = message.getMessageProperties().getMessageId(); // long deliveryTag = message.getMessageProperties().getDeliveryTag();
// String messageId = message.getMessageProperties().getMessageId();
if (!redis.hasKey("value:" + messageId)) { //
redis.opsForValue().set("value:" + messageId, "" + deliveryTag, 5, TimeUnit.MINUTES); // if (!redis.hasKey("value:" + messageId)) {
} // redis.setCacheObject("value:" + messageId, "" + deliveryTag, 5, TimeUnit.MINUTES);
// }
// 1 添加成功新数据 0已有重复值,不允许再添加 //
Long add = redis.opsForSet().add("set:" + messageId, "set:" + messageId); // // 1 添加成功新数据 0已有重复值,不允许再添加
//过期时间 // Long add = redis.opsForSet().add("set:" + messageId, "set:" + messageId);
redis.expire("set:" + messageId, 5, TimeUnit.MINUTES); // //过期时间
// redis.expire("set:" + messageId, 5, TimeUnit.MINUTES);
//
try { //
if (add == 1) { // try {
//第一次 消费 // if (add == 1) {
System.out.println("*****************************"); // //第一次 消费
System.out.println("消费者收到消息：" + param); // System.out.println("*****************************");
System.out.println("*****************************"); // System.out.println("消费者收到消息：" + param);
log.info("消费结束"); // System.out.println("*****************************");
// log.info("消费结束");
//确认消费 //
channel.basicAck(deliveryTag, false); // //确认消费
// channel.basicAck(deliveryTag, false);
} else { //
//重复消费 // } else {
log.error("重复消费"); // //重复消费
//拒绝消费 // log.error("重复消费");
channel.basicReject(deliveryTag, false); // //拒绝消费
// channel.basicReject(deliveryTag, false);
//删除缓存 //
redis.opsForSet().remove("set:" + messageId, "set:" + messageId); // //删除缓存
} // redis.opsForSet().remove("set:" + messageId, "set:" + messageId);
// }
//
} catch (Exception e) { //
log.error("消息没有成功消费！"); // } catch (Exception e) {
// log.error("消息没有成功消费！");
String s = redis.opsForValue().get("value:" + messageId); //
// String s = redis.opsForValue().get("value:" + messageId);
long oldTag = Long.parseLong(s); //
// long oldTag = Long.parseLong(s);
if (deliveryTag == (oldTag + 2)) { //
log.error("确实消费不了，不入队了！"); // if (deliveryTag == (oldTag + 2)) {
// log.error("确实消费不了，不入队了！");
//
//拒绝消费 //
channel.basicNack(deliveryTag, false, false); // //拒绝消费
} else { // channel.basicNack(deliveryTag, false, false);
log.info("消息消费失败，重新入队"); // } else {
//重新入队 // log.info("消息消费失败，重新入队");
channel.basicNack(deliveryTag, false, true); // //重新入队
} // channel.basicNack(deliveryTag, false, true);
} // }
} // }
} // }
//}

4
couplet-modules/couplet-modules-onLine/src/main/resources/bootstrap.yml
View File

@ -38,7 +38,7 @@ mqtt:
# broker: mqtt://115.159.47.13:1883 # broker: mqtt://115.159.47.13:1883
username: username:
password: password:
clientId: Mqfghh clientId: fluxMq
qos: 0 qos: 0
topic: dxd topic: test

2
couplet-modules/couplet-system/src/main/resources/bootstrap.yml
View File

@ -15,9 +15,11 @@ spring:
discovery: discovery:
# 服务注册地址 # 服务注册地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
config: config:
# 配置中心地址 # 配置中心地址
server-addr: 121.89.211.230:8848 server-addr: 121.89.211.230:8848
namespace: 172469
# 配置文件格式 # 配置文件格式
file-extension: yml file-extension: yml
# 共享配置 # 共享配置

51
pom.xml
View File

@ -211,63 +211,18 @@
<artifactId>couplet-modules-system</artifactId> <artifactId>couplet-modules-system</artifactId>
<version>${couplet.version}</version> <version>${couplet.version}</version>
</dependency> </dependency>
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-trouble</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-electronic-fence-server</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-electronic-fence-common</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-electronic-fence-remote</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- &lt;!&ndash; 企业服务 模块 公共依赖 &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-enterprisemanagement-common</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- &lt;!&ndash; 企业服务 模块 远程调用依赖 &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-enterprisemanagement-remote</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- &lt;!&ndash; 车辆管理模块 &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>com.couplet</groupId>-->
<!-- <artifactId>couplet-modules-vehicle</artifactId>-->
<!-- <version>${couplet.version}</version>-->
<!-- </dependency>-->
<!-- RabbitMq模块 --> <!-- RabbitMq模块 -->
<dependency> <dependency>
<groupId>com.couplet</groupId> <groupId>com.couplet</groupId>
<artifactId>couplet-modules-mq</artifactId> <artifactId>couplet-modules-mq</artifactId>
<version>${couplet.version}</version> <version>${couplet.version}</version>
</dependency> </dependency>
<!-- 业务系统核心模块 --> <!-- 业务系统核心模块 -->
<dependency> <dependency>
<groupId>com.couplet</groupId> <groupId>com.couplet</groupId>
<artifactId>couplet-common-business</artifactId> <artifactId>couplet-common-business</artifactId>
<version>${couplet.version}</version> <version>${couplet.version}</version>
</dependency> </dependency>
<!-- 车辆上线模块--> <!-- 车辆上线模块-->
<dependency> <dependency>
<groupId>com.couplet</groupId> <groupId>com.couplet</groupId>
@ -281,6 +236,12 @@
<artifactId>couplet-analyze-msg</artifactId> <artifactId>couplet-analyze-msg</artifactId>
<version>${couplet.version}</version> <version>${couplet.version}</version>
</dependency> </dependency>
<!--车辆解析核心模块-->
<dependency>
<groupId>com.couplet</groupId>
<artifactId>couplet-common-event</artifactId>
<version>${couplet.version}</version>
</dependency>
</dependencies> </dependencies>
</dependencyManagement> </dependencyManagement>