[add] 绿波数据优化

signal-feign-service/src/main/resources/application-docker.properties

-utc.service.url=http://192.168.150.1:32000/utc
-utc.dt.service.url=http://192.168.150.1:39002/utc-dt
-utc.hisense.service.url=http://192.168.150.1:39003/utc-hisense
-control.url=http://192.168.150.1:32001/web
-ehualu.url=http://192.168.150.1:30015
+utc.service.url=http://173.0.0.1:32000/utc
+utc.dt.service.url=http://173.0.0.1:39002/utc-dt
+utc.hisense.service.url=http://173.0.0.1:39003/utc-hisense
+control.url=http://173.0.0.1:32001/web
+ehualu.url=http://173.0.0.1:30015
\ No newline at end of file

signal-feign-service/src/main/resources/application-greencity.properties

-utc.service.url=http://37.12.182.29:32000/utc
-utc.dt.service.url=http://37.12.182.29:39002/utc-dt
-utc.hisense.service.url=http://37.12.182.29:39003/utc-hisense
-control.url=http://37.12.182.29:32001/web
+utc.service.url=http://173.0.0.1:32000/utc
+utc.dt.service.url=http://173.0.0.1:39002/utc-dt
+utc.hisense.service.url=http://173.0.0.1:39003/utc-hisense
+control.url=http://173.0.0.1:32001/web
+ehualu.url=http://173.0.0.1:30015

signal-optimize-service/src/main/java/net/wanji/opt/common/RedisConfig.java

@@ -3,6 +3,7 @@ package net.wanji.opt.common;
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
 import org.springframework.beans.factory.annotation.Value;
@@ -16,6 +17,7 @@ import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.cache.RedisCacheWriter;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 import redis.clients.jedis.JedisPool;
@@ -71,23 +73,22 @@ public class RedisConfig extends CachingConfigurerSupport {
 
 
     @Bean
-    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
         RedisTemplate<String, Object> template = new RedisTemplate<>();
-        template.setConnectionFactory(connectionFactory);
+        template.setConnectionFactory(factory);
 
-        // 使用 Jackson2JsonRedisSerializer 替代默认的 JDK 序列化器
-        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
+        // 使用 Jackson 作为序列化器
         ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
         objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
-                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
-        serializer.setObjectMapper(objectMapper);
+                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
 
-        template.setKeySerializer(new StringRedisSerializer()); // 设置 Key 的序列化器
-        template.setValueSerializer(serializer); // 设置 Value 的序列化器
+        GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer(objectMapper);
+
+        template.setValueSerializer(serializer);
+        template.setKeySerializer(new StringRedisSerializer());
         template.setHashKeySerializer(new StringRedisSerializer());
         template.setHashValueSerializer(serializer);
-
         template.afterPropertiesSet();
         return template;
     }

signal-optimize-service/src/main/java/net/wanji/opt/po/StrategyGreenOptHistEntity.java

@@ -18,7 +18,7 @@ public class StrategyGreenOptHistEntity {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
     @TableField("green_id")
-    private String greenId;
+    private Integer greenId;
     @TableField("length")
     private Double length;
     @TableField("cycle")

signal-optimize-service/src/main/java/net/wanji/opt/synthesis/controller/StrategyGreenBeltController.java

@@ -5,16 +5,14 @@ import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
 import net.wanji.common.framework.rest.JsonViewObject;
-import net.wanji.common.utils.tool.JacksonUtils;
-import net.wanji.opt.common.Constants;
-import net.wanji.opt.common.RedisUtils;
-import net.wanji.opt.service.GreenBeltInfoService;
+import net.wanji.opt.synthesis.service.impl.StrategyGreenBeltServiceImpl;
 import net.wanji.opt.vo.GreenBeltChartVO;
 import net.wanji.opt.vo.GreenBeltInfoVO;
 import org.springframework.web.bind.annotation.*;
 
 import javax.annotation.Resource;
 import javax.ws.rs.core.MediaType;
+import java.util.Date;
 
 /**
  * @author duanruiming
@@ -27,9 +25,7 @@ import javax.ws.rs.core.MediaType;
 public class StrategyGreenBeltController {
 
     @Resource
-    private RedisUtils redisUtils;
-    @Resource
-    private GreenBeltInfoService greenBeltInfoService;
+    private StrategyGreenBeltServiceImpl strategyGreenBeltService;
 
     @ApiOperation(value = "绿波时序图数据查询", notes = "绿波时序图数据查询", response = JsonViewObject.class,
             produces = MediaType.APPLICATION_JSON, consumes = MediaType.APPLICATION_JSON)
@@ -38,11 +34,11 @@ public class StrategyGreenBeltController {
             @ApiResponse(code = 200, message = "OK", response = GreenBeltInfoVO.class),
     })
     public JsonViewObject greenBletData(String greenId) throws Exception {
-        String key = Constants.GREEN_ID_OPT_KEY.concat(greenId);
-        Object obj = redisUtils.get(key);
+        //String key = Constants.GREEN_ID_OPT_KEY.concat(greenId);
+        //Object obj = redisUtils.get(key);
         JsonViewObject jsonViewObject = JsonViewObject.newInstance();
-        GreenBeltInfoVO greenBeltInfoVO = JacksonUtils.getInstance().readValue(String.valueOf(obj), GreenBeltInfoVO.class);
-        return jsonViewObject.success(greenBeltInfoVO);
+        //GreenBeltInfoVO greenBeltInfoVO = JacksonUtils.getInstance().readValue(String.valueOf(obj), GreenBeltInfoVO.class);
+        return jsonViewObject.success(null);
     }
 
     @ApiOperation(value = "绿波时序图图形查询", notes = "绿波时序图图形查询", response = JsonViewObject.class,
@@ -51,11 +47,9 @@ public class StrategyGreenBeltController {
     @ApiResponses({
             @ApiResponse(code = 200, message = "OK", response = GreenBeltInfoVO.class),
     })
-    public JsonViewObject greenBeltChart(String greenId) throws Exception {
-        String key = Constants.GREEN_ID_OPT_CHART_KEY.concat(greenId);
-        Object obj = redisUtils.get(key);
-        JsonViewObject jsonViewObject = JsonViewObject.newInstance();
-        GreenBeltChartVO greenBeltChartVO = JacksonUtils.getInstance().readValue((String)obj, GreenBeltChartVO.class);
-        return jsonViewObject.success(greenBeltChartVO);
+    public JsonViewObject greenBeltChart(Integer greenId, Date date) throws Exception {
+        GreenBeltChartVO greenBeltChartVO = strategyGreenBeltService.selectChart(greenId, date);
+        return JsonViewObject.newInstance().success(greenBeltChartVO);
     }
+
 }

signal-optimize-service/src/main/java/net/wanji/opt/synthesis/service/StrategyGreenBeltService.java

+package net.wanji.opt.synthesis.service;
+
+import net.wanji.opt.vo.GreenBeltChartVO;
+
+import java.util.Date;
+
+/**
+ * @author duanruiming
+ * @date 2024/11/25 13:53
+ */
+public interface StrategyGreenBeltService {
+
+    GreenBeltChartVO selectChart(Integer greenId, Date queryDate);
+}

signal-optimize-service/src/main/java/net/wanji/opt/synthesis/service/impl/StrategyGreenBeltServiceImpl.java

+package net.wanji.opt.synthesis.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import net.wanji.common.utils.tool.JacksonUtils;
+import net.wanji.opt.dao.mapper.StrategyGreenOptHistMapper;
+import net.wanji.opt.po.StrategyGreenOptHistEntity;
+import net.wanji.opt.synthesis.service.StrategyGreenBeltService;
+import net.wanji.opt.vo.GreenBeltChartVO;
+import net.wanji.opt.vo.GreenBeltInfoVO;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author duanruiming
+ * @date 2024/11/25 13:53
+ */
+@Service
+@Slf4j
+public class StrategyGreenBeltServiceImpl implements StrategyGreenBeltService {
+
+    @Resource
+    StrategyGreenOptHistMapper strategyGreenOptHistMapper;
+
+    @Override
+    public GreenBeltChartVO selectChart(Integer greenId, Date queryDate) {
+        try {
+            ObjectMapper mapper = JacksonUtils.getInstance();
+            QueryWrapper<StrategyGreenOptHistEntity> queryWrapper = new QueryWrapper<>();
+            String customOrderBy = "ABS(DATEDIFF(control_time, '" + queryDate + "'))";
+            queryWrapper.orderByAsc(true, customOrderBy);
+            queryWrapper.last("LIMIT 2");
+            List<StrategyGreenOptHistEntity> entities = strategyGreenOptHistMapper.selectList(queryWrapper);
+            if (!CollectionUtils.isEmpty(entities)) {
+                Map<String, List<StrategyGreenOptHistEntity>> controlTimeMap = entities.stream().collect(Collectors.groupingBy(StrategyGreenOptHistEntity::getControlTime));
+                // 判断下发是否是正向还是反向 相同时间两条，双向绿波
+                GreenBeltInfoVO greenBeltInfoVO = new GreenBeltInfoVO();
+                List<GreenBeltInfoVO.DirGreenDetail> dirGreenDetails = new ArrayList<>();
+                // 相同时间，双向绿波
+                if (controlTimeMap.size() == 1) {
+                    setBeltInfo(mapper, entities, greenBeltInfoVO, dirGreenDetails);
+                } else {
+                    entities.remove(entities.size() - 1);
+                    setBeltInfo(mapper, entities, greenBeltInfoVO, dirGreenDetails);
+                }
+                greenBeltInfoVO.setDirGreenDetails(dirGreenDetails);
+                System.err.println(greenBeltInfoVO);
+                GreenBeltChartVO greenBeltChartVO = calGreenChart(greenBeltInfoVO);
+                return greenBeltChartVO;
+            }
+        } catch (Exception e) {
+            log.error("数据转化异常", e);
+            throw new RuntimeException(e);
+        }
+        return null;
+    }
+
+    private static void setBeltInfo(ObjectMapper mapper, List<StrategyGreenOptHistEntity> entities, GreenBeltInfoVO greenBeltInfoVO, List<GreenBeltInfoVO.DirGreenDetail> dirGreenDetails) throws JsonProcessingException {
+        for (StrategyGreenOptHistEntity entity : entities) {
+            greenBeltInfoVO.setGreenId(String.valueOf(entity.getGreenId()));
+            greenBeltInfoVO.setLength(entity.getLength());
+            greenBeltInfoVO.setCycle(entity.getCycle());
+            greenBeltInfoVO.setControlTime(entity.getControlTime());
+            greenBeltInfoVO.setControlDuration(entity.getControlDuration());
+            greenBeltInfoVO.setType(entity.getType());
+            greenBeltInfoVO.setDynamic(entity.getDynamic());
+            greenBeltInfoVO.setControlMethod(entity.getControlMethod());
+
+            GreenBeltInfoVO.DirGreenDetail dirGreenDetail = new GreenBeltInfoVO.DirGreenDetail();
+            dirGreenDetail.setDirType(entity.getDirType());
+            dirGreenDetail.setDir(entity.getDir());
+            dirGreenDetail.setMaxSpeed(entity.getMaxSpeed());
+            dirGreenDetail.setMinSpeed(entity.getMinSpeed());
+            dirGreenDetail.setGreenWidthTime(entity.getGreenWidthTime());
+            String crossGreenDetail = entity.getCrossGreenDetail();
+            List<GreenBeltInfoVO.CrossGreenDetail> crossGreenDetails = mapper.readValue(crossGreenDetail, new TypeReference<List<GreenBeltInfoVO.CrossGreenDetail>>() {});
+            dirGreenDetail.setCrossGreenDetailList(crossGreenDetails);
+            dirGreenDetails.add(dirGreenDetail);
+        }
+    }
+
+    private static GreenBeltChartVO calGreenChart(GreenBeltInfoVO greenBeltInfoVO) throws JsonProcessingException {
+        ObjectMapper mapper = JacksonUtils.getInstance();
+        Map<String, List<List<Double>>> crossRedTimesMap = new TreeMap<>();
+        Map<String, List<List<Double>>> backCrossRedTimesMap = new TreeMap<>();
+        Map<String, Double> crossGreenStartMap = new TreeMap<>();
+        Map<String, Double> backCrossGreenStartMap = new TreeMap<>();
+        Map<String, Double> distanceMap = new TreeMap<>();
+        // 处理绿波时序图数据
+        List<GreenBeltInfoVO.DirGreenDetail> dirGreenDetails = greenBeltInfoVO.getDirGreenDetails();
+        Double greenWidthTime = 0.0;
+        Double backGreenWidthTime = 0.0;
+        if (!CollectionUtils.isEmpty(dirGreenDetails)) {
+            Integer cycle = greenBeltInfoVO.getCycle();
+            for (GreenBeltInfoVO.DirGreenDetail dirGreenDetail : dirGreenDetails) {
+                Integer dirType = dirGreenDetail.getDirType();
+                if (dirType == 1) {
+                    greenWidthTime = dirGreenDetail.getGreenWidthTime();
+                    List<GreenBeltInfoVO.CrossGreenDetail> list = dirGreenDetail.getCrossGreenDetailList();
+                    getaDouble(crossRedTimesMap, crossGreenStartMap, distanceMap, cycle, list);
+                }
+                if (dirType == 0) {
+                    backGreenWidthTime = dirGreenDetail.getGreenWidthTime();
+                    List<GreenBeltInfoVO.CrossGreenDetail> list = dirGreenDetail.getCrossGreenDetailList();
+                    Collections.reverse(list);
+                    getaDouble(backCrossRedTimesMap, backCrossGreenStartMap, distanceMap, cycle, list);
+
+                }
+            }
+        }
+        GreenBeltChartVO greenBeltChartVO = new GreenBeltChartVO();
+        greenBeltChartVO.setGreenWidthTime(greenWidthTime);
+        greenBeltChartVO.setBackGreenWidthTime(backGreenWidthTime);
+        greenBeltChartVO.setCrossRedTimesMap(mapper.writeValueAsString(crossRedTimesMap));
+        greenBeltChartVO.setBackCrossRedTimesMap(mapper.writeValueAsString(backCrossRedTimesMap));
+        greenBeltChartVO.setGreenStartMap(mapper.writeValueAsString(crossGreenStartMap));
+        greenBeltChartVO.setBackGreenStartMap(mapper.writeValueAsString(backCrossGreenStartMap));
+        greenBeltChartVO.setDistanceMap(mapper.writeValueAsString(distanceMap));
+        return greenBeltChartVO;
+    }
+
+    private static void getaDouble(Map<String, List<List<Double>>> crossRedTimesMap, Map<String, Double> crossGreenStartMap, Map<String, Double> distanceMap,
+                                   Integer cycle, List<GreenBeltInfoVO.CrossGreenDetail> crossGreenDetailList) {
+        if (!CollectionUtils.isEmpty(crossGreenDetailList)) {
+
+            // 所有行程时间
+            double totalTravel = crossGreenDetailList.stream().mapToDouble(GreenBeltInfoVO.CrossGreenDetail::getTravelTime).sum();
+            GreenBeltInfoVO.CrossGreenDetail firstCrossGreenDetail = crossGreenDetailList.get(0);
+            Double firstOffset = firstCrossGreenDetail.getOffset();
+            Double firstPhaseStartTime = firstCrossGreenDetail.getPhaseStartTime();
+            Double firstGreenStart = firstCrossGreenDetail.getGreenStartTime();
+            double cycleSum = Math.ceil((totalTravel + firstOffset + firstPhaseStartTime + firstGreenStart) / cycle);
+            Double crossGreenStartTime = firstOffset + firstPhaseStartTime + firstGreenStart;
+            for (GreenBeltInfoVO.CrossGreenDetail crossGreenDetail : crossGreenDetailList) {
+                List<List<Double>> redTimes = new ArrayList<>();
+                String crossId = crossGreenDetail.getCrossId();
+                Double offset = crossGreenDetail.getOffset();
+                Double phaseStartTime = crossGreenDetail.getPhaseStartTime();
+                Double travelTime = crossGreenDetail.getTravelTime();
+                Double distance = crossGreenDetail.getDistance();
+                // 相位结束时间大于周期，绿灯时时间补到周期开始位置
+                Double cycleD = Double.valueOf(cycle);
+                Double phaseEndTime = crossGreenDetail.getPhaseEndTime();
+
+                for (int i = 0; i < cycleSum; i++) {
+                    // 周期 + 相位差
+                    Double cycleIndex = i * cycleD;
+                    Double phaseReverseStartTime = phaseEndTime.intValue() - cycleD;
+                    // 最后结尾要将前面相位差时间补充为周期
+                    Double endCycleExt = cycleD - offset;
+                    Double offsetIndex = endCycleExt;
+                    // 相位结束时间 > cycle, 周期相位差后面补充周期要添加绿灯
+                    if (phaseReverseStartTime > 0) {
+                        phaseReverseStartTime = Math.abs(phaseReverseStartTime);
+                        // cycle内红灯
+                        redTimes.add(Arrays.asList(cycleIndex + phaseReverseStartTime, cycleIndex + phaseStartTime));
+                        redTimes.add(Arrays.asList(cycleIndex + phaseEndTime, cycleIndex + cycleD));
+                        if (endCycleExt >= phaseStartTime) {
+                            // endCycleExt内红灯
+                            redTimes.add(Arrays.asList(cycleIndex + offset + phaseReverseStartTime, cycleIndex + offset + phaseStartTime));
+                            // offset内红灯
+                            redTimes.add(Arrays.asList(phaseReverseStartTime - offsetIndex, phaseStartTime - offsetIndex));
+                        } else if (endCycleExt < phaseStartTime && phaseReverseStartTime > endCycleExt) {
+                            // endCycleExt全绿灯
+                            // offset全绿灯
+                        } else if (phaseReverseStartTime <= endCycleExt) {
+                            // endCycleExt内红灯
+                            redTimes.add(Arrays.asList(cycleIndex + offset + phaseReverseStartTime, cycleIndex + offset + phaseStartTime));
+                            // offset内红灯
+                            redTimes.add(Arrays.asList(phaseEndTime - offsetIndex, offset));
+                        }
+                    } else {
+                        // cycle内红灯
+                        redTimes.add(Arrays.asList(cycleIndex + offset, cycleIndex + offset + phaseStartTime));
+                        redTimes.add(Arrays.asList(cycleIndex + offset + phaseEndTime, cycleIndex + offset + cycleD));
+                        if (endCycleExt >= phaseStartTime) {
+                            // endCycleExt红灯
+                            redTimes.add(Arrays.asList(cycleIndex + offset + cycleD, cycleIndex + offset + cycleD + phaseStartTime));
+                            // offset红灯
+                            redTimes.add(Arrays.asList(phaseEndTime - offsetIndex, offset));
+                        } else {
+                            // endCycleExt红灯
+                            redTimes.add(Arrays.asList(cycleIndex + offset + cycleD, cycleIndex + offset + cycleD + endCycleExt));
+                            // offset内红灯
+                            redTimes.add(Arrays.asList(0.0, phaseStartTime - offsetIndex));
+                            redTimes.add(Arrays.asList(phaseEndTime - offsetIndex, offset));
+                        }
+                    }
+
+                    // 去重和排序
+                    List<List<Double>> uniqueSortedRedTimes = redTimes.stream()
+                            .distinct()  // 去重
+                            .sorted((list1, list2) -> {
+                                // 按照列表第一个元素排序
+                                return Double.compare(list1.get(0), list2.get(0));
+                            })
+                            .collect(Collectors.toList());
+
+                    crossRedTimesMap.put(crossId, uniqueSortedRedTimes);
+                }
+                crossGreenStartMap.put(crossId, crossGreenStartTime);
+                crossGreenStartTime += travelTime;
+                distanceMap.put(crossId, distance);
+            }
+        }
+    }
+}

signal-optimize-service/src/main/java/net/wanji/opt/vo/GreenBeltChartVO.java

 package net.wanji.opt.vo;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.annotations.ApiModel;
@@ -9,6 +10,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import net.wanji.common.utils.tool.JacksonUtils;
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
 
@@ -19,26 +21,28 @@ import java.util.Map;
 @Data
 @ApiModel(value = "GreenBeltChartVO", description = "绿波时序图返回实体")
 @JsonIgnoreProperties(ignoreUnknown = true)
-@AllArgsConstructor
-@NoArgsConstructor
 public class GreenBeltChartVO {
     private static final long serialVersionUID = 1L;
     @ApiModelProperty("绿波路口红灯范围")
     @JsonProperty("crossRedTimesMap")
-    Map<String, List<List<Double>>> crossRedTimesMap;
+    String crossRedTimesMap;
     @ApiModelProperty("反向绿波路口红灯范围")
     @JsonProperty("backCrossRedTimesMap")
-    Map<String, List<List<Double>>> backCrossRedTimesMap;
+    String backCrossRedTimesMap;
     @ApiModelProperty("绿波路口绿波开始时间")
     @JsonProperty("greenStartMap")
-    Map<String, Double> greenStartMap;
+    String greenStartMap;
     @ApiModelProperty("反向绿波路口绿波开始时间")
-    Map<String, Double> BackGreenStartMap;
+    String BackGreenStartMap;
     @JsonProperty("distanceMap")
     @ApiModelProperty("绿波路口距离下一个路口距离")
-    Map<String, Double> distanceMap;
+    String distanceMap;
     @ApiModelProperty("绿波带宽")
     private Double greenWidthTime;
     @ApiModelProperty("反向绿波带宽")
     private Double BackGreenWidthTime;
+
+    @JsonCreator
+    public GreenBeltChartVO(){
+    }
 }